Attachment #34108 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




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.IActionBars2;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;

            
            EditorSite site = new EditorSite(this, part, manager.page, descr);
            
            site.setActionBars(new EditorActionBars(manager.page, site, getId()));
					.getActionBars(), site, getId()));
            try {
                part.init(site, input);
            } catch (PartInitException e) {

Lines 1-5 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/WorkbenchWindowConfigurer.java (-3 / +33 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2003, 2005 IBM Corporation and others.	2	* Copyright (c) 2003, 2006 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 20-25 Link Here
20	import org.eclipse.jface.action.ICoolBarManager;	20	import org.eclipse.jface.action.ICoolBarManager;
21	import org.eclipse.jface.action.IMenuManager;	21	import org.eclipse.jface.action.IMenuManager;
22	import org.eclipse.jface.action.IStatusLineManager;	22	import org.eclipse.jface.action.IStatusLineManager;
		23	import org.eclipse.jface.action.IToolBarManager;
		24	import org.eclipse.jface.action.IToolBarManager2;
23	import org.eclipse.jface.window.Window;	25	import org.eclipse.jface.window.Window;
24	import org.eclipse.swt.SWT;	26	import org.eclipse.swt.SWT;
25	import org.eclipse.swt.dnd.DropTarget;	27	import org.eclipse.swt.dnd.DropTarget;
Lines 37-42 Link Here
37	import org.eclipse.ui.application.IWorkbenchConfigurer;	39	import org.eclipse.ui.application.IWorkbenchConfigurer;
38	import org.eclipse.ui.application.IWorkbenchWindowConfigurer;	40	import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
39	import org.eclipse.ui.application.WorkbenchAdvisor;	41	import org.eclipse.ui.application.WorkbenchAdvisor;
		42	import org.eclipse.ui.internal.presentations.ActionBarPresentation;
40	import org.eclipse.ui.presentations.AbstractPresentationFactory;	43	import org.eclipse.ui.presentations.AbstractPresentationFactory;
41	import org.eclipse.ui.presentations.WorkbenchPresentationFactory;	44	import org.eclipse.ui.presentations.WorkbenchPresentationFactory;
42		45
Lines 205-211 Link Here
205	if (proxy != null) {	208	if (proxy != null) {
206	return proxy.getCoolBarManager();	209	return proxy.getCoolBarManager();
207	}	210	}
208	return window.getCoolBarManager();	211	return window.getCoolBarManager2();
209	}	212	}
210		213
211	/* (non-Javadoc)	214	/* (non-Javadoc)
Lines 217-222 Link Here
217	}	220	}
218	window.registerGlobalAction(action);	221	window.registerGlobalAction(action);
219	}	222	}
		223
		224	private ActionBarPresentation getActionBarPresentation() {
		225	WorkbenchWindow window = (WorkbenchWindow)getWindowConfigurer().getWindow();
		226	return window.getActionBarPresentation();
		227	}
		228
		229	/* (non-Javadoc)
		230	* @see org.eclipse.ui.application.IActionBarConfigurer#createToolBarManager(int)
		231	*/
		232	public IToolBarManager createToolBarManager(int style) {
		233	return getActionBarPresentation().createToolBarManager(style);
		234	}
		235
		236	/* (non-Javadoc)
		237	* @see org.eclipse.ui.application.IActionBarConfigurer#createToolBarControl(org.eclipse.jface.action.IToolBarManager2, org.eclipse.swt.widgets.Composite)
		238	*/
		239	public Control createToolBarControl(IToolBarManager2 toolBarManager, Composite parent) {
		240	return getActionBarPresentation().createToolBarControl(toolBarManager, parent);
		241	}
		242
		243	/* (non-Javadoc)
		244	* @see org.eclipse.ui.application.IActionBarConfigurer#createToolBarContributionItem(org.eclipse.jface.action.IToolBarManager, java.lang.String)
		245	*/
		246	public IContributionItem createToolBarContributionItem(IToolBarManager toolBarManager, String id) {
		247	return getActionBarPresentation().createToolBarContributionItem(toolBarManager, id);
		248	}
220	}	249	}
221		250
222	/**	251	/**
Lines 588-594 Link Here
588	* @see org.eclipse.ui.application.IWorkbenchWindowConfigurer	617	* @see org.eclipse.ui.application.IWorkbenchWindowConfigurer
589	*/	618	*/
590	public Control createCoolBarControl(Composite parent) {	619	public Control createCoolBarControl(Composite parent) {
591	return window.getCoolBarManager().createControl(parent);	620	return actionBarConfigurer.getActionBarPresentation().createCoolBarControl(
		621	window.getCoolBarManager2(), parent);
592	}	622	}
593		623
594	/* (non-Javadoc)	624	/* (non-Javadoc)

Lines 1-5 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/WorkbenchWindow.java (-37 / +113 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.	2	* Copyright (c) 2000, 2006 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 36-47 Link Here
36	import org.eclipse.jface.action.IAction;	36	import org.eclipse.jface.action.IAction;
37	import org.eclipse.jface.action.IContributionItem;	37	import org.eclipse.jface.action.IContributionItem;
38	import org.eclipse.jface.action.IContributionManager;	38	import org.eclipse.jface.action.IContributionManager;
		39	import org.eclipse.jface.action.ICoolBarManager;
39	import org.eclipse.jface.action.IMenuManager;	40	import org.eclipse.jface.action.IMenuManager;
		41	import org.eclipse.jface.action.IToolBarContributionItem;
		42	import org.eclipse.jface.action.IToolBarManager2;
40	import org.eclipse.jface.action.MenuManager;	43	import org.eclipse.jface.action.MenuManager;
41	import org.eclipse.jface.action.Separator;	44	import org.eclipse.jface.action.Separator;
42	import org.eclipse.jface.action.StatusLineManager;	45	import org.eclipse.jface.action.StatusLineManager;
43	import org.eclipse.jface.action.ToolBarContributionItem;
44	import org.eclipse.jface.action.ToolBarManager;
45	import org.eclipse.jface.commands.ActionHandler;	46	import org.eclipse.jface.commands.ActionHandler;
46	import org.eclipse.jface.menus.ILayoutNode;	47	import org.eclipse.jface.menus.ILayoutNode;
47	import org.eclipse.jface.menus.SMenuLayout;	48	import org.eclipse.jface.menus.SMenuLayout;
Lines 117-122 Link Here
117	import org.eclipse.ui.internal.misc.Policy;	118	import org.eclipse.ui.internal.misc.Policy;
118	import org.eclipse.ui.internal.misc.UIListenerLogging;	119	import org.eclipse.ui.internal.misc.UIListenerLogging;
119	import org.eclipse.ui.internal.misc.UIStats;	120	import org.eclipse.ui.internal.misc.UIStats;
		121	import org.eclipse.ui.internal.presentations.ActionBarPresentation;
		122	import org.eclipse.ui.internal.presentations.InternalPresentationFactory;
120	import org.eclipse.ui.internal.progress.ProgressRegion;	123	import org.eclipse.ui.internal.progress.ProgressRegion;
121	import org.eclipse.ui.internal.registry.ActionSetRegistry;	124	import org.eclipse.ui.internal.registry.ActionSetRegistry;
122	import org.eclipse.ui.internal.registry.IActionSetDescriptor;	125	import org.eclipse.ui.internal.registry.IActionSetDescriptor;
Lines 125-130 Link Here
125	import org.eclipse.ui.internal.services.ServiceLocator;	128	import org.eclipse.ui.internal.services.ServiceLocator;
126	import org.eclipse.ui.internal.util.PrefUtil;	129	import org.eclipse.ui.internal.util.PrefUtil;
127	import org.eclipse.ui.menus.IMenuService;	130	import org.eclipse.ui.menus.IMenuService;
		131	import org.eclipse.ui.presentations.AbstractPresentationFactory;
128		132
129	/**	133	/**
130	* A window within the workbench.	134	* A window within the workbench.
Lines 318-325 Link Here
318	addCoolBar(SWT.FLAT);	322	addCoolBar(SWT.FLAT);
319	addStatusLine();	323	addStatusLine();
320		324
321	actionPresentation = new ActionPresentation(this);
322
323	// register with the tracker	325	// register with the tracker
324	getExtensionTracker()	326	getExtensionTracker()
325	.registerHandler(	327	.registerHandler(
Lines 700-706 Link Here
700	* Return whether or not the coolbar layout is locked.	702	* Return whether or not the coolbar layout is locked.
701	*/	703	*/
702	protected boolean isCoolBarLocked() {	704	protected boolean isCoolBarLocked() {
703	CoolBarManager cbm = getCoolBarManager();	705	ICoolBarManager cbm = getCoolBarManager2();
704	return cbm != null && cbm.getLockLayout();	706	return cbm != null && cbm.getLockLayout();
705	}	707	}
706		708
Lines 1411-1417 Link Here
1411	boolean result;	1413	boolean result;
1412	try {	1414	try {
1413	// Clear the action sets, fix for bug 27416.	1415	// Clear the action sets, fix for bug 27416.
1414	actionPresentation.clearActionSets();	1416	getActionPresentation().clearActionSets();
1415		1417
1416	// Remove the handler submissions. Bug 64024.	1418	// Remove the handler submissions. Bug 64024.
1417	final IWorkbench workbench = getWorkbench();	1419	final IWorkbench workbench = getWorkbench();
Lines 1476-1482 Link Here
1476	*/	1478	*/
1477	/* package */	1479	/* package */
1478	void lockCoolBar(boolean lock) {	1480	void lockCoolBar(boolean lock) {
1479	getCoolBarManager().setLockLayout(lock);	1481	getCoolBarManager2().setLockLayout(lock);
1480	}	1482	}
1481		1483
1482	/**	1484	/**
Lines 1642-1649 Link Here
1642	// This needs to be done before pages are created to ensure proper	1644	// This needs to be done before pages are created to ensure proper
1643	// canonical creation	1645	// canonical creation
1644	// of cool items	1646	// of cool items
1645	if (getCoolBarManager() != null) {	1647	ICoolBarManager coolBarMgr = getCoolBarManager2();
1646	CoolBarManager coolBarMgr = getCoolBarManager();	1648	if (coolBarMgr != null) {
1647	IMemento coolBarMem = memento	1649	IMemento coolBarMem = memento
1648	.getChild(IWorkbenchConstants.TAG_COOLBAR_LAYOUT);	1650	.getChild(IWorkbenchConstants.TAG_COOLBAR_LAYOUT);
1649	if (coolBarMem != null) {	1651	if (coolBarMem != null) {
Lines 1711-1722 Link Here
1711	if (oldItem != null) {	1713	if (oldItem != null) {
1712	newItem = oldItem;	1714	newItem = oldItem;
1713	} else {	1715	} else {
1714	newItem = new ToolBarContributionItem(	1716	ActionBarPresentation actionBarPresentation = getActionBarPresentation();
1715	new ToolBarManager(coolBarMgr	1717	newItem = actionBarPresentation.createToolBarContributionItem(
		1718	actionBarPresentation.createToolBarManager(coolBarMgr
1716	.getStyle()), id);	1719	.getStyle()), id);
1717	if (type	1720	if (type
1718	.equals(IWorkbenchConstants.TAG_TYPE_PLACEHOLDER)) {	1721	.equals(IWorkbenchConstants.TAG_TYPE_PLACEHOLDER)) {
1719	ToolBarContributionItem newToolBarItem = (ToolBarContributionItem) newItem;	1722	IToolBarContributionItem newToolBarItem = (IToolBarContributionItem) newItem;
1720	if (height != null) {	1723	if (height != null) {
1721	newToolBarItem.setCurrentHeight(height	1724	newToolBarItem.setCurrentHeight(height
1722	.intValue());	1725	.intValue());
Lines 1744-1756 Link Here
1744	}	1747	}
1745	// Set the current height and width	1748	// Set the current height and width
1746	if ((width != null)	1749	if ((width != null)
1747	&& (newItem instanceof ToolBarContributionItem)) {	1750	&& (newItem instanceof IToolBarContributionItem)) {
1748	((ToolBarContributionItem) newItem)	1751	((IToolBarContributionItem) newItem)
1749	.setCurrentWidth(width.intValue());	1752	.setCurrentWidth(width.intValue());
1750	}	1753	}
1751	if ((height != null)	1754	if ((height != null)
1752	&& (newItem instanceof ToolBarContributionItem)) {	1755	&& (newItem instanceof IToolBarContributionItem)) {
1753	((ToolBarContributionItem) newItem)	1756	((IToolBarContributionItem) newItem)
1754	.setCurrentHeight(height.intValue());	1757	.setCurrentHeight(height.intValue());
1755	}	1758	}
1756	}	1759	}
Lines 1935-1941 Link Here
1935	if (coolbarMem == null) {	1938	if (coolbarMem == null) {
1936	return false;	1939	return false;
1937	}	1940	}
1938	CoolBarManager coolBarMgr = getCoolBarManager();	1941	ICoolBarManager coolBarMgr = getCoolBarManager2();
1939	// Check to see if layout is locked	1942	// Check to see if layout is locked
1940	Integer locked = coolbarMem.getInteger(IWorkbenchConstants.TAG_LOCKED);	1943	Integer locked = coolbarMem.getInteger(IWorkbenchConstants.TAG_LOCKED);
1941	boolean state = (locked != null) && (locked.intValue() == 1);	1944	boolean state = (locked != null) && (locked.intValue() == 1);
Lines 2027-2037 Link Here
2027	}	2030	}
2028	// If a tool bar contribution item already exists for this id	2031	// If a tool bar contribution item already exists for this id
2029	// then use the old object	2032	// then use the old object
2030	if (oldItem instanceof ToolBarContributionItem) {	2033	if (oldItem instanceof IToolBarContributionItem) {
2031	newItem = oldItem;	2034	newItem = oldItem;
2032	} else {	2035	} else {
2033	newItem = new ToolBarContributionItem(new ToolBarManager(	2036	ActionBarPresentation actionBarPresentaiton = getActionBarPresentation();
2034	coolBarMgr.getStyle()), id);	2037	newItem = actionBarPresentaiton.createToolBarContributionItem(
		2038	actionBarPresentaiton.createToolBarManager(coolBarMgr.getStyle()), id);
2035	// make it invisible by default	2039	// make it invisible by default
2036	newItem.setVisible(false);	2040	newItem.setVisible(false);
2037	// Need to add the item to the cool bar manager so that its	2041	// Need to add the item to the cool bar manager so that its
Lines 2267-2282 Link Here
2267	}	2271	}
2268		2272
2269	// / Save the order of the cool bar contribution items	2273	// / Save the order of the cool bar contribution items
2270	if (getCoolBarManager() != null) {	2274	ICoolBarManager coolBarMgr = getCoolBarManager2();
2271	getCoolBarManager().refresh();	2275	if (coolBarMgr != null) {
		2276	coolBarMgr.refresh();
2272	IMemento coolBarMem = memento	2277	IMemento coolBarMem = memento
2273	.createChild(IWorkbenchConstants.TAG_COOLBAR_LAYOUT);	2278	.createChild(IWorkbenchConstants.TAG_COOLBAR_LAYOUT);
2274	if (getCoolBarManager().getLockLayout() == true) {	2279	if (coolBarMgr.getLockLayout() == true) {
2275	coolBarMem.putInteger(IWorkbenchConstants.TAG_LOCKED, 1);	2280	coolBarMem.putInteger(IWorkbenchConstants.TAG_LOCKED, 1);
2276	} else {	2281	} else {
2277	coolBarMem.putInteger(IWorkbenchConstants.TAG_LOCKED, 0);	2282	coolBarMem.putInteger(IWorkbenchConstants.TAG_LOCKED, 0);
2278	}	2283	}
2279	IContributionItem[] items = getCoolBarManager().getItems();	2284	IContributionItem[] items = coolBarMgr.getItems();
2280	for (int i = 0; i < items.length; i++) {	2285	for (int i = 0; i < items.length; i++) {
2281	IMemento coolItemMem = coolBarMem	2286	IMemento coolItemMem = coolBarMem
2282	.createChild(IWorkbenchConstants.TAG_COOLITEM);	2287	.createChild(IWorkbenchConstants.TAG_COOLITEM);
Lines 2312-2319 Link Here
2312	*/	2317	*/
2313	final int height;	2318	final int height;
2314	final int width;	2319	final int width;
2315	if (item instanceof ToolBarContributionItem) {	2320	if (item instanceof IToolBarContributionItem) {
2316	ToolBarContributionItem toolBarItem = (ToolBarContributionItem) item;	2321	IToolBarContributionItem toolBarItem = (IToolBarContributionItem) item;
2317	toolBarItem.saveWidgetState();	2322	toolBarItem.saveWidgetState();
2318	height = toolBarItem.getCurrentHeight();	2323	height = toolBarItem.getCurrentHeight();
2319	width = toolBarItem.getCurrentWidth();	2324	width = toolBarItem.getCurrentWidth();
Lines 2619-2625 Link Here
2619	}	2624	}
2620	// updateAll required in order to enable accelerators on pull-down menus	2625	// updateAll required in order to enable accelerators on pull-down menus
2621	getMenuBarManager().updateAll(false);	2626	getMenuBarManager().updateAll(false);
2622	getCoolBarManager().update(false);	2627	getCoolBarManager2().update(false);
2623	getStatusLineManager().update(false);	2628	getStatusLineManager().update(false);
2624	}	2629	}
2625		2630
Lines 2683-2694 Link Here
2683		2688
2684	WorkbenchPage currentPage = getActiveWorkbenchPage();	2689	WorkbenchPage currentPage = getActiveWorkbenchPage();
2685	if (currentPage == null)	2690	if (currentPage == null)
2686	actionPresentation.clearActionSets();	2691	getActionPresentation().clearActionSets();
2687	else {	2692	else {
2688	if (getCoolBarManager() != null) {	2693	if (getCoolBarManager2() != null) {
2689	getCoolBarManager().refresh();	2694	getCoolBarManager2().refresh();
2690	}	2695	}
2691	actionPresentation.setActionSets(currentPage.getActionSets());	2696	getActionPresentation().setActionSets(currentPage.getActionSets());
2692	}	2697	}
2693	fireActionSetsChanged();	2698	fireActionSetsChanged();
2694	updateActionBars();	2699	updateActionBars();
Lines 3195-3205 Link Here
3195	.getPerspectiveBar();	3200	.getPerspectiveBar();
3196	}	3201	}
3197		3202
3198	// for dynamic UI	3203	/**
3199	public ActionPresentation getActionPresentation() {	3204	* Returns the action presentation for dynamic UI
3200	return actionPresentation;	3205	* @return action presentation
3201	}	3206	*/
3202		3207	public ActionPresentation getActionPresentation() {
		3208	if (actionPresentation == null) {
		3209	actionPresentation = new ActionPresentation(this);
		3210	}
		3211	return actionPresentation;
		3212	}
		3213
		3214	/package/ ActionBarPresentation getActionBarPresentation() {
		3215	// allow replacement of the actionbar presentation
		3216	ActionBarPresentation actionBarPresentation;
		3217	AbstractPresentationFactory presentationFactory =
		3218	getWindowConfigurer().getPresentationFactory();
		3219	if (presentationFactory instanceof InternalPresentationFactory) {
		3220	actionBarPresentation = ((InternalPresentationFactory) presentationFactory)
		3221	.createActionBarPresentation(this);
		3222	}
		3223	else
		3224	actionBarPresentation = new ActionBarPresentation();
		3225
		3226	return actionBarPresentation;
		3227	}
		3228
3203	/*	3229	/*
3204	* (non-Javadoc)	3230	* (non-Javadoc)
3205	*	3231	*
Lines 3210-3215 Link Here
3210	}	3236	}
3211		3237
3212	/**	3238	/**
		3239	* Returns a new cool bar manager for the window.
		3240	* <p>
		3241	* Subclasses may override this method to customize the cool bar manager.
		3242	* </p>
		3243	*
		3244	* @return a cool bar manager
		3245	* @since 3.2
		3246	*/
		3247	protected ICoolBarManager createCoolBarManager2(int style) {
		3248	return getActionBarPresentation().createCoolBarManager(style);
		3249	}
		3250
		3251	/**
		3252	* Creates the control for the cool bar manager.
		3253	* <p>
		3254	* Subclasses may override this method to customize the cool bar manager.
		3255	* </p>
		3256	*
		3257	* @return an instance of <code>CoolBar</code>\
		3258	* @since 3.2
		3259	*/
		3260	protected Control createCoolBarControl(Composite parent) {
		3261	return getActionBarPresentation().createCoolBarControl(getCoolBarManager2(), parent);
		3262	}
		3263
		3264	/**
		3265	* Returns a new tool bar manager for the window.
		3266	* <p>
		3267	* Subclasses may override this method to customize the tool bar manager.
		3268	* </p>
		3269	* @return a tool bar manager
		3270	* @since 3.2
		3271	*/
		3272	protected IToolBarManager2 createToolBarManager2(int style) {
		3273	return getActionBarPresentation().createToolBarManager(style);
		3274	}
		3275
		3276	/**
		3277	* Creates the control for the tool bar manager.
		3278	* <p>
		3279	* Subclasses may override this method to customize the tool bar manager.
		3280	* </p>
		3281	* @return a Control
		3282	* @since 3.2
		3283	*/
		3284	protected Control createToolBarControl(Composite parent) {
		3285	return getActionBarPresentation().createToolBarControl(getToolBarManager2(), parent);
		3286	}
		3287
		3288	/**
3213	* Delegate to the presentation factory.	3289	* Delegate to the presentation factory.
3214	*	3290	*
3215	* @see org.eclipse.jface.window.ApplicationWindow#createStatusLineManager	3291	* @see org.eclipse.jface.window.ApplicationWindow#createStatusLineManager




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

            }

            PluginAction action = ad.getAction();
            ActionContributionItem actionContribution = new PluginActionCoolBarContributionItem(
                    action);

            bars.addAdjunctContribution(actionContribution);


            // Create the action
            PluginAction action = ad.getAction();
            ActionContributionItem actionContribution = new PluginActionCoolBarContributionItem(
                    action);

            // retreive the toolbar from the action bars.

            //			if (menuMgr != null) 
            //				revokeActionSetFromMenu(menuMgr, id);

            revokeActionSetFromCoolbar(window.getCoolBarManager2(), id);
            //			IToolBarManager toolBarMgr = bars.getToolBarManager();
            //			if (toolBarMgr != null && toolBarMgr instanceof CoolItemToolBarManager) 
            //				revokeActionSetFromToolbar(toolBarMgr, id);

Lines 1-5 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/WWinActionBars.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2004 IBM Corporation and others.	2	* Copyright (c) 2000, 2006 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 41-47 Link Here
41	*	41	*
42	*/	42	*/
43	public ICoolBarManager getCoolBarManager() {	43	public ICoolBarManager getCoolBarManager() {
44	return window.getCoolBarManager();	44	return window.getCoolBarManager2();
45	}	45	}
46		46
47	/**	47	/**




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

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;

        // Run op in busy cursor.
        // Use set redraw to eliminate the "flash" that can occur in the
        // coolbar as the perspective is reset.
        ICoolBarManager mgr = window.getCoolBarManager2();
        try {
            mgr.getControl().setRedraw(false);
            BusyIndicator.showWhile(null, new Runnable() {

        // 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.
        ICoolBarManager mgr = window.getCoolBarManager2();
        try {
            mgr.getControl2().setRedraw(false);
            getClientComposite().setRedraw(false);
            // Run op in busy cursor.
            BusyIndicator.showWhile(null, new Runnable() {

            });
        } finally {
            getClientComposite().setRedraw(true);
            mgr.getControl2().setRedraw(true);
            IWorkbenchPart part = getActivePart();
            if (part != null)
                part.setFocus();

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

    /**

Lines 1-5 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/EditorManager.java (-9 / +7 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.	2	* Copyright (c) 2000, 2006 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 52-59 Link Here
52	import org.eclipse.swt.widgets.Display;	52	import org.eclipse.swt.widgets.Display;
53	import org.eclipse.swt.widgets.Shell;	53	import org.eclipse.swt.widgets.Shell;
54	import org.eclipse.ui.ActiveShellExpression;	54	import org.eclipse.ui.ActiveShellExpression;
55	import org.eclipse.ui.ISaveableModel;
56	import org.eclipse.ui.ISaveableModelSource;
57	import org.eclipse.ui.IEditorActionBarContributor;	55	import org.eclipse.ui.IEditorActionBarContributor;
58	import org.eclipse.ui.IEditorDescriptor;	56	import org.eclipse.ui.IEditorDescriptor;
59	import org.eclipse.ui.IEditorInput;	57	import org.eclipse.ui.IEditorInput;
Lines 67-72 Link Here
67	import org.eclipse.ui.IPathEditorInput;	65	import org.eclipse.ui.IPathEditorInput;
68	import org.eclipse.ui.IPersistableElement;	66	import org.eclipse.ui.IPersistableElement;
69	import org.eclipse.ui.IReusableEditor;	67	import org.eclipse.ui.IReusableEditor;
		68	import org.eclipse.ui.ISaveableModel;
		69	import org.eclipse.ui.ISaveableModelSource;
70	import org.eclipse.ui.ISaveablePart;	70	import org.eclipse.ui.ISaveablePart;
71	import org.eclipse.ui.ISaveablePart2;	71	import org.eclipse.ui.ISaveablePart2;
72	import org.eclipse.ui.IViewPart;	72	import org.eclipse.ui.IViewPart;
Lines 296-303 Link Here
296	}	296	}
297		297
298	// Create a new action bar set.	298	// Create a new action bar set.
299	actionBars = new EditorActionBars(	299	actionBars = new EditorActionBars(page, site, type);
300	(WWinActionBars) page.getActionBars(), site, type);
301	actionBars.addRef();	300	actionBars.addRef();
302	actionCache.put(type, actionBars);	301	actionCache.put(type, actionBars);
303		302
Lines 329-336 Link Here
329		328
330	// Create a new action bar set.	329	// Create a new action bar set.
331	// Note: It is an empty set.	330	// Note: It is an empty set.
332	EditorActionBars actionBars = new EditorActionBars(	331	EditorActionBars actionBars = new EditorActionBars(page, site, type);
333	(WWinActionBars) page.getActionBars(), site, type);
334	actionBars.addRef();	332	actionBars.addRef();
335	actionCache.put(type, actionBars);	333	actionCache.put(type, actionBars);
336		334
Lines 347-354 Link Here
347	String type = actionBars.getEditorType();	345	String type = actionBars.getEditorType();
348	actionCache.remove(type);	346	actionCache.remove(type);
349	// refresh the cool bar manager before disposing of a cool item	347	// refresh the cool bar manager before disposing of a cool item
350	if (window.getCoolBarManager() != null) {	348	if (window.getCoolBarManager2() != null) {
351	window.getCoolBarManager().refresh();	349	window.getCoolBarManager2().refresh();
352	}	350	}
353	actionBars.dispose();	351	actionBars.dispose();
354	}	352	}




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


import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IContributionManager;
import org.eclipse.jface.action.IToolBarContributionItem;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.CoolBar;
import org.eclipse.swt.widgets.Menu;

     * @param item
     *            The item to be replaced; must not be <code>null</code>.
     */
    PlaceholderContributionItem(final IToolBarContributionItem item) {
        item.saveWidgetState();
        id = item.getId();
        storedHeight = item.getCurrentHeight();

        storedUseChevron = item.getUseChevron();
    }

    /**
     * Creates a new tool bar contribution item on the given manager -- using
     * the stored data to initialize some of its properties.
     * 
     * @param manager
     *            The manager for which the contribution item should be
     *            created; must not be <code>null</code>
     * @return A new tool bar contribution item equivalent to the contribution
     *         item this placeholder was intended to replace; never <code>null</code>.
     */
    ToolBarContributionItem createToolBarContributionItem(
            final ToolBarManager manager) {
        ToolBarContributionItem toolBarContributionItem = new ToolBarContributionItem(
                manager, id);
        toolBarContributionItem.setCurrentHeight(storedHeight);
        toolBarContributionItem.setCurrentWidth(storedWidth);
        toolBarContributionItem.setMinimumItemsToShow(storedMinimumItems);
        toolBarContributionItem.setUseChevron(storedUseChevron);
        return toolBarContributionItem;
    }

    /*
     * (non-Javadoc)
     * 

    int getWidth() {
        return storedWidth;
    }
    
    /**
     * 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)
	 * @since 3.2
     */
    int getMinimumItemsToShow() {
    	return storedMinimumItems;
    }
    
    /**
     * Returns whether chevron support is enabled.
     * 
     * @return <code>true</code> if chevron support is enabled, <code>false</code>
     *         otherwise
	 * @since 3.2
     */
    boolean getUseChevron() {
        return storedUseChevron;
    }

    /*
     * (non-Javadoc)




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

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.action.ToolBarContributionItem;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.ui.IActionBars2;
import org.eclipse.ui.IEditorActionBarContributor;

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

/**


	private int refCount;

	private IToolBarContributionItem toolBarContributionItem = null;

	private String type;
	
	private ActionBarPresentation actionBarPresentation;

	/**
	 * Constructs the EditorActionBars for an editor.
	 */
	public EditorActionBars(WorkbenchPage page,
			final IServiceLocator serviceLocator, String type) {
		super((IActionBars2)page.getActionBars(), serviceLocator);
		this.type = type;
		this.actionBarPresentation = ((WorkbenchWindow) page
				.getWorkbenchWindow()).getActionBarPresentation();
	}

	/**

		}
		if (toolBarContributionItem == null) {
			IContributionItem foundItem = coolBarManager.find(type);
			if ((foundItem instanceof IToolBarContributionItem)) {
				toolBarContributionItem = (IToolBarContributionItem) foundItem;
				coolItemToolBarMgr = toolBarContributionItem.getToolBarManager();
						.getToolBarManager();
				if (coolItemToolBarMgr == null) {
					coolItemToolBarMgr = actionBarPresentation.createToolBarManager(coolBarManager
							.getStyle());
					toolBarContributionItem = actionBarPresentation.createToolBarContributionItem(
							coolItemToolBarMgr, type);
					// Add editor item to group
					coolBarManager.prependToGroup(

				if ((coolBarManager instanceof ContributionManager)
						&& (foundItem instanceof PlaceholderContributionItem)) {
					PlaceholderContributionItem placeholder = (PlaceholderContributionItem) foundItem;
					toolBarContributionItem = createToolBarContributionItem(
							(ToolBarManager) coolItemToolBarMgr, placeholder);
					// Restore from a placeholder
					((ContributionManager) coolBarManager).replaceItem(type,
							toolBarContributionItem);
				} else {
					toolBarContributionItem = actionBarPresentation.createToolBarContributionItem(
							coolItemToolBarMgr, type);
					// Add editor item to group
					coolBarManager.prependToGroup(


		return coolItemToolBarMgr;
	}
	
    /*
     * Creates a new tool bar contribution item on the given manager -- using
     * the stored data to initialize some of its properties.
     */
    IToolBarContributionItem createToolBarContributionItem(
			final ToolBarManager manager, PlaceholderContributionItem item) {
		IToolBarContributionItem toolBarContributionItem = actionBarPresentation
				.createToolBarContributionItem(manager, item.getId());
		toolBarContributionItem.setCurrentHeight(item.getHeight());
		toolBarContributionItem.setCurrentWidth(item.getWidth());
		toolBarContributionItem.setMinimumItemsToShow(item.getMinimumItemsToShow());
		toolBarContributionItem.setUseChevron(item.getUseChevron());
		return toolBarContributionItem;
	}

	/**
	 * Returns whether the contribution list is visible. If the visibility is




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

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.action.ToolBarContributionItem;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.ui.IActionBars2;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.SubActionBars2;
import org.eclipse.ui.internal.presentations.ActionBarPresentation;
import org.eclipse.ui.services.IServiceLocator;

/**
 * This class represents the action bars for an action set.
 */
public class ActionSetActionBars extends SubActionBars2 {
	
	private ActionBarPresentation actionBarPresentation = null;

	private String actionSetId;



	private IToolBarManager coolItemToolBarMgr = null;

	private IToolBarContributionItem toolBarContributionItem = null;

	/**
     * Constructs a new action bars object
     */
    public ActionSetActionBars(IActionBars2 parent, final IServiceLocator serviceLocator, 
    		String actionSetId, WorkbenchWindow window) {
    	super(parent, serviceLocator);
		this.actionSetId = actionSetId;		
        this.actionBarPresentation = window.getActionBarPresentation();
    }

	/**
	 * Adds to the list all the actions that are part of this action set but

		for (int i = 0; i < adjunctContributions.size(); i++) {
			ContributionItem item = (ContributionItem) adjunctContributions
					.get(i);
			IContributionManager parent = item.getParent();
			if (parent != null) {
				parent.remove(item);
				item.dispose();

		if (coolBarManager == null) {
			return null;
		}
        return actionBarPresentation.createToolBarManager(coolBarManager.getStyle());
	}

	/**

		// tool bar
		// id then create one. Otherwise retrieve the tool bar contribution
		// item
		if (cbItem instanceof IToolBarContributionItem) {

			IToolBarContributionItem tbcbItem = (IToolBarContributionItem) cbItem;
			coolItemToolBarMgr = tbcbItem.getToolBarManager();
			// If this not an adjuct type then we can cashe the tool bar
			// contribution type

				toolBarContributionItem = tbcbItem;
			}
		} else {
			
			coolItemToolBarMgr = actionBarPresentation
					.createToolBarManager(coolBarManager.getStyle());
           
			// If this is not an adjunct type then create a tool bar
			// contribution item
			// we don't create one for an adjunct type because another action
			// set action bars contains one
            
            IContributionItem toolBarContributionItem = actionBarPresentation
					.createToolBarContributionItem(coolItemToolBarMgr,
							toolBarId);

			toolBarContributionItem = new ToolBarContributionItem(
					coolItemToolBarMgr, toolBarId);
			toolBarContributionItem.setParent(coolItemToolBarMgr);
			toolBarContributionItem.setVisible(getActive());
			coolItemToolBarMgr.markDirty();

Lines 1-5 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/ActionPresentation.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.	2	* Copyright (c) 2000, 2006 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 146-152 Link Here
146	} else {	146	} else {
147	IActionSet set = desc.createActionSet();	147	IActionSet set = desc.createActionSet();
148	SubActionBars bars = new ActionSetActionBars(window	148	SubActionBars bars = new ActionSetActionBars(window
149	.getActionBars(), window, desc.getId());	149	.getActionBars(), window, desc.getId(), window);
150	rec = new SetRec(desc, set, bars);	150	rec = new SetRec(desc, set, bars);
151	set.init(window, bars);	151	set.init(window, bars);
152	sets.add(set);	152	sets.add(set);




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

package org.eclipse.ui.internal;


import org.eclipse.jface.action.IToolBarManager2;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;

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



    // create initially toolbarless bar manager so that actions may be added in the 
    // init method of the view.
    private IToolBarManager2 isvToolBarMgr = null;
            | SWT.WRAP);

    private MenuManager isvMenuMgr;


    /**
     * Toolbar manager for the ISV toolbar.
     */
    private class ISVPropListener implements IPropertyChangeListener {    	
    	private Control toolBar;    	
    	
    	/**
    	 * Constructor
    	 * @param toolBar
    	 */
    	public ISVPropListener (Control toolBar) {
    		this.toolBar = toolBar;
    	}
    	
    	/* (non-Javadoc)
    	 * @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)
    	 */
    	public void propertyChange(PropertyChangeEvent event) {    		
    		String property = event.getProperty();
    		Integer newValue = (Integer)event.getNewValue();
	       	if (IToolBarManager2.PROP_LAYOUT.equals(property)) {
	       		toolBarResized(toolBar, newValue != null ? newValue.intValue() : 0);	
	       		if (toolBar instanceof Composite)
	       			((Composite)toolBar).layout();
	       		else
	       			toolBar.getParent().layout();
	       	}
	    }
    }

    /**

     */
    public ViewPane(IViewReference ref, WorkbenchPage page) {
        super(ref, page);
        ActionBarPresentation actionBarPresentation = ((WorkbenchWindow) page
				.getWorkbenchWindow()).getActionBarPresentation();
        
        isvToolBarMgr = actionBarPresentation.createViewToolBarManager(SWT.FLAT | SWT.WRAP);
    }

    /**


    }

    private void toolBarResized(Control toolBar, int newSize) {
        
        Control toolbar = isvToolBarMgr.getControl2();
        if (toolbar != null) {
            Control ctrl = getControl();


        
        // ISV toolbar.
        //			// 1GD0ISU: ITPUI:ALL - Dbl click on view tool cause zoom
        final Control isvToolBar = isvToolBarMgr.createControl2(parentControl.getParent());
        
        isvToolBarMgr.addPropertyChangeListener(new ISVPropListener(isvToolBar));
        
        isvToolBar.addMouseListener(new MouseAdapter() {
            public void mouseDoubleClick(MouseEvent event) {

    /**
     * @see ViewActionBars
     */
    public IToolBarManager2 getToolBarManager() {
        return isvToolBarMgr;
    }


        super.reparent(newParent);

        if (isvToolBarMgr != null) {
            Control bar = isvToolBarMgr.getControl2();
            if (bar != null) {
                bar.setParent(newParent);
                bar.moveAbove(control);

    }

    public boolean toolbarIsVisible() {
        IToolBarManager2 toolbarManager = getToolBarManager();

        if (toolbarManager == null) {
            return false;
        }

        Control control = toolbarManager.getControl2();

        if (control == null || control.isDisposed()) {
            return false;
        }

        return toolbarManager.getItemCount() > 0;
    }

    /*

        return internalGetToolbar();
    }
    
    private Control internalGetToolbar() {
        if (isvToolBarMgr == null) {
            return null;
        }
        
        return isvToolBarMgr.getControl2();        
    }

    /* (non-Javadoc)

Lines 11-19 Link Here

(-)Eclipse UI/org/eclipse/ui/application/IActionBarConfigurer.java (+34 lines)
11	package org.eclipse.ui.application;	11	package org.eclipse.ui.application;
12		12
13	import org.eclipse.jface.action.IAction;	13	import org.eclipse.jface.action.IAction;
		14	import org.eclipse.jface.action.IContributionItem;
14	import org.eclipse.jface.action.ICoolBarManager;	15	import org.eclipse.jface.action.ICoolBarManager;
15	import org.eclipse.jface.action.IMenuManager;	16	import org.eclipse.jface.action.IMenuManager;
16	import org.eclipse.jface.action.IStatusLineManager;	17	import org.eclipse.jface.action.IStatusLineManager;
		18	import org.eclipse.jface.action.IToolBarManager;
		19	import org.eclipse.jface.action.IToolBarManager2;
		20	import org.eclipse.swt.widgets.Composite;
		21	import org.eclipse.swt.widgets.Control;
17		22
18	/**	23	/**
19	* Interface providing special access for configuring the action bars	24	* Interface providing special access for configuring the action bars
Lines 61-66 Link Here
61	* @return the cool bar manager	66	* @return the cool bar manager
62	*/	67	*/
63	public ICoolBarManager getCoolBarManager();	68	public ICoolBarManager getCoolBarManager();
		69
		70	/**
		71	* Creates tool bar manager for the workbench window's tool bar.
		72	*
		73	* @param style
		74	* @return toolBarManager
		75	* @since 3.2
		76	*/
		77	public IToolBarManager createToolBarManager(int style);
		78
		79	/**
		80	* Creates the control for the window's tool bar.
		81	*
		82	* @param toolBarManager the window's tool bar manager
		83	* @param parent the parent composite
		84	* @return the window's tool bar control
		85	* @since 3.2
		86	*/
		87	public Control createToolBarControl(IToolBarManager2 toolBarManager, Composite parent);
		88
		89	/**
		90	* Creates a toolbar contribution item for the window's tool bar.
		91	*
		92	* @param toolBarManager the window's tool bar manager
		93	* @param id the id of the contribution
		94	* @return the contribution item
		95	* @since 3.2
		96	*/
		97	public IContributionItem createToolBarContributionItem(IToolBarManager toolBarManager, String id);
64		98
65	/**	99	/**
66	* Register the action as a global action with a workbench	100	* Register the action as a global action with a workbench




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.IToolBarManager2;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.StatusLineManager;
import org.eclipse.jface.action.ToolBarContributionItem;

		public final IServiceLocator getServiceLocator() {
			return configurer.getWindow();
		}

		/* (non-Javadoc)
		 * @see org.eclipse.ui.application.IActionBarConfigurer#createToolBarContributionItem(org.eclipse.jface.action.IToolBarManager, java.lang.String)
		 */
		public IContributionItem createToolBarContributionItem(IToolBarManager toolBarManager, String id) {
			return null;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.ui.application.IActionBarConfigurer#createToolBarManager(int)
		 */
		public IToolBarManager createToolBarManager(int style) {
			return null;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.ui.application.IActionBarConfigurer#createToolBarControl(org.eclipse.jface.action.IToolBarManager2, org.eclipse.swt.widgets.Composite)
		 */
		public Control createToolBarControl(IToolBarManager2 toolBarManager, Composite parent) {
			return null;
		}
    }

    class ShortcutMenuItemContentProvider implements IStructuredContentProvider {

    private void buildMenusAndToolbarsFor(CustomizeActionBars customizeActionBars, ActionSetDescriptor actionSetDesc) {
        String id = actionSetDesc.getId();
        ActionSetActionBars bars = new ActionSetActionBars(
        		customizeActionBars, window, id, window);
        PluginActionSetBuilder builder = new PluginActionSetBuilder();
        PluginActionSet actionSet = null;
        try {




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

                                            if (manager != null)
                                                updateManager(manager);
                                            manager = window
                                                    .getCoolBarManager2();
                                            if (manager != null)
                                                updateManager(manager);
                                            manager = window
                                                    .getToolBarManager2();
                                            if (manager != null)
                                                updateManager(manager);
                                            manager = window




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

import org.eclipse.jface.action.CoolBarManager;
import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IToolBarContributionItem;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.IToolBarManager2;
import org.eclipse.jface.action.ToolBarContributionItem;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

/**
 * Manage the creation of tool bars for a presentation factory.
 * <p>
 * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
 * part of a work in progress. There is a guarantee neither that this API will
 * work nor that it will remain the same. Please do not use this API without
 * consulting with the Platform/UI team.
 * </p>
 * 
 * @since 3.2
 */
public class ActionBarPresentation  {
    
    /**
     * Creates CoolBarManager for WorkbenchWindow's tool bar
     * 
     * @param style
     * @return coolBarManager
     */
    public ICoolBarManager createCoolBarManager(int style) {
        CoolBarManager coolBarManager = new CoolBarManager(style);
        return coolBarManager;
    }
    
    /**
     * Creates the control for the window's cool bar.
     * Subclasses may override.
     * 
     * @param coolBarManager the window's status line manager
     * @param parent the parent composite
     * @return the window's cool bar control
     */
    public Control createCoolBarControl(ICoolBarManager coolBarManager, Composite parent) {
    	return coolBarManager.createControl2(parent);
    }
    
    /**
     * Creates ToolBarManager for WorkbenchWindow's tool bar
     * 
     * @param style
     * @return toolBarManager
     */
    public IToolBarManager2 createToolBarManager(int style) {
        return new ToolBarManager(style);
    }
    
    /**
     * 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) {
    	return toolBarManager.createControl2(parent);
    }
    
    /**
     * Creates ToolBarManager for a view part tool bar
     * 
     * @param style
     * @return toolBarManager
     */
    public IToolBarManager2 createViewToolBarManager(int style) {
        return new ToolBarManager(style);
    }
    
    /**
     * Creates the control for a view part tool bar.
     * Subclasses may override.
     * 
     * @param toolBarManager the view part's toolbar manager
     * @param parent the parent composite
     * @return the window's tool bar control
     */
    public Control createViewToolBarControl(IToolBarManager2 toolBarManager, Composite parent) {
    	return toolBarManager.createControl2(parent);
    }
    
    /**
     * Creates a toolbar contribution.  
     * This is to support custom coolbar managers.
     * 
     * @param toolBarManager the toolbar manager
     * @param id the id of the contribution 
     * @return the toolbar contribution item
     */
    public IToolBarContributionItem createToolBarContributionItem(IToolBarManager toolBarManager, String id) {
    	return new ToolBarContributionItem(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.ui.IWorkbenchWindow;
import org.eclipse.ui.presentations.WorkbenchPresentationFactory;

/**
 * <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 abstract class InternalPresentationFactory extends WorkbenchPresentationFactory {

    /**
     * Creates an action presentation for a window
     * @param window 
     * @return ActionPresentation
     */
    public abstract ActionBarPresentation createActionBarPresentation(IWorkbenchWindow window);

}

Return to bug 123257

Lines 1-5 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/PluginActionSetBuilder.java (-4 / +4 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.	2	* Copyright (c) 2000, 2006 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 375-381 Link Here
375	}	375	}
376		376
377	PluginAction action = ad.getAction();	377	PluginAction action = ad.getAction();
378	PluginActionCoolBarContributionItem actionContribution = new PluginActionCoolBarContributionItem(	378	ActionContributionItem actionContribution = new PluginActionCoolBarContributionItem(
379	action);	379	action);
380		380
381	bars.addAdjunctContribution(actionContribution);	381	bars.addAdjunctContribution(actionContribution);
Lines 430-436 Link Here
430		430
431	// Create the action	431	// Create the action
432	PluginAction action = ad.getAction();	432	PluginAction action = ad.getAction();
433	PluginActionCoolBarContributionItem actionContribution = new PluginActionCoolBarContributionItem(	433	ActionContributionItem actionContribution = new PluginActionCoolBarContributionItem(
434	action);	434	action);
435		435
436	// retreive the toolbar from the action bars.	436	// retreive the toolbar from the action bars.
Lines 562-568 Link Here
562	// if (menuMgr != null)	562	// if (menuMgr != null)
563	// revokeActionSetFromMenu(menuMgr, id);	563	// revokeActionSetFromMenu(menuMgr, id);
564		564
565	revokeActionSetFromCoolbar(window.getCoolBarManager(), id);	565	revokeActionSetFromCoolbar(window.getCoolBarManager2(), id);
566	// IToolBarManager toolBarMgr = bars.getToolBarManager();	566	// IToolBarManager toolBarMgr = bars.getToolBarManager();
567	// if (toolBarMgr != null && toolBarMgr instanceof CoolItemToolBarManager)	567	// if (toolBarMgr != null && toolBarMgr instanceof CoolItemToolBarManager)
568	// revokeActionSetFromToolbar(toolBarMgr, id);	568	// revokeActionSetFromToolbar(toolBarMgr, id);

Lines 1-5 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/ViewPane.java (-24 / +47 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.	2	* Copyright (c) 2000, 2006 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 13-20 Link Here
13	package org.eclipse.ui.internal;	13	package org.eclipse.ui.internal;
14		14
15		15
		16	import org.eclipse.jface.action.IToolBarManager2;
16	import org.eclipse.jface.action.MenuManager;	17	import org.eclipse.jface.action.MenuManager;
17	import org.eclipse.jface.action.ToolBarManager;	18	import org.eclipse.jface.util.IPropertyChangeListener;
		19	import org.eclipse.jface.util.PropertyChangeEvent;
18	import org.eclipse.swt.SWT;	20	import org.eclipse.swt.SWT;
19	import org.eclipse.swt.events.MouseAdapter;	21	import org.eclipse.swt.events.MouseAdapter;
20	import org.eclipse.swt.events.MouseEvent;	22	import org.eclipse.swt.events.MouseEvent;
Lines 28-33 Link Here
28	import org.eclipse.ui.IViewReference;	30	import org.eclipse.ui.IViewReference;
29	import org.eclipse.ui.IWorkbenchPart;	31	import org.eclipse.ui.IWorkbenchPart;
30	import org.eclipse.ui.internal.dnd.DragUtil;	32	import org.eclipse.ui.internal.dnd.DragUtil;
		33	import org.eclipse.ui.internal.presentations.ActionBarPresentation;
31	import org.eclipse.ui.presentations.IPresentablePart;	34	import org.eclipse.ui.presentations.IPresentablePart;
32	import org.eclipse.ui.presentations.StackPresentation;	35	import org.eclipse.ui.presentations.StackPresentation;
33		36
Lines 41-48 Link Here
41		44
42	// create initially toolbarless bar manager so that actions may be added in the	45	// create initially toolbarless bar manager so that actions may be added in the
43	// init method of the view.	46	// init method of the view.
44	private ToolBarManager isvToolBarMgr = new PaneToolBarManager(SWT.FLAT	47	private IToolBarManager2 isvToolBarMgr = null;
45	\| SWT.WRAP);
46		48
47	private MenuManager isvMenuMgr;	49	private MenuManager isvMenuMgr;
48		50
Lines 56-71 Link Here
56	/**	58	/**
57	* Toolbar manager for the ISV toolbar.	59	* Toolbar manager for the ISV toolbar.
58	*/	60	*/
59	class PaneToolBarManager extends ToolBarManager {	61	private class ISVPropListener implements IPropertyChangeListener {
60	public PaneToolBarManager(int style) {	62	private Control toolBar;
61	super(style);	63
62	}	64	/**
63		65	* Constructor
64	protected void relayout(ToolBar toolBar, int oldCount, int newCount) {	66	* @param toolBar
65	toolBarResized(toolBar, newCount);	67	*/
66		68	public ISVPropListener (Control toolBar) {
67	toolBar.layout();	69	this.toolBar = toolBar;
68	}	70	}
		71
		72	/* (non-Javadoc)
		73	* @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)
		74	*/
		75	public void propertyChange(PropertyChangeEvent event) {
		76	String property = event.getProperty();
		77	Integer newValue = (Integer)event.getNewValue();
		78	if (IToolBarManager2.PROP_LAYOUT.equals(property)) {
		79	toolBarResized(toolBar, newValue != null ? newValue.intValue() : 0);
		80	if (toolBar instanceof Composite)
		81	((Composite)toolBar).layout();
		82	else
		83	toolBar.getParent().layout();
		84	}
		85	}
69	}	86	}
70		87
71	/**	88	/**
Lines 92-97 Link Here
92	*/	109	*/
93	public ViewPane(IViewReference ref, WorkbenchPage page) {	110	public ViewPane(IViewReference ref, WorkbenchPage page) {
94	super(ref, page);	111	super(ref, page);
		112	ActionBarPresentation actionBarPresentation = ((WorkbenchWindow) page
		113	.getWorkbenchWindow()).getActionBarPresentation();
		114
		115	isvToolBarMgr = actionBarPresentation.createViewToolBarManager(SWT.FLAT \| SWT.WRAP);
95	}	116	}
96		117
97	/**	118	/**
Lines 123-131 Link Here
123		144
124	}	145	}
125		146
126	private void toolBarResized(ToolBar toolBar, int newSize) {	147	private void toolBarResized(Control toolBar, int newSize) {
127		148
128	Control toolbar = isvToolBarMgr.getControl();	149	Control toolbar = isvToolBarMgr.getControl2();
129	if (toolbar != null) {	150	if (toolbar != null) {
130	Control ctrl = getControl();	151	Control ctrl = getControl();
131		152
Lines 146-152 Link Here
146		167
147	// ISV toolbar.	168	// ISV toolbar.
148	// // 1GD0ISU: ITPUI:ALL - Dbl click on view tool cause zoom	169	// // 1GD0ISU: ITPUI:ALL - Dbl click on view tool cause zoom
149	final ToolBar isvToolBar = isvToolBarMgr.createControl(parentControl.getParent());	170	final Control isvToolBar = isvToolBarMgr.createControl2(parentControl.getParent());
		171
		172	isvToolBarMgr.addPropertyChangeListener(new ISVPropListener(isvToolBar));
150		173
151	isvToolBar.addMouseListener(new MouseAdapter() {	174	isvToolBar.addMouseListener(new MouseAdapter() {
152	public void mouseDoubleClick(MouseEvent event) {	175	public void mouseDoubleClick(MouseEvent event) {
Lines 301-307 Link Here
301	/**	324	/**
302	* @see ViewActionBars	325	* @see ViewActionBars
303	*/	326	*/
304	public ToolBarManager getToolBarManager() {	327	public IToolBarManager2 getToolBarManager() {
305	return isvToolBarMgr;	328	return isvToolBarMgr;
306	}	329	}
307		330
Lines 463-469 Link Here
463	super.reparent(newParent);	486	super.reparent(newParent);
464		487
465	if (isvToolBarMgr != null) {	488	if (isvToolBarMgr != null) {
466	ToolBar bar = isvToolBarMgr.getControl();	489	Control bar = isvToolBarMgr.getControl2();
467	if (bar != null) {	490	if (bar != null) {
468	bar.setParent(newParent);	491	bar.setParent(newParent);
469	bar.moveAbove(control);	492	bar.moveAbove(control);
Lines 499-517 Link Here
499	}	522	}
500		523
501	public boolean toolbarIsVisible() {	524	public boolean toolbarIsVisible() {
502	ToolBarManager toolbarManager = getToolBarManager();	525	IToolBarManager2 toolbarManager = getToolBarManager();
503		526
504	if (toolbarManager == null) {	527	if (toolbarManager == null) {
505	return false;	528	return false;
506	}	529	}
507		530
508	ToolBar control = toolbarManager.getControl();	531	Control control = toolbarManager.getControl2();
509		532
510	if (control == null \|\| control.isDisposed()) {	533	if (control == null \|\| control.isDisposed()) {
511	return false;	534	return false;
512	}	535	}
513		536
514	return control.getItemCount() > 0;	537	return toolbarManager.getItemCount() > 0;
515	}	538	}
516		539
517	/*	540	/*
Lines 559-570 Link Here
559	return internalGetToolbar();	582	return internalGetToolbar();
560	}	583	}
561		584
562	private ToolBar internalGetToolbar() {	585	private Control internalGetToolbar() {
563	if (isvToolBarMgr == null) {	586	if (isvToolBarMgr == null) {
564	return null;	587	return null;
565	}	588	}
566		589
567	return isvToolBarMgr.getControl();	590	return isvToolBarMgr.getControl2();
568	}	591	}
569		592
570	/* (non-Javadoc)	593	/* (non-Javadoc)

Lines 1-5 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/CustomizePerspectiveDialog.java (-2 / +24 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2004 IBM Corporation and others.	2	* Copyright (c) 2000, 2006 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 Common Public License v1.0	4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 27-32 Link Here
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.IToolBarManager;	29	import org.eclipse.jface.action.IToolBarManager;
		30	import org.eclipse.jface.action.IToolBarManager2;
30	import org.eclipse.jface.action.MenuManager;	31	import org.eclipse.jface.action.MenuManager;
31	import org.eclipse.jface.action.StatusLineManager;	32	import org.eclipse.jface.action.StatusLineManager;
32	import org.eclipse.jface.action.ToolBarContributionItem;	33	import org.eclipse.jface.action.ToolBarContributionItem;
Lines 479-484 Link Here
479	public final IServiceLocator getServiceLocator() {	480	public final IServiceLocator getServiceLocator() {
480	return configurer.getWindow();	481	return configurer.getWindow();
481	}	482	}
		483
		484	/* (non-Javadoc)
		485	* @see org.eclipse.ui.application.IActionBarConfigurer#createToolBarContributionItem(org.eclipse.jface.action.IToolBarManager, java.lang.String)
		486	*/
		487	public IContributionItem createToolBarContributionItem(IToolBarManager toolBarManager, String id) {
		488	return null;
		489	}
		490
		491	/* (non-Javadoc)
		492	* @see org.eclipse.ui.application.IActionBarConfigurer#createToolBarManager(int)
		493	*/
		494	public IToolBarManager createToolBarManager(int style) {
		495	return null;
		496	}
		497
		498	/* (non-Javadoc)
		499	* @see org.eclipse.ui.application.IActionBarConfigurer#createToolBarControl(org.eclipse.jface.action.IToolBarManager2, org.eclipse.swt.widgets.Composite)
		500	*/
		501	public Control createToolBarControl(IToolBarManager2 toolBarManager, Composite parent) {
		502	return null;
		503	}
482	}	504	}
483		505
484	class ShortcutMenuItemContentProvider implements IStructuredContentProvider {	506	class ShortcutMenuItemContentProvider implements IStructuredContentProvider {
Lines 942-948 Link Here
942	private void buildMenusAndToolbarsFor(CustomizeActionBars customizeActionBars, ActionSetDescriptor actionSetDesc) {	964	private void buildMenusAndToolbarsFor(CustomizeActionBars customizeActionBars, ActionSetDescriptor actionSetDesc) {
943	String id = actionSetDesc.getId();	965	String id = actionSetDesc.getId();
944	ActionSetActionBars bars = new ActionSetActionBars(	966	ActionSetActionBars bars = new ActionSetActionBars(
945	customizeActionBars, window, id);	967	customizeActionBars, window, id, window);
946	PluginActionSetBuilder builder = new PluginActionSetBuilder();	968	PluginActionSetBuilder builder = new PluginActionSetBuilder();
947	PluginActionSet actionSet = null;	969	PluginActionSet actionSet = null;
948	try {	970	try {

Added Link Here

(-)Eclipse (+114 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.internal.presentations;
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;
17	import org.eclipse.jface.action.IToolBarManager2;
18	import org.eclipse.jface.action.ToolBarContributionItem;
19	import org.eclipse.jface.action.ToolBarManager;
20	import org.eclipse.swt.widgets.Composite;
21	import org.eclipse.swt.widgets.Control;
22
23	/**
24	* Manage the creation of tool bars for a presentation factory.
25	* <p>
26	* <strong>EXPERIMENTAL</strong>. This class or interface has been added as
27	* part of a work in progress. There is a guarantee neither that this API will
28	* work nor that it will remain the same. Please do not use this API without
29	* consulting with the Platform/UI team.
30	* </p>
31	*
32	* @since 3.2
33	*/
34	public class ActionBarPresentation {
35
36	/**
37	* Creates CoolBarManager for WorkbenchWindow's tool bar
38	*
39	* @param style
40	* @return coolBarManager
41	*/
42	public ICoolBarManager createCoolBarManager(int style) {
43	CoolBarManager coolBarManager = new CoolBarManager(style);
44	return coolBarManager;
45	}
46
47	/**
48	* Creates the control for the window's cool bar.
49	* Subclasses may override.
50	*
51	* @param coolBarManager the window's status line manager
52	* @param parent the parent composite
53	* @return the window's cool bar control
54	*/
55	public Control createCoolBarControl(ICoolBarManager coolBarManager, Composite parent) {
56	return coolBarManager.createControl2(parent);
57	}
58
59	/**
60	* Creates ToolBarManager for WorkbenchWindow's tool bar
61	*
62	* @param style
63	* @return toolBarManager
64	*/
65	public IToolBarManager2 createToolBarManager(int style) {
66	return new ToolBarManager(style);
67	}
68
69	/**
70	* Creates the control for the window's tool bar.
71	* Subclasses may override.
72	*
73	* @param toolBarManager the window's toolbar manager
74	* @param parent the parent composite
75	* @return the window's tool bar control
76	*/
77	public Control createToolBarControl(IToolBarManager2 toolBarManager, Composite parent) {
78	return toolBarManager.createControl2(parent);
79	}
80
81	/**
82	* Creates ToolBarManager for a view part tool bar
83	*
84	* @param style
85	* @return toolBarManager
86	*/
87	public IToolBarManager2 createViewToolBarManager(int style) {
88	return new ToolBarManager(style);
89	}
90
91	/**
92	* Creates the control for a view part tool bar.
93	* Subclasses may override.
94	*
95	* @param toolBarManager the view part's toolbar manager
96	* @param parent the parent composite
97	* @return the window's tool bar control
98	*/
99	public Control createViewToolBarControl(IToolBarManager2 toolBarManager, Composite parent) {
100	return toolBarManager.createControl2(parent);
101	}
102
103	/**
104	* Creates a toolbar contribution.
105	* This is to support custom coolbar managers.
106	*
107	* @param toolBarManager the toolbar manager
108	* @param id the id of the contribution
109	* @return the toolbar contribution item
110	*/
111	public IToolBarContributionItem createToolBarContributionItem(IToolBarManager toolBarManager, String id) {
112	return new ToolBarContributionItem(toolBarManager, id);
113	}
114	}

Added Link Here

(-)Eclipse (+36 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.presentations;
13
14	import org.eclipse.ui.IWorkbenchWindow;
15	import org.eclipse.ui.presentations.WorkbenchPresentationFactory;
16
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 abstract class InternalPresentationFactory extends WorkbenchPresentationFactory {
28
29	/**
30	* Creates an action presentation for a window
31	* @param window
32	* @return ActionPresentation
33	*/
34	public abstract ActionBarPresentation createActionBarPresentation(IWorkbenchWindow window);
35
36	}