Attachment #34437 for bug #123257

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 123257 | Differences between

and this patch

Collapse All | Expand All




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

import org.eclipse.core.runtime.ListenerList;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.accessibility.ACC;
import org.eclipse.swt.accessibility.AccessibleAdapter;

 * </p>
 */
public class ToolBarManager extends ContributionManager implements
		IToolBarManager {

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

	private MenuManager contextMenuManager = null;

	/**
	 * A collection of objects listening to changes to this manager. This
	 * collection is <code>null</code> if there are no listeners.
	 */
	private transient ListenerList listenerList = null;
	
	/**
	 * Creates a new tool bar manager with the default SWT button style. Use the
	 * <code>createControl</code> method to create the tool bar control.
	 */

	protected void relayout(ToolBar layoutBar, int oldCount, int newCount) {
		if ((oldCount == 0) != (newCount == 0))
			layoutBar.getParent().layout();
		firePropertyChange(PROP_LAYOUT, new Integer(oldCount), new Integer(newCount));
	}

	/**

		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#createControl2(org.eclipse.swt.widgets.Composite)
	 */
	public Control createControl2(Composite parent) {
		return createControl(parent);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#getControl2()
	 */
	public Control getControl2() {
		return getControl();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#getItemCount()
	 */
	public int getItemCount() {
		if (!toolBarExist())
			return 0;
		return toolBar.getItemCount();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#addPropertyChangeListener(org.eclipse.jface.util.IPropertyChangeListener)
	 */
	public void addPropertyChangeListener(IPropertyChangeListener listener) {
		if (listenerList == null) {
			listenerList = new ListenerList(ListenerList.IDENTITY);
		}

		listenerList.add(listener);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#removePropertyChangeListener(org.eclipse.jface.util.IPropertyChangeListener)
	 */
	public void removePropertyChangeListener(IPropertyChangeListener listener) {
		if (listenerList != null) {
			listenerList.remove(listener);

			if (listenerList.isEmpty()) {
				listenerList = null;
			}
		}
	}
	
	/*
	 * Returns the listeners attached to this event manager.
	 * The listeners currently attached; may be empty, but never
	 * null.
	 */
	protected final Object[] getListeners() {
		final ListenerList list = listenerList;
		if (list == null) {
			return new Object[0];
		}

		return list.getListeners();
	}

	/*
	 * Notifies any property change listeners that a property has changed. Only
	 * listeners registered at the time this method is called are notified.
	 */
	private void firePropertyChange(final PropertyChangeEvent event) {
		final Object[] list = getListeners();
		for (int i = 0; i < list.length; ++i) {
			((IPropertyChangeListener) list[i]).propertyChange(event);
		}
	}

	/*
	 * Notifies any property change listeners that a property has changed. Only
	 * listeners registered at the time this method is called are notified. This
	 * method avoids creating an event object if there are no listeners
	 * registered, but calls firePropertyChange(PropertyChangeEvent) if there are.
	 */
	private void firePropertyChange(final String propertyName,
			final Object oldValue, final Object newValue) {
		if (listenerList != null) {
			firePropertyChange(new PropertyChangeEvent(this, propertyName,
					oldValue, newValue));
		}
	}

}

Lines 43-49 Link Here

(-)src/org/eclipse/jface/action/ToolBarContributionItem.java (-1 / +1 lines)
43	*	43	*
44	* @since 3.0	44	* @since 3.0
45	*/	45	*/
46	public class ToolBarContributionItem extends ContributionItem implements IToolBarContributionItem {	46	public class ToolBarContributionItem extends ContributionItem {
47		47
48	/**	48	/**
49	* A constant used by <code>setMinimumItemsToShow</code> and <code>getMinimumItemsToShow</code>	49	* A constant used by <code>setMinimumItemsToShow</code> and <code>getMinimumItemsToShow</code>




/*******************************************************************************
 * Copyright (c) 2003, 2004 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

 *******************************************************************************/
package org.eclipse.jface.action;

import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.CoolBar;

/**

     * @see ToolBarContributionItem
     */
    public void add(IToolBarManager toolBarManager);
    
    /**
     * Creates and returns this manager's cool bar control. Does not create a
     * new control if one already exists.
     * 
	 * <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>
     * 
     * @param parent
     *            the parent control
     * @return the cool bar control
	 * @since 3.2
     */
    public CoolBar createControl(Composite parent);

    /**
     * Creates and returns this manager's control. Does not create a
     * new control if one already exists.
     * 
	 * <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>
     * 
     * @param parent
     *            the parent control
     * @return the control
	 * @since 3.2
     */
    public Control createControl2(Composite parent);

    /**
     * Returns the context menu manager used by this cool bar manager. This

    public IMenuManager getContextMenuManager();

    /**
     * Returns the cool bar control for this manager.
     * 
	 * <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>
     * 
     * @return the cool bar control, or <code>null</code> if none
	 * @since 3.2
     */
    public CoolBar getControl();
    
    /**
     * Returns the bar control for this manager.
     * 
	 * <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>
     *  
     * @return the bar control, or <code>null</code> if none
	 * @since 3.2
     */
    public Control getControl2();

    /**
     * Returns whether the layout of the underlying cool bar widget is locked.
     * 
     * @return <code>true</code> if cool bar layout is locked, <code>false</code>

    public void setContextMenuManager(IMenuManager menuManager);

    /**
     * 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>
     * 
	 * <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 void refresh();
    
    /**
	 * Disposes the resources for this manager.
     * 
	 * <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 void dispose();

    /**
     * Restores the canonical order of this cool bar manager. The canonical
     * order is the order in which the contribution items where added.
     * 
	 * <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 void resetItemOrder();

    /**
     * Replaces the current items with the given items.
     * Forces an update.
     * 
	 * <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>
     * 
     * @param newItems the items with which to replace the current items
     * @since 3.2
	 */
    public void setItems(IContributionItem[] newItems);
	
    /**
     * Locks or unlocks the layout of the underlying cool bar widget. Once the
     * cool bar is locked, cool items cannot be repositioned by the user.
     * <p>

     * cool bar is locked.
     * </p>
     * 
	 * <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>
     *  
     * @param value
     *            <code>true</code> to lock the cool bar, <code>false</code>
     *            to unlock




        }
        return coolBar;
    }
    
    /**
     * Creates and returns this manager's cool bar control. Does not create a
     * new control if one already exists.
     * 
	 * <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>
     * 
     * @param parent
     *            the parent control
     * @return the cool bar control
	 * @since 3.2
     */
    public Control createControl2(Composite parent) {
        return createControl(parent);
    }

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

    public CoolBar getControl() {
        return coolBar;
    }
    
    /**
     * Returns the control for this manager.
     * 
	 * <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>
     * 
     * @return the control, or <code>null</code> if none
	 * @since 3.2
     */
    public Control getControl2() {
        return coolBar;
    }

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




/*******************************************************************************
 * Copyright (c) 2003, 2004 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

package org.eclipse.jface.action;

import org.eclipse.jface.util.Assert;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.CoolBar;

/**
 * A <code>SubCoolBarManager</code> monitors the additional and removal of 

        super.add(new ToolBarContributionItem(toolBarManager));
    }

    /*
     *  (non-Javadoc)
     * @see org.eclipse.jface.action.ICoolBarManager#createControl(org.eclipse.swt.widgets.Composite)
     */
    public CoolBar createControl(Composite parent) {
        return null;
    }
    
    /*
     *  (non-Javadoc)
     * @see org.eclipse.jface.action.ICoolBarManager#createControl2(org.eclipse.swt.widgets.Composite)
     */
    public Control createControl2(Composite parent) {
        return createControl(parent);
    }

    /*
     *  (non-Javadoc)
     * @see org.eclipse.jface.action.ICoolBarManager#getControl()
     */
    public CoolBar getControl() {
        return null;
    }
    
    /*
     *  (non-Javadoc)
     * @see org.eclipse.jface.action.ICoolBarManager#getControl2()
     */
    public Control getControl2() {
        return null;
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.jface.action.ICoolBarManager#getStyle()
     */

        return null;
    }

    /*
     *  (non-Javadoc)
     * @see org.eclipse.jface.action.ICoolBarManager#refresh()
     */
    public void refresh() {
        // do nothing
    }

    /*
     *  (non-Javadoc)
     * @see org.eclipse.jface.action.ICoolBarManager#resetItemOrder()
     */
    public void resetItemOrder() {
        // do nothing
    }
    
    /* (non-Javadoc)
     * In SubCoolBarManager we do nothing.
     */

        // do nothing
    }

    /*
     *  (non-Javadoc)
     * @see org.eclipse.jface.action.ICoolBarManager#setItems(org.eclipse.jface.action.IContributionItem[])
     */
    public void setItems(IContributionItem[] newItems) {
    	// do nothing
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionManager#update(boolean)
     */

        getParentCoolBarManager().update(force);
    }

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ICoolBarManager#dispose()
	 */
	public void dispose() {
		// do nothing
	}







}




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

import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.ToolBar;

/**
 * The <code>IToolBarManager2</code> interface provides protocol for managing
 * contributions to a tool bar. It extends <code>IToolBarManager</code>
 * and provides a <code>dispose</code> method.
 * 
 * <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>
 * 
 * This package also provides a concrete tool bar manager implementation,
 * {@link ToolBarManager <code>ToolBarManager</code>}.
 * </p>
 * 
 * @since 3.2
 */
public interface IToolBarManager2 extends IToolBarManager {
	
	/**
	 * The property id for changes to the control's layout
	 */
	public static final String PROP_LAYOUT = "PROP_LAYOUT"; //$NON-NLS-1$
	
    /**
     * Creates and returns this manager's toolbar control. Does not create a
     * new control if one already exists.
     * 
     * @param parent
     *            the parent control
     * @return the toolbar control
     */
	public ToolBar createControl(Composite parent);
	
    /**
     * Creates and returns this manager's control. Does not create a
     * new control if one already exists.
     * 
     * @param parent
     *            the parent control
     * @return the control
     */
	public Control createControl2(Composite parent);
	
    /**
     * Returns the toolbar control for this manager.
     * 
     * @return the toolbar control, or <code>null</code> if none
     */
	public ToolBar getControl();
	
    /**
     * Returns the control for this manager.
     * 
     * @return the control, or <code>null</code> if none
     */
	public Control getControl2();

    /**
	 * Disposes the resources for this manager.
     */
	public void dispose();
	
	/**
	 * Returns the item count of the control used 
	 * by this manager.
	 * 
	 * @return the number of items in the control
	 */
	public int getItemCount();
	
	/**
	 * Registers a property change listner with this manager.
	 * 
	 * @param listener
	 */
	public void addPropertyChangeListener(IPropertyChangeListener listener);
	
	/**
	 * Removes a property change listner from this manager.
	 * 
	 * @param listener
	 */
	public void removePropertyChangeListener(IPropertyChangeListener listener);
	
    /**
     * Sets the overrides for this contribution manager
     * 
     * @param newOverrides the overrides for the items of this manager
     */
    public void setOverrides(IContributionManagerOverrides newOverrides);
	
}




/*******************************************************************************
 * 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.jface.action;

/**
 * The intention of this interface is to provide in interface for 
 * ToolBarContributionItem so that the implementation can be replaced.
 * 
 * <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 IToolBarContributionItem extends IContributionItem {

    /**
     * Returns the current height of the corresponding cool item.
     * 
     * @return the current height
     */
    public int getCurrentHeight();

    /**
     * Returns the current width of the corresponding cool item.
     * 
     * @return the current size
     */
    public int getCurrentWidth();

    /**
     * Returns the minimum number of tool items to show in the cool item.
     * 
     * @return the minimum number of tool items to show, or <code>SHOW_ALL_ITEMS</code>
     *         if a value was not set
     * @see #setMinimumItemsToShow(int)
     */
    public int getMinimumItemsToShow();
    
    /**
     * Returns whether chevron support is enabled.
     * 
     * @return <code>true</code> if chevron support is enabled, <code>false</code>
     *         otherwise
     */
    public boolean getUseChevron();
    
    /**
     * Sets the current height of the cool item. Update(SIZE) should be called
     * to adjust the widget.
     * 
     * @param currentHeight
     *            the current height to set
     */
    public void setCurrentHeight(int currentHeight);

    /**
     * Sets the current width of the cool item. Update(SIZE) should be called
     * to adjust the widget.
     * 
     * @param currentWidth
     *            the current width to set
     */
    public void setCurrentWidth(int currentWidth);

    /**
     * Sets the minimum number of tool items to show in the cool item. If this
     * number is less than the total tool items, a chevron will appear and the
     * hidden tool items appear in a drop down menu. By default, all the tool
     * items are shown in the cool item.
     * 
     * @param minimumItemsToShow
     *            the minimum number of tool items to show.
     * @see #getMinimumItemsToShow()
     * @see #setUseChevron(boolean)
     */
    public void setMinimumItemsToShow(int minimumItemsToShow);

    /**
     * Enables or disables chevron support for the cool item. By default,
     * chevron support is enabled.
     * 
     * @param value
     *            <code>true</code> to enable chevron support, <code>false</code>
     *            otherwise.
     */
    public void setUseChevron(boolean value);
    
    /**
     * Returns the internal tool bar manager of the contribution item.
     * 
     * @return the tool bar manager, or <code>null</code> if one is not
     *         defined.
     * @see IToolBarManager
     */
    public IToolBarManager getToolBarManager();
    
    /**
     * Returns the parent contribution manager, or <code>null</code> if this 
     * contribution item is not currently added to a contribution manager.
     * 
     * @return the parent contribution manager, or <code>null</code>
     * 
     * TODO may not need this, getToolBarManager may be enough.
     */
    public IContributionManager getParent();
    
}

Lines 16-25 Link Here

(-)src/org/eclipse/jface/window/ApplicationWindow.java (-12 / +32 lines)
16	import org.eclipse.core.runtime.NullProgressMonitor;	16	import org.eclipse.core.runtime.NullProgressMonitor;
17	import org.eclipse.jface.action.CoolBarManager;	17	import org.eclipse.jface.action.CoolBarManager;
18	import org.eclipse.jface.action.ICoolBarManager;	18	import org.eclipse.jface.action.ICoolBarManager;
19	import org.eclipse.jface.action.IToolBarManager2;	19	import org.eclipse.jface.action.IToolBarManager;
20	import org.eclipse.jface.action.MenuManager;	20	import org.eclipse.jface.action.MenuManager;
21	import org.eclipse.jface.action.StatusLineManager;	21	import org.eclipse.jface.action.StatusLineManager;
22	import org.eclipse.jface.action.ToolBarManager;	22	import org.eclipse.jface.action.ToolBarManager;
		23	import org.eclipse.jface.internal.provisional.action.ICoolBarManager2;
		24	import org.eclipse.jface.internal.provisional.action.IToolBarManager2;
23	import org.eclipse.jface.operation.IRunnableContext;	25	import org.eclipse.jface.operation.IRunnableContext;
24	import org.eclipse.jface.operation.IRunnableWithProgress;	26	import org.eclipse.jface.operation.IRunnableWithProgress;
25	import org.eclipse.jface.operation.ModalContext;	27	import org.eclipse.jface.operation.ModalContext;
Lines 79-85 Link Here
79	*	81	*
80	* @see #addToolBar	82	* @see #addToolBar
81	*/	83	*/
82	private IToolBarManager2 toolBarManager = null;	84	private IToolBarManager toolBarManager = null;
83		85
84	/**	86	/**
85	* Status line manager, or <code>null</code> if none (default).	87	* Status line manager, or <code>null</code> if none (default).
Lines 296-302 Link Here
296	menuBarManager = null;	298	menuBarManager = null;
297	}	299	}
298	if (toolBarManager != null) {	300	if (toolBarManager != null) {
299	toolBarManager.dispose();	301	if (toolBarManager instanceof IToolBarManager2)
		302	((IToolBarManager2) toolBarManager).dispose();
		303	else if (toolBarManager instanceof ToolBarManager)
		304	((ToolBarManager) toolBarManager).dispose();
300	toolBarManager = null;	305	toolBarManager = null;
301	}	306	}
302	if (statusLineManager != null) {	307	if (statusLineManager != null) {
Lines 304-310 Link Here
304	statusLineManager = null;	309	statusLineManager = null;
305	}	310	}
306	if (coolBarManager != null) {	311	if (coolBarManager != null) {
307	coolBarManager.dispose();	312	if (coolBarManager instanceof ICoolBarManager2)
		313	((ICoolBarManager2) coolBarManager).dispose();
		314	else if (coolBarManager instanceof CoolBarManager)
		315	((CoolBarManager) coolBarManager).dispose();
308	coolBarManager = null;	316	coolBarManager = null;
309	}	317	}
310	return true;	318	return true;
Lines 416-422 Link Here
416	* </p>	424	* </p>
417	*	425	*
418	* <p>	426	* <p>
419	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as	427	* <strong>EXPERIMENTAL</strong>. This method has been added as
420	* part of a work in progress. There is a guarantee neither that this API will	428	* part of a work in progress. There is a guarantee neither that this API will
421	* work nor that it will remain the same. Please do not use this API without	429	* work nor that it will remain the same. Please do not use this API without
422	* consulting with the Platform/UI team.	430	* consulting with the Platform/UI team.
Lines 425-431 Link Here
425	* @return a tool bar manager	433	* @return a tool bar manager
426	* @since 3.2	434	* @since 3.2
427	*/	435	*/
428	protected IToolBarManager2 createToolBarManager2(int style) {	436	protected IToolBarManager createToolBarManager2(int style) {
429	return createToolBarManager(style);	437	return createToolBarManager(style);
430	}	438	}
431		439
Lines 451-457 Link Here
451	* </p>	459	* </p>
452	*	460	*
453	* <p>	461	* <p>
454	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as	462	* <strong>EXPERIMENTAL</strong>. This method has been added as
455	* part of a work in progress. There is a guarantee neither that this API will	463	* part of a work in progress. There is a guarantee neither that this API will
456	* work nor that it will remain the same. Please do not use this API without	464	* work nor that it will remain the same. Please do not use this API without
457	* consulting with the Platform/UI team.	465	* consulting with the Platform/UI team.
Lines 473-479 Link Here
473	*/	481	*/
474	protected Control createToolBarControl(Composite parent) {	482	protected Control createToolBarControl(Composite parent) {
475	if (toolBarManager != null) {	483	if (toolBarManager != null) {
476	return toolBarManager.createControl2(parent);	484	if (toolBarManager instanceof IToolBarManager2)
		485	return ((IToolBarManager2) toolBarManager).createControl2(parent);
		486	if (toolBarManager instanceof ToolBarManager)
		487	return ((ToolBarManager) toolBarManager).createControl(parent);
477	}	488	}
478	return null;	489	return null;
479	}	490	}
Lines 489-495 Link Here
489	*/	500	*/
490	protected Control createCoolBarControl(Composite composite) {	501	protected Control createCoolBarControl(Composite composite) {
491	if (coolBarManager != null) {	502	if (coolBarManager != null) {
492	return coolBarManager.createControl2(composite);	503	if (coolBarManager instanceof ICoolBarManager2)
		504	return ((ICoolBarManager2) coolBarManager).createControl2(composite);
		505	if (coolBarManager instanceof CoolBarManager)
		506	return ((CoolBarManager) coolBarManager).createControl(composite);
493	}	507	}
494	return null;	508	return null;
495	}	509	}
Lines 576-582 Link Here
576	* @see #addToolBar(int)	590	* @see #addToolBar(int)
577	* @since 3.2	591	* @since 3.2
578	*/	592	*/
579	public IToolBarManager2 getToolBarManager2() {	593	public IToolBarManager getToolBarManager2() {
580	return toolBarManager;	594	return toolBarManager;
581	}	595	}
582		596
Lines 622-628 Link Here
622	*/	636	*/
623	protected Control getToolBarControl() {	637	protected Control getToolBarControl() {
624	if (toolBarManager != null) {	638	if (toolBarManager != null) {
625	return toolBarManager.getControl();	639	if (toolBarManager instanceof IToolBarManager2)
		640	return ((IToolBarManager2) toolBarManager).getControl2();
		641	if (toolBarManager instanceof ToolBarManager)
		642	return ((ToolBarManager) toolBarManager).getControl();
626	}	643	}
627	return null;	644	return null;
628	}	645	}
Lines 638-644 Link Here
638	*/	655	*/
639	protected Control getCoolBarControl() {	656	protected Control getCoolBarControl() {
640	if (coolBarManager != null) {	657	if (coolBarManager != null) {
641	return coolBarManager.getControl();	658	if (coolBarManager instanceof ICoolBarManager2)
		659	return ((ICoolBarManager2) coolBarManager).getControl2();
		660	if (coolBarManager instanceof CoolBarManager)
		661	return ((CoolBarManager) coolBarManager).getControl();
642	}	662	}
643	return null;	663	return null;
644	}	664	}

Lines 18-23 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
18	org.eclipse.jface.dialogs.images,	18	org.eclipse.jface.dialogs.images,
19	org.eclipse.jface.fieldassist,	19	org.eclipse.jface.fieldassist,
20	org.eclipse.jface.images,	20	org.eclipse.jface.images,
		21	org.eclipse.jface.internal.provisional.action,
21	org.eclipse.jface.layout,	22	org.eclipse.jface.layout,
22	org.eclipse.jface.menus,	23	org.eclipse.jface.menus,
23	org.eclipse.jface.operation,	24	org.eclipse.jface.operation,




/*******************************************************************************
 * 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.jface.internal.provisional.action;

import org.eclipse.jface.action.CoolBarManager;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.CoolBar;

/**
 * Extends <code>CoolBarManager</code> to implement <code>ICoolBarManager2</code>
 * @since 3.2
 */
public class CoolBarManager2 extends CoolBarManager implements ICoolBarManager2 {

    /**
     * Creates a new cool bar manager with the default style. Equivalent to
     * <code>CoolBarManager(SWT.NONE)</code>.
     */
    public CoolBarManager2() {
        super();
    }

    /**
     * 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 CoolBarManager2(CoolBar coolBar) {
        super(coolBar);
    }

    /**
     * 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 CoolBarManager2(int style) {
       super(style);
    }
    
    /**
     * Creates and returns this manager's cool bar control. Does not create a
     * new control if one already exists.
     * 
	 * <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>
     * 
     * @param parent
     *            the parent control
     * @return the cool bar control
	 * @since 3.2
     */
    public Control createControl2(Composite parent) {
        return createControl(parent);
    }
    
    /**
     * Returns the control for this manager.
     * 
	 * <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>
     * 
     * @return the control, or <code>null</code> if none
	 * @since 3.2
     */
    public Control getControl2() {
        return getControl();
    }

}




/*******************************************************************************
 * 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.jface.internal.provisional.action;

import org.eclipse.core.runtime.ListenerList;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.ToolBar;

/**
 * Extends <code>ToolBarManager</code> to implement <code>IToolBarManager2</code>.
 * 
 * @since 3.2
 */
public class ToolBarManager2 extends ToolBarManager implements IToolBarManager2 {

	/**
	 * A collection of objects listening to changes to this manager. This
	 * collection is <code>null</code> if there are no listeners.
	 */
	private transient ListenerList listenerList = null;
	
	/**
	 * Creates a new tool bar manager with the default SWT button style. Use the
	 * <code>createControl</code> method to create the tool bar control.
	 */
	public ToolBarManager2() {
		super();
	}

	/**
	 * Creates a tool bar manager with the given SWT button style. Use the
	 * <code>createControl</code> method to create the tool bar control.
	 * 
	 * @param style
	 *            the tool bar item style
	 * @see org.eclipse.swt.widgets.ToolBar for valid style bits
	 */
	public ToolBarManager2(int style) {
		super(style);
	}

	/**
	 * Creates a tool bar manager for an existing tool bar control. This manager
	 * becomes responsible for the control, and will dispose of it when the
	 * manager is disposed.
	 * 
	 * @param toolbar
	 *            the tool bar control
	 */
	public ToolBarManager2(ToolBar toolbar) {
		super(toolbar);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#createControl2(org.eclipse.swt.widgets.Composite)
	 */
	public Control createControl2(Composite parent) {
		return createControl(parent);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#getControl2()
	 */
	public Control getControl2() {
		return getControl();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#getItemCount()
	 */
	public int getItemCount() {
		ToolBar toolBar = getControl();
		if (toolBar == null || toolBar.isDisposed())
			return 0;
		return toolBar.getItemCount();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#addPropertyChangeListener(org.eclipse.jface.util.IPropertyChangeListener)
	 */
	public void addPropertyChangeListener(IPropertyChangeListener listener) {
		if (listenerList == null) {
			listenerList = new ListenerList(ListenerList.IDENTITY);
		}

		listenerList.add(listener);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#removePropertyChangeListener(org.eclipse.jface.util.IPropertyChangeListener)
	 */
	public void removePropertyChangeListener(IPropertyChangeListener listener) {
		if (listenerList != null) {
			listenerList.remove(listener);

			if (listenerList.isEmpty()) {
				listenerList = null;
			}
		}
	}
	
	/*
	 * Returns the listeners attached to this event manager.
	 * The listeners currently attached; may be empty, but never
	 * null.
	 */
	protected final Object[] getListeners() {
		final ListenerList list = listenerList;
		if (list == null) {
			return new Object[0];
		}

		return list.getListeners();
	}

	/*
	 * Notifies any property change listeners that a property has changed. Only
	 * listeners registered at the time this method is called are notified.
	 */
	private void firePropertyChange(final PropertyChangeEvent event) {
		final Object[] list = getListeners();
		for (int i = 0; i < list.length; ++i) {
			((IPropertyChangeListener) list[i]).propertyChange(event);
		}
	}

	/*
	 * Notifies any property change listeners that a property has changed. Only
	 * listeners registered at the time this method is called are notified. This
	 * method avoids creating an event object if there are no listeners
	 * registered, but calls firePropertyChange(PropertyChangeEvent) if there are.
	 */
	private void firePropertyChange(final String propertyName,
			final Object oldValue, final Object newValue) {
		if (listenerList != null) {
			firePropertyChange(new PropertyChangeEvent(this, propertyName,
					oldValue, newValue));
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ToolBarManager#relayout(org.eclipse.swt.widgets.ToolBar, int, int)
	 */
	protected void relayout(ToolBar layoutBar, int oldCount, int newCount) {
		super.relayout(layoutBar, oldCount, newCount);
		firePropertyChange(PROP_LAYOUT, new Integer(oldCount), new Integer(newCount));
	}
}




/*******************************************************************************
 * 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.jface.internal.provisional.action;

import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.ToolBarContributionItem;

/**
 * Extends <code>ToolBarContributionItem</code> to implement <code>IToolBarContributionItem</code>.
 * 
 * @since 3.2
 */
public class ToolBarContributionItem2 extends ToolBarContributionItem implements
		IToolBarContributionItem {

	/**
	 * 
	 */
	public ToolBarContributionItem2() {
		super();
	}

	/**
	 * @param toolBarManager
	 */
	public ToolBarContributionItem2(IToolBarManager toolBarManager) {
		super(toolBarManager);
	}

	/**
	 * @param toolBarManager
	 * @param id
	 */
	public ToolBarContributionItem2(IToolBarManager toolBarManager, String id) {
		super(toolBarManager, id);
	}

}




/*******************************************************************************
 * 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.jface.internal.provisional.action;

import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IContributionManager;
import org.eclipse.jface.action.IToolBarManager;

/**
 * The intention of this interface is to provide in interface for 
 * ToolBarContributionItem so that the implementation can be replaced.
 * 
 * <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 IToolBarContributionItem extends IContributionItem {

    /**
     * Returns the current height of the corresponding cool item.
     * 
     * @return the current height
     */
    public int getCurrentHeight();

    /**
     * Returns the current width of the corresponding cool item.
     * 
     * @return the current size
     */
    public int getCurrentWidth();

    /**
     * Returns the minimum number of tool items to show in the cool item.
     * 
     * @return the minimum number of tool items to show, or <code>SHOW_ALL_ITEMS</code>
     *         if a value was not set
     * @see #setMinimumItemsToShow(int)
     */
    public int getMinimumItemsToShow();
    
    /**
     * Returns whether chevron support is enabled.
     * 
     * @return <code>true</code> if chevron support is enabled, <code>false</code>
     *         otherwise
     */
    public boolean getUseChevron();
    
    /**
     * Sets the current height of the cool item. Update(SIZE) should be called
     * to adjust the widget.
     * 
     * @param currentHeight
     *            the current height to set
     */
    public void setCurrentHeight(int currentHeight);

    /**
     * Sets the current width of the cool item. Update(SIZE) should be called
     * to adjust the widget.
     * 
     * @param currentWidth
     *            the current width to set
     */
    public void setCurrentWidth(int currentWidth);

    /**
     * Sets the minimum number of tool items to show in the cool item. If this
     * number is less than the total tool items, a chevron will appear and the
     * hidden tool items appear in a drop down menu. By default, all the tool
     * items are shown in the cool item.
     * 
     * @param minimumItemsToShow
     *            the minimum number of tool items to show.
     * @see #getMinimumItemsToShow()
     * @see #setUseChevron(boolean)
     */
    public void setMinimumItemsToShow(int minimumItemsToShow);

    /**
     * Enables or disables chevron support for the cool item. By default,
     * chevron support is enabled.
     * 
     * @param value
     *            <code>true</code> to enable chevron support, <code>false</code>
     *            otherwise.
     */
    public void setUseChevron(boolean value);
    
    /**
     * Returns the internal tool bar manager of the contribution item.
     * 
     * @return the tool bar manager, or <code>null</code> if one is not
     *         defined.
     * @see IToolBarManager
     */
    public IToolBarManager getToolBarManager();
    
    /**
     * Returns the parent contribution manager, or <code>null</code> if this 
     * contribution item is not currently added to a contribution manager.
     * 
     * @return the parent contribution manager, or <code>null</code>
     * 
     * TODO may not need this, getToolBarManager may be enough.
     */
    public IContributionManager getParent();
    
}




/*******************************************************************************
 * 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.jface.internal.provisional.action;

import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

/**
 * Extends <code>ICoolBarManager</code> to allow clients to be decoupled
 * from the actual kind of control used.
 * 
 * @since 3.2
 */
public interface ICoolBarManager2 extends ICoolBarManager {

    /**
     * Creates and returns this manager's control. Does not create a
     * new control if one already exists.
     * 
	 * <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>
     * 
     * @param parent
     *            the parent control
     * @return the control
	 * @since 3.2
     */
    public Control createControl2(Composite parent);

    /**
     * Returns the bar control for this manager.
     * 
	 * <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>
     *  
     * @return the bar control, or <code>null</code> if none
	 * @since 3.2
     */
    public Control getControl2();

    /**
     * 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>
     * 
	 * <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 void refresh();
    
    /**
	 * Disposes the resources for this manager.
     * 
	 * <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 void dispose();

    /**
     * Restores the canonical order of this cool bar manager. The canonical
     * order is the order in which the contribution items where added.
     * 
	 * <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 void resetItemOrder();

    /**
     * Replaces the current items with the given items.
     * Forces an update.
     * 
	 * <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>
     * 
     * @param newItems the items with which to replace the current items
     * @since 3.2
	 */
    public void setItems(IContributionItem[] newItems);

}




/*******************************************************************************
 * 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.jface.internal.provisional.action;

import org.eclipse.jface.action.IContributionManagerOverrides;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.ToolBar;

/**
 * The <code>IToolBarManager2</code> interface provides protocol for managing
 * contributions to a tool bar. It extends <code>IToolBarManager</code>
 * and provides a <code>dispose</code> method.
 * 
 * <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>
 * 
 * This package also provides a concrete tool bar manager implementation,
 * {@link ToolBarManager <code>ToolBarManager</code>}.
 * </p>
 * 
 * @since 3.2
 */
public interface IToolBarManager2 extends IToolBarManager {
	
	/**
	 * The property id for changes to the control's layout
	 */
	public static final String PROP_LAYOUT = "PROP_LAYOUT"; //$NON-NLS-1$
	
    /**
     * Creates and returns this manager's toolbar control. Does not create a
     * new control if one already exists.
     * 
     * @param parent
     *            the parent control
     * @return the toolbar control
     */
	public ToolBar createControl(Composite parent);
	
    /**
     * Creates and returns this manager's control. Does not create a
     * new control if one already exists.
     * 
     * @param parent
     *            the parent control
     * @return the control
     */
	public Control createControl2(Composite parent);
	
    /**
     * Returns the toolbar control for this manager.
     * 
     * @return the toolbar control, or <code>null</code> if none
     */
	public ToolBar getControl();
	
    /**
     * Returns the control for this manager.
     * 
     * @return the control, or <code>null</code> if none
     */
	public Control getControl2();

    /**
	 * Disposes the resources for this manager.
     */
	public void dispose();
	
	/**
	 * Returns the item count of the control used 
	 * by this manager.
	 * 
	 * @return the number of items in the control
	 */
	public int getItemCount();
	
	/**
	 * Registers a property change listner with this manager.
	 * 
	 * @param listener
	 */
	public void addPropertyChangeListener(IPropertyChangeListener listener);
	
	/**
	 * Removes a property change listner from this manager.
	 * 
	 * @param listener
	 */
	public void removePropertyChangeListener(IPropertyChangeListener listener);
	
    /**
     * Sets the overrides for this contribution manager
     * 
     * @param newOverrides the overrides for the items of this manager
     */
    public void setOverrides(IContributionManagerOverrides newOverrides);
	
}

Lines 46-54 Link Here

(-)plugin.xml (-3 / +4 lines)
46	class="org.eclipse.ui.examples.presentation.wrappedtabs.WrappedTabsPresentationFactory"	46	class="org.eclipse.ui.examples.presentation.wrappedtabs.WrappedTabsPresentationFactory"
47	name="Wrapped tabs presentation"	47	name="Wrapped tabs presentation"
48	id="org.eclipse.ui.examples.presentation.wrappedtabs"/>	48	id="org.eclipse.ui.examples.presentation.wrappedtabs"/>
49	</extension>
50	<extension
51	point="org.eclipse.ui.presentationFactories">
52	<factory	49	<factory
53	class="org.eclipse.ui.internal.presentations.defaultpresentation.NativePresentationFactory"	50	class="org.eclipse.ui.internal.presentations.defaultpresentation.NativePresentationFactory"
54	name="Native Tabs"	51	name="Native Tabs"
Lines 61-66 Link Here
61	class="org.eclipse.ui.examples.presentation.sidewinder.SideWinderPresentationFactory"	58	class="org.eclipse.ui.examples.presentation.sidewinder.SideWinderPresentationFactory"
62	id="org.eclipse.ui.examples.presentation.factory2"	59	id="org.eclipse.ui.examples.presentation.factory2"
63	name="Side Winder"/>	60	name="Side Winder"/>
		61	<factory
		62	class="org.eclipse.ui.examples.presentation.customtoolbar.CustomToolBarPresentationFactory"
		63	id="org.eclipse.ui.examples.presentation.customtoolbar"
		64	name="Custom Toolbar"/>
64	</extension>	65	</extension>
65		66
66	<!-- =================================================================================== -->	67	<!-- =================================================================================== -->

Added Link Here

(-)src/org/eclipse/ui/examples/presentation/customtoolbar/widgets/ISContributionItem.java (+8 lines)
1	package org.eclipse.ui.examples.presentation.customtoolbar.widgets;
2
3	import org.eclipse.jface.action.IContributionItem;
4
5	public interface ISContributionItem extends IContributionItem {
6	public void fill(SCoolBar parent, int index);
7	public void fill(SToolBar parent, int index);
8	}




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

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

import org.eclipse.core.runtime.ListenerList;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.ContributionManager;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.SubContributionItem;
import org.eclipse.jface.internal.provisional.action.IToolBarManager2;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.accessibility.ACC;
import org.eclipse.swt.accessibility.AccessibleAdapter;
import org.eclipse.swt.accessibility.AccessibleEvent;
import org.eclipse.swt.accessibility.AccessibleListener;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.ToolBar;

public class SToolBarManager2 extends ContributionManager implements IToolBarManager2 {

	/**
	 * The tool bar items style; <code>SWT.NONE</code> by default.
	 */
	private int itemStyle = SWT.NONE;

	/**
	 * The tool bat control; <code>null</code> before creation and after
	 * disposal.
	 */
	private Control toolBar = null;

	/**
	 * The menu manager to the context menu associated with the toolbar.
	 * 
	 * @since 3.0
	 */
	private MenuManager contextMenuManager = null;
	
	/**
	 * A collection of objects listening to changes to this manager. This
	 * collection is <code>null</code> if there are no listeners.
	 */
	private transient ListenerList listenerList = null;

	/**
	 * Creates a new tool bar manager with the default SWT button style. Use the
	 * <code>createControl</code> method to create the tool bar control.
	 */
	public SToolBarManager2() {
		//Do nothing if there are no parameters
	}

	/**
	 * Creates a tool bar manager with the given SWT button style. Use the
	 * <code>createControl</code> method to create the tool bar control.
	 * 
	 * @param style
	 *            the tool bar item style
	 * @see org.eclipse.swt.widgets.ToolBar for valid style bits
	 */
	public SToolBarManager2(int style) {
		itemStyle = style;
	}

	/**
	 * Creates a tool bar manager for an existing tool bar control. This manager
	 * becomes responsible for the control, and will dispose of it when the
	 * manager is disposed.
	 * 
	 * @param toolbar
	 *            the tool bar control
	 */
	public SToolBarManager2(ToolBar toolbar) {
		this();
		this.toolBar = toolbar;
	}

    public void add(IAction action) {
        super.add(new SActionContributionItem(action));
    }

    public void add(IContributionItem item) {
    	/*if (item instanceof Separator) {
    		Separator separator = (Separator)item;
    		String label = separator.getGroupName();
    		SActionContributionItem sItem = new SActionContributionItem();
    		IAction action = sItem.getAction();
    		action.setText(label);
    		item = sItem;
    	}
    	if (item instanceof ActionContributionItem) {
    		SActionContributionItem proxyItem = 
    			new SActionContributionItem(((ActionContributionItem)item).getAction());
    		item = proxyItem;
    	}*/
    	if (item instanceof SubContributionItem) {
    		SubContributionItem wrapper = (SubContributionItem)item;
    		item = wrapper.getInnerItem();
    		add(item);
    	}
    	else
    		super.add(item);
    }

	/**
	 * Creates and returns this manager's tool bar control. Does not create a
	 * new control if one already exists.
	 * 
	 * @param parent
	 *            the parent control
	 * @return the tool bar control
	 */
	public ToolBar createControl(Composite parent) {
		return null;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#createControl2(org.eclipse.swt.widgets.Composite)
	 */
	public Control createControl2(Composite parent) {
		if (!toolBarExist() && parent != null) {
			toolBar = new SToolBar(parent, itemStyle);
			((SToolBar)toolBar).setSkin(new HannoverGlobalToolBarSkin());
			toolBar.setMenu(getContextMenuControl());
			update(false);
			
			toolBar.getAccessible().addAccessibleListener(getAccessibleListener());
		}
		return toolBar;
	}

	/**
	 * Get the accessible listener for the tool bar.
	 * 
	 * @return AccessibleListener
	 * 
	 * @since 3.1
	 */
	private AccessibleListener getAccessibleListener() {
		return new AccessibleAdapter() {
			public void getName(AccessibleEvent e) {
				if (e.childID != ACC.CHILDID_SELF) {
					SToolItem item = ((SToolBar)toolBar).getItem(e.childID);
					if (item != null) {
						String toolTip = item.getToolTipText();
						if (toolTip != null) {
							e.result = toolTip;
						}
					}
				}
			}
		};

	}

	/**
	 * Disposes of this tool 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 tool bar manager and its
	 * associated contribution items. Use <code>removeAll</code> for that
	 * purpose.
	 */
	public void dispose() {

		if (toolBarExist()) {
			toolBar.dispose();
		}
		toolBar = null;

		IContributionItem[] items = getItems();
		for (int i = 0; i < items.length; i++) {
			items[i].dispose();
		}

		if (getContextMenuManager() != null) {
			getContextMenuManager().dispose();
			setContextMenuManager(null);
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#getControl()
	 */
	public ToolBar getControl() {
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#getControl2()
	 */
	public Control getControl2() {
		return toolBar;
	}
	
	/**
	 * Re-lays out the tool bar.
	 * <p>
	 * The default implementation of this framework method re-lays out the
	 * parent when the number of items crosses the zero threshold. Subclasses
	 * should override this method to implement their own re-layout strategy
	 * 
	 * @param layoutBar
	 *            the tool bar control
	 * @param oldCount
	 *            the old number of items
	 * @param newCount
	 *            the new number of items
	 */
	protected void relayout(SToolBar layoutBar, int oldCount, int newCount) {
		if ((oldCount == 0) != (newCount == 0))
			layoutBar.getParent().layout();
		firePropertyChange(PROP_LAYOUT, new Integer(oldCount), new Integer(newCount));
	}

	/**
	 * Returns whether the tool bar control is created and not disposed.
	 * 
	 * @return <code>true</code> if the control is created and not disposed,
	 *         <code>false</code> otherwise
	 */
	private boolean toolBarExist() {
		return toolBar != null && !toolBar.isDisposed();
	}

	/*
	 * (non-Javadoc) Method declared on IContributionManager.
	 */
	public void update(boolean force) {

		//	long startTime= 0;
		//	if (DEBUG) {
		//		dumpStatistics();
		//		startTime= (new Date()).getTime();
		//	}

		if (isDirty() || force) {

			if (toolBarExist()) {

				int oldCount = ((SToolBar)toolBar).getItemCount();

				// clean contains all active items without double separators
				IContributionItem[] items = getItems();
				ArrayList clean = new ArrayList(items.length);
				IContributionItem separator = null;
				//			long cleanStartTime= 0;
				//			if (DEBUG) {
				//				cleanStartTime= (new Date()).getTime();
				//			}
				for (int i = 0; i < items.length; ++i) {
					IContributionItem ci = items[i];
					if (!ci.isVisible())
						continue;
					if (ci.isSeparator()) {
						// delay creation until necessary
						// (handles both adjacent separators, and separator at
						// end)
						separator = ci;
					} else {
						if (separator != null) {
							if (clean.size() > 0) // no separator if first item
								clean.add(separator);
							separator = null;
						}
						clean.add(ci);
					}
				}
				//			if (DEBUG) {
				//				System.out.println(" Time needed to build clean vector: " +
				// ((new Date()).getTime() - cleanStartTime));
				//			}

				// determine obsolete items (removed or non active)
				SToolItem[] mi = ((SToolBar)toolBar).getItems();
				ArrayList toRemove = new ArrayList(mi.length);
				for (int i = 0; i < mi.length; i++) {
					Object data = mi[i].getData();
					if (data == null
							|| !clean.contains(data)
							|| (data instanceof IContributionItem && ((IContributionItem) data)
									.isDynamic())) {
						toRemove.add(mi[i]);
					}
				}

				// Turn redraw off if the number of items to be added
				// is above a certain threshold, to minimize flicker,
				// otherwise the toolbar can be seen to redraw after each item.
				// Do this before any modifications are made.
				// We assume each contribution item will contribute at least one
				// toolbar item.
				boolean useRedraw = (clean.size() - (mi.length - toRemove
						.size())) >= 3;
                try {
                    if (useRedraw) {
                        toolBar.setRedraw(false);
                    }

                    // remove obsolete items
                    for (int i = toRemove.size(); --i >= 0;) {
                        SToolItem item = (SToolItem) toRemove.get(i);
                        if (!item.isDisposed()) {
                            Control ctrl = item.getControl();
                            if (ctrl != null) {
                                item.setControl(null);
                                ctrl.dispose();
                            }
                            item.dispose();
                        }
                    }

                    // add new items
                    IContributionItem src, dest;
                    mi = ((SToolBar)toolBar).getItems();
                    int srcIx = 0;
                    int destIx = 0;
                    for (Iterator e = clean.iterator(); e.hasNext();) {
                        src = (IContributionItem) e.next();

                        // get corresponding item in SWT widget
                        if (srcIx < mi.length)
                            dest = (IContributionItem) mi[srcIx].getData();
                        else
                            dest = null;

                        if (dest != null && src.equals(dest)) {
                            srcIx++;
                            destIx++;
                            continue;
                        }

                        if (dest != null && dest.isSeparator()
                                && src.isSeparator()) {
                            mi[srcIx].setData(src);
                            srcIx++;
                            destIx++;
                            continue;
                        }

                        int start = ((SToolBar)toolBar).getItemCount();
                        
                        if (src instanceof ISContributionItem)
                        	((ISContributionItem)src).fill(((SToolBar)toolBar), destIx);
                        else if (src instanceof ActionContributionItem) {
                    		SActionContributionItem proxyItem = 
                    			new SActionContributionItem(((ActionContributionItem)src).getAction());
                    		proxyItem.fill(((SToolBar)toolBar), destIx);
                    	}
                        
                        int newItems = ((SToolBar)toolBar).getItemCount() - start;
                        for (int i = 0; i < newItems; i++) {
                            SToolItem item = ((SToolBar)toolBar).getItem(destIx++);
                            item.setData(src);
                        }
                    }

                    // remove any old tool items not accounted for
                    for (int i = mi.length; --i >= srcIx;) {
                        SToolItem item = mi[i];
                        if (!item.isDisposed()) {
                            Control ctrl = item.getControl();
                            if (ctrl != null) {
                                item.setControl(null);
                                ctrl.dispose();
                            }
                            item.dispose();
                        }
                    }

                    setDirty(false);

                    // turn redraw back on if we turned it off above
                } finally {
                    if (useRedraw) {
                        toolBar.setRedraw(true);
                    }
                }

				int newCount = ((SToolBar)toolBar).getItemCount();
				relayout((SToolBar)toolBar, oldCount, newCount);
			}

		}

		//	if (DEBUG) {
		//		System.out.println(" Time needed for update: " + ((new
		// Date()).getTime() - startTime));
		//		System.out.println();
		//	}
	}

	/**
	 * Returns the control of the Menu Manager. If the menu manager does not
	 * have a control then one is created.
	 * 
	 * @return menu widget associated with manager
	 */
	private Menu getContextMenuControl() {
		if ((contextMenuManager != null) && (toolBar != null)) {
			Menu menuWidget = contextMenuManager.getMenu();
			if ((menuWidget == null) || (menuWidget.isDisposed())) {
				menuWidget = contextMenuManager.createContextMenu(toolBar);
			}
			return menuWidget;
		}
		return null;
	}

	/**
	 * Returns the context menu manager for this tool bar manager.
	 * 
	 * @return the context menu manager, or <code>null</code> if none
	 * @since 3.0
	 */
	public MenuManager getContextMenuManager() {
		return contextMenuManager;
	}

	/**
	 * Sets the context menu manager for this tool bar manager to the given menu
	 * manager. If the tool bar control exists, it also adds the menu control to
	 * the tool bar.
	 * 
	 * @param contextMenuManager
	 *            the context menu manager, or <code>null</code> if none
	 * @since 3.0
	 */
	public void setContextMenuManager(MenuManager contextMenuManager) {
		this.contextMenuManager = contextMenuManager;
		if (toolBar != null) {
			toolBar.setMenu(getContextMenuControl());
		}
	}

	public int getItemCount() {
		return 1;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#addPropertyChangeListener(org.eclipse.jface.util.IPropertyChangeListener)
	 */
	public void addPropertyChangeListener(IPropertyChangeListener listener) {
		if (listenerList == null) {
			listenerList = new ListenerList(ListenerList.IDENTITY);
		}

		listenerList.add(listener);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.IToolBarManager2#removePropertyChangeListener(org.eclipse.jface.util.IPropertyChangeListener)
	 */
	public void removePropertyChangeListener(IPropertyChangeListener listener) {
		if (listenerList != null) {
			listenerList.remove(listener);

			if (listenerList.isEmpty()) {
				listenerList = null;
			}
		}
	}
	
	/*
	 * Returns the listeners attached to this event manager.
	 * The listeners currently attached; may be empty, but never
	 * null.
	 */
	protected final Object[] getListeners() {
		final ListenerList list = listenerList;
		if (list == null) {
			return new Object[0];
		}

		return list.getListeners();
	}

	/*
	 * Notifies any property change listeners that a property has changed. Only
	 * listeners registered at the time this method is called are notified.
	 */
	private void firePropertyChange(final PropertyChangeEvent event) {
		final Object[] list = getListeners();
		for (int i = 0; i < list.length; ++i) {
			((IPropertyChangeListener) list[i]).propertyChange(event);
		}
	}

	/*
	 * Notifies any property change listeners that a property has changed. Only
	 * listeners registered at the time this method is called are notified. This
	 * method avoids creating an event object if there are no listeners
	 * registered, but calls firePropertyChange(PropertyChangeEvent) if there are.
	 */
	private void firePropertyChange(final String propertyName,
			final Object oldValue, final Object newValue) {
		if (listenerList != null) {
			firePropertyChange(new PropertyChangeEvent(this, propertyName,
					oldValue, newValue));
		}
	}
	
}




/*
*	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 
		// it is exclusively a SEPARATOR or if it is a separator with a control. 
		//
		boolean measureMinMax = true;
		if ((getStyle() & SWT.SEPARATOR) == SWT.SEPARATOR) {
			if (control != null || t == null) { 
				measureMinMax = false;
			}
		}
		
		if (measureMinMax) {
			Point minMax = skin.getSize(Skin.TYPE_ITEM_MIN_MAX_WIDTHS, Skin.NORMAL);
			if (minMax != null) {
				if (minMax.x > size.x && minMax.x != SWT.DEFAULT) {
					size.x = minMax.x;
				}
				if (minMax.y < size.x && minMax.y != SWT.DEFAULT) {
					size.x = minMax.y;
				}
			}
	
			minMax = skin.getSize(Skin.TYPE_ITEM_MIN_MAX_HEIGHT, Skin.NORMAL);
			if (minMax != null) {
				if (minMax.x > size.y && minMax.x != SWT.DEFAULT) {
					size.y = minMax.x;
				}
				if (minMax.y < size.y && minMax.y != SWT.DEFAULT) {
					size.y = minMax.y;
				}
			}
		}
		
		return size;
	}
	
	public void dispose() {
		if (isDisposed ()) return;
		parent.destroyItem(this);
		super.dispose();
	}

	/**
	 * @return
	 */
	public Rectangle getBounds() {
		return itemRect;
	}

	/**
	 * @return
	 */
	public Control getControl() {
		return control;
	}

	Skin getSkin() {
		Skin skin = parent.getSkin();
		return skin;
	}
	
	/**
	 * @return
	 */
	public Image getDisabledImage() {
		return disabledImage;
	}

	/**
	 * @return
	 */
	public boolean getEnabled() {
		return enabled;
	}
	
	/**
	 * @return
	 */
	public Image getHotImage() {
		return hotImage;
	}

	/**
	 * @return pressed image.
	 */
	public Image getPressedImage() {
		return pressedImage;
	}
	
	/**
	 * @return
	 */
	public SToolBar getParent() {
		return this.parent;
	}
	
	/**
	 * @return
	 */
	public boolean getSelection() {
		return selected;
	}

	private int getState() {
		return state;
	}
	
	private int getArrowState() {
		return arrowState;
	}
	
	/**
	 * Compute the minimum size.
	 */
	private Point getContentSize(Image image, String text) {
		Point size = new Point(0, 0);
		Skin skin = getSkin();
		
		Control control = getControl();
		if (control != null) {
			size = control.computeSize(SWT.DEFAULT, SWT.DEFAULT);
			if (width != -1)
				size.x = width;
			return size;
		}

		if (image != null) {
			Rectangle r;
			Point imageSize = skin.getSize(Skin.TYPE_ITEM_ICON_SIZE, state);
			if (imageSize != null && imageSize.y != SWT.DEFAULT) {
				r = new Rectangle(0, 0, imageSize.x, imageSize.y);
			} else {
				r = image.getBounds();
			}
			size.x += r.width;
			size.y += r.height;
		}

		if (skin != null) {
			Rectangle margins = skin.getRect(Skin.TYPE_ITEM_MARGINS, Skin.NORMAL);
			if (margins == null) {
				margins = new Rectangle(0, 0, 0, 0);
			}
			
			if (text != null && text.length() > 0) {
				GC gc = new GC(this.getParent());
				gc.setFont(skin.getFont(Skin.TYPE_ITEM_FONT, Skin.NORMAL));
				FontMetrics fm = gc.getFontMetrics();
				Point e = gc.textExtent(text, SWT.DRAW_TRANSPARENT);
				size.x += e.x;
				size.y = Math.max(size.y, fm.getAscent());
				if (image != null) {
					size.x += margins.x;
				}
				gc.dispose();
			} 
	
			if ((getStyle() & SWT.DROP_DOWN) != 0) {
				Point hinkySize = skin.getSize(Skin.TYPE_DECORATION_ARROW, Skin.NORMAL);
				if (hinkySize == null) {
					hinkySize = new Point(0, 0);
				}
				size.x += hinkySize.x + margins.y;
				
				if ((getStyle() & SWT.SIMPLE) != SWT.SIMPLE) {
					Point separatorSize = skin.getSize(Skin.TYPE_DECORATION_INTERNAL_SEPARATOR, Skin.NORMAL);
					if (separatorSize == null) {
						separatorSize = new Point(0, 0);
					}
					size.x += separatorSize.x;
				}
			}
		}
		
		return size;
	}
	
	/**
	 * @return
	 */
	public String getToolTipText() {
		return toolTipText;
	}
	
	/**
	 * @return
	 */
	public int getWidth() {
		return itemRect.width;
	}
	
	public Rectangle getArrowRect() {
		return arrowRect;
	}
	
	/**
	 * @return
	 */
	public boolean isEnabled() {
		return enabled;
	}
	
	/**
	 * 
	 */
	void onDispose() {
		// TODO Auto-generated method stub
	}
	
	/**
	 * @param event
	 */
	void onFocus(Event event) {
		// TODO Auto-generated method stub
	}

	/**
	 * @param event
	 */
	void onMouseDoubleClick(Event event) {		
	}
	
	/**
	 * @param event
	 */
	void onMouseDown(Event event) {
		if (arrowRect != null) {
			if (arrowRect.contains(event.x, event.y)) {
				setArrowPressed(true);
			}
		}
		if ((arrowState & Skin.PRESSED) == 0) {
			setPressed(true);
		}
		notifyListeners(SWT.MouseDown, event);
		
		if ((getStyle() & SWT.RADIO) == SWT.RADIO) {
			Event e = new Event();
			e.button = event.button;
			e.character = event.character;
			e.count = event.count;
			e.data = event.data;
			e.detail = event.detail;
			e.display = event.display;
			e.doit = event.doit;
			e.end = event.end;
			e.gc = event.gc;
			e.height = event.height;
			e.item = event.item;
			e.keyCode = event.keyCode;
			e.start = event.start;
			e.stateMask = event.stateMask;
			e.text = event.text;
			e.time = event.time;
			e.widget = event.widget;
			e.width = event.width;
			e.x = event.x;
			e.y = event.y;
			
			e.type = SWT.Selection;
			notifyListeners(SWT.Selection, e);
			setSelected(true);
		}
	}

	/**
	 * @param event
	 */
	void onMouseExit(Event event) {
	}

	/**
	 * @param event
	 */
	void onMouseHover(Event event) {
		notifyListeners(SWT.MouseHover, event);
	}
	
	void setHot(boolean hot) {
		if (hot)
			state |= Skin.HOVER;
		else if ((state & Skin.HOVER) != 0) 
			state = (state & ~Skin.HOVER);
	}

	void setArrowHot(boolean hot) {
		if (hot) {
			arrowState |= Skin.HOVER;
		} else if ((arrowState & Skin.HOVER) == Skin.HOVER) {
			arrowState = (arrowState & ~Skin.HOVER);
		}
	}
	
	void setPressed(boolean pressed) {
		if (pressed)
			state |= Skin.PRESSED;
		else if ((state & Skin.PRESSED) != 0) 
			state = (state & ~Skin.PRESSED);
	}
	
	void setArrowPressed(boolean pressed) {
		if (pressed)
			arrowState |= Skin.PRESSED;
		else if ((arrowState & Skin.PRESSED) == Skin.PRESSED) 
			arrowState = (arrowState & ~Skin.PRESSED);
	}

	public void setSelected(boolean selected) {
		if (selected) {
			/* Clear all adjacent selected radio buttons */
			int itemIndex = parent.indexOf(this);
			int i;
			SToolItem item;
			
			for (i = itemIndex -1; i > 0; i--) {
				item = parent.getItem(i);
				if ((item.getStyle() & SWT.RADIO) == SWT.RADIO) {
					item.setSelected(false);
				} else {
					break;
				}
			}
			for (i = itemIndex +1; i < parent.getItemCount(); i++) {
				item = parent.getItem(i);
				if ((item.getStyle() & SWT.RADIO) == SWT.RADIO) {
					item.setSelected(false);
				} else {
					break;
				}
			}
			state |= Skin.SELECTED;
		} else if ((state & Skin.SELECTED) == Skin.SELECTED) { 
			state = (state & ~Skin.SELECTED);
		}
	}
	
	/**
	 * @param event
	 */
	void onMouseMove(Event event) {
	}

	/**
	 * @param event
	 */
	void onMouseUp(Event event) {
		setPressed(false);
		
		Event e = new Event();
		e.type = SWT.MouseUp;
		e.widget = this;
		e.gc = event.gc;
		e.x = event.x;
		e.y = event.y;
		notifyListeners(SWT.MouseUp, event);

		if ((getStyle() & SWT.RADIO) != SWT.RADIO) {
			e = new Event();
			e.type = SWT.Selection;
			e.widget = this;
			e.gc = event.gc;
			e.x = event.x;
			e.y = event.y;
			if (arrowRect != null && arrowRect.contains(event.x, event.y))
				e.detail |= SWT.ARROW;
			notifyListeners(SWT.Selection, e);
		}
	}
		
	
	/*
	 * Process the paint event
	 */
	void onPaint(GC gc) {
		Skin skin = parent.getSkin();
		String t = getText();
		if (t != null && t.length() == 0) {
			t = null;
		}
		Image img = null;

		int state = getState();

		/*
		 * A separator with text will just draw static text rather than a line separator
		 * so always keep the state normal so it doesn't behave like a button. 
		 */
		if (control == null && (getStyle() & SWT.SEPARATOR) == SWT.SEPARATOR && t != null) {
			state = Skin.NORMAL;
		}

		if (isEnabled() == false) {
			img = getDisabledImage();
		} else if ((state & Skin.PRESSED) == Skin.PRESSED) {
			img = getPressedImage();
		} else if ((state & Skin.HOVER) == Skin.HOVER) {
			img = getHotImage();
		}
		
		if (img == null) {
			img = getImage();
		}
		
		Rectangle insets = skin.getRect(Skin.TYPE_ITEM_INSETS, state);
		if (insets == null) {
			insets = new Rectangle(0, 0, 0, 0);
		}
		gc.setFont(skin.getFont(Skin.TYPE_ITEM_FONT, state));

		Rectangle rect = getBounds();
		if (rect.width == 0 || rect.height == 0)
			return;
		
		int availableWidth = rect.width - (insets.x + insets.width);
		Point extent = getContentSize(img, t);
		if (extent.x > availableWidth) {
			img = null;
			extent = getContentSize(img, t);
		}

		// determine horizontal position
		int x = (rect.x + insets.x);
		if (align == SWT.CENTER) {
			x = (rect.width - extent.x) / 2;
		}
		else if (align == SWT.RIGHT) {
			x = rect.width - extent.x - insets.width;
		}
//gc.setForeground(getDisplay().getSystemColor(SWT.COLOR_RED));
//gc.drawRectangle(rect);
		if (control == null && (getStyle() & SWT.SEPARATOR) == SWT.SEPARATOR && t == null) {
			state = (state & ~(Skin.PRESSED));
			skin.drawDecoration(gc, rect, parent, Skin.TYPE_DECORATION_SEPARATOR, state);
			return;
		}
		
		// paint background
		skin.drawBackground(gc, rect, parent, Skin.TYPE_ITEM_BACKGROUND, state);
		
		// paint border
		skin.drawBorder(gc, rect, parent, Skin.TYPE_ITEM_BORDER, state);
		
		Rectangle itemMargins = skin.getRect(Skin.TYPE_ITEM_MARGINS, state);
		if (itemMargins == null) {
			itemMargins = new Rectangle(0, 0, 0, 0);
		}
		
		// draw the image
		
		if (img != null) {
			Rectangle imageRect;
			Point imageSize = skin.getSize(Skin.TYPE_ITEM_ICON_SIZE, state);
			if (imageSize != null && imageSize.y != SWT.DEFAULT) {
				imageRect = new Rectangle(0, 0, imageSize.x, imageSize.y);
			} else {
				imageRect = img.getBounds();
			}

			imageRect = new Rectangle(x, rect.y + ((rect.height - imageRect.height) / 2),
					imageRect.width, imageRect.height);
			skin.drawImage(gc, imageRect, img, parent, Skin.TYPE_ITEM_IMAGE, state);
			
			x += imageRect.width + itemMargins.x;
		}
		
		// draw the text
		if (t != null) {
			FontMetrics fm = gc.getFontMetrics();
			int textHeight = fm.getAscent();
			int textWidth = gc.textExtent(getText(), SWT.DRAW_TRANSPARENT  | SWT.DRAW_MNEMONIC).x;
			int y = rect.y;
			int availableHeight = rect.height;
			y = y + ((availableHeight / 2) - (textHeight / 2));
			Rectangle textRect = new Rectangle(x, y, textWidth, textHeight);
//Used for debugging text rect rendering.
//			gc.setBackground(getDisplay().getSystemColor(SWT.COLOR_GREEN));
//			gc.fillRectangle(textRect);
			/* Don't include leading so top of text lines up when expected in the drawing rect. */
			textRect.y -= fm.getLeading();
			skin.drawText(gc, textRect, getText(), SWT.DRAW_TRANSPARENT | SWT.DRAW_MNEMONIC, parent, Skin.TYPE_ITEM_TEXT, state);
			/* Add leading back in to get the "text rect" that the text is actually rendered in. */
			textRect.y += fm.getLeading();
			x += textRect.width + itemMargins.y;
		}

		// draw the hinky and text/hinky separator
		if ((getStyle() & SWT.DROP_DOWN) != 0) {
			Point hinkySize = skin.getSize(Skin.TYPE_DECORATION_ARROW, state);
			if (hinkySize == null) {
				hinkySize = new Point(0, 0);
			}
			int myX = x;
			int myY = rect.y + ((rect.height /2) - ((hinkySize.y == SWT.DEFAULT ? 0 : hinkySize.y) / 2));
			Point separatorSize = skin.getSize(Skin.TYPE_DECORATION_INTERNAL_SEPARATOR, state);
			if (separatorSize == null) {
				separatorSize = new Point(0, 0);
			}
			int sepLineX = myX -2;

			int arrowState = state;
			// separator
			Rectangle sepLineRectangle = null;
			if ((getStyle() & SWT.SIMPLE) != SWT.SIMPLE) {
				int y = rect.y + (((rect.height / 2) - ((separatorSize.y == SWT.DEFAULT ? rect.height : separatorSize.y)) / 2));
				sepLineRectangle = new Rectangle(sepLineX, y, separatorSize.x, (separatorSize.y == SWT.DEFAULT ? rect.height : separatorSize.y));
				skin.drawDecoration(gc, sepLineRectangle, parent, Skin.TYPE_DECORATION_INTERNAL_SEPARATOR, state);
				myX += separatorSize.x;
				/* Since it is separate, use the arrow state to draw the hinky below. */
				arrowState = getArrowState();
			}
			
			// hinky
			int height = (hinkySize.y == SWT.DEFAULT ? rect.height : hinkySize.y); 
			Rectangle arrowImageRect = new Rectangle(myX, myY, hinkySize.x, height);
			skin.drawDecoration(gc, arrowImageRect, parent, Skin.TYPE_DECORATION_ARROW, arrowState);
			
			if (sepLineRectangle != null)
				arrowRect = new Rectangle(sepLineRectangle.x, 0, myX, rect.height);
			else
				arrowRect = null;
		}
	}

	public void removeSelectionListener (SelectionListener listener) {
		checkWidget();
		if (listener == null) SWT.error (SWT.ERROR_NULL_ARGUMENT);
		removeListener(SWT.Selection, listener);
		removeListener(SWT.DefaultSelection,listener);	
	}
	
	/**
	 * @param control
	 */
	public void setControl(Control control) {
		this.control = control;
		if (control != null) {
			Point pt = control.computeSize(SWT.DEFAULT, SWT.DEFAULT);
			itemRect = new Rectangle(0, 0, pt.x, pt.y);
			control.setBounds(itemRect);
			parent.itemChanged(this);
		}
	}
	
	/**
	 * @param image
	 */
	public void setDisabledImage(Image image) {
		this.disabledImage = image;
		parent.itemChanged(this);
	}
	
	/**
	 * @param enabled
	 */
	public void setEnabled(boolean enabled) {
		this.enabled = enabled;
		parent.itemChanged(this);
	}
	
	/**
	 * @param image
	 */
	public void setHotImage(Image image) {
		this.hotImage = image;
		parent.itemChanged(this);
	}
	
	/**
	 * @param pressed image
	 */
	public void setPressedImage(Image image) {
		this.pressedImage = image;
		parent.itemChanged(this);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.swt.widgets.Item#setImage(org.eclipse.swt.graphics.Image)
	 */
	public void setImage(Image image) {
		if ((getStyle() & SWT.SEPARATOR) != 0)
			return;
		super.setImage(image);
		parent.itemChanged(this);
	}

	/**
	 * @param selected
	 */
	public void setSelection(boolean selected) {
		this.selected = selected;
		parent.itemChanged(this);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.swt.widgets.Item#setText(java.lang.String)
	 */
	public void setText(String string) {
		super.setText(string);
		parent.itemChanged(this);
	}
	
	/**
	 * @param string
	 */
	public void setToolTipText(String string) {
		toolTipText = string;
		parent.itemChanged(this);
	}
	
	public void setWidth(int width) {
		this.width = width;
		if (control != null) {
			Point size = control.getSize();
			size.x = width;
			control.setSize(size);
		}
	}

}




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

import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.ContributionItem;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.action.SubContributionItem;
import org.eclipse.jface.action.ToolBarContributionItem;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
import org.eclipse.jface.util.Policy;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.CoolBar;
import org.eclipse.swt.widgets.CoolItem;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;

public class SToolBarContributionItem2 extends ContributionItem implements ISContributionItem, IToolBarContributionItem {

    /**
     * A constant used by <code>setMinimumItemsToShow</code> and <code>getMinimumItemsToShow</code>
     * to indicate that all tool items should be shown in the cool item.
     */
    public static final int SHOW_ALL_ITEMS = -1;

    /**
     * The pull down menu used to list all hidden tool items if the current
     * size is less than the preffered size.
     */
    private MenuManager chevronMenuManager = null;

    /**
     * The widget created for this item; <code>null</code> before creation
     * and after disposal.
     */
    private SCoolItem coolItem = null;

    /**
     * Current height of cool item
     */
    private int currentHeight = -1;

    /**
     * Current width of cool item.
     */
    private int currentWidth = -1;

    /**
     * A flag indicating that this item has been disposed. This prevents future
     * method invocations from doing things they shouldn't.
     */
    private boolean disposed = false;

    /**
     * Mininum number of tool items to show in the cool item widget.
     */
    private int minimumItemsToShow = SHOW_ALL_ITEMS;

    /**
     * The tool bar manager used to manage the tool items contained in the cool
     * item widget.
     */
    private IToolBarManager toolBarManager = null;

    /**
     * Enable/disable chevron support.
     */
    private boolean useChevron = true;

	private String id;

    /**
     * Convenience method equivalent to <code>ToolBarContributionItem(new ToolBarManager(), null)</code>.
     */
    public SToolBarContributionItem2() {
        this(new SToolBarManager2(), (String)null);
    }
    
    /**
     * Convenience method equivalent to <code>ToolBarContributionItem(toolBarManager, null)</code>.
     * 
     * @param toolBarManager
     *            the tool bar manager
     */
    public SToolBarContributionItem2(IToolBarManager toolBarManager) {
        this(toolBarManager, (String)null);
    }

    /**
     * Creates a tool bar contribution item.
     * 
     * @param toolBarManager
     *            the tool bar manager to wrap
     * @param id
     *            the contribution item id, or <code>null</code> if none
     */
    public SToolBarContributionItem2(IToolBarManager toolBarManager, String id) {
        super();
        this.toolBarManager = toolBarManager;
        this.id = id;
    }
    
    /**
     * Checks whether this contribution item has been disposed. If it has, and
     * the tracing options are active, then it prints some debugging
     * information.
     * 
     * @return <code>true</code> if the item is disposed; <code>false</code>
     *         otherwise.
     *  
     */
    private final boolean checkDisposed() {
        if (disposed) {
            if (Policy.TRACE_TOOLBAR) { //$NON-NLS-1$
                System.out
                        .println("Method invocation on a disposed tool bar contribution item."); //$NON-NLS-1$
                new Exception().printStackTrace(System.out);
            }

            return true;
        }

        return false;
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.jface.action.IContributionItem#dispose()
     */
    public void dispose() {
        // Dispose of the ToolBar and all its contributions
        if (toolBarManager != null) {
        	// TODO: handle dispose
        	if (toolBarManager instanceof ToolBarManager)
        		((ToolBarManager)toolBarManager).dispose();
        	else if (toolBarManager instanceof SToolBarManager2)
        		((SToolBarManager2)toolBarManager).dispose();
            toolBarManager = null;
        }

        /*
         * We need to dispose the cool item or we might be left holding a cool
         * item with a disposed control.
         */
        if ((coolItem != null) && (!coolItem.isDisposed())) {
            coolItem.dispose();
            coolItem = null;
        }

        // Mark this item as disposed.
        disposed = true;
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.jface.action.IContributionItem#fill(org.eclipse.swt.widgets.CoolBar,
     *      int)
     */
    public void fill(CoolBar coolBar, int index) {
    	// do nothing
    }
    
    /**
     * Returns 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.
     */
    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 current height of the corresponding cool item.
     * 
     * @return the current height
     */
    public int getCurrentHeight() {
        if (checkDisposed()) {
            return -1;
        }
        return currentHeight;
    }

    /**
     * Returns the current width of the corresponding cool item.
     * 
     * @return the current size
     */
    public int getCurrentWidth() {
        if (checkDisposed()) {
            return -1;
        }
        return currentWidth;
    }

    /*
     *  (non-Javadoc)
     * @see org.eclipse.jface.action.IContributionItem#getId()
     */
    public String getId() {
    	return this.id;
    }
    
    /**
     * Returns the minimum number of tool items to show in the cool item.
     * 
     * @return the minimum number of tool items to show, or <code>SHOW_ALL_ITEMS</code>
     *         if a value was not set
     * @see #setMinimumItemsToShow(int)
     */
    public int getMinimumItemsToShow() {
        if (checkDisposed()) {
            return -1;
        }
        return minimumItemsToShow;
    }

    /**
     * Returns the internal tool bar manager of the contribution item.
     * 
     * @return the tool bar manager, or <code>null</code> if one is not
     *         defined.
     * @see IToolBarManager
     */
    public IToolBarManager getToolBarManager() {
        if (checkDisposed()) {
            return null;
        }
        return toolBarManager;
    }

    /**
     * Returns whether chevron support is enabled.
     * 
     * @return <code>true</code> if chevron support is enabled, <code>false</code>
     *         otherwise
     */
    public boolean getUseChevron() {
        if (checkDisposed()) {
            return false;
        }
        return useChevron;
    }

    /**
     * Create and display the chevron menu.
     */
    private void handleChevron(SelectionEvent event) {
        CoolItem item = (CoolItem) event.widget;
        Control control = item.getControl();
        if ((control instanceof ToolBar) == false) {
            return;
        }
        CoolBar coolBar = item.getParent();
        ToolBar toolBar = (ToolBar) control;
        Rectangle toolBarBounds = toolBar.getBounds();
        ToolItem[] items = toolBar.getItems();
        ArrayList hidden = new ArrayList();
        for (int i = 0; i < items.length; ++i) {
            Rectangle itemBounds = items[i].getBounds();
            if (!((itemBounds.x + itemBounds.width <= toolBarBounds.width) && (itemBounds.y
                    + itemBounds.height <= toolBarBounds.height))) {
                hidden.add(items[i]);
            }
        }

        // Create a pop-up menu with items for each of the hidden buttons.
        if (chevronMenuManager != null) {
            chevronMenuManager.dispose();
        }
        chevronMenuManager = new MenuManager();
        for (Iterator i = hidden.iterator(); i.hasNext();) {
            ToolItem toolItem = (ToolItem) i.next();
            IContributionItem data = (IContributionItem) toolItem.getData();
            if (data instanceof ActionContributionItem) {
                ActionContributionItem contribution = new ActionContributionItem(
                        ((ActionContributionItem) data).getAction());
                chevronMenuManager.add(contribution);
            } else if (data instanceof SubContributionItem) {
                IContributionItem innerData = ((SubContributionItem) data)
                        .getInnerItem();
                if (innerData instanceof ActionContributionItem) {
                    ActionContributionItem contribution = new ActionContributionItem(
                            ((ActionContributionItem) innerData).getAction());
                    chevronMenuManager.add(contribution);
                }
            } else if (data.isSeparator()) {
                chevronMenuManager.add(new Separator());
            }
        }
        Menu popup = chevronMenuManager.createContextMenu(coolBar);
        Point chevronPosition = coolBar.toDisplay(event.x, event.y);
        popup.setLocation(chevronPosition.x, chevronPosition.y);
        popup.setVisible(true);
    }

    /**
     * Handles the event when the toobar item does not have its own context
     * menu.
     * 
     * @param event
     *            the event object
     */
    private void handleContextMenu(Event event) {
        Control toolBar = null;
        if (toolBarManager instanceof SToolBarManager2)
        	toolBar = ((SToolBarManager2)toolBarManager).getControl2();
        else if (toolBarManager instanceof ToolBarManager)
        	toolBar = ((ToolBarManager)toolBarManager).getControl();
        else
        	return;
        // If parent has a menu then use that one
        Menu parentMenu = toolBar.getParent().getMenu();
        if ((parentMenu != null) && (!parentMenu.isDisposed())) {
            toolBar.setMenu(parentMenu);
            // Hook listener to remove menu once it has disapeared
            parentMenu.addListener(SWT.Hide, new Listener() {

                public void handleEvent(Event innerEvent) {
                    Control innerToolBar = null;
                    if (toolBarManager instanceof ToolBarManager)
                    	innerToolBar = ((ToolBarManager)toolBarManager).getControl();
                    else if (toolBarManager instanceof SToolBarManager2)
                    	innerToolBar = ((SToolBarManager2)toolBarManager).getControl();
                    if (innerToolBar != null) {
                        innerToolBar.setMenu(null);
                        Menu innerParentMenu = innerToolBar.getParent()
                                .getMenu();
                        if (innerParentMenu != null) {
                            innerParentMenu.removeListener(SWT.Hide, this);
                        }
                    }
                }
            });
        }
    }

    /**
     * Handles the disposal of the widget.
     * 
     * @param event
     *            the event object
     */
    private void handleWidgetDispose(DisposeEvent event) {
        coolItem = null;
    }

    /**
     * A contribution item is visible iff its internal state is visible <em>or</em>
     * the tool bar manager contains something other than group markers and
     * separators.
     * 
     * @return <code>true</code> if the tool bar manager contains something
     *         other than group marks and separators, and the internal state is
     *         set to be visible.
     */
    public boolean isVisible() {
        if (checkDisposed()) {
            return false;
        }

        boolean visibleItem = false;
        if (toolBarManager != null) {
            IContributionItem[] contributionItems = toolBarManager.getItems();
            for (int i = 0; i < contributionItems.length; i++) {
                IContributionItem contributionItem = contributionItems[i];
                if ((!contributionItem.isGroupMarker())
                        && (!contributionItem.isSeparator())) {
                    visibleItem = true;
                    break;
                }
            }
        }

        return (visibleItem || super.isVisible());
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.jface.action.IContributionItem#saveWidgetState()
     */
    public void saveWidgetState() {
        if (checkDisposed()) {
            return;
        }
        if (coolItem == null)
            return;

        //1. Save current size
        SCoolBar coolBar = (SCoolBar)coolItem.getParent();
        boolean isLastOnRow = false;
        int lastIndex = coolBar.getItemCount() - 1;
        int coolItemIndex = coolBar.indexOf(coolItem);
        int[] wrapIndicies = getAdjustedWrapIndices(coolBar.getWrapIndices());
        // Traverse through all wrap indicies backwards
        for (int row = wrapIndicies.length - 1; row >= 0; row--) {
            if (wrapIndicies[row] <= coolItemIndex) {

                int nextRow = row + 1;
                int nextRowStartIndex;
                if (nextRow > (wrapIndicies.length - 1)) {
                    nextRowStartIndex = lastIndex + 1;
                } else {
                    nextRowStartIndex = wrapIndicies[nextRow];
                }

                // Check to see if its the last item on the row
                if (coolItemIndex == (nextRowStartIndex - 1)) {
                    isLastOnRow = true;
                }
                break;
            }
        }

        // Save the preferred size as actual size for the last item on a row
        int nCurrentWidth;
        if (isLastOnRow) {
            nCurrentWidth = coolItem.getPreferredSize().x;
        } else {
            nCurrentWidth = coolItem.getSize().x;
        }
        setCurrentWidth(nCurrentWidth);
        setCurrentHeight(coolItem.getSize().y);
    }

    /**
     * Sets the current height of the cool item. Update(SIZE) should be called
     * to adjust the widget.
     * 
     * @param currentHeight
     *            the current height to set
     */
    public void setCurrentHeight(int currentHeight) {
        if (checkDisposed()) {
            return;
        }
        this.currentHeight = currentHeight;
    }

    /**
     * Sets the current width of the cool item. Update(SIZE) should be called
     * to adjust the widget.
     * 
     * @param currentWidth
     *            the current width to set
     */
    public void setCurrentWidth(int currentWidth) {
        if (checkDisposed()) {
            return;
        }
        this.currentWidth = currentWidth;
    }

    /**
     * Sets the minimum number of tool items to show in the cool item. If this
     * number is less than the total tool items, a chevron will appear and the
     * hidden tool items appear in a drop down menu. By default, all the tool
     * items are shown in the cool item.
     * 
     * @param minimumItemsToShow
     *            the minimum number of tool items to show.
     * @see #getMinimumItemsToShow()
     * @see #setUseChevron(boolean)
     */
    public void setMinimumItemsToShow(int minimumItemsToShow) {
        if (checkDisposed()) {
            return;
        }
        this.minimumItemsToShow = minimumItemsToShow;
    }

    /**
     * Enables or disables chevron support for the cool item. By default,
     * chevron support is enabled.
     * 
     * @param value
     *            <code>true</code> to enable chevron support, <code>false</code>
     *            otherwise.
     */
    public void setUseChevron(boolean value) {
        if (checkDisposed()) {
            return;
        }
        useChevron = value;
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.jface.action.IContributionItem#update(java.lang.String)
     */
    public void update(String propertyName) {
        if (checkDisposed()) {
            return;
        }
        if (coolItem != null) {
            IToolBarManager manager = getToolBarManager();
            if (manager != null) {
                manager.update(true);
            }

            if ((propertyName == null)
                    || propertyName.equals(ICoolBarManager.SIZE)) {
                updateSize(true);
            }
        }
    }

    /**
     * Updates the cool items' preferred, minimum, and current size. The
     * preferred size is calculated based on the tool bar size and extra trim.
     * 
     * @param changeCurrentSize
     *            <code>true</code> if the current size should be changed to
     *            the preferred size, <code>false</code> to not change the
     *            current size
     */
    private void updateSize(boolean changeCurrentSize) {
        if (checkDisposed()) {
            return;
        }
        // cannot set size if coolItem is null
        if (coolItem == null || coolItem.isDisposed()) {
            return;
        }
        boolean locked = false;
        SCoolBar coolBar = (SCoolBar)coolItem.getParent();
        try {
            // Fix odd behaviour with locked tool bars
            if (coolBar != null) {
                if (coolBar.getLocked()) {
                    coolBar.setLocked(false);
                    locked = true;
                }
            }
            SToolBar toolBar = (SToolBar) coolItem.getControl();
            if ((toolBar == null) || (toolBar.isDisposed())
                    || (toolBar.getItemCount() <= 0)) {
                // if the toolbar does not contain any items then dispose of
                // coolItem
                coolItem.setData(null);
                Control control = coolItem.getControl();
                if ((control != null) && !control.isDisposed()) {
                    control.dispose();
                    coolItem.setControl(null);
                }
                if (!coolItem.isDisposed()) {
                    coolItem.dispose();
                }
            } else {
                // If the toolbar item exists then adjust the size of the cool
                // item
                Point toolBarSize = toolBar.computeSize(SWT.DEFAULT,
                        SWT.DEFAULT);
                // Set the preffered size to the size of the toolbar plus trim
/* FIXME TFS Why is this needed? For repositioning..???
 * 		Oh well. Interferring with the LS build so commenting out.              
 * 				Point preferredSize = coolItem.computeSize(toolBarSize.x,
                        toolBarSize.y);
                coolItem.setPreferredSize(preferredSize);
*/                // note setMinimumSize must be called before setSize, see PR
                // 15565
                // Set minimum size
                if (getMinimumItemsToShow() != SHOW_ALL_ITEMS) {
                    int toolItemWidth = toolBar.getItems()[0].getWidth();
                    int minimumWidth = toolItemWidth * getMinimumItemsToShow();
                    coolItem.setMinimumSize(minimumWidth, toolBarSize.y);
                } else {
                    coolItem.setMinimumSize(toolBarSize.x, toolBarSize.y);
                }
/* FIXME TFS See the fixme above. 
 *                if (changeCurrentSize) {
                    // Set current size to preferred size
                    coolItem.setSize(preferredSize);
                }
*/            }
        } finally {
            // If the cool bar was locked, then set it back to locked
            if ((locked) && (coolBar != null)) {
                coolBar.setLocked(true);
            }
        }
    }

    public void fill(SCoolBar coolBar, int index) {
        if (checkDisposed()) {
            return;
        }

        if (coolItem == null && coolBar != null) {
            Control oldToolBar = null;
            Control toolBar = null;
            if (toolBarManager instanceof ToolBarManager) {
                oldToolBar = ((ToolBarManager)toolBarManager).getControl();
                toolBar = ((ToolBarManager)toolBarManager).createControl(coolBar);
            } else if (toolBarManager instanceof SToolBarManager2) {
                oldToolBar = ((SToolBarManager2)toolBarManager).getControl();
                toolBar = ((SToolBarManager2)toolBarManager).createControl2(coolBar);
            }
            if ((oldToolBar != null) && (oldToolBar.equals(toolBar))) {
                // We are using an old tool bar, so we need to update.
                toolBarManager.update(true);
            }

            // Do not create a coolItem if the toolbar is empty
            if (toolBar instanceof ToolBar) {
                if (((ToolBar)toolBar).getItemCount() < 1)
                    return;
            } else if (toolBar instanceof SToolBar) {
                if (((SToolBar)toolBar).getItemCount() < 1)
                    return;
            }
            int flags = SWT.DROP_DOWN;
            if (index >= 0) {
                coolItem = new SCoolItem(coolBar, flags, index);
            } else {
                coolItem = new SCoolItem(coolBar, flags);
            }
            // sets the back reference
            coolItem.setData(this);
            // Add the toolbar to the CoolItem widget
            coolItem.setControl(toolBar);

            // Handle Context Menu
            // ToolBarManager.createControl can actually return a pre-existing control.
            // Only add the listener if the toolbar was newly created (bug 62097).
            if (oldToolBar != toolBar) {
	            toolBar.addListener(SWT.MenuDetect, new Listener() {
	
	                public void handleEvent(Event event) {
	                    // if the toolbar does not have its own context menu then
	                    // handle the event
	                    if (toolBarManager instanceof ToolBarManager) {
		                    if (((ToolBarManager)toolBarManager).getContextMenuManager() == null) {
		                        handleContextMenu(event);
		                    }
	                    } else if (toolBarManager instanceof SToolBarManager2) {
		                    if (((SToolBarManager2)toolBarManager).getContextMenuManager() == null) {
		                        handleContextMenu(event);
		                    }
	                    }
	                }
	            });
            }

            // Handle for chevron clicking
            if (getUseChevron()) {
                // Chevron Support
                coolItem.addSelectionListener(new SelectionAdapter() {

                    public void widgetSelected(SelectionEvent event) {
                        if (event.detail == SWT.ARROW) {
                            handleChevron(event);
                        }
                    }
                });
            }

            // Handle for disposal
            coolItem.addDisposeListener(new DisposeListener() {

                public void widgetDisposed(DisposeEvent event) {
                    handleWidgetDispose(event);
                }
            });

            // Sets the size of the coolItem
            updateSize(true);
        }
    }

	public void fill(SToolBar parent, int index) {
		// Do nothing
	}

}




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.FontData;
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.Display;

public class HannoverGlobalToolBarSkin implements Skin {
	
	// border colors
	Color borderTopColor = new Color(null, 255, 255, 255);
	Color borderBottomColor = new Color(null, 144, 161, 181);
	Color borderColor = new Color(null, 132, 132, 132);
	Color borderLeftRightColor = new Color(null, 255, 255, 255);
	Color itemBorderColor = new Color(null, 180, 180, 180);
	
	// 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);
	
	Color separatorColor = new Color(null, 168, 181, 197);
	Font textFont;
	
	public HannoverGlobalToolBarSkin() {
		super();
		FontData fd = new FontData("Tahoma", 9, SWT.NORMAL);
		textFont = new Font(null, fd);
	}

	/**
	 * @deprecated use getRect() instead.
	 */
	public Rectangle getInsets(int type, int state) {
		return null;
	}

	/**
	 * @deprecated use getRect() instead.
	 */
	public Rectangle getMargins(int type, int state) {
		return new Rectangle(0,0,0,0);
	}

	public Font getFont(int type, int state) {
		return textFont;
	}

	public Point getSize(int type, int state) {
		if (type == Skin.TYPE_ITEM_MIN_MAX_HEIGHT) {
			return new Point(SWT.DEFAULT, SWT.DEFAULT);
		} else if (type == Skin.TYPE_ITEM_MIN_MAX_WIDTHS) {
			return new Point(SWT.DEFAULT, SWT.DEFAULT);
		} else if (type == Skin.TYPE_DECORATION_ARROW) {
			return new Point(5, 3);
		} else if (type == Skin.TYPE_DECORATION_SEPARATOR) {
			return new Point(3, SWT.DEFAULT);
		} else if (type == Skin.TYPE_ITEM_ICON_SIZE) {
			return new Point(20, 20);
		}
		return null;
	}

	public Rectangle getRect(int type, int state) {
		if (type == Skin.TYPE_ITEM_AREA_INSETS) {
			/*
			 * x - leading space before first item.
			 * y - space between top of toolbar and top of item
			 * width - trailing space after last item
			 * height - space between bottom of toolbar and bottom of item.
			 */
			return new Rectangle(1, 3, 1, 3);
		} else if (type == Skin.TYPE_ITEM_AREA_MARGINS) {
			/*
			 * x - space between items
			 * y - undefined
			 * width - undefined;
			 * height - undefined;
			 */
			return new Rectangle(5, 0, 0, 0);
		} else if (type == Skin.TYPE_ITEM_MARGINS) {
			/*
			 * x = horizontal space between image and text.
			 * y = horizontal space between image or text and hinky.
			 * width = undefined 
			 * height = undefined 
			 */
			return new Rectangle(3, 2, 0, 0);
		} else if (type == Skin.TYPE_ITEM_INSETS) {
			/* 
			 * x = left edge of tool item to left edge of image or text
			 * y = top edge of tool item to top edge of image or text
			 * width = right edge of last internal element and right edge of tool item.
			 * height = bottom edge of last internal element and bottom edge of tool item.
			 */
			return new Rectangle(0, 0, 0, 0);
		}
		
		return new Rectangle(0, 0, 0, 0);
	}

	public void drawBorder(GC gc, Rectangle rect, SWidget widget, int type, int state) {
		if (type == Skin.TYPE_BORDER) {
			// top edge
			gc.setForeground(borderTopColor);
			gc.drawLine(rect.x, rect.y, rect.x+rect.width, rect.y);
			// bottom edge
			gc.setForeground(borderBottomColor);
			gc.drawLine(rect.x, rect.y+rect.height-1, rect.x+rect.width, rect.y+rect.height-1);
		}
		
	}

	public void drawBackground(GC gc, Rectangle rect, SWidget widget, int type, int state) {
		if (type == Skin.TYPE_BACKGROUND) {
			if (widget instanceof Control) {
				gc.setForeground(backgroundTopColor); 
				gc.setBackground(backgroundBottomColor); 
				gc.fillGradientRectangle(rect.x, rect.y-1, rect.width, rect.height+1, true);
			}
		}
	}

	public void drawDecoration(GC gc, Rectangle rect, SWidget widget, int type, int state) {
		if (type == Skin.TYPE_DECORATION_ARROW) {
			int delta = 0;
			if ((state & Skin.PRESSED) == Skin.PRESSED) {
				delta = 1;
			}
			gc.setForeground(arrowColor);
			gc.drawLine(rect.x + delta, rect.y + delta, rect.x + rect.width -1 + delta, rect.y + delta);
			gc.drawLine(rect.x + 1 + delta, rect.y + 1 + delta, rect.x + rect.width -2 + delta, rect.y + 1 + delta);
			gc.drawPoint(rect.x + 2 + delta, rect.y + 2 + delta);
		} else if (type == Skin.TYPE_DECORATION_SEPARATOR) {
			gc.setForeground(separatorColor);
			gc.drawLine(rect.x + (rect.width /2), rect.y, rect.x + (rect.width /2), rect.y + rect.height - 1);
		}
	}

	public void drawText(GC gc, Rectangle rect, String text, int style, SWidget widget, int type, int state) {
		int delta = 0;
		if ((state & Skin.PRESSED) == Skin.PRESSED) {
			delta = 1;
			gc.setForeground(textColor);
		} 
		else if ((state & Skin.HOVER) == Skin.HOVER) {
			gc.setForeground(textColor);
		} 
		else {
			gc.setForeground(textColor);
		}
		gc.drawText(text, rect.x + delta, rect.y + delta, style);
	}

	public void drawImage(GC gc, Rectangle rect, Image image, SWidget widget, int type, int state) {
		Rectangle imageRect = image.getBounds();
		gc.drawImage(image, imageRect.x, imageRect.y, imageRect.width, imageRect.height,
					 rect.x, rect.y, imageRect.width, imageRect.height);
	}

	public void dispose() {
		if (borderColor != null && borderColor.isDisposed() == false)
			borderColor.dispose();
		if (itemBorderColor != null && itemBorderColor.isDisposed() == false)
			itemBorderColor.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();
		
		if (separatorColor != null) {
			separatorColor.dispose();
		}
		
		if (textFont != null) {
			textFont.dispose();
			textFont = null;
		}
	}
}




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 (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.examples.presentation.customtoolbar.widgets;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.ExternalActionManager;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IContributionManagerOverrides;
import org.eclipse.jface.action.IMenuCreator;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.resource.LocalResourceManager;
import org.eclipse.jface.resource.ResourceManager;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.Policy;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.CoolBar;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.Widget;

/**
 * A contribution item which delegates to an action.
 * <p>
 * This class may be instantiated; it is not intended to be subclassed.
 * </p>
 */
public class SActionContributionItem extends ActionContributionItem implements ISContributionItem {

	ActionContributionItem actionContributionItem = null;

	private boolean isSeparator;
	
	/**
     * The listener for changes to the text of the action contributed by an
     * external source.
     */
    private final IPropertyChangeListener actionTextListener = new IPropertyChangeListener() {

        /**
         * @see IPropertyChangeListener#propertyChange(PropertyChangeEvent)
         */
        public void propertyChange(PropertyChangeEvent event) {
            update(event.getProperty());
        }
    };

    /**
     * Remembers all images in use by this contribution item
     */
    private LocalResourceManager imageManager;

    private boolean isWidgetSet = false;
    
    /**
     * Listener for SWT tool item widget events.
     */
    private Listener toolItemListener;
    
    /**
     * The widget created for this item; <code>null</code>
     * before creation and after disposal.
     */
    private Widget widget = null;
    
    /**
     * Listener for action property change notifications.
     */
    private final IPropertyChangeListener propertyListener = new IPropertyChangeListener() {
        public void propertyChange(PropertyChangeEvent event) {
            actionPropertyChange(event);
        }
    };
	
	public SActionContributionItem() {
		this(new ActionContributionItem(new Action() {public void run() {}}));
		this.isSeparator = true;
	}
	
    /**
     * @param action
     */
    public SActionContributionItem(IAction action) {
		this(new ActionContributionItem(action));
	}
    
    /**
     * 
     * @param action
     */
    public SActionContributionItem(ActionContributionItem actionContributionItem) {
		super(actionContributionItem.getAction());
		this.actionContributionItem = actionContributionItem;
    }

	public boolean isSeparator() {
		return isSeparator;
	}

    /**
     * Handles a property change event on the action (forwarded by nested listener).
     */
    private void actionPropertyChange(final PropertyChangeEvent e) {
        // This code should be removed. Avoid using free asyncExec

        if (isVisible() && widget != null) {
            Display display = widget.getDisplay();
            if (display.getThread() == Thread.currentThread()) {
                update(e.getProperty());
            } else {
                display.asyncExec(new Runnable() {
                    public void run() {
                        update(e.getProperty());
                    }
                });
            }

        }
    }
	
    /**
     * Dispose any images allocated for this contribution item
     */
    private void disposeOldImages() {
        if (imageManager != null) {
            imageManager.dispose();
            imageManager = null;
        }
    }
    
	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ActionContributionItem#fill(org.eclipse.swt.widgets.Composite)
	 */
	public void fill(Composite parent) {
		isWidgetSet = true;
		actionContributionItem.fill(parent);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ContributionItem#fill(org.eclipse.swt.widgets.CoolBar, int)
	 */
	public void fill(CoolBar parent, int index) {
		if (widget instanceof SToolItem)
			return;
		isWidgetSet = true;
		actionContributionItem.fill(parent, index);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ActionContributionItem#fill(org.eclipse.swt.widgets.Menu, int)
	 */
	public void fill(Menu parent, int index) {
		if (widget instanceof SToolItem)
			return;
		isWidgetSet = true;
		actionContributionItem.fill(parent, index);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ActionContributionItem#fill(org.eclipse.swt.widgets.ToolBar, int)
	 */
	public void fill(ToolBar parent, int index) {
		if (widget instanceof SToolItem)
			return;
		isWidgetSet = true;
		actionContributionItem.fill(parent, index);
	}
    
	public void fill(SCoolBar parent, int index) {
		// do nothing
	}

	public void fill(SToolBar parent, int index) {
        if (isWidgetSet == false && widget == null && parent != null) {
            int flags = SWT.PUSH;
            IAction action = getAction();
            if (action != null) {
				if (isSeparator) {
					flags = SWT.SEPARATOR;
				} else {
	                int style = action.getStyle();
	                if (style == IAction.AS_CHECK_BOX)
	                    flags = SWT.CHECK;
	                else if (style == IAction.AS_RADIO_BUTTON)
	                    flags = SWT.RADIO;
	                else if (style == IAction.AS_DROP_DOWN_MENU)
	                    flags = SWT.DROP_DOWN;
				}
            }

            Item ti = null;
            if (index >= 0)
                ti = new SToolItem(parent, flags, index);
            else
                ti = new SToolItem(parent, flags);
            ti.setData(this);
            ti.addListener(SWT.Selection, getToolItemListener());
            ti.addListener(SWT.Dispose, getToolItemListener());

            widget = ti;

            update(null);

            // Attach some extra listeners.
            action.addPropertyChangeListener(propertyListener);
            if (action != null) {
                String commandId = action.getActionDefinitionId();
                ExternalActionManager.ICallback callback = ExternalActionManager
                        .getInstance().getCallback();

                if ((callback != null) && (commandId != null)) {
                    callback.addPropertyChangeListener(commandId,
                            actionTextListener);
                }
            }
        }
	}
	
    private Listener getToolItemListener() {
        if (toolItemListener == null) {
            toolItemListener = new Listener() {
                public void handleEvent(Event event) {
                    switch (event.type) {
                    case SWT.Dispose:
                        handleWidgetDispose(event);
                        break;
                    case SWT.Selection:
                        Widget ew = event.widget;
                        if (ew != null) {
                            handleWidgetSelection(event, ((SToolItem) ew)
                                    .getSelection());
                        }
                        break;
                    }
                }
            };
        }
        return toolItemListener;
    }
    
    /**
     * Handles a widget dispose event for the widget corresponding to this item.
     */
    private void handleWidgetDispose(Event e) {
        // Check if our widget is the one being disposed.
        if (e.widget == widget) {
            IAction action = getAction();
            // Dispose of the menu creator.
            if (action.getStyle() == IAction.AS_DROP_DOWN_MENU) {
                IMenuCreator mc = action.getMenuCreator();
                if (mc != null) {
                    mc.dispose();
                }
            }

            // Unhook all of the listeners.
            action.removePropertyChangeListener(propertyListener);
            if (action != null) {
                String commandId = action.getActionDefinitionId();
                ExternalActionManager.ICallback callback = ExternalActionManager
                        .getInstance().getCallback();

                if ((callback != null) && (commandId != null)) {
                    callback.removePropertyChangeListener(commandId,
                            actionTextListener);
                }
            }

            // Clear the widget field.
            widget = null;
            
            disposeOldImages();
        }
    }

    /**
     * Handles a widget selection event.
     */
    private void handleWidgetSelection(Event e, boolean selection) {

        Widget item = e.widget;
        if (item != null) {
            int style = item.getStyle();
            IAction action = getAction();

            if ((style & (SWT.TOGGLE | SWT.CHECK)) != 0) {
                if (action.getStyle() == IAction.AS_CHECK_BOX) {
                    action.setChecked(selection);
                }
            } else if ((style & SWT.RADIO) != 0) {
                if (action.getStyle() == IAction.AS_RADIO_BUTTON) {
                    action.setChecked(selection);
                }
            } else if ((style & SWT.DROP_DOWN) != 0) {
                if (e.detail == 4) { // on drop-down button
                    if (action.getStyle() == IAction.AS_DROP_DOWN_MENU) {
                        IMenuCreator mc = action.getMenuCreator();
                        SToolItem ti = (SToolItem) item;
                        // we create the menu as a sub-menu of "dummy" so that we can use
                        // it in a cascading menu too.
                        // If created on a SWT control we would get an SWT error...
                        //Menu dummy= new Menu(ti.getParent());
                        //Menu m= mc.getMenu(dummy);
                        //dummy.dispose();
                        if (mc != null) {
                            Menu m = mc.getMenu(ti.getParent());
                            if (m != null) {
                                // position the menu below the drop down item
                                Rectangle b = ti.getBounds();
                                Point p = ti.getParent().toDisplay(
                                        new Point(b.x, b.y + b.height));
                                m.setLocation(p.x, p.y); // waiting for SWT 0.42
                                m.setVisible(true);
                                return; // we don't fire the action
                            }
                        }
                    }
                }
            }
            // Ensure action is enabled first.
            // See 1GAN3M6: ITPUI:WINNT - Any IAction in the workbench can be executed while disabled.
            if (action.isEnabled()) {
                boolean trace = Policy.TRACE_ACTIONS;

                long ms = System.currentTimeMillis();
                if (trace)
                    System.out.println("Running action: " + action.getText()); //$NON-NLS-1$

                action.runWithEvent(e);

                if (trace)
                    System.out.println((System.currentTimeMillis() - ms)
                            + " ms to run action: " + action.getText()); //$NON-NLS-1$
            }
        }
    }
    
    /**
     * Returns whether the given action has any images.
     * 
     * @param actionToCheck the action
     * @return <code>true</code> if the action has any images, <code>false</code> if not
     */
    private boolean hasImages(IAction actionToCheck) {
        return actionToCheck.getImageDescriptor() != null
                || actionToCheck.getHoverImageDescriptor() != null
                || actionToCheck.getDisabledImageDescriptor() != null;
    }
    
    /**
     * Synchronizes the UI with the given property.
     *
     * @param propertyName the name of the property, or <code>null</code> meaning all applicable
     *   properties 
     */
    public void update(String propertyName) {
    	
        if (widget instanceof SToolItem) {
        	
            // determine what to do
        	IAction action = getAction();
            boolean textChanged = propertyName == null
                    || propertyName.equals(IAction.TEXT);
            boolean imageChanged = propertyName == null
                    || propertyName.equals(IAction.IMAGE);
            boolean tooltipTextChanged = propertyName == null
                    || propertyName.equals(IAction.TOOL_TIP_TEXT);
            boolean enableStateChanged = propertyName == null
                    || propertyName.equals(IAction.ENABLED)
                    || propertyName
                            .equals(IContributionManagerOverrides.P_ENABLED);
            boolean checkChanged = (action.getStyle() == IAction.AS_CHECK_BOX || action
                    .getStyle() == IAction.AS_RADIO_BUTTON)
                    && (propertyName == null || propertyName
                            .equals(IAction.CHECKED));

            if (widget instanceof SToolItem) {
                SToolItem ti = (SToolItem) widget;
                String text = action.getText();
                // the set text is shown only if there is no image or if forced by MODE_FORCE_TEXT
                boolean showText = text != null
                        && ((getMode() & MODE_FORCE_TEXT) != 0 || !hasImages(action));

                // only do the trimming if the text will be used
                if (showText && text != null) {
                    text = Action.removeAcceleratorText(text);
                    text = Action.removeMnemonics(text);
                }

                if (textChanged) {
                    String textToSet = showText ? text : ""; //$NON-NLS-1$
                    boolean rightStyle = (ti.getParent().getStyle() & SWT.RIGHT) != 0;
                    if (rightStyle || !ti.getText().equals(textToSet)) {
                        // In addition to being required to update the text if it
                        // gets nulled out in the action, this is also a workaround 
                        // for bug 50151: Using SWT.RIGHT on a ToolBar leaves blank space
                        ti.setText(textToSet);
                    }
                }

                if (imageChanged) {
                    // only substitute a missing image if it has no text
                    updateImages(!showText);
                }

                if (tooltipTextChanged || textChanged) {
                    String toolTip = action.getToolTipText();
                    // if the text is showing, then only set the tooltip if different
                    if (!showText || toolTip != null && !toolTip.equals(text)) {
                        ti.setToolTipText(toolTip);
                    } else {
                        ti.setToolTipText(null);
                    }
                }

/* FIXME TFS -- Need to keep the buttons enabled for now so they actually look like they work.
 * 			[Terry Smith 12/9/2005].
 *                 if (enableStateChanged) {
                    boolean shouldBeEnabled = action.isEnabled()
                            && isEnabledAllowed();

                    if (ti.getEnabled() != shouldBeEnabled)
                       ti.setEnabled(shouldBeEnabled);
                }
*/
                if (checkChanged) {
                    boolean bv = action.isChecked();

                    if (ti.getSelection() != bv)
                        ti.setSelection(bv);
                }
                return;
            }
        } else {
       		actionContributionItem.update(propertyName);
        }
    }

    /**
     * Updates the images for this action.
     *
     * @param forceImage <code>true</code> if some form of image is compulsory,
     *  and <code>false</code> if it is acceptable for this item to have no image
     * @return <code>true</code> if there are images for this action, <code>false</code> if not
     */
    private boolean updateImages(boolean forceImage) {

        ResourceManager parentResourceManager = JFaceResources.getResources();
        
        if (widget instanceof SToolItem) {
        	IAction action = getAction();
            if (getUseColorIconsInToolbars()) {
                ImageDescriptor imageDesc = action.getImageDescriptor();
                ImageDescriptor hoverImageDesc = action.getHoverImageDescriptor();
                ImageDescriptor disabledImageDesc = action.getDisabledImageDescriptor();
                ImageDescriptor pressedImageDesc = null;
                                
                if (imageDesc == null && forceImage) {
                    imageDesc = ImageDescriptor.getMissingImageDescriptor();
                }
                
//                if (disabledImageDesc == null && imageDesc != null) {
//               	disabledImageDesc = ImageDescriptor.createWithFlags(imageDesc, SWT.IMAGE_GRAY); 
//                }

                LocalResourceManager localManager = new LocalResourceManager(parentResourceManager);
                
                // performance: more efficient in SWT to set disabled and hot image before regular image
                ((SToolItem) widget).setDisabledImage(disabledImageDesc != null ? localManager.createImageWithDefault(disabledImageDesc) : null);
                ((SToolItem) widget).setHotImage(hoverImageDesc != null ? localManager.createImageWithDefault(hoverImageDesc) : null);
                ((SToolItem) widget).setImage(imageDesc != null ? localManager.createImageWithDefault(imageDesc) : null);
                disposeOldImages();
                imageManager = localManager;

                return imageDesc != null;
/* TODO TFS Old Crap             	
                ImageDescriptor image = action.getHoverImageDescriptor();
                if (image == null) {
                    image = action.getImageDescriptor();
                }
                ImageDescriptor disabledImage = action.getDisabledImageDescriptor();

                // Make sure there is a valid image.
                if (image == null && forceImage) {
                    image = ImageDescriptor.getMissingImageDescriptor();
                }
        
                LocalResourceManager localManager = new LocalResourceManager(parentResourceManager);
                
                // performance: more efficient in SWT to set disabled and hot image before regular image
                ((SToolItem) widget).setDisabledImage(disabledImage == null ? null : localManager.createImageWithDefault(disabledImage));
                ((SToolItem) widget).setImage(image == null ? null : localManager.createImageWithDefault(image));

                disposeOldImages();
                imageManager = localManager;
                
                return image != null;
*/
            }
            ImageDescriptor image = action.getImageDescriptor();
            ImageDescriptor hoverImage = action
                    .getHoverImageDescriptor();
            ImageDescriptor disabledImage = action
                    .getDisabledImageDescriptor();

            // If there is no regular image, but there is a hover image,
            // convert the hover image to gray and use it as the regular image.
            if (image == null && hoverImage != null) {
                image = ImageDescriptor.createWithFlags(action.getHoverImageDescriptor(), SWT.IMAGE_GRAY); 
            } else {
                // If there is no hover image, use the regular image as the hover image,
                // and convert the regular image to gray
                if (hoverImage == null && image != null) {
                    hoverImage = image;
                    image = ImageDescriptor.createWithFlags(action.getImageDescriptor(), SWT.IMAGE_GRAY);
                }
            }

            // Make sure there is a valid image.
            if (hoverImage == null && image == null && forceImage) {
                image = ImageDescriptor.getMissingImageDescriptor();
            }

            // Create a local resource manager to remember the images we've allocated for this tool item
            LocalResourceManager localManager = new LocalResourceManager(parentResourceManager);
            
            // performance: more efficient in SWT to set disabled and hot image before regular image
            ((SToolItem) widget).setDisabledImage(disabledImage == null? null : localManager.createImageWithDefault(disabledImage));
            ((SToolItem) widget).setHotImage(hoverImage == null? null : localManager.createImageWithDefault(hoverImage));
            ((SToolItem) widget).setImage(image == null? null : localManager.createImageWithDefault(image));

            // Now that we're no longer referencing the old images, clear them out.
            disposeOldImages();
            imageManager = localManager;
            
            return image != null;
        }
        return false;
    }

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ActionContributionItem#equals(java.lang.Object)
	 */
	public boolean equals(Object o) {
		
        if (!(o instanceof ActionContributionItem)) {
            return false;
        }
        return actionContributionItem.getAction().equals(((ActionContributionItem) o).getAction());
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ActionContributionItem#getAction()
	 */
	public IAction getAction() {
		return actionContributionItem.getAction();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ActionContributionItem#getMode()
	 */
	public int getMode() {
		return actionContributionItem.getMode();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ActionContributionItem#hashCode()
	 */
	public int hashCode() {
		return actionContributionItem.hashCode();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ActionContributionItem#isDynamic()
	 */
	public boolean isDynamic() {
		return actionContributionItem.isDynamic();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ActionContributionItem#isEnabled()
	 */
	public boolean isEnabled() {
		return actionContributionItem.isEnabled();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ActionContributionItem#isEnabledAllowed()
	 */
	protected boolean isEnabledAllowed() {
        if (actionContributionItem.getParent() == null)
            return true;
        Boolean value = actionContributionItem.getParent().getOverrides().getEnabled(this);
        return (value == null) ? true : value.booleanValue();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ActionContributionItem#isVisible()
	 */
	public boolean isVisible() {
		return actionContributionItem.isVisible();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.ActionContributionItem#setMode(int)
	 */
	public void setMode(int mode) {
		actionContributionItem.setMode(mode);
	}
}




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

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
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.Item;

public class SCoolItem extends Item {
	Control control;
	int preferredHeight = -1;
	int preferredWidth = -1;
	int width = -1;
	int height = -1;
	//int hIndent = 8;
	int hIndent = 0;
	//int vIndent = 8;
	int vIndent = 0;
	Rectangle itemBounds = new Rectangle(0, 0, 0, 0);
	boolean wrap = false;  // true if the item should be moved onto the next row.
	boolean alignment = false;  // true if the item and (the items following the items) should be right-aligned. 
	Image arrowImage = null;
	private SCoolBar parent = null;
	
	public SCoolItem(SCoolBar parent, int style) {
		this(parent, style, parent.getItemCount());
	}

	public SCoolItem(SCoolBar parent, int style, int index) {
		super(parent, style);
		this.parent = parent;
		parent.createItem (this, index);
	}

	public void addSelectionListener(SelectionAdapter adapter) {
		// TODO Auto-generated method stub
	}

	public Point computeSize(int wHint, int hHint) {
		return computeSize(wHint, hHint, true);
	}
	
	public Point computeSize(int wHint, int hHint, boolean changed) {
		checkWidget();

		Skin skin = parent.getSkin();
		int width = wHint;
		int height = hHint;
		
		if (control != null && (width == SWT.DEFAULT || height == SWT.DEFAULT)) {
			Point size = control.computeSize(width, height);
			if (width == SWT.DEFAULT) {
				width = size.x;
			}
			if (height == SWT.DEFAULT) {
				height = size.y;
			}
			
			size = null;
			if (skin != null) {
				size = skin.getSize(Skin.TYPE_DECORATION_GRIPPER, Skin.NORMAL);
			} 
			if (size == null) {
				size = new Point(0, 0);
			}
			if ((parent.getStyle() & SWT.VERTICAL) == SWT.VERTICAL) {
				height += size.x;
				if (size.y != SWT.DEFAULT) {
					width = Math.max(width, size.y);
				}
			} else {
				width += size.x;
				if (size.y != SWT.DEFAULT) {
					height = Math.max(height, size.y);
				}
			}
		} else {
			Point minMax = null;
			if (skin != null) {
				minMax = skin.getSize(Skin.TYPE_ITEM_MIN_MAX_HEIGHT, Skin.NORMAL);
			} 
			if (minMax == null) {
				minMax = new Point(SWT.DEFAULT, SWT.DEFAULT);
			}
			
			if (height == SWT.DEFAULT) {
				if (minMax.x != SWT.DEFAULT) {
					height = minMax.x;
				} else {
					height = 0;
				}
			}

			minMax = null;
			if (skin != null) {
				minMax = skin.getSize(Skin.TYPE_ITEM_MIN_MAX_HEIGHT, Skin.NORMAL);
			} 
			if (minMax == null) {
				minMax = new Point(SWT.DEFAULT, SWT.DEFAULT);
			}
			if (width == SWT.DEFAULT) {
				if (minMax.x != SWT.DEFAULT) {
					width = minMax.x;
				} else {
					width = 0;
				}
			}
		}

		Rectangle borders = null;
		if (skin != null) {
			borders = skin.getRect(Skin.TYPE_ITEM_BORDER, Skin.NORMAL);
		} 
		if (borders == null) {
			borders = new Rectangle(0, 0, 0, 0);
		}
		
		width += borders.x + borders.width;
		height += borders.y + borders.height;
		
		return new Point(width, height);
	}

	public Rectangle getBounds() {
		return itemBounds;
	}
	
	public Control getControl() {
		return control;
	}

	public Control getParent() {
		return this.parent;
	}
	
	public Point getPreferredSize() {
		checkWidget();
		int width = preferredWidth;
		int height = preferredHeight;
		if (control != null && (width == SWT.DEFAULT || height == SWT.DEFAULT)) {
			Point size = control.computeSize(width, height);
			if (width == SWT.DEFAULT) {
				width = size.x;
			}
			if (height == SWT.DEFAULT) {
				height = size.y;
			}
			
			Skin skin = parent.getSkin();
			size = null;
			if (skin != null) {
				size = skin.getSize(Skin.TYPE_DECORATION_GRIPPER, Skin.NORMAL);
			} 
			if (size == null) {
				size = new Point(0, 0);
			}
			if ((parent.getStyle() & SWT.VERTICAL) == SWT.VERTICAL) {
				height += size.x;
				if (size.y != SWT.DEFAULT) {
					width = Math.max(width, size.y);
				}
			} else {
				width += size.x;
				if (size.y != SWT.DEFAULT) {
					height = Math.max(height, size.y);
				}
			}

			Rectangle borders = null;
			if (skin != null) {
				borders = skin.getRect(Skin.TYPE_ITEM_BORDER, Skin.NORMAL);
			} 
			if (borders == null) {
				borders = new Rectangle(0, 0, 0, 0);
			}
			
			width += borders.x + borders.width;
			height += borders.y + borders.height;
		}
		
		return new Point(width, height);
	}

	public Point getSize() {
		checkWidget();
		if (itemBounds == null)
			itemBounds = new Rectangle(0,0,0,0);
		return new Point(itemBounds.width, itemBounds.height);
	}
	
	public void setBounds(int x, int y, int width, int height) {
		itemBounds.x = x;
		itemBounds.y = y;
		itemBounds.width = width;
		itemBounds.height = height;

		if (control != null) {
			Skin skin = parent.getSkin();
			Point size = null;
			if (skin != null) {
				size = skin.getSize(Skin.TYPE_DECORATION_GRIPPER, Skin.NORMAL);
			} 
			if (size == null) {
				size = new Point(0, 0);
			}

			if (width > size.x) {
				width -= size.x;
			} else {
				width = size.x;
			}

			Rectangle borders = null;
			if (skin != null) {
				borders = skin.getRect(Skin.TYPE_ITEM_BORDER, Skin.NORMAL);
			} 
			if (borders == null) {
				borders = new Rectangle(0, 0, 0, 0);
			}
			
			width -= (borders.x + borders.width);
			height -= (borders.y + borders.height);

			Rectangle controlRect = new Rectangle(itemBounds.x + size.x, y, width - size.x, height);
			control.setBounds(controlRect);
		}
	}

	public void setControl(Control control) {
		if (control != null) {
			if (control.isDisposed()) 
				SWT.error (SWT.ERROR_INVALID_ARGUMENT);
			if (control.getParent() != parent) 
				SWT.error (SWT.ERROR_INVALID_PARENT);
		}
		this.control = control;
		
		parent.layout();
	}
	
	public void setMinimumSize(int width, int height) {
		// TODO Auto-generated method stub
	}
	
	public void setPreferredSize(Point preferredSize) {
		setPreferredSize(preferredSize.x, preferredSize.y);
	}

	public void setPreferredSize (int width, int height) {
		preferredWidth = width;
		preferredHeight = height;
	}

	public void setSize(int width, int height) {
		checkWidget();
		itemBounds.width = width;
		itemBounds.height = height;
		
		if (preferredWidth == -1)
			preferredWidth = width;
		if (preferredHeight == -1)
			preferredHeight = height;
		
//		if (control != null) {
//			control.setSize(width - SCoolBar.GRIPPER_AREA_WIDTH, height);
//		}
//	TFS - parent.layout()?
	}
	
	public void setSize(Point pt) {
		checkWidget();
		if (pt == null) {
			SWT.error (SWT.ERROR_NULL_ARGUMENT);
		}
		setSize(pt.x, pt.y);
	}

	public void paint(GC gc, int state) {
		Skin skin = parent.getSkin();

		if (skin == null) {
			return;
		}

		skin.drawBackground(gc, itemBounds, parent, Skin.TYPE_ITEM_BACKGROUND, state);
		skin.drawBorder(gc, itemBounds, parent, Skin.TYPE_ITEM_BORDER, state);

		Point size = skin.getSize(Skin.TYPE_DECORATION_GRIPPER, state);
		if (size == null) {
			return;
		}

		if ((parent.getStyle() & SWT.VERTICAL) == SWT.VERTICAL) {
			if (size.y == SWT.DEFAULT) {
				size.y = 0;
			}
			if (size.x == SWT.DEFAULT) {
				size.x = itemBounds.width;
			}
			
		} else {
			if (size.x == SWT.DEFAULT) {
				size.x = 0;
			}
			if (size.y == SWT.DEFAULT) {
				size.y = itemBounds.height;
			}
		}
		
		if (size.x == 0 || size.y == 0) {
			return;
		}
		
		Rectangle gripperRect = new Rectangle(itemBounds.x, itemBounds.y, size.x, size.y);
		skin.drawDecoration(gc, gripperRect, parent, Skin.TYPE_DECORATION_GRIPPER, state);

	}

}




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

import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.internal.provisional.action.ICoolBarManager2;
import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
import org.eclipse.jface.internal.provisional.action.IToolBarManager2;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.examples.presentation.customtoolbar.widgets.SCoolBarManager;
import org.eclipse.ui.examples.presentation.customtoolbar.widgets.SToolBarContributionItem2;
import org.eclipse.ui.examples.presentation.customtoolbar.widgets.SToolBarManager2;
import org.eclipse.ui.internal.provisional.presentations.IActionBarPresentationFactory;
import org.eclipse.ui.presentations.WorkbenchPresentationFactory;

/**
 * Demonstrates how to customize the tool bars in an RCP application.
 *
 */
public class CustomToolBarPresentationFactory extends WorkbenchPresentationFactory implements IActionBarPresentationFactory {

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createCoolBarManager()
	 */
	public ICoolBarManager2 createCoolBarManager() {
		SCoolBarManager coolBarManager = new SCoolBarManager(SWT.FLAT);
		return coolBarManager;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createToolBarManager()
	 */
	public IToolBarManager2 createToolBarManager() {
		SToolBarManager2 toolBarManager = new SToolBarManager2(SWT.FLAT);
		return toolBarManager;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createViewToolBarManager()
	 */
	public IToolBarManager2 createViewToolBarManager() {
		SToolBarManager2 toolBarManager = new SToolBarManager2(SWT.FLAT);
		return toolBarManager;
	}
	
    /* (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 SToolBarContributionItem2(toolBarManager, id);
    }

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createCoolBarControl(org.eclipse.jface.action.ICoolBarManager, org.eclipse.swt.widgets.Composite)
	 */
	public Control createCoolBarControl(ICoolBarManager2 coolBarManager, Composite parent) {
		return coolBarManager.createControl2(parent);
	}

	/* (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#createViewToolBarControl(org.eclipse.jface.action.IToolBarManager2, org.eclipse.swt.widgets.Composite)
	 */
	public Control createViewToolBarControl(IToolBarManager2 toolBarManager, Composite parent) {
		return toolBarManager.createControl2(parent);
	}		
	
}




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.internal.provisional.action.ICoolBarManager2;
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 ICoolBarManager2 {

    /**
     * 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$
    //                        + 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;
	}
}




/*
*	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 java.util.ArrayList;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.PaletteData;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;

public class SToolBar extends SWidget {
	
	private ArrayList items = new ArrayList();
	private SToolItem hoverItem;
	private SToolItem mouseDownItem;
	
	private Point offscreenImageSize = new Point(-1, -1);
	private Image offscreenImage = null;
	private GC offscreenGc = null;
	
	static final int ITEM_INSET_TOP = 3;
	static final int ITEM_INSET_BOTTOM = 4;
	static final int LEFT_MARGIN = 6;
	static final int SHADOW_SIZE = 4;
	
	/**
	 * @param parent
	 * @param style
	 */
	public SToolBar(Composite parent, int style) {
		super(parent, checkStyle(style));

		// Add all listeners
		Listener listener = new Listener() {
			public void handleEvent(Event event) {
				switch (event.type) {
					case SWT.Dispose:          onDispose(); break;
					case SWT.FocusIn:          onFocus(event);	break;
					case SWT.FocusOut:         onFocus(event);	break;
					case SWT.MouseDoubleClick: onMouseDoubleClick(event); break;
					case SWT.MouseDown:        onMouseDown(event);	break;
					case SWT.MouseExit:        onMouseExit(event);	break;
					case SWT.MouseHover:       onMouseHover(event); break;
					case SWT.MouseMove:        onMouseMove(event); break;
					case SWT.MouseUp:          onMouseUp(event); break;
					case SWT.Paint:            onPaint(event);	break;
					case SWT.Traverse:         onTraverse(event); break;
				}
			}
		};

		int[] toolBarEvents = new int[]{

			SWT.Dispose,
			SWT.FocusIn, 
			SWT.FocusOut, 
			SWT.KeyDown,
			SWT.MouseDoubleClick, 
			SWT.MouseDown,
			SWT.MouseExit,
			SWT.MouseHover, 
			SWT.MouseMove,
			SWT.MouseUp,
			SWT.Paint,
			SWT.Resize,  
			SWT.Traverse
		};
		for (int i = 0; i < toolBarEvents.length; i++) {
			addListener(toolBarEvents[i], listener);
		}
	}
	
	private static int checkStyle(int style) {
		return SWT.NO_BACKGROUND;
	}

	void createItem(SToolItem item, int index) {
		if (!(0 <= index && index <= items.size()))
			SWT.error(SWT.ERROR_INVALID_RANGE);
		items.add(index, item);
		redraw();
	}

	public Point computeSize(int wHint, int hHint, boolean changed) {
		if (getLayout() != null) {
			return super.computeSize (wHint, hHint, changed);
		}
		
		Skin skin = getSkin();
		Rectangle itemAreaInsets = null; 
		Rectangle itemMargins = null;
		if (skin != null) {
			itemAreaInsets = skin.getRect(Skin.TYPE_ITEM_AREA_INSETS, Skin.NORMAL);
			itemMargins = skin.getRect(Skin.TYPE_ITEM_AREA_MARGINS, Skin.NORMAL);
		}
		if (itemAreaInsets == null) {
			itemAreaInsets = new Rectangle(0, 0, 0, 0);
		}
		if (itemMargins == null) {
			itemMargins = new Rectangle(0, 0, 0, 0);
		}

		int x;
		int y;
		Point size = getSize();
		int length = (items != null) ? items.size() : 0;
		if ((getStyle() & SWT.VERTICAL) == SWT.VERTICAL) {
			x = 0;
			y = itemAreaInsets.x + itemMargins.x;
			for (int i = 0; i < length; i++) {
				SToolItem item = (SToolItem)items.get(i);
				Point pt = item.computeSize(wHint, hHint, changed);
				x = (pt.x > x) ? pt.x : x;
				y += (pt.y + itemMargins.x);
			}
			x += itemAreaInsets.y + itemAreaInsets.height;
			y += itemAreaInsets.width;
		} else {
			x = itemAreaInsets.x + itemMargins.x;
			y = 0;
			for (int i = 0; i < length; i++) {
				SToolItem item = (SToolItem)items.get(i);
				Point pt = item.computeSize(wHint, hHint, changed);
				x += (pt.x + itemMargins.x);
				y = (pt.y > y) ? pt.y : y;
			}
			y += itemAreaInsets.y + itemAreaInsets.height;
			x += itemAreaInsets.width;
		}
		
		if (wHint != SWT.DEFAULT && wHint >= x)
			x = wHint;
		if (hHint != SWT.DEFAULT && hHint >= y)
			y = hHint;
		// TODO: to be refactored. we should not use the value from getSize(). 
		// Otherwise toolbar cannot be smaller.
		//if (wHint == SWT.DEFAULT && size.x > x)
		//	x = size.x; 
		if (hHint == SWT.DEFAULT && size.y > y)
			y = size.y; 
		return new Point(x, y);
	}
	
	public Rectangle computeTrim(int x, int y, int width, int height) {
		return new Rectangle(x+SHADOW_SIZE, y+SHADOW_SIZE, 
				width-(SHADOW_SIZE*2), height-(SHADOW_SIZE*2));
	}

	void destroyItem(SToolItem item) {
		if (items.contains(item))
			items.remove(item);
	}
	
	public SToolItem getItem(int index) {
		return (SToolItem)items.get(index);
	}
	
	public SToolItem getItem(Point point) {
		return null;
	}
	
	public int getItemCount() {
		return items.size();
	}
	
	public SToolItem[] getItems() {
		return (SToolItem[])items.toArray(new SToolItem[0]);
	}
	
	public int getRowCount() {
		return 0;
	}
	
	public int indexOf(SToolItem item) {
		return items.indexOf(item);
	}

	void itemChanged(SToolItem item) {
		updateItems();
		redraw();
	}
	
	/**
	 * 
	 */
	protected void onDispose() {
		Skin skin = getSkin();
		if (skin != null)
			skin.dispose();
	}
	
	/**
	 * @param event
	 */
	protected void onFocus(Event event) {
		// TODO Auto-generated method stub
	}

	/**
	 * @param event
	 */
	protected void onMouseDoubleClick(Event event) {
		// TODO Auto-generated method stub
	}
	
	/**
	 * @param event
	 */
	protected void onMouseDown(Event event) {
		SToolItem item = findToolItem(event.x, event.y);
		if (item != null) {
			item.onMouseDown(event);
			mouseDownItem = item;
			redraw();
		}
	}

	/**
	 * @param event
	 */
	protected void onMouseExit(Event event) {
		boolean needsRedraw = false;
		if (hoverItem != null) {
			hoverItem.setHot(false);
			hoverItem.setArrowHot(false);
			hoverItem = null;
			needsRedraw = true;
		}
		if (mouseDownItem != null) {
			mouseDownItem.setPressed(false);
			mouseDownItem.setArrowPressed(false);
			mouseDownItem = null;
			needsRedraw = true;
		}
		if (needsRedraw)
			redraw();
	}

	/**
	 * @param event
	 */
	protected void onMouseHover(Event event) {
		// TODO Auto-generated method stub
	}
	
	/**
	 * @param event
	 */
	protected void onMouseMove(Event event) {
		SToolItem item = findToolItem(event.x, event.y);
		if (item != null) {
			if (hoverItem != item) {
				item.setHot(true);
				Rectangle arrowRect = item.getArrowRect();
				if (arrowRect != null) {
					if (arrowRect.contains(event.x, event.y)) {
						item.setArrowHot(true);
					}
				}
				
				if (hoverItem != null) {
					hoverItem.setHot(false);
					hoverItem.setArrowHot(false);
				}
				
				hoverItem = item;
				redraw();
			}
		} else if (hoverItem != null) {
			hoverItem.setHot(false);
			hoverItem.setArrowHot(false);
			hoverItem = null;
			redraw();
		}
	}

	/**
	 * @param event
	 */
	protected void onMouseUp(Event event) {
		boolean needsRedraw = false;
		
		try {
			SToolItem item = findToolItem(event.x, event.y);
			if (item != null && item == mouseDownItem) {
				needsRedraw = true;
				item.onMouseUp(event);
			} else if (mouseDownItem != null) {
				needsRedraw = true;
				mouseDownItem.setPressed(false);
				mouseDownItem.setArrowPressed(false);
			}
		} finally {
			if (needsRedraw)
				redraw();
		}
	}
	
	
	/**
	 * @param event
	 */
	protected void onPaint(Event event) {
		Point size = getSize();
		GC gc = event.gc;
		
		try {
			if (offscreenImageSize.x != size.x || offscreenImageSize.y != size.y) {
				if (offscreenImage != null) {
					offscreenImage.dispose();
					offscreenImage = null;
				}
				if (offscreenGc != null) {
					offscreenGc.dispose();
					offscreenGc = null;
				}
				PaletteData offscreenImagePalette = new PaletteData(0x0000FF00, 0x00FF0000, 0xFF000000);
				ImageData offscreenImageData = new ImageData(size.x, size.y, 32, offscreenImagePalette);
				offscreenImageData.type = SWT.BITMAP;
				offscreenImage = new Image(null, offscreenImageData);
				offscreenGc = new GC(offscreenImage, getStyle());
				offscreenImageSize.x = size.x;
				offscreenImageSize.y = size.y;
			}
		} finally {
			if (offscreenGc != null) {
				offscreenGc.setForeground(event.gc.getForeground());
				offscreenGc.setBackground(event.gc.getBackground());
				offscreenGc.fillRectangle(0, 0, size.x, size.y);
				gc = offscreenGc;
			}
		}
		
		updateItems();
		Skin skin = getSkin();
		
		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 tool items
		for (int i = 0; i < items.size(); i++) {
			SToolItem item = this.getItem(i);
			item.onPaint(gc);
		}

		// paint border
		skin.drawBorder(gc, rect, this, Skin.TYPE_BORDER, state);
		
		// draw the offscreen image
		if (gc == offscreenGc)
			event.gc.drawImage(offscreenImage, 0, 0);
	
	}
	
	/**
	 * @param event
	 */
	protected void onTraverse(Event event) {
		// TODO Auto-generated method stub
	}

	private SToolItem findToolItem(int x, int y) {
		SToolItem item = null;
		for (int i=0; i<items.size(); i++) {
			Rectangle bounds = ((SToolItem)items.get(i)).getBounds();
			if (bounds.contains(x, y)){
				item = (SToolItem)items.get(i);
			}
		}
		return item;
	}
	
	public void setSkin(Skin skin) {
		super.setSkin(skin);
	}
	
	boolean setItemLocation() {
		if (items.size() == 0)
			return false;
		
		Skin skin = getSkin();
		Rectangle itemAreaInsets = null; 
		Rectangle itemMargins = null;
		if (skin != null) {
			itemAreaInsets = skin.getRect(Skin.TYPE_ITEM_AREA_INSETS, Skin.NORMAL);
			itemMargins = skin.getRect(Skin.TYPE_ITEM_AREA_MARGINS, Skin.NORMAL);
		}
		if (itemAreaInsets == null) {
			itemAreaInsets = new Rectangle(0, 0, 0, 0);
		}
		if (itemMargins == null) {
			itemMargins = new Rectangle(0, 0, 0, 0);
		}

		/*
		 * TODO Handle vertical toolbars.
		 */
		
		Rectangle barBounds = getBounds();
		int height = 0;
		if (barBounds != null) {
			height = barBounds.height;
		}

		boolean changed = false;
		int x = itemAreaInsets.x + itemMargins.x;
		int y;
		for (int i = 0; i < items.size(); i++) {
			SToolItem item = (SToolItem)items.get(i);
			if (item.itemRect.x != x) {
				item.itemRect.x = x;
				changed = true;
			}

			/*
			 * Center vertically.
			 */
			y = itemAreaInsets.y + (((height - itemAreaInsets.y - itemAreaInsets.height) / 2) - (item.itemRect.height / 2));

			if (item.itemRect.y != y) {
				item.itemRect.y = y;
				changed = true;
			}
			if (changed == true) {
				Control control = item.getControl(); 
				if (control != null) {
					Rectangle r = control.getBounds();
					r.x = item.itemRect.x + (item.itemRect.width - r.width) / 2;
					r.y = item.itemRect.y + (item.itemRect.height - r.height) / 2;
					control.setLocation(r.x, r.y);
				}
			}
			x += (item.itemRect.width + itemMargins.x);
		}
		return changed;
	}

	boolean setItemSize() {
		if (items.size() == 0)
			return false;
		
		boolean changed = false;

		Skin skin = getSkin();
		Rectangle itemAreaInsets = null; 
		if (skin != null) {
			itemAreaInsets = skin.getRect(Skin.TYPE_ITEM_AREA_INSETS, Skin.NORMAL);
		}
		if (itemAreaInsets == null) {
			itemAreaInsets = new Rectangle(0, 0, 0, 0);
		}

		for (int i = 0; i < items.size(); i++) {
			SToolItem item = (SToolItem)items.get(i);
			Point pt = item.computeSize(SWT.DEFAULT, SWT.DEFAULT, false);
			
			if (pt.y == SWT.DEFAULT) {
				if ((getStyle() & SWT.VERTICAL) == SWT.VERTICAL) {
					pt.y = pt.x;
					pt.x = getSize().x - (itemAreaInsets.y + itemAreaInsets.height);
				} else {
					pt.y = getSize().y - (itemAreaInsets.y + itemAreaInsets.height);
				}
			}
			
			if (pt.x != item.itemRect.width) {
				item.itemRect.width = pt.x;
				changed = true;
			}
		    if (pt.y != item.itemRect.height) {
		    	item.itemRect.height = pt.y;
				changed = true;
		    }
		}
		return changed;
	}
	
	void updateItems() {
		setItemSize();
		setItemLocation();
	}

}




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


import org.eclipse.jface.action.IToolBarManager2;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.internal.provisional.action.IToolBarManager2;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.swt.SWT;

import org.eclipse.ui.IViewReference;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.internal.dnd.DragUtil;
import org.eclipse.ui.internal.provisional.presentations.IActionBarPresentationFactory;
import org.eclipse.ui.presentations.IPresentablePart;
import org.eclipse.ui.presentations.StackPresentation;


Lines 13-19 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/PlaceholderContributionItem.java (-1 / +1 lines)
13		13
14	import org.eclipse.jface.action.IContributionItem;	14	import org.eclipse.jface.action.IContributionItem;
15	import org.eclipse.jface.action.IContributionManager;	15	import org.eclipse.jface.action.IContributionManager;
16	import org.eclipse.jface.action.IToolBarContributionItem;	16	import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
17	import org.eclipse.swt.widgets.Composite;	17	import org.eclipse.swt.widgets.Composite;
18	import org.eclipse.swt.widgets.CoolBar;	18	import org.eclipse.swt.widgets.CoolBar;
19	import org.eclipse.swt.widgets.Menu;	19	import org.eclipse.swt.widgets.Menu;




import org.eclipse.core.runtime.dynamichelpers.ExtensionTracker;
import org.eclipse.core.runtime.dynamichelpers.IExtensionChangeHandler;
import org.eclipse.core.runtime.dynamichelpers.IExtensionTracker;
import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.internal.provisional.action.ICoolBarManager2;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.util.Assert;

        // Run op in busy cursor.
        // Use set redraw to eliminate the "flash" that can occur in the
        // coolbar as the perspective is reset.
        ICoolBarManager2 mgr = (ICoolBarManager2) window.getCoolBarManager2();
        try {
            mgr.getControl2().setRedraw(false);
            BusyIndicator.showWhile(null, new Runnable() {
                public void run() {
                    busyResetPerspective();
                }
            });
        } finally {
            mgr.getControl2().setRedraw(true);
        }
    }


        // Going from multiple to single rows can make the coolbar
        // and its adjacent views appear jumpy as perspectives are
        // switched. Turn off redraw to help with this.
        ICoolBarManager2 mgr = (ICoolBarManager2) window.getCoolBarManager2();
        try {
            mgr.getControl2().setRedraw(false);
            getClientComposite().setRedraw(false);

     * Restore the toolbar layout for the active perspective.
     */
    protected void resetToolBarLayout() {
    	ICoolBarManager2 mgr = (ICoolBarManager2) window.getCoolBarManager2();
    	mgr.resetItemOrder();
    }

    /**

Lines 22-30 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/PluginActionSetBuilder.java (-1 / +1 lines)
22	import org.eclipse.jface.action.IContributionManager;	22	import org.eclipse.jface.action.IContributionManager;
23	import org.eclipse.jface.action.ICoolBarManager;	23	import org.eclipse.jface.action.ICoolBarManager;
24	import org.eclipse.jface.action.IMenuManager;	24	import org.eclipse.jface.action.IMenuManager;
25	import org.eclipse.jface.action.IToolBarContributionItem;
26	import org.eclipse.jface.action.IToolBarManager;	25	import org.eclipse.jface.action.IToolBarManager;
27	import org.eclipse.jface.action.Separator;	26	import org.eclipse.jface.action.Separator;
		27	import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
28	import org.eclipse.ui.IActionBars;	28	import org.eclipse.ui.IActionBars;
29	import org.eclipse.ui.IWorkbenchActionConstants;	29	import org.eclipse.ui.IWorkbenchActionConstants;
30	import org.eclipse.ui.IWorkbenchWindow;	30	import org.eclipse.ui.IWorkbenchWindow;




import org.eclipse.jface.action.IContributionManager;
import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarContributionItem;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.SubMenuManager;
import org.eclipse.jface.action.SubToolBarManager;
import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
import org.eclipse.ui.IActionBars2;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.SubActionBars2;
import org.eclipse.ui.internal.provisional.application.IActionBarConfigurer2;
import org.eclipse.ui.services.IServiceLocator;

/**

 */
public class ActionSetActionBars extends SubActionBars2 {
	
	private IActionBarConfigurer2 actionBarConfigurer = null;

	private String actionSetId;


	/**
     * Constructs a new action bars object
     */
    public ActionSetActionBars(IActionBars2 parent, IServiceLocator serviceLocator, IActionBarConfigurer2 actionBarConfigurer, String actionSetId) {
    	super(parent, serviceLocator);
		this.actionSetId = actionSetId;		
        this.actionBarConfigurer = actionBarConfigurer;




import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarContributionItem;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.internal.provisional.action.ICoolBarManager2;
import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DropTarget;

import org.eclipse.ui.application.IWorkbenchConfigurer;
import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
import org.eclipse.ui.application.WorkbenchAdvisor;
import org.eclipse.ui.internal.provisional.application.IActionBarConfigurer2;
import org.eclipse.ui.internal.provisional.presentations.IActionBarPresentationFactory;
import org.eclipse.ui.presentations.AbstractPresentationFactory;
import org.eclipse.ui.presentations.WorkbenchPresentationFactory;


     * Action bar configurer that changes this workbench window.
     * This implementation keeps track of of cool bar items
     */
    class WindowActionBarConfigurer implements IActionBarConfigurer2 {

        private IActionBarConfigurer2 proxy;
        
        /**
         * Sets the proxy to use, or <code>null</code> for none.
         * 
         * @param proxy the proxy
         */
        public void setProxy(IActionBarConfigurer2 proxy) {
            this.proxy = proxy;
        }
        

     */
    public Control createCoolBarControl(Composite parent) {
        return actionBarConfigurer.getActionBarPresentationFactory().createCoolBarControl(
        		(ICoolBarManager2) window.getCoolBarManager2(), parent);
    }

    /* (non-Javadoc)




import org.eclipse.jface.action.IContributionManager;
import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.IToolBarManager2;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.action.StatusLineManager;
import org.eclipse.jface.commands.ActionHandler;
import org.eclipse.jface.internal.provisional.action.ICoolBarManager2;
import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
import org.eclipse.jface.internal.provisional.action.IToolBarManager2;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.window.ApplicationWindow;
import org.eclipse.jface.window.Window;

import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.WorkbenchException;
import org.eclipse.ui.application.ActionBarAdvisor;
import org.eclipse.ui.application.IActionBarConfigurer;
import org.eclipse.ui.application.WorkbenchAdvisor;
import org.eclipse.ui.application.WorkbenchWindowAdvisor;
import org.eclipse.ui.commands.ICommandService;

import org.eclipse.ui.internal.misc.UIListenerLogging;
import org.eclipse.ui.internal.misc.UIStats;
import org.eclipse.ui.internal.presentations.DefaultActionBarPresentationFactory;
import org.eclipse.ui.internal.presentations.IActionBarPresentationFactory;
import org.eclipse.ui.internal.progress.ProgressRegion;
import org.eclipse.ui.internal.provisional.application.IActionBarConfigurer2;
import org.eclipse.ui.internal.provisional.presentations.IActionBarPresentationFactory;
import org.eclipse.ui.internal.registry.ActionSetRegistry;
import org.eclipse.ui.internal.registry.IActionSetDescriptor;
import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;

		// This needs to be done before pages are created to ensure proper
		// canonical creation
		// of cool items
		ICoolBarManager2 coolBarMgr = (ICoolBarManager2) getCoolBarManager2();
        if (coolBarMgr != null) {
			IMemento coolBarMem = memento
					.getChild(IWorkbenchConstants.TAG_COOLBAR_LAYOUT);

		if (coolbarMem == null) {
			return false;
		}
        ICoolBarManager2 coolBarMgr = (ICoolBarManager2) getCoolBarManager2();
		// Check to see if layout is locked
		Integer locked = coolbarMem.getInteger(IWorkbenchConstants.TAG_LOCKED);
		boolean state = (locked != null) && (locked.intValue() == 1);

		}

		// / Save the order of the cool bar contribution items
        ICoolBarManager2 coolBarMgr = (ICoolBarManager2) getCoolBarManager2();
        if (coolBarMgr != null) {
        	coolBarMgr.refresh();
			IMemento coolBarMem = memento

		if (currentPage == null)
			getActionPresentation().clearActionSets();
		else {
			ICoolBarManager2 coolBarManager = (ICoolBarManager2) getCoolBarManager2();
			if (coolBarManager != null) {
				coolBarManager.refresh();
			}
			getActionPresentation().setActionSets(currentPage.getActionSets());
		}

	 * @param flags
	 *            indicate which bars to fill
	 */
	public void fillActionBars(IActionBarConfigurer2 proxyBars, int flags) {
		Assert.isNotNull(proxyBars);
		WorkbenchWindowConfigurer.WindowActionBarConfigurer wab = (WorkbenchWindowConfigurer.WindowActionBarConfigurer) getWindowConfigurer()
				.getActionBarConfigurer();

	 * @since 3.2
     */
    protected Control createCoolBarControl(Composite parent) {
        return getActionBarPresentationFactory().createCoolBarControl((ICoolBarManager2) getCoolBarManager2(), parent);
    }

    /**

     * @return a tool bar manager
	 * @since 3.2
     */
    protected IToolBarManager createToolBarManager2(int style) {
        return getActionBarPresentationFactory().createToolBarManager();
    }


	 * @since 3.2
     */
    protected Control createToolBarControl(Composite parent) {
        return getActionBarPresentationFactory().createToolBarControl((IToolBarManager2) getToolBarManager2(), parent);
    }
    
    /**




import org.eclipse.jface.action.IContributionManagerOverrides;
import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarContributionItem;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.SubContributionManager;
import org.eclipse.jface.action.SubMenuManager;
import org.eclipse.jface.action.SubStatusLineManager;
import org.eclipse.jface.action.SubToolBarManager;
import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
import org.eclipse.ui.IActionBars2;
import org.eclipse.ui.IEditorActionBarContributor;
import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.SubActionBars2;
import org.eclipse.ui.actions.RetargetAction;
import org.eclipse.ui.internal.misc.Policy;
import org.eclipse.ui.internal.provisional.presentations.IActionBarPresentationFactory;
import org.eclipse.ui.services.IServiceLocator;

/**




import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.internal.provisional.action.ICoolBarManager2;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;

			String type = actionBars.getEditorType();
			actionCache.remove(type);
			// refresh the cool bar manager before disposing of a cool item
			ICoolBarManager2 coolBar = (ICoolBarManager2) window.getCoolBarManager2();
            if (coolBar != null) {
            	coolBar.refresh();
			}
			actionBars.dispose();
		}




import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarContributionItem;
import org.eclipse.jface.action.IToolBarManager;

/**
 * Interface providing special access for configuring the action bars

    public ICoolBarManager getCoolBarManager();
    
    /**
     * Creates a tool bar manager for the workbench window's tool bar.
     * The action bar advisor should use this factory method rather than
     * creating a <code>ToolBarManager</code> directly. 
	 *
     * @return the tool bar manager
     * @since 3.2
     */
    public IToolBarManager createToolBarManager();
        
    /**
     * Creates a toolbar contribution item for the window's tool bar.
     * The action bar advisor should use this factory method rather than
     * creating a <code>ToolBarContributionItem</code> directly. 
	 * 
     * @param toolBarManager a tool bar manager for the workbench window's tool bar
     * @param id the id of the contribution
     * @return the tool bar contribution item
	 * @since 3.2
     */
    public IToolBarContributionItem createToolBarContributionItem(IToolBarManager toolBarManager, String id);

    /**
     * Register the action as a global action with a workbench
     * window.
     * <p>




import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarContributionItem;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.StatusLineManager;
import org.eclipse.jface.action.ToolBarContributionItem;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.dialogs.TrayDialog;
import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
import org.eclipse.jface.internal.provisional.action.ToolBarContributionItem2;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.AbstractTreeViewer;
import org.eclipse.jface.viewers.ArrayContentProvider;

import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.activities.WorkbenchActivityHelper;
import org.eclipse.ui.application.ActionBarAdvisor;
import org.eclipse.ui.application.IActionBarConfigurer;
import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
import org.eclipse.ui.internal.ActionSetActionBars;
import org.eclipse.ui.internal.ActionSetContributionItem;

import org.eclipse.ui.internal.WorkbenchPlugin;
import org.eclipse.ui.internal.WorkbenchWindow;
import org.eclipse.ui.internal.intro.IIntroConstants;
import org.eclipse.ui.internal.provisional.application.IActionBarConfigurer2;
import org.eclipse.ui.internal.registry.ActionSetDescriptor;
import org.eclipse.ui.internal.registry.ActionSetRegistry;
import org.eclipse.ui.internal.registry.IActionSetDescriptor;

     * window's hardwired menus and toolbars in order to display their
     * structure properly in the preview panes.
     */
    public class CustomizeActionBars implements IActionBarConfigurer2,
			IActionBars2 {
        
        IWorkbenchWindowConfigurer configurer;

		 * @see org.eclipse.ui.application.IActionBarConfigurer#createToolBarContributionItem(org.eclipse.jface.action.IToolBarManager, java.lang.String)
		 */
		public IToolBarContributionItem createToolBarContributionItem(IToolBarManager toolBarManager, String id) {
			return new ToolBarContributionItem2(toolBarManager, id);
		}

		/* (non-Javadoc)




 *******************************************************************************/
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.internal.provisional.action.CoolBarManager2;
import org.eclipse.jface.internal.provisional.action.ICoolBarManager2;
import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
import org.eclipse.jface.internal.provisional.action.IToolBarManager2;
import org.eclipse.jface.internal.provisional.action.ToolBarContributionItem2;
import org.eclipse.jface.internal.provisional.action.ToolBarManager2;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.internal.provisional.presentations.IActionBarPresentationFactory;

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

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createCoolBarManager()
	 */
	public ICoolBarManager2 createCoolBarManager() {
		return new CoolBarManager2(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(ICoolBarManager2 coolBarManager,
			Composite parent) {
		return coolBarManager.createControl2(parent);
	}

	 * @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createToolBarManager()
	 */
	public IToolBarManager2 createToolBarManager() {
		return new ToolBarManager2(SWT.FLAT | SWT.RIGHT);
	}

	/* (non-Javadoc)

	 * @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createViewToolBarManager()
	 */
	public IToolBarManager2 createViewToolBarManager() {
		return new ToolBarManager2(SWT.FLAT | SWT.RIGHT);
	}

	/* (non-Javadoc)

	 */
	public IToolBarContributionItem createToolBarContributionItem(
			IToolBarManager toolBarManager, String id) {
		return new ToolBarContributionItem2(toolBarManager, id);
	}
}




/*******************************************************************************
 * 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) 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.provisional.application;

import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
import org.eclipse.ui.application.IActionBarConfigurer;

/**
 * Extends <code>IActionBarConfigurer</code> with API to allow the advisor to
 * be decoupled from the implementation types for tool bar managers and tool bar
 * contribution items.
 * 
 * @since 3.2
 */
public interface IActionBarConfigurer2 extends IActionBarConfigurer {
	
	/**
	 * Creates a tool bar manager for the workbench window's tool bar. The
	 * action bar advisor should use this factory method rather than creating a
	 * <code>ToolBarManager</code> directly.
	 * 
	 * @return the tool bar manager
	 */
	public IToolBarManager createToolBarManager();

	/**
	 * Creates a toolbar contribution item for the window's tool bar. The action
	 * bar advisor should use this factory method rather than creating a
	 * <code>ToolBarContributionItem</code> directly.
	 * 
	 * @param toolBarManager
	 *            a tool bar manager for the workbench window's tool bar
	 * @param id
	 *            the id of the contribution
	 * @return the tool bar contribution item
	 */
	public IToolBarContributionItem createToolBarContributionItem(
			IToolBarManager toolBarManager, String id);

}




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

import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.internal.provisional.action.ICoolBarManager2;
import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
import org.eclipse.jface.internal.provisional.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 ICoolBarManager2 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(ICoolBarManager2 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);

}

Lines 18-23 Link Here

(-)src/org/eclipse/ui/examples/rcp/browser/BrowserActionBarAdvisor.java (-3 / +4 lines)
18	import org.eclipse.jface.action.IToolBarManager;	18	import org.eclipse.jface.action.IToolBarManager;
19	import org.eclipse.jface.action.MenuManager;	19	import org.eclipse.jface.action.MenuManager;
20	import org.eclipse.jface.action.Separator;	20	import org.eclipse.jface.action.Separator;
		21	import org.eclipse.jface.action.ToolBarContributionItem;
		22	import org.eclipse.jface.action.ToolBarManager;
21	import org.eclipse.ui.ISharedImages;	23	import org.eclipse.ui.ISharedImages;
22	import org.eclipse.ui.IViewPart;	24	import org.eclipse.ui.IViewPart;
23	import org.eclipse.ui.IWorkbenchPage;	25	import org.eclipse.ui.IWorkbenchPage;
Lines 155-163 Link Here
155	}	157	}
156		158
157	protected void fillCoolBar(ICoolBarManager coolBar) {	159	protected void fillCoolBar(ICoolBarManager coolBar) {
158	IToolBarManager toolBar = getActionBarConfigurer().createToolBarManager();	160	IToolBarManager toolBar = new ToolBarManager();
159	coolBar.add(getActionBarConfigurer().createToolBarContributionItem(	161	coolBar.add(new ToolBarContributionItem(toolBar, "standard")); //$NON-NLS-1$
160	toolBar, "standard")); //$NON-NLS-1$
161		162
162	// For the Back and Forward actions, force their text to be shown on the toolbar,	163	// For the Back and Forward actions, force their text to be shown on the toolbar,
163	// not just their image. For the remaining actions, the ActionContributionItem	164	// not just their image. For the remaining actions, the ActionContributionItem




import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarContributionItem;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.ui.internal.ide.actions.BuildUtilities;
import org.eclipse.ui.internal.ide.actions.QuickMenuAction;
import org.eclipse.ui.internal.ide.actions.RetargetActionWithDefault;
import org.eclipse.ui.internal.provisional.application.IActionBarConfigurer2;
import org.eclipse.ui.internal.util.StatusLineContributionItem;

/**

     */
    protected void fillCoolBar(ICoolBarManager coolBar) {

    	IActionBarConfigurer2 actionBarConfigurer = (IActionBarConfigurer2) getActionBarConfigurer();
        { // Set up the context Menu
            IMenuManager popUpMenu = new MenuManager();
            popUpMenu.add(new ActionContributionItem(lockToolBarAction));

Return to bug 123257

Lines 13-21 Link Here

(-)src/org/eclipse/jface/action/ToolBarManager.java (-97 / +1 lines)
13	import java.util.ArrayList;	13	import java.util.ArrayList;
14	import java.util.Iterator;	14	import java.util.Iterator;
15		15
16	import org.eclipse.core.runtime.ListenerList;
17	import org.eclipse.jface.util.IPropertyChangeListener;
18	import org.eclipse.jface.util.PropertyChangeEvent;
19	import org.eclipse.swt.SWT;	16	import org.eclipse.swt.SWT;
20	import org.eclipse.swt.accessibility.ACC;	17	import org.eclipse.swt.accessibility.ACC;
21	import org.eclipse.swt.accessibility.AccessibleAdapter;	18	import org.eclipse.swt.accessibility.AccessibleAdapter;
Lines 36-42 Link Here
36	* </p>	33	* </p>
37	*/	34	*/
38	public class ToolBarManager extends ContributionManager implements	35	public class ToolBarManager extends ContributionManager implements
39	IToolBarManager2 {	36	IToolBarManager {
40		37
41	/**	38	/**
42	* The tool bar items style; <code>SWT.NONE</code> by default.	39	* The tool bar items style; <code>SWT.NONE</code> by default.
Lines 57-68 Link Here
57	private MenuManager contextMenuManager = null;	54	private MenuManager contextMenuManager = null;
58		55
59	/**	56	/**
60	* A collection of objects listening to changes to this manager. This
61	* collection is <code>null</code> if there are no listeners.
62	*/
63	private transient ListenerList listenerList = null;
64
65	/**
66	* Creates a new tool bar manager with the default SWT button style. Use the	57	* Creates a new tool bar manager with the default SWT button style. Use the
67	* <code>createControl</code> method to create the tool bar control.	58	* <code>createControl</code> method to create the tool bar control.
68	*/	59	*/
Lines 191-197 Link Here
191	protected void relayout(ToolBar layoutBar, int oldCount, int newCount) {	182	protected void relayout(ToolBar layoutBar, int oldCount, int newCount) {
192	if ((oldCount == 0) != (newCount == 0))	183	if ((oldCount == 0) != (newCount == 0))
193	layoutBar.getParent().layout();	184	layoutBar.getParent().layout();
194	firePropertyChange(PROP_LAYOUT, new Integer(oldCount), new Integer(newCount));
195	}	185	}
196		186
197	/**	187	/**
Lines 406-495 Link Here
406	}	396	}
407	}	397	}
408		398
409	/* (non-Javadoc)
410	* @see org.eclipse.jface.action.IToolBarManager2#createControl2(org.eclipse.swt.widgets.Composite)
411	*/
412	public Control createControl2(Composite parent) {
413	return createControl(parent);
414	}
415
416	/* (non-Javadoc)
417	* @see org.eclipse.jface.action.IToolBarManager2#getControl2()
418	*/
419	public Control getControl2() {
420	return getControl();
421	}
422
423	/* (non-Javadoc)
424	* @see org.eclipse.jface.action.IToolBarManager2#getItemCount()
425	*/
426	public int getItemCount() {
427	if (!toolBarExist())
428	return 0;
429	return toolBar.getItemCount();
430	}
431
432	/* (non-Javadoc)
433	* @see org.eclipse.jface.action.IToolBarManager2#addPropertyChangeListener(org.eclipse.jface.util.IPropertyChangeListener)
434	*/
435	public void addPropertyChangeListener(IPropertyChangeListener listener) {
436	if (listenerList == null) {
437	listenerList = new ListenerList(ListenerList.IDENTITY);
438	}
439
440	listenerList.add(listener);
441	}
442
443	/* (non-Javadoc)
444	* @see org.eclipse.jface.action.IToolBarManager2#removePropertyChangeListener(org.eclipse.jface.util.IPropertyChangeListener)
445	*/
446	public void removePropertyChangeListener(IPropertyChangeListener listener) {
447	if (listenerList != null) {
448	listenerList.remove(listener);
449
450	if (listenerList.isEmpty()) {
451	listenerList = null;
452	}
453	}
454	}
455
456	/*
457	* Returns the listeners attached to this event manager.
458	* The listeners currently attached; may be empty, but never
459	* null.
460	*/
461	protected final Object[] getListeners() {
462	final ListenerList list = listenerList;
463	if (list == null) {
464	return new Object[0];
465	}
466
467	return list.getListeners();
468	}
469
470	/*
471	* Notifies any property change listeners that a property has changed. Only
472	* listeners registered at the time this method is called are notified.
473	*/
474	private void firePropertyChange(final PropertyChangeEvent event) {
475	final Object[] list = getListeners();
476	for (int i = 0; i < list.length; ++i) {
477	((IPropertyChangeListener) list[i]).propertyChange(event);
478	}
479	}
480
481	/*
482	* Notifies any property change listeners that a property has changed. Only
483	* listeners registered at the time this method is called are notified. This
484	* method avoids creating an event object if there are no listeners
485	* registered, but calls firePropertyChange(PropertyChangeEvent) if there are.
486	*/
487	private void firePropertyChange(final String propertyName,
488	final Object oldValue, final Object newValue) {
489	if (listenerList != null) {
490	firePropertyChange(new PropertyChangeEvent(this, propertyName,
491	oldValue, newValue));
492	}
493	}
494
495	}	399	}

Lines 1-5 Link Here

(-)src/org/eclipse/jface/action/ICoolBarManager.java (-144 / +1 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2003, 2006 IBM Corporation and others.	2	* Copyright (c) 2003, 2004 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 10-17 Link Here
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jface.action;	11	package org.eclipse.jface.action;
12		12
13	import org.eclipse.swt.widgets.Composite;
14	import org.eclipse.swt.widgets.Control;
15	import org.eclipse.swt.widgets.CoolBar;	13	import org.eclipse.swt.widgets.CoolBar;
16		14
17	/**	15	/**
Lines 52-93 Link Here
52	* @see ToolBarContributionItem	50	* @see ToolBarContributionItem
53	*/	51	*/
54	public void add(IToolBarManager toolBarManager);	52	public void add(IToolBarManager toolBarManager);
55
56	/**
57	* Creates and returns this manager's cool bar control. Does not create a
58	* new control if one already exists.
59	*
60	* <p>
61	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
62	* part of a work in progress. There is a guarantee neither that this API will
63	* work nor that it will remain the same. Please do not use this API without
64	* consulting with the Platform/UI team.
65	* </p>
66	*
67	* @param parent
68	* the parent control
69	* @return the cool bar control
70	* @since 3.2
71	*/
72	public CoolBar createControl(Composite parent);
73
74	/**
75	* Creates and returns this manager's control. Does not create a
76	* new control if one already exists.
77	*
78	* <p>
79	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
80	* part of a work in progress. There is a guarantee neither that this API will
81	* work nor that it will remain the same. Please do not use this API without
82	* consulting with the Platform/UI team.
83	* </p>
84	*
85	* @param parent
86	* the parent control
87	* @return the control
88	* @since 3.2
89	*/
90	public Control createControl2(Composite parent);
91		53
92	/**	54	/**
93	* Returns the context menu manager used by this cool bar manager. This	55	* Returns the context menu manager used by this cool bar manager. This
Lines 100-135 Link Here
100	public IMenuManager getContextMenuManager();	62	public IMenuManager getContextMenuManager();
101		63
102	/**	64	/**
103	* Returns the cool bar control for this manager.
104	*
105	* <p>
106	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
107	* part of a work in progress. There is a guarantee neither that this API will
108	* work nor that it will remain the same. Please do not use this API without
109	* consulting with the Platform/UI team.
110	* </p>
111	*
112	* @return the cool bar control, or <code>null</code> if none
113	* @since 3.2
114	*/
115	public CoolBar getControl();
116
117	/**
118	* Returns the bar control for this manager.
119	*
120	* <p>
121	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
122	* part of a work in progress. There is a guarantee neither that this API will
123	* work nor that it will remain the same. Please do not use this API without
124	* consulting with the Platform/UI team.
125	* </p>
126	*
127	* @return the bar control, or <code>null</code> if none
128	* @since 3.2
129	*/
130	public Control getControl2();
131
132	/**
133	* Returns whether the layout of the underlying cool bar widget is locked.	65	* Returns whether the layout of the underlying cool bar widget is locked.
134	*	66	*
135	* @return <code>true</code> if cool bar layout is locked, <code>false</code>	67	* @return <code>true</code> if cool bar layout is locked, <code>false</code>
Lines 155-228 Link Here
155	public void setContextMenuManager(IMenuManager menuManager);	87	public void setContextMenuManager(IMenuManager menuManager);
156		88
157	/**	89	/**
158	* Synchronizes the visual order of the cool items in the control with this
159	* manager's internal data structures. This method should be called before
160	* requesting the order of the contribution items to ensure that the order
161	* is accurate.
162	* <p>
163	* Note that <code>update()</code> and <code>refresh()</code> are
164	* converses: <code>update()</code> changes the visual order to match the
165	* internal structures, and <code>refresh</code> changes the internal
166	* structures to match the visual order.
167	* </p>
168	*
169	* <p>
170	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
171	* part of a work in progress. There is a guarantee neither that this API will
172	* work nor that it will remain the same. Please do not use this API without
173	* consulting with the Platform/UI team.
174	* </p>
175	*
176	* @since 3.2
177	*/
178	public void refresh();
179
180	/**
181	* Disposes the resources for this manager.
182	*
183	* <p>
184	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
185	* part of a work in progress. There is a guarantee neither that this API will
186	* work nor that it will remain the same. Please do not use this API without
187	* consulting with the Platform/UI team.
188	* </p>
189	*
190	* @since 3.2
191	*/
192	public void dispose();
193
194	/**
195	* Restores the canonical order of this cool bar manager. The canonical
196	* order is the order in which the contribution items where added.
197	*
198	* <p>
199	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
200	* part of a work in progress. There is a guarantee neither that this API will
201	* work nor that it will remain the same. Please do not use this API without
202	* consulting with the Platform/UI team.
203	* </p>
204	*
205	* @since 3.2
206	*/
207	public void resetItemOrder();
208
209	/**
210	* Replaces the current items with the given items.
211	* Forces an update.
212	*
213	* <p>
214	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
215	* part of a work in progress. There is a guarantee neither that this API will
216	* work nor that it will remain the same. Please do not use this API without
217	* consulting with the Platform/UI team.
218	* </p>
219	*
220	* @param newItems the items with which to replace the current items
221	* @since 3.2
222	*/
223	public void setItems(IContributionItem[] newItems);
224
225	/**
226	* Locks or unlocks the layout of the underlying cool bar widget. Once the	90	* Locks or unlocks the layout of the underlying cool bar widget. Once the
227	* cool bar is locked, cool items cannot be repositioned by the user.	91	* cool bar is locked, cool items cannot be repositioned by the user.
228	* <p>	92	* <p>
Lines 230-242 Link Here
230	* cool bar is locked.	94	* cool bar is locked.
231	* </p>	95	* </p>
232	*	96	*
233	* <p>
234	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
235	* part of a work in progress. There is a guarantee neither that this API will
236	* work nor that it will remain the same. Please do not use this API without
237	* consulting with the Platform/UI team.
238	* </p>
239	*
240	* @param value	97	* @param value
241	* <code>true</code> to lock the cool bar, <code>false</code>	98	* <code>true</code> to lock the cool bar, <code>false</code>
242	* to unlock	99	* to unlock

Lines 245-270 Link Here

(-)src/org/eclipse/jface/action/CoolBarManager.java (-37 lines)
245	}	245	}
246	return coolBar;	246	return coolBar;
247	}	247	}
248
249	/**
250	* Creates and returns this manager's cool bar control. Does not create a
251	* new control if one already exists.
252	*
253	* <p>
254	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
255	* part of a work in progress. There is a guarantee neither that this API will
256	* work nor that it will remain the same. Please do not use this API without
257	* consulting with the Platform/UI team.
258	* </p>
259	*
260	* @param parent
261	* the parent control
262	* @return the cool bar control
263	* @since 3.2
264	*/
265	public Control createControl2(Composite parent) {
266	return createControl(parent);
267	}
268		248
269	/**	249	/**
270	* Disposes of this cool bar manager and frees all allocated SWT resources.	250	* Disposes of this cool bar manager and frees all allocated SWT resources.
Lines 402-424 Link Here
402	public CoolBar getControl() {	382	public CoolBar getControl() {
403	return coolBar;	383	return coolBar;
404	}	384	}
405
406	/**
407	* Returns the control for this manager.
408	*
409	* <p>
410	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
411	* part of a work in progress. There is a guarantee neither that this API will
412	* work nor that it will remain the same. Please do not use this API without
413	* consulting with the Platform/UI team.
414	* </p>
415	*
416	* @return the control, or <code>null</code> if none
417	* @since 3.2
418	*/
419	public Control getControl2() {
420	return coolBar;
421	}
422		385
423	/**	386	/**
424	* Returns an array list of all the contribution items in the manager.	387	* Returns an array list of all the contribution items in the manager.

Lines 1-5 Link Here

(-)src/org/eclipse/jface/action/SubCoolBarManager.java (-73 / +1 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2003, 2006 IBM Corporation and others.	2	* Copyright (c) 2003, 2004 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 11-19 Link Here
11	package org.eclipse.jface.action;	11	package org.eclipse.jface.action;
12		12
13	import org.eclipse.jface.util.Assert;	13	import org.eclipse.jface.util.Assert;
14	import org.eclipse.swt.widgets.Composite;
15	import org.eclipse.swt.widgets.Control;
16	import org.eclipse.swt.widgets.CoolBar;
17		14
18	/**	15	/**
19	* A <code>SubCoolBarManager</code> monitors the additional and removal of	16	* A <code>SubCoolBarManager</code> monitors the additional and removal of
Lines 45-82 Link Here
45	super.add(new ToolBarContributionItem(toolBarManager));	42	super.add(new ToolBarContributionItem(toolBarManager));
46	}	43	}
47		44
48	/*
49	* (non-Javadoc)
50	* @see org.eclipse.jface.action.ICoolBarManager#createControl(org.eclipse.swt.widgets.Composite)
51	*/
52	public CoolBar createControl(Composite parent) {
53	return null;
54	}
55
56	/*
57	* (non-Javadoc)
58	* @see org.eclipse.jface.action.ICoolBarManager#createControl2(org.eclipse.swt.widgets.Composite)
59	*/
60	public Control createControl2(Composite parent) {
61	return createControl(parent);
62	}
63
64	/*
65	* (non-Javadoc)
66	* @see org.eclipse.jface.action.ICoolBarManager#getControl()
67	*/
68	public CoolBar getControl() {
69	return null;
70	}
71
72	/*
73	* (non-Javadoc)
74	* @see org.eclipse.jface.action.ICoolBarManager#getControl2()
75	*/
76	public Control getControl2() {
77	return null;
78	}
79
80	/* (non-Javadoc)	45	/* (non-Javadoc)
81	* @see org.eclipse.jface.action.ICoolBarManager#getStyle()	46	* @see org.eclipse.jface.action.ICoolBarManager#getStyle()
82	*/	47	*/
Lines 117-138 Link Here
117	return null;	82	return null;
118	}	83	}
119		84
120	/*
121	* (non-Javadoc)
122	* @see org.eclipse.jface.action.ICoolBarManager#refresh()
123	*/
124	public void refresh() {
125	// do nothing
126	}
127
128	/*
129	* (non-Javadoc)
130	* @see org.eclipse.jface.action.ICoolBarManager#resetItemOrder()
131	*/
132	public void resetItemOrder() {
133	// do nothing
134	}
135
136	/* (non-Javadoc)	85	/* (non-Javadoc)
137	* In SubCoolBarManager we do nothing.	86	* In SubCoolBarManager we do nothing.
138	*/	87	*/
Lines 140-153 Link Here
140	// do nothing	89	// do nothing
141	}	90	}
142		91
143	/*
144	* (non-Javadoc)
145	* @see org.eclipse.jface.action.ICoolBarManager#setItems(org.eclipse.jface.action.IContributionItem[])
146	*/
147	public void setItems(IContributionItem[] newItems) {
148	// do nothing
149	}
150
151	/* (non-Javadoc)	92	/* (non-Javadoc)
152	* @see org.eclipse.jface.action.IContributionManager#update(boolean)	93	* @see org.eclipse.jface.action.IContributionManager#update(boolean)
153	*/	94	*/
Lines 158-174 Link Here
158	getParentCoolBarManager().update(force);	99	getParentCoolBarManager().update(force);
159	}	100	}
160		101
161	/* (non-Javadoc)
162	* @see org.eclipse.jface.action.ICoolBarManager#dispose()
163	*/
164	public void dispose() {
165	// do nothing
166	}
167
168
169
170
171
172
173
174	}	102	}

Removed Link Here

(-)src/org/eclipse/jface/action/IToolBarManager2.java (-111 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005, 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jface.action;
12
13	import org.eclipse.jface.util.IPropertyChangeListener;
14	import org.eclipse.swt.widgets.Composite;
15	import org.eclipse.swt.widgets.Control;
16	import org.eclipse.swt.widgets.ToolBar;
17
18	/**
19	* The <code>IToolBarManager2</code> interface provides protocol for managing
20	* contributions to a tool bar. It extends <code>IToolBarManager</code>
21	* and provides a <code>dispose</code> method.
22	*
23	* <p>
24	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
25	* part of a work in progress. There is a guarantee neither that this API will
26	* work nor that it will remain the same. Please do not use this API without
27	* consulting with the Platform/UI team.
28	* </p>
29	*
30	* This package also provides a concrete tool bar manager implementation,
31	* {@link ToolBarManager <code>ToolBarManager</code>}.
32	* </p>
33	*
34	* @since 3.2
35	*/
36	public interface IToolBarManager2 extends IToolBarManager {
37
38	/**
39	* The property id for changes to the control's layout
40	*/
41	public static final String PROP_LAYOUT = "PROP_LAYOUT"; //$NON-NLS-1$
42
43	/**
44	* Creates and returns this manager's toolbar control. Does not create a
45	* new control if one already exists.
46	*
47	* @param parent
48	* the parent control
49	* @return the toolbar control
50	*/
51	public ToolBar createControl(Composite parent);
52
53	/**
54	* Creates and returns this manager's control. Does not create a
55	* new control if one already exists.
56	*
57	* @param parent
58	* the parent control
59	* @return the control
60	*/
61	public Control createControl2(Composite parent);
62
63	/**
64	* Returns the toolbar control for this manager.
65	*
66	* @return the toolbar control, or <code>null</code> if none
67	*/
68	public ToolBar getControl();
69
70	/**
71	* Returns the control for this manager.
72	*
73	* @return the control, or <code>null</code> if none
74	*/
75	public Control getControl2();
76
77	/**
78	* Disposes the resources for this manager.
79	*/
80	public void dispose();
81
82	/**
83	* Returns the item count of the control used
84	* by this manager.
85	*
86	* @return the number of items in the control
87	*/
88	public int getItemCount();
89
90	/**
91	* Registers a property change listner with this manager.
92	*
93	* @param listener
94	*/
95	public void addPropertyChangeListener(IPropertyChangeListener listener);
96
97	/**
98	* Removes a property change listner from this manager.
99	*
100	* @param listener
101	*/
102	public void removePropertyChangeListener(IPropertyChangeListener listener);
103
104	/**
105	* Sets the overrides for this contribution manager
106	*
107	* @param newOverrides the overrides for the items of this manager
108	*/
109	public void setOverrides(IContributionManagerOverrides newOverrides);
110
111	}

Removed Link Here

(-)src/org/eclipse/jface/action/IToolBarContributionItem.java (-120 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.action;
13
14	/**
15	* The intention of this interface is to provide in interface for
16	* ToolBarContributionItem so that the implementation can be replaced.
17	*
18	* <p>
19	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
20	* part of a work in progress. There is a guarantee neither that this API will
21	* work nor that it will remain the same. Please do not use this API without
22	* consulting with the Platform/UI team.
23	* </p>
24	*
25	* @since 3.2
26	*/
27	public interface IToolBarContributionItem extends IContributionItem {
28
29	/**
30	* Returns the current height of the corresponding cool item.
31	*
32	* @return the current height
33	*/
34	public int getCurrentHeight();
35
36	/**
37	* Returns the current width of the corresponding cool item.
38	*
39	* @return the current size
40	*/
41	public int getCurrentWidth();
42
43	/**
44	* Returns the minimum number of tool items to show in the cool item.
45	*
46	* @return the minimum number of tool items to show, or <code>SHOW_ALL_ITEMS</code>
47	* if a value was not set
48	* @see #setMinimumItemsToShow(int)
49	*/
50	public int getMinimumItemsToShow();
51
52	/**
53	* Returns whether chevron support is enabled.
54	*
55	* @return <code>true</code> if chevron support is enabled, <code>false</code>
56	* otherwise
57	*/
58	public boolean getUseChevron();
59
60	/**
61	* Sets the current height of the cool item. Update(SIZE) should be called
62	* to adjust the widget.
63	*
64	* @param currentHeight
65	* the current height to set
66	*/
67	public void setCurrentHeight(int currentHeight);
68
69	/**
70	* Sets the current width of the cool item. Update(SIZE) should be called
71	* to adjust the widget.
72	*
73	* @param currentWidth
74	* the current width to set
75	*/
76	public void setCurrentWidth(int currentWidth);
77
78	/**
79	* Sets the minimum number of tool items to show in the cool item. If this
80	* number is less than the total tool items, a chevron will appear and the
81	* hidden tool items appear in a drop down menu. By default, all the tool
82	* items are shown in the cool item.
83	*
84	* @param minimumItemsToShow
85	* the minimum number of tool items to show.
86	* @see #getMinimumItemsToShow()
87	* @see #setUseChevron(boolean)
88	*/
89	public void setMinimumItemsToShow(int minimumItemsToShow);
90
91	/**
92	* Enables or disables chevron support for the cool item. By default,
93	* chevron support is enabled.
94	*
95	* @param value
96	* <code>true</code> to enable chevron support, <code>false</code>
97	* otherwise.
98	*/
99	public void setUseChevron(boolean value);
100
101	/**
102	* Returns the internal tool bar manager of the contribution item.
103	*
104	* @return the tool bar manager, or <code>null</code> if one is not
105	* defined.
106	* @see IToolBarManager
107	*/
108	public IToolBarManager getToolBarManager();
109
110	/**
111	* Returns the parent contribution manager, or <code>null</code> if this
112	* contribution item is not currently added to a contribution manager.
113	*
114	* @return the parent contribution manager, or <code>null</code>
115	*
116	* TODO may not need this, getToolBarManager may be enough.
117	*/
118	public IContributionManager getParent();
119
120	}

Added Link Here

(-)src/org/eclipse/jface/internal/provisional/action/CoolBarManager2.java (+95 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.internal.provisional.action;
13
14	import org.eclipse.jface.action.CoolBarManager;
15	import org.eclipse.swt.widgets.Composite;
16	import org.eclipse.swt.widgets.Control;
17	import org.eclipse.swt.widgets.CoolBar;
18
19	/**
20	* Extends <code>CoolBarManager</code> to implement <code>ICoolBarManager2</code>
21	* @since 3.2
22	*/
23	public class CoolBarManager2 extends CoolBarManager implements ICoolBarManager2 {
24
25	/**
26	* Creates a new cool bar manager with the default style. Equivalent to
27	* <code>CoolBarManager(SWT.NONE)</code>.
28	*/
29	public CoolBarManager2() {
30	super();
31	}
32
33	/**
34	* Creates a cool bar manager for an existing cool bar control. This
35	* manager becomes responsible for the control, and will dispose of it when
36	* the manager is disposed.
37	*
38	* @param coolBar
39	* the cool bar control
40	*/
41	public CoolBarManager2(CoolBar coolBar) {
42	super(coolBar);
43	}
44
45	/**
46	* Creates a cool bar manager with the given SWT style. Calling <code>createControl</code>
47	* will create the cool bar control.
48	*
49	* @param style
50	* the cool bar item style; see
51	* {@link org.eclipse.swt.widgets.CoolBar CoolBar}for for valid
52	* style bits
53	*/
54	public CoolBarManager2(int style) {
55	super(style);
56	}
57
58	/**
59	* Creates and returns this manager's cool bar control. Does not create a
60	* new control if one already exists.
61	*
62	* <p>
63	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
64	* part of a work in progress. There is a guarantee neither that this API will
65	* work nor that it will remain the same. Please do not use this API without
66	* consulting with the Platform/UI team.
67	* </p>
68	*
69	* @param parent
70	* the parent control
71	* @return the cool bar control
72	* @since 3.2
73	*/
74	public Control createControl2(Composite parent) {
75	return createControl(parent);
76	}
77
78	/**
79	* Returns the control for this manager.
80	*
81	* <p>
82	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
83	* part of a work in progress. There is a guarantee neither that this API will
84	* work nor that it will remain the same. Please do not use this API without
85	* consulting with the Platform/UI team.
86	* </p>
87	*
88	* @return the control, or <code>null</code> if none
89	* @since 3.2
90	*/
91	public Control getControl2() {
92	return getControl();
93	}
94
95	}

Added Link Here

(-)src/org/eclipse/ui/examples/presentation/customtoolbar/widgets/SToolItem.java (+731 lines)
1	/*
2	* Copyright IBM Corporation 2003, 2005
3	* All rights reserved.
4	* US Government Users Restricted Rights - Use, duplication or disclosure
5	* restricted by GS ADP Schedule Contract with IBM Corp.
6	*/
7	package org.eclipse.ui.examples.presentation.customtoolbar.widgets;
8
9	import org.eclipse.swt.SWT;
10	import org.eclipse.swt.events.SelectionListener;
11	import org.eclipse.swt.graphics.FontMetrics;
12	import org.eclipse.swt.graphics.GC;
13	import org.eclipse.swt.graphics.Image;
14	import org.eclipse.swt.graphics.Point;
15	import org.eclipse.swt.graphics.Rectangle;
16	import org.eclipse.swt.widgets.Control;
17	import org.eclipse.swt.widgets.Event;
18	import org.eclipse.swt.widgets.Item;
19	import org.eclipse.swt.widgets.TypedListener;
20
21	public class SToolItem extends Item {
22	SToolBar parent;
23	Control control;
24	int index;
25	String toolTipText;
26	Image disabledImage;
27	Image hotImage;
28	Image pressedImage;
29	boolean enabled = true;
30	boolean selected;
31	int separatorWidth;
32	int width = -1;
33	Point arrowSize = new Point(5, 5);
34	int state;
35	int arrowState;
36
37	/** the alignment. Either CENTER, RIGHT, LEFT. Default is LEFT */
38	private int align = SWT.LEFT;
39
40	Rectangle itemRect = new Rectangle(0,0,0,0);
41	Rectangle arrowRect;
42
43	/**
44	* @param parent
45	* @param style
46	*/
47	public SToolItem(SToolBar parent, int style) {
48	super(parent, style);
49	this.parent = parent;
50	parent.createItem(this, parent.getItemCount());
51	}
52
53	/**
54	* @param parent
55	* @param style
56	* @param index
57	*/
58	public SToolItem(SToolBar parent, int style, int index) {
59	super(parent, style, index);
60	this.parent = parent;
61	parent.createItem(this, index);
62	}
63
64	public void addSelectionListener(SelectionListener listener) {
65	checkWidget();
66	if (listener == null) SWT.error (SWT.ERROR_NULL_ARGUMENT);
67	TypedListener typedListener = new TypedListener (listener);
68	addListener (SWT.Selection, typedListener);
69	addListener (SWT.DefaultSelection, typedListener);
70	}
71
72	public Point computeSize(int wHint, int hHint, boolean changed) {
73	checkWidget();
74	Skin skin = parent.getSkin();
75
76	Rectangle insets = skin.getRect(Skin.TYPE_ITEM_INSETS, Skin.NORMAL);
77	if (insets == null) {
78	insets = new Rectangle(0, 0, 0, 0);
79	}
80
81	Point size = null;
82	String t = getText();
83	if (t != null && t.length() == 0) {
84	t = null;
85	}
86
87	if (control == null && (getStyle() & SWT.SEPARATOR) == SWT.SEPARATOR &&
88	t == null) {
89	size = skin.getSize(Skin.TYPE_DECORATION_SEPARATOR, Skin.NORMAL);
90	}
91	else {
92	size = getContentSize(getImage(), getText());
93	}
94	if (size == null) {
95	size = new Point(0, 0);
96	}
97
98	if (wHint == SWT.DEFAULT) {
99	size.x += (insets.x + insets.width);
100	} else {
101	size.x = wHint;
102	}
103	if (hHint == SWT.DEFAULT) {
104	if (size.y != SWT.DEFAULT) {
105	if (getControl() == null) {
106	size.y += (insets.y + insets.height);
107	}
108	}
109	} else {
110	size.y = hHint;
111	}
112
113	//
114	// Everything gets measured for a min/max width and height except if
115	// it is exclusively a SEPARATOR or if it is a separator with a control.
116	//
117	boolean measureMinMax = true;
118	if ((getStyle() & SWT.SEPARATOR) == SWT.SEPARATOR) {
119	if (control != null \|\| t == null) {
120	measureMinMax = false;
121	}
122	}
123
124	if (measureMinMax) {
125	Point minMax = skin.getSize(Skin.TYPE_ITEM_MIN_MAX_WIDTHS, Skin.NORMAL);
126	if (minMax != null) {
127	if (minMax.x > size.x && minMax.x != SWT.DEFAULT) {
128	size.x = minMax.x;
129	}
130	if (minMax.y < size.x && minMax.y != SWT.DEFAULT) {
131	size.x = minMax.y;
132	}
133	}
134
135	minMax = skin.getSize(Skin.TYPE_ITEM_MIN_MAX_HEIGHT, Skin.NORMAL);
136	if (minMax != null) {
137	if (minMax.x > size.y && minMax.x != SWT.DEFAULT) {
138	size.y = minMax.x;
139	}
140	if (minMax.y < size.y && minMax.y != SWT.DEFAULT) {
141	size.y = minMax.y;
142	}
143	}
144	}
145
146	return size;
147	}
148
149	public void dispose() {
150	if (isDisposed ()) return;
151	parent.destroyItem(this);
152	super.dispose();
153	}
154
155	/**
156	* @return
157	*/
158	public Rectangle getBounds() {
159	return itemRect;
160	}
161
162	/**
163	* @return
164	*/
165	public Control getControl() {
166	return control;
167	}
168
169	Skin getSkin() {
170	Skin skin = parent.getSkin();
171	return skin;
172	}
173
174	/**
175	* @return
176	*/
177	public Image getDisabledImage() {
178	return disabledImage;
179	}
180
181	/**
182	* @return
183	*/
184	public boolean getEnabled() {
185	return enabled;
186	}
187
188	/**
189	* @return
190	*/
191	public Image getHotImage() {
192	return hotImage;
193	}
194
195	/**
196	* @return pressed image.
197	*/
198	public Image getPressedImage() {
199	return pressedImage;
200	}
201
202	/**
203	* @return
204	*/
205	public SToolBar getParent() {
206	return this.parent;
207	}
208
209	/**
210	* @return
211	*/
212	public boolean getSelection() {
213	return selected;
214	}
215
216	private int getState() {
217	return state;
218	}
219
220	private int getArrowState() {
221	return arrowState;
222	}
223
224	/**
225	* Compute the minimum size.
226	*/
227	private Point getContentSize(Image image, String text) {
228	Point size = new Point(0, 0);
229	Skin skin = getSkin();
230
231	Control control = getControl();
232	if (control != null) {
233	size = control.computeSize(SWT.DEFAULT, SWT.DEFAULT);
234	if (width != -1)
235	size.x = width;
236	return size;
237	}
238
239	if (image != null) {
240	Rectangle r;
241	Point imageSize = skin.getSize(Skin.TYPE_ITEM_ICON_SIZE, state);
242	if (imageSize != null && imageSize.y != SWT.DEFAULT) {
243	r = new Rectangle(0, 0, imageSize.x, imageSize.y);
244	} else {
245	r = image.getBounds();
246	}
247	size.x += r.width;
248	size.y += r.height;
249	}
250
251	if (skin != null) {
252	Rectangle margins = skin.getRect(Skin.TYPE_ITEM_MARGINS, Skin.NORMAL);
253	if (margins == null) {
254	margins = new Rectangle(0, 0, 0, 0);
255	}
256
257	if (text != null && text.length() > 0) {
258	GC gc = new GC(this.getParent());
259	gc.setFont(skin.getFont(Skin.TYPE_ITEM_FONT, Skin.NORMAL));
260	FontMetrics fm = gc.getFontMetrics();
261	Point e = gc.textExtent(text, SWT.DRAW_TRANSPARENT);
262	size.x += e.x;
263	size.y = Math.max(size.y, fm.getAscent());
264	if (image != null) {
265	size.x += margins.x;
266	}
267	gc.dispose();
268	}
269
270	if ((getStyle() & SWT.DROP_DOWN) != 0) {
271	Point hinkySize = skin.getSize(Skin.TYPE_DECORATION_ARROW, Skin.NORMAL);
272	if (hinkySize == null) {
273	hinkySize = new Point(0, 0);
274	}
275	size.x += hinkySize.x + margins.y;
276
277	if ((getStyle() & SWT.SIMPLE) != SWT.SIMPLE) {
278	Point separatorSize = skin.getSize(Skin.TYPE_DECORATION_INTERNAL_SEPARATOR, Skin.NORMAL);
279	if (separatorSize == null) {
280	separatorSize = new Point(0, 0);
281	}
282	size.x += separatorSize.x;
283	}
284	}
285	}
286
287	return size;
288	}
289
290	/**
291	* @return
292	*/
293	public String getToolTipText() {
294	return toolTipText;
295	}
296
297	/**
298	* @return
299	*/
300	public int getWidth() {
301	return itemRect.width;
302	}
303
304	public Rectangle getArrowRect() {
305	return arrowRect;
306	}
307
308	/**
309	* @return
310	*/
311	public boolean isEnabled() {
312	return enabled;
313	}
314
315	/**
316	*
317	*/
318	void onDispose() {
319	// TODO Auto-generated method stub
320	}
321
322	/**
323	* @param event
324	*/
325	void onFocus(Event event) {
326	// TODO Auto-generated method stub
327	}
328
329	/**
330	* @param event
331	*/
332	void onMouseDoubleClick(Event event) {
333	}
334
335	/**
336	* @param event
337	*/
338	void onMouseDown(Event event) {
339	if (arrowRect != null) {
340	if (arrowRect.contains(event.x, event.y)) {
341	setArrowPressed(true);
342	}
343	}
344	if ((arrowState & Skin.PRESSED) == 0) {
345	setPressed(true);
346	}
347	notifyListeners(SWT.MouseDown, event);
348
349	if ((getStyle() & SWT.RADIO) == SWT.RADIO) {
350	Event e = new Event();
351	e.button = event.button;
352	e.character = event.character;
353	e.count = event.count;
354	e.data = event.data;
355	e.detail = event.detail;
356	e.display = event.display;
357	e.doit = event.doit;
358	e.end = event.end;
359	e.gc = event.gc;
360	e.height = event.height;
361	e.item = event.item;
362	e.keyCode = event.keyCode;
363	e.start = event.start;
364	e.stateMask = event.stateMask;
365	e.text = event.text;
366	e.time = event.time;
367	e.widget = event.widget;
368	e.width = event.width;
369	e.x = event.x;
370	e.y = event.y;
371
372	e.type = SWT.Selection;
373	notifyListeners(SWT.Selection, e);
374	setSelected(true);
375	}
376	}
377
378	/**
379	* @param event
380	*/
381	void onMouseExit(Event event) {
382	}
383
384	/**
385	* @param event
386	*/
387	void onMouseHover(Event event) {
388	notifyListeners(SWT.MouseHover, event);
389	}
390
391	void setHot(boolean hot) {
392	if (hot)
393	state \|= Skin.HOVER;
394	else if ((state & Skin.HOVER) != 0)
395	state = (state & ~Skin.HOVER);
396	}
397
398	void setArrowHot(boolean hot) {
399	if (hot) {
400	arrowState \|= Skin.HOVER;
401	} else if ((arrowState & Skin.HOVER) == Skin.HOVER) {
402	arrowState = (arrowState & ~Skin.HOVER);
403	}
404	}
405
406	void setPressed(boolean pressed) {
407	if (pressed)
408	state \|= Skin.PRESSED;
409	else if ((state & Skin.PRESSED) != 0)
410	state = (state & ~Skin.PRESSED);
411	}
412
413	void setArrowPressed(boolean pressed) {
414	if (pressed)
415	arrowState \|= Skin.PRESSED;
416	else if ((arrowState & Skin.PRESSED) == Skin.PRESSED)
417	arrowState = (arrowState & ~Skin.PRESSED);
418	}
419
420	public void setSelected(boolean selected) {
421	if (selected) {
422	/* Clear all adjacent selected radio buttons */
423	int itemIndex = parent.indexOf(this);
424	int i;
425	SToolItem item;
426
427	for (i = itemIndex -1; i > 0; i--) {
428	item = parent.getItem(i);
429	if ((item.getStyle() & SWT.RADIO) == SWT.RADIO) {
430	item.setSelected(false);
431	} else {
432	break;
433	}
434	}
435	for (i = itemIndex +1; i < parent.getItemCount(); i++) {
436	item = parent.getItem(i);
437	if ((item.getStyle() & SWT.RADIO) == SWT.RADIO) {
438	item.setSelected(false);
439	} else {
440	break;
441	}
442	}
443	state \|= Skin.SELECTED;
444	} else if ((state & Skin.SELECTED) == Skin.SELECTED) {
445	state = (state & ~Skin.SELECTED);
446	}
447	}
448
449	/**
450	* @param event
451	*/
452	void onMouseMove(Event event) {
453	}
454
455	/**
456	* @param event
457	*/
458	void onMouseUp(Event event) {
459	setPressed(false);
460
461	Event e = new Event();
462	e.type = SWT.MouseUp;
463	e.widget = this;
464	e.gc = event.gc;
465	e.x = event.x;
466	e.y = event.y;
467	notifyListeners(SWT.MouseUp, event);
468
469	if ((getStyle() & SWT.RADIO) != SWT.RADIO) {
470	e = new Event();
471	e.type = SWT.Selection;
472	e.widget = this;
473	e.gc = event.gc;
474	e.x = event.x;
475	e.y = event.y;
476	if (arrowRect != null && arrowRect.contains(event.x, event.y))
477	e.detail \|= SWT.ARROW;
478	notifyListeners(SWT.Selection, e);
479	}
480	}
481
482
483	/*
484	* Process the paint event
485	*/
486	void onPaint(GC gc) {
487	Skin skin = parent.getSkin();
488	String t = getText();
489	if (t != null && t.length() == 0) {
490	t = null;
491	}
492	Image img = null;
493
494	int state = getState();
495
496	/*
497	* A separator with text will just draw static text rather than a line separator
498	* so always keep the state normal so it doesn't behave like a button.
499	*/
500	if (control == null && (getStyle() & SWT.SEPARATOR) == SWT.SEPARATOR && t != null) {
501	state = Skin.NORMAL;
502	}
503
504	if (isEnabled() == false) {
505	img = getDisabledImage();
506	} else if ((state & Skin.PRESSED) == Skin.PRESSED) {
507	img = getPressedImage();
508	} else if ((state & Skin.HOVER) == Skin.HOVER) {
509	img = getHotImage();
510	}
511
512	if (img == null) {
513	img = getImage();
514	}
515
516	Rectangle insets = skin.getRect(Skin.TYPE_ITEM_INSETS, state);
517	if (insets == null) {
518	insets = new Rectangle(0, 0, 0, 0);
519	}
520	gc.setFont(skin.getFont(Skin.TYPE_ITEM_FONT, state));
521
522	Rectangle rect = getBounds();
523	if (rect.width == 0 \|\| rect.height == 0)
524	return;
525
526	int availableWidth = rect.width - (insets.x + insets.width);
527	Point extent = getContentSize(img, t);
528	if (extent.x > availableWidth) {
529	img = null;
530	extent = getContentSize(img, t);
531	}
532
533	// determine horizontal position
534	int x = (rect.x + insets.x);
535	if (align == SWT.CENTER) {
536	x = (rect.width - extent.x) / 2;
537	}
538	else if (align == SWT.RIGHT) {
539	x = rect.width - extent.x - insets.width;
540	}
541	//gc.setForeground(getDisplay().getSystemColor(SWT.COLOR_RED));
542	//gc.drawRectangle(rect);
543	if (control == null && (getStyle() & SWT.SEPARATOR) == SWT.SEPARATOR && t == null) {
544	state = (state & ~(Skin.PRESSED));
545	skin.drawDecoration(gc, rect, parent, Skin.TYPE_DECORATION_SEPARATOR, state);
546	return;
547	}
548
549	// paint background
550	skin.drawBackground(gc, rect, parent, Skin.TYPE_ITEM_BACKGROUND, state);
551
552	// paint border
553	skin.drawBorder(gc, rect, parent, Skin.TYPE_ITEM_BORDER, state);
554
555	Rectangle itemMargins = skin.getRect(Skin.TYPE_ITEM_MARGINS, state);
556	if (itemMargins == null) {
557	itemMargins = new Rectangle(0, 0, 0, 0);
558	}
559
560	// draw the image
561
562	if (img != null) {
563	Rectangle imageRect;
564	Point imageSize = skin.getSize(Skin.TYPE_ITEM_ICON_SIZE, state);
565	if (imageSize != null && imageSize.y != SWT.DEFAULT) {
566	imageRect = new Rectangle(0, 0, imageSize.x, imageSize.y);
567	} else {
568	imageRect = img.getBounds();
569	}
570
571	imageRect = new Rectangle(x, rect.y + ((rect.height - imageRect.height) / 2),
572	imageRect.width, imageRect.height);
573	skin.drawImage(gc, imageRect, img, parent, Skin.TYPE_ITEM_IMAGE, state);
574
575	x += imageRect.width + itemMargins.x;
576	}
577
578	// draw the text
579	if (t != null) {
580	FontMetrics fm = gc.getFontMetrics();
581	int textHeight = fm.getAscent();
582	int textWidth = gc.textExtent(getText(), SWT.DRAW_TRANSPARENT \| SWT.DRAW_MNEMONIC).x;
583	int y = rect.y;
584	int availableHeight = rect.height;
585	y = y + ((availableHeight / 2) - (textHeight / 2));
586	Rectangle textRect = new Rectangle(x, y, textWidth, textHeight);
587	//Used for debugging text rect rendering.
588	// gc.setBackground(getDisplay().getSystemColor(SWT.COLOR_GREEN));
589	// gc.fillRectangle(textRect);
590	/* Don't include leading so top of text lines up when expected in the drawing rect. */
591	textRect.y -= fm.getLeading();
592	skin.drawText(gc, textRect, getText(), SWT.DRAW_TRANSPARENT \| SWT.DRAW_MNEMONIC, parent, Skin.TYPE_ITEM_TEXT, state);
593	/* Add leading back in to get the "text rect" that the text is actually rendered in. */
594	textRect.y += fm.getLeading();
595	x += textRect.width + itemMargins.y;
596	}
597
598	// draw the hinky and text/hinky separator
599	if ((getStyle() & SWT.DROP_DOWN) != 0) {
600	Point hinkySize = skin.getSize(Skin.TYPE_DECORATION_ARROW, state);
601	if (hinkySize == null) {
602	hinkySize = new Point(0, 0);
603	}
604	int myX = x;
605	int myY = rect.y + ((rect.height /2) - ((hinkySize.y == SWT.DEFAULT ? 0 : hinkySize.y) / 2));
606	Point separatorSize = skin.getSize(Skin.TYPE_DECORATION_INTERNAL_SEPARATOR, state);
607	if (separatorSize == null) {
608	separatorSize = new Point(0, 0);
609	}
610	int sepLineX = myX -2;
611
612	int arrowState = state;
613	// separator
614	Rectangle sepLineRectangle = null;
615	if ((getStyle() & SWT.SIMPLE) != SWT.SIMPLE) {
616	int y = rect.y + (((rect.height / 2) - ((separatorSize.y == SWT.DEFAULT ? rect.height : separatorSize.y)) / 2));
617	sepLineRectangle = new Rectangle(sepLineX, y, separatorSize.x, (separatorSize.y == SWT.DEFAULT ? rect.height : separatorSize.y));
618	skin.drawDecoration(gc, sepLineRectangle, parent, Skin.TYPE_DECORATION_INTERNAL_SEPARATOR, state);
619	myX += separatorSize.x;
620	/* Since it is separate, use the arrow state to draw the hinky below. */
621	arrowState = getArrowState();
622	}
623
624	// hinky
625	int height = (hinkySize.y == SWT.DEFAULT ? rect.height : hinkySize.y);
626	Rectangle arrowImageRect = new Rectangle(myX, myY, hinkySize.x, height);
627	skin.drawDecoration(gc, arrowImageRect, parent, Skin.TYPE_DECORATION_ARROW, arrowState);
628
629	if (sepLineRectangle != null)
630	arrowRect = new Rectangle(sepLineRectangle.x, 0, myX, rect.height);
631	else
632	arrowRect = null;
633	}
634	}
635
636	public void removeSelectionListener (SelectionListener listener) {
637	checkWidget();
638	if (listener == null) SWT.error (SWT.ERROR_NULL_ARGUMENT);
639	removeListener(SWT.Selection, listener);
640	removeListener(SWT.DefaultSelection,listener);
641	}
642
643	/**
644	* @param control
645	*/
646	public void setControl(Control control) {
647	this.control = control;
648	if (control != null) {
649	Point pt = control.computeSize(SWT.DEFAULT, SWT.DEFAULT);
650	itemRect = new Rectangle(0, 0, pt.x, pt.y);
651	control.setBounds(itemRect);
652	parent.itemChanged(this);
653	}
654	}
655
656	/**
657	* @param image
658	*/
659	public void setDisabledImage(Image image) {
660	this.disabledImage = image;
661	parent.itemChanged(this);
662	}
663
664	/**
665	* @param enabled
666	*/
667	public void setEnabled(boolean enabled) {
668	this.enabled = enabled;
669	parent.itemChanged(this);
670	}
671
672	/**
673	* @param image
674	*/
675	public void setHotImage(Image image) {
676	this.hotImage = image;
677	parent.itemChanged(this);
678	}
679
680	/**
681	* @param pressed image
682	*/
683	public void setPressedImage(Image image) {
684	this.pressedImage = image;
685	parent.itemChanged(this);
686	}
687
688	/* (non-Javadoc)
689	* @see org.eclipse.swt.widgets.Item#setImage(org.eclipse.swt.graphics.Image)
690	*/
691	public void setImage(Image image) {
692	if ((getStyle() & SWT.SEPARATOR) != 0)
693	return;
694	super.setImage(image);
695	parent.itemChanged(this);
696	}
697
698	/**
699	* @param selected
700	*/
701	public void setSelection(boolean selected) {
702	this.selected = selected;
703	parent.itemChanged(this);
704	}
705
706	/* (non-Javadoc)
707	* @see org.eclipse.swt.widgets.Item#setText(java.lang.String)
708	*/
709	public void setText(String string) {
710	super.setText(string);
711	parent.itemChanged(this);
712	}
713
714	/**
715	* @param string
716	*/
717	public void setToolTipText(String string) {
718	toolTipText = string;
719	parent.itemChanged(this);
720	}
721
722	public void setWidth(int width) {
723	this.width = width;
724	if (control != null) {
725	Point size = control.getSize();
726	size.x = width;
727	control.setSize(size);
728	}
729	}
730
731	}

Added Link Here

(-)src/org/eclipse/ui/examples/presentation/customtoolbar/widgets/Skin.java (+94 lines)
1	package org.eclipse.ui.examples.presentation.customtoolbar.widgets;
2
3	import org.eclipse.swt.graphics.Font;
4	import org.eclipse.swt.graphics.GC;
5	import org.eclipse.swt.graphics.Image;
6	import org.eclipse.swt.graphics.Point;
7	import org.eclipse.swt.graphics.Rectangle;
8
9	public interface Skin {
10
11	// states
12	public static final int NORMAL = 0;
13	public static final int HOVER = 1 << 1;
14	public static final int SELECTED = 1 << 2;
15	public static final int PRESSED = 1 << 3;
16	public static final int DISABLED = 1 << 4;
17	public static final int COLLAPSED = 1 << 5;
18
19	// decorations
20	public final static int TYPE_DECORATION_CLOSE = 1;
21	public final static int TYPE_DECORATION_SEPARATOR = 2;
22	public final static int TYPE_DECORATION_FOCUS = 3;
23	public final static int TYPE_DECORATION_ARROW = 4;
24	public final static int TYPE_DECORATION_CHEVRON = 5;
25	public final static int TYPE_DECORATION_DROPDOWN_BUTTON = 6;
26	public final static int TYPE_DECORATION_COLLAPSE_BUTTON = 7;
27	public final static int TYPE_DECORATION_EXPAND_BUTTON = 8;
28	public final static int TYPE_DECORATION_GRIPPER = 9;
29	public final static int TYPE_DECORATION_INTERNAL_SEPARATOR = 10;
30
31	// borders
32	public final static int TYPE_ITEM_MENU_BORDER = 11;
33	public final static int TYPE_ITEM_AREA_BORDER = 12;
34	public final static int TYPE_ITEM_BORDER = 13;
35	public final static int TYPE_BORDER = 14;
36	public final static int TYPE_GROUP_ITEM_BORDER = 15;
37	public final static int TYPE_GROUP_BORDER = 16;
38	public final static int TYPE_HEADER_ITEM_BORDER = 17;
39	public final static int TYPE_HEADER_BORDER = 18;
40
41	// backgrounds
42	public final static int TYPE_ITEM_MENU_BACKGROUND = 19;
43	public final static int TYPE_ITEM_AREA_BACKGROUND = 20;
44	public final static int TYPE_ITEM_BACKGROUND = 21;
45	public final static int TYPE_BACKGROUND = 22;
46	public final static int TYPE_GROUP_ITEM_BACKGROUND = 23;
47	public final static int TYPE_HEADER_ITEM_BACKGROUND = 24;
48	public final static int TYPE_HEADER_BACKGROUND = 25;
49
50	// fonts
51	public final static int TYPE_ITEM_MENU_FONT = 26;
52	public final static int TYPE_ITEM_FONT = 27;
53	public final static int TYPE_FONT = 28;
54
55	// text
56	public final static int TYPE_ITEM_MENU_TEXT = 29;
57	public final static int TYPE_ITEM_TEXT = 30;
58	public final static int TYPE_TEXT= 31;
59	public final static int TYPE_GROUP_ITEM_TEXT = 32;
60	public final static int TYPE_HEADER_ITEM_TEXT = 33;
61
62	// images
63	public final static int TYPE_ITEM_IMAGE = 34;
64	public final static int TYPE_IMAGE = 35;
65
66	// properties
67	public final static int TYPE_MARGINS = 36;
68	public final static int TYPE_INSETS = 37;
69	public final static int TYPE_ITEM_MARGINS = 38;
70	public final static int TYPE_ITEM_INSETS = 39;
71	public final static int TYPE_ITEM_AREA_MARGINS = 40;
72	public final static int TYPE_ITEM_AREA_INSETS = 41;
73	public final static int TYPE_ITEM_MENU_MARGINS = 42;
74	public final static int TYPE_ITEM_MENU_INSETS = 43;
75	public final static int TYPE_DECORATION_CLOSE_INSETS = 44;
76	public final static int TYPE_ITEM_MIN_MAX_WIDTHS = 45;
77	public final static int TYPE_ITEM_ICON_SIZE = 46;
78	public final static int TYPE_ITEM_MIN_MAX_HEIGHT = 47;
79
80	abstract public Rectangle getInsets(int type, int state);
81	abstract public Point getSize(int type, int state);
82	abstract public Font getFont(int type, int state);
83	abstract public Rectangle getMargins(int type, int state);
84	abstract public Rectangle getRect(int type, int state);
85
86	public abstract void drawBorder(GC gc, Rectangle rect, SWidget widget, int type, int state);
87	public abstract void drawBackground(GC gc, Rectangle rect, SWidget widget, int type, int state);
88	public abstract void drawDecoration(GC gc, Rectangle rect, SWidget widget, int type, int state);
89	public abstract void drawText(GC gc, Rectangle rect, String text, int style, SWidget widget, int type, int state);
90	public abstract void drawImage(GC gc, Rectangle rect, Image image, SWidget widget, int type, int state);
91
92	abstract public void dispose();
93
94	}

Added Link Here

(-)src/org/eclipse/ui/examples/presentation/customtoolbar/widgets/SActionContributionItem.java (+627 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ui.examples.presentation.customtoolbar.widgets;
12
13	import org.eclipse.jface.action.Action;
14	import org.eclipse.jface.action.ActionContributionItem;
15	import org.eclipse.jface.action.ExternalActionManager;
16	import org.eclipse.jface.action.IAction;
17	import org.eclipse.jface.action.IContributionManagerOverrides;
18	import org.eclipse.jface.action.IMenuCreator;
19	import org.eclipse.jface.resource.ImageDescriptor;
20	import org.eclipse.jface.resource.JFaceResources;
21	import org.eclipse.jface.resource.LocalResourceManager;
22	import org.eclipse.jface.resource.ResourceManager;
23	import org.eclipse.jface.util.IPropertyChangeListener;
24	import org.eclipse.jface.util.Policy;
25	import org.eclipse.jface.util.PropertyChangeEvent;
26	import org.eclipse.swt.SWT;
27	import org.eclipse.swt.graphics.Point;
28	import org.eclipse.swt.graphics.Rectangle;
29	import org.eclipse.swt.widgets.Composite;
30	import org.eclipse.swt.widgets.CoolBar;
31	import org.eclipse.swt.widgets.Display;
32	import org.eclipse.swt.widgets.Event;
33	import org.eclipse.swt.widgets.Item;
34	import org.eclipse.swt.widgets.Listener;
35	import org.eclipse.swt.widgets.Menu;
36	import org.eclipse.swt.widgets.ToolBar;
37	import org.eclipse.swt.widgets.Widget;
38
39	/**
40	* A contribution item which delegates to an action.
41	* <p>
42	* This class may be instantiated; it is not intended to be subclassed.
43	* </p>
44	*/
45	public class SActionContributionItem extends ActionContributionItem implements ISContributionItem {
46
47	ActionContributionItem actionContributionItem = null;
48
49	private boolean isSeparator;
50
51	/**
52	* The listener for changes to the text of the action contributed by an
53	* external source.
54	*/
55	private final IPropertyChangeListener actionTextListener = new IPropertyChangeListener() {
56
57	/**
58	* @see IPropertyChangeListener#propertyChange(PropertyChangeEvent)
59	*/
60	public void propertyChange(PropertyChangeEvent event) {
61	update(event.getProperty());
62	}
63	};
64
65	/**
66	* Remembers all images in use by this contribution item
67	*/
68	private LocalResourceManager imageManager;
69
70	private boolean isWidgetSet = false;
71
72	/**
73	* Listener for SWT tool item widget events.
74	*/
75	private Listener toolItemListener;
76
77	/**
78	* The widget created for this item; <code>null</code>
79	* before creation and after disposal.
80	*/
81	private Widget widget = null;
82
83	/**
84	* Listener for action property change notifications.
85	*/
86	private final IPropertyChangeListener propertyListener = new IPropertyChangeListener() {
87	public void propertyChange(PropertyChangeEvent event) {
88	actionPropertyChange(event);
89	}
90	};
91
92	public SActionContributionItem() {
93	this(new ActionContributionItem(new Action() {public void run() {}}));
94	this.isSeparator = true;
95	}
96
97	/**
98	* @param action
99	*/
100	public SActionContributionItem(IAction action) {
101	this(new ActionContributionItem(action));
102	}
103
104	/**
105	*
106	* @param action
107	*/
108	public SActionContributionItem(ActionContributionItem actionContributionItem) {
109	super(actionContributionItem.getAction());
110	this.actionContributionItem = actionContributionItem;
111	}
112
113	public boolean isSeparator() {
114	return isSeparator;
115	}
116
117	/**
118	* Handles a property change event on the action (forwarded by nested listener).
119	*/
120	private void actionPropertyChange(final PropertyChangeEvent e) {
121	// This code should be removed. Avoid using free asyncExec
122
123	if (isVisible() && widget != null) {
124	Display display = widget.getDisplay();
125	if (display.getThread() == Thread.currentThread()) {
126	update(e.getProperty());
127	} else {
128	display.asyncExec(new Runnable() {
129	public void run() {
130	update(e.getProperty());
131	}
132	});
133	}
134
135	}
136	}
137
138	/**
139	* Dispose any images allocated for this contribution item
140	*/
141	private void disposeOldImages() {
142	if (imageManager != null) {
143	imageManager.dispose();
144	imageManager = null;
145	}
146	}
147
148	/* (non-Javadoc)
149	* @see org.eclipse.jface.action.ActionContributionItem#fill(org.eclipse.swt.widgets.Composite)
150	*/
151	public void fill(Composite parent) {
152	isWidgetSet = true;
153	actionContributionItem.fill(parent);
154	}
155
156	/* (non-Javadoc)
157	* @see org.eclipse.jface.action.ContributionItem#fill(org.eclipse.swt.widgets.CoolBar, int)
158	*/
159	public void fill(CoolBar parent, int index) {
160	if (widget instanceof SToolItem)
161	return;
162	isWidgetSet = true;
163	actionContributionItem.fill(parent, index);
164	}
165
166	/* (non-Javadoc)
167	* @see org.eclipse.jface.action.ActionContributionItem#fill(org.eclipse.swt.widgets.Menu, int)
168	*/
169	public void fill(Menu parent, int index) {
170	if (widget instanceof SToolItem)
171	return;
172	isWidgetSet = true;
173	actionContributionItem.fill(parent, index);
174	}
175
176	/* (non-Javadoc)
177	* @see org.eclipse.jface.action.ActionContributionItem#fill(org.eclipse.swt.widgets.ToolBar, int)
178	*/
179	public void fill(ToolBar parent, int index) {
180	if (widget instanceof SToolItem)
181	return;
182	isWidgetSet = true;
183	actionContributionItem.fill(parent, index);
184	}
185
186	public void fill(SCoolBar parent, int index) {
187	// do nothing
188	}
189
190	public void fill(SToolBar parent, int index) {
191	if (isWidgetSet == false && widget == null && parent != null) {
192	int flags = SWT.PUSH;
193	IAction action = getAction();
194	if (action != null) {
195	if (isSeparator) {
196	flags = SWT.SEPARATOR;
197	} else {
198	int style = action.getStyle();
199	if (style == IAction.AS_CHECK_BOX)
200	flags = SWT.CHECK;
201	else if (style == IAction.AS_RADIO_BUTTON)
202	flags = SWT.RADIO;
203	else if (style == IAction.AS_DROP_DOWN_MENU)
204	flags = SWT.DROP_DOWN;
205	}
206	}
207
208	Item ti = null;
209	if (index >= 0)
210	ti = new SToolItem(parent, flags, index);
211	else
212	ti = new SToolItem(parent, flags);
213	ti.setData(this);
214	ti.addListener(SWT.Selection, getToolItemListener());
215	ti.addListener(SWT.Dispose, getToolItemListener());
216
217	widget = ti;
218
219	update(null);
220
221	// Attach some extra listeners.
222	action.addPropertyChangeListener(propertyListener);
223	if (action != null) {
224	String commandId = action.getActionDefinitionId();
225	ExternalActionManager.ICallback callback = ExternalActionManager
226	.getInstance().getCallback();
227
228	if ((callback != null) && (commandId != null)) {
229	callback.addPropertyChangeListener(commandId,
230	actionTextListener);
231	}
232	}
233	}
234	}
235
236	private Listener getToolItemListener() {
237	if (toolItemListener == null) {
238	toolItemListener = new Listener() {
239	public void handleEvent(Event event) {
240	switch (event.type) {
241	case SWT.Dispose:
242	handleWidgetDispose(event);
243	break;
244	case SWT.Selection:
245	Widget ew = event.widget;
246	if (ew != null) {
247	handleWidgetSelection(event, ((SToolItem) ew)
248	.getSelection());
249	}
250	break;
251	}
252	}
253	};
254	}
255	return toolItemListener;
256	}
257
258	/**
259	* Handles a widget dispose event for the widget corresponding to this item.
260	*/
261	private void handleWidgetDispose(Event e) {
262	// Check if our widget is the one being disposed.
263	if (e.widget == widget) {
264	IAction action = getAction();
265	// Dispose of the menu creator.
266	if (action.getStyle() == IAction.AS_DROP_DOWN_MENU) {
267	IMenuCreator mc = action.getMenuCreator();
268	if (mc != null) {
269	mc.dispose();
270	}
271	}
272
273	// Unhook all of the listeners.
274	action.removePropertyChangeListener(propertyListener);
275	if (action != null) {
276	String commandId = action.getActionDefinitionId();
277	ExternalActionManager.ICallback callback = ExternalActionManager
278	.getInstance().getCallback();
279
280	if ((callback != null) && (commandId != null)) {
281	callback.removePropertyChangeListener(commandId,
282	actionTextListener);
283	}
284	}
285
286	// Clear the widget field.
287	widget = null;
288
289	disposeOldImages();
290	}
291	}
292
293	/**
294	* Handles a widget selection event.
295	*/
296	private void handleWidgetSelection(Event e, boolean selection) {
297
298	Widget item = e.widget;
299	if (item != null) {
300	int style = item.getStyle();
301	IAction action = getAction();
302
303	if ((style & (SWT.TOGGLE \| SWT.CHECK)) != 0) {
304	if (action.getStyle() == IAction.AS_CHECK_BOX) {
305	action.setChecked(selection);
306	}
307	} else if ((style & SWT.RADIO) != 0) {
308	if (action.getStyle() == IAction.AS_RADIO_BUTTON) {
309	action.setChecked(selection);
310	}
311	} else if ((style & SWT.DROP_DOWN) != 0) {
312	if (e.detail == 4) { // on drop-down button
313	if (action.getStyle() == IAction.AS_DROP_DOWN_MENU) {
314	IMenuCreator mc = action.getMenuCreator();
315	SToolItem ti = (SToolItem) item;
316	// we create the menu as a sub-menu of "dummy" so that we can use
317	// it in a cascading menu too.
318	// If created on a SWT control we would get an SWT error...
319	//Menu dummy= new Menu(ti.getParent());
320	//Menu m= mc.getMenu(dummy);
321	//dummy.dispose();
322	if (mc != null) {
323	Menu m = mc.getMenu(ti.getParent());
324	if (m != null) {
325	// position the menu below the drop down item
326	Rectangle b = ti.getBounds();
327	Point p = ti.getParent().toDisplay(
328	new Point(b.x, b.y + b.height));
329	m.setLocation(p.x, p.y); // waiting for SWT 0.42
330	m.setVisible(true);
331	return; // we don't fire the action
332	}
333	}
334	}
335	}
336	}
337	// Ensure action is enabled first.
338	// See 1GAN3M6: ITPUI:WINNT - Any IAction in the workbench can be executed while disabled.
339	if (action.isEnabled()) {
340	boolean trace = Policy.TRACE_ACTIONS;
341
342	long ms = System.currentTimeMillis();
343	if (trace)
344	System.out.println("Running action: " + action.getText()); //$NON-NLS-1$
345
346	action.runWithEvent(e);
347
348	if (trace)
349	System.out.println((System.currentTimeMillis() - ms)
350	+ " ms to run action: " + action.getText()); //$NON-NLS-1$
351	}
352	}
353	}
354
355	/**
356	* Returns whether the given action has any images.
357	*
358	* @param actionToCheck the action
359	* @return <code>true</code> if the action has any images, <code>false</code> if not
360	*/
361	private boolean hasImages(IAction actionToCheck) {
362	return actionToCheck.getImageDescriptor() != null
363	\|\| actionToCheck.getHoverImageDescriptor() != null
364	\|\| actionToCheck.getDisabledImageDescriptor() != null;
365	}
366
367	/**
368	* Synchronizes the UI with the given property.
369	*
370	* @param propertyName the name of the property, or <code>null</code> meaning all applicable
371	* properties
372	*/
373	public void update(String propertyName) {
374
375	if (widget instanceof SToolItem) {
376
377	// determine what to do
378	IAction action = getAction();
379	boolean textChanged = propertyName == null
380	\|\| propertyName.equals(IAction.TEXT);
381	boolean imageChanged = propertyName == null
382	\|\| propertyName.equals(IAction.IMAGE);
383	boolean tooltipTextChanged = propertyName == null
384	\|\| propertyName.equals(IAction.TOOL_TIP_TEXT);
385	boolean enableStateChanged = propertyName == null
386	\|\| propertyName.equals(IAction.ENABLED)
387	\|\| propertyName
388	.equals(IContributionManagerOverrides.P_ENABLED);
389	boolean checkChanged = (action.getStyle() == IAction.AS_CHECK_BOX \|\| action
390	.getStyle() == IAction.AS_RADIO_BUTTON)
391	&& (propertyName == null \|\| propertyName
392	.equals(IAction.CHECKED));
393
394	if (widget instanceof SToolItem) {
395	SToolItem ti = (SToolItem) widget;
396	String text = action.getText();
397	// the set text is shown only if there is no image or if forced by MODE_FORCE_TEXT
398	boolean showText = text != null
399	&& ((getMode() & MODE_FORCE_TEXT) != 0 \|\| !hasImages(action));
400
401	// only do the trimming if the text will be used
402	if (showText && text != null) {
403	text = Action.removeAcceleratorText(text);
404	text = Action.removeMnemonics(text);
405	}
406
407	if (textChanged) {
408	String textToSet = showText ? text : ""; //$NON-NLS-1$
409	boolean rightStyle = (ti.getParent().getStyle() & SWT.RIGHT) != 0;
410	if (rightStyle \|\| !ti.getText().equals(textToSet)) {
411	// In addition to being required to update the text if it
412	// gets nulled out in the action, this is also a workaround
413	// for bug 50151: Using SWT.RIGHT on a ToolBar leaves blank space
414	ti.setText(textToSet);
415	}
416	}
417
418	if (imageChanged) {
419	// only substitute a missing image if it has no text
420	updateImages(!showText);
421	}
422
423	if (tooltipTextChanged \|\| textChanged) {
424	String toolTip = action.getToolTipText();
425	// if the text is showing, then only set the tooltip if different
426	if (!showText \|\| toolTip != null && !toolTip.equals(text)) {
427	ti.setToolTipText(toolTip);
428	} else {
429	ti.setToolTipText(null);
430	}
431	}
432
433	/* FIXME TFS -- Need to keep the buttons enabled for now so they actually look like they work.
434	* [Terry Smith 12/9/2005].
435	* if (enableStateChanged) {
436	boolean shouldBeEnabled = action.isEnabled()
437	&& isEnabledAllowed();
438
439	if (ti.getEnabled() != shouldBeEnabled)
440	ti.setEnabled(shouldBeEnabled);
441	}
442	*/
443	if (checkChanged) {
444	boolean bv = action.isChecked();
445
446	if (ti.getSelection() != bv)
447	ti.setSelection(bv);
448	}
449	return;
450	}
451	} else {
452	actionContributionItem.update(propertyName);
453	}
454	}
455
456	/**
457	* Updates the images for this action.
458	*
459	* @param forceImage <code>true</code> if some form of image is compulsory,
460	* and <code>false</code> if it is acceptable for this item to have no image
461	* @return <code>true</code> if there are images for this action, <code>false</code> if not
462	*/
463	private boolean updateImages(boolean forceImage) {
464
465	ResourceManager parentResourceManager = JFaceResources.getResources();
466
467	if (widget instanceof SToolItem) {
468	IAction action = getAction();
469	if (getUseColorIconsInToolbars()) {
470	ImageDescriptor imageDesc = action.getImageDescriptor();
471	ImageDescriptor hoverImageDesc = action.getHoverImageDescriptor();
472	ImageDescriptor disabledImageDesc = action.getDisabledImageDescriptor();
473	ImageDescriptor pressedImageDesc = null;
474
475	if (imageDesc == null && forceImage) {
476	imageDesc = ImageDescriptor.getMissingImageDescriptor();
477	}
478
479	// if (disabledImageDesc == null && imageDesc != null) {
480	// disabledImageDesc = ImageDescriptor.createWithFlags(imageDesc, SWT.IMAGE_GRAY);
481	// }
482
483	LocalResourceManager localManager = new LocalResourceManager(parentResourceManager);
484
485	// performance: more efficient in SWT to set disabled and hot image before regular image
486	((SToolItem) widget).setDisabledImage(disabledImageDesc != null ? localManager.createImageWithDefault(disabledImageDesc) : null);
487	((SToolItem) widget).setHotImage(hoverImageDesc != null ? localManager.createImageWithDefault(hoverImageDesc) : null);
488	((SToolItem) widget).setImage(imageDesc != null ? localManager.createImageWithDefault(imageDesc) : null);
489	disposeOldImages();
490	imageManager = localManager;
491
492	return imageDesc != null;
493	/* TODO TFS Old Crap
494	ImageDescriptor image = action.getHoverImageDescriptor();
495	if (image == null) {
496	image = action.getImageDescriptor();
497	}
498	ImageDescriptor disabledImage = action.getDisabledImageDescriptor();
499
500	// Make sure there is a valid image.
501	if (image == null && forceImage) {
502	image = ImageDescriptor.getMissingImageDescriptor();
503	}
504
505	LocalResourceManager localManager = new LocalResourceManager(parentResourceManager);
506
507	// performance: more efficient in SWT to set disabled and hot image before regular image
508	((SToolItem) widget).setDisabledImage(disabledImage == null ? null : localManager.createImageWithDefault(disabledImage));
509	((SToolItem) widget).setImage(image == null ? null : localManager.createImageWithDefault(image));
510
511	disposeOldImages();
512	imageManager = localManager;
513
514	return image != null;
515	*/
516	}
517	ImageDescriptor image = action.getImageDescriptor();
518	ImageDescriptor hoverImage = action
519	.getHoverImageDescriptor();
520	ImageDescriptor disabledImage = action
521	.getDisabledImageDescriptor();
522
523	// If there is no regular image, but there is a hover image,
524	// convert the hover image to gray and use it as the regular image.
525	if (image == null && hoverImage != null) {
526	image = ImageDescriptor.createWithFlags(action.getHoverImageDescriptor(), SWT.IMAGE_GRAY);
527	} else {
528	// If there is no hover image, use the regular image as the hover image,
529	// and convert the regular image to gray
530	if (hoverImage == null && image != null) {
531	hoverImage = image;
532	image = ImageDescriptor.createWithFlags(action.getImageDescriptor(), SWT.IMAGE_GRAY);
533	}
534	}
535
536	// Make sure there is a valid image.
537	if (hoverImage == null && image == null && forceImage) {
538	image = ImageDescriptor.getMissingImageDescriptor();
539	}
540
541	// Create a local resource manager to remember the images we've allocated for this tool item
542	LocalResourceManager localManager = new LocalResourceManager(parentResourceManager);
543
544	// performance: more efficient in SWT to set disabled and hot image before regular image
545	((SToolItem) widget).setDisabledImage(disabledImage == null? null : localManager.createImageWithDefault(disabledImage));
546	((SToolItem) widget).setHotImage(hoverImage == null? null : localManager.createImageWithDefault(hoverImage));
547	((SToolItem) widget).setImage(image == null? null : localManager.createImageWithDefault(image));
548
549	// Now that we're no longer referencing the old images, clear them out.
550	disposeOldImages();
551	imageManager = localManager;
552
553	return image != null;
554	}
555	return false;
556	}
557
558	/* (non-Javadoc)
559	* @see org.eclipse.jface.action.ActionContributionItem#equals(java.lang.Object)
560	*/
561	public boolean equals(Object o) {
562
563	if (!(o instanceof ActionContributionItem)) {
564	return false;
565	}
566	return actionContributionItem.getAction().equals(((ActionContributionItem) o).getAction());
567	}
568
569	/* (non-Javadoc)
570	* @see org.eclipse.jface.action.ActionContributionItem#getAction()
571	*/
572	public IAction getAction() {
573	return actionContributionItem.getAction();
574	}
575
576	/* (non-Javadoc)
577	* @see org.eclipse.jface.action.ActionContributionItem#getMode()
578	*/
579	public int getMode() {
580	return actionContributionItem.getMode();
581	}
582
583	/* (non-Javadoc)
584	* @see org.eclipse.jface.action.ActionContributionItem#hashCode()
585	*/
586	public int hashCode() {
587	return actionContributionItem.hashCode();
588	}
589
590	/* (non-Javadoc)
591	* @see org.eclipse.jface.action.ActionContributionItem#isDynamic()
592	*/
593	public boolean isDynamic() {
594	return actionContributionItem.isDynamic();
595	}
596
597	/* (non-Javadoc)
598	* @see org.eclipse.jface.action.ActionContributionItem#isEnabled()
599	*/
600	public boolean isEnabled() {
601	return actionContributionItem.isEnabled();
602	}
603
604	/* (non-Javadoc)
605	* @see org.eclipse.jface.action.ActionContributionItem#isEnabledAllowed()
606	*/
607	protected boolean isEnabledAllowed() {
608	if (actionContributionItem.getParent() == null)
609	return true;
610	Boolean value = actionContributionItem.getParent().getOverrides().getEnabled(this);
611	return (value == null) ? true : value.booleanValue();
612	}
613
614	/* (non-Javadoc)
615	* @see org.eclipse.jface.action.ActionContributionItem#isVisible()
616	*/
617	public boolean isVisible() {
618	return actionContributionItem.isVisible();
619	}
620
621	/* (non-Javadoc)
622	* @see org.eclipse.jface.action.ActionContributionItem#setMode(int)
623	*/
624	public void setMode(int mode) {
625	actionContributionItem.setMode(mode);
626	}
627	}

Added Link Here

(-)src/org/eclipse/ui/examples/presentation/customtoolbar/widgets/SWidget.java (+31 lines)
1	package org.eclipse.ui.examples.presentation.customtoolbar.widgets;
2
3	import org.eclipse.swt.widgets.Canvas;
4	import org.eclipse.swt.widgets.Composite;
5
6	public abstract class SWidget extends Canvas {
7
8	public static final int HOVER = 1 << 1;
9	public static final int SELECTED = 1 << 2;
10	public static final int PRESSED = 1 << 3;
11
12	private Skin skin;
13
14	public SWidget(Composite parent, int style) {
15	super(parent, style);
16	}
17
18	public void setSkin(Skin skin) {
19	if (this.skin != null) {
20	this.skin.dispose();
21	this.skin = null;
22	}
23
24	this.skin = skin;
25	}
26
27	public Skin getSkin() {
28	return skin;
29	}
30
31	}

Lines 13-20 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/ViewPane.java (-2 / +2 lines)
13	package org.eclipse.ui.internal;	13	package org.eclipse.ui.internal;
14		14
15		15
16	import org.eclipse.jface.action.IToolBarManager2;
17	import org.eclipse.jface.action.MenuManager;	16	import org.eclipse.jface.action.MenuManager;
		17	import org.eclipse.jface.internal.provisional.action.IToolBarManager2;
18	import org.eclipse.jface.util.IPropertyChangeListener;	18	import org.eclipse.jface.util.IPropertyChangeListener;
19	import org.eclipse.jface.util.PropertyChangeEvent;	19	import org.eclipse.jface.util.PropertyChangeEvent;
20	import org.eclipse.swt.SWT;	20	import org.eclipse.swt.SWT;
Lines 30-36 Link Here
30	import org.eclipse.ui.IViewReference;	30	import org.eclipse.ui.IViewReference;
31	import org.eclipse.ui.IWorkbenchPart;	31	import org.eclipse.ui.IWorkbenchPart;
32	import org.eclipse.ui.internal.dnd.DragUtil;	32	import org.eclipse.ui.internal.dnd.DragUtil;
33	import org.eclipse.ui.internal.presentations.IActionBarPresentationFactory;	33	import org.eclipse.ui.internal.provisional.presentations.IActionBarPresentationFactory;
34	import org.eclipse.ui.presentations.IPresentablePart;	34	import org.eclipse.ui.presentations.IPresentablePart;
35	import org.eclipse.ui.presentations.StackPresentation;	35	import org.eclipse.ui.presentations.StackPresentation;
36		36

Lines 37-46 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/WorkbenchPage.java (-6 / +7 lines)
37	import org.eclipse.core.runtime.dynamichelpers.ExtensionTracker;	37	import org.eclipse.core.runtime.dynamichelpers.ExtensionTracker;
38	import org.eclipse.core.runtime.dynamichelpers.IExtensionChangeHandler;	38	import org.eclipse.core.runtime.dynamichelpers.IExtensionChangeHandler;
39	import org.eclipse.core.runtime.dynamichelpers.IExtensionTracker;	39	import org.eclipse.core.runtime.dynamichelpers.IExtensionTracker;
40	import org.eclipse.jface.action.ICoolBarManager;
41	import org.eclipse.jface.dialogs.ErrorDialog;	40	import org.eclipse.jface.dialogs.ErrorDialog;
42	import org.eclipse.jface.dialogs.IDialogConstants;	41	import org.eclipse.jface.dialogs.IDialogConstants;
43	import org.eclipse.jface.dialogs.MessageDialog;	42	import org.eclipse.jface.dialogs.MessageDialog;
		43	import org.eclipse.jface.internal.provisional.action.ICoolBarManager2;
44	import org.eclipse.jface.operation.IRunnableWithProgress;	44	import org.eclipse.jface.operation.IRunnableWithProgress;
45	import org.eclipse.jface.preference.IPreferenceStore;	45	import org.eclipse.jface.preference.IPreferenceStore;
46	import org.eclipse.jface.util.Assert;	46	import org.eclipse.jface.util.Assert;
Lines 2539-2554 Link Here
2539	// Run op in busy cursor.	2539	// Run op in busy cursor.
2540	// Use set redraw to eliminate the "flash" that can occur in the	2540	// Use set redraw to eliminate the "flash" that can occur in the
2541	// coolbar as the perspective is reset.	2541	// coolbar as the perspective is reset.
2542	ICoolBarManager mgr = window.getCoolBarManager2();	2542	ICoolBarManager2 mgr = (ICoolBarManager2) window.getCoolBarManager2();
2543	try {	2543	try {
2544	mgr.getControl().setRedraw(false);	2544	mgr.getControl2().setRedraw(false);
2545	BusyIndicator.showWhile(null, new Runnable() {	2545	BusyIndicator.showWhile(null, new Runnable() {
2546	public void run() {	2546	public void run() {
2547	busyResetPerspective();	2547	busyResetPerspective();
2548	}	2548	}
2549	});	2549	});
2550	} finally {	2550	} finally {
2551	mgr.getControl().setRedraw(true);	2551	mgr.getControl2().setRedraw(true);
2552	}	2552	}
2553	}	2553	}
2554		2554
Lines 3148-3154 Link Here
3148	// Going from multiple to single rows can make the coolbar	3148	// Going from multiple to single rows can make the coolbar
3149	// and its adjacent views appear jumpy as perspectives are	3149	// and its adjacent views appear jumpy as perspectives are
3150	// switched. Turn off redraw to help with this.	3150	// switched. Turn off redraw to help with this.
3151	ICoolBarManager mgr = window.getCoolBarManager2();	3151	ICoolBarManager2 mgr = (ICoolBarManager2) window.getCoolBarManager2();
3152	try {	3152	try {
3153	mgr.getControl2().setRedraw(false);	3153	mgr.getControl2().setRedraw(false);
3154	getClientComposite().setRedraw(false);	3154	getClientComposite().setRedraw(false);
Lines 3180-3186 Link Here
3180	* Restore the toolbar layout for the active perspective.	3180	* Restore the toolbar layout for the active perspective.
3181	*/	3181	*/
3182	protected void resetToolBarLayout() {	3182	protected void resetToolBarLayout() {
3183	window.getCoolBarManager2().resetItemOrder();	3183	ICoolBarManager2 mgr = (ICoolBarManager2) window.getCoolBarManager2();
		3184	mgr.resetItemOrder();
3184	}	3185	}
3185		3186
3186	/**	3187	/**

Lines 18-31 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/ActionSetActionBars.java (-4 / +4 lines)
18	import org.eclipse.jface.action.IContributionManager;	18	import org.eclipse.jface.action.IContributionManager;
19	import org.eclipse.jface.action.ICoolBarManager;	19	import org.eclipse.jface.action.ICoolBarManager;
20	import org.eclipse.jface.action.IMenuManager;	20	import org.eclipse.jface.action.IMenuManager;
21	import org.eclipse.jface.action.IToolBarContributionItem;
22	import org.eclipse.jface.action.IToolBarManager;	21	import org.eclipse.jface.action.IToolBarManager;
23	import org.eclipse.jface.action.SubMenuManager;	22	import org.eclipse.jface.action.SubMenuManager;
24	import org.eclipse.jface.action.SubToolBarManager;	23	import org.eclipse.jface.action.SubToolBarManager;
		24	import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
25	import org.eclipse.ui.IActionBars2;	25	import org.eclipse.ui.IActionBars2;
26	import org.eclipse.ui.IWorkbenchActionConstants;	26	import org.eclipse.ui.IWorkbenchActionConstants;
27	import org.eclipse.ui.SubActionBars2;	27	import org.eclipse.ui.SubActionBars2;
28	import org.eclipse.ui.application.IActionBarConfigurer;	28	import org.eclipse.ui.internal.provisional.application.IActionBarConfigurer2;
29	import org.eclipse.ui.services.IServiceLocator;	29	import org.eclipse.ui.services.IServiceLocator;
30		30
31	/**	31	/**
Lines 33-39 Link Here
33	*/	33	*/
34	public class ActionSetActionBars extends SubActionBars2 {	34	public class ActionSetActionBars extends SubActionBars2 {
35		35
36	private IActionBarConfigurer actionBarConfigurer = null;	36	private IActionBarConfigurer2 actionBarConfigurer = null;
37		37
38	private String actionSetId;	38	private String actionSetId;
39		39
Lines 46-52 Link Here
46	/**	46	/**
47	* Constructs a new action bars object	47	* Constructs a new action bars object
48	*/	48	*/
49	public ActionSetActionBars(IActionBars2 parent, IServiceLocator serviceLocator, IActionBarConfigurer actionBarConfigurer, String actionSetId) {	49	public ActionSetActionBars(IActionBars2 parent, IServiceLocator serviceLocator, IActionBarConfigurer2 actionBarConfigurer, String actionSetId) {
50	super(parent, serviceLocator);	50	super(parent, serviceLocator);
51	this.actionSetId = actionSetId;	51	this.actionSetId = actionSetId;
52	this.actionBarConfigurer = actionBarConfigurer;	52	this.actionBarConfigurer = actionBarConfigurer;

Lines 18-29 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/EditorActionBars.java (-2 / +2 lines)
18	import org.eclipse.jface.action.IContributionManagerOverrides;	18	import org.eclipse.jface.action.IContributionManagerOverrides;
19	import org.eclipse.jface.action.ICoolBarManager;	19	import org.eclipse.jface.action.ICoolBarManager;
20	import org.eclipse.jface.action.IMenuManager;	20	import org.eclipse.jface.action.IMenuManager;
21	import org.eclipse.jface.action.IToolBarContributionItem;
22	import org.eclipse.jface.action.IToolBarManager;	21	import org.eclipse.jface.action.IToolBarManager;
23	import org.eclipse.jface.action.SubContributionManager;	22	import org.eclipse.jface.action.SubContributionManager;
24	import org.eclipse.jface.action.SubMenuManager;	23	import org.eclipse.jface.action.SubMenuManager;
25	import org.eclipse.jface.action.SubStatusLineManager;	24	import org.eclipse.jface.action.SubStatusLineManager;
26	import org.eclipse.jface.action.SubToolBarManager;	25	import org.eclipse.jface.action.SubToolBarManager;
		26	import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
27	import org.eclipse.ui.IActionBars2;	27	import org.eclipse.ui.IActionBars2;
28	import org.eclipse.ui.IEditorActionBarContributor;	28	import org.eclipse.ui.IEditorActionBarContributor;
29	import org.eclipse.ui.IEditorPart;	29	import org.eclipse.ui.IEditorPart;
Lines 32-38 Link Here
32	import org.eclipse.ui.SubActionBars2;	32	import org.eclipse.ui.SubActionBars2;
33	import org.eclipse.ui.actions.RetargetAction;	33	import org.eclipse.ui.actions.RetargetAction;
34	import org.eclipse.ui.internal.misc.Policy;	34	import org.eclipse.ui.internal.misc.Policy;
35	import org.eclipse.ui.internal.presentations.IActionBarPresentationFactory;	35	import org.eclipse.ui.internal.provisional.presentations.IActionBarPresentationFactory;
36	import org.eclipse.ui.services.IServiceLocator;	36	import org.eclipse.ui.services.IServiceLocator;
37		37
38	/**	38	/**

Lines 20-25 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/ActionPresentation.java (-1 / +2 lines)
20	import org.eclipse.core.runtime.CoreException;	20	import org.eclipse.core.runtime.CoreException;
21	import org.eclipse.core.runtime.dynamichelpers.IExtensionTracker;	21	import org.eclipse.core.runtime.dynamichelpers.IExtensionTracker;
22	import org.eclipse.ui.SubActionBars;	22	import org.eclipse.ui.SubActionBars;
		23	import org.eclipse.ui.internal.provisional.application.IActionBarConfigurer2;
23	import org.eclipse.ui.internal.registry.IActionSet;	24	import org.eclipse.ui.internal.registry.IActionSet;
24	import org.eclipse.ui.internal.registry.IActionSetDescriptor;	25	import org.eclipse.ui.internal.registry.IActionSetDescriptor;
25		26
Lines 147-153 Link Here
147	IActionSet set = desc.createActionSet();	148	IActionSet set = desc.createActionSet();
148	SubActionBars bars = new ActionSetActionBars(window	149	SubActionBars bars = new ActionSetActionBars(window
149	.getActionBars(), window,	150	.getActionBars(), window,
150	window.getWindowConfigurer()	151	(IActionBarConfigurer2) window.getWindowConfigurer()
151	.getActionBarConfigurer(), desc.getId());	152	.getActionBarConfigurer(), desc.getId());
152	rec = new SetRec(desc, set, bars);	153	rec = new SetRec(desc, set, bars);
153	set.init(window, bars);	154	set.init(window, bars);

Lines 14-21 Link Here

(-)Eclipse UI/org/eclipse/ui/application/IActionBarConfigurer.java (-24 lines)
14	import org.eclipse.jface.action.ICoolBarManager;	14	import org.eclipse.jface.action.ICoolBarManager;
15	import org.eclipse.jface.action.IMenuManager;	15	import org.eclipse.jface.action.IMenuManager;
16	import org.eclipse.jface.action.IStatusLineManager;	16	import org.eclipse.jface.action.IStatusLineManager;
17	import org.eclipse.jface.action.IToolBarContributionItem;
18	import org.eclipse.jface.action.IToolBarManager;
19		17
20	/**	18	/**
21	* Interface providing special access for configuring the action bars	19	* Interface providing special access for configuring the action bars
Lines 65-92 Link Here
65	public ICoolBarManager getCoolBarManager();	63	public ICoolBarManager getCoolBarManager();
66		64
67	/**	65	/**
68	* Creates a tool bar manager for the workbench window's tool bar.
69	* The action bar advisor should use this factory method rather than
70	* creating a <code>ToolBarManager</code> directly.
71	*
72	* @return the tool bar manager
73	* @since 3.2
74	*/
75	public IToolBarManager createToolBarManager();
76
77	/**
78	* Creates a toolbar contribution item for the window's tool bar.
79	* The action bar advisor should use this factory method rather than
80	* creating a <code>ToolBarContributionItem</code> directly.
81	*
82	* @param toolBarManager a tool bar manager for the workbench window's tool bar
83	* @param id the id of the contribution
84	* @return the tool bar contribution item
85	* @since 3.2
86	*/
87	public IToolBarContributionItem createToolBarContributionItem(IToolBarManager toolBarManager, String id);
88
89	/**
90	* Register the action as a global action with a workbench	66	* Register the action as a global action with a workbench
91	* window.	67	* window.
92	* <p>	68	* <p>

Lines 26-38 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/CustomizePerspectiveDialog.java (-5 / +5 lines)
26	import org.eclipse.jface.action.ICoolBarManager;	26	import org.eclipse.jface.action.ICoolBarManager;
27	import org.eclipse.jface.action.IMenuManager;	27	import org.eclipse.jface.action.IMenuManager;
28	import org.eclipse.jface.action.IStatusLineManager;	28	import org.eclipse.jface.action.IStatusLineManager;
29	import org.eclipse.jface.action.IToolBarContributionItem;
30	import org.eclipse.jface.action.IToolBarManager;	29	import org.eclipse.jface.action.IToolBarManager;
31	import org.eclipse.jface.action.MenuManager;	30	import org.eclipse.jface.action.MenuManager;
32	import org.eclipse.jface.action.StatusLineManager;	31	import org.eclipse.jface.action.StatusLineManager;
33	import org.eclipse.jface.action.ToolBarContributionItem;
34	import org.eclipse.jface.action.ToolBarManager;	32	import org.eclipse.jface.action.ToolBarManager;
35	import org.eclipse.jface.dialogs.TrayDialog;	33	import org.eclipse.jface.dialogs.TrayDialog;
		34	import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
		35	import org.eclipse.jface.internal.provisional.action.ToolBarContributionItem2;
36	import org.eclipse.jface.resource.ImageDescriptor;	36	import org.eclipse.jface.resource.ImageDescriptor;
37	import org.eclipse.jface.viewers.AbstractTreeViewer;	37	import org.eclipse.jface.viewers.AbstractTreeViewer;
38	import org.eclipse.jface.viewers.ArrayContentProvider;	38	import org.eclipse.jface.viewers.ArrayContentProvider;
Lines 86-92 Link Here
86	import org.eclipse.ui.PlatformUI;	86	import org.eclipse.ui.PlatformUI;
87	import org.eclipse.ui.activities.WorkbenchActivityHelper;	87	import org.eclipse.ui.activities.WorkbenchActivityHelper;
88	import org.eclipse.ui.application.ActionBarAdvisor;	88	import org.eclipse.ui.application.ActionBarAdvisor;
89	import org.eclipse.ui.application.IActionBarConfigurer;
90	import org.eclipse.ui.application.IWorkbenchWindowConfigurer;	89	import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
91	import org.eclipse.ui.internal.ActionSetActionBars;	90	import org.eclipse.ui.internal.ActionSetActionBars;
92	import org.eclipse.ui.internal.ActionSetContributionItem;	91	import org.eclipse.ui.internal.ActionSetContributionItem;
Lines 102-107 Link Here
102	import org.eclipse.ui.internal.WorkbenchPlugin;	101	import org.eclipse.ui.internal.WorkbenchPlugin;
103	import org.eclipse.ui.internal.WorkbenchWindow;	102	import org.eclipse.ui.internal.WorkbenchWindow;
104	import org.eclipse.ui.internal.intro.IIntroConstants;	103	import org.eclipse.ui.internal.intro.IIntroConstants;
		104	import org.eclipse.ui.internal.provisional.application.IActionBarConfigurer2;
105	import org.eclipse.ui.internal.registry.ActionSetDescriptor;	105	import org.eclipse.ui.internal.registry.ActionSetDescriptor;
106	import org.eclipse.ui.internal.registry.ActionSetRegistry;	106	import org.eclipse.ui.internal.registry.ActionSetRegistry;
107	import org.eclipse.ui.internal.registry.IActionSetDescriptor;	107	import org.eclipse.ui.internal.registry.IActionSetDescriptor;
Lines 386-392 Link Here
386	* window's hardwired menus and toolbars in order to display their	386	* window's hardwired menus and toolbars in order to display their
387	* structure properly in the preview panes.	387	* structure properly in the preview panes.
388	*/	388	*/
389	public class CustomizeActionBars implements IActionBarConfigurer,	389	public class CustomizeActionBars implements IActionBarConfigurer2,
390	IActionBars2 {	390	IActionBars2 {
391		391
392	IWorkbenchWindowConfigurer configurer;	392	IWorkbenchWindowConfigurer configurer;
Lines 486-492 Link Here
486	* @see org.eclipse.ui.application.IActionBarConfigurer#createToolBarContributionItem(org.eclipse.jface.action.IToolBarManager, java.lang.String)	486	* @see org.eclipse.ui.application.IActionBarConfigurer#createToolBarContributionItem(org.eclipse.jface.action.IToolBarManager, java.lang.String)
487	*/	487	*/
488	public IToolBarContributionItem createToolBarContributionItem(IToolBarManager toolBarManager, String id) {	488	public IToolBarContributionItem createToolBarContributionItem(IToolBarManager toolBarManager, String id) {
489	return new ToolBarContributionItem(toolBarManager, id);	489	return new ToolBarContributionItem2(toolBarManager, id);
490	}	490	}
491		491
492	/* (non-Javadoc)	492	/* (non-Javadoc)

Lines 10-25 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/presentations/DefaultActionBarPresentationFactory.java (-12 / +13 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.ui.internal.presentations;	11	package org.eclipse.ui.internal.presentations;
12		12
13	import org.eclipse.jface.action.CoolBarManager;
14	import org.eclipse.jface.action.ICoolBarManager;
15	import org.eclipse.jface.action.IToolBarContributionItem;
16	import org.eclipse.jface.action.IToolBarManager;	13	import org.eclipse.jface.action.IToolBarManager;
17	import org.eclipse.jface.action.IToolBarManager2;	14	import org.eclipse.jface.internal.provisional.action.CoolBarManager2;
18	import org.eclipse.jface.action.ToolBarContributionItem;	15	import org.eclipse.jface.internal.provisional.action.ICoolBarManager2;
19	import org.eclipse.jface.action.ToolBarManager;	16	import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
		17	import org.eclipse.jface.internal.provisional.action.IToolBarManager2;
		18	import org.eclipse.jface.internal.provisional.action.ToolBarContributionItem2;
		19	import org.eclipse.jface.internal.provisional.action.ToolBarManager2;
20	import org.eclipse.swt.SWT;	20	import org.eclipse.swt.SWT;
21	import org.eclipse.swt.widgets.Composite;	21	import org.eclipse.swt.widgets.Composite;
22	import org.eclipse.swt.widgets.Control;	22	import org.eclipse.swt.widgets.Control;
		23	import org.eclipse.ui.internal.provisional.presentations.IActionBarPresentationFactory;
23		24
24	/**	25	/**
25	* The intention of this class is to allow for replacing the implementation of	26	* The intention of this class is to allow for replacing the implementation of
Lines 38-51 Link Here
38	/* (non-Javadoc)	39	/* (non-Javadoc)
39	* @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createCoolBarManager()	40	* @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createCoolBarManager()
40	*/	41	*/
41	public ICoolBarManager createCoolBarManager() {	42	public ICoolBarManager2 createCoolBarManager() {
42	return new CoolBarManager(SWT.FLAT);	43	return new CoolBarManager2(SWT.FLAT);
43	}	44	}
44		45
45	/* (non-Javadoc)	46	/* (non-Javadoc)
46	* @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createCoolBarControl(org.eclipse.jface.action.ICoolBarManager, org.eclipse.swt.widgets.Composite)	47	* @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createCoolBarControl(org.eclipse.jface.action.ICoolBarManager, org.eclipse.swt.widgets.Composite)
47	*/	48	*/
48	public Control createCoolBarControl(ICoolBarManager coolBarManager,	49	public Control createCoolBarControl(ICoolBarManager2 coolBarManager,
49	Composite parent) {	50	Composite parent) {
50	return coolBarManager.createControl2(parent);	51	return coolBarManager.createControl2(parent);
51	}	52	}
Lines 54-60 Link Here
54	* @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createToolBarManager()	55	* @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createToolBarManager()
55	*/	56	*/
56	public IToolBarManager2 createToolBarManager() {	57	public IToolBarManager2 createToolBarManager() {
57	return new ToolBarManager(SWT.FLAT \| SWT.RIGHT);	58	return new ToolBarManager2(SWT.FLAT \| SWT.RIGHT);
58	}	59	}
59		60
60	/* (non-Javadoc)	61	/* (non-Javadoc)
Lines 69-75 Link Here
69	* @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createViewToolBarManager()	70	* @see org.eclipse.ui.internal.presentations.IActionBarPresentationFactory#createViewToolBarManager()
70	*/	71	*/
71	public IToolBarManager2 createViewToolBarManager() {	72	public IToolBarManager2 createViewToolBarManager() {
72	return new ToolBarManager(SWT.FLAT \| SWT.RIGHT);	73	return new ToolBarManager2(SWT.FLAT \| SWT.RIGHT);
73	}	74	}
74		75
75	/* (non-Javadoc)	76	/* (non-Javadoc)
Lines 85-90 Link Here
85	*/	86	*/
86	public IToolBarContributionItem createToolBarContributionItem(	87	public IToolBarContributionItem createToolBarContributionItem(
87	IToolBarManager toolBarManager, String id) {	88	IToolBarManager toolBarManager, String id) {
88	return new ToolBarContributionItem(toolBarManager, id);	89	return new ToolBarContributionItem2(toolBarManager, id);
89	}	90	}
90	}	91	}

Lines 35-40 Link Here

(-)META-INF/MANIFEST.MF (+3 lines)
35	org.eclipse.ui.internal.dnd;x-friends:="org.eclipse.ui.intro,org.eclipse.ui.presentations.r21",	35	org.eclipse.ui.internal.dnd;x-friends:="org.eclipse.ui.intro,org.eclipse.ui.presentations.r21",
36	org.eclipse.ui.internal.editorsupport;x-internal:=true,	36	org.eclipse.ui.internal.editorsupport;x-internal:=true,
37	org.eclipse.ui.internal.expressions;x-internal:=true,	37	org.eclipse.ui.internal.expressions;x-internal:=true,
		38	org.eclipse.ui.internal.fieldassist;x-internal:=true,
38	org.eclipse.ui.internal.handlers;x-internal:=true,	39	org.eclipse.ui.internal.handlers;x-internal:=true,
39	org.eclipse.ui.internal.help;x-internal:=true,	40	org.eclipse.ui.internal.help;x-internal:=true,
40	org.eclipse.ui.internal.intro;x-internal:=true,	41	org.eclipse.ui.internal.intro;x-internal:=true,
Lines 49-54 Link Here
49	org.eclipse.ui.internal.presentations.defaultpresentation;x-internal:=true,	50	org.eclipse.ui.internal.presentations.defaultpresentation;x-internal:=true,
50	org.eclipse.ui.internal.presentations.util;x-friends:="org.eclipse.ui.presentations.r21",	51	org.eclipse.ui.internal.presentations.util;x-friends:="org.eclipse.ui.presentations.r21",
51	org.eclipse.ui.internal.progress;x-internal:=true,	52	org.eclipse.ui.internal.progress;x-internal:=true,
		53	org.eclipse.ui.internal.provisional.application,
		54	org.eclipse.ui.internal.provisional.presentations,
52	org.eclipse.ui.internal.registry;x-internal:=true,	55	org.eclipse.ui.internal.registry;x-internal:=true,
53	org.eclipse.ui.internal.services;x-internal:=true,	56	org.eclipse.ui.internal.services;x-internal:=true,
54	org.eclipse.ui.internal.testing;x-internal:=true,	57	org.eclipse.ui.internal.testing;x-internal:=true,

Added Link Here

(-)Eclipse (+50 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.provisional.application;
13
14	import org.eclipse.jface.action.IToolBarManager;
15	import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
16	import org.eclipse.ui.application.IActionBarConfigurer;
17
18	/**
19	* Extends <code>IActionBarConfigurer</code> with API to allow the advisor to
20	* be decoupled from the implementation types for tool bar managers and tool bar
21	* contribution items.
22	*
23	* @since 3.2
24	*/
25	public interface IActionBarConfigurer2 extends IActionBarConfigurer {
26
27	/**
28	* Creates a tool bar manager for the workbench window's tool bar. The
29	* action bar advisor should use this factory method rather than creating a
30	* <code>ToolBarManager</code> directly.
31	*
32	* @return the tool bar manager
33	*/
34	public IToolBarManager createToolBarManager();
35
36	/**
37	* Creates a toolbar contribution item for the window's tool bar. The action
38	* bar advisor should use this factory method rather than creating a
39	* <code>ToolBarContributionItem</code> directly.
40	*
41	* @param toolBarManager
42	* a tool bar manager for the workbench window's tool bar
43	* @param id
44	* the id of the contribution
45	* @return the tool bar contribution item
46	*/
47	public IToolBarContributionItem createToolBarContributionItem(
48	IToolBarManager toolBarManager, String id);
49
50	}

Added Link Here

(-)Eclipse (+105 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.provisional.presentations;
13
14	import org.eclipse.jface.action.IToolBarManager;
15	import org.eclipse.jface.internal.provisional.action.ICoolBarManager2;
16	import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
17	import org.eclipse.jface.internal.provisional.action.IToolBarManager2;
18	import org.eclipse.swt.widgets.Composite;
19	import org.eclipse.swt.widgets.Control;
20
21	/**
22	* The intention of this class is to allow for replacing the implementation of
23	* the cool bar and tool bars in the workbench.
24	* <p>
25	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
26	* part of a work in progress. There is a guarantee neither that this API will
27	* work nor that it will remain the same. Please do not use this API without
28	* consulting with the Platform/UI team.
29	* </p>
30	*
31	* @since 3.2
32	*/
33	public interface IActionBarPresentationFactory {
34
35	/**
36	* Creates the cool bar manager for the window's tool bar area.
37	*
38	* @return the cool bar manager
39	*/
40	public ICoolBarManager2 createCoolBarManager();
41
42	/**
43	* Creates the control for the window's cool bar. Subclasses may override.
44	*
45	* @param coolBarManager
46	* the window's cool bar manager
47	* @param parent
48	* the parent composite
49	* @return the window's cool bar control
50	*/
51	public Control createCoolBarControl(ICoolBarManager2 coolBarManager,
52	Composite parent);
53
54	/**
55	* Creates a tool bar manager for window's tool bar area.
56	*
57	* @return the tool bar manager
58	*/
59	public IToolBarManager2 createToolBarManager();
60
61	/**
62	* Creates the control for the window's tool bar. Subclasses may override.
63	*
64	* @param toolBarManager
65	* the window's toolbar manager
66	* @param parent
67	* the parent composite
68	* @return the window's tool bar control
69	*/
70	public Control createToolBarControl(IToolBarManager2 toolBarManager,
71	Composite parent);
72
73	/**
74	* Creates a tool bar manager for a view's tool bar.
75	*
76	* @return the tool bar manager
77	*/
78	public IToolBarManager2 createViewToolBarManager();
79
80	/**
81	* Creates the control for a view tool bar. Subclasses may override.
82	*
83	* @param toolBarManager
84	* the view's tool bar manager
85	* @param parent
86	* the parent composite
87	* @return the view's tool bar control
88	*/
89	public Control createViewToolBarControl(IToolBarManager2 toolBarManager,
90	Composite parent);
91
92	/**
93	* Creates a toolbar contribution item for a window toolbar manager to be
94	* added to the window's cool bar.
95	*
96	* @param toolBarManager
97	* the tool bar manager
98	* @param id
99	* the id of the contribution
100	* @return the toolbar contribution item
101	*/
102	public IToolBarContributionItem createToolBarContributionItem(
103	IToolBarManager toolBarManager, String id);
104
105	}

Lines 26-35 Link Here

(-)src/org/eclipse/ui/internal/ide/WorkbenchActionBuilder.java (-2 / +3 lines)
26	import org.eclipse.jface.action.ICoolBarManager;	26	import org.eclipse.jface.action.ICoolBarManager;
27	import org.eclipse.jface.action.IMenuManager;	27	import org.eclipse.jface.action.IMenuManager;
28	import org.eclipse.jface.action.IStatusLineManager;	28	import org.eclipse.jface.action.IStatusLineManager;
29	import org.eclipse.jface.action.IToolBarContributionItem;
30	import org.eclipse.jface.action.IToolBarManager;	29	import org.eclipse.jface.action.IToolBarManager;
31	import org.eclipse.jface.action.MenuManager;	30	import org.eclipse.jface.action.MenuManager;
32	import org.eclipse.jface.action.Separator;	31	import org.eclipse.jface.action.Separator;
		32	import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
33	import org.eclipse.jface.preference.IPreferenceStore;	33	import org.eclipse.jface.preference.IPreferenceStore;
34	import org.eclipse.jface.util.IPropertyChangeListener;	34	import org.eclipse.jface.util.IPropertyChangeListener;
35	import org.eclipse.jface.util.PropertyChangeEvent;	35	import org.eclipse.jface.util.PropertyChangeEvent;
Lines 53-58 Link Here
53	import org.eclipse.ui.internal.ide.actions.BuildUtilities;	53	import org.eclipse.ui.internal.ide.actions.BuildUtilities;
54	import org.eclipse.ui.internal.ide.actions.QuickMenuAction;	54	import org.eclipse.ui.internal.ide.actions.QuickMenuAction;
55	import org.eclipse.ui.internal.ide.actions.RetargetActionWithDefault;	55	import org.eclipse.ui.internal.ide.actions.RetargetActionWithDefault;
		56	import org.eclipse.ui.internal.provisional.application.IActionBarConfigurer2;
56	import org.eclipse.ui.internal.util.StatusLineContributionItem;	57	import org.eclipse.ui.internal.util.StatusLineContributionItem;
57		58
58	/**	59	/**
Lines 355-361 Link Here
355	*/	356	*/
356	protected void fillCoolBar(ICoolBarManager coolBar) {	357	protected void fillCoolBar(ICoolBarManager coolBar) {
357		358
358	IActionBarConfigurer actionBarConfigurer = getActionBarConfigurer();	359	IActionBarConfigurer2 actionBarConfigurer = (IActionBarConfigurer2) getActionBarConfigurer();
359	{ // Set up the context Menu	360	{ // Set up the context Menu
360	IMenuManager popUpMenu = new MenuManager();	361	IMenuManager popUpMenu = new MenuManager();
361	popUpMenu.add(new ActionContributionItem(lockToolBarAction));	362	popUpMenu.add(new ActionContributionItem(lockToolBarAction));