Attachment #182202 for bug #325392

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

Lines 310-315 Link Here

(-)model/UIElements.ecore (+5 lines)
310	<eStructuralFeatures xsi:type="ecore:EAttribute" name="contributionItem" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"	310	<eStructuralFeatures xsi:type="ecore:EAttribute" name="contributionItem" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
311	transient="true"/>	311	transient="true"/>
312	</eClassifiers>	312	</eClassifiers>
		313	<eClassifiers xsi:type="ecore:EClass" name="OpaqueMenuItem" eSuperTypes="#//ui/menu/MenuElement">
		314	<eStructuralFeatures xsi:type="ecore:EAttribute" name="opaqueItem" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"
		315	transient="true"/>
		316	</eClassifiers>
		317	<eClassifiers xsi:type="ecore:EClass" name="OpaqueMenu" eSuperTypes="#//ui/menu/Menu"/>
313	</eSubpackages>	318	</eSubpackages>
314	<eSubpackages name="basic" nsURI="http://www.eclipse.org/ui/2010/UIModel/application/ui/basic"	319	<eSubpackages name="basic" nsURI="http://www.eclipse.org/ui/2010/UIModel/application/ui/basic"
315	nsPrefix="basic">	320	nsPrefix="basic">

Lines 27-33 Link Here

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

Lines 34-44 Link Here

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

Lines 30-35 Link Here

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

Lines 176-182 Link Here

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




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

import org.eclipse.e4.ui.model.application.ui.menu.MMenuElement;
import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;
import org.eclipse.e4.ui.model.application.ui.menu.MOpaqueMenu;
import org.eclipse.e4.ui.model.application.ui.menu.MOpaqueMenuItem;
import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;
import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
import org.eclipse.e4.ui.workbench.IResourceUtilities;
import org.eclipse.e4.ui.workbench.UIEvents;
import org.eclipse.e4.ui.workbench.modeling.ExpressionContext;

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

	private Map<MMenu, MenuManager> modelToManager = new HashMap<MMenu, MenuManager>();
	private Map<MenuManager, MMenu> managerToModel = new HashMap<MenuManager, MMenu>();

	private Map<MMenuElement, IContributionItem> modelToContribution = new HashMap<MMenuElement, IContributionItem>();
	private Map<IContributionItem, MMenuElement> contributionToModel = new HashMap<IContributionItem, MMenuElement>();

	private Map<MMenuElement, ContributionRecord> modelContributionToRecord = new HashMap<MMenuElement, ContributionRecord>();


							modelProcessSwitch(parent, itemModel);
						}
					} else {
						IContributionItem ici = getContribution(itemModel);
						clearModelToContribution(itemModel, ici);
						if (ici != null && parent != null) {
							parent.remove(ici);
						}

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


			MMenuItem itemModel = (MMenuItem) event
					.getProperty(UIEvents.EventTags.ELEMENT);
			IContributionItem ici = getContribution(itemModel);
			if (ici != null) {
				ici.update();
			}


			MMenuItem itemModel = (MMenuItem) event
					.getProperty(UIEvents.EventTags.ELEMENT);
			IContributionItem ici = getContribution(itemModel);
			if (ici != null) {
				ici.update();
			}
		}
	};

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

	@PostConstruct
	public void init() {

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

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

	}

	@PreDestroy

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

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

	/*


		final MMenu menuModel = (MMenu) element;
		Menu newMenu = null;
		MenuManager menuManager = null;
		boolean menuBar = false;

		if (parent instanceof Decorations) {
			MUIElement container = (MUIElement) ((EObject) element)
					.eContainer();
			if (container instanceof MWindow) {
				menuManager = getManager(menuModel);
				if (menuManager == null) {
					menuManager = new MenuManager(NO_LABEL,
							menuModel.getElementId());
					linkModelToManager(menuModel, menuManager);
				}
				newMenu = menuManager.createMenuBar((Decorations) parent);
				((Decorations) parent).setMenuBar(newMenu);
				newMenu.setData(menuManager);
				menuBar = true;
			} else {
				menuManager = getManager(menuModel);
				if (menuManager == null) {
					menuManager = new MenuManager(NO_LABEL,
							menuModel.getElementId());
					linkModelToManager(menuModel, menuManager);
				}
				newMenu = menuManager.createContextMenu((Control) parent);
				// we can't be sure this is the correct parent.
				// ((Control) parent).setMenu(newMenu);
				newMenu.setData(menuManager);
			}
		} else if (parent instanceof Menu) {
			// Object data = ((Menu) parent).getData();
			logger.debug(new Exception(), "Trying to render a sub menu " //$NON-NLS-1$
					+ menuModel + "\n\t" + parent); //$NON-NLS-1$
			return null;

		} else if (parent instanceof Control) {
			menuManager = getManager(menuModel);
			if (menuManager == null) {
				menuManager = new MenuManager(NO_LABEL,
						menuModel.getElementId());
				linkModelToManager(menuModel, menuManager);
			}
			newMenu = menuManager.createContextMenu((Control) parent);
			// we can't be sure this is the correct parent.
			// ((Control) parent).setMenu(newMenu);
			newMenu.setData(menuManager);
		}
		if (!menuManager.getRemoveAllWhenShown()) {
			processContributions(menuModel, menuBar);
		}
		processContributions(menuModel, menuBar);
		if (newMenu != null) {
			newMenu.addDisposeListener(new DisposeListener() {
				public void widgetDisposed(DisposeEvent e) {

	/**
	 * @param menuModel
	 */
	public void cleanUp(MMenu menuModel) {
		Collection<ContributionRecord> vals = modelContributionToRecord
				.values();
		for (ContributionRecord record : vals

							copyManager.dispose();
						}
					} else {
						IContributionItem ici = getContribution(copy);
						clearModelToContribution(copy, ici);
						if (ici != null) {
							record.manager.remove(ici);
						}

	 * @param menuModel
	 * @param menuBar
	 */
	public void processContributions(MMenu menuModel, boolean menuBar) {
		final ArrayList<MMenuContribution> toContribute = new ArrayList<MMenuContribution>();
		ContributionsAnalyzer.XXXgatherMenuContributions(menuModel,
				application.getMenuContributions(), menuModel.getElementId(),

			boolean isVisible = ContributionsAnalyzer.isVisible(
					menuContribution, exprContext);
			for (MMenuElement item : generatedElements) {
				if (isVisible && item.getVisibleWhen() != null) {
					MenuManagerRenderer.updateVisibility(manager, item,
							exprContext);
				} else {
					item.setVisible(isVisible);
				}
			}
			manager.markDirty();
		}

	 * @param menuModel
	 */
	private void processMenu(MenuManager parentManager, MMenu menuModel) {
		MenuManager menuManager = getManager(menuModel);
		if (menuManager == null) {
			String menuText = getText(menuModel);
			ImageDescriptor desc = getImageDescriptor(menuModel);
			menuManager = new MenuManager(menuText, desc,
					menuModel.getElementId());
			linkModelToManager(menuModel, menuManager);
			menuManager.setVisible(menuModel.isVisible());
			parentManager.add(menuManager);
		}
		processContributions(menuModel, false);
		List<MMenuElement> parts = menuModel.getChildren();
		if (parts != null) {

		} else if (childME instanceof MMenuSeparator) {
			MMenuSeparator sep = (MMenuSeparator) childME;
			processSeparator(menuManager, sep);
		} else if (childME instanceof MOpaqueMenu) {
			// I'm not sure what to do here.
		} else if (childME instanceof MMenu) {
			MMenu itemModel = (MMenu) childME;
			processMenu(menuManager, itemModel);

	 */
	void processDirectItem(MenuManager parentManager,
			MDirectMenuItem itemModel, String id) {
		IContributionItem ici = getContribution(itemModel);
		if (ici != null) {
			return;
		}
		final IEclipseContext lclContext = getContext(itemModel);
		DirectContributionItem ci = ContextInjectionFactory.make(
				DirectContributionItem.class, lclContext);
		ci.setModel(itemModel);
		ci.setVisible(itemModel.isVisible());
		parentManager.add(ci);
		linkModelToContribution(itemModel, ci);
	}

	/**

	 */
	void processHandledItem(MenuManager parentManager,
			MHandledMenuItem itemModel) {
		IContributionItem ici = getContribution(itemModel);
		if (ici != null) {
			return;
		}
		final IEclipseContext lclContext = getContext(itemModel);
		HandledContributionItem ci = ContextInjectionFactory.make(
				HandledContributionItem.class, lclContext);
		ci.setModel(itemModel);
		ci.setVisible(itemModel.isVisible());
		parentManager.add(ci);
		linkModelToContribution(itemModel, ci);
	}

	private String getText(MMenu menuModel) {

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

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

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

	public MMenuElement getMenuElement(IContributionItem item) {
		return contributionToModel.get(item);
	}

	public void linkModelToContribution(MMenuElement model,
			IContributionItem item) {
		modelToContribution.put(model, item);
		contributionToModel.put(item, model);
	}

	public void clearModelToContribution(MMenuElement model,
			IContributionItem item) {
		modelToContribution.remove(model);
		contributionToModel.remove(item);
	}

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

	/**
	 * @param menuManager
	 * @param menuModel
	 */
	public void reconcileManagerToModel(MenuManager menuManager, MMenu menuModel) {
		List<MMenuElement> modelChildren = menuModel.getChildren();

		HashSet<MOpaqueMenuItem> oldModelItems = new HashSet<MOpaqueMenuItem>();
		HashSet<MOpaqueMenu> oldMenus = new HashSet<MOpaqueMenu>();
		for (MMenuElement itemModel : modelChildren) {
			if (itemModel instanceof MOpaqueMenuItem) {
				oldModelItems.add((MOpaqueMenuItem) itemModel);
			} else if (itemModel instanceof MOpaqueMenu) {
				oldMenus.add((MOpaqueMenu) itemModel);
			}
		}

		IContributionItem[] items = menuManager.getItems();
		for (int src = 0, dest = 0; src < items.length; src++, dest++) {
			IContributionItem item = items[src];
			if (item instanceof MenuManager) {
				MenuManager childManager = (MenuManager) item;
				MMenu childModel = getMenuModel(childManager);
				if (childModel == null) {
					MMenu legacyModel = MenuFactoryImpl.eINSTANCE
							.createOpaqueMenu();
					legacyModel.setElementId(childManager.getId());
					legacyModel.setVisible(childManager.isVisible());
					linkModelToManager(legacyModel, childManager);
					modelChildren.add(dest, legacyModel);
				} else {
					if (childModel instanceof MOpaqueMenu) {
						oldMenus.remove(childModel);
					}
					if (modelChildren.size() > dest) {
						if (modelChildren.get(dest) != childModel) {
							modelChildren.remove(childModel);
							modelChildren.add(dest, childModel);
						}
					} else {
						modelChildren.add(childModel);
					}
				}
			} else {
				MMenuElement menuElement = getMenuElement(item);
				if (menuElement == null) {
					MOpaqueMenuItem legacyItem = MenuFactoryImpl.eINSTANCE
							.createOpaqueMenuItem();
					legacyItem.setElementId(item.getId());
					legacyItem.setVisible(item.isVisible());
					legacyItem.setOpaqueItem(item);
					linkModelToContribution(legacyItem, item);
					modelChildren.add(dest, legacyItem);
				} else if (menuElement instanceof MOpaqueMenuItem) {
					MOpaqueMenuItem legacyItem = (MOpaqueMenuItem) menuElement;
					oldModelItems.remove(legacyItem);
					if (modelChildren.size() > dest) {
						if (modelChildren.get(dest) != legacyItem) {
							modelChildren.remove(legacyItem);
							modelChildren.add(dest, legacyItem);
						}
					} else {
						modelChildren.add(legacyItem);
					}
				}
			}
		}
		if (!oldModelItems.isEmpty()) {
			modelChildren.removeAll(oldModelItems);
			for (MOpaqueMenuItem model : oldModelItems) {
				clearModelToContribution(model,
						(IContributionItem) model.getOpaqueItem());
			}
		}
		if (!oldMenus.isEmpty()) {
			modelChildren.removeAll(oldMenus);
			for (MOpaqueMenu oldMenu : oldMenus) {
				MenuManager oldManager = getManager(oldMenu);
				clearModelToManager(oldMenu, oldManager);
			}
		}
	}

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




/*******************************************************************************
 * 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.model.application.ui.menu.MRenderedMenu;
import org.eclipse.e4.ui.workbench.modeling.EModelService;
import org.eclipse.e4.ui.workbench.modeling.ExpressionContext;
import org.eclipse.e4.ui.workbench.renderers.swt.MenuManagerRenderer.ContributionRecord;
import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Widget;

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

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

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

	private static Method aboutToShow;

	private static Method aboutToHide;

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

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

	@Inject
	private Logger logger;

	@Inject
	private EModelService modelService;

	@Inject
	private IRendererFactory rendererFactory;

	@Inject
	private MenuManagerRenderer renderer;

	@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 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, null);
		// }
		event.type = SWT.None;
		event.doit = false;
	}

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




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;

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

	}




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

Return to bug 325392

Lines 219-224 Link Here

(-)src/org/eclipse/e4/ui/workbench/UIEvents.java (+6 lines)
219		219
220	public static interface UIElement {	220	public static interface UIElement {
221	public static final String TOPIC = UITopicBase + "/ui/UIElement"; //$NON-NLS-1$	221	public static final String TOPIC = UITopicBase + "/ui/UIElement"; //$NON-NLS-1$
		222	public static final String ACCESSIBILITYPHRASE = "accessibilityPhrase"; //$NON-NLS-1$
222	public static final String CONTAINERDATA = "containerData"; //$NON-NLS-1$	223	public static final String CONTAINERDATA = "containerData"; //$NON-NLS-1$
223	public static final String CURSHAREDREF = "curSharedRef"; //$NON-NLS-1$	224	public static final String CURSHAREDREF = "curSharedRef"; //$NON-NLS-1$
224	public static final String ONTOP = "onTop"; //$NON-NLS-1$	225	public static final String ONTOP = "onTop"; //$NON-NLS-1$
Lines 272-277 Link Here
272	public static final String MNEMONICS = "mnemonics"; //$NON-NLS-1$	273	public static final String MNEMONICS = "mnemonics"; //$NON-NLS-1$
273	}	274	}
274		275
		276	public static interface OpaqueMenuItem {
		277	public static final String TOPIC = UITopicBase + "/menu/OpaqueMenuItem"; //$NON-NLS-1$
		278	public static final String OPAQUEITEM = "opaqueItem"; //$NON-NLS-1$
		279	}
		280
275	public static interface RenderedMenu {	281	public static interface RenderedMenu {
276	public static final String TOPIC = UITopicBase + "/menu/RenderedMenu"; //$NON-NLS-1$	282	public static final String TOPIC = UITopicBase + "/menu/RenderedMenu"; //$NON-NLS-1$
277	public static final String CONTRIBUTIONMANAGER = "contributionManager"; //$NON-NLS-1$	283	public static final String CONTRIBUTIONMANAGER = "contributionManager"; //$NON-NLS-1$

Added Link Here

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

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 (-100 / +34 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 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();