Attachment #181226 for bug #325392

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

Lines 27-33 Link Here

(-)UIAllTests.launch (-1 / +1 lines)
27	<booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>	27	<booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>
28	<stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>	28	<stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>
29	<stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit3"/>	29	<stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit3"/>
30	<stringAttribute key="org.eclipse.jdt.launching.JRE_CONTAINER" value="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>	30	<stringAttribute key="org.eclipse.jdt.launching.JRE_CONTAINER" value="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
31	<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.e4.ui.tests.UIAllTests"/>	31	<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.e4.ui.tests.UIAllTests"/>
32	<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-os ${target.os} -ws ${target.ws} -arch ${target.arch} -nl ${target.nl}"/>	32	<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-os ${target.os} -ws ${target.ws} -arch ${target.arch} -nl ${target.nl}"/>
33	<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.e4.ui.tests"/>	33	<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.e4.ui.tests"/>

Lines 34-44 Link Here

(-)src/org/eclipse/e4/ui/tests/workbench/MMenuItemTest.java (-14 / +146 lines)
34	import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;	34	import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
35	import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;	35	import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;
36	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;	36	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
37	import org.eclipse.e4.ui.workbench.renderers.swt.MenuRenderer;	37	import org.eclipse.e4.ui.workbench.renderers.swt.MenuManagerRenderer;
38	import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;	38	import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
		39	import org.eclipse.jface.action.IContributionItem;
		40	import org.eclipse.jface.action.MenuManager;
39	import org.eclipse.swt.SWT;	41	import org.eclipse.swt.SWT;
40	import org.eclipse.swt.widgets.Event;	42	import org.eclipse.swt.widgets.Event;
		43	import org.eclipse.swt.widgets.Menu;
41	import org.eclipse.swt.widgets.MenuItem;	44	import org.eclipse.swt.widgets.MenuItem;
		45	import org.eclipse.swt.widgets.Widget;
42		46
43	public class MMenuItemTest extends TestCase {	47	public class MMenuItemTest extends TestCase {
44	protected IEclipseContext appContext;	48	protected IEclipseContext appContext;
Lines 82-87 Link Here
82	wb = new E4Workbench(window, appContext);	86	wb = new E4Workbench(window, appContext);
83	wb.createAndRunUI(window);	87	wb.createAndRunUI(window);
84		88
		89	((MenuManager) ((Widget) menu.getWidget()).getData()).updateAll(true);
		90
85	Object widget = menuItem.getWidget();	91	Object widget = menuItem.getWidget();
86	assertNotNull(widget);	92	assertNotNull(widget);
87	assertTrue(widget instanceof MenuItem);	93	assertTrue(widget instanceof MenuItem);
Lines 157-162 Link Here
157	wb = new E4Workbench(window, appContext);	163	wb = new E4Workbench(window, appContext);
158	wb.createAndRunUI(window);	164	wb.createAndRunUI(window);
159		165
		166	((MenuManager) ((Widget) menu.getWidget()).getData()).updateAll(true);
		167
160	Object widget1 = menuItem1.getWidget();	168	Object widget1 = menuItem1.getWidget();
161	assertNotNull(widget1);	169	assertNotNull(widget1);
162	assertTrue(widget1 instanceof MenuItem);	170	assertTrue(widget1 instanceof MenuItem);
Lines 212-217 Link Here
212	wb = new E4Workbench(window, appContext);	220	wb = new E4Workbench(window, appContext);
213	wb.createAndRunUI(window);	221	wb.createAndRunUI(window);
214		222
		223	((MenuManager) ((Widget) menu.getWidget()).getData()).updateAll(true);
		224
215	Object widget1 = menuItem.getWidget();	225	Object widget1 = menuItem.getWidget();
216	assertNotNull(widget1);	226	assertNotNull(widget1);
217	assertTrue(widget1 instanceof MenuItem);	227	assertTrue(widget1 instanceof MenuItem);
Lines 228-234 Link Here
228	MCommand command = CommandsFactoryImpl.eINSTANCE.createCommand();	238	MCommand command = CommandsFactoryImpl.eINSTANCE.createCommand();
229		239
230	command.setElementId("commandId");	240	command.setElementId("commandId");
231	command.setCommandName("CommandForTest");
232		241
233	menuItem.setCommand(command);	242	menuItem.setCommand(command);
234	menuItem.setType(ItemType.CHECK);	243	menuItem.setType(ItemType.CHECK);
Lines 240-252 Link Here
240	MApplication application = ApplicationFactoryImpl.eINSTANCE	249	MApplication application = ApplicationFactoryImpl.eINSTANCE
241	.createApplication();	250	.createApplication();
242	application.getChildren().add(window);	251	application.getChildren().add(window);
243	application.getCommands().add(command);
244	application.setContext(appContext);	252	application.setContext(appContext);
245	appContext.set(MApplication.class.getName(), application);	253	appContext.set(MApplication.class.getName(), application);
246		254
247	wb = new E4Workbench(window, appContext);	255	wb = new E4Workbench(window, appContext);
248	wb.createAndRunUI(window);	256	wb.createAndRunUI(window);
249		257
		258	MenuManager barManager = (MenuManager) ((Menu) menu.getWidget())
		259	.getData();
		260	barManager.updateAll(true);
		261
250	Object widget1 = menuItem.getWidget();	262	Object widget1 = menuItem.getWidget();
251	assertNotNull(widget1);	263	assertNotNull(widget1);
252	assertTrue(widget1 instanceof MenuItem);	264	assertTrue(widget1 instanceof MenuItem);
Lines 255-261 Link Here
255	assertTrue(menuItemWidget.getSelection());	267	assertTrue(menuItemWidget.getSelection());
256	}	268	}
257		269
258	public void XXXtestSubMenuCreation() throws Exception {	270	public void testSubMenuCreation() throws Exception {
259	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();	271	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
260	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();	272	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
261	menuBar.setElementId("org.eclipse.ui.main.menu");	273	menuBar.setElementId("org.eclipse.ui.main.menu");
Lines 289-297 Link Here
289	wb = new E4Workbench(window, appContext);	301	wb = new E4Workbench(window, appContext);
290	wb.createAndRunUI(window);	302	wb.createAndRunUI(window);
291		303
		304	MenuManagerRenderer renderer = getRenderer(appContext, menuBar);
		305	MenuManager manager = renderer.getManager(menuBar);
		306	assertNotNull("failed to create menu bar manager", manager);
		307
		308	assertEquals(1, manager.getSize());
		309
		310	MenuManager fileManager = (MenuManager) manager.getItems()[0];
		311	MenuManager fileR = renderer.getManager(fileMenu);
		312	assertEquals(fileManager, fileR);
		313
		314	assertEquals(3, fileManager.getSize());
292	}	315	}
293		316
294	public void XXXtestTbrItem() throws Exception {	317	public void testTbrItem() throws Exception {
295	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();	318	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
296	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();	319	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
297	menuBar.setElementId("org.eclipse.ui.main.menu");	320	menuBar.setElementId("org.eclipse.ui.main.menu");
Lines 326-336 Link Here
326	wb = new E4Workbench(window, appContext);	349	wb = new E4Workbench(window, appContext);
327	wb.createAndRunUI(window);	350	wb.createAndRunUI(window);
328		351
329	// MenuRenderer renderer = getRenderer(appContext, menuBar);	352	MenuManagerRenderer renderer = getRenderer(appContext, menuBar);
		353	MenuManager manager = renderer.getManager(menuBar);
		354	assertNotNull("failed to create menu bar manager", manager);
		355
		356	assertEquals(1, manager.getSize());
		357
		358	MenuManager fileManager = (MenuManager) manager.getItems()[0];
		359	MenuManager fileR = renderer.getManager(fileMenu);
		360	assertEquals(fileManager, fileR);
330		361
		362	assertEquals(2, fileManager.getSize());
331	}	363	}
332		364
333	public void XXXtestInvisibleItem() throws Exception {	365	public void testInvisibleItem() throws Exception {
334	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();	366	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
335	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();	367	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
336	menuBar.setElementId("org.eclipse.ui.main.menu");	368	menuBar.setElementId("org.eclipse.ui.main.menu");
Lines 365-375 Link Here
365	wb = new E4Workbench(window, appContext);	397	wb = new E4Workbench(window, appContext);
366	wb.createAndRunUI(window);	398	wb.createAndRunUI(window);
367		399
368	// MenuRenderer renderer = getRenderer(appContext, menuBar);	400	MenuManagerRenderer renderer = getRenderer(appContext, menuBar);
		401	MenuManager manager = renderer.getManager(menuBar);
		402	assertNotNull("failed to create menu bar manager", manager);
		403
		404	assertEquals(1, manager.getSize());
		405
		406	MenuManager fileManager = (MenuManager) manager.getItems()[0];
		407	MenuManager fileR = renderer.getManager(fileMenu);
		408	assertEquals(fileManager, fileR);
369		409
		410	assertEquals(3, fileManager.getSize());
		411
		412	assertEquals(false, fileManager.getItems()[2].isVisible());
370	}	413	}
371		414
372	public void XXXtestMenuContribution() throws Exception {	415	public void testMenuContribution() throws Exception {
373	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();	416	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
374	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();	417	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
375	menuBar.setElementId("org.eclipse.ui.main.menu");	418	menuBar.setElementId("org.eclipse.ui.main.menu");
Lines 404-412 Link Here
404	wb = new E4Workbench(window, appContext);	447	wb = new E4Workbench(window, appContext);
405	wb.createAndRunUI(window);	448	wb.createAndRunUI(window);
406		449
		450	MenuManagerRenderer renderer = getRenderer(appContext, menuBar);
		451
		452	MenuManager fileManager = renderer.getManager(fileMenu);
		453	assertNotNull("No file menu?", fileManager);
		454
		455	assertEquals(4, fileManager.getSize());
		456
		457	assertEquals("mmc.item1", fileManager.getItems()[3].getId());
407	}	458	}
408		459
409	public void XXXtestWithVisible() throws Exception {	460	public void testWithVisible() throws Exception {
410	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();	461	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
411	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();	462	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
412	menuBar.setElementId("org.eclipse.ui.main.menu");	463	menuBar.setElementId("org.eclipse.ui.main.menu");
Lines 441-449 Link Here
441	wb = new E4Workbench(window, appContext);	492	wb = new E4Workbench(window, appContext);
442	wb.createAndRunUI(window);	493	wb.createAndRunUI(window);
443		494
		495	MenuManagerRenderer renderer = getRenderer(appContext, menuBar);
		496
		497	MenuManager fileManager = renderer.getManager(fileMenu);
		498	assertNotNull("No file menu?", fileManager);
		499
		500	assertEquals(4, fileManager.getSize());
		501
		502	IContributionItem mmcItem = fileManager.getItems()[3];
		503	assertEquals("mmc.item1", mmcItem.getId());
		504	assertEquals("before the first show, we have no context to evaluate",
		505	true, mmcItem.isVisible());
		506
		507	MenuManager manager = renderer.getManager(menuBar);
		508	manager.updateAll(true);
		509	Menu fileWidget = fileManager.getMenu();
		510	assertNotNull(fileWidget);
		511
		512	Event show = new Event();
		513	show.widget = fileWidget;
		514	show.type = SWT.Show;
		515
		516	Event hide = new Event();
		517	hide.widget = fileWidget;
		518	hide.type = SWT.Hide;
		519
		520	fileWidget.notifyListeners(SWT.Show, show);
		521
		522	assertEquals("after the first show, it should not be visible", false,
		523	mmcItem.isVisible());
		524
		525	fileWidget.notifyListeners(SWT.Hide, hide);
		526
		527	appContext.set("mmc1", Boolean.TRUE);
		528
		529	assertEquals("Change should not show up until next show", false,
		530	mmcItem.isVisible());
		531
		532	fileWidget.notifyListeners(SWT.Show, show);
		533
		534	assertEquals(true, mmcItem.isVisible());
		535
		536	fileWidget.notifyListeners(SWT.Hide, hide);
		537
		538	appContext.remove("mmc1");
		539
		540	fileWidget.notifyListeners(SWT.Show, show);
		541
		542	assertEquals(false, mmcItem.isVisible());
		543
		544	fileWidget.notifyListeners(SWT.Hide, hide);
444	}	545	}
445		546
446	public void XXXtestMenuBarVisibility() throws Exception {	547	public void testMenuBarVisibility() throws Exception {
447	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();	548	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
448	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();	549	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
449	menuBar.setElementId("org.eclipse.ui.main.menu");	550	menuBar.setElementId("org.eclipse.ui.main.menu");
Lines 478-483 Link Here
478	wb = new E4Workbench(window, appContext);	579	wb = new E4Workbench(window, appContext);
479	wb.createAndRunUI(window);	580	wb.createAndRunUI(window);
480		581
		582	MenuManagerRenderer renderer = getRenderer(appContext, menuBar);
		583	MenuManager manager = renderer.getManager(menuBar);
		584	manager.updateAll(true);
		585
		586	assertEquals(2, manager.getSize());
		587
		588	MenuManager vanishManager = (MenuManager) manager.getItems()[1];
		589	assertEquals("vanish", vanishManager.getId());
		590
		591	assertFalse(vanishManager.isVisible());
		592	assertNull(vanishManager.getMenu());
		593
		594	appContext.set("mmc1", Boolean.TRUE);
		595
		596	assertTrue(vanishManager.isVisible());
		597	assertNotNull(vanishManager.getMenu());
		598
		599	appContext.remove("mmc1");
		600
		601	assertFalse(vanishManager.isVisible());
		602	Menu vanishMenu = vanishManager.getMenu();
		603	if (vanishMenu != null) {
		604	assertTrue(vanishMenu.isDisposed());
		605	}
		606
		607	appContext.set("mmc1", Boolean.TRUE);
		608
		609	assertTrue(vanishManager.isVisible());
		610	assertNotNull(vanishManager.getMenu());
		611	assertFalse(vanishManager.getMenu().isDisposed());
481	}	612	}
482		613
483	private MMenuContribution createContribution(boolean withVisibleWhen) {	614	private MMenuContribution createContribution(boolean withVisibleWhen) {
Lines 537-547 Link Here
537	application.getMenuContributions().add(mmc);	668	application.getMenuContributions().add(mmc);
538	}	669	}
539		670
540	MenuRenderer getRenderer(IEclipseContext context, MUIElement element) {	671	private MenuManagerRenderer getRenderer(IEclipseContext context,
		672	MUIElement element) {
541	IRendererFactory rendererFactory = context.get(IRendererFactory.class);	673	IRendererFactory rendererFactory = context.get(IRendererFactory.class);
542	AbstractPartRenderer renderer = rendererFactory.getRenderer(element,	674	AbstractPartRenderer renderer = rendererFactory.getRenderer(element,
543	null);	675	null);
544	assertEquals(MenuRenderer.class, renderer.getClass());	676	assertEquals(MenuManagerRenderer.class, renderer.getClass());
545	return (MenuRenderer) renderer;	677	return (MenuManagerRenderer) renderer;
546	}	678	}
547	}	679	}

Lines 30-35 Link Here

(-)src/org/eclipse/e4/ui/tests/workbench/MWindowTest.java (+3 lines)
30	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;	30	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
31	import org.eclipse.e4.ui.services.IServiceConstants;	31	import org.eclipse.e4.ui.services.IServiceConstants;
32	import org.eclipse.e4.ui.widgets.CTabFolder;	32	import org.eclipse.e4.ui.widgets.CTabFolder;
		33	import org.eclipse.jface.action.MenuManager;
33	import org.eclipse.swt.SWT;	34	import org.eclipse.swt.SWT;
34	import org.eclipse.swt.graphics.Rectangle;	35	import org.eclipse.swt.graphics.Rectangle;
35	import org.eclipse.swt.widgets.Composite;	36	import org.eclipse.swt.widgets.Composite;
Lines 230-235 Link Here
230		231
231	wb = new E4Workbench(application, appContext);	232	wb = new E4Workbench(application, appContext);
232	wb.createAndRunUI(window);	233	wb.createAndRunUI(window);
		234	((MenuManager) ((Widget) window.getMainMenu().getWidget()).getData())
		235	.updateAll(true);
233		236
234	Widget topWidget = (Widget) window.getWidget();	237	Widget topWidget = (Widget) window.getWidget();
235	assertNotNull(topWidget);	238	assertNotNull(topWidget);

Lines 176-182 Link Here

(-)src/org/eclipse/e4/ui/internal/workbench/ContributionsAnalyzer.java (-1 / +1 lines)
176	return isVisible((MCoreExpression) contribution.getVisibleWhen(), eContext);	176	return isVisible((MCoreExpression) contribution.getVisibleWhen(), eContext);
177	}	177	}
178		178
179	static boolean isVisible(MCoreExpression exp, ExpressionContext eContext) {	179	public static boolean isVisible(MCoreExpression exp, ExpressionContext eContext) {
180	Expression ref = null;	180	Expression ref = null;
181	if (exp.getCoreExpression() instanceof Expression) {	181	if (exp.getCoreExpression() instanceof Expression) {
182	ref = (Expression) exp.getCoreExpression();	182	ref = (Expression) exp.getCoreExpression();




import org.eclipse.e4.core.services.events.IEventBroker;
import org.eclipse.e4.core.services.log.Logger;
import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;
import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
import org.eclipse.e4.ui.model.application.MApplication;
import org.eclipse.e4.ui.model.application.ui.MContext;
import org.eclipse.e4.ui.model.application.ui.MElementContainer;
import org.eclipse.e4.ui.model.application.ui.MUIElement;
import org.eclipse.e4.ui.model.application.ui.MUILabel;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.jface.action.AbstractGroupMarker;
import org.eclipse.jface.action.ContributionItem;
import org.eclipse.jface.action.GroupMarker;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Decorations;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Menu;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventHandler;

						return;
					}
					manager.setVisible(menuModel.isVisible());
					if (manager.getParent() != null) {
						manager.getParent().markDirty();
					}
				} else if (element instanceof MMenuElement) {
					MMenuElement itemModel = (MMenuElement) element;
					Object obj = getContribution(itemModel);
					if (!(obj instanceof ContributionItem)) {
						return;
					}
					ContributionItem item = (ContributionItem) obj;
					item.setVisible(itemModel.isVisible());
					if (item.getParent() != null) {
						item.getParent().markDirty();
					}
				}
			}
		}

		}
	};

	private MenuManagerRendererFilter rendererFilter;
		public void menuAboutToShow(IMenuManager manager) {
			MenuManager menuManager = (MenuManager) manager;
			if (menuManager.getMenu() == null) {
				return;
			}
			MMenu menuModel = getMenuModel(menuManager);
			if (menuModel == null) {
				Menu menu = menuManager.getMenu();
				Object obj = menu.getData(AbstractPartRenderer.OWNING_ME);
				if (obj == null && menu.getParentItem() != null) {
					obj = menu.getParentItem().getData(
							AbstractPartRenderer.OWNING_ME);
				}
				if (!(obj instanceof MMenu)) {
					return;
				}
				menuModel = (MMenu) obj;
			} else if (menuModel.getWidget() == null) {
				bindWidget(menuModel, menuManager.getMenu());
			}
			final IEclipseContext evalContext;
			if (menuModel instanceof MContext) {
				evalContext = ((MContext) menuModel).getContext();
			} else {
				evalContext = modelService.getContainingContext(menuModel);
			}
			HashSet<ContributionRecord> records = new HashSet<ContributionRecord>();
			for (MMenuElement element : menuModel.getChildren()) {
				ContributionRecord record = modelContributionToRecord
						.get(element);
				if (record != null && records.add(record)) {
					record.updateVisibility(evalContext);
				}
			}
		}
	};

	@PostConstruct
	public void init() {

		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UIElement.TOPIC),
				toBeRenderedUpdater);

		context.set(MenuManagerRenderer.class, this);
		Display display = context.get(Display.class);
		rendererFilter = ContextInjectionFactory.make(
				MenuManagerRendererFilter.class, context);
		display.addFilter(SWT.Show, rendererFilter);
		display.addFilter(SWT.Hide, rendererFilter);
		display.addFilter(SWT.Dispose, rendererFilter);
		context.set(MenuManagerRendererFilter.class, rendererFilter);

	}

	@PreDestroy

		eventBroker.unsubscribe(selectionUpdater);
		eventBroker.unsubscribe(enabledUpdater);
		eventBroker.unsubscribe(toBeRenderedUpdater);

		context.remove(MenuManagerRenderer.class);
		Display display = context.get(Display.class);
		if (display != null && !display.isDisposed()) {
			display.removeFilter(SWT.Show, rendererFilter);
			display.removeFilter(SWT.Hide, rendererFilter);
			display.removeFilter(SWT.Dispose, rendererFilter);
			context.remove(MenuManagerRendererFilter.class);
			ContextInjectionFactory.uninject(rendererFilter, context);
			rendererFilter = null;
		}
	}

	/*

	public void linkModelToManager(MMenu model, MenuManager manager) {
		modelToManager.put(model, manager);
		managerToModel.put(manager, model);
		manager.addMenuListener(visibilityCalculationListener);
	}

	public void clearModelToManager(MMenu model, MenuManager manager) {
		modelToManager.remove(model);
		managerToModel.remove(manager);
		if (manager != null) {
			manager.removeMenuListener(visibilityCalculationListener);
		}
	}

	public IContributionItem getContribution(MMenuElement model) {
		return modelToContribution.get(model);
	}

	public ContributionRecord getContributionRecord(MMenuElement element) {
		return modelContributionToRecord.get(element);
	}
}




/*******************************************************************************
 * Copyright (c) 2010 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.e4.ui.workbench.renderers.swt;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.HashSet;
import javax.inject.Inject;
import org.eclipse.core.commands.ParameterizedCommand;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.e4.core.commands.EHandlerService;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.services.log.Logger;
import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;
import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
import org.eclipse.e4.ui.internal.workbench.swt.Policy;
import org.eclipse.e4.ui.internal.workbench.swt.WorkbenchSWTActivator;
import org.eclipse.e4.ui.model.application.ui.MContext;
import org.eclipse.e4.ui.model.application.ui.MCoreExpression;
import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;
import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
import org.eclipse.e4.ui.model.application.ui.menu.MMenuElement;
import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;
import org.eclipse.e4.ui.model.application.ui.menu.MRenderedMenu;
import org.eclipse.e4.ui.workbench.modeling.EModelService;
import org.eclipse.e4.ui.workbench.modeling.ExpressionContext;
import org.eclipse.e4.ui.workbench.renderers.swt.MenuManagerRenderer.ContributionRecord;
import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Widget;

public class MenuManagerRendererFilter implements Listener {
	public static final String NUL_MENU_ITEM = "(None Applicable)"; //$NON-NLS-1$

	private static final String TMP_ORIGINAL_CONTEXT = "MenuServiceFilter.original.context"; //$NON-NLS-1$

	private static void trace(String msg, Widget menu, MMenu menuModel) {
		WorkbenchSWTActivator.trace(Policy.MENUS, msg + ": " + menu + ": " //$NON-NLS-1$ //$NON-NLS-2$
				+ menuModel, null);
	}

	private static Method aboutToShow;

	private static Method aboutToHide;

	public static Method getAboutToShow() {
		if (aboutToShow == null) {
			try {
				aboutToShow = MenuManager.class
						.getDeclaredMethod("handleAboutToShow"); //$NON-NLS-1$
				aboutToShow.setAccessible(true);
			} catch (SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (NoSuchMethodException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return aboutToShow;
	}

	public static Method getAboutToHide() {
		if (aboutToHide == null) {
			try {
				aboutToHide = MenuManager.class
						.getDeclaredMethod("handleAboutToHide"); //$NON-NLS-1$
				aboutToHide.setAccessible(true);
			} catch (SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (NoSuchMethodException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return aboutToHide;
	}

	@Inject
	private Logger logger;

	@Inject
	private EModelService modelService;

	@Inject
	private IRendererFactory rendererFactory;

	@Inject
	private MenuManagerRenderer renderer;

	private HashMap<Menu, Runnable> pendingCleanup = new HashMap<Menu, Runnable>();

	private class SafeWrapper implements ISafeRunnable {
		Event event;

		public void handleException(Throwable e) {
			if (e instanceof Error) {
				// errors are deadly, we shouldn't ignore these
				throw (Error) e;
			}
			// log exceptions otherwise
			if (logger != null) {
				logger.error(e);
			}
		}

		public void run() throws Exception {
			safeHandleEvent(event);
		}
	}

	private SafeWrapper safeWrapper = new SafeWrapper();

	public void handleEvent(final Event event) {
		// wrap the handling in a SafeRunner so that exceptions do not prevent
		// the menu from being shown
		safeWrapper.event = event;
		SafeRunner.run(safeWrapper);
	}

	private void safeHandleEvent(Event event) {
		if (!(event.widget instanceof Menu)) {
			return;
		}
		final Menu menu = (Menu) event.widget;
		if (event.type == SWT.Dispose) {
			trace("handleMenu.Dispose", menu, null); //$NON-NLS-1$
			cleanUp(menu);
		}
		Object obj = menu.getData(AbstractPartRenderer.OWNING_ME);
		if (obj == null && menu.getParentItem() != null) {
			obj = menu.getParentItem().getData(AbstractPartRenderer.OWNING_ME);
			if (obj == null) {
				// hack because MenuManager doesn't do a setData()
				Object tmp = menu.getParentItem().getData();
				if (tmp instanceof MenuManager) {
					MenuManager tmpManager = (MenuManager) tmp;
					if (menu == tmpManager.getMenu()) {
						// Eureka! We found a match, by golly!
						obj = renderer.getMenuModel(tmpManager);
					}
				}
			}
		}
		if (obj instanceof MPopupMenu) {
			handleContextMenu(event, menu, (MPopupMenu) obj);
		} else if (obj instanceof MMenu) {
			handleMenu(event, menu, (MMenu) obj);
		} else {
			trace("Incorrect menu model to work with: " + obj, menu, null); //$NON-NLS-1$
		}
	}

	private void handleMenu(final Event event, final Menu menu,
			final MMenu menuModel) {
		if ((menu.getStyle() & SWT.BAR) != 0) {
			// don't process the menu bar, it's not fair :-)
			return;
		}
		switch (event.type) {
		case SWT.Show:
			trace("handleMenu.Show", menu, menuModel); //$NON-NLS-1$
			cleanUp(menu);
			showMenu(event, menu, menuModel);
			break;
		case SWT.Hide:
			trace("handleMenu.Hide", menu, menuModel); //$NON-NLS-1$
			// TODO we'll clean up on show
			break;
		}
	}

	public void showMenu(final Event event, final Menu menu,
			final MMenu menuModel) {
		AbstractPartRenderer obj = rendererFactory.getRenderer(menuModel,
				menu.getParent());
		if (!(obj instanceof MenuManagerRenderer)) {
			trace("Not the correct renderer: " + obj, menu, menuModel); //$NON-NLS-1$
			return;
		}
		MenuManagerRenderer renderer = (MenuManagerRenderer) obj;
		MenuManager menuManager = renderer.getManager(menuModel);
		if (menuModel.getWidget() == null) {
			renderer.bindWidget(menuModel, menuManager.getMenu());
		}

		Method handleAboutToShow = getAboutToShow();
		try {
			handleAboutToShow.invoke(menuManager);
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		//
		// TODO merge MRenderedMenuItems back into the model
		// this will make the 3.x world visible to the model
		// without actually modeling it fully
		//

		final IEclipseContext evalContext;
		if (menuModel instanceof MContext) {
			evalContext = ((MContext) menuModel).getContext();
		} else {
			evalContext = modelService.getContainingContext(menuModel);
		}
		updateElementVisibility(menuModel, renderer, menuManager, evalContext,
				true);

		// last thing to do, kill the event and update the menu manager
		event.type = SWT.None;
		event.doit = false;
		menuManager.update(false);
	}

	/**
	 * @param menuModel
	 * @param renderer
	 * @param menuManager
	 * @param evalContext
	 */
	private void updateElementVisibility(final MMenu menuModel,
			MenuManagerRenderer renderer, MenuManager menuManager,
			final IEclipseContext evalContext, boolean recurse) {
		final ExpressionContext exprContext = new ExpressionContext(evalContext);
		HashSet<ContributionRecord> records = new HashSet<ContributionRecord>();
		for (MMenuElement element : menuModel.getChildren()) {
			ContributionRecord record = renderer.getContributionRecord(element);
			if (record != null) {
				if (records.add(record)) {
					record.updateVisibility(evalContext);
				}
			} else {
				updateVisibility(menuManager, element, exprContext);
			}
			if (recurse && element.isVisible() && element instanceof MMenu) {
				MMenu childMenu = (MMenu) element;
				MenuManager childManager = renderer.getManager(childMenu);
				if (childManager != null) {
					updateElementVisibility(childMenu, renderer, childManager,
							evalContext, false);
				}
			}
		}
	}

	/**
	 * @param menuManager
	 * @param element
	 * @param evalContext
	 */
	private void updateVisibility(MenuManager menuManager,
			MMenuElement element, ExpressionContext evalContext) {
		if (!(element.getVisibleWhen() instanceof MCoreExpression)) {
			return;
		}
		boolean val = ContributionsAnalyzer.isVisible(
				(MCoreExpression) element.getVisibleWhen(), evalContext);
		if (val != element.isVisible()) {
			element.setVisible(val);
			menuManager.markDirty();
		}
	}

	private void handleContextMenu(final Event event, final Menu menu,
			final MPopupMenu menuModel) {
		switch (event.type) {
		case SWT.Show:
			trace("handleContextMenu.Show", menu, menuModel); //$NON-NLS-1$
			cleanUp(menu);
			showPopup(event, menu, menuModel);
			break;
		case SWT.Hide:
			trace("handleContextMenu.Hide", menu, menuModel); //$NON-NLS-1$
			hidePopup(event, menu, menuModel);
			break;
		}
	}

	public void hidePopup(Event event, Menu menu, MPopupMenu menuModel) {
		final IEclipseContext popupContext = menuModel.getContext();
		final IEclipseContext originalChild = (IEclipseContext) popupContext
				.get(TMP_ORIGINAL_CONTEXT);
		popupContext.remove(TMP_ORIGINAL_CONTEXT);
		if (!menu.isDisposed()) {
			menu.getDisplay().asyncExec(new Runnable() {
				public void run() {
					if (originalChild == null) {
						popupContext.deactivate();
					} else {
						originalChild.activate();
					}
				}
			});
		}
	}

	public void showPopup(final Event event, final Menu menu,
			final MPopupMenu menuModel) {
		// System.err.println("showPopup: " + menuModel + "\n\t" + menu);
		// we need some context foolery here
		final IEclipseContext popupContext = menuModel.getContext();
		final IEclipseContext parentContext = popupContext.getParent();
		final IEclipseContext originalChild = parentContext.getActiveChild();
		popupContext.activate();
		popupContext.set(TMP_ORIGINAL_CONTEXT, originalChild);

		showMenu(event, menu, menuModel);
	}

	void setEnabled(MHandledMenuItem item) {
		if (!item.isToBeRendered() || !item.isVisible()
				|| item.getWidget() == null) {
			return;
		}
		ParameterizedCommand cmd = item.getWbCommand();
		if (cmd == null) {
			return;
		}
		final IEclipseContext lclContext = modelService
				.getContainingContext(item);
		EHandlerService service = lclContext.get(EHandlerService.class);
		item.setEnabled(service.canExecute(cmd));
	}

	public void showRenderedMenu(final Event event, final Menu menu,
			final MRenderedMenu menuModel) {
		if (!(menuModel.getContributionManager() instanceof MenuManager)) {
			return;
		}

		MenuManager manager = (MenuManager) menuModel.getContributionManager();
		Method handleAboutToShow = getAboutToShow();
		try {
			handleAboutToShow.invoke(manager);
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		if (menuModel.getChildren().size() == 1
				&& menuModel.getChildren().get(0) instanceof MPopupMenu) {
			showPopup(event, menu, (MPopupMenu) menuModel.getChildren().get(0));
		} else {
			showMenu(event, menu, menuModel);
		}
		event.type = SWT.None;
		event.doit = false;
	}

	public void cleanUp(final Menu menu) {
		trace("cleanUp", menu, null); //$NON-NLS-1$
		if (pendingCleanup.isEmpty()) {
			return;
		}
		Runnable cleanUp = pendingCleanup.remove(menu);
		if (cleanUp != null) {
			trace("cleanUp.run()", menu, null); //$NON-NLS-1$
			cleanUp.run();
		}
	}

	public void dispose() {
		Menu[] keys = pendingCleanup.keySet().toArray(
				new Menu[pendingCleanup.size()]);
		for (Menu menu : keys) {
			cleanUp(menu);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2010 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.e4.ui.workbench.renderers.swt;

import java.lang.reflect.Method;
import javax.inject.Inject;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.services.log.Logger;
import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
import org.eclipse.e4.ui.internal.workbench.swt.Policy;
import org.eclipse.e4.ui.internal.workbench.swt.WorkbenchSWTActivator;
import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;
import org.eclipse.e4.ui.workbench.modeling.EModelService;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Widget;

public class MenuManagerServiceFilter implements Listener {
	public static final String NUL_MENU_ITEM = "(None Applicable)"; //$NON-NLS-1$

	private static final String TMP_ORIGINAL_CONTEXT = "MenuServiceFilter.original.context"; //$NON-NLS-1$

	private static void trace(String msg, Widget menu, MMenu menuModel) {
		WorkbenchSWTActivator.trace(Policy.MENUS, msg + ": " + menu + ": " //$NON-NLS-1$ //$NON-NLS-2$
				+ menuModel, null);
	}

	private static Method aboutToShow;

	public static Method getAboutToShow() {
		if (aboutToShow == null) {
			try {
				aboutToShow = MenuManager.class
						.getDeclaredMethod("handleAboutToShow"); //$NON-NLS-1$
				aboutToShow.setAccessible(true);
			} catch (SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (NoSuchMethodException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return aboutToShow;
	}

	@Inject
	private Logger logger;

	@Inject
	EModelService modelService;

	public void handleEvent(final Event event) {
		// wrap the handling in a SafeRunner so that exceptions do not prevent
		// the menu from being shown
		SafeRunner.run(new ISafeRunnable() {
			public void handleException(Throwable e) {
				if (e instanceof Error) {
					// errors are deadly, we shouldn't ignore these
					throw (Error) e;
				} else {
					// log exceptions otherwise
					if (logger != null) {
						logger.error(e);
					}
				}
			}

			public void run() throws Exception {
				safeHandleEvent(event);
			}
		});
	}

	private void safeHandleEvent(Event event) {
		if (!(event.widget instanceof Menu)) {
			return;
		}
		final Menu menu = (Menu) event.widget;
		if (event.type == SWT.Dispose) {
			trace("handleMenu.Dispose", menu, null); //$NON-NLS-1$
			cleanUp(menu);
		}
		Object obj = menu.getData(AbstractPartRenderer.OWNING_ME);
		if (obj == null && menu.getParentItem() != null) {
			obj = menu.getParentItem().getData(AbstractPartRenderer.OWNING_ME);
		}
		if (obj instanceof MPopupMenu) {
			handleContextMenu(event, menu, (MPopupMenu) obj);
		} else if (obj instanceof MMenu) {
			handleMenu(event, menu, (MMenu) obj);
		}
	}

	private void handleMenu(final Event event, final Menu menu,
			final MMenu menuModel) {
		if ((menu.getStyle() & SWT.BAR) != 0) {
			// don't process the menu bar, it's not fair :-)
			return;
		}
		switch (event.type) {
		case SWT.Show:
			cleanUp(menu);
			showMenu(event, menu, menuModel);
			break;
		case SWT.Hide:
			// TODO we'll clean up on show
			break;
		}
	}

	public void showMenu(final Event event, final Menu menu,
			final MMenu menuModel) {
		// System.err.println("showMenu: " + menuModel + "\n\t" + menu);
	}

	private void handleContextMenu(final Event event, final Menu menu,
			final MPopupMenu menuModel) {
		switch (event.type) {
		case SWT.Show:
			cleanUp(menu);
			showPopup(event, menu, menuModel);
			break;
		case SWT.Hide:
			hidePopup(event, menu, menuModel);
			break;
		}
	}

	public void hidePopup(Event event, Menu menu, MPopupMenu menuModel) {
		// System.err.println("hidePopup: " + menuModel + "\n\t" + menu);
		final IEclipseContext popupContext = menuModel.getContext();
		final IEclipseContext originalChild = (IEclipseContext) popupContext
				.get(TMP_ORIGINAL_CONTEXT);
		popupContext.remove(TMP_ORIGINAL_CONTEXT);
		if (!menu.isDisposed()) {
			menu.getDisplay().asyncExec(new Runnable() {
				public void run() {
					if (originalChild == null) {
						popupContext.deactivate();
					} else {
						originalChild.activate();
					}
				}
			});
		}
	}

	public void showPopup(final Event event, final Menu menu,
			final MPopupMenu menuModel) {
		// System.err.println("showPopup: " + menuModel + "\n\t" + menu);
		// we need some context foolery here
		final IEclipseContext popupContext = menuModel.getContext();
		final IEclipseContext parentContext = popupContext.getParent();
		final IEclipseContext originalChild = parentContext.getActiveChild();
		popupContext.activate();
		popupContext.set(TMP_ORIGINAL_CONTEXT, originalChild);

	}

	public void cleanUp(final Menu menu) {
		// System.err.println("cleanUp: " + menu);
	}

	public void dispose() {
		// System.err.println("dispose");
	}
}

Lines 25-31 Link Here

(-)src/org/eclipse/e4/ui/workbench/renderers/swt/MenuRenderer.java (-2 / +1 lines)
25	import org.eclipse.e4.ui.model.application.ui.menu.MMenuElement;	25	import org.eclipse.e4.ui.model.application.ui.menu.MMenuElement;
26	import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;	26	import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;
27	import org.eclipse.e4.ui.workbench.modeling.ExpressionContext;	27	import org.eclipse.e4.ui.workbench.modeling.ExpressionContext;
28	import org.eclipse.e4.ui.workbench.swt.modeling.MenuServiceFilter;
29	import org.eclipse.emf.ecore.EObject;	28	import org.eclipse.emf.ecore.EObject;
30	import org.eclipse.swt.SWT;	29	import org.eclipse.swt.SWT;
31	import org.eclipse.swt.events.DisposeEvent;	30	import org.eclipse.swt.events.DisposeEvent;
Lines 102-108 Link Here
102	}	101	}
103	Menu menu = mi.getMenu();	102	Menu menu = mi.getMenu();
104	MenuItem menuItem = new MenuItem(menu, SWT.PUSH);	103	MenuItem menuItem = new MenuItem(menu, SWT.PUSH);
105	menuItem.setText(MenuServiceFilter.NUL_MENU_ITEM);	104	menuItem.setText(MenuManagerRendererFilter.NUL_MENU_ITEM);
106	menuItem.setEnabled(false);	105	menuItem.setEnabled(false);
107	}	106	}
108	}	107	}





import java.util.List;
import org.eclipse.e4.ui.model.application.ui.MUIElement;
import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBarSeparator;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;
import org.eclipse.swt.widgets.Widget;

			return null;
		}
		if (nextVisibleChild.isVisible()
				&& (nextVisibleChild instanceof MToolBarSeparator)) {
			return null;
		}
		if (element instanceof MToolBarSeparator) {
			Menu menu = null;
			Object widget = element.getParent().getWidget();
			if (widget instanceof Menu) {
				menu = (Menu) widget;
			} else if (widget instanceof MenuItem) {
				menu = ((MenuItem) widget).getMenu();
			}
			if (menu != null) {
				newSep = new MenuItem(menu, SWT.SEPARATOR, addIndex);
			}
		} else if (element instanceof MToolBarSeparator) {
			ToolBar tb = parent instanceof ToolBar ? (ToolBar) parent
					: (ToolBar) element.getParent().getWidget();
			newSep = new ToolItem(tb, SWT.SEPARATOR, addIndex);




import org.eclipse.e4.ui.model.application.ui.basic.MPartStack;
import org.eclipse.e4.ui.model.application.ui.basic.MTrimBar;
import org.eclipse.e4.ui.model.application.ui.basic.MWindow;
import org.eclipse.e4.ui.model.application.ui.menu.MDirectMenuItem;
import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;
import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;
import org.eclipse.e4.ui.model.application.ui.menu.MRenderedMenu;
import org.eclipse.e4.ui.model.application.ui.menu.MRenderedMenuItem;
import org.eclipse.e4.ui.model.application.ui.menu.MRenderedToolBar;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBar;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBarSeparator;

public class WorkbenchRendererFactory implements IRendererFactory {

	private AreaRenderer areaRenderer;
	private MenuManagerRenderer menuRenderer;
	private HandledMenuItemRenderer handledMenuItemRenderer;
	private ToolBarRenderer toolbarRenderer;
	private ToolItemRenderer toolItemRenderer;
	private SeparatorRenderer separatorRenderer;

	private WBWRenderer wbwRenderer;

	private IEclipseContext context;
	private DirectMenuItemRenderer directMenuItemRenderer;
	private RenderedMenuRenderer renderedMenuRenderer;
	private RenderedMenuItemRenderer renderedMenuItemRenderer;
	private RenderedToolBarRenderer renderedToolbarRenderer;

	public AbstractPartRenderer getRenderer(MUIElement uiElement, Object parent) {

				initRenderer(contributedPartRenderer);
			}
			return contributedPartRenderer;
		} else if (uiElement instanceof MHandledMenuItem) {
			if (handledMenuItemRenderer == null) {
				handledMenuItemRenderer = new HandledMenuItemRenderer();
				initRenderer(handledMenuItemRenderer);
			}
			return handledMenuItemRenderer;
		} else if (uiElement instanceof MDirectMenuItem) {
			if (directMenuItemRenderer == null) {
				directMenuItemRenderer = new DirectMenuItemRenderer();
				initRenderer(directMenuItemRenderer);
			}
			return directMenuItemRenderer;
		} else if (uiElement instanceof MRenderedMenu) {
			if (renderedMenuRenderer == null) {
				renderedMenuRenderer = new RenderedMenuRenderer();
				initRenderer(renderedMenuRenderer);
			}
			return renderedMenuRenderer;
		} else if (uiElement instanceof MRenderedMenuItem) {
			if (renderedMenuItemRenderer == null) {
				renderedMenuItemRenderer = new RenderedMenuItemRenderer();
				initRenderer(renderedMenuItemRenderer);
			}
			return renderedMenuItemRenderer;
		} else if (uiElement instanceof MMenu) {
			if (menuRenderer == null) {
				menuRenderer = new MenuManagerRenderer();
				initRenderer(menuRenderer);
			}
			return menuRenderer;




import org.eclipse.e4.ui.model.application.ui.advanced.MPlaceholder;
import org.eclipse.e4.ui.model.application.ui.basic.MTrimmedWindow;
import org.eclipse.e4.ui.model.application.ui.basic.MWindow;
import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
import org.eclipse.e4.ui.services.IStylingEngine;
import org.eclipse.e4.ui.workbench.IPresentationEngine;
import org.eclipse.e4.ui.workbench.IResourceUtilities;

import org.eclipse.e4.ui.workbench.UIEvents;
import org.eclipse.e4.ui.workbench.modeling.EModelService;
import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
import org.eclipse.e4.ui.workbench.swt.modeling.MenuServiceFilter;
import org.eclipse.emf.ecore.impl.EObjectImpl;
import org.eclipse.equinox.app.IApplication;
import org.eclipse.equinox.app.IApplicationContext;


	IRendererFactory curFactory = null;

	MenuServiceFilter menuServiceFilter;

	org.eclipse.swt.widgets.Listener keyListener;

	// Life Cycle handlers

						.eContainer();
			}

			boolean menuChild = parent instanceof MMenu;

			// If the parent isn't displayed who cares?
			if (parent == null || parent.getWidget() == null || menuChild)
				return;

			if (changedElement.isToBeRendered()) {

			MElementContainer<MUIElement> changedElement = (MElementContainer<MUIElement>) changedObj;
			boolean isApplication = changedObj instanceof MApplication;

			boolean menuChild = changedObj instanceof MMenu;
			// If the parent isn't in the UI then who cares?
			AbstractPartRenderer renderer = getRendererFor(changedElement);
			if ((!isApplication && renderer == null) || menuChild)
				return;

			String eventType = (String) event


	public Object run(final MApplicationElement uiRoot,
			final IEclipseContext runContext) {
		final Display display;
		if (runContext.get(Display.class) != null) {
			display = runContext.get(Display.class);
		} else {
			display = Display.getDefault();
			runContext.set(Display.class, display);
		}
		Realm.runWithDefault(SWTObservables.getRealm(display), new Runnable() {

			public void run() {

				display.addFilter(SWT.KeyDown, keyListener);
				display.addFilter(SWT.Traverse, keyListener);

				menuServiceFilter = ContextInjectionFactory.make(
						MenuServiceFilter.class, runContext);
				display.addFilter(SWT.Show, menuServiceFilter);
				display.addFilter(SWT.Hide, menuServiceFilter);
				display.addFilter(SWT.Dispose, menuServiceFilter);
				runContext.set(MenuServiceFilter.class, menuServiceFilter);

				// Show the initial UI

				// Create a 'limbo' shell (used to host controls that shouldn't

	 * why this is needed we should make this safe for multiple calls
	 */
	private void cleanUp() {
		if (menuServiceFilter != null) {
			Display display = Display.getDefault();
			if (!display.isDisposed()) {
				display.removeFilter(SWT.Show, menuServiceFilter);
				display.removeFilter(SWT.Hide, menuServiceFilter);
				display.removeFilter(SWT.Dispose, menuServiceFilter);
				menuServiceFilter.dispose();
				menuServiceFilter = null;
				appContext.remove(MenuServiceFilter.class);
			}
		}
		if (keyListener != null) {
			Display display = Display.getDefault();
			if (!display.isDisposed()) {




/*******************************************************************************
 * Copyright (c) 2010 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.e4.ui.workbench.swt.modeling;

import java.lang.reflect.Method;
import java.util.HashMap;
import javax.inject.Inject;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.services.log.Logger;
import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
import org.eclipse.e4.ui.internal.workbench.swt.Policy;
import org.eclipse.e4.ui.internal.workbench.swt.WorkbenchSWTActivator;
import org.eclipse.e4.ui.model.application.MApplication;
import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;
import org.eclipse.e4.ui.workbench.IPresentationEngine;
import org.eclipse.e4.ui.workbench.modeling.EModelService;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Widget;

public class MenuManagerServiceFilter implements Listener {
	public static final String NUL_MENU_ITEM = "(None Applicable)"; //$NON-NLS-1$

	private static final String TMP_ORIGINAL_CONTEXT = "MenuServiceFilter.original.context";

	private static void trace(String msg, Widget menu, MMenu menuModel) {
		WorkbenchSWTActivator.trace(Policy.MENUS, msg + ": " + menu + ": "
				+ menuModel, null);
	}

	private static Method aboutToShow;

	public static Method getAboutToShow() {
		if (aboutToShow == null) {
			try {
				aboutToShow = MenuManager.class
						.getDeclaredMethod("handleAboutToShow");
				aboutToShow.setAccessible(true);
			} catch (SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (NoSuchMethodException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return aboutToShow;
	}

	@Inject
	private MApplication application;

	@Inject
	private IPresentationEngine renderer;

	@Inject
	private Logger logger;

	@Inject
	EModelService modelService;

	private HashMap<Menu, Runnable> pendingCleanup = new HashMap<Menu, Runnable>();

	public void handleEvent(final Event event) {
		// wrap the handling in a SafeRunner so that exceptions do not prevent
		// the menu from being shown
		SafeRunner.run(new ISafeRunnable() {
			public void handleException(Throwable e) {
				if (e instanceof Error) {
					// errors are deadly, we shouldn't ignore these
					throw (Error) e;
				} else {
					// log exceptions otherwise
					if (logger != null) {
						logger.error(e);
					}
				}
			}

			public void run() throws Exception {
				safeHandleEvent(event);
			}
		});
	}

	private void safeHandleEvent(Event event) {
		if (!(event.widget instanceof Menu)) {
			return;
		}
		final Menu menu = (Menu) event.widget;
		if (event.type == SWT.Dispose) {
			trace("handleMenu.Dispose", menu, null);
			cleanUp(menu);
		}
		Object obj = menu.getData(AbstractPartRenderer.OWNING_ME);
		if (obj == null && menu.getParentItem() != null) {
			obj = menu.getParentItem().getData(AbstractPartRenderer.OWNING_ME);
		}
		if (obj instanceof MPopupMenu) {
			handleContextMenu(event, menu, (MPopupMenu) obj);
		} else if (obj instanceof MMenu) {
			handleMenu(event, menu, (MMenu) obj);
		}
	}

	private void handleMenu(final Event event, final Menu menu,
			final MMenu menuModel) {
		if ((menu.getStyle() & SWT.BAR) != 0) {
			// don't process the menu bar, it's not fair :-)
			return;
		}
		switch (event.type) {
		case SWT.Show:
			cleanUp(menu);
			showMenu(event, menu, menuModel);
			break;
		case SWT.Hide:
			// TODO we'll clean up on show
			break;
		}
	}

	public void showMenu(final Event event, final Menu menu,
			final MMenu menuModel) {
		// System.err.println("showMenu: " + menuModel + "\n\t" + menu);
	}

	private void handleContextMenu(final Event event, final Menu menu,
			final MPopupMenu menuModel) {
		switch (event.type) {
		case SWT.Show:
			cleanUp(menu);
			showPopup(event, menu, menuModel);
			break;
		case SWT.Hide:
			hidePopup(event, menu, menuModel);
			break;
		}
	}

	public void hidePopup(Event event, Menu menu, MPopupMenu menuModel) {
		// System.err.println("hidePopup: " + menuModel + "\n\t" + menu);
		final IEclipseContext popupContext = menuModel.getContext();
		final IEclipseContext originalChild = (IEclipseContext) popupContext
				.get(TMP_ORIGINAL_CONTEXT);
		popupContext.remove(TMP_ORIGINAL_CONTEXT);
		if (!menu.isDisposed()) {
			menu.getDisplay().asyncExec(new Runnable() {
				public void run() {
					if (originalChild == null) {
						popupContext.deactivate();
					} else {
						originalChild.activate();
					}
				}
			});
		}
	}

	public void showPopup(final Event event, final Menu menu,
			final MPopupMenu menuModel) {
		// System.err.println("showPopup: " + menuModel + "\n\t" + menu);
		// we need some context foolery here
		final IEclipseContext popupContext = menuModel.getContext();
		final IEclipseContext parentContext = popupContext.getParent();
		final IEclipseContext originalChild = parentContext.getActiveChild();
		popupContext.activate();
		popupContext.set(TMP_ORIGINAL_CONTEXT, originalChild);

	}

	public void cleanUp(final Menu menu) {
		// System.err.println("cleanUp: " + menu);
	}

	public void dispose() {
		// System.err.println("dispose");
	}
}

Lines 13-25 Link Here

(-)src/org/eclipse/e4/ui/workbench/swt/modeling/MenuService.java (-14 / +33 lines)
13	import javax.inject.Inject;	13	import javax.inject.Inject;
14	import org.eclipse.e4.core.contexts.IEclipseContext;	14	import org.eclipse.e4.core.contexts.IEclipseContext;
15	import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;	15	import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
		16	import org.eclipse.e4.ui.model.application.ui.MElementContainer;
		17	import org.eclipse.e4.ui.model.application.ui.MUIElement;
16	import org.eclipse.e4.ui.model.application.ui.basic.MPart;	18	import org.eclipse.e4.ui.model.application.ui.basic.MPart;
17	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;	19	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
18	import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;	20	import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;
19	import org.eclipse.swt.SWT;	21	import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
20	import org.eclipse.swt.widgets.Control;	22	import org.eclipse.swt.widgets.Control;
21	import org.eclipse.swt.widgets.Event;
22	import org.eclipse.swt.widgets.Listener;
23	import org.eclipse.swt.widgets.Menu;	23	import org.eclipse.swt.widgets.Menu;
24		24
25	public class MenuService implements EMenuService {	25	public class MenuService implements EMenuService {
Lines 49-68 Link Here
49	if (mmenu.getWidget() != null) {	49	if (mmenu.getWidget() != null) {
50	return false;	50	return false;
51	}	51	}
52	Menu menu = new Menu(parentControl);	52	// we need to delegate to the renderer so that it "processes" the
53	parentControl.setMenu(menu);	53	// MenuManager correctly
54	mmenu.setWidget(menu);	54	IRendererFactory rendererFactory = myPart.getContext().get(
55	menu.setData(AbstractPartRenderer.OWNING_ME, mmenu);	55	IRendererFactory.class);
		56	AbstractPartRenderer renderer = rendererFactory.getRenderer(mmenu,
		57	parentControl);
56	IEclipseContext popupContext = myPart.getContext().createChild(	58	IEclipseContext popupContext = myPart.getContext().createChild(
57	"popup:" + mmenu.getElementId());	59	"popup:" + mmenu.getElementId());
58	mmenu.setContext(popupContext);	60	mmenu.setContext(popupContext);
59	menu.addListener(SWT.Dispose, new Listener() {	61	Object widget = renderer.createWidget(mmenu, parentControl);
60	public void handleEvent(Event event) {	62	if (!(widget instanceof Menu)) {
61	mmenu.getContext().dispose();	63	return false;
62	mmenu.setContext(null);	64	}
63	mmenu.setWidget(null);	65	renderer.bindWidget(mmenu, widget);
64	}	66	renderer.hookControllerLogic(mmenu);
65	});	67
		68	// Process its internal structure through the renderer that created
		69	// it
		70	Object castObject = mmenu;
		71	renderer.processContents((MElementContainer<MUIElement>) castObject);
		72
		73	// Allow a final chance to set up
		74	renderer.postProcess(mmenu);
		75
		76	// Now that we have a widget let the parent (if any) know
		77	if (mmenu.getParent() instanceof MUIElement) {
		78	MElementContainer<MUIElement> parentElement = mmenu.getParent();
		79	AbstractPartRenderer parentRenderer = rendererFactory.getRenderer(
		80	parentElement, null);
		81	if (parentRenderer != null)
		82	parentRenderer.childRendered(parentElement, mmenu);
		83	}
		84
66	return true;	85	return true;
67	}	86	}
68	}	87	}




/*******************************************************************************
 * Copyright (c) 2010 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.e4.ui.workbench.swt.modeling;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import javax.inject.Inject;
import org.eclipse.core.commands.ParameterizedCommand;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.e4.core.commands.EHandlerService;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.services.log.Logger;
import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;
import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
import org.eclipse.e4.ui.internal.workbench.swt.Policy;
import org.eclipse.e4.ui.internal.workbench.swt.WorkbenchSWTActivator;
import org.eclipse.e4.ui.model.application.MApplication;
import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;
import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
import org.eclipse.e4.ui.model.application.ui.menu.MMenuContribution;
import org.eclipse.e4.ui.model.application.ui.menu.MMenuElement;
import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;
import org.eclipse.e4.ui.model.application.ui.menu.MRenderedMenu;
import org.eclipse.e4.ui.workbench.IPresentationEngine;
import org.eclipse.e4.ui.workbench.modeling.EModelService;
import org.eclipse.e4.ui.workbench.modeling.ExpressionContext;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Widget;

public class MenuServiceFilter implements Listener {
	public static final String NUL_MENU_ITEM = "(None Applicable)"; //$NON-NLS-1$

	private static final String TMP_ORIGINAL_CONTEXT = "MenuServiceFilter.original.context";

	private static void trace(String msg, Widget menu, MMenu menuModel) {
		WorkbenchSWTActivator.trace(Policy.MENUS, msg + ": " + menu + ": "
				+ menuModel, null);
	}

	private static Method aboutToShow;

	public static Method getAboutToShow() {
		if (aboutToShow == null) {
			try {
				aboutToShow = MenuManager.class
						.getDeclaredMethod("handleAboutToShow");
				aboutToShow.setAccessible(true);
			} catch (SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (NoSuchMethodException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return aboutToShow;
	}

	@Inject
	private MApplication application;

	@Inject
	private IPresentationEngine renderer;

	@Inject
	private Logger logger;

	@Inject
	EModelService modelService;

	private HashMap<Menu, Runnable> pendingCleanup = new HashMap<Menu, Runnable>();

	public void handleEvent(final Event event) {
		// wrap the handling in a SafeRunner so that exceptions do not prevent
		// the menu from being shown
		SafeRunner.run(new ISafeRunnable() {
			public void handleException(Throwable e) {
				if (e instanceof Error) {
					// errors are deadly, we shouldn't ignore these
					throw (Error) e;
				} else {
					// log exceptions otherwise
					if (logger != null) {
						logger.error(e);
					}
				}
			}

			public void run() throws Exception {
				safeHandleEvent(event);
			}
		});
	}

	private void safeHandleEvent(Event event) {
		if (!(event.widget instanceof Menu)) {
			return;
		}
		final Menu menu = (Menu) event.widget;
		if (event.type == SWT.Dispose) {
			trace("handleMenu.Dispose", menu, null);
			cleanUp(menu);
		}
		Object obj = menu.getData(AbstractPartRenderer.OWNING_ME);
		if (obj == null && menu.getParentItem() != null) {
			obj = menu.getParentItem().getData(AbstractPartRenderer.OWNING_ME);
		}
		if (obj instanceof MRenderedMenu) {
			handlerRenderedMenu(event, menu, (MRenderedMenu) obj);
		} else if (obj instanceof MPopupMenu) {
			handleContextMenu(event, menu, (MPopupMenu) obj);
		} else if (obj instanceof MMenu) {
			handleMenu(event, menu, (MMenu) obj);
		}
	}

	private void handleMenu(final Event event, final Menu menu,
			final MMenu menuModel) {
		if ((menu.getStyle() & SWT.BAR) != 0) {
			// don't process the menu bar, it's not fair :-)
			return;
		}
		switch (event.type) {
		case SWT.Show:
			trace("handleMenu.Show", menu, menuModel);
			cleanUp(menu);
			showMenu(event, menu, menuModel);
			break;
		case SWT.Hide:
			trace("handleMenu.Hide", menu, menuModel);
			// TODO we'll clean up on show
			break;
		}
	}

	public void showMenu(final Event event, final Menu menu,
			final MMenu menuModel) {
		final IEclipseContext parentContext = modelService
				.getContainingContext(menuModel);

		final ArrayList<MMenuContribution> toContribute = new ArrayList<MMenuContribution>();
		final ArrayList<MMenuElement> menuContributionsToRemove = new ArrayList<MMenuElement>();
		ExpressionContext eContext = new ExpressionContext(parentContext);
		ContributionsAnalyzer.gatherMenuContributions(menuModel,
				application.getMenuContributions(), menuModel.getElementId(),
				toContribute, eContext, false);
		if (menu.getItemCount() == 1) {
			MenuItem item = menu.getItem(0);
			if (NUL_MENU_ITEM.equals(item.getText())) {
				item.dispose();
			}
		}
		ContributionsAnalyzer.addMenuContributions(menuModel, toContribute,
				menuContributionsToRemove);

		// create a cleanup routine for the Hide or next Show
		pendingCleanup.put(menu, new Runnable() {
			public void run() {
				if (!menu.isDisposed()) {
					unrender(menuContributionsToRemove);
				}
				removeMenuContributions(menuModel, menuContributionsToRemove);
			}
		});
		render(menu, menuModel);
		if (menu.getItemCount() == 0) {
			MenuItem menuItem = new MenuItem(menu, SWT.PUSH);
			menuItem.setText(NUL_MENU_ITEM);
			menuItem.setEnabled(false);
		}
	}

	private void handleContextMenu(final Event event, final Menu menu,
			final MPopupMenu menuModel) {
		switch (event.type) {
		case SWT.Show:
			trace("handleContextMenu.Show", menu, menuModel);
			cleanUp(menu);
			showPopup(event, menu, menuModel);
			break;
		case SWT.Hide:
			trace("handleContextMenu.Hide", menu, menuModel);
			hidePopup(event, menu, menuModel);
			break;
		}
	}

	public void hidePopup(Event event, Menu menu, MPopupMenu menuModel) {
		final IEclipseContext popupContext = menuModel.getContext();
		final IEclipseContext originalChild = (IEclipseContext) popupContext
				.get(TMP_ORIGINAL_CONTEXT);
		popupContext.remove(TMP_ORIGINAL_CONTEXT);
		if (!menu.isDisposed()) {
			menu.getDisplay().asyncExec(new Runnable() {
				public void run() {
					if (originalChild == null) {
						popupContext.deactivate();
					} else {
						originalChild.activate();
					}
				}
			});
		}
	}

	public void showPopup(final Event event, final Menu menu,
			final MPopupMenu menuModel) {
		// System.err.println("showPopup: " + menuModel + "\n\t" + menu);
		// we need some context foolery here
		final IEclipseContext popupContext = menuModel.getContext();
		final IEclipseContext parentContext = popupContext.getParent();
		final IEclipseContext originalChild = parentContext.getActiveChild();
		popupContext.activate();
		popupContext.set(TMP_ORIGINAL_CONTEXT, originalChild);

		final ArrayList<MMenuContribution> toContribute = new ArrayList<MMenuContribution>();
		final ArrayList<MMenuElement> menuContributionsToRemove = new ArrayList<MMenuElement>();
		ExpressionContext eContext = new ExpressionContext(popupContext);
		ContributionsAnalyzer.gatherMenuContributions(menuModel,
				application.getMenuContributions(), menuModel.getElementId(),
				toContribute, eContext, true);

		for (String tag : menuModel.getTags()) {
			if (tag.startsWith("popup:") && tag.length() > 6) {
				ContributionsAnalyzer.gatherMenuContributions(menuModel,
						application.getMenuContributions(), tag.substring(6),
						toContribute, eContext, false);
			}
		}
		ContributionsAnalyzer.addMenuContributions(menuModel, toContribute,
				menuContributionsToRemove);

		// create a cleanup routine for the Hide or next Show
		pendingCleanup.put(menu, new Runnable() {
			public void run() {
				if (!menu.isDisposed()) {
					unrender(menuContributionsToRemove);
				}
				removeMenuContributions(menuModel, menuContributionsToRemove);
			}
		});
		render(menu, menuModel);
	}

	private void render(final Menu menu, final MMenu menuModel) {
		trace("render", menu, menuModel);
		for (MMenuElement element : menuModel.getChildren()) {
			renderer.createGui(element, menu, null);
			if (element instanceof MHandledMenuItem) {
				setEnabled((MHandledMenuItem) element);
			}
		}
	}

	private void setEnabled(MHandledMenuItem item) {
		if (!item.isToBeRendered() || !item.isVisible()
				|| item.getWidget() == null) {
			return;
		}
		ParameterizedCommand cmd = item.getWbCommand();
		if (cmd == null) {
			return;
		}
		final IEclipseContext lclContext = modelService
				.getContainingContext(item);
		EHandlerService service = lclContext.get(EHandlerService.class);
		item.setEnabled(service.canExecute(cmd));
	}

	private void unrender(final List<MMenuElement> menuModel) {
		trace("unrender", null, null);
		for (MMenuElement element : menuModel) {
			renderer.removeGui(element);
		}
	}

	private void removeMenuContributions(final MMenu menuModel,
			final ArrayList<MMenuElement> menuContributionsToRemove) {
		for (MMenuElement item : menuContributionsToRemove) {
			trace("removeMenuContributions " + item,
					(Widget) menuModel.getWidget(), menuModel);
			menuModel.getChildren().remove(item);
		}
	}

	private void handlerRenderedMenu(final Event event, final Menu menu,
			final MRenderedMenu menuModel) {
		// Do nothing here for the moment, except process any cleanups
		switch (event.type) {
		case SWT.Show:
			trace("handlerRenderedMenu.Show", menu, menuModel);
			cleanUp(menu);
			showRenderedMenu(event, menu, menuModel);
			break;
		case SWT.Hide:
			trace("handlerRenderedMenu.Hide", menu, menuModel);
			// TODO don't care
			break;
		}
	}

	public void showRenderedMenu(final Event event, final Menu menu,
			final MRenderedMenu menuModel) {
		if (!(menuModel.getContributionManager() instanceof MenuManager)) {
			return;
		}

		MenuManager manager = (MenuManager) menuModel.getContributionManager();
		Method handleAboutToShow = getAboutToShow();
		try {
			handleAboutToShow.invoke(manager);
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		if (menuModel.getChildren().size() == 1
				&& menuModel.getChildren().get(0) instanceof MPopupMenu) {
			showPopup(event, menu, (MPopupMenu) menuModel.getChildren().get(0));
		} else {
			showMenu(event, menu, menuModel);
		}
		event.type = SWT.None;
		event.doit = false;
	}

	public void cleanUp(final Menu menu) {
		trace("cleanUp", menu, null);
		if (pendingCleanup.isEmpty()) {
			return;
		}
		Runnable cleanUp = pendingCleanup.remove(menu);
		if (cleanUp != null) {
			trace("cleanUp.run()", menu, null);
			cleanUp.run();
		}
	}

	public void dispose() {
		Menu[] keys = pendingCleanup.keySet().toArray(
				new Menu[pendingCleanup.size()]);
		for (Menu menu : keys) {
			cleanUp(menu);
		}
	}
}

Lines 12-25 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/e4/compatibility/CompatibilityView.java (-6 / +16 lines)
12	package org.eclipse.ui.internal.e4.compatibility;	12	package org.eclipse.ui.internal.e4.compatibility;
13		13
14	import javax.inject.Inject;	14	import javax.inject.Inject;
		15	import org.eclipse.e4.core.contexts.IEclipseContext;
15	import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;	16	import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;
		17	import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
16	import org.eclipse.e4.ui.model.application.ui.basic.MPart;	18	import org.eclipse.e4.ui.model.application.ui.basic.MPart;
17	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;	19	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
18	import org.eclipse.e4.ui.model.application.ui.menu.MRenderedMenu;
19	import org.eclipse.e4.ui.model.application.ui.menu.MRenderedToolBar;	20	import org.eclipse.e4.ui.model.application.ui.menu.MRenderedToolBar;
20	import org.eclipse.e4.ui.model.application.ui.menu.MToolBar;	21	import org.eclipse.e4.ui.model.application.ui.menu.MToolBar;
21	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;	22	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
		23	import org.eclipse.e4.ui.workbench.renderers.swt.MenuManagerRenderer;
		24	import org.eclipse.e4.ui.workbench.renderers.swt.MenuRenderer;
22	import org.eclipse.e4.ui.workbench.renderers.swt.StackRenderer;	25	import org.eclipse.e4.ui.workbench.renderers.swt.StackRenderer;
		26	import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
23	import org.eclipse.jface.action.MenuManager;	27	import org.eclipse.jface.action.MenuManager;
24	import org.eclipse.jface.action.ToolBarManager;	28	import org.eclipse.jface.action.ToolBarManager;
25	import org.eclipse.swt.widgets.Composite;	29	import org.eclipse.swt.widgets.Composite;
Lines 75-90 Link Here
75	// dispose the tb, it will be re-created when the tab is shown	79	// dispose the tb, it will be re-created when the tab is shown
76	tb.dispose();	80	tb.dispose();
77		81
		82	IEclipseContext context = getModel().getContext();
		83	IRendererFactory rendererFactory = context.get(IRendererFactory.class);
		84
78	MenuManager mm = (MenuManager) actionBars.getMenuManager();	85	MenuManager mm = (MenuManager) actionBars.getMenuManager();
79	MRenderedMenu menu = null;	86	MMenu menu = null;
80	for (MMenu me : part.getMenus()) {	87	for (MMenu me : part.getMenus()) {
81	if (me.getTags().contains(StackRenderer.TAG_VIEW_MENU) && (me instanceof MRenderedMenu)) {	88	if (me.getTags().contains(StackRenderer.TAG_VIEW_MENU)) {
82	menu = (MRenderedMenu) me;	89	menu = me;
83	break;	90	break;
84	}	91	}
85	}	92	}
86	if (menu == null) {	93	if (menu == null) {
87	menu = MenuFactoryImpl.eINSTANCE.createRenderedMenu();	94	menu = MenuFactoryImpl.eINSTANCE.createMenu();
88	menu.setElementId(part.getElementId());	95	menu.setElementId(part.getElementId());
89		96
90	menu.getTags().add(StackRenderer.TAG_VIEW_MENU);	97	menu.getTags().add(StackRenderer.TAG_VIEW_MENU);
Lines 92-98 Link Here
92	part.getMenus().add(menu);	99	part.getMenus().add(menu);
93		100
94	}	101	}
95	menu.setContributionManager(mm);	102	AbstractPartRenderer apr = rendererFactory.getRenderer(menu, parent);
		103	if (apr instanceof MenuRenderer) {
		104	((MenuManagerRenderer) apr).linkModelToManager(menu, mm);
		105	}
96		106
97	// Construct the toolbar (if necessary)	107	// Construct the toolbar (if necessary)
98	MToolBar toolbar = part.getToolbar();	108	MToolBar toolbar = part.getToolbar();

Return to bug 325392

Lines 25-33 Link Here

(-)src/org/eclipse/e4/ui/workbench/renderers/swt/MenuManagerRenderer.java (-48 / +38 lines)
25	import org.eclipse.e4.core.services.events.IEventBroker;	25	import org.eclipse.e4.core.services.events.IEventBroker;
26	import org.eclipse.e4.core.services.log.Logger;	26	import org.eclipse.e4.core.services.log.Logger;
27	import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;	27	import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;
28	import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
29	import org.eclipse.e4.ui.model.application.MApplication;	28	import org.eclipse.e4.ui.model.application.MApplication;
30	import org.eclipse.e4.ui.model.application.ui.MContext;
31	import org.eclipse.e4.ui.model.application.ui.MElementContainer;	29	import org.eclipse.e4.ui.model.application.ui.MElementContainer;
32	import org.eclipse.e4.ui.model.application.ui.MUIElement;	30	import org.eclipse.e4.ui.model.application.ui.MUIElement;
33	import org.eclipse.e4.ui.model.application.ui.MUILabel;	31	import org.eclipse.e4.ui.model.application.ui.MUILabel;
Lines 48-64 Link Here
48	import org.eclipse.emf.ecore.EObject;	46	import org.eclipse.emf.ecore.EObject;
49	import org.eclipse.emf.ecore.util.EcoreUtil;	47	import org.eclipse.emf.ecore.util.EcoreUtil;
50	import org.eclipse.jface.action.AbstractGroupMarker;	48	import org.eclipse.jface.action.AbstractGroupMarker;
		49	import org.eclipse.jface.action.ContributionItem;
51	import org.eclipse.jface.action.GroupMarker;	50	import org.eclipse.jface.action.GroupMarker;
52	import org.eclipse.jface.action.IContributionItem;	51	import org.eclipse.jface.action.IContributionItem;
53	import org.eclipse.jface.action.IMenuListener;
54	import org.eclipse.jface.action.IMenuManager;
55	import org.eclipse.jface.action.MenuManager;	52	import org.eclipse.jface.action.MenuManager;
56	import org.eclipse.jface.action.Separator;	53	import org.eclipse.jface.action.Separator;
57	import org.eclipse.jface.resource.ImageDescriptor;	54	import org.eclipse.jface.resource.ImageDescriptor;
		55	import org.eclipse.swt.SWT;
58	import org.eclipse.swt.events.DisposeEvent;	56	import org.eclipse.swt.events.DisposeEvent;
59	import org.eclipse.swt.events.DisposeListener;	57	import org.eclipse.swt.events.DisposeListener;
60	import org.eclipse.swt.widgets.Control;	58	import org.eclipse.swt.widgets.Control;
61	import org.eclipse.swt.widgets.Decorations;	59	import org.eclipse.swt.widgets.Decorations;
		60	import org.eclipse.swt.widgets.Display;
62	import org.eclipse.swt.widgets.Menu;	61	import org.eclipse.swt.widgets.Menu;
63	import org.osgi.service.event.Event;	62	import org.osgi.service.event.Event;
64	import org.osgi.service.event.EventHandler;	63	import org.osgi.service.event.EventHandler;
Lines 145-157 Link Here
145	return;	144	return;
146	}	145	}
147	manager.setVisible(menuModel.isVisible());	146	manager.setVisible(menuModel.isVisible());
		147	if (manager.getParent() != null) {
		148	manager.getParent().markDirty();
		149	}
148	} else if (element instanceof MMenuElement) {	150	} else if (element instanceof MMenuElement) {
149	MMenuElement itemModel = (MMenuElement) element;	151	MMenuElement itemModel = (MMenuElement) element;
150	IContributionItem ici = getContribution(itemModel);	152	Object obj = getContribution(itemModel);
151	if (ici == null) {	153	if (!(obj instanceof ContributionItem)) {
152	return;	154	return;
153	}	155	}
154	ici.setVisible(itemModel.isVisible());	156	ContributionItem item = (ContributionItem) obj;
		157	item.setVisible(itemModel.isVisible());
		158	if (item.getParent() != null) {
		159	item.getParent().markDirty();
		160	}
155	}	161	}
156	}	162	}
157	}	163	}
Lines 187-229 Link Here
187	}	193	}
188	};	194	};
189		195
190	private IMenuListener visibilityCalculationListener = new IMenuListener() {	196	private MenuManagerRendererFilter rendererFilter;
191	public void menuAboutToShow(IMenuManager manager) {
192	MenuManager menuManager = (MenuManager) manager;
193	if (menuManager.getMenu() == null) {
194	return;
195	}
196	MMenu menuModel = getMenuModel(menuManager);
197	if (menuModel == null) {
198	Menu menu = menuManager.getMenu();
199	Object obj = menu.getData(AbstractPartRenderer.OWNING_ME);
200	if (obj == null && menu.getParentItem() != null) {
201	obj = menu.getParentItem().getData(
202	AbstractPartRenderer.OWNING_ME);
203	}
204	if (!(obj instanceof MMenu)) {
205	return;
206	}
207	menuModel = (MMenu) obj;
208	} else if (menuModel.getWidget() == null) {
209	bindWidget(menuModel, menuManager.getMenu());
210	}
211	final IEclipseContext evalContext;
212	if (menuModel instanceof MContext) {
213	evalContext = ((MContext) menuModel).getContext();
214	} else {
215	evalContext = modelService.getContainingContext(menuModel);
216	}
217	HashSet<ContributionRecord> records = new HashSet<ContributionRecord>();
218	for (MMenuElement element : menuModel.getChildren()) {
219	ContributionRecord record = modelContributionToRecord
220	.get(element);
221	if (record != null && records.add(record)) {
222	record.updateVisibility(evalContext);
223	}
224	}
225	}
226	};
227		197
228	@PostConstruct	198	@PostConstruct
229	public void init() {	199	public void init() {
Lines 237-242 Link Here
237	eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UIElement.TOPIC),	207	eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UIElement.TOPIC),
238	toBeRenderedUpdater);	208	toBeRenderedUpdater);
239		209
		210	context.set(MenuManagerRenderer.class, this);
		211	Display display = context.get(Display.class);
		212	rendererFilter = ContextInjectionFactory.make(
		213	MenuManagerRendererFilter.class, context);
		214	display.addFilter(SWT.Show, rendererFilter);
		215	display.addFilter(SWT.Hide, rendererFilter);
		216	display.addFilter(SWT.Dispose, rendererFilter);
		217	context.set(MenuManagerRendererFilter.class, rendererFilter);
		218
240	}	219	}
241		220
242	@PreDestroy	221	@PreDestroy
Lines 245-250 Link Here
245	eventBroker.unsubscribe(selectionUpdater);	224	eventBroker.unsubscribe(selectionUpdater);
246	eventBroker.unsubscribe(enabledUpdater);	225	eventBroker.unsubscribe(enabledUpdater);
247	eventBroker.unsubscribe(toBeRenderedUpdater);	226	eventBroker.unsubscribe(toBeRenderedUpdater);
		227
		228	context.remove(MenuManagerRenderer.class);
		229	Display display = context.get(Display.class);
		230	if (display != null && !display.isDisposed()) {
		231	display.removeFilter(SWT.Show, rendererFilter);
		232	display.removeFilter(SWT.Hide, rendererFilter);
		233	display.removeFilter(SWT.Dispose, rendererFilter);
		234	context.remove(MenuManagerRendererFilter.class);
		235	ContextInjectionFactory.uninject(rendererFilter, context);
		236	rendererFilter = null;
		237	}
248	}	238	}
249		239
250	/*	240	/*
Lines 686-703 Link Here
686	public void linkModelToManager(MMenu model, MenuManager manager) {	676	public void linkModelToManager(MMenu model, MenuManager manager) {
687	modelToManager.put(model, manager);	677	modelToManager.put(model, manager);
688	managerToModel.put(manager, model);	678	managerToModel.put(manager, model);
689	manager.addMenuListener(visibilityCalculationListener);
690	}	679	}
691		680
692	public void clearModelToManager(MMenu model, MenuManager manager) {	681	public void clearModelToManager(MMenu model, MenuManager manager) {
693	modelToManager.remove(model);	682	modelToManager.remove(model);
694	managerToModel.remove(manager);	683	managerToModel.remove(manager);
695	if (manager != null) {
696	manager.removeMenuListener(visibilityCalculationListener);
697	}
698	}	684	}
699		685
700	public IContributionItem getContribution(MMenuElement model) {	686	public IContributionItem getContribution(MMenuElement model) {
701	return modelToContribution.get(model);	687	return modelToContribution.get(model);
702	}	688	}
		689
		690	public ContributionRecord getContributionRecord(MMenuElement element) {
		691	return modelContributionToRecord.get(element);
		692	}
703	}	693	}

Added Link Here

(-)src/org/eclipse/e4/ui/workbench/renderers/swt/MenuManagerRendererFilter.java (+397 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 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.e4.ui.workbench.renderers.swt;
12
13	import java.lang.reflect.InvocationTargetException;
14	import java.lang.reflect.Method;
15	import java.util.HashMap;
16	import java.util.HashSet;
17	import javax.inject.Inject;
18	import org.eclipse.core.commands.ParameterizedCommand;
19	import org.eclipse.core.runtime.ISafeRunnable;
20	import org.eclipse.core.runtime.SafeRunner;
21	import org.eclipse.e4.core.commands.EHandlerService;
22	import org.eclipse.e4.core.contexts.IEclipseContext;
23	import org.eclipse.e4.core.services.log.Logger;
24	import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;
25	import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
26	import org.eclipse.e4.ui.internal.workbench.swt.Policy;
27	import org.eclipse.e4.ui.internal.workbench.swt.WorkbenchSWTActivator;
28	import org.eclipse.e4.ui.model.application.ui.MContext;
29	import org.eclipse.e4.ui.model.application.ui.MCoreExpression;
30	import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;
31	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
32	import org.eclipse.e4.ui.model.application.ui.menu.MMenuElement;
33	import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;
34	import org.eclipse.e4.ui.model.application.ui.menu.MRenderedMenu;
35	import org.eclipse.e4.ui.workbench.modeling.EModelService;
36	import org.eclipse.e4.ui.workbench.modeling.ExpressionContext;
37	import org.eclipse.e4.ui.workbench.renderers.swt.MenuManagerRenderer.ContributionRecord;
38	import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
39	import org.eclipse.jface.action.MenuManager;
40	import org.eclipse.swt.SWT;
41	import org.eclipse.swt.widgets.Event;
42	import org.eclipse.swt.widgets.Listener;
43	import org.eclipse.swt.widgets.Menu;
44	import org.eclipse.swt.widgets.Widget;
45
46	public class MenuManagerRendererFilter implements Listener {
47	public static final String NUL_MENU_ITEM = "(None Applicable)"; //$NON-NLS-1$
48
49	private static final String TMP_ORIGINAL_CONTEXT = "MenuServiceFilter.original.context"; //$NON-NLS-1$
50
51	private static void trace(String msg, Widget menu, MMenu menuModel) {
52	WorkbenchSWTActivator.trace(Policy.MENUS, msg + ": " + menu + ": " //$NON-NLS-1$ //$NON-NLS-2$
53	+ menuModel, null);
54	}
55
56	private static Method aboutToShow;
57
58	private static Method aboutToHide;
59
60	public static Method getAboutToShow() {
61	if (aboutToShow == null) {
62	try {
63	aboutToShow = MenuManager.class
64	.getDeclaredMethod("handleAboutToShow"); //$NON-NLS-1$
65	aboutToShow.setAccessible(true);
66	} catch (SecurityException e) {
67	// TODO Auto-generated catch block
68	e.printStackTrace();
69	} catch (NoSuchMethodException e) {
70	// TODO Auto-generated catch block
71	e.printStackTrace();
72	}
73	}
74	return aboutToShow;
75	}
76
77	public static Method getAboutToHide() {
78	if (aboutToHide == null) {
79	try {
80	aboutToHide = MenuManager.class
81	.getDeclaredMethod("handleAboutToHide"); //$NON-NLS-1$
82	aboutToHide.setAccessible(true);
83	} catch (SecurityException e) {
84	// TODO Auto-generated catch block
85	e.printStackTrace();
86	} catch (NoSuchMethodException e) {
87	// TODO Auto-generated catch block
88	e.printStackTrace();
89	}
90	}
91	return aboutToHide;
92	}
93
94	@Inject
95	private Logger logger;
96
97	@Inject
98	private EModelService modelService;
99
100	@Inject
101	private IRendererFactory rendererFactory;
102
103	@Inject
104	private MenuManagerRenderer renderer;
105
106	private HashMap<Menu, Runnable> pendingCleanup = new HashMap<Menu, Runnable>();
107
108	private class SafeWrapper implements ISafeRunnable {
109	Event event;
110
111	public void handleException(Throwable e) {
112	if (e instanceof Error) {
113	// errors are deadly, we shouldn't ignore these
114	throw (Error) e;
115	}
116	// log exceptions otherwise
117	if (logger != null) {
118	logger.error(e);
119	}
120	}
121
122	public void run() throws Exception {
123	safeHandleEvent(event);
124	}
125	}
126
127	private SafeWrapper safeWrapper = new SafeWrapper();
128
129	public void handleEvent(final Event event) {
130	// wrap the handling in a SafeRunner so that exceptions do not prevent
131	// the menu from being shown
132	safeWrapper.event = event;
133	SafeRunner.run(safeWrapper);
134	}
135
136	private void safeHandleEvent(Event event) {
137	if (!(event.widget instanceof Menu)) {
138	return;
139	}
140	final Menu menu = (Menu) event.widget;
141	if (event.type == SWT.Dispose) {
142	trace("handleMenu.Dispose", menu, null); //$NON-NLS-1$
143	cleanUp(menu);
144	}
145	Object obj = menu.getData(AbstractPartRenderer.OWNING_ME);
146	if (obj == null && menu.getParentItem() != null) {
147	obj = menu.getParentItem().getData(AbstractPartRenderer.OWNING_ME);
148	if (obj == null) {
149	// hack because MenuManager doesn't do a setData()
150	Object tmp = menu.getParentItem().getData();
151	if (tmp instanceof MenuManager) {
152	MenuManager tmpManager = (MenuManager) tmp;
153	if (menu == tmpManager.getMenu()) {
154	// Eureka! We found a match, by golly!
155	obj = renderer.getMenuModel(tmpManager);
156	}
157	}
158	}
159	}
160	if (obj instanceof MPopupMenu) {
161	handleContextMenu(event, menu, (MPopupMenu) obj);
162	} else if (obj instanceof MMenu) {
163	handleMenu(event, menu, (MMenu) obj);
164	} else {
165	trace("Incorrect menu model to work with: " + obj, menu, null); //$NON-NLS-1$
166	}
167	}
168
169	private void handleMenu(final Event event, final Menu menu,
170	final MMenu menuModel) {
171	if ((menu.getStyle() & SWT.BAR) != 0) {
172	// don't process the menu bar, it's not fair :-)
173	return;
174	}
175	switch (event.type) {
176	case SWT.Show:
177	trace("handleMenu.Show", menu, menuModel); //$NON-NLS-1$
178	cleanUp(menu);
179	showMenu(event, menu, menuModel);
180	break;
181	case SWT.Hide:
182	trace("handleMenu.Hide", menu, menuModel); //$NON-NLS-1$
183	// TODO we'll clean up on show
184	break;
185	}
186	}
187
188	public void showMenu(final Event event, final Menu menu,
189	final MMenu menuModel) {
190	AbstractPartRenderer obj = rendererFactory.getRenderer(menuModel,
191	menu.getParent());
192	if (!(obj instanceof MenuManagerRenderer)) {
193	trace("Not the correct renderer: " + obj, menu, menuModel); //$NON-NLS-1$
194	return;
195	}
196	MenuManagerRenderer renderer = (MenuManagerRenderer) obj;
197	MenuManager menuManager = renderer.getManager(menuModel);
198	if (menuModel.getWidget() == null) {
199	renderer.bindWidget(menuModel, menuManager.getMenu());
200	}
201
202	Method handleAboutToShow = getAboutToShow();
203	try {
204	handleAboutToShow.invoke(menuManager);
205	} catch (IllegalArgumentException e) {
206	// TODO Auto-generated catch block
207	e.printStackTrace();
208	} catch (IllegalAccessException e) {
209	// TODO Auto-generated catch block
210	e.printStackTrace();
211	} catch (InvocationTargetException e) {
212	// TODO Auto-generated catch block
213	e.printStackTrace();
214	}
215
216	//
217	// TODO merge MRenderedMenuItems back into the model
218	// this will make the 3.x world visible to the model
219	// without actually modeling it fully
220	//
221
222	final IEclipseContext evalContext;
223	if (menuModel instanceof MContext) {
224	evalContext = ((MContext) menuModel).getContext();
225	} else {
226	evalContext = modelService.getContainingContext(menuModel);
227	}
228	updateElementVisibility(menuModel, renderer, menuManager, evalContext,
229	true);
230
231	// last thing to do, kill the event and update the menu manager
232	event.type = SWT.None;
233	event.doit = false;
234	menuManager.update(false);
235	}
236
237	/**
238	* @param menuModel
239	* @param renderer
240	* @param menuManager
241	* @param evalContext
242	*/
243	private void updateElementVisibility(final MMenu menuModel,
244	MenuManagerRenderer renderer, MenuManager menuManager,
245	final IEclipseContext evalContext, boolean recurse) {
246	final ExpressionContext exprContext = new ExpressionContext(evalContext);
247	HashSet<ContributionRecord> records = new HashSet<ContributionRecord>();
248	for (MMenuElement element : menuModel.getChildren()) {
249	ContributionRecord record = renderer.getContributionRecord(element);
250	if (record != null) {
251	if (records.add(record)) {
252	record.updateVisibility(evalContext);
253	}
254	} else {
255	updateVisibility(menuManager, element, exprContext);
256	}
257	if (recurse && element.isVisible() && element instanceof MMenu) {
258	MMenu childMenu = (MMenu) element;
259	MenuManager childManager = renderer.getManager(childMenu);
260	if (childManager != null) {
261	updateElementVisibility(childMenu, renderer, childManager,
262	evalContext, false);
263	}
264	}
265	}
266	}
267
268	/**
269	* @param menuManager
270	* @param element
271	* @param evalContext
272	*/
273	private void updateVisibility(MenuManager menuManager,
274	MMenuElement element, ExpressionContext evalContext) {
275	if (!(element.getVisibleWhen() instanceof MCoreExpression)) {
276	return;
277	}
278	boolean val = ContributionsAnalyzer.isVisible(
279	(MCoreExpression) element.getVisibleWhen(), evalContext);
280	if (val != element.isVisible()) {
281	element.setVisible(val);
282	menuManager.markDirty();
283	}
284	}
285
286	private void handleContextMenu(final Event event, final Menu menu,
287	final MPopupMenu menuModel) {
288	switch (event.type) {
289	case SWT.Show:
290	trace("handleContextMenu.Show", menu, menuModel); //$NON-NLS-1$
291	cleanUp(menu);
292	showPopup(event, menu, menuModel);
293	break;
294	case SWT.Hide:
295	trace("handleContextMenu.Hide", menu, menuModel); //$NON-NLS-1$
296	hidePopup(event, menu, menuModel);
297	break;
298	}
299	}
300
301	public void hidePopup(Event event, Menu menu, MPopupMenu menuModel) {
302	final IEclipseContext popupContext = menuModel.getContext();
303	final IEclipseContext originalChild = (IEclipseContext) popupContext
304	.get(TMP_ORIGINAL_CONTEXT);
305	popupContext.remove(TMP_ORIGINAL_CONTEXT);
306	if (!menu.isDisposed()) {
307	menu.getDisplay().asyncExec(new Runnable() {
308	public void run() {
309	if (originalChild == null) {
310	popupContext.deactivate();
311	} else {
312	originalChild.activate();
313	}
314	}
315	});
316	}
317	}
318
319	public void showPopup(final Event event, final Menu menu,
320	final MPopupMenu menuModel) {
321	// System.err.println("showPopup: " + menuModel + "\n\t" + menu);
322	// we need some context foolery here
323	final IEclipseContext popupContext = menuModel.getContext();
324	final IEclipseContext parentContext = popupContext.getParent();
325	final IEclipseContext originalChild = parentContext.getActiveChild();
326	popupContext.activate();
327	popupContext.set(TMP_ORIGINAL_CONTEXT, originalChild);
328
329	showMenu(event, menu, menuModel);
330	}
331
332	void setEnabled(MHandledMenuItem item) {
333	if (!item.isToBeRendered() \|\| !item.isVisible()
334	\|\| item.getWidget() == null) {
335	return;
336	}
337	ParameterizedCommand cmd = item.getWbCommand();
338	if (cmd == null) {
339	return;
340	}
341	final IEclipseContext lclContext = modelService
342	.getContainingContext(item);
343	EHandlerService service = lclContext.get(EHandlerService.class);
344	item.setEnabled(service.canExecute(cmd));
345	}
346
347	public void showRenderedMenu(final Event event, final Menu menu,
348	final MRenderedMenu menuModel) {
349	if (!(menuModel.getContributionManager() instanceof MenuManager)) {
350	return;
351	}
352
353	MenuManager manager = (MenuManager) menuModel.getContributionManager();
354	Method handleAboutToShow = getAboutToShow();
355	try {
356	handleAboutToShow.invoke(manager);
357	} catch (IllegalArgumentException e) {
358	// TODO Auto-generated catch block
359	e.printStackTrace();
360	} catch (IllegalAccessException e) {
361	// TODO Auto-generated catch block
362	e.printStackTrace();
363	} catch (InvocationTargetException e) {
364	// TODO Auto-generated catch block
365	e.printStackTrace();
366	}
367
368	if (menuModel.getChildren().size() == 1
369	&& menuModel.getChildren().get(0) instanceof MPopupMenu) {
370	showPopup(event, menu, (MPopupMenu) menuModel.getChildren().get(0));
371	} else {
372	showMenu(event, menu, menuModel);
373	}
374	event.type = SWT.None;
375	event.doit = false;
376	}
377
378	public void cleanUp(final Menu menu) {
379	trace("cleanUp", menu, null); //$NON-NLS-1$
380	if (pendingCleanup.isEmpty()) {
381	return;
382	}
383	Runnable cleanUp = pendingCleanup.remove(menu);
384	if (cleanUp != null) {
385	trace("cleanUp.run()", menu, null); //$NON-NLS-1$
386	cleanUp.run();
387	}
388	}
389
390	public void dispose() {
391	Menu[] keys = pendingCleanup.keySet().toArray(
392	new Menu[pendingCleanup.size()]);
393	for (Menu menu : keys) {
394	cleanUp(menu);
395	}
396	}
397	}

Lines 12-22 Link Here

(-)src/org/eclipse/e4/ui/workbench/renderers/swt/SeparatorRenderer.java (-16 / +2 lines)
12		12
13	import java.util.List;	13	import java.util.List;
14	import org.eclipse.e4.ui.model.application.ui.MUIElement;	14	import org.eclipse.e4.ui.model.application.ui.MUIElement;
15	import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;
16	import org.eclipse.e4.ui.model.application.ui.menu.MToolBarSeparator;	15	import org.eclipse.e4.ui.model.application.ui.menu.MToolBarSeparator;
17	import org.eclipse.swt.SWT;	16	import org.eclipse.swt.SWT;
18	import org.eclipse.swt.widgets.Menu;
19	import org.eclipse.swt.widgets.MenuItem;
20	import org.eclipse.swt.widgets.ToolBar;	17	import org.eclipse.swt.widgets.ToolBar;
21	import org.eclipse.swt.widgets.ToolItem;	18	import org.eclipse.swt.widgets.ToolItem;
22	import org.eclipse.swt.widgets.Widget;	19	import org.eclipse.swt.widgets.Widget;
Lines 41-61 Link Here
41	return null;	38	return null;
42	}	39	}
43	if (nextVisibleChild.isVisible()	40	if (nextVisibleChild.isVisible()
44	&& (nextVisibleChild instanceof MMenuSeparator \|\| nextVisibleChild instanceof MToolBarSeparator)) {	41	&& (nextVisibleChild instanceof MToolBarSeparator)) {
45	return null;	42	return null;
46	}	43	}
47	if (element instanceof MMenuSeparator) {	44	if (element instanceof MToolBarSeparator) {
48	Menu menu = null;
49	Object widget = element.getParent().getWidget();
50	if (widget instanceof Menu) {
51	menu = (Menu) widget;
52	} else if (widget instanceof MenuItem) {
53	menu = ((MenuItem) widget).getMenu();
54	}
55	if (menu != null) {
56	newSep = new MenuItem(menu, SWT.SEPARATOR, addIndex);
57	}
58	} else if (element instanceof MToolBarSeparator) {
59	ToolBar tb = parent instanceof ToolBar ? (ToolBar) parent	45	ToolBar tb = parent instanceof ToolBar ? (ToolBar) parent
60	: (ToolBar) element.getParent().getWidget();	46	: (ToolBar) element.getParent().getWidget();
61	newSep = new ToolItem(tb, SWT.SEPARATOR, addIndex);	47	newSep = new ToolItem(tb, SWT.SEPARATOR, addIndex);