Attachment #183010 for bug #325392

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

Lines 316-321 Link Here

(-)model/UIElements.ecore (+9 lines)
316	<eStructuralFeatures xsi:type="ecore:EAttribute" name="contributionItem" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"	316	<eStructuralFeatures xsi:type="ecore:EAttribute" name="contributionItem" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
317	transient="true"/>	317	transient="true"/>
318	</eClassifiers>	318	</eClassifiers>
		319	<eClassifiers xsi:type="ecore:EClass" name="OpaqueMenuItem" eSuperTypes="#//ui/menu/MenuItem">
		320	<eStructuralFeatures xsi:type="ecore:EAttribute" name="opaqueItem" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
		321	transient="true"/>
		322	</eClassifiers>
		323	<eClassifiers xsi:type="ecore:EClass" name="OpaqueMenuSeparator" eSuperTypes="#//ui/menu/MenuSeparator">
		324	<eStructuralFeatures xsi:type="ecore:EAttribute" name="opaqueItem" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
		325	transient="true"/>
		326	</eClassifiers>
		327	<eClassifiers xsi:type="ecore:EClass" name="OpaqueMenu" eSuperTypes="#//ui/menu/Menu"/>
319	</eSubpackages>	328	</eSubpackages>
320	<eSubpackages name="basic" nsURI="http://www.eclipse.org/ui/2010/UIModel/application/ui/basic"	329	<eSubpackages name="basic" nsURI="http://www.eclipse.org/ui/2010/UIModel/application/ui/basic"
321	nsPrefix="basic">	330	nsPrefix="basic">




<listEntry value="1"/>
</listAttribute>
<mapAttribute key="org.eclipse.debug.core.environmentVariables">
<mapEntry key="DISPLAY" value=":1.0"/>
</mapAttribute>
<stringAttribute key="org.eclipse.e4.ui.model.application" value="org.eclipse.pde.junit.runtime.coretestapplication"/>
<stringAttribute key="org.eclipse.jdt.junit.CONTAINER" value=""/>
<booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>
<stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>
<stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit3"/>
<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"/>
<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.e4.ui.tests.UIAllTests"/>
<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-os ${target.os} -ws ${target.ws} -arch ${target.arch} -nl ${target.nl}"/>
<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.e4.ui.tests"/>

Lines 33-43 Link Here

(-)src/org/eclipse/e4/ui/tests/workbench/MMenuItemTest.java (-14 / +146 lines)
33	import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;	33	import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
34	import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;	34	import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;
35	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;	35	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
36	import org.eclipse.e4.ui.workbench.renderers.swt.MenuRenderer;	36	import org.eclipse.e4.ui.workbench.renderers.swt.MenuManagerRenderer;
37	import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;	37	import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
		38	import org.eclipse.jface.action.IContributionItem;
		39	import org.eclipse.jface.action.MenuManager;
38	import org.eclipse.swt.SWT;	40	import org.eclipse.swt.SWT;
39	import org.eclipse.swt.widgets.Event;	41	import org.eclipse.swt.widgets.Event;
		42	import org.eclipse.swt.widgets.Menu;
40	import org.eclipse.swt.widgets.MenuItem;	43	import org.eclipse.swt.widgets.MenuItem;
		44	import org.eclipse.swt.widgets.Widget;
41		45
42	public class MMenuItemTest extends TestCase {	46	public class MMenuItemTest extends TestCase {
43	protected IEclipseContext appContext;	47	protected IEclipseContext appContext;
Lines 78-83 Link Here
78	wb = new E4Workbench(window, appContext);	82	wb = new E4Workbench(window, appContext);
79	wb.createAndRunUI(window);	83	wb.createAndRunUI(window);
80		84
		85	((MenuManager) ((Widget) menu.getWidget()).getData()).updateAll(true);
		86
81	Object widget = menuItem.getWidget();	87	Object widget = menuItem.getWidget();
82	assertNotNull(widget);	88	assertNotNull(widget);
83	assertTrue(widget instanceof MenuItem);	89	assertTrue(widget instanceof MenuItem);
Lines 153-158 Link Here
153	wb = new E4Workbench(window, appContext);	159	wb = new E4Workbench(window, appContext);
154	wb.createAndRunUI(window);	160	wb.createAndRunUI(window);
155		161
		162	((MenuManager) ((Widget) menu.getWidget()).getData()).updateAll(true);
		163
156	Object widget1 = menuItem1.getWidget();	164	Object widget1 = menuItem1.getWidget();
157	assertNotNull(widget1);	165	assertNotNull(widget1);
158	assertTrue(widget1 instanceof MenuItem);	166	assertTrue(widget1 instanceof MenuItem);
Lines 208-213 Link Here
208	wb = new E4Workbench(window, appContext);	216	wb = new E4Workbench(window, appContext);
209	wb.createAndRunUI(window);	217	wb.createAndRunUI(window);
210		218
		219	((MenuManager) ((Widget) menu.getWidget()).getData()).updateAll(true);
		220
211	Object widget1 = menuItem.getWidget();	221	Object widget1 = menuItem.getWidget();
212	assertNotNull(widget1);	222	assertNotNull(widget1);
213	assertTrue(widget1 instanceof MenuItem);	223	assertTrue(widget1 instanceof MenuItem);
Lines 224-230 Link Here
224	MCommand command = CommandsFactoryImpl.eINSTANCE.createCommand();	234	MCommand command = CommandsFactoryImpl.eINSTANCE.createCommand();
225		235
226	command.setElementId("commandId");	236	command.setElementId("commandId");
227	command.setCommandName("CommandForTest");
228		237
229	menuItem.setCommand(command);	238	menuItem.setCommand(command);
230	menuItem.setType(ItemType.CHECK);	239	menuItem.setType(ItemType.CHECK);
Lines 236-248 Link Here
236	MApplication application = ApplicationFactoryImpl.eINSTANCE	245	MApplication application = ApplicationFactoryImpl.eINSTANCE
237	.createApplication();	246	.createApplication();
238	application.getChildren().add(window);	247	application.getChildren().add(window);
239	application.getCommands().add(command);
240	application.setContext(appContext);	248	application.setContext(appContext);
241	appContext.set(MApplication.class.getName(), application);	249	appContext.set(MApplication.class.getName(), application);
242		250
243	wb = new E4Workbench(window, appContext);	251	wb = new E4Workbench(window, appContext);
244	wb.createAndRunUI(window);	252	wb.createAndRunUI(window);
245		253
		254	MenuManager barManager = (MenuManager) ((Menu) menu.getWidget())
		255	.getData();
		256	barManager.updateAll(true);
		257
246	Object widget1 = menuItem.getWidget();	258	Object widget1 = menuItem.getWidget();
247	assertNotNull(widget1);	259	assertNotNull(widget1);
248	assertTrue(widget1 instanceof MenuItem);	260	assertTrue(widget1 instanceof MenuItem);
Lines 251-257 Link Here
251	assertTrue(menuItemWidget.getSelection());	263	assertTrue(menuItemWidget.getSelection());
252	}	264	}
253		265
254	public void XXXtestSubMenuCreation() throws Exception {	266	public void testSubMenuCreation() throws Exception {
255	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();	267	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
256	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();	268	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
257	menuBar.setElementId("org.eclipse.ui.main.menu");	269	menuBar.setElementId("org.eclipse.ui.main.menu");
Lines 285-293 Link Here
285	wb = new E4Workbench(window, appContext);	297	wb = new E4Workbench(window, appContext);
286	wb.createAndRunUI(window);	298	wb.createAndRunUI(window);
287		299
		300	MenuManagerRenderer renderer = getRenderer(appContext, menuBar);
		301	MenuManager manager = renderer.getManager(menuBar);
		302	assertNotNull("failed to create menu bar manager", manager);
		303
		304	assertEquals(1, manager.getSize());
		305
		306	MenuManager fileManager = (MenuManager) manager.getItems()[0];
		307	MenuManager fileR = renderer.getManager(fileMenu);
		308	assertEquals(fileManager, fileR);
		309
		310	assertEquals(3, fileManager.getSize());
288	}	311	}
289		312
290	public void XXXtestTbrItem() throws Exception {	313	public void testTbrItem() throws Exception {
291	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();	314	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
292	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();	315	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
293	menuBar.setElementId("org.eclipse.ui.main.menu");	316	menuBar.setElementId("org.eclipse.ui.main.menu");
Lines 322-332 Link Here
322	wb = new E4Workbench(window, appContext);	345	wb = new E4Workbench(window, appContext);
323	wb.createAndRunUI(window);	346	wb.createAndRunUI(window);
324		347
325	// MenuRenderer renderer = getRenderer(appContext, menuBar);	348	MenuManagerRenderer renderer = getRenderer(appContext, menuBar);
		349	MenuManager manager = renderer.getManager(menuBar);
		350	assertNotNull("failed to create menu bar manager", manager);
		351
		352	assertEquals(1, manager.getSize());
		353
		354	MenuManager fileManager = (MenuManager) manager.getItems()[0];
		355	MenuManager fileR = renderer.getManager(fileMenu);
		356	assertEquals(fileManager, fileR);
326		357
		358	assertEquals(2, fileManager.getSize());
327	}	359	}
328		360
329	public void XXXtestInvisibleItem() throws Exception {	361	public void testInvisibleItem() throws Exception {
330	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();	362	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
331	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();	363	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
332	menuBar.setElementId("org.eclipse.ui.main.menu");	364	menuBar.setElementId("org.eclipse.ui.main.menu");
Lines 361-371 Link Here
361	wb = new E4Workbench(window, appContext);	393	wb = new E4Workbench(window, appContext);
362	wb.createAndRunUI(window);	394	wb.createAndRunUI(window);
363		395
364	// MenuRenderer renderer = getRenderer(appContext, menuBar);	396	MenuManagerRenderer renderer = getRenderer(appContext, menuBar);
		397	MenuManager manager = renderer.getManager(menuBar);
		398	assertNotNull("failed to create menu bar manager", manager);
		399
		400	assertEquals(1, manager.getSize());
		401
		402	MenuManager fileManager = (MenuManager) manager.getItems()[0];
		403	MenuManager fileR = renderer.getManager(fileMenu);
		404	assertEquals(fileManager, fileR);
365		405
		406	assertEquals(3, fileManager.getSize());
		407
		408	assertEquals(false, fileManager.getItems()[2].isVisible());
366	}	409	}
367		410
368	public void XXXtestMenuContribution() throws Exception {	411	public void testMenuContribution() throws Exception {
369	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();	412	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
370	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();	413	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
371	menuBar.setElementId("org.eclipse.ui.main.menu");	414	menuBar.setElementId("org.eclipse.ui.main.menu");
Lines 400-408 Link Here
400	wb = new E4Workbench(window, appContext);	443	wb = new E4Workbench(window, appContext);
401	wb.createAndRunUI(window);	444	wb.createAndRunUI(window);
402		445
		446	MenuManagerRenderer renderer = getRenderer(appContext, menuBar);
		447
		448	MenuManager fileManager = renderer.getManager(fileMenu);
		449	assertNotNull("No file menu?", fileManager);
		450
		451	assertEquals(4, fileManager.getSize());
		452
		453	assertEquals("mmc.item1", fileManager.getItems()[3].getId());
403	}	454	}
404		455
405	public void XXXtestWithVisible() throws Exception {	456	public void testWithVisible() throws Exception {
406	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();	457	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
407	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();	458	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
408	menuBar.setElementId("org.eclipse.ui.main.menu");	459	menuBar.setElementId("org.eclipse.ui.main.menu");
Lines 437-445 Link Here
437	wb = new E4Workbench(window, appContext);	488	wb = new E4Workbench(window, appContext);
438	wb.createAndRunUI(window);	489	wb.createAndRunUI(window);
439		490
		491	MenuManagerRenderer renderer = getRenderer(appContext, menuBar);
		492
		493	MenuManager fileManager = renderer.getManager(fileMenu);
		494	assertNotNull("No file menu?", fileManager);
		495
		496	assertEquals(4, fileManager.getSize());
		497
		498	IContributionItem mmcItem = fileManager.getItems()[3];
		499	assertEquals("mmc.item1", mmcItem.getId());
		500	assertEquals("before the first show, we have no context to evaluate",
		501	true, mmcItem.isVisible());
		502
		503	MenuManager manager = renderer.getManager(menuBar);
		504	manager.updateAll(true);
		505	Menu fileWidget = fileManager.getMenu();
		506	assertNotNull(fileWidget);
		507
		508	Event show = new Event();
		509	show.widget = fileWidget;
		510	show.type = SWT.Show;
		511
		512	Event hide = new Event();
		513	hide.widget = fileWidget;
		514	hide.type = SWT.Hide;
		515
		516	fileWidget.notifyListeners(SWT.Show, show);
		517
		518	assertEquals("after the first show, it should not be visible", false,
		519	mmcItem.isVisible());
		520
		521	fileWidget.notifyListeners(SWT.Hide, hide);
		522
		523	appContext.set("mmc1", Boolean.TRUE);
		524
		525	assertEquals("Change should not show up until next show", false,
		526	mmcItem.isVisible());
		527
		528	fileWidget.notifyListeners(SWT.Show, show);
		529
		530	assertEquals(true, mmcItem.isVisible());
		531
		532	fileWidget.notifyListeners(SWT.Hide, hide);
		533
		534	appContext.remove("mmc1");
		535
		536	fileWidget.notifyListeners(SWT.Show, show);
		537
		538	assertEquals(false, mmcItem.isVisible());
		539
		540	fileWidget.notifyListeners(SWT.Hide, hide);
440	}	541	}
441		542
442	public void XXXtestMenuBarVisibility() throws Exception {	543	public void testMenuBarVisibility() throws Exception {
443	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();	544	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
444	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();	545	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
445	menuBar.setElementId("org.eclipse.ui.main.menu");	546	menuBar.setElementId("org.eclipse.ui.main.menu");
Lines 474-479 Link Here
474	wb = new E4Workbench(window, appContext);	575	wb = new E4Workbench(window, appContext);
475	wb.createAndRunUI(window);	576	wb.createAndRunUI(window);
476		577
		578	MenuManagerRenderer renderer = getRenderer(appContext, menuBar);
		579	MenuManager manager = renderer.getManager(menuBar);
		580	manager.updateAll(true);
		581
		582	assertEquals(2, manager.getSize());
		583
		584	MenuManager vanishManager = (MenuManager) manager.getItems()[1];
		585	assertEquals("vanish", vanishManager.getId());
		586
		587	assertFalse(vanishManager.isVisible());
		588	assertNull(vanishManager.getMenu());
		589
		590	appContext.set("mmc1", Boolean.TRUE);
		591
		592	assertTrue(vanishManager.isVisible());
		593	assertNotNull(vanishManager.getMenu());
		594
		595	appContext.remove("mmc1");
		596
		597	assertFalse(vanishManager.isVisible());
		598	Menu vanishMenu = vanishManager.getMenu();
		599	if (vanishMenu != null) {
		600	assertTrue(vanishMenu.isDisposed());
		601	}
		602
		603	appContext.set("mmc1", Boolean.TRUE);
		604
		605	assertTrue(vanishManager.isVisible());
		606	assertNotNull(vanishManager.getMenu());
		607	assertFalse(vanishManager.getMenu().isDisposed());
477	}	608	}
478		609
479	private MMenuContribution createContribution(boolean withVisibleWhen) {	610	private MMenuContribution createContribution(boolean withVisibleWhen) {
Lines 533-543 Link Here
533	application.getMenuContributions().add(mmc);	664	application.getMenuContributions().add(mmc);
534	}	665	}
535		666
536	MenuRenderer getRenderer(IEclipseContext context, MUIElement element) {	667	private MenuManagerRenderer getRenderer(IEclipseContext context,
		668	MUIElement element) {
537	IRendererFactory rendererFactory = context.get(IRendererFactory.class);	669	IRendererFactory rendererFactory = context.get(IRendererFactory.class);
538	AbstractPartRenderer renderer = rendererFactory.getRenderer(element,	670	AbstractPartRenderer renderer = rendererFactory.getRenderer(element,
539	null);	671	null);
540	assertEquals(MenuRenderer.class, renderer.getClass());	672	assertEquals(MenuManagerRenderer.class, renderer.getClass());
541	return (MenuRenderer) renderer;	673	return (MenuManagerRenderer) renderer;
542	}	674	}
543	}	675	}

Lines 29-34 Link Here

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




			final List<MMenuContribution> menuContributionList, final String id,
			final ArrayList<MMenuContribution> toContribute, final ExpressionContext eContext,
			boolean includePopups) {
		ArrayList<String> popupIds = new ArrayList<String>();
		if (includePopups) {
			popupIds.add(POPUP_PARENT_ID);
			popupIds.add(id);
			for (String tag : menuModel.getTags()) {
				if (tag.startsWith("popup:")) { //$NON-NLS-1$
					String tmp = tag.substring("popup:".length()); //$NON-NLS-1$
					if (!popupIds.contains(tmp)) {
						popupIds.add(tmp);
					}
				}
			}
		}
		for (MMenuContribution menuContribution : menuContributionList) {
			String parentID = menuContribution.getParentId();
			if (parentID == null) {
				// it doesn't make sense for this to be null, temporary workaround for bug 320790
				continue;
			}
			boolean popup = includePopups && (menuModel instanceof MPopupMenu)
					&& popupIds.contains(parentID);
			boolean filtered = isFiltered(menuModel, menuContribution);
			if (filtered || (!popup && !parentID.equals(id)) || !menuContribution.isToBeRendered()) {
				continue;

		return isVisible((MCoreExpression) contribution.getVisibleWhen(), eContext);
	}

	public static boolean isVisible(MCoreExpression exp, ExpressionContext eContext) {
		Expression ref = null;
		if (exp.getCoreExpression() instanceof Expression) {
			ref = (Expression) exp.getCoreExpression();




	 */
	public void createAndRunUI(MApplicationElement uiRoot) {
		// Has someone already created one ?
		instantiateRenderer();

		if (renderer != null) {
			renderer.run(uiRoot, appContext);
		}
	}

	/**
	 * 
	 */
	public void instantiateRenderer() {
		renderer = (IPresentationEngine) appContext.get(IPresentationEngine.class.getName());
		if (renderer == null) {
			String presentationURI = (String) appContext.get(PRESENTATION_URI_ARG);

				logger.error("Failed to create the presentation engine for URI: " + presentationURI); //$NON-NLS-1$
			}
		}

		if (renderer != null) {
			renderer.run(uiRoot, appContext);
		}
	}

	private void init(MApplication appElement) {

Lines 276-281 Link Here

(-)src/org/eclipse/e4/ui/workbench/UIEvents.java (+5 lines)
276	public static final String MNEMONICS = "mnemonics"; //$NON-NLS-1$	276	public static final String MNEMONICS = "mnemonics"; //$NON-NLS-1$
277	}	277	}
278		278
		279	public static interface OpaqueMenuItem {
		280	public static final String TOPIC = UITopicBase + "/menu/OpaqueMenuItem"; //$NON-NLS-1$
		281	public static final String OPAQUEITEM = "opaqueItem"; //$NON-NLS-1$
		282	}
		283
279	public static interface RenderedMenu {	284	public static interface RenderedMenu {
280	public static final String TOPIC = UITopicBase + "/menu/RenderedMenu"; //$NON-NLS-1$	285	public static final String TOPIC = UITopicBase + "/menu/RenderedMenu"; //$NON-NLS-1$
281	public static final String CONTRIBUTIONMANAGER = "contributionManager"; //$NON-NLS-1$	286	public static final String CONTRIBUTIONMANAGER = "contributionManager"; //$NON-NLS-1$

Lines 20-33 Link Here

(-)src/org/eclipse/e4/ui/workbench/renderers/swt/MenuManagerRenderer.java (-90 / +296 lines)
20	import javax.annotation.PreDestroy;	20	import javax.annotation.PreDestroy;
21	import javax.inject.Inject;	21	import javax.inject.Inject;
22	import org.eclipse.e4.core.contexts.ContextInjectionFactory;	22	import org.eclipse.e4.core.contexts.ContextInjectionFactory;
		23	import org.eclipse.e4.core.contexts.IContextFunction;
23	import org.eclipse.e4.core.contexts.IEclipseContext;	24	import org.eclipse.e4.core.contexts.IEclipseContext;
24	import org.eclipse.e4.core.contexts.RunAndTrack;	25	import org.eclipse.e4.core.contexts.RunAndTrack;
25	import org.eclipse.e4.core.services.events.IEventBroker;	26	import org.eclipse.e4.core.services.events.IEventBroker;
26	import org.eclipse.e4.core.services.log.Logger;	27	import org.eclipse.e4.core.services.log.Logger;
27	import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;	28	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;	29	import org.eclipse.e4.ui.model.application.MApplication;
30	import org.eclipse.e4.ui.model.application.ui.MContext;	30	import org.eclipse.e4.ui.model.application.ui.MCoreExpression;
31	import org.eclipse.e4.ui.model.application.ui.MElementContainer;	31	import org.eclipse.e4.ui.model.application.ui.MElementContainer;
32	import org.eclipse.e4.ui.model.application.ui.MUIElement;	32	import org.eclipse.e4.ui.model.application.ui.MUIElement;
33	import org.eclipse.e4.ui.model.application.ui.MUILabel;	33	import org.eclipse.e4.ui.model.application.ui.MUILabel;
Lines 39-45 Link Here
39	import org.eclipse.e4.ui.model.application.ui.menu.MMenuElement;	39	import org.eclipse.e4.ui.model.application.ui.menu.MMenuElement;
40	import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;	40	import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
41	import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;	41	import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;
		42	import org.eclipse.e4.ui.model.application.ui.menu.MOpaqueMenu;
		43	import org.eclipse.e4.ui.model.application.ui.menu.MOpaqueMenuItem;
		44	import org.eclipse.e4.ui.model.application.ui.menu.MOpaqueMenuSeparator;
42	import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;	45	import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;
		46	import org.eclipse.e4.ui.model.application.ui.menu.MRenderedMenuItem;
		47	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
43	import org.eclipse.e4.ui.workbench.IResourceUtilities;	48	import org.eclipse.e4.ui.workbench.IResourceUtilities;
44	import org.eclipse.e4.ui.workbench.UIEvents;	49	import org.eclipse.e4.ui.workbench.UIEvents;
45	import org.eclipse.e4.ui.workbench.modeling.ExpressionContext;	50	import org.eclipse.e4.ui.workbench.modeling.ExpressionContext;
Lines 48-64 Link Here
48	import org.eclipse.emf.ecore.EObject;	53	import org.eclipse.emf.ecore.EObject;
49	import org.eclipse.emf.ecore.util.EcoreUtil;	54	import org.eclipse.emf.ecore.util.EcoreUtil;
50	import org.eclipse.jface.action.AbstractGroupMarker;	55	import org.eclipse.jface.action.AbstractGroupMarker;
		56	import org.eclipse.jface.action.ContributionItem;
51	import org.eclipse.jface.action.GroupMarker;	57	import org.eclipse.jface.action.GroupMarker;
52	import org.eclipse.jface.action.IContributionItem;	58	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;	59	import org.eclipse.jface.action.MenuManager;
56	import org.eclipse.jface.action.Separator;	60	import org.eclipse.jface.action.Separator;
57	import org.eclipse.jface.resource.ImageDescriptor;	61	import org.eclipse.jface.resource.ImageDescriptor;
		62	import org.eclipse.swt.SWT;
58	import org.eclipse.swt.events.DisposeEvent;	63	import org.eclipse.swt.events.DisposeEvent;
59	import org.eclipse.swt.events.DisposeListener;	64	import org.eclipse.swt.events.DisposeListener;
60	import org.eclipse.swt.widgets.Control;	65	import org.eclipse.swt.widgets.Control;
61	import org.eclipse.swt.widgets.Decorations;	66	import org.eclipse.swt.widgets.Decorations;
		67	import org.eclipse.swt.widgets.Display;
62	import org.eclipse.swt.widgets.Menu;	68	import org.eclipse.swt.widgets.Menu;
63	import org.osgi.service.event.Event;	69	import org.osgi.service.event.Event;
64	import org.osgi.service.event.EventHandler;	70	import org.osgi.service.event.EventHandler;
Lines 72-78 Link Here
72	private Map<MMenu, MenuManager> modelToManager = new HashMap<MMenu, MenuManager>();	78	private Map<MMenu, MenuManager> modelToManager = new HashMap<MMenu, MenuManager>();
73	private Map<MenuManager, MMenu> managerToModel = new HashMap<MenuManager, MMenu>();	79	private Map<MenuManager, MMenu> managerToModel = new HashMap<MenuManager, MMenu>();
74		80
75	private Map<MMenuItem, IContributionItem> modelToContribution = new HashMap<MMenuItem, IContributionItem>();	81	private Map<MMenuElement, IContributionItem> modelToContribution = new HashMap<MMenuElement, IContributionItem>();
		82	private Map<IContributionItem, MMenuElement> contributionToModel = new HashMap<IContributionItem, MMenuElement>();
76		83
77	private Map<MMenuElement, ContributionRecord> modelContributionToRecord = new HashMap<MMenuElement, ContributionRecord>();	84	private Map<MMenuElement, ContributionRecord> modelContributionToRecord = new HashMap<MMenuElement, ContributionRecord>();
78		85
Lines 126-133 Link Here
126	modelProcessSwitch(parent, itemModel);	133	modelProcessSwitch(parent, itemModel);
127	}	134	}
128	} else {	135	} else {
129	IContributionItem ici = modelToContribution	136	IContributionItem ici = getContribution(itemModel);
130	.remove(itemModel);	137	clearModelToContribution(itemModel, ici);
131	if (ici != null && parent != null) {	138	if (ici != null && parent != null) {
132	parent.remove(ici);	139	parent.remove(ici);
133	}	140	}
Lines 145-157 Link Here
145	return;	152	return;
146	}	153	}
147	manager.setVisible(menuModel.isVisible());	154	manager.setVisible(menuModel.isVisible());
		155	if (manager.getParent() != null) {
		156	manager.getParent().markDirty();
		157	}
148	} else if (element instanceof MMenuElement) {	158	} else if (element instanceof MMenuElement) {
149	MMenuElement itemModel = (MMenuElement) element;	159	MMenuElement itemModel = (MMenuElement) element;
150	IContributionItem ici = getContribution(itemModel);	160	Object obj = getContribution(itemModel);
151	if (ici == null) {	161	if (!(obj instanceof ContributionItem)) {
152	return;	162	return;
153	}	163	}
154	ici.setVisible(itemModel.isVisible());	164	ContributionItem item = (ContributionItem) obj;
		165	item.setVisible(itemModel.isVisible());
		166	if (item.getParent() != null) {
		167	item.getParent().markDirty();
		168	}
155	}	169	}
156	}	170	}
157	}	171	}
Lines 165-171 Link Here
165		179
166	MMenuItem itemModel = (MMenuItem) event	180	MMenuItem itemModel = (MMenuItem) event
167	.getProperty(UIEvents.EventTags.ELEMENT);	181	.getProperty(UIEvents.EventTags.ELEMENT);
168	IContributionItem ici = modelToContribution.get(itemModel);	182	IContributionItem ici = getContribution(itemModel);
169	if (ici != null) {	183	if (ici != null) {
170	ici.update();	184	ici.update();
171	}	185	}
Lines 180-229 Link Here
180		194
181	MMenuItem itemModel = (MMenuItem) event	195	MMenuItem itemModel = (MMenuItem) event
182	.getProperty(UIEvents.EventTags.ELEMENT);	196	.getProperty(UIEvents.EventTags.ELEMENT);
183	IContributionItem ici = modelToContribution.get(itemModel);	197	IContributionItem ici = getContribution(itemModel);
184	if (ici != null) {	198	if (ici != null) {
185	ici.update();	199	ici.update();
186	}	200	}
187	}	201	}
188	};	202	};
189		203
190	private IMenuListener visibilityCalculationListener = new IMenuListener() {	204	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		205
228	@PostConstruct	206	@PostConstruct
229	public void init() {	207	public void init() {
Lines 237-242 Link Here
237	eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UIElement.TOPIC),	215	eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UIElement.TOPIC),
238	toBeRenderedUpdater);	216	toBeRenderedUpdater);
239		217
		218	context.set(MenuManagerRenderer.class, this);
		219	Display display = context.get(Display.class);
		220	rendererFilter = ContextInjectionFactory.make(
		221	MenuManagerRendererFilter.class, context);
		222	display.addFilter(SWT.Show, rendererFilter);
		223	display.addFilter(SWT.Hide, rendererFilter);
		224	display.addFilter(SWT.Dispose, rendererFilter);
		225	context.set(MenuManagerRendererFilter.class, rendererFilter);
		226
240	}	227	}
241		228
242	@PreDestroy	229	@PreDestroy
Lines 245-250 Link Here
245	eventBroker.unsubscribe(selectionUpdater);	232	eventBroker.unsubscribe(selectionUpdater);
246	eventBroker.unsubscribe(enabledUpdater);	233	eventBroker.unsubscribe(enabledUpdater);
247	eventBroker.unsubscribe(toBeRenderedUpdater);	234	eventBroker.unsubscribe(toBeRenderedUpdater);
		235
		236	context.remove(MenuManagerRendererFilter.class);
		237	Display display = context.get(Display.class);
		238	if (display != null && !display.isDisposed() && rendererFilter != null) {
		239	display.removeFilter(SWT.Show, rendererFilter);
		240	display.removeFilter(SWT.Hide, rendererFilter);
		241	display.removeFilter(SWT.Dispose, rendererFilter);
		242	}
		243	if (rendererFilter != null) {
		244	ContextInjectionFactory.uninject(rendererFilter, context);
		245	rendererFilter = null;
		246	}
		247	context.remove(MenuManagerRenderer.class);
248	}	248	}
249		249
250	/*	250	/*
Lines 261-310 Link Here
261		261
262	final MMenu menuModel = (MMenu) element;	262	final MMenu menuModel = (MMenu) element;
263	Menu newMenu = null;	263	Menu newMenu = null;
		264	MenuManager menuManager = null;
264	boolean menuBar = false;	265	boolean menuBar = false;
265		266
266	if (parent instanceof Decorations) {	267	if (parent instanceof Decorations) {
267	MUIElement container = (MUIElement) ((EObject) element)	268	MUIElement container = (MUIElement) ((EObject) element)
268	.eContainer();	269	.eContainer();
269	if (container instanceof MWindow) {	270	if (container instanceof MWindow) {
270	MenuManager menuBarManager = getManager(menuModel);	271	menuManager = getManager(menuModel);
271	if (menuBarManager == null) {	272	if (menuManager == null) {
272	menuBarManager = new MenuManager(NO_LABEL,	273	menuManager = new MenuManager(NO_LABEL,
273	menuModel.getElementId());	274	menuModel.getElementId());
274	linkModelToManager(menuModel, menuBarManager);	275	linkModelToManager(menuModel, menuManager);
275	}	276	}
276	newMenu = menuBarManager.createMenuBar((Decorations) parent);	277	newMenu = menuManager.createMenuBar((Decorations) parent);
277	((Decorations) parent).setMenuBar(newMenu);	278	((Decorations) parent).setMenuBar(newMenu);
278	newMenu.setData(menuBarManager);	279	newMenu.setData(menuManager);
279	menuBar = true;	280	menuBar = true;
280	} else {	281	} else {
281	MenuManager popupManager = getManager(menuModel);	282	menuManager = getManager(menuModel);
282	if (popupManager == null) {	283	if (menuManager == null) {
283	popupManager = new MenuManager(NO_LABEL,	284	menuManager = new MenuManager(NO_LABEL,
284	menuModel.getElementId());	285	menuModel.getElementId());
285	linkModelToManager(menuModel, popupManager);	286	linkModelToManager(menuModel, menuManager);
286	}	287	}
287	newMenu = popupManager.createContextMenu((Control) parent);	288	newMenu = menuManager.createContextMenu((Control) parent);
288	((Control) parent).setMenu(newMenu);	289	// we can't be sure this is the correct parent.
289	newMenu.setData(popupManager);	290	// ((Control) parent).setMenu(newMenu);
		291	newMenu.setData(menuManager);
290	}	292	}
291	} else if (parent instanceof Menu) {	293	} else if (parent instanceof Menu) {
292	// Object data = ((Menu) parent).getData();	294	// Object data = ((Menu) parent).getData();
293	logger.debug(new Exception(), "Trying to render a sub menu " //$NON-NLS-1$	295	logger.debug(new Exception(), "Trying to render a sub menu " //$NON-NLS-1$
294	+ menuModel + "\n\t" + parent); //$NON-NLS-1$	296	+ menuModel + "\n\t" + parent); //$NON-NLS-1$
		297	return null;
295		298
296	} else if (parent instanceof Control) {	299	} else if (parent instanceof Control) {
297	MenuManager popupManager = getManager(menuModel);	300	menuManager = getManager(menuModel);
298	if (popupManager == null) {	301	if (menuManager == null) {
299	popupManager = new MenuManager(NO_LABEL,	302	menuManager = new MenuManager(NO_LABEL,
300	menuModel.getElementId());	303	menuModel.getElementId());
301	linkModelToManager(menuModel, popupManager);	304	linkModelToManager(menuModel, menuManager);
302	}	305	}
303	newMenu = popupManager.createContextMenu((Control) parent);	306	newMenu = menuManager.createContextMenu((Control) parent);
304	((Control) parent).setMenu(newMenu);	307	// we can't be sure this is the correct parent.
305	newMenu.setData(popupManager);	308	// ((Control) parent).setMenu(newMenu);
		309	newMenu.setData(menuManager);
		310	}
		311	if (!menuManager.getRemoveAllWhenShown()) {
		312	processContributions(menuModel, menuBar);
306	}	313	}
307	processContributions(menuModel, menuBar);
308	if (newMenu != null) {	314	if (newMenu != null) {
309	newMenu.addDisposeListener(new DisposeListener() {	315	newMenu.addDisposeListener(new DisposeListener() {
310	public void widgetDisposed(DisposeEvent e) {	316	public void widgetDisposed(DisposeEvent e) {
Lines 318-324 Link Here
318	/**	324	/**
319	* @param menuModel	325	* @param menuModel
320	*/	326	*/
321	protected void cleanUp(MMenu menuModel) {	327	public void cleanUp(MMenu menuModel) {
322	Collection<ContributionRecord> vals = modelContributionToRecord	328	Collection<ContributionRecord> vals = modelContributionToRecord
323	.values();	329	.values();
324	for (ContributionRecord record : vals	330	for (ContributionRecord record : vals
Lines 333-343 Link Here
333	MenuManager copyManager = getManager(menuCopy);	339	MenuManager copyManager = getManager(menuCopy);
334	clearModelToManager(menuCopy, copyManager);	340	clearModelToManager(menuCopy, copyManager);
335	if (copyManager != null) {	341	if (copyManager != null) {
		342	record.manager.remove(copyManager);
336	copyManager.dispose();	343	copyManager.dispose();
337	}	344	}
338	} else {	345	} else {
339	IContributionItem ici = modelToContribution	346	IContributionItem ici = getContribution(copy);
340	.remove(copy);	347	clearModelToContribution(copy, ici);
341	if (ici != null) {	348	if (ici != null) {
342	record.manager.remove(ici);	349	record.manager.remove(ici);
343	}	350	}
Lines 352-358 Link Here
352	* @param menuModel	359	* @param menuModel
353	* @param menuBar	360	* @param menuBar
354	*/	361	*/
355	private void processContributions(MMenu menuModel, boolean menuBar) {	362	public void processContributions(MMenu menuModel, boolean menuBar) {
356	final ArrayList<MMenuContribution> toContribute = new ArrayList<MMenuContribution>();	363	final ArrayList<MMenuContribution> toContribute = new ArrayList<MMenuContribution>();
357	ContributionsAnalyzer.XXXgatherMenuContributions(menuModel,	364	ContributionsAnalyzer.XXXgatherMenuContributions(menuModel,
358	application.getMenuContributions(), menuModel.getElementId(),	365	application.getMenuContributions(), menuModel.getElementId(),
Lines 500-506 Link Here
500	boolean isVisible = ContributionsAnalyzer.isVisible(	507	boolean isVisible = ContributionsAnalyzer.isVisible(
501	menuContribution, exprContext);	508	menuContribution, exprContext);
502	for (MMenuElement item : generatedElements) {	509	for (MMenuElement item : generatedElements) {
503	item.setVisible(isVisible);	510	if (isVisible && item.getVisibleWhen() != null) {
		511	MenuManagerRenderer.updateVisibility(manager, item,
		512	exprContext);
		513	} else {
		514	item.setVisible(isVisible);
		515	}
504	}	516	}
505	manager.markDirty();	517	manager.markDirty();
506	}	518	}
Lines 564-576 Link Here
564	* @param menuModel	576	* @param menuModel
565	*/	577	*/
566	private void processMenu(MenuManager parentManager, MMenu menuModel) {	578	private void processMenu(MenuManager parentManager, MMenu menuModel) {
567	String menuText = getText(menuModel);	579	MenuManager menuManager = getManager(menuModel);
568	ImageDescriptor desc = getImageDescriptor(menuModel);	580	if (menuManager == null) {
569	MenuManager menuManager = new MenuManager(menuText, desc,	581	String menuText = getText(menuModel);
570	menuModel.getElementId());	582	ImageDescriptor desc = getImageDescriptor(menuModel);
571	linkModelToManager(menuModel, menuManager);	583	menuManager = new MenuManager(menuText, desc,
572	menuManager.setVisible(menuModel.isVisible());	584	menuModel.getElementId());
573	parentManager.add(menuManager);	585	linkModelToManager(menuModel, menuManager);
		586	menuManager.setVisible(menuModel.isVisible());
		587	parentManager.add(menuManager);
		588	}
574	processContributions(menuModel, false);	589	processContributions(menuModel, false);
575	List<MMenuElement> parts = menuModel.getChildren();	590	List<MMenuElement> parts = menuModel.getChildren();
576	if (parts != null) {	591	if (parts != null) {
Lines 591-597 Link Here
591	if (!childME.isToBeRendered()) {	606	if (!childME.isToBeRendered()) {
592	return;	607	return;
593	}	608	}
594	if (childME instanceof MHandledMenuItem) {	609	if (childME instanceof MRenderedMenuItem) {
		610	MRenderedMenuItem itemModel = (MRenderedMenuItem) childME;
		611	processRenderedItem(menuManager, itemModel);
		612	} else if (childME instanceof MHandledMenuItem) {
595	MHandledMenuItem itemModel = (MHandledMenuItem) childME;	613	MHandledMenuItem itemModel = (MHandledMenuItem) childME;
596	processHandledItem(menuManager, itemModel);	614	processHandledItem(menuManager, itemModel);
597	} else if (childME instanceof MDirectMenuItem) {	615	} else if (childME instanceof MDirectMenuItem) {
Lines 600-605 Link Here
600	} else if (childME instanceof MMenuSeparator) {	618	} else if (childME instanceof MMenuSeparator) {
601	MMenuSeparator sep = (MMenuSeparator) childME;	619	MMenuSeparator sep = (MMenuSeparator) childME;
602	processSeparator(menuManager, sep);	620	processSeparator(menuManager, sep);
		621	} else if (childME instanceof MOpaqueMenu) {
		622	// I'm not sure what to do here
		623	// so I'll just take it out of the running
603	} else if (childME instanceof MMenu) {	624	} else if (childME instanceof MMenu) {
604	MMenu itemModel = (MMenu) childME;	625	MMenu itemModel = (MMenu) childME;
605	processMenu(menuManager, itemModel);	626	processMenu(menuManager, itemModel);
Lines 607-617 Link Here
607	}	628	}
608		629
609	/**	630	/**
		631	* @param parentManager
		632	* @param itemModel
		633	*/
		634	void processRenderedItem(MenuManager parentManager,
		635	MRenderedMenuItem itemModel) {
		636	IContributionItem ici = getContribution(itemModel);
		637	if (ici != null) {
		638	return;
		639	}
		640	Object obj = itemModel.getContributionItem();
		641	if (obj instanceof IContextFunction) {
		642	final IEclipseContext lclContext = getContext(itemModel);
		643	ici = (IContributionItem) ((IContextFunction) obj)
		644	.compute(lclContext);
		645	itemModel.setContributionItem(ici);
		646	} else if (obj instanceof IContributionItem) {
		647	ici = (IContributionItem) obj;
		648	}
		649	ici.setVisible(itemModel.isVisible());
		650	parentManager.add(ici);
		651	linkModelToContribution(itemModel, ici);
		652	}
		653
		654	/**
610	* @param menuManager	655	* @param menuManager
611	* @param itemModel	656	* @param itemModel
612	*/	657	*/
613	private void processSeparator(MenuManager menuManager,	658	private void processSeparator(MenuManager menuManager,
614	MMenuSeparator itemModel) {	659	MMenuSeparator itemModel) {
		660	IContributionItem ici = getContribution(itemModel);
		661	if (ici != null) {
		662	return;
		663	}
615	AbstractGroupMarker marker = null;	664	AbstractGroupMarker marker = null;
616	if (itemModel.isVisible()) {	665	if (itemModel.isVisible()) {
617	marker = new Separator();	666	marker = new Separator();
Lines 622-644 Link Here
622	}	671	}
623	}	672	}
624	menuManager.add(marker);	673	menuManager.add(marker);
		674	linkModelToContribution(itemModel, marker);
625	}	675	}
626		676
627	/**	677	/**
628	* @param parentManager	678	* @param parentManager
629	* @param itemModel	679	* @param itemModel
630	* @param id	680	* @param id
631	* TODO
632	*/	681	*/
633	void processDirectItem(MenuManager parentManager,	682	void processDirectItem(MenuManager parentManager,
634	MDirectMenuItem itemModel, String id) {	683	MDirectMenuItem itemModel, String id) {
		684	IContributionItem ici = getContribution(itemModel);
		685	if (ici != null) {
		686	return;
		687	}
635	final IEclipseContext lclContext = getContext(itemModel);	688	final IEclipseContext lclContext = getContext(itemModel);
636	DirectContributionItem ci = ContextInjectionFactory.make(	689	DirectContributionItem ci = ContextInjectionFactory.make(
637	DirectContributionItem.class, lclContext);	690	DirectContributionItem.class, lclContext);
638	ci.setModel(itemModel);	691	ci.setModel(itemModel);
639	ci.setVisible(itemModel.isVisible());	692	ci.setVisible(itemModel.isVisible());
640	parentManager.add(ci);	693	parentManager.add(ci);
641	modelToContribution.put(itemModel, ci);	694	linkModelToContribution(itemModel, ci);
642	}	695	}
643		696
644	/**	697	/**
Lines 647-659 Link Here
647	*/	700	*/
648	void processHandledItem(MenuManager parentManager,	701	void processHandledItem(MenuManager parentManager,
649	MHandledMenuItem itemModel) {	702	MHandledMenuItem itemModel) {
		703	IContributionItem ici = getContribution(itemModel);
		704	if (ici != null) {
		705	return;
		706	}
650	final IEclipseContext lclContext = getContext(itemModel);	707	final IEclipseContext lclContext = getContext(itemModel);
651	HandledContributionItem ci = ContextInjectionFactory.make(	708	HandledContributionItem ci = ContextInjectionFactory.make(
652	HandledContributionItem.class, lclContext);	709	HandledContributionItem.class, lclContext);
653	ci.setModel(itemModel);	710	ci.setModel(itemModel);
654	ci.setVisible(itemModel.isVisible());	711	ci.setVisible(itemModel.isVisible());
655	parentManager.add(ci);	712	parentManager.add(ci);
656	modelToContribution.put(itemModel, ci);	713	linkModelToContribution(itemModel, ci);
657	}	714	}
658		715
659	private String getText(MMenu menuModel) {	716	private String getText(MMenu menuModel) {
Lines 686-703 Link Here
686	public void linkModelToManager(MMenu model, MenuManager manager) {	743	public void linkModelToManager(MMenu model, MenuManager manager) {
687	modelToManager.put(model, manager);	744	modelToManager.put(model, manager);
688	managerToModel.put(manager, model);	745	managerToModel.put(manager, model);
689	manager.addMenuListener(visibilityCalculationListener);
690	}	746	}
691		747
692	public void clearModelToManager(MMenu model, MenuManager manager) {	748	public void clearModelToManager(MMenu model, MenuManager manager) {
693	modelToManager.remove(model);	749	modelToManager.remove(model);
694	managerToModel.remove(manager);	750	managerToModel.remove(manager);
695	if (manager != null) {
696	manager.removeMenuListener(visibilityCalculationListener);
697	}
698	}	751	}
699		752
700	public IContributionItem getContribution(MMenuElement model) {	753	public IContributionItem getContribution(MMenuElement model) {
701	return modelToContribution.get(model);	754	return modelToContribution.get(model);
702	}	755	}
		756
		757	public MMenuElement getMenuElement(IContributionItem item) {
		758	return contributionToModel.get(item);
		759	}
		760
		761	public void linkModelToContribution(MMenuElement model,
		762	IContributionItem item) {
		763	modelToContribution.put(model, item);
		764	contributionToModel.put(item, model);
		765	}
		766
		767	public void clearModelToContribution(MMenuElement model,
		768	IContributionItem item) {
		769	modelToContribution.remove(model);
		770	contributionToModel.remove(item);
		771	}
		772
		773	public ContributionRecord getContributionRecord(MMenuElement element) {
		774	return modelContributionToRecord.get(element);
		775	}
		776
		777	/**
		778	* @param menuManager
		779	* @param menuModel
		780	*/
		781	public void reconcileManagerToModel(MenuManager menuManager, MMenu menuModel) {
		782	List<MMenuElement> modelChildren = menuModel.getChildren();
		783
		784	HashSet<MOpaqueMenuItem> oldModelItems = new HashSet<MOpaqueMenuItem>();
		785	HashSet<MOpaqueMenu> oldMenus = new HashSet<MOpaqueMenu>();
		786	HashSet<MOpaqueMenuSeparator> oldSeps = new HashSet<MOpaqueMenuSeparator>();
		787	for (MMenuElement itemModel : modelChildren) {
		788	if (itemModel instanceof MOpaqueMenuSeparator) {
		789	oldSeps.add((MOpaqueMenuSeparator) itemModel);
		790	} else if (itemModel instanceof MOpaqueMenuItem) {
		791	oldModelItems.add((MOpaqueMenuItem) itemModel);
		792	} else if (itemModel instanceof MOpaqueMenu) {
		793	oldMenus.add((MOpaqueMenu) itemModel);
		794	}
		795	}
		796
		797	IContributionItem[] items = menuManager.getItems();
		798	for (int src = 0, dest = 0; src < items.length; src++, dest++) {
		799	IContributionItem item = items[src];
		800	if (item instanceof MenuManager) {
		801	MenuManager childManager = (MenuManager) item;
		802	MMenu childModel = getMenuModel(childManager);
		803	if (childModel == null) {
		804	MMenu legacyModel = MenuFactoryImpl.eINSTANCE
		805	.createOpaqueMenu();
		806	legacyModel.setElementId(childManager.getId());
		807	legacyModel.setVisible(childManager.isVisible());
		808	linkModelToManager(legacyModel, childManager);
		809	modelChildren.add(dest, legacyModel);
		810	} else {
		811	if (childModel instanceof MOpaqueMenu) {
		812	oldMenus.remove(childModel);
		813	}
		814	if (modelChildren.size() > dest) {
		815	if (modelChildren.get(dest) != childModel) {
		816	modelChildren.remove(childModel);
		817	modelChildren.add(dest, childModel);
		818	}
		819	} else {
820	modelChildren.add(childModel);
821	}
822	}
823	} else if (item.isSeparator() \|\| item.isGroupMarker()) {
824	MMenuElement menuElement = getMenuElement(item);
825	if (menuElement == null) {
826	MOpaqueMenuSeparator legacySep = MenuFactoryImpl.eINSTANCE
827	.createOpaqueMenuSeparator();
828	legacySep.setElementId(item.getId());
829	legacySep.setVisible(item.isVisible());
830	legacySep.setOpaqueItem(item);
831	linkModelToContribution(legacySep, item);
832	modelChildren.add(dest, legacySep);
833	} else if (menuElement instanceof MOpaqueMenuSeparator) {
834	MOpaqueMenuSeparator legacySep = (MOpaqueMenuSeparator) menuElement;
835	oldSeps.remove(legacySep);
836	if (modelChildren.size() > dest) {
837	if (modelChildren.get(dest) != legacySep) {
838	modelChildren.remove(legacySep);
839	modelChildren.add(dest, legacySep);
840	}
841	} else {
842	modelChildren.add(legacySep);
843	}
844	}
845	} else {
846	MMenuElement menuElement = getMenuElement(item);
847	if (menuElement == null) {
848	MOpaqueMenuItem legacyItem = MenuFactoryImpl.eINSTANCE
849	.createOpaqueMenuItem();
850	legacyItem.setElementId(item.getId());
851	legacyItem.setVisible(item.isVisible());
852	legacyItem.setOpaqueItem(item);
853	linkModelToContribution(legacyItem, item);
854	modelChildren.add(dest, legacyItem);
855	} else if (menuElement instanceof MOpaqueMenuItem) {
856	MOpaqueMenuItem legacyItem = (MOpaqueMenuItem) menuElement;
857	oldModelItems.remove(legacyItem);
858	if (modelChildren.size() > dest) {
859	if (modelChildren.get(dest) != legacyItem) {
860	modelChildren.remove(legacyItem);
861	modelChildren.add(dest, legacyItem);
862	}
863	} else {
864	modelChildren.add(legacyItem);
865	}
866	}
867	}
868	}
869	if (!oldModelItems.isEmpty()) {
870	modelChildren.removeAll(oldModelItems);
871	for (MOpaqueMenuItem model : oldModelItems) {
872	clearModelToContribution(model,
873	(IContributionItem) model.getOpaqueItem());
874	}
875	}
876	if (!oldMenus.isEmpty()) {
877	modelChildren.removeAll(oldMenus);
878	for (MOpaqueMenu oldMenu : oldMenus) {
879	MenuManager oldManager = getManager(oldMenu);
880	clearModelToManager(oldMenu, oldManager);
881	}
882	}
883	if (!oldSeps.isEmpty()) {
884	modelChildren.removeAll(oldSeps);
885	for (MOpaqueMenuSeparator model : oldSeps) {
886	clearModelToContribution(model,
887	(IContributionItem) model.getOpaqueItem());
888	}
889	}
890	}
891
892	/**
893	* @param menuManager
894	* @param element
895	* @param evalContext
896	*/
897	public static void updateVisibility(MenuManager menuManager,
898	MMenuElement element, ExpressionContext evalContext) {
899	if (!(element.getVisibleWhen() instanceof MCoreExpression)) {
900	return;
901	}
902	boolean val = ContributionsAnalyzer.isVisible(
903	(MCoreExpression) element.getVisibleWhen(), evalContext);
904	if (val != element.isVisible()) {
905	element.setVisible(val);
906	menuManager.markDirty();
907	}
908	}
703	}	909	}




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

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.HashSet;
import javax.inject.Inject;
import org.eclipse.core.commands.ParameterizedCommand;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.e4.core.commands.EHandlerService;
import org.eclipse.e4.core.contexts.ContextInjectionFactory;
import org.eclipse.e4.core.contexts.EclipseContextFactory;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.di.annotations.CanExecute;
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.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.menu.MDirectMenuItem;
import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;
import org.eclipse.e4.ui.model.application.ui.menu.MItem;
import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
import org.eclipse.e4.ui.model.application.ui.menu.MMenuElement;
import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;
import org.eclipse.e4.ui.workbench.modeling.EModelService;
import org.eclipse.e4.ui.workbench.modeling.ExpressionContext;
import org.eclipse.e4.ui.workbench.renderers.swt.MenuManagerRenderer.ContributionRecord;
import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Widget;

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

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

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

	private static Method aboutToShow;

	private static Method aboutToHide;

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

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

	@Inject
	private Logger logger;

	@Inject
	private EModelService modelService;

	@Inject
	private IRendererFactory rendererFactory;

	@Inject
	private MenuManagerRenderer renderer;

	@Inject
	private EHandlerService handlerService;

	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 ((menu.getStyle() & SWT.BAR) != 0) {
			// don't process the menu bar, it's not fair :-)
			return;
		}
		if (event.type == SWT.Dispose) {
			trace("handleMenu.Dispose", menu, null); //$NON-NLS-1$
			cleanUp(menu, null, null);
			return;
		}

		// fill in all of the pieces
		MMenu menuModel = null;
		MenuManager menuManager = null;
		Object obj = menu.getData(AbstractPartRenderer.OWNING_ME);
		if (obj == null && menu.getParentItem() != null) {
			obj = menu.getParentItem().getData(AbstractPartRenderer.OWNING_ME);
			if (obj == null) {
				// hack because MenuManager doesn't do a setData()
				Object tmp = menu.getParentItem().getData();
				if (tmp instanceof MenuManager) {
					MenuManager tmpManager = (MenuManager) tmp;
					if (menu == tmpManager.getMenu()) {
						// Eureka! We found a match, by golly!
						menuManager = tmpManager;
						obj = renderer.getMenuModel(tmpManager);
					}
				}
			}
		}
		if (obj instanceof MMenu) {
			menuModel = (MMenu) obj;
		}
		if (menuManager == null && menuModel != null) {
			menuManager = renderer.getManager(menuModel);
		}

		switch (event.type) {
		case SWT.Show:
			handleShow(event, menu, menuModel, menuManager);
			break;
		case SWT.Hide:
			handleHide(event, menu, menuModel, menuManager);
			break;
		}

	}

	private void handleShow(final Event event, final Menu menu,
			MMenu menuModel, MenuManager menuManager) {
		if (menuModel != null && menuManager != null) {
			cleanUp(menu, menuModel, menuManager);
		}
		if (menuModel instanceof MPopupMenu) {
			showPopup(event, menu, (MPopupMenu) menuModel, menuManager);
		}
		if (menuModel != null) {
			showMenu(event, menu, menuModel, menuManager);
		} else {
			trace("Incorrect menu model to work with " + menuManager, menu, menuModel); //$NON-NLS-1$
		}
	}

	private void handleHide(final Event event, final Menu menu,
			MMenu menuModel, MenuManager menuManager) {
		if (menuModel instanceof MPopupMenu) {
			hidePopup(event, menu, (MPopupMenu) menuModel, menuManager);
		}
	}

	public void showMenu(final Event event, final Menu menu,
			final MMenu menuModel, MenuManager menuManager) {
		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;
		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();
		}

		if (!menuManager.getRemoveAllWhenShown()) {
			renderer.reconcileManagerToModel(menuManager, menuModel);
			// this will make sure all model elements are represented in the
			// menu itself.
			// double cast because we're bad people
			renderer.processContents((MElementContainer<MUIElement>) ((Object) menuModel));
		}

		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 {
				MenuManagerRenderer.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);
				}
			}

			if (element instanceof MHandledMenuItem) {
				ParameterizedCommand cmd = ((MHandledMenuItem) element)
						.getWbCommand();
				if (cmd != null) {
					((MHandledMenuItem) element).setEnabled(handlerService
							.canExecute(cmd));
				}
			} else if (element instanceof MDirectMenuItem) {
				MDirectMenuItem contrib = (MDirectMenuItem) element;
				if (contrib.getObject() != null) {
					IEclipseContext staticContext = EclipseContextFactory
							.create();
					staticContext.set(MItem.class, contrib);
					Object rc = ContextInjectionFactory.invoke(
							contrib.getObject(), CanExecute.class, evalContext,
							staticContext, Boolean.TRUE);
					if (rc instanceof Boolean) {
						contrib.setEnabled((Boolean) rc);
					}
				}
			}
		}
	}

	public void hidePopup(Event event, Menu menu, MPopupMenu menuModel,
			MenuManager menuManager) {
		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, MenuManager menuManager) {
		// 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);
	}

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

	public void cleanUp(final Menu menu, MMenu menuModel,
			MenuManager menuManager) {
		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, null, null);
		}
	}
}




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

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

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

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

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

	private static Method aboutToShow;

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

	@Inject
	private Logger logger;

	@Inject
	EModelService modelService;

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

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

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

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

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

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

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

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

	}

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

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

Lines 25-31 Link Here

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





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

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




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

public class WorkbenchRendererFactory implements IRendererFactory {

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

	private WBWRenderer wbwRenderer;

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

	public AbstractPartRenderer getRenderer(MUIElement uiElement, Object parent) {

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




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

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


	IRendererFactory curFactory = null;

	MenuServiceFilter menuServiceFilter;

	org.eclipse.swt.widgets.Listener keyListener;

	// Life Cycle handlers

						.eContainer();
			}

			boolean menuChild = parent instanceof MMenu;

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

			if (changedElement.isToBeRendered()) {

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

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

			String eventType = (String) event


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

			public void run() {

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

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

				// Show the initial UI

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

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




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

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

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

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

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

	private static Method aboutToShow;

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

	@Inject
	private MApplication application;

	@Inject
	private IPresentationEngine renderer;

	@Inject
	private Logger logger;

	@Inject
	EModelService modelService;

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

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

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

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

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

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

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

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

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

	}

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

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

Lines 13-25 Link Here

(-)src/org/eclipse/e4/ui/workbench/swt/modeling/MenuService.java (-20 / +42 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 34-40 Link Here
34	for (MMenu mmenu : myPart.getMenus()) {	34	for (MMenu mmenu : myPart.getMenus()) {
35	if (menuId.equals(mmenu.getElementId())	35	if (menuId.equals(mmenu.getElementId())
36	&& mmenu instanceof MPopupMenu) {	36	&& mmenu instanceof MPopupMenu) {
37	if (registerMenu(parentControl, (MPopupMenu) mmenu)) {	37	Menu menu = registerMenu(parentControl, (MPopupMenu) mmenu,
		38	myPart);
		39	if (menu != null) {
		40	parentControl.setMenu(menu);
38	return (MPopupMenu) mmenu;	41	return (MPopupMenu) mmenu;
39	} else {	42	} else {
40	return null;	43	return null;
Lines 44-68 Link Here
44	return null;	47	return null;
45	}	48	}
46		49
47	private boolean registerMenu(final Control parentControl,	50	public static Menu registerMenu(final Control parentControl,
48	final MPopupMenu mmenu) {	51	final MPopupMenu mmenu, final MPart part) {
49	if (mmenu.getWidget() != null) {	52	if (mmenu.getWidget() != null) {
50	return false;	53	return (Menu) mmenu.getWidget();
51	}	54	}
52	Menu menu = new Menu(parentControl);	55	// we need to delegate to the renderer so that it "processes" the
53	parentControl.setMenu(menu);	56	// MenuManager correctly
54	mmenu.setWidget(menu);	57	IRendererFactory rendererFactory = part.getContext().get(
55	menu.setData(AbstractPartRenderer.OWNING_ME, mmenu);	58	IRendererFactory.class);
56	IEclipseContext popupContext = myPart.getContext().createChild(	59	AbstractPartRenderer renderer = rendererFactory.getRenderer(mmenu,
		60	parentControl);
		61	IEclipseContext popupContext = part.getContext().createChild(
57	"popup:" + mmenu.getElementId());	62	"popup:" + mmenu.getElementId());
58	mmenu.setContext(popupContext);	63	mmenu.setContext(popupContext);
59	menu.addListener(SWT.Dispose, new Listener() {	64	Object widget = renderer.createWidget(mmenu, parentControl);
60	public void handleEvent(Event event) {	65	if (!(widget instanceof Menu)) {
61	mmenu.getContext().dispose();	66	return null;
62	mmenu.setContext(null);	67	}
63	mmenu.setWidget(null);	68	renderer.bindWidget(mmenu, widget);
64	}	69	renderer.hookControllerLogic(mmenu);
65	});	70
66	return true;	71	// Process its internal structure through the renderer that created
		72	// it
		73	Object castObject = mmenu;
		74	renderer.processContents((MElementContainer<MUIElement>) castObject);
		75
		76	// Allow a final chance to set up
		77	renderer.postProcess(mmenu);
		78
		79	// Now that we have a widget let the parent (if any) know
		80	if (mmenu.getParent() instanceof MUIElement) {
		81	MElementContainer<MUIElement> parentElement = mmenu.getParent();
		82	AbstractPartRenderer parentRenderer = rendererFactory.getRenderer(
		83	parentElement, null);
		84	if (parentRenderer != null)
		85	parentRenderer.childRendered(parentElement, mmenu);
		86	}
		87
		88	return (Menu) widget;
67	}	89	}
68	}	90	}




/*******************************************************************************
 * 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 188-194 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/EditorMenuManager.java (+8 lines)
188	mc.getChildren().add(separator);	188	mc.getChildren().add(separator);
189	} else if (!(item instanceof SubContributionItem) && !(item instanceof SubMenuManager)) {	189	} else if (!(item instanceof SubContributionItem) && !(item instanceof SubMenuManager)) {
190	MRenderedMenuItem menuItem = MenuFactoryImpl.eINSTANCE.createRenderedMenuItem();	190	MRenderedMenuItem menuItem = MenuFactoryImpl.eINSTANCE.createRenderedMenuItem();
		191	menuItem.setElementId(item.getId());
191	menuItem.setContributionItem(item);	192	menuItem.setContributionItem(item);
		193	// IRendererFactory factory =
		194	// application.getContext().get(IRendererFactory.class);
		195	// AbstractPartRenderer renderer = factory.getRenderer(mc, null);
		196	// if (renderer instanceof MenuManagerRenderer) {
		197	// ((MenuManagerRenderer)
		198	// renderer).linkModelToContribution(menuItem, item);
		199	// }
192	mc.getChildren().add(menuItem);	200	mc.getChildren().add(menuItem);
193	}	201	}
194	}	202	}




import org.eclipse.core.runtime.IRegistryChangeEvent;
import org.eclipse.core.runtime.IRegistryChangeListener;
import org.eclipse.core.runtime.Platform;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;
import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
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.basic.MPart;
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.model.application.ui.menu.impl.MenuFactoryImpl;
import org.eclipse.e4.ui.workbench.renderers.swt.MenuManagerRenderer;
import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
import org.eclipse.e4.ui.workbench.swt.modeling.MenuService;
import org.eclipse.jface.action.ContributionManager;
import org.eclipse.jface.action.GroupMarker;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IMenuListener2;
import org.eclipse.jface.action.IMenuManager;

import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPartSite;
import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;

	
	private ArrayList actionContributionCache = new ArrayList();
	private ArrayList managerContributionCache = new ArrayList();
	private ArrayList<MRenderedMenu> renderedMenuCache = new ArrayList<MRenderedMenu>();
	private ArrayList<MRenderedMenu> lastRenderedMenuCache = new ArrayList<MRenderedMenu>();
	private boolean cleanupNeeded = false;

	private MPart modelPart;

			menuWrapper.setVisible(true);
		}
		createModelFor(id);
		addMenuId(id);
				
		Platform.getExtensionRegistry().addRegistryChangeListener(this);
	}

		}
		menuModel = null;
		for (MMenu item : modelPart.getMenus()) {
			if (id.equals(item.getElementId()) && item instanceof MPopupMenu
					&& item.getTags().contains("popup")) { //$NON-NLS-1$
				menuModel = (MPopupMenu) item;
				break;
			}
		}
		if (menuModel == null) {
			menuModel = MenuFactoryImpl.eINSTANCE.createPopupMenu();
			menuModel.setElementId(id);
			menuModel.getTags().add(ContributionsAnalyzer.MC_POPUP);
			modelPart.getMenus().add(menuModel);
			MPopupMenu popup = MenuFactoryImpl.eINSTANCE.createPopupMenu();
			popup.setElementId(id);
			popup.getTags().add(ContributionsAnalyzer.MC_POPUP);
			menuModel.getChildren().add(popup);
		}
		IRendererFactory factory = modelPart.getContext().get(IRendererFactory.class);
		AbstractPartRenderer obj = factory.getRenderer(menuModel, null);
		if (obj instanceof MenuManagerRenderer) {
			((MenuManagerRenderer) obj).linkModelToManager(menuModel, menu);
		}
		registerE4Support();
	}

	private void registerE4Support() {
		if (menuModel.getWidget() == null && menu.getMenu() != null) {
			MenuService.registerMenu(menu.getMenu().getParent(), menuModel, modelPart);
			menu.getMenu().setData(AbstractPartRenderer.OWNING_ME, menuModel);
			MPopupMenu popup = (MPopupMenu) menuModel.getChildren().get(0);
			IEclipseContext popupContext = modelPart.getContext().createChild(
					"popup:" + popup.getElementId()); //$NON-NLS-1$
			popup.setContext(popupContext);

		}
	}
	// getMenuId() added by Dan Rubel (dan_rubel@instantiations.com)

    public final void addMenuId(final String menuId) {
		bitSet &= ~STATIC_ACTION_READ;
		if (menuModel != null) {
			List<String> tags = menuModel.getTags();
			String tag = "popup:" + menuId; //$NON-NLS-1$
			if (!tags.contains(tag)) {
				tags.add(tag);

			}
		}
    	
		addMenuContributions(mgr);

    	readStaticActions();
        // test for additions removed to comply with menu contributions
        if (menuWrapper != null) {
            mgr = menuWrapper;
            menuWrapper.removeAll();
        }
		addMenuContributions(mgr);
        if ((bitSet & INCLUDE_EDITOR_INPUT) != 0) {
            addEditorActions(mgr);
        }
        addObjectActions(mgr);
        addStaticActions(mgr);
        cleanUpContributionCache();
    }
    

	/**
	 * well, this goes to the renderer.
	 * 
	 * @param mgr
	 */
	private void addMenuContributions(IMenuManager mgr) {
		IRendererFactory factory = modelPart.getContext().get(IRendererFactory.class);
		AbstractPartRenderer obj = factory.getRenderer(menuModel, null);
		if (obj instanceof MenuManagerRenderer) {
			MenuManagerRenderer renderer = (MenuManagerRenderer) obj;
			renderer.reconcileManagerToModel(menu, menuModel);
			renderer.processContributions(menuModel, false);
			// double cast because we're bad people
			renderer.processContents((MElementContainer<MUIElement>) ((Object) menuModel));

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

		for (String tag : popup.getTags()) {
			if (tag.startsWith("popup:") && tag.length() > 6) { //$NON-NLS-1$
				ContributionsAnalyzer.gatherMenuContributions(popup,
						application.getMenuContributions(), tag.substring(6), toContribute,
						eContext, false);
			}
		}
		for (MMenuContribution contribution : toContribute) {
			String positionInParent = contribution.getPositionInParent();
			String id = null;
			String modifier = null;
			if (positionInParent != null && positionInParent.length() > 0) {
				String[] array = positionInParent.split("="); //$NON-NLS-1$
				modifier = array[0];
				id = array[1];
			}
			if (id == null) {
				continue;
			}
			IContributionItem item = mgr.find(id);
			if (item == null) {
				if (IWorkbenchActionConstants.MB_ADDITIONS.equals(id)) {
					mgr.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
				} else {
					continue;
				}
			}
			for (MMenuElement element : contribution.getChildren()) {
				if (element instanceof MMenu) {
					MMenu menu = (MMenu) element;
					if (mgr.find(menu.getElementId()) != null) {
						continue;
					}
					MenuManager submenu = new MenuManager(menu.getLabel(), menu.getElementId());
					if (modifier.equals("before")) { //$NON-NLS-1$
						mgr.insertBefore(id, submenu);
					} else {
						mgr.insertAfter(id, submenu);
					}
					MRenderedMenu renderedMenu = MenuFactoryImpl.eINSTANCE.createRenderedMenu();
					renderedMenu.setElementId(menu.getElementId());
					renderedMenu.getTags().add(ContributionsAnalyzer.MC_POPUP);
					renderedMenu.setContributionManager(submenu);
					popup.getChildren().add(renderedMenu);
					renderedMenuCache.add(renderedMenu);
				}
			}
		}
	}

	private MPopupMenu menuModel;
    
    /**
	 * Notifies the listener that the menu is about to be hidden.
	 */
    public final void menuAboutToHide(final IMenuManager mgr) {
    	gatherContributions(mgr);
		if (!renderedMenuCache.isEmpty()) {
			lastRenderedMenuCache = renderedMenuCache;
			renderedMenuCache = new ArrayList<MRenderedMenu>();
		}
		cleanupNeeded = true;
    	// Remove this menu as a visible menu.
    	final IWorkbenchPartSite site = part.getSite();

			}
		}

		IRendererFactory factory = modelPart.getContext().get(IRendererFactory.class);
		AbstractPartRenderer obj = factory.getRenderer(menuModel, null);
		if (obj instanceof MenuManagerRenderer) {
			MenuManagerRenderer renderer = (MenuManagerRenderer) obj;
			renderer.cleanUp(menuModel);
		}

		managerContributionCache.clear();

	}

Lines 533-538 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/Workbench.java (+2 lines)
533	IEclipseContext workbenchContext = e4Workbench.getContext();	533	IEclipseContext workbenchContext = e4Workbench.getContext();
534	workbenchContext.set(Display.class, display);	534	workbenchContext.set(Display.class, display);
535		535
		536	e4Workbench.instantiateRenderer();
		537
536	// create the workbench instance	538	// create the workbench instance
537	Workbench workbench = new Workbench(display, advisor, e4Workbench	539	Workbench workbench = new Workbench(display, advisor, e4Workbench
538	.getApplication(), e4Workbench.getContext());	540	.getApplication(), e4Workbench.getContext());

Lines 659-664 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/WorkbenchWindow.java (+1 lines)
659	} else {	659	} else {
660	MRenderedMenuItem menuItem = MenuFactoryImpl.eINSTANCE.createRenderedMenuItem();	660	MRenderedMenuItem menuItem = MenuFactoryImpl.eINSTANCE.createRenderedMenuItem();
661	menuItem.setContributionItem(item);	661	menuItem.setContributionItem(item);
		662	menuItem.setElementId(item.getId());
662	menu.getChildren().add(menuItem);	663	menu.getChildren().add(menuItem);
663	}	664	}
664	}	665	}




package org.eclipse.ui.internal.e4.compatibility;

import javax.inject.Inject;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;
import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
import org.eclipse.e4.ui.model.application.ui.basic.MPart;
import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
import org.eclipse.e4.ui.model.application.ui.menu.MRenderedMenu;
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.impl.MenuFactoryImpl;
import org.eclipse.e4.ui.workbench.renderers.swt.MenuManagerRenderer;
import org.eclipse.e4.ui.workbench.renderers.swt.StackRenderer;
import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.swt.widgets.Composite;

		// dispose the tb, it will be re-created when the tab is shown
		tb.dispose();

		IEclipseContext context = getModel().getContext();
		IRendererFactory rendererFactory = context.get(IRendererFactory.class);

		MenuManager mm = (MenuManager) actionBars.getMenuManager();
		MMenu menu = null;
		for (MMenu me : part.getMenus()) {
			if (me.getTags().contains(StackRenderer.TAG_VIEW_MENU)) {
				menu = me;
				break;
			}
		}
		if (menu == null) {
			menu = MenuFactoryImpl.eINSTANCE.createMenu();
			menu.setElementId(part.getElementId());

			menu.getTags().add(StackRenderer.TAG_VIEW_MENU);

			part.getMenus().add(menu);

		}
		AbstractPartRenderer apr = rendererFactory.getRenderer(menu, parent);
		if (apr instanceof MenuManagerRenderer) {
			((MenuManagerRenderer) apr).linkModelToManager(menu, mm);
		}

		// Construct the toolbar (if necessary)
		MToolBar toolbar = part.getToolbar();




import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.InvalidRegistryObjectException;
import org.eclipse.e4.core.commands.ECommandService;
import org.eclipse.e4.core.contexts.ContextFunction;
import org.eclipse.e4.core.contexts.IContextFunction;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.di.annotations.CanExecute;
import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;
import org.eclipse.e4.ui.internal.workbench.ExtensionPointProxy;
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.ui.IActionDelegate;
import org.eclipse.ui.ISelectionService;
import org.eclipse.ui.IWorkbenchCommandConstants;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowPulldownDelegate;
import org.eclipse.ui.IWorkbenchWindowPulldownDelegate2;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.commands.ICommandImageService;
import org.eclipse.ui.commands.ICommandService;
import org.eclipse.ui.internal.ActionDescriptor;
import org.eclipse.ui.internal.OpenPreferencesAction;
import org.eclipse.ui.internal.PluginAction;
import org.eclipse.ui.internal.WorkbenchWindow;
import org.eclipse.ui.internal.handlers.ActionDelegateHandlerProxy;
import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;
import org.eclipse.ui.internal.services.ServiceLocator;
import org.eclipse.ui.internal.util.Util;
import org.eclipse.ui.menus.CommandContributionItem;
import org.eclipse.ui.menus.CommandContributionItemParameter;

				.getIconUrl(menuAddition, IWorkbenchRegistryConstants.ATT_ICON));
		element.setLabel(Util.safeString(text));

		for (final IConfigurationElement child : menuAddition.getChildren()) {
			if (child.getName().equals(IWorkbenchRegistryConstants.TAG_DYNAMIC)) {
				ContextFunction generator = new ContextFunction() {
					@Override
					public Object compute(IEclipseContext context) {
						ServiceLocator sl = new ServiceLocator();
						sl.setContext(context);
						DynamicMenuContributionItem item = new DynamicMenuContributionItem(
								getId(child), sl, child);
						return item;
					}
				};

				MRenderedMenuItem menuItem = MenuFactoryImpl.eINSTANCE.createRenderedMenuItem();
				menuItem.setElementId(getId(child));
				menuItem.setContributionItem(generator);
				// IRendererFactory factory =
				// application.getContext().get(IRendererFactory.class);
				// AbstractPartRenderer renderer = factory.getRenderer(element,
				// null);
				// if (renderer instanceof MenuManagerRenderer) {
				// ((MenuManagerRenderer)
				// renderer).linkModelToContribution(menuItem, item);
				// }
				element.getChildren().add(menuItem);
			}
		}

		String pulldown = element.getAttribute("pulldown"); //$NON-NLS-1$
		if (IWorkbenchRegistryConstants.STYLE_PULLDOWN.equals(style)
				|| (pulldown != null && pulldown.equals("true"))) { //$NON-NLS-1$
			MRenderedMenuItem item = MenuFactoryImpl.eINSTANCE.createRenderedMenuItem();
			item.setLabel(text);
			menu.setLabel(text);
			if (iconUri != null) {
				item.setIconURI(iconUri);
			}
			IContextFunction generator = new ContextFunction() {
				@Override
				public Object compute(IEclipseContext context) {
					IWorkbenchWindow window = context.get(IWorkbenchWindow.class);
					if (window == null) {
				private ActionDelegateHandlerProxy getProxy() {
					if (handlerProxy == null) {
						handlerProxy = new ActionDelegateHandlerProxy(element,
								IWorkbenchRegistryConstants.ATT_CLASS, id, parmCmd, PlatformUI
										.getWorkbench().getActiveWorkbenchWindow(), null, null,
								null);
					}
					return handlerProxy;
				}

				private IWorkbenchWindowPulldownDelegate getDelegate() {
					getProxy();
					if (handlerProxy == null) {
						return null;
					}
					ActionDescriptor desc = new ActionDescriptor(element,
							ActionDescriptor.T_WORKBENCH_PULLDOWN, window);
					final PluginAction action = desc.getAction();
					return new ActionContributionItem(action) {
						@Override
						public void dispose() {
							super.dispose();
							action.disposeDelegate();
						}
					};
				}
			};
			item.setContributionItem(generator);
			return item;
				public Menu getMenu(Control parent) {
					return getDelegate() == null ? null : getDelegate().getMenu(parent);
				}

				public void dispose() {
					if (handlerProxy != null) {
						handlerProxy.dispose();
						handlerProxy = null;
					}
				}
			});
			return menu;
		}

		ItemType type = ItemType.PUSH;

Return to bug 325392

Lines 20-33 Link Here

(-)UIAllTests.launch (-2 / +2 lines)
20	<listEntry value="1"/>	20	<listEntry value="1"/>
21	</listAttribute>	21	</listAttribute>
22	<mapAttribute key="org.eclipse.debug.core.environmentVariables">	22	<mapAttribute key="org.eclipse.debug.core.environmentVariables">
23	<mapEntry key="DISPLAY" value=":8.0"/>	23	<mapEntry key="DISPLAY" value=":1.0"/>
24	</mapAttribute>	24	</mapAttribute>
25	<stringAttribute key="org.eclipse.e4.ui.model.application" value="org.eclipse.pde.junit.runtime.coretestapplication"/>	25	<stringAttribute key="org.eclipse.e4.ui.model.application" value="org.eclipse.pde.junit.runtime.coretestapplication"/>
26	<stringAttribute key="org.eclipse.jdt.junit.CONTAINER" value=""/>	26	<stringAttribute key="org.eclipse.jdt.junit.CONTAINER" value=""/>
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 104-117 Link Here

(-)src/org/eclipse/e4/ui/internal/workbench/ContributionsAnalyzer.java (-3 / +16 lines)
104	final List<MMenuContribution> menuContributionList, final String id,	104	final List<MMenuContribution> menuContributionList, final String id,
105	final ArrayList<MMenuContribution> toContribute, final ExpressionContext eContext,	105	final ArrayList<MMenuContribution> toContribute, final ExpressionContext eContext,
106	boolean includePopups) {	106	boolean includePopups) {
		107	ArrayList<String> popupIds = new ArrayList<String>();
		108	if (includePopups) {
		109	popupIds.add(POPUP_PARENT_ID);
		110	popupIds.add(id);
		111	for (String tag : menuModel.getTags()) {
		112	if (tag.startsWith("popup:")) { //$NON-NLS-1$
		113	String tmp = tag.substring("popup:".length()); //$NON-NLS-1$
		114	if (!popupIds.contains(tmp)) {
		115	popupIds.add(tmp);
		116	}
		117	}
		118	}
		119	}
107	for (MMenuContribution menuContribution : menuContributionList) {	120	for (MMenuContribution menuContribution : menuContributionList) {
108	String parentID = menuContribution.getParentId();	121	String parentID = menuContribution.getParentId();
109	if (parentID == null) {	122	if (parentID == null) {
110	// it doesn't make sense for this to be null, temporary workaround for bug 320790	123	// it doesn't make sense for this to be null, temporary workaround for bug 320790
111	continue;	124	continue;
112	}	125	}
113	boolean popup = parentID.equals(POPUP_PARENT_ID) && (menuModel instanceof MPopupMenu)	126	boolean popup = includePopups && (menuModel instanceof MPopupMenu)
114	&& includePopups;	127	&& popupIds.contains(parentID);
115	boolean filtered = isFiltered(menuModel, menuContribution);	128	boolean filtered = isFiltered(menuModel, menuContribution);
116	if (filtered \|\| (!popup && !parentID.equals(id)) \|\| !menuContribution.isToBeRendered()) {	129	if (filtered \|\| (!popup && !parentID.equals(id)) \|\| !menuContribution.isToBeRendered()) {
117	continue;	130	continue;
Lines 176-182 Link Here
176	return isVisible((MCoreExpression) contribution.getVisibleWhen(), eContext);	189	return isVisible((MCoreExpression) contribution.getVisibleWhen(), eContext);
177	}	190	}
178		191
179	static boolean isVisible(MCoreExpression exp, ExpressionContext eContext) {	192	public static boolean isVisible(MCoreExpression exp, ExpressionContext eContext) {
180	Expression ref = null;	193	Expression ref = null;
181	if (exp.getCoreExpression() instanceof Expression) {	194	if (exp.getCoreExpression() instanceof Expression) {
182	ref = (Expression) exp.getCoreExpression();	195	ref = (Expression) exp.getCoreExpression();

Lines 85-90 Link Here

(-)src/org/eclipse/e4/ui/internal/workbench/E4Workbench.java (-4 / +11 lines)
85	*/	85	*/
86	public void createAndRunUI(MApplicationElement uiRoot) {	86	public void createAndRunUI(MApplicationElement uiRoot) {
87	// Has someone already created one ?	87	// Has someone already created one ?
		88	instantiateRenderer();
		89
		90	if (renderer != null) {
		91	renderer.run(uiRoot, appContext);
		92	}
		93	}
		94
		95	/**
		96	*
		97	*/
		98	public void instantiateRenderer() {
88	renderer = (IPresentationEngine) appContext.get(IPresentationEngine.class.getName());	99	renderer = (IPresentationEngine) appContext.get(IPresentationEngine.class.getName());
89	if (renderer == null) {	100	if (renderer == null) {
90	String presentationURI = (String) appContext.get(PRESENTATION_URI_ARG);	101	String presentationURI = (String) appContext.get(PRESENTATION_URI_ARG);
Lines 99-108 Link Here
99	logger.error("Failed to create the presentation engine for URI: " + presentationURI); //$NON-NLS-1$	110	logger.error("Failed to create the presentation engine for URI: " + presentationURI); //$NON-NLS-1$
100	}	111	}
101	}	112	}
102
103	if (renderer != null) {
104	renderer.run(uiRoot, appContext);
105	}
106	}	113	}
107		114
108	private void init(MApplication appElement) {	115	private void init(MApplication appElement) {

Added Link Here

(-)src/org/eclipse/e4/ui/workbench/renderers/swt/MenuManagerRendererFilter.java (+386 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.e4.ui.workbench.renderers.swt;
12
13	import java.lang.reflect.InvocationTargetException;
14	import java.lang.reflect.Method;
15	import java.util.HashMap;
16	import java.util.HashSet;
17	import javax.inject.Inject;
18	import org.eclipse.core.commands.ParameterizedCommand;
19	import org.eclipse.core.runtime.ISafeRunnable;
20	import org.eclipse.core.runtime.SafeRunner;
21	import org.eclipse.e4.core.commands.EHandlerService;
22	import org.eclipse.e4.core.contexts.ContextInjectionFactory;
23	import org.eclipse.e4.core.contexts.EclipseContextFactory;
24	import org.eclipse.e4.core.contexts.IEclipseContext;
25	import org.eclipse.e4.core.di.annotations.CanExecute;
26	import org.eclipse.e4.core.services.log.Logger;
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.ui.MContext;
31	import org.eclipse.e4.ui.model.application.ui.MElementContainer;
32	import org.eclipse.e4.ui.model.application.ui.MUIElement;
33	import org.eclipse.e4.ui.model.application.ui.menu.MDirectMenuItem;
34	import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;
35	import org.eclipse.e4.ui.model.application.ui.menu.MItem;
36	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
37	import org.eclipse.e4.ui.model.application.ui.menu.MMenuElement;
38	import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;
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 Logger logger;
100
101	@Inject
102	private EModelService modelService;
103
104	@Inject
105	private IRendererFactory rendererFactory;
106
107	@Inject
108	private MenuManagerRenderer renderer;
109
110	@Inject
111	private EHandlerService handlerService;
112
113	private HashMap<Menu, Runnable> pendingCleanup = new HashMap<Menu, Runnable>();
114
115	private class SafeWrapper implements ISafeRunnable {
116	Event event;
117
118	public void handleException(Throwable e) {
119	if (e instanceof Error) {
120	// errors are deadly, we shouldn't ignore these
121	throw (Error) e;
122	}
123	// log exceptions otherwise
124	if (logger != null) {
125	logger.error(e);
126	}
127	}
128
129	public void run() throws Exception {
130	safeHandleEvent(event);
131	}
132	}
133
134	private SafeWrapper safeWrapper = new SafeWrapper();
135
136	public void handleEvent(final Event event) {
137	// wrap the handling in a SafeRunner so that exceptions do not prevent
138	// the menu from being shown
139	safeWrapper.event = event;
140	SafeRunner.run(safeWrapper);
141	}
142
143	private void safeHandleEvent(Event event) {
144	if (!(event.widget instanceof Menu)) {
145	return;
146	}
147	final Menu menu = (Menu) event.widget;
148	if ((menu.getStyle() & SWT.BAR) != 0) {
149	// don't process the menu bar, it's not fair :-)
150	return;
151	}
152	if (event.type == SWT.Dispose) {
153	trace("handleMenu.Dispose", menu, null); //$NON-NLS-1$
154	cleanUp(menu, null, null);
155	return;
156	}
157
158	// fill in all of the pieces
159	MMenu menuModel = null;
160	MenuManager menuManager = null;
161	Object obj = menu.getData(AbstractPartRenderer.OWNING_ME);
162	if (obj == null && menu.getParentItem() != null) {
163	obj = menu.getParentItem().getData(AbstractPartRenderer.OWNING_ME);
164	if (obj == null) {
165	// hack because MenuManager doesn't do a setData()
166	Object tmp = menu.getParentItem().getData();
167	if (tmp instanceof MenuManager) {
168	MenuManager tmpManager = (MenuManager) tmp;
169	if (menu == tmpManager.getMenu()) {
170	// Eureka! We found a match, by golly!
171	menuManager = tmpManager;
172	obj = renderer.getMenuModel(tmpManager);
173	}
174	}
175	}
176	}
177	if (obj instanceof MMenu) {
178	menuModel = (MMenu) obj;
179	}
180	if (menuManager == null && menuModel != null) {
181	menuManager = renderer.getManager(menuModel);
182	}
183
184	switch (event.type) {
185	case SWT.Show:
186	handleShow(event, menu, menuModel, menuManager);
187	break;
188	case SWT.Hide:
189	handleHide(event, menu, menuModel, menuManager);
190	break;
191	}
192
193	}
194
195	private void handleShow(final Event event, final Menu menu,
196	MMenu menuModel, MenuManager menuManager) {
197	if (menuModel != null && menuManager != null) {
198	cleanUp(menu, menuModel, menuManager);
199	}
200	if (menuModel instanceof MPopupMenu) {
201	showPopup(event, menu, (MPopupMenu) menuModel, menuManager);
202	}
203	if (menuModel != null) {
204	showMenu(event, menu, menuModel, menuManager);
205	} else {
206	trace("Incorrect menu model to work with " + menuManager, menu, menuModel); //$NON-NLS-1$
207	}
208	}
209
210	private void handleHide(final Event event, final Menu menu,
211	MMenu menuModel, MenuManager menuManager) {
212	if (menuModel instanceof MPopupMenu) {
213	hidePopup(event, menu, (MPopupMenu) menuModel, menuManager);
214	}
215	}
216
217	public void showMenu(final Event event, final Menu menu,
218	final MMenu menuModel, MenuManager menuManager) {
219	AbstractPartRenderer obj = rendererFactory.getRenderer(menuModel,
220	menu.getParent());
221	if (!(obj instanceof MenuManagerRenderer)) {
222	trace("Not the correct renderer: " + obj, menu, menuModel); //$NON-NLS-1$
223	return;
224	}
225	MenuManagerRenderer renderer = (MenuManagerRenderer) obj;
226	if (menuModel.getWidget() == null) {
227	renderer.bindWidget(menuModel, menuManager.getMenu());
228	}
229
230	Method handleAboutToShow = getAboutToShow();
231	try {
232	handleAboutToShow.invoke(menuManager);
233	} catch (IllegalArgumentException e) {
234	// TODO Auto-generated catch block
235	e.printStackTrace();
236	} catch (IllegalAccessException e) {
237	// TODO Auto-generated catch block
238	e.printStackTrace();
239	} catch (InvocationTargetException e) {
240	// TODO Auto-generated catch block
241	e.printStackTrace();
242	}
243
244	if (!menuManager.getRemoveAllWhenShown()) {
245	renderer.reconcileManagerToModel(menuManager, menuModel);
246	// this will make sure all model elements are represented in the
247	// menu itself.
248	// double cast because we're bad people
249	renderer.processContents((MElementContainer<MUIElement>) ((Object) menuModel));
250	}
251
252	final IEclipseContext evalContext;
253	if (menuModel instanceof MContext) {
254	evalContext = ((MContext) menuModel).getContext();
255	} else {
256	evalContext = modelService.getContainingContext(menuModel);
257	}
258	updateElementVisibility(menuModel, renderer, menuManager, evalContext,
259	true);
260
261	// last thing to do, kill the event and update the menu manager
262	event.type = SWT.None;
263	event.doit = false;
264	menuManager.update(false);
265	}
266
267	/**
268	* @param menuModel
269	* @param renderer
270	* @param menuManager
271	* @param evalContext
272	*/
273	private void updateElementVisibility(final MMenu menuModel,
274	MenuManagerRenderer renderer, MenuManager menuManager,
275	final IEclipseContext evalContext, boolean recurse) {
276	final ExpressionContext exprContext = new ExpressionContext(evalContext);
277	HashSet<ContributionRecord> records = new HashSet<ContributionRecord>();
278	for (MMenuElement element : menuModel.getChildren()) {
279	ContributionRecord record = renderer.getContributionRecord(element);
280	if (record != null) {
281	if (records.add(record)) {
282	record.updateVisibility(evalContext);
283	}
284	} else {
285	MenuManagerRenderer.updateVisibility(menuManager, element,
286	exprContext);
287	}
288	if (recurse && element.isVisible() && element instanceof MMenu) {
289	MMenu childMenu = (MMenu) element;
290	MenuManager childManager = renderer.getManager(childMenu);
291	if (childManager != null) {
292	updateElementVisibility(childMenu, renderer, childManager,
293	evalContext, false);
294	}
295	}
296
297	if (element instanceof MHandledMenuItem) {
298	ParameterizedCommand cmd = ((MHandledMenuItem) element)
299	.getWbCommand();
300	if (cmd != null) {
301	((MHandledMenuItem) element).setEnabled(handlerService
302	.canExecute(cmd));
303	}
304	} else if (element instanceof MDirectMenuItem) {
305	MDirectMenuItem contrib = (MDirectMenuItem) element;
306	if (contrib.getObject() != null) {
307	IEclipseContext staticContext = EclipseContextFactory
308	.create();
309	staticContext.set(MItem.class, contrib);
310	Object rc = ContextInjectionFactory.invoke(
311	contrib.getObject(), CanExecute.class, evalContext,
312	staticContext, Boolean.TRUE);
313	if (rc instanceof Boolean) {
314	contrib.setEnabled((Boolean) rc);
315	}
316	}
317	}
318	}
319	}
320
321	public void hidePopup(Event event, Menu menu, MPopupMenu menuModel,
322	MenuManager menuManager) {
323	final IEclipseContext popupContext = menuModel.getContext();
324	final IEclipseContext originalChild = (IEclipseContext) popupContext
325	.get(TMP_ORIGINAL_CONTEXT);
326	popupContext.remove(TMP_ORIGINAL_CONTEXT);
327	if (!menu.isDisposed()) {
328	menu.getDisplay().asyncExec(new Runnable() {
329	public void run() {
330	if (originalChild == null) {
331	popupContext.deactivate();
332	} else {
333	originalChild.activate();
334	}
335	}
336	});
337	}
338	}
339
340	public void showPopup(final Event event, final Menu menu,
341	final MPopupMenu menuModel, MenuManager menuManager) {
342	// System.err.println("showPopup: " + menuModel + "\n\t" + menu);
343	// we need some context foolery here
344	final IEclipseContext popupContext = menuModel.getContext();
345	final IEclipseContext parentContext = popupContext.getParent();
346	final IEclipseContext originalChild = parentContext.getActiveChild();
347	popupContext.activate();
348	popupContext.set(TMP_ORIGINAL_CONTEXT, originalChild);
349	}
350
351	void setEnabled(MHandledMenuItem item) {
352	if (!item.isToBeRendered() \|\| !item.isVisible()
353	\|\| item.getWidget() == null) {
354	return;
355	}
356	ParameterizedCommand cmd = item.getWbCommand();
357	if (cmd == null) {
358	return;
359	}
360	final IEclipseContext lclContext = modelService
361	.getContainingContext(item);
362	EHandlerService service = lclContext.get(EHandlerService.class);
363	item.setEnabled(service.canExecute(cmd));
364	}
365
366	public void cleanUp(final Menu menu, MMenu menuModel,
367	MenuManager menuManager) {
368	trace("cleanUp", menu, null); //$NON-NLS-1$
369	if (pendingCleanup.isEmpty()) {
370	return;
371	}
372	Runnable cleanUp = pendingCleanup.remove(menu);
373	if (cleanUp != null) {
374	trace("cleanUp.run()", menu, null); //$NON-NLS-1$
375	cleanUp.run();
376	}
377	}
378
379	public void dispose() {
380	Menu[] keys = pendingCleanup.keySet().toArray(
381	new Menu[pendingCleanup.size()]);
382	for (Menu menu : keys) {
383	cleanUp(menu, null, null);
384	}
385	}
386	}

Lines 12-22 Link Here

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

Lines 24-43 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/PopupMenuExtender.java (-101 / +35 lines)
24	import org.eclipse.core.runtime.IRegistryChangeEvent;	24	import org.eclipse.core.runtime.IRegistryChangeEvent;
25	import org.eclipse.core.runtime.IRegistryChangeListener;	25	import org.eclipse.core.runtime.IRegistryChangeListener;
26	import org.eclipse.core.runtime.Platform;	26	import org.eclipse.core.runtime.Platform;
27	import org.eclipse.e4.core.contexts.IEclipseContext;
28	import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;	27	import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;
29	import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;	28	import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
30	import org.eclipse.e4.ui.model.application.MApplication;	29	import org.eclipse.e4.ui.model.application.ui.MElementContainer;
		30	import org.eclipse.e4.ui.model.application.ui.MUIElement;
31	import org.eclipse.e4.ui.model.application.ui.basic.MPart;	31	import org.eclipse.e4.ui.model.application.ui.basic.MPart;
32	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;	32	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
33	import org.eclipse.e4.ui.model.application.ui.menu.MMenuContribution;
34	import org.eclipse.e4.ui.model.application.ui.menu.MMenuElement;
35	import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;	33	import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;
36	import org.eclipse.e4.ui.model.application.ui.menu.MRenderedMenu;
37	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;	34	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
38	import org.eclipse.e4.ui.workbench.modeling.ExpressionContext;	35	import org.eclipse.e4.ui.workbench.renderers.swt.MenuManagerRenderer;
		36	import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
		37	import org.eclipse.e4.ui.workbench.swt.modeling.MenuService;
39	import org.eclipse.jface.action.ContributionManager;	38	import org.eclipse.jface.action.ContributionManager;
40	import org.eclipse.jface.action.GroupMarker;
41	import org.eclipse.jface.action.IContributionItem;	39	import org.eclipse.jface.action.IContributionItem;
42	import org.eclipse.jface.action.IMenuListener2;	40	import org.eclipse.jface.action.IMenuListener2;
43	import org.eclipse.jface.action.IMenuManager;	41	import org.eclipse.jface.action.IMenuManager;
Lines 51-57 Link Here
51	import org.eclipse.swt.widgets.Display;	49	import org.eclipse.swt.widgets.Display;
52	import org.eclipse.ui.IEditorPart;	50	import org.eclipse.ui.IEditorPart;
53	import org.eclipse.ui.IWorkbench;	51	import org.eclipse.ui.IWorkbench;
54	import org.eclipse.ui.IWorkbenchActionConstants;
55	import org.eclipse.ui.IWorkbenchPart;	52	import org.eclipse.ui.IWorkbenchPart;
56	import org.eclipse.ui.IWorkbenchPartSite;	53	import org.eclipse.ui.IWorkbenchPartSite;
57	import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;	54	import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;
Lines 93-100 Link Here
93		90
94	private ArrayList actionContributionCache = new ArrayList();	91	private ArrayList actionContributionCache = new ArrayList();
95	private ArrayList managerContributionCache = new ArrayList();	92	private ArrayList managerContributionCache = new ArrayList();
96	private ArrayList<MRenderedMenu> renderedMenuCache = new ArrayList<MRenderedMenu>();
97	private ArrayList<MRenderedMenu> lastRenderedMenuCache = new ArrayList<MRenderedMenu>();
98	private boolean cleanupNeeded = false;	93	private boolean cleanupNeeded = false;
99		94
100	private MPart modelPart;	95	private MPart modelPart;
Lines 148-154 Link Here
148	menuWrapper.setVisible(true);	143	menuWrapper.setVisible(true);
149	}	144	}
150	createModelFor(id);	145	createModelFor(id);
151	readStaticActionsFor(id);	146	addMenuId(id);
152		147
153	Platform.getExtensionRegistry().addRegistryChangeListener(this);	148	Platform.getExtensionRegistry().addRegistryChangeListener(this);
154	}	149	}
Lines 159-193 Link Here
159	}	154	}
160	menuModel = null;	155	menuModel = null;
161	for (MMenu item : modelPart.getMenus()) {	156	for (MMenu item : modelPart.getMenus()) {
162	if (id.equals(item.getElementId()) && item instanceof MRenderedMenu	157	if (id.equals(item.getElementId()) && item instanceof MPopupMenu
163	&& item.getTags().contains("popup")) { //$NON-NLS-1$	158	&& item.getTags().contains("popup")) { //$NON-NLS-1$
164	menuModel = (MRenderedMenu) item;	159	menuModel = (MPopupMenu) item;
165	break;	160	break;
166	}	161	}
167	}	162	}
168	if (menuModel == null) {	163	if (menuModel == null) {
169	menuModel = MenuFactoryImpl.eINSTANCE.createRenderedMenu();	164	menuModel = MenuFactoryImpl.eINSTANCE.createPopupMenu();
170	menuModel.setElementId(id);	165	menuModel.setElementId(id);
171	menuModel.getTags().add(ContributionsAnalyzer.MC_POPUP);	166	menuModel.getTags().add(ContributionsAnalyzer.MC_POPUP);
172	modelPart.getMenus().add(menuModel);	167	modelPart.getMenus().add(menuModel);
173	MPopupMenu popup = MenuFactoryImpl.eINSTANCE.createPopupMenu();
174	popup.setElementId(id);
175	popup.getTags().add(ContributionsAnalyzer.MC_POPUP);
176	menuModel.getChildren().add(popup);
177	}	168	}
178	menuModel.setContributionManager(menu);	169	IRendererFactory factory = modelPart.getContext().get(IRendererFactory.class);
		170	AbstractPartRenderer obj = factory.getRenderer(menuModel, null);
		171	if (obj instanceof MenuManagerRenderer) {
		172	((MenuManagerRenderer) obj).linkModelToManager(menuModel, menu);
		173	}
179	registerE4Support();	174	registerE4Support();
180	}	175	}
181		176
182	private void registerE4Support() {	177	private void registerE4Support() {
183	if (menuModel.getWidget() == null && menu.getMenu() != null) {	178	if (menuModel.getWidget() == null && menu.getMenu() != null) {
184	menuModel.setWidget(menu.getMenu());	179	MenuService.registerMenu(menu.getMenu().getParent(), menuModel, modelPart);
185	menu.getMenu().setData(AbstractPartRenderer.OWNING_ME, menuModel);
186	MPopupMenu popup = (MPopupMenu) menuModel.getChildren().get(0);
187	IEclipseContext popupContext = modelPart.getContext().createChild(
188	"popup:" + popup.getElementId()); //$NON-NLS-1$
189	popup.setContext(popupContext);
190
191	}	180	}
192	}	181	}
193	// getMenuId() added by Dan Rubel (dan_rubel@instantiations.com)	182	// getMenuId() added by Dan Rubel (dan_rubel@instantiations.com)
Lines 227-233 Link Here
227	public final void addMenuId(final String menuId) {	216	public final void addMenuId(final String menuId) {
228	bitSet &= ~STATIC_ACTION_READ;	217	bitSet &= ~STATIC_ACTION_READ;
229	if (menuModel != null) {	218	if (menuModel != null) {
230	List<String> tags = menuModel.getChildren().get(0).getTags();	219	List<String> tags = menuModel.getTags();
231	String tag = "popup:" + menuId; //$NON-NLS-1$	220	String tag = "popup:" + menuId; //$NON-NLS-1$
232	if (!tags.contains(tag)) {	221	if (!tags.contains(tag)) {
233	tags.add(tag);	222	tags.add(tag);
Lines 388-490 Link Here
388	}	377	}
389	}	378	}
390		379
		380	addMenuContributions(mgr);
		381
391	readStaticActions();	382	readStaticActions();
392	// test for additions removed to comply with menu contributions	383	// test for additions removed to comply with menu contributions
393	if (menuWrapper != null) {	384	if (menuWrapper != null) {
394	mgr = menuWrapper;	385	mgr = menuWrapper;
395	menuWrapper.removeAll();	386	menuWrapper.removeAll();
396	}	387	}
397	addMenuContributions(mgr);
398	if ((bitSet & INCLUDE_EDITOR_INPUT) != 0) {	388	if ((bitSet & INCLUDE_EDITOR_INPUT) != 0) {
399	addEditorActions(mgr);	389	addEditorActions(mgr);
400	}	390	}
401	addObjectActions(mgr);	391	addObjectActions(mgr);
402	addStaticActions(mgr);	392	addStaticActions(mgr);
403	cleanUpContributionCache();
404	}	393	}
405		394
406		395
407	/**	396	/**
		397	* well, this goes to the renderer.
		398	*
408	* @param mgr	399	* @param mgr
409	*/	400	*/
410	private void addMenuContributions(IMenuManager mgr) {	401	private void addMenuContributions(IMenuManager mgr) {
411	MPopupMenu popup = (MPopupMenu) menuModel.getChildren().get(0);	402	IRendererFactory factory = modelPart.getContext().get(IRendererFactory.class);
412	final IEclipseContext popupContext = popup.getContext();	403	AbstractPartRenderer obj = factory.getRenderer(menuModel, null);
413	final IEclipseContext parentContext = popupContext.getParent();	404	if (obj instanceof MenuManagerRenderer) {
414	// final IEclipseContext originalChild = (IEclipseContext) parentContext	405	MenuManagerRenderer renderer = (MenuManagerRenderer) obj;
415	// .getLocal(IContextConstants.ACTIVE_CHILD);	406	renderer.reconcileManagerToModel(menu, menuModel);
416	// parentContext.set(IContextConstants.ACTIVE_CHILD, popupContext);	407	renderer.processContributions(menuModel, false);
417	// popupContext.set(TMP_ORIGINAL_CONTEXT, originalChild);	408	// double cast because we're bad people
418	MApplication application = parentContext.get(MApplication.class);	409	renderer.processContents((MElementContainer<MUIElement>) ((Object) menuModel));
419
420	final ArrayList<MMenuContribution> toContribute = new ArrayList<MMenuContribution>();
421	// final ArrayList<MMenuElement> menuContributionsToRemove = new
422	// ArrayList<MMenuElement>();
423	ExpressionContext eContext = new ExpressionContext(popupContext);
424	ContributionsAnalyzer.gatherMenuContributions(popup, application.getMenuContributions(),
425	popup.getElementId(), toContribute, eContext, true);
426
427	for (String tag : popup.getTags()) {
428	if (tag.startsWith("popup:") && tag.length() > 6) { //$NON-NLS-1$
429	ContributionsAnalyzer.gatherMenuContributions(popup,
430	application.getMenuContributions(), tag.substring(6), toContribute,
431	eContext, false);
432	}
433	}
434	for (MMenuContribution contribution : toContribute) {
435	String positionInParent = contribution.getPositionInParent();
436	String id = null;
437	String modifier = null;
438	if (positionInParent != null && positionInParent.length() > 0) {
439	String[] array = positionInParent.split("="); //$NON-NLS-1$
440	modifier = array[0];
441	id = array[1];
442	}
443	if (id == null) {
444	continue;
445	}
446	IContributionItem item = mgr.find(id);
447	if (item == null) {
448	if (IWorkbenchActionConstants.MB_ADDITIONS.equals(id)) {
449	mgr.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
450	} else {
451	continue;
452	}
453	}
454	for (MMenuElement element : contribution.getChildren()) {
455	if (element instanceof MMenu) {
456	MMenu menu = (MMenu) element;
457	if (mgr.find(menu.getElementId()) != null) {
458	continue;
459	}
460	MenuManager submenu = new MenuManager(menu.getLabel(), menu.getElementId());
461	if (modifier.equals("before")) { //$NON-NLS-1$
462	mgr.insertBefore(id, submenu);
463	} else {
464	mgr.insertAfter(id, submenu);
465	}
466	MRenderedMenu renderedMenu = MenuFactoryImpl.eINSTANCE.createRenderedMenu();
467	renderedMenu.setElementId(menu.getElementId());
468	renderedMenu.getTags().add(ContributionsAnalyzer.MC_POPUP);
469	renderedMenu.setContributionManager(submenu);
470	popup.getChildren().add(renderedMenu);
471	renderedMenuCache.add(renderedMenu);
472	}
473	}
474	}	410	}
475	}	411	}
476		412
477	private MRenderedMenu menuModel;	413	private MPopupMenu menuModel;
478		414
479	/**	415	/**
480	* Notifies the listener that the menu is about to be hidden.	416	* Notifies the listener that the menu is about to be hidden.
481	*/	417	*/
482	public final void menuAboutToHide(final IMenuManager mgr) {	418	public final void menuAboutToHide(final IMenuManager mgr) {
483	gatherContributions(mgr);	419	gatherContributions(mgr);
484	if (!renderedMenuCache.isEmpty()) {
485	lastRenderedMenuCache = renderedMenuCache;
486	renderedMenuCache = new ArrayList<MRenderedMenu>();
487	}
488	cleanupNeeded = true;	420	cleanupNeeded = true;
489	// Remove this menu as a visible menu.	421	// Remove this menu as a visible menu.
490	final IWorkbenchPartSite site = part.getSite();	422	final IWorkbenchPartSite site = part.getSite();
Lines 539-549 Link Here
539	}	471	}
540	}	472	}
541		473
542	for (MRenderedMenu rmenu : lastRenderedMenuCache) {	474	IRendererFactory factory = modelPart.getContext().get(IRendererFactory.class);
543	MPopupMenu popup = (MPopupMenu) menuModel.getChildren().get(0);	475	AbstractPartRenderer obj = factory.getRenderer(menuModel, null);
544	popup.getChildren().remove(rmenu);	476	if (obj instanceof MenuManagerRenderer) {
		477	MenuManagerRenderer renderer = (MenuManagerRenderer) obj;
		478	renderer.cleanUp(menuModel);
545	}	479	}
546	lastRenderedMenuCache.clear();	480
547	managerContributionCache.clear();	481	managerContributionCache.clear();
548		482
549	}	483	}

Lines 12-25 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/e4/compatibility/CompatibilityView.java (-6 / +15 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;
22	import org.eclipse.e4.ui.workbench.renderers.swt.StackRenderer;	24	import org.eclipse.e4.ui.workbench.renderers.swt.StackRenderer;
		25	import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
23	import org.eclipse.jface.action.MenuManager;	26	import org.eclipse.jface.action.MenuManager;
24	import org.eclipse.jface.action.ToolBarManager;	27	import org.eclipse.jface.action.ToolBarManager;
25	import org.eclipse.swt.widgets.Composite;	28	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	78	// dispose the tb, it will be re-created when the tab is shown
76	tb.dispose();	79	tb.dispose();
77		80
		81	IEclipseContext context = getModel().getContext();
		82	IRendererFactory rendererFactory = context.get(IRendererFactory.class);
		83
78	MenuManager mm = (MenuManager) actionBars.getMenuManager();	84	MenuManager mm = (MenuManager) actionBars.getMenuManager();
79	MRenderedMenu menu = null;	85	MMenu menu = null;
80	for (MMenu me : part.getMenus()) {	86	for (MMenu me : part.getMenus()) {
81	if (me.getTags().contains(StackRenderer.TAG_VIEW_MENU) && (me instanceof MRenderedMenu)) {	87	if (me.getTags().contains(StackRenderer.TAG_VIEW_MENU)) {
82	menu = (MRenderedMenu) me;	88	menu = me;
83	break;	89	break;
84	}	90	}
85	}	91	}
86	if (menu == null) {	92	if (menu == null) {
87	menu = MenuFactoryImpl.eINSTANCE.createRenderedMenu();	93	menu = MenuFactoryImpl.eINSTANCE.createMenu();
88	menu.setElementId(part.getElementId());	94	menu.setElementId(part.getElementId());
89		95
90	menu.getTags().add(StackRenderer.TAG_VIEW_MENU);	96	menu.getTags().add(StackRenderer.TAG_VIEW_MENU);
Lines 92-98 Link Here
92	part.getMenus().add(menu);	98	part.getMenus().add(menu);
93		99
94	}	100	}
95	menu.setContributionManager(mm);	101	AbstractPartRenderer apr = rendererFactory.getRenderer(menu, parent);
		102	if (apr instanceof MenuManagerRenderer) {
		103	((MenuManagerRenderer) apr).linkModelToManager(menu, mm);
		104	}
96		105
97	// Construct the toolbar (if necessary)	106	// Construct the toolbar (if necessary)
98	MToolBar toolbar = part.getToolbar();	107	MToolBar toolbar = part.getToolbar();

Lines 26-36 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/menus/MenuHelper.java (-53 / +49 lines)
26	import org.eclipse.core.runtime.IConfigurationElement;	26	import org.eclipse.core.runtime.IConfigurationElement;
27	import org.eclipse.core.runtime.InvalidRegistryObjectException;	27	import org.eclipse.core.runtime.InvalidRegistryObjectException;
28	import org.eclipse.e4.core.commands.ECommandService;	28	import org.eclipse.e4.core.commands.ECommandService;
		29	import org.eclipse.e4.core.contexts.ContextFunction;
		30	import org.eclipse.e4.core.contexts.IContextFunction;
29	import org.eclipse.e4.core.contexts.IEclipseContext;	31	import org.eclipse.e4.core.contexts.IEclipseContext;
30	import org.eclipse.e4.core.di.annotations.CanExecute;	32	import org.eclipse.e4.core.di.annotations.CanExecute;
31	import org.eclipse.e4.core.di.annotations.Execute;	33	import org.eclipse.e4.core.di.annotations.Execute;
32	import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;	34	import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;
33	import org.eclipse.e4.ui.internal.workbench.ExtensionPointProxy;
34	import org.eclipse.e4.ui.internal.workbench.swt.Policy;	35	import org.eclipse.e4.ui.internal.workbench.swt.Policy;
35	import org.eclipse.e4.ui.internal.workbench.swt.WorkbenchSWTActivator;	36	import org.eclipse.e4.ui.internal.workbench.swt.WorkbenchSWTActivator;
36	import org.eclipse.e4.ui.model.application.MApplication;	37	import org.eclipse.e4.ui.model.application.MApplication;
Lines 60-74 Link Here
60	import org.eclipse.ui.IActionDelegate;	61	import org.eclipse.ui.IActionDelegate;
61	import org.eclipse.ui.ISelectionService;	62	import org.eclipse.ui.ISelectionService;
62	import org.eclipse.ui.IWorkbenchCommandConstants;	63	import org.eclipse.ui.IWorkbenchCommandConstants;
		64	import org.eclipse.ui.IWorkbenchWindow;
63	import org.eclipse.ui.IWorkbenchWindowPulldownDelegate;	65	import org.eclipse.ui.IWorkbenchWindowPulldownDelegate;
64	import org.eclipse.ui.IWorkbenchWindowPulldownDelegate2;	66	import org.eclipse.ui.IWorkbenchWindowPulldownDelegate2;
65	import org.eclipse.ui.PlatformUI;	67	import org.eclipse.ui.PlatformUI;
66	import org.eclipse.ui.commands.ICommandImageService;	68	import org.eclipse.ui.commands.ICommandImageService;
67	import org.eclipse.ui.commands.ICommandService;	69	import org.eclipse.ui.commands.ICommandService;
		70	import org.eclipse.ui.internal.ActionDescriptor;
68	import org.eclipse.ui.internal.OpenPreferencesAction;	71	import org.eclipse.ui.internal.OpenPreferencesAction;
		72	import org.eclipse.ui.internal.PluginAction;
69	import org.eclipse.ui.internal.WorkbenchWindow;	73	import org.eclipse.ui.internal.WorkbenchWindow;
70	import org.eclipse.ui.internal.handlers.ActionDelegateHandlerProxy;	74	import org.eclipse.ui.internal.handlers.ActionDelegateHandlerProxy;
71	import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;	75	import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;
		76	import org.eclipse.ui.internal.services.ServiceLocator;
72	import org.eclipse.ui.internal.util.Util;	77	import org.eclipse.ui.internal.util.Util;
73	import org.eclipse.ui.menus.CommandContributionItem;	78	import org.eclipse.ui.menus.CommandContributionItem;
74	import org.eclipse.ui.menus.CommandContributionItemParameter;	79	import org.eclipse.ui.menus.CommandContributionItemParameter;
Lines 348-360 Link Here
348	.getIconUrl(menuAddition, IWorkbenchRegistryConstants.ATT_ICON));	353	.getIconUrl(menuAddition, IWorkbenchRegistryConstants.ATT_ICON));
349	element.setLabel(Util.safeString(text));	354	element.setLabel(Util.safeString(text));
350		355
351	for (IConfigurationElement child : menuAddition.getChildren()) {	356	for (final IConfigurationElement child : menuAddition.getChildren()) {
352	if (child.getName().equals(IWorkbenchRegistryConstants.TAG_DYNAMIC)) {	357	if (child.getName().equals(IWorkbenchRegistryConstants.TAG_DYNAMIC)) {
353	ExtensionPointProxy proxy = new ExtensionPointProxy(child,	358	ContextFunction generator = new ContextFunction() {
354	IWorkbenchRegistryConstants.TAG_CLASS, new ExtensionContribution());	359	@Override
		360	public Object compute(IEclipseContext context) {
		361	ServiceLocator sl = new ServiceLocator();
		362	sl.setContext(context);
		363	DynamicMenuContributionItem item = new DynamicMenuContributionItem(
		364	getId(child), sl, child);
		365	return item;
		366	}
		367	};
		368
355	MRenderedMenuItem menuItem = MenuFactoryImpl.eINSTANCE.createRenderedMenuItem();	369	MRenderedMenuItem menuItem = MenuFactoryImpl.eINSTANCE.createRenderedMenuItem();
356	menuItem.setElementId(getId(child));	370	menuItem.setElementId(getId(child));
357	menuItem.setContributionItem(proxy);	371	menuItem.setContributionItem(generator);
		372	// IRendererFactory factory =
		373	// application.getContext().get(IRendererFactory.class);
		374	// AbstractPartRenderer renderer = factory.getRenderer(element,
		375	// null);
		376	// if (renderer instanceof MenuManagerRenderer) {
		377	// ((MenuManagerRenderer)
		378	// renderer).linkModelToContribution(menuItem, item);
		379	// }
358	element.getChildren().add(menuItem);	380	element.getChildren().add(menuItem);
359	}	381	}
360	}	382	}
Lines 395-452 Link Here
395	String pulldown = element.getAttribute("pulldown"); //$NON-NLS-1$	417	String pulldown = element.getAttribute("pulldown"); //$NON-NLS-1$
396	if (IWorkbenchRegistryConstants.STYLE_PULLDOWN.equals(style)	418	if (IWorkbenchRegistryConstants.STYLE_PULLDOWN.equals(style)
397	\|\| (pulldown != null && pulldown.equals("true"))) { //$NON-NLS-1$	419	\|\| (pulldown != null && pulldown.equals("true"))) { //$NON-NLS-1$
398	MRenderedMenu menu = MenuFactoryImpl.eINSTANCE.createRenderedMenu();	420	MRenderedMenuItem item = MenuFactoryImpl.eINSTANCE.createRenderedMenuItem();
399	menu.setElementId(id);	421	item.setLabel(text);
400	menu.setLabel(text);
401	if (iconUri != null) {	422	if (iconUri != null) {
402	menu.setIconURI(iconUri);	423	item.setIconURI(iconUri);
403	}	424	}
404	ECommandService cs = app.getContext().get(ECommandService.class);	425	IContextFunction generator = new ContextFunction() {
405	final ParameterizedCommand parmCmd = cs.createCommand(cmdId, null);	426	@Override
406	menu.setContributionManager(new IMenuCreator() {	427	public Object compute(IEclipseContext context) {
407	private ActionDelegateHandlerProxy handlerProxy;	428	IWorkbenchWindow window = context.get(IWorkbenchWindow.class);
408		429	if (window == null) {
409	private ActionDelegateHandlerProxy getProxy() {
410	if (handlerProxy == null) {
411	handlerProxy = new ActionDelegateHandlerProxy(element,
412	IWorkbenchRegistryConstants.ATT_CLASS, id, parmCmd, PlatformUI
413	.getWorkbench().getActiveWorkbenchWindow(), null, null,
414	null);
415	}
416	return handlerProxy;
417	}
418
419	private IWorkbenchWindowPulldownDelegate getDelegate() {
420	getProxy();
421	if (handlerProxy == null) {
422	return null;	430	return null;
423	}	431	}
424	if (handlerProxy.getDelegate() == null) {	432	ActionDescriptor desc = new ActionDescriptor(element,
425	handlerProxy.loadDelegate();	433	ActionDescriptor.T_WORKBENCH_PULLDOWN, window);
426	}	434	final PluginAction action = desc.getAction();
427	return (IWorkbenchWindowPulldownDelegate) handlerProxy.getDelegate();	435	return new ActionContributionItem(action) {
428	}	436	@Override
429		437	public void dispose() {
430	public Menu getMenu(Menu parent) {	438	super.dispose();
431	IWorkbenchWindowPulldownDelegate2 delegate = (IWorkbenchWindowPulldownDelegate2) getDelegate();	439	action.disposeDelegate();
432	if (delegate == null) {	440	}
433	return null;	441	};
434	}	442	}
435	return delegate.getMenu(parent);	443	};
436	}	444	item.setContributionItem(generator);
437		445	return item;
438	public Menu getMenu(Control parent) {
439	return getDelegate() == null ? null : getDelegate().getMenu(parent);
440	}
441
442	public void dispose() {
443	if (handlerProxy != null) {
444	handlerProxy.dispose();
445	handlerProxy = null;
446	}
447	}
448	});
449	return menu;
450	}	446	}
451		447
452	ItemType type = ItemType.PUSH;	448	ItemType type = ItemType.PUSH;