Attachment #181191 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 ici = getContribution(itemModel);
					if (!(ici instanceof ContributionItem)) {
						return;
					}
					ContributionItem item = (ContributionItem) ici;
					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);

		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);

		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);
			ContextInjectionFactory.uninject(rendererFilter, context);
			context.remove(MenuManagerRendererFilter.class);
			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.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
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.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.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.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 MApplication application;

	@Inject
	private Logger logger;

	@Inject
	private EModelService modelService;

	@Inject
	private IRendererFactory rendererFactory;

	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 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);

		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) { //$NON-NLS-1$
				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); //$NON-NLS-1$

	}

	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); //$NON-NLS-1$
	}

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

	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

				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 / +36 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 ici = getContribution(itemModel);
151	if (ici == null) {	153	if (!(ici instanceof ContributionItem)) {
152	return;	154	return;
153	}	155	}
154	ici.setVisible(itemModel.isVisible());	156	ContributionItem item = (ContributionItem) ici;
		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	Display display = context.get(Display.class);
		211	rendererFilter = ContextInjectionFactory.make(
		212	MenuManagerRendererFilter.class, context);
		213	display.addFilter(SWT.Show, rendererFilter);
		214	display.addFilter(SWT.Hide, rendererFilter);
		215	display.addFilter(SWT.Dispose, rendererFilter);
		216	context.set(MenuManagerRendererFilter.class, rendererFilter);
		217
240	}	218	}
241		219
242	@PreDestroy	220	@PreDestroy
Lines 245-250 Link Here
245	eventBroker.unsubscribe(selectionUpdater);	223	eventBroker.unsubscribe(selectionUpdater);
246	eventBroker.unsubscribe(enabledUpdater);	224	eventBroker.unsubscribe(enabledUpdater);
247	eventBroker.unsubscribe(toBeRenderedUpdater);	225	eventBroker.unsubscribe(toBeRenderedUpdater);
		226
		227	Display display = context.get(Display.class);
		228	if (display != null && !display.isDisposed()) {
		229	display.removeFilter(SWT.Show, rendererFilter);
		230	display.removeFilter(SWT.Hide, rendererFilter);
		231	display.removeFilter(SWT.Dispose, rendererFilter);
		232	ContextInjectionFactory.uninject(rendererFilter, context);
		233	context.remove(MenuManagerRendererFilter.class);
		234	rendererFilter = null;
		235	}
248	}	236	}
249		237
250	/*	238	/*
Lines 686-703 Link Here
686	public void linkModelToManager(MMenu model, MenuManager manager) {	674	public void linkModelToManager(MMenu model, MenuManager manager) {
687	modelToManager.put(model, manager);	675	modelToManager.put(model, manager);
688	managerToModel.put(manager, model);	676	managerToModel.put(manager, model);
689	manager.addMenuListener(visibilityCalculationListener);
690	}	677	}
691		678
692	public void clearModelToManager(MMenu model, MenuManager manager) {	679	public void clearModelToManager(MMenu model, MenuManager manager) {
693	modelToManager.remove(model);	680	modelToManager.remove(model);
694	managerToModel.remove(manager);	681	managerToModel.remove(manager);
695	if (manager != null) {
696	manager.removeMenuListener(visibilityCalculationListener);
697	}
698	}	682	}
699		683
700	public IContributionItem getContribution(MMenuElement model) {	684	public IContributionItem getContribution(MMenuElement model) {
701	return modelToContribution.get(model);	685	return modelToContribution.get(model);
702	}	686	}
		687
		688	public ContributionRecord getContributionRecord(MMenuElement element) {
		689	return modelContributionToRecord.get(element);
		690	}
703	}	691	}

Added Link Here

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