Attachment #180901 for bug #325392

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




import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
import org.eclipse.e4.ui.workbench.renderers.swt.MenuRenderer;
import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Widget;

public class MMenuItemTest extends TestCase {
	protected IEclipseContext appContext;

		wb = new E4Workbench(window, appContext);
		wb.createAndRunUI(window);

		((MenuManager) ((Widget) menu.getWidget()).getData()).updateAll(true);

		Object widget = menuItem.getWidget();
		assertNotNull(widget);
		assertTrue(widget instanceof MenuItem);

		wb = new E4Workbench(window, appContext);
		wb.createAndRunUI(window);

		((MenuManager) ((Widget) menu.getWidget()).getData()).updateAll(true);

		Object widget1 = menuItem1.getWidget();
		assertNotNull(widget1);
		assertTrue(widget1 instanceof MenuItem);

		wb = new E4Workbench(window, appContext);
		wb.createAndRunUI(window);

		((MenuManager) ((Widget) menu.getWidget()).getData()).updateAll(true);

		Object widget1 = menuItem.getWidget();
		assertNotNull(widget1);
		assertTrue(widget1 instanceof MenuItem);

		MCommand command = CommandsFactoryImpl.eINSTANCE.createCommand();

		command.setElementId("commandId");
		command.setCommandName("CommandForTest");

		menuItem.setCommand(command);
		menuItem.setType(ItemType.CHECK);

		MApplication application = ApplicationFactoryImpl.eINSTANCE
				.createApplication();
		application.getChildren().add(window);
		application.getCommands().add(command);
		application.setContext(appContext);
		appContext.set(MApplication.class.getName(), application);

		wb = new E4Workbench(window, appContext);
		wb.createAndRunUI(window);

		MenuManager barManager = (MenuManager) ((Menu) menu.getWidget())
				.getData();
		barManager.updateAll(true);

		Object widget1 = menuItem.getWidget();
		assertNotNull(widget1);
		assertTrue(widget1 instanceof MenuItem);

		assertTrue(menuItemWidget.getSelection());
	}

	public void XXXtestSubMenuCreation() throws Exception {
		MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
		MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
		menuBar.setElementId("org.eclipse.ui.main.menu");

		wb = new E4Workbench(window, appContext);
		wb.createAndRunUI(window);

		MenuRenderer renderer = getRenderer(appContext, menuBar);
		MenuManager manager = renderer.getManager(menuBar);
		assertNotNull("failed to create menu bar manager", manager);

		assertEquals(1, manager.getSize());

		MenuManager fileManager = (MenuManager) manager.getItems()[0];
		MenuManager fileR = renderer.getManager(fileMenu);
		assertEquals(fileManager, fileR);

		assertEquals(3, fileManager.getSize());
	}

	public void XXXtestTbrItem() throws Exception {
		MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
		MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
		menuBar.setElementId("org.eclipse.ui.main.menu");

		wb = new E4Workbench(window, appContext);
		wb.createAndRunUI(window);

		// MenuRenderer renderer = getRenderer(appContext, menuBar);
		MenuManager manager = renderer.getManager(menuBar);
		assertNotNull("failed to create menu bar manager", manager);

		assertEquals(1, manager.getSize());

		MenuManager fileManager = (MenuManager) manager.getItems()[0];
		MenuManager fileR = renderer.getManager(fileMenu);
		assertEquals(fileManager, fileR);

		assertEquals(2, fileManager.getSize());
	}

	public void XXXtestInvisibleItem() throws Exception {
		MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
		MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
		menuBar.setElementId("org.eclipse.ui.main.menu");

		wb = new E4Workbench(window, appContext);
		wb.createAndRunUI(window);

		// MenuRenderer renderer = getRenderer(appContext, menuBar);
		MenuManager manager = renderer.getManager(menuBar);
		assertNotNull("failed to create menu bar manager", manager);

		assertEquals(1, manager.getSize());

		MenuManager fileManager = (MenuManager) manager.getItems()[0];
		MenuManager fileR = renderer.getManager(fileMenu);
		assertEquals(fileManager, fileR);

		assertEquals(3, fileManager.getSize());

		assertEquals(false, fileManager.getItems()[2].isVisible());
	}

	public void XXXtestMenuContribution() throws Exception {
		MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
		MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
		menuBar.setElementId("org.eclipse.ui.main.menu");

		wb = new E4Workbench(window, appContext);
		wb.createAndRunUI(window);

		MenuRenderer renderer = getRenderer(appContext, menuBar);

		MenuManager fileManager = renderer.getManager(fileMenu);
		assertNotNull("No file menu?", fileManager);

		assertEquals(4, fileManager.getSize());

		assertEquals("mmc.item1", fileManager.getItems()[3].getId());
	}

	public void XXXtestWithVisible() throws Exception {
		MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
		MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
		menuBar.setElementId("org.eclipse.ui.main.menu");

		wb = new E4Workbench(window, appContext);
		wb.createAndRunUI(window);

		MenuRenderer renderer = getRenderer(appContext, menuBar);

		MenuManager fileManager = renderer.getManager(fileMenu);
		assertNotNull("No file menu?", fileManager);

		assertEquals(4, fileManager.getSize());

		IContributionItem mmcItem = fileManager.getItems()[3];
		assertEquals("mmc.item1", mmcItem.getId());
		assertEquals("before the first show, we have no context to evaluate",
				true, mmcItem.isVisible());

		MenuManager manager = renderer.getManager(menuBar);
		manager.updateAll(true);
		Menu fileWidget = fileManager.getMenu();
		assertNotNull(fileWidget);

		Event show = new Event();
		show.widget = fileWidget;
		show.type = SWT.Show;

		Event hide = new Event();
		hide.widget = fileWidget;
		hide.type = SWT.Hide;

		fileWidget.notifyListeners(SWT.Show, show);

		assertEquals("after the first show, it should not be visible", false,
				mmcItem.isVisible());

		fileWidget.notifyListeners(SWT.Hide, hide);

		appContext.set("mmc1", Boolean.TRUE);

		assertEquals("Change should not show up until next show", false,
				mmcItem.isVisible());

		fileWidget.notifyListeners(SWT.Show, show);

		assertEquals(true, mmcItem.isVisible());

		fileWidget.notifyListeners(SWT.Hide, hide);

		appContext.remove("mmc1");

		fileWidget.notifyListeners(SWT.Show, show);

		assertEquals(false, mmcItem.isVisible());

		fileWidget.notifyListeners(SWT.Hide, hide);
	}

	public void XXXtestMenuBarVisibility() throws Exception {
		MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
		MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
		menuBar.setElementId("org.eclipse.ui.main.menu");

		wb = new E4Workbench(window, appContext);
		wb.createAndRunUI(window);

		MenuRenderer renderer = getRenderer(appContext, menuBar);
		MenuManager manager = renderer.getManager(menuBar);
		manager.updateAll(true);

		assertEquals(2, manager.getSize());

		MenuManager vanishManager = (MenuManager) manager.getItems()[1];
		assertEquals("vanish", vanishManager.getId());

		assertFalse(vanishManager.isVisible());
		assertNull(vanishManager.getMenu());

		appContext.set("mmc1", Boolean.TRUE);

		assertTrue(vanishManager.isVisible());
		assertNotNull(vanishManager.getMenu());

		appContext.remove("mmc1");

		assertFalse(vanishManager.isVisible());
		Menu vanishMenu = vanishManager.getMenu();
		if (vanishMenu != null) {
			assertTrue(vanishMenu.isDisposed());
		}

		appContext.set("mmc1", Boolean.TRUE);

		assertTrue(vanishManager.isVisible());
		assertNotNull(vanishManager.getMenu());
		assertFalse(vanishManager.getMenu().isDisposed());
	}

	private MMenuContribution createContribution(boolean withVisibleWhen) {

		application.getMenuContributions().add(mmc);
	}

	MenuRenderer getRenderer(IEclipseContext context, MUIElement element) {
		IRendererFactory rendererFactory = context.get(IRendererFactory.class);
		AbstractPartRenderer renderer = rendererFactory.getRenderer(element,
				null);

Lines 30-36 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;
34	import org.eclipse.swt.SWT;	33	import org.eclipse.swt.SWT;
35	import org.eclipse.swt.graphics.Rectangle;	34	import org.eclipse.swt.graphics.Rectangle;
36	import org.eclipse.swt.widgets.Composite;	35	import org.eclipse.swt.widgets.Composite;
Lines 231-238 Link Here
231		230
232	wb = new E4Workbench(application, appContext);	231	wb = new E4Workbench(application, appContext);
233	wb.createAndRunUI(window);	232	wb.createAndRunUI(window);
234	((MenuManager) ((Widget) window.getMainMenu().getWidget()).getData())
235	.updateAll(true);
236		233
237	Widget topWidget = (Widget) window.getWidget();	234	Widget topWidget = (Widget) window.getWidget();
238	assertNotNull(topWidget);	235	assertNotNull(topWidget);




		return false;
	}

	public static void XXXgatherToolBarContributions(final MToolBar toolbarModel,
			final List<MToolBarContribution> toolbarContributionList, final String id,
			final ArrayList<MToolBarContribution> toContribute) {
		for (MToolBarContribution toolBarContribution : toolbarContributionList) {

		}
	}

	public static void gatherToolBarContributions(final MToolBar toolbarModel,
			final List<MToolBarContribution> toolbarContributionList, final String id,
			final ArrayList<MToolBarContribution> toContribute, final ExpressionContext eContext) {
		for (MToolBarContribution toolBarContribution : toolbarContributionList) {
			String parentID = toolBarContribution.getParentId();
			boolean filtered = isFiltered(toolbarModel, toolBarContribution);
			if (filtered || !parentID.equals(id) || !toolBarContribution.isToBeRendered()) {
				continue;
			}
			toContribute.add(toolBarContribution);
		}
	}

	static boolean isFiltered(MToolBar toolbarModel, MToolBarContribution toolBarContribution) {
		return false;
	}




/*******************************************************************************
 * Copyright (c) 2009, 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 javax.inject.Inject;
import org.eclipse.e4.core.contexts.ContextInjectionFactory;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.e4.core.services.contributions.IContributionFactory;
import org.eclipse.e4.core.services.log.Logger;
import org.eclipse.e4.ui.model.application.ui.MUIElement;
import org.eclipse.e4.ui.model.application.ui.menu.ItemType;
import org.eclipse.e4.ui.model.application.ui.menu.MDirectMenuItem;
import org.eclipse.e4.ui.model.application.ui.menu.MItem;
import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;

/**
 * Create a contribute part.
 */
public class DirectMenuItemRenderer extends MenuItemRenderer {

	@Inject
	Logger logger;

	public Object createWidget(final MUIElement element, Object parent) {
		if (!(element instanceof MDirectMenuItem) || !(parent instanceof Menu))
			return null;

		MDirectMenuItem itemModel = (MDirectMenuItem) element;
		if (itemModel.getVisibleWhen() != null) {
			processVisible(itemModel);
		}

		if (!itemModel.isVisible()) {
			return null;
		}

		// determine the index at which we should create the new item
		int addIndex = calcVisibleIndex(element);

		// OK, it's a real menu item, what kind?
		int flags = 0;
		if (itemModel.getType() == ItemType.PUSH)
			flags = SWT.PUSH;
		else if (itemModel.getType() == ItemType.CHECK)
			flags = SWT.CHECK;
		else if (itemModel.getType() == ItemType.RADIO)
			flags = SWT.RADIO;

		MenuItem newItem = new MenuItem((Menu) parent, flags, addIndex);
		setItemText(itemModel, newItem);
		newItem.setImage(getImage(itemModel));
		setEnabled(itemModel, newItem);
		newItem.setEnabled(itemModel.isEnabled());
		newItem.setSelection(itemModel.isSelected());

		return newItem;
	}

	private void setEnabled(MDirectMenuItem itemModel, final MenuItem newItem) {
		// TODO direct query to @CanExecute goes here
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#hookControllerLogic
	 * (org.eclipse.e4.ui.model.application.MUIElement)
	 */
	@Override
	public void hookControllerLogic(MUIElement me) {
		super.hookControllerLogic(me);

		// 'Execute' the operation if possible
		if (me instanceof MDirectMenuItem
				&& ((MDirectMenuItem) me).getContributionURI() != null) {
			final MMenuItem item = (MMenuItem) me;
			final MDirectMenuItem contrib = (MDirectMenuItem) me;
			final IEclipseContext lclContext = getContext(me);
			MenuItem mi = (MenuItem) me.getWidget();
			mi.addSelectionListener(new SelectionListener() {
				public void widgetSelected(SelectionEvent e) {
					if (contrib.getObject() == null) {
						IContributionFactory cf = (IContributionFactory) lclContext
								.get(IContributionFactory.class.getName());
						contrib.setObject(cf.create(
								contrib.getContributionURI(), lclContext));
					}
					lclContext.set(MItem.class.getName(), item);
					ContextInjectionFactory.invoke(contrib.getObject(),
							Execute.class, lclContext);
					lclContext.remove(MItem.class.getName());
				}

				public void widgetDefaultSelected(SelectionEvent e) {
				}
			});
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009, 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.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.inject.Inject;
import org.eclipse.core.commands.ParameterizedCommand;
import org.eclipse.core.commands.common.NotDefinedException;
import org.eclipse.e4.core.commands.ECommandService;
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.bindings.EBindingService;
import org.eclipse.e4.ui.model.application.commands.MParameter;
import org.eclipse.e4.ui.model.application.ui.MUIElement;
import org.eclipse.e4.ui.model.application.ui.menu.ItemType;
import org.eclipse.e4.ui.model.application.ui.menu.MHandledItem;
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.MMenuItem;
import org.eclipse.jface.bindings.TriggerSequence;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;

/**
 * Create a contribute part.
 */
public class HandledMenuItemRenderer extends MenuItemRenderer {

	@Inject
	Logger logger;

	public Object createWidget(final MUIElement element, Object parent) {
		if (!(element instanceof MHandledMenuItem) || !(parent instanceof Menu))
			return null;

		MHandledMenuItem itemModel = (MHandledMenuItem) element;
		if (itemModel.getVisibleWhen() != null) {
			processVisible(itemModel);
		}

		if (!itemModel.isVisible()) {
			return null;
		}

		// determine the index at which we should create the new item
		int addIndex = calcVisibleIndex(element);

		// OK, it's a real menu item, what kind?
		int flags = 0;
		if (itemModel.getType() == ItemType.PUSH)
			flags = SWT.PUSH;
		else if (itemModel.getType() == ItemType.CHECK)
			flags = SWT.CHECK;
		else if (itemModel.getType() == ItemType.RADIO)
			flags = SWT.RADIO;

		ParameterizedCommand cmd = itemModel.getWbCommand();
		if (cmd == null) {
			IEclipseContext lclContext = getContext(itemModel);
			cmd = generateParameterizedCommand(itemModel, lclContext);
		}
		MenuItem newItem = new MenuItem((Menu) parent, flags, addIndex);
		setItemText(itemModel, newItem);
		setEnabled(itemModel, newItem);
		newItem.setImage(getImage(itemModel));
		newItem.setSelection(itemModel.isSelected());

		return newItem;
	}

	private void setEnabled(MHandledMenuItem itemModel, MenuItem newItem) {
		ParameterizedCommand cmd = itemModel.getWbCommand();
		if (cmd == null) {
			return;
		}
		final IEclipseContext lclContext = getContext(itemModel);
		EHandlerService service = lclContext.get(EHandlerService.class);
		itemModel.setEnabled(service.canExecute(cmd));
		newItem.setEnabled(itemModel.isEnabled());
	}

	protected void setItemText(MMenuItem model, MenuItem item) {
		String text = model.getLabel();
		if (model instanceof MHandledItem) {
			MHandledItem handledItem = (MHandledItem) model;
			IEclipseContext context = getContext(model);
			EBindingService bs = (EBindingService) context
					.get(EBindingService.class.getName());
			ParameterizedCommand cmd = handledItem.getWbCommand();
			if (cmd != null && (text == null || text.length() == 0)) {
				try {
					text = cmd.getName();
				} catch (NotDefinedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			TriggerSequence sequence = bs.getBestSequenceFor(handledItem
					.getWbCommand());
			if (sequence != null) {
				text = text + '\t' + sequence.format();
			}
			item.setText(text == null ? handledItem.getCommand().getElementId()
					: text);
		} else {
			super.setItemText(model, item);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#hookControllerLogic
	 * (org.eclipse.e4.ui.model.application.MUIElement)
	 */
	@Override
	public void hookControllerLogic(MUIElement me) {
		// If the item is a CHECK or RADIO update the model's state to match
		super.hookControllerLogic(me);

		// 'Execute' the operation if possible
		if (me instanceof MHandledItem) {
			final MHandledItem item = (MHandledItem) me;
			final IEclipseContext lclContext = getContext(me);
			MenuItem mi = (MenuItem) me.getWidget();
			mi.addSelectionListener(new SelectionListener() {
				public void widgetSelected(SelectionEvent e) {
					EHandlerService service = (EHandlerService) lclContext
							.get(EHandlerService.class.getName());
					ParameterizedCommand cmd = item.getWbCommand();
					if (cmd == null) {
						return;
					}
					lclContext.set(MItem.class.getName(), item);
					service.executeHandler(cmd);
					lclContext.remove(MItem.class.getName());
				}

				public void widgetDefaultSelected(SelectionEvent e) {
				}
			});
		}
	}

	public static ParameterizedCommand generateParameterizedCommand(
			final MHandledItem item, final IEclipseContext lclContext) {
		ECommandService cmdService = (ECommandService) lclContext
				.get(ECommandService.class.getName());
		Map<String, Object> parameters = null;
		List<MParameter> modelParms = item.getParameters();
		if (modelParms != null && !modelParms.isEmpty()) {
			parameters = new HashMap<String, Object>();
			for (MParameter mParm : modelParms) {
				parameters.put(mParm.getName(), mParm.getValue());
			}
		}
		ParameterizedCommand cmd = cmdService.createCommand(item.getCommand()
				.getElementId(), parameters);
		item.setWbCommand(cmd);
		return cmd;
	}
}




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

import org.eclipse.e4.ui.model.application.ui.basic.MPart;
import org.eclipse.e4.ui.model.application.ui.basic.MPartStack;
import org.eclipse.e4.ui.model.application.ui.basic.MWindow;
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.MToolControl;
import org.eclipse.e4.ui.widgets.CTabFolder;

					if (!curTB.isDisposed()) {
						MUIElement tbME = (MUIElement) curTB
								.getData(AbstractPartRenderer.OWNING_ME);
						if (tbME instanceof MRenderedToolBar)
							renderer.removeGui(tbME);
						else
							curTB.dispose();

					if (!curTB.isDisposed()) {
						MUIElement tbME = (MUIElement) curTB
								.getData(AbstractPartRenderer.OWNING_ME);
						if (tbME instanceof MRenderedToolBar)
							renderer.removeGui(tbME);
						else
							curTB.dispose();

				IEclipseContext newParentContext = modelService
						.getContainingContext(element);
				if (context.getParent() != newParentContext) {
					//					System.out.println("Update Context: " + context.toString() //$NON-NLS-1$
					//							+ " new parent: " + newParentContext.toString()); //$NON-NLS-1$
					context.setParent(newParentContext);
				}
			}




/*******************************************************************************
 * Copyright (c) 2009 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 org.eclipse.e4.ui.internal.workbench.swt.WorkbenchSWTActivator;

import java.util.HashMap;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import org.eclipse.core.expressions.EvaluationResult;
import org.eclipse.core.expressions.Expression;
import org.eclipse.core.internal.expressions.ReferenceExpression;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.contexts.RunAndTrack;
import org.eclipse.e4.core.services.events.IEventBroker;
import org.eclipse.e4.core.services.log.Logger;
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.menu.ItemType;
import org.eclipse.e4.ui.model.application.ui.menu.MItem;
import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
import org.eclipse.e4.ui.workbench.UIEvents;
import org.eclipse.e4.ui.workbench.modeling.ExpressionContext;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Widget;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventHandler;

/**
 * Create a contribute part.
 */
public abstract class MenuItemRenderer extends SWTPartRenderer {
	static class VisibleRAT extends RunAndTrack {
		Expression exp;
		MMenuItem item;
		ExpressionContext ec;
		boolean participating = true;

		public VisibleRAT(MMenuItem i, Expression e, IEclipseContext c) {
			exp = e;
			item = i;
			ec = new ExpressionContext(c);
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see
		 * org.eclipse.e4.core.contexts.RunAndTrack#changed(org.eclipse.e4.core
		 * .contexts.IEclipseContext)
		 */
		@Override
		public boolean changed(IEclipseContext context) {
			try {
				item.setVisible(EvaluationResult.FALSE != exp.evaluate(ec));
			} catch (CoreException e) {
				item.setVisible(false);
				WorkbenchSWTActivator.trace(
						"/trace/menus", "VisibleRAT failed", e); //$NON-NLS-1$//$NON-NLS-2$
			}
			return participating;
		}
	}

	private HashMap<MMenuItem, Expression> menuItemToExpression = new HashMap<MMenuItem, Expression>();
	private HashMap<MMenuItem, VisibleRAT> menuItemToRAT = new HashMap<MMenuItem, VisibleRAT>();

	@Inject
	Logger logger;
	@Inject
	IEventBroker eventBroker;
	private EventHandler itemUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MMenuItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
				return;

			MMenuItem itemModel = (MMenuItem) event
					.getProperty(UIEvents.EventTags.ELEMENT);
			MenuItem menuItem = (MenuItem) itemModel.getWidget();

			// No widget == nothing to update
			if (menuItem == null)
				return;

			String attName = (String) event
					.getProperty(UIEvents.EventTags.ATTNAME);
			if (UIEvents.UILabel.LABEL.equals(attName)) {
				setItemText(itemModel, menuItem);
			} else if (UIEvents.UILabel.ICONURI.equals(attName)) {
				menuItem.setImage(getImage(itemModel));
			}
		}
	};

	private EventHandler selectionUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MToolItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
				return;

			MMenuItem itemModel = (MMenuItem) event
					.getProperty(UIEvents.EventTags.ELEMENT);
			MenuItem menuItem = (MenuItem) itemModel.getWidget();
			if (menuItem != null) {
				menuItem.setSelection(itemModel.isSelected());
			}
		}
	};

	private EventHandler enabledUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MMenuItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
				return;

			MMenuItem itemModel = (MMenuItem) event
					.getProperty(UIEvents.EventTags.ELEMENT);
			MenuItem menuItem = (MenuItem) itemModel.getWidget();
			if (menuItem != null) {
				menuItem.setEnabled(itemModel.isEnabled());
			}
		}
	};

	@PostConstruct
	public void init() {
		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UILabel.TOPIC),
				itemUpdater);
		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
				UIEvents.Item.SELECTED), selectionUpdater);
		eventBroker
				.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
						UIEvents.Item.ENABLED), enabledUpdater);
	}

	@PreDestroy
	public void contextDisposed() {
		eventBroker.unsubscribe(itemUpdater);
		eventBroker.unsubscribe(selectionUpdater);
		eventBroker.unsubscribe(enabledUpdater);
	}

	protected void processVisible(MMenuItem item) {
		if (menuItemToExpression.get(item) != null) {
			return;
		}
		MCoreExpression exp = (MCoreExpression) item.getVisibleWhen();
		Expression ref = null;
		if (exp.getCoreExpression() instanceof Expression) {
			ref = (Expression) exp.getCoreExpression();
		} else {
			ref = new ReferenceExpression(exp.getCoreExpressionId());
			exp.setCoreExpression(ref);
		}
		menuItemToExpression.put(item, ref);
		IEclipseContext itemContext = getContext(item);
		VisibleRAT rat = new VisibleRAT(item, ref, itemContext);
		menuItemToRAT.put(item, rat);
		itemContext.runAndTrack(rat);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#hideChild
	 * (org.eclipse.e4.ui.model.application.MElementContainer,
	 * org.eclipse.e4.ui.model.application.MUIElement)
	 */
	@Override
	public void hideChild(MElementContainer<MUIElement> parentElement,
			MUIElement child) {
		super.hideChild(parentElement, child);

		// Since there's no place to 'store' a child that's not in a menu
		// we'll blow it away and re-create on an add
		Widget widget = (Widget) child.getWidget();
		if (widget != null && !widget.isDisposed())
			widget.dispose();
		menuItemToExpression.remove(child);
		VisibleRAT rat = menuItemToRAT.remove(child);
		if (rat != null) {
			rat.participating = false;
		}
	}

	protected void setItemText(MMenuItem model, MenuItem item) {
		String text = model.getLabel();
		if (text == null) {
			text = ""; //$NON-NLS-1$
		}
		item.setText(text);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#hookControllerLogic
	 * (org.eclipse.e4.ui.model.application.MUIElement)
	 */
	@Override
	public void hookControllerLogic(MUIElement me) {
		// If the item is a CHECK or RADIO update the model's state to match
		if (me instanceof MItem) {
			final MItem item = (MItem) me;
			if (item.getType() == ItemType.CHECK
					|| item.getType() == ItemType.RADIO) {
				MenuItem ti = (MenuItem) me.getWidget();
				ti.addSelectionListener(new SelectionListener() {
					public void widgetSelected(SelectionEvent e) {
						item.setSelected(((MenuItem) e.widget).getSelection());
					}

					public void widgetDefaultSelected(SelectionEvent e) {
						item.setSelected(((MenuItem) e.widget).getSelection());
					}
				});
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import org.eclipse.e4.core.contexts.ContextInjectionFactory;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.contexts.RunAndTrack;
import org.eclipse.e4.core.services.events.IEventBroker;
import org.eclipse.e4.core.services.log.Logger;
import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;
import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
import org.eclipse.e4.ui.model.application.MApplication;
import org.eclipse.e4.ui.model.application.ui.MContext;
import org.eclipse.e4.ui.model.application.ui.MElementContainer;
import org.eclipse.e4.ui.model.application.ui.MUIElement;
import org.eclipse.e4.ui.model.application.ui.MUILabel;
import org.eclipse.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.MMenuContribution;
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.MPopupMenu;
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.e4.ui.workbench.swt.util.ISWTResourceUtilities;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.jface.action.AbstractGroupMarker;
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.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.Menu;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventHandler;

/**
 * Create a contribute part.
 */
public class MenuManagerRenderer extends SWTPartRenderer {
	private static final String NO_LABEL = "UnLabled"; //$NON-NLS-1$

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

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

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

	@Inject
	private Logger logger;

	@Inject
	private MApplication application;

	@Inject
	IEventBroker eventBroker;
	private EventHandler itemUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MMenuItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
				return;

			MMenuItem itemModel = (MMenuItem) event
					.getProperty(UIEvents.EventTags.ELEMENT);

			IContributionItem ici = getContribution(itemModel);
			if (ici == null) {
				return;
			}

			String attName = (String) event
					.getProperty(UIEvents.EventTags.ATTNAME);
			if (UIEvents.UILabel.LABEL.equals(attName)) {
				ici.update();
			} else if (UIEvents.UILabel.ICONURI.equals(attName)) {
				ici.update();
			}
		}
	};

	private EventHandler toBeRenderedUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			Object element = event.getProperty(UIEvents.EventTags.ELEMENT);
			String attName = (String) event
					.getProperty(UIEvents.EventTags.ATTNAME);
			if (element instanceof MMenuItem) {
				MMenuItem itemModel = (MMenuItem) element;
				if (UIEvents.UIElement.TOBERENDERED.equals(attName)) {
					Object obj = itemModel.getParent();
					if (!(obj instanceof MMenu)) {
						return;
					}
					MenuManager parent = getManager((MMenu) obj);
					if (itemModel.isToBeRendered()) {
						if (parent != null) {
							modelProcessSwitch(parent, itemModel);
						}
					} else {
						IContributionItem ici = modelToContribution
								.remove(itemModel);
						if (ici != null && parent != null) {
							parent.remove(ici);
						}
						if (ici != null) {
							ici.dispose();
						}
					}
				}
			}
			if (UIEvents.UIElement.VISIBLE.equals(attName)) {
				if (element instanceof MMenu) {
					MMenu menuModel = (MMenu) element;
					MenuManager manager = getManager(menuModel);
					if (manager == null) {
						return;
					}
					manager.setVisible(menuModel.isVisible());
				} else if (element instanceof MMenuElement) {
					MMenuElement itemModel = (MMenuElement) element;
					IContributionItem ici = getContribution(itemModel);
					if (ici == null) {
						return;
					}
					ici.setVisible(itemModel.isVisible());
				}
			}
		}
	};

	private EventHandler selectionUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MToolItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
				return;

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

	private EventHandler enabledUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MMenuItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
				return;

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

	private IMenuListener visibilityCalculationListener = new IMenuListener() {
		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.UILabel.TOPIC),
				itemUpdater);
		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
				UIEvents.Item.SELECTED), selectionUpdater);
		eventBroker
				.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
						UIEvents.Item.ENABLED), enabledUpdater);
		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UIElement.TOPIC),
				toBeRenderedUpdater);

	}

	@PreDestroy
	public void contextDisposed() {
		eventBroker.unsubscribe(itemUpdater);
		eventBroker.unsubscribe(selectionUpdater);
		eventBroker.unsubscribe(enabledUpdater);
		eventBroker.unsubscribe(toBeRenderedUpdater);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#createWidget
	 * (org.eclipse.e4.ui.model.application.ui.MUIElement, java.lang.Object)
	 */
	@Override
	public Object createWidget(MUIElement element, Object parent) {
		if (!(element instanceof MMenu))
			return null;

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

		if (parent instanceof Decorations) {
			MUIElement container = (MUIElement) ((EObject) element)
					.eContainer();
			if (container instanceof MWindow) {
				MenuManager menuBarManager = getManager(menuModel);
				if (menuBarManager == null) {
					menuBarManager = new MenuManager(NO_LABEL,
							menuModel.getElementId());
					linkModelToManager(menuModel, menuBarManager);
				}
				newMenu = menuBarManager.createMenuBar((Decorations) parent);
				((Decorations) parent).setMenuBar(newMenu);
				newMenu.setData(menuBarManager);
				menuBar = true;
			} else {
				MenuManager popupManager = getManager(menuModel);
				if (popupManager == null) {
					popupManager = new MenuManager(NO_LABEL,
							menuModel.getElementId());
					linkModelToManager(menuModel, popupManager);
				}
				newMenu = popupManager.createContextMenu((Control) parent);
				((Control) parent).setMenu(newMenu);
				newMenu.setData(popupManager);
			}
		} 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$

		} else if (parent instanceof Control) {
			MenuManager popupManager = getManager(menuModel);
			if (popupManager == null) {
				popupManager = new MenuManager(NO_LABEL,
						menuModel.getElementId());
				linkModelToManager(menuModel, popupManager);
			}
			newMenu = popupManager.createContextMenu((Control) parent);
			((Control) parent).setMenu(newMenu);
			newMenu.setData(popupManager);
		}
		processContributions(menuModel, menuBar);
		if (newMenu != null) {
			newMenu.addDisposeListener(new DisposeListener() {
				public void widgetDisposed(DisposeEvent e) {
					cleanUp(menuModel);
				}
			});
		}
		return newMenu;
	}

	/**
	 * @param menuModel
	 */
	protected void cleanUp(MMenu menuModel) {
		Collection<ContributionRecord> vals = modelContributionToRecord
				.values();
		for (ContributionRecord record : vals
				.toArray(new ContributionRecord[vals.size()])) {
			if (record.menuModel == menuModel) {
				record.dispose();
				for (MMenuElement copy : record.generatedElements) {
					modelContributionToRecord.remove(copy);
					if (copy instanceof MMenu) {
						MMenu menuCopy = (MMenu) copy;
						cleanUp(menuCopy);
						MenuManager copyManager = getManager(menuCopy);
						clearModelToManager(menuCopy, copyManager);
						if (copyManager != null) {
							copyManager.dispose();
						}
					} else {
						IContributionItem ici = modelToContribution
								.remove(copy);
						if (ici != null) {
							record.manager.remove(ici);
						}
					}
				}
				record.generatedElements.clear();
			}
		}
	}

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

	/**
	 * @param menuModel
	 * @param toContribute
	 */
	private void generateContributions(MMenu menuModel,
			ArrayList<MMenuContribution> toContribute, boolean menuBar) {
		HashSet<String> existingMenuIds = new HashSet<String>();
		HashSet<String> existingSeparatorNames = new HashSet<String>();
		for (MMenuElement child : menuModel.getChildren()) {
			String elementId = child.getElementId();
			if (child instanceof MMenu && elementId != null) {
				existingMenuIds.add(elementId);
			} else if (child instanceof MMenuSeparator && elementId != null) {
				existingSeparatorNames.add(elementId);
			}
		}

		MenuManager manager = getManager(menuModel);
		boolean done = toContribute.size() == 0;
		while (!done) {
			ArrayList<MMenuContribution> curList = new ArrayList<MMenuContribution>(
					toContribute);
			int retryCount = toContribute.size();
			toContribute.clear();

			for (MMenuContribution menuContribution : curList) {
				if (!processAddition(menuModel, manager, menuContribution,
						existingMenuIds, existingSeparatorNames, menuBar)) {
					toContribute.add(menuContribution);
				}
			}

			// We're done if the retryList is now empty (everything done) or
			// if the list hasn't changed at all (no hope)
			done = (toContribute.size() == 0)
					|| (toContribute.size() == retryCount);
		}
	}

	/**
	 * @param menuModel
	 * @param manager
	 * @param menuContribution
	 * @return true if the menuContribution was processed
	 */
	private boolean processAddition(MMenu menuModel, final MenuManager manager,
			MMenuContribution menuContribution,
			final HashSet<String> existingMenuIds,
			HashSet<String> existingSeparatorNames, boolean menuBar) {
		int idx = getIndex(menuModel, menuContribution.getPositionInParent());
		if (idx == -1) {
			return false;
		}
		final ContributionRecord record = new ContributionRecord(menuModel,
				menuContribution, manager);
		record.generate();
		for (MMenuElement copy : record.generatedElements) {
			modelContributionToRecord.put(copy, record);
			if (copy instanceof MMenu
					&& existingMenuIds.contains(copy.getElementId())) {
				// skip this, it's already there
				continue;
			} else if (copy instanceof MMenuSeparator
					&& existingSeparatorNames.contains(copy.getElementId())) {
				// skip this, it's already there
				continue;
			}
			menuModel.getChildren().add(idx++, copy);
			if (copy instanceof MMenu && copy.getElementId() != null) {
				existingMenuIds.add(copy.getElementId());
			} else if (copy instanceof MMenuSeparator
					&& copy.getElementId() != null) {
				existingSeparatorNames.add(copy.getElementId());
			}
		}
		if (menuBar) {
			if (menuContribution.getVisibleWhen() != null) {
				final IEclipseContext parentContext = modelService
						.getContainingContext(menuModel);
				parentContext.runAndTrack(new RunAndTrack() {
					@Override
					public boolean changed(IEclipseContext context) {
						record.updateVisibility(parentContext.getActiveLeaf());
						manager.update(true);
						return true;
					}
				});
			}
		}
		return true;
	}

	private static int getIndex(MElementContainer<?> menuModel,
			String positionInParent) {
		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) {
			return menuModel.getChildren().size();
		}

		int idx = 0;
		int size = menuModel.getChildren().size();
		while (idx < size) {
			if (id.equals(menuModel.getChildren().get(idx).getElementId())) {
				if ("after".equals(modifier)) { //$NON-NLS-1$
					idx++;
				}
				return idx;
			}
			idx++;
		}
		return id.equals("additions") ? menuModel.getChildren().size() : -1; //$NON-NLS-1$
	}

	static class ContributionRecord {
		MMenu menuModel;
		MMenuContribution menuContribution;
		ArrayList<MMenuElement> generatedElements = new ArrayList<MMenuElement>();
		MenuManager manager;

		public ContributionRecord(MMenu menuModel,
				MMenuContribution contribution, MenuManager manager) {
			this.menuModel = menuModel;
			this.menuContribution = contribution;
			this.manager = manager;
		}

		/**
		 * @param context
		 */
		public void updateVisibility(IEclipseContext context) {
			ExpressionContext exprContext = new ExpressionContext(context);
			boolean isVisible = ContributionsAnalyzer.isVisible(
					menuContribution, exprContext);
			for (MMenuElement item : generatedElements) {
				item.setVisible(isVisible);
			}
			manager.markDirty();
		}

		public void generate() {
			for (MMenuElement item : menuContribution.getChildren()) {
				MMenuElement copy = (MMenuElement) EcoreUtil
						.copy((EObject) item);
				generatedElements.add(copy);
			}
		}

		public void dispose() {
			for (MMenuElement copy : generatedElements) {
				menuModel.getChildren().remove(copy);
			}
		}
	}

	void removeMenuContributions(final MMenu menuModel,
			final ArrayList<MMenuElement> menuContributionsToRemove) {
		for (MMenuElement item : menuContributionsToRemove) {
			menuModel.getChildren().remove(item);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#processContents
	 * (org.eclipse.e4.ui.model.application.ui.MElementContainer)
	 */
	@Override
	public void processContents(MElementContainer<MUIElement> container) {
		// I can either simply stop processing, or we can walk the model
		// ourselves like the "old" days
		// EMF gives us null lists if empty
		if (container == null)
			return;

		// this is in direct violation of good programming
		MenuManager parentManager = getManager((MMenu) ((Object) container));
		if (parentManager == null) {
			return;
		}
		// Process any contents of the newly created ME
		List<MUIElement> parts = container.getChildren();
		if (parts != null) {
			MUIElement[] plist = parts.toArray(new MUIElement[parts.size()]);
			for (int i = 0; i < plist.length; i++) {
				MUIElement childME = plist[i];
				modelProcessSwitch(parentManager, (MMenuElement) childME);
			}
		}
		parentManager.update(false);
	}

	/**
	 * @param parentManager
	 * @param menuModel
	 */
	private void processMenu(MenuManager parentManager, MMenu menuModel) {
		String menuText = getText(menuModel);
		ImageDescriptor desc = getImageDescriptor(menuModel);
		MenuManager 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) {
			MMenuElement[] plist = parts
					.toArray(new MMenuElement[parts.size()]);
			for (int i = 0; i < plist.length; i++) {
				MMenuElement childME = plist[i];
				modelProcessSwitch(menuManager, childME);
			}
		}
	}

	/**
	 * @param menuManager
	 * @param childME
	 */
	void modelProcessSwitch(MenuManager menuManager, MMenuElement childME) {
		if (!childME.isToBeRendered()) {
			return;
		}
		if (childME instanceof MHandledMenuItem) {
			MHandledMenuItem itemModel = (MHandledMenuItem) childME;
			processHandledItem(menuManager, itemModel);
		} else if (childME instanceof MDirectMenuItem) {
			MDirectMenuItem itemModel = (MDirectMenuItem) childME;
			processDirectItem(menuManager, itemModel, null);
		} else if (childME instanceof MMenuSeparator) {
			MMenuSeparator sep = (MMenuSeparator) childME;
			processSeparator(menuManager, sep);
		} else if (childME instanceof MMenu) {
			MMenu itemModel = (MMenu) childME;
			processMenu(menuManager, itemModel);
		}
	}

	/**
	 * @param menuManager
	 * @param itemModel
	 */
	private void processSeparator(MenuManager menuManager,
			MMenuSeparator itemModel) {
		AbstractGroupMarker marker = null;
		if (itemModel.isVisible()) {
			marker = new Separator();
			marker.setId(itemModel.getElementId());
		} else {
			if (itemModel.getElementId() != null) {
				marker = new GroupMarker(itemModel.getElementId());
			}
		}
		menuManager.add(marker);
	}

	/**
	 * @param parentManager
	 * @param itemModel
	 * @param id
	 *            TODO
	 */
	void processDirectItem(MenuManager parentManager,
			MDirectMenuItem itemModel, String id) {
		final IEclipseContext lclContext = getContext(itemModel);
		DirectContributionItem ci = ContextInjectionFactory.make(
				DirectContributionItem.class, lclContext);
		ci.setModel(itemModel);
		ci.setVisible(itemModel.isVisible());
		parentManager.add(ci);
		modelToContribution.put(itemModel, ci);
	}

	/**
	 * @param parentManager
	 * @param itemModel
	 */
	void processHandledItem(MenuManager parentManager,
			MHandledMenuItem itemModel) {
		final IEclipseContext lclContext = getContext(itemModel);
		HandledContributionItem ci = ContextInjectionFactory.make(
				HandledContributionItem.class, lclContext);
		ci.setModel(itemModel);
		ci.setVisible(itemModel.isVisible());
		parentManager.add(ci);
		modelToContribution.put(itemModel, ci);
	}

	private String getText(MMenu menuModel) {
		String text = menuModel.getLabel();
		if (text == null || text.length() == 0) {
			return NO_LABEL;
		}
		return text;
	}

	private ImageDescriptor getImageDescriptor(MUILabel element) {
		IEclipseContext localContext = context;
		String iconURI = element.getIconURI();
		if (iconURI != null && iconURI.length() > 0) {
			ISWTResourceUtilities resUtils = (ISWTResourceUtilities) localContext
					.get(IResourceUtilities.class.getName());
			return resUtils.imageDescriptorFromURI(URI.createURI(iconURI));
		}
		return null;
	}

	public MenuManager getManager(MMenu model) {
		return modelToManager.get(model);
	}

	public MMenu getMenuModel(MenuManager manager) {
		return managerToModel.get(manager);
	}

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




package org.eclipse.e4.ui.workbench.renderers.swt;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import org.eclipse.e4.core.contexts.ContextInjectionFactory;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.contexts.RunAndTrack;
import org.eclipse.e4.core.services.events.IEventBroker;
import org.eclipse.e4.core.services.log.Logger;
import org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer;
import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
import org.eclipse.e4.ui.model.application.MApplication;
import org.eclipse.e4.ui.model.application.ui.MContext;
import org.eclipse.e4.ui.model.application.ui.MElementContainer;
import org.eclipse.e4.ui.model.application.ui.MUIElement;
import org.eclipse.e4.ui.model.application.ui.MUILabel;
import org.eclipse.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.MMenuContribution;
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.MPopupMenu;
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.e4.ui.workbench.swt.modeling.MenuServiceFilter;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.swt.SWT;
import org.eclipse.jface.action.AbstractGroupMarker;
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.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.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Widget;

/**
 * Create a contribute part.
 */
public class MenuRenderer extends SWTPartRenderer {
	private static final String NO_LABEL = "UnLabled"; //$NON-NLS-1$

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

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

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

	@Inject
	private Logger logger;

	@Inject
	private MApplication application;
	private HashMap<MMenu, ArrayList<ArrayList<MMenuElement>>> pendingCleanup = new HashMap<MMenu, ArrayList<ArrayList<MMenuElement>>>();

	@Override
	public void init(IEclipseContext context) {
		super.init(context);
		application = context.get(MApplication.class);
			// Ensure that this event is for a MMenuItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
				return;

			MMenuItem itemModel = (MMenuItem) event
					.getProperty(UIEvents.EventTags.ELEMENT);

			IContributionItem ici = getContribution(itemModel);
			if (ici == null) {
				return;
			}

			String attName = (String) event
					.getProperty(UIEvents.EventTags.ATTNAME);
			if (UIEvents.UILabel.LABEL.equals(attName)) {
				ici.update();
			} else if (UIEvents.UILabel.ICONURI.equals(attName)) {
				ici.update();
			}
		}
	};

	private EventHandler toBeRenderedUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			Object element = event.getProperty(UIEvents.EventTags.ELEMENT);
			String attName = (String) event
					.getProperty(UIEvents.EventTags.ATTNAME);
			if (element instanceof MMenuItem) {
				MMenuItem itemModel = (MMenuItem) element;
				if (UIEvents.UIElement.TOBERENDERED.equals(attName)) {
					Object obj = itemModel.getParent();
					if (!(obj instanceof MMenu)) {
						return;
					}
					MenuManager parent = getManager((MMenu) obj);
					if (itemModel.isToBeRendered()) {
						if (parent != null) {
							modelProcessSwitch(parent, itemModel);
						}
					} else {
						IContributionItem ici = modelToContribution
								.remove(itemModel);
						if (ici != null && parent != null) {
							parent.remove(ici);
						}
						if (ici != null) {
							ici.dispose();
						}
					}
				}
			}
			if (UIEvents.UIElement.VISIBLE.equals(attName)) {
				if (element instanceof MMenu) {
					MMenu menuModel = (MMenu) element;
					MenuManager manager = getManager(menuModel);
					if (manager == null) {
						return;
					}
					manager.setVisible(menuModel.isVisible());
				} else if (element instanceof MMenuElement) {
					MMenuElement itemModel = (MMenuElement) element;
					IContributionItem ici = getContribution(itemModel);
					if (ici == null) {
						return;
					}
					ici.setVisible(itemModel.isVisible());
				}
			}
		}
	};

	private EventHandler selectionUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MToolItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
				return;

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

	private EventHandler enabledUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MMenuItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
				return;

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

	private IMenuListener visibilityCalculationListener = new IMenuListener() {
		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.UILabel.TOPIC),
				itemUpdater);
		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
				UIEvents.Item.SELECTED), selectionUpdater);
		eventBroker
				.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
						UIEvents.Item.ENABLED), enabledUpdater);
		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UIElement.TOPIC),
				toBeRenderedUpdater);

	}

	@PreDestroy
	public void contextDisposed() {
		eventBroker.unsubscribe(itemUpdater);
		eventBroker.unsubscribe(selectionUpdater);
		eventBroker.unsubscribe(enabledUpdater);
		eventBroker.unsubscribe(toBeRenderedUpdater);
	}

	public Object createWidget(final MUIElement element, Object parent) {
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#createWidget
	 * (org.eclipse.e4.ui.model.application.ui.MUIElement, java.lang.Object)
	 */
	@Override
	public Object createWidget(MUIElement element, Object parent) {
		if (!(element instanceof MMenu))
			return null;

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

		Menu newMenu = null;
		if (parent instanceof Decorations) {
			MUIElement container = (MUIElement) ((EObject) element)
					.eContainer();
			if (container instanceof MWindow) {
				newMenu = new Menu((Decorations) parent, SWT.BAR);
				newMenu.addDisposeListener(new DisposeListener() {
					public void widgetDisposed(DisposeEvent e) {
						cleanUp(menuModel);
					}
				});
				newMenu = menuBarManager.createMenuBar((Decorations) parent);
				((Decorations) parent).setMenuBar(newMenu);
				newMenu.setData(menuBarManager);
				menuBar = true;
			} else {
				newMenu = new Menu((Decorations) parent, SWT.POP_UP);
				if (popupManager == null) {
					popupManager = new MenuManager(NO_LABEL,
							menuModel.getElementId());
					linkModelToManager(menuModel, popupManager);
				}
				newMenu = popupManager.createContextMenu((Control) parent);
				((Control) parent).setMenu(newMenu);
				newMenu.setData(popupManager);
			}
		} else if (parent instanceof Menu) {
			int addIndex = calcVisibleIndex(menuModel);
			MenuItem newItem = new MenuItem((Menu) parent, SWT.CASCADE,
					addIndex);
			setItemText(menuModel, newItem);
			newItem.setImage(getImage(menuModel));
			newItem.setEnabled(menuModel.isEnabled());
			return newItem;
		} else if (parent instanceof Control) {
			newMenu = new Menu((Control) parent);
			if (popupManager == null) {
				popupManager = new MenuManager(NO_LABEL,
						menuModel.getElementId());
				linkModelToManager(menuModel, popupManager);
			}
			newMenu = popupManager.createContextMenu((Control) parent);
			((Control) parent).setMenu(newMenu);
			newMenu.setData(popupManager);
		}
		processContributions(menuModel, menuBar);
		if (newMenu != null) {
			newMenu.addDisposeListener(new DisposeListener() {
				public void widgetDisposed(DisposeEvent e) {
					cleanUp(menuModel);
				}
			});
		}

		return newMenu;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#processContents
	 * (org.eclipse.e4.ui.model.application.ui.MElementContainer)
	 */
	@Override
	public void processContents(MElementContainer<MUIElement> container) {
		if (container.getChildren().size() == 0) {
			Object obj = container.getWidget();
			if (obj instanceof MenuItem) {
				MenuItem mi = (MenuItem) obj;
				if (mi.getMenu() == null) {
					mi.setMenu(new Menu(mi));
				}
				Menu menu = mi.getMenu();
				MenuItem menuItem = new MenuItem(menu, SWT.PUSH);
				menuItem.setText(MenuServiceFilter.NUL_MENU_ITEM);
				menuItem.setEnabled(false);
						clearModelToManager(menuCopy, copyManager);
						if (copyManager != null) {
							copyManager.dispose();
						}
					} else {
						IContributionItem ici = modelToContribution
								.remove(copy);
						if (ici != null) {
							record.manager.remove(ici);
						}
					}
				}
				record.generatedElements.clear();
			}
		}
	}

		super.processContents(container);

		Object obj = container.getWidget();
		Object menuObj = container;
		if ((obj instanceof Menu) && (((Menu) obj).getStyle() & SWT.BAR) != 0
				&& (menuObj instanceof MMenu)) {
			MMenu menuModel = (MMenu) menuObj;
			IEclipseContext ctx = getContext(container);
			ExpressionContext eContext = new ExpressionContext(ctx);
			ArrayList<MMenuContribution> toContribute = new ArrayList<MMenuContribution>();
			ContributionsAnalyzer.gatherMenuContributions(menuModel,
					application.getMenuContributions(),
					menuModel.getElementId(), toContribute, eContext, false);
			addMenuBarContributions(menuModel, toContribute, ctx, eContext);
		}
	}

	// this is similar in nature to:
	// org.eclipse.e4.ui.internal.workbench.ContributionsAnalyzer.addMenuContributions(MMenu,
	// ArrayList<MMenuContribution>, ArrayList<MMenuElement>)
	// the difference is it needs to add all the contributions and manage their
	// visiblility through a RAT
	private void addMenuBarContributions(final MMenu menuModel,
			ArrayList<MMenuContribution> toContribute,
			final IEclipseContext ctx, final ExpressionContext eContext) {
		HashSet<String> existingMenuIds = new HashSet<String>();
		HashSet<String> existingSeparatorNames = new HashSet<String>();
		for (MMenuElement child : menuModel.getChildren()) {

			}
		}

		MenuManager manager = getManager(menuModel);
		boolean done = toContribute.size() == 0;
		while (!done) {
			ArrayList<MMenuContribution> curList = new ArrayList<MMenuContribution>(

			int retryCount = toContribute.size();
			toContribute.clear();

			for (final MMenuContribution menuContribution : curList) {
				final ArrayList<MMenuElement> menuContributionsToRemove = new ArrayList<MMenuElement>();
				if (!ContributionsAnalyzer.processAddition(menuModel,
						menuContributionsToRemove, menuContribution,
						existingMenuIds, existingSeparatorNames)) {
					toContribute.add(menuContribution);
				} else {
					if (menuContribution.getVisibleWhen() != null) {
						ctx.runAndTrack(new RunAndTrack() {
							@Override
							public boolean changed(IEclipseContext context) {
								if (!menuModel.isToBeRendered()
										|| !menuModel.isVisible()
										|| menuModel.getWidget() == null) {
									return false;
								}
								boolean rc = ContributionsAnalyzer.isVisible(
										menuContribution, eContext);
								for (MMenuElement element : menuContributionsToRemove) {
									element.setToBeRendered(rc);
								}
								return true;
							}
						});
					}
					ArrayList<ArrayList<MMenuElement>> lists = pendingCleanup
							.get(menuModel);
					if (lists == null) {
						lists = new ArrayList<ArrayList<MMenuElement>>();
						pendingCleanup.put(menuModel, lists);
					}
					lists.add(menuContributionsToRemove);
				}
			}

			// We're done if the retryList is now empty (everything done) or
			// if the list hasn't changed at all (no hope)
			done = (toContribute.size() == 0)

		}
	}

	private void setItemText(MMenu model, MenuItem item) {
		String text = model.getLabel();
		if (text == null) {
			text = ""; //$NON-NLS-1$
	 * @return true if the menuContribution was processed
	 */
	private boolean processAddition(MMenu menuModel, final MenuManager manager,
			MMenuContribution menuContribution,
			final HashSet<String> existingMenuIds,
			HashSet<String> existingSeparatorNames, boolean menuBar) {
		int idx = getIndex(menuModel, menuContribution.getPositionInParent());
		if (idx == -1) {
			return false;
		}
		item.setText(text);
				menuContribution, manager);
		record.generate();
		for (MMenuElement copy : record.generatedElements) {
			modelContributionToRecord.put(copy, record);
			if (copy instanceof MMenu
					&& existingMenuIds.contains(copy.getElementId())) {
				// skip this, it's already there
				continue;
			} else if (copy instanceof MMenuSeparator
					&& existingSeparatorNames.contains(copy.getElementId())) {
				// skip this, it's already there
				continue;
			}
			menuModel.getChildren().add(idx++, copy);
			if (copy instanceof MMenu && copy.getElementId() != null) {
				existingMenuIds.add(copy.getElementId());
			} else if (copy instanceof MMenuSeparator
					&& copy.getElementId() != null) {
				existingSeparatorNames.add(copy.getElementId());
			}
		}
		if (menuBar) {
			if (menuContribution.getVisibleWhen() != null) {
				final IEclipseContext parentContext = modelService
						.getContainingContext(menuModel);
				parentContext.runAndTrack(new RunAndTrack() {
					@Override
					public boolean changed(IEclipseContext context) {
						record.updateVisibility(parentContext.getActiveLeaf());
						manager.update(true);
						return true;
					}
				});
			}
		}
		return true;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#hideChild
	 * (org.eclipse.e4.ui.model.application.MElementContainer,
	 * org.eclipse.e4.ui.model.application.MUIElement)
	 */
	@Override
	public void hideChild(MElementContainer<MUIElement> parentElement,
			MUIElement child) {
		super.hideChild(parentElement, child);

		// Since there's no place to 'store' a child that's not in a menu
		// we'll blow it away and re-create on an add
		Widget widget = (Widget) child.getWidget();
		if (widget != null && !widget.isDisposed())
			widget.dispose();
					idx++;
				}
				return idx;
			}
			idx++;
		}
		return id.equals("additions") ? menuModel.getChildren().size() : -1; //$NON-NLS-1$
	}

	static class ContributionRecord {
		MMenu menuModel;
		MMenuContribution menuContribution;
		ArrayList<MMenuElement> generatedElements = new ArrayList<MMenuElement>();
		MenuManager manager;

		public ContributionRecord(MMenu menuModel,
				MMenuContribution contribution, MenuManager manager) {
			this.menuModel = menuModel;
			this.menuContribution = contribution;
			this.manager = manager;
		}

		/**
		 * @param context
		 */
		public void updateVisibility(IEclipseContext context) {
			ExpressionContext exprContext = new ExpressionContext(context);
			boolean isVisible = ContributionsAnalyzer.isVisible(
					menuContribution, exprContext);
			for (MMenuElement item : generatedElements) {
				item.setVisible(isVisible);
			}
			manager.markDirty();
		}

		public void generate() {
			for (MMenuElement item : menuContribution.getChildren()) {
				MMenuElement copy = (MMenuElement) EcoreUtil
						.copy((EObject) item);
				generatedElements.add(copy);
			}
		}

		public void dispose() {
			for (MMenuElement copy : generatedElements) {
				menuModel.getChildren().remove(copy);
			}
		}
	}

	void removeMenuContributions(final MMenu menuModel,
			final ArrayList<MMenuElement> menuContributionsToRemove) {
		for (MMenuElement item : menuContributionsToRemove) {
			menuModel.getChildren().remove(item);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.AbstractPartRenderer#getUIContainer
	 * (org.eclipse.e4.ui.model.application.MUIElement)
	 */
	@Override
	public Object getUIContainer(MUIElement element) {
		if (!(element instanceof MMenuElement))
			return null;
		// EMF gives us null lists if empty
		if (container == null)
			return;

		if (element.getParent().getWidget() instanceof MenuItem) {
			MenuItem mi = (MenuItem) element.getParent().getWidget();
			if (mi.getMenu() == null) {
				mi.setMenu(new Menu(mi));
		}
		// Process any contents of the newly created ME
		List<MUIElement> parts = container.getChildren();
		if (parts != null) {
			MUIElement[] plist = parts.toArray(new MUIElement[parts.size()]);
			for (int i = 0; i < plist.length; i++) {
				MUIElement childME = plist[i];
				modelProcessSwitch(parentManager, (MMenuElement) childME);
			}
			return mi.getMenu();
		}
		parentManager.update(false);
	}

		return super.getUIContainer(element);
	 * @param parentManager
	 * @param menuModel
	 */
	private void processMenu(MenuManager parentManager, MMenu menuModel) {
		String menuText = getText(menuModel);
		ImageDescriptor desc = getImageDescriptor(menuModel);
		MenuManager 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) {
			MMenuElement[] plist = parts
					.toArray(new MMenuElement[parts.size()]);
			for (int i = 0; i < plist.length; i++) {
				MMenuElement childME = plist[i];
				modelProcessSwitch(menuManager, childME);
			}
		}
	}

	void cleanUp(MMenu menuModel) {
		ArrayList<ArrayList<MMenuElement>> lists = pendingCleanup
				.remove(menuModel);
		if (lists == null) {
	void modelProcessSwitch(MenuManager menuManager, MMenuElement childME) {
		if (!childME.isToBeRendered()) {
			return;
		}
		for (ArrayList<MMenuElement> list : lists) {
			for (MMenuElement item : list) {
				menuModel.getChildren().remove(item);
		} else if (childME instanceof MDirectMenuItem) {
			MDirectMenuItem itemModel = (MDirectMenuItem) childME;
			processDirectItem(menuManager, itemModel, null);
		} else if (childME instanceof MMenuSeparator) {
			MMenuSeparator sep = (MMenuSeparator) childME;
			processSeparator(menuManager, sep);
		} else if (childME instanceof MMenu) {
			MMenu itemModel = (MMenu) childME;
			processMenu(menuManager, itemModel);
		}
	}

	/**
	 * @param menuManager
	 * @param itemModel
	 */
	private void processSeparator(MenuManager menuManager,
			MMenuSeparator itemModel) {
		AbstractGroupMarker marker = null;
		if (itemModel.isVisible()) {
			marker = new Separator();
			marker.setId(itemModel.getElementId());
		} else {
			if (itemModel.getElementId() != null) {
				marker = new GroupMarker(itemModel.getElementId());
			}
		}
		menuManager.add(marker);
	}

	/**
	 * @param parentManager
	 * @param itemModel
	 * @param id
	 *            TODO
	 */
	void processDirectItem(MenuManager parentManager,
			MDirectMenuItem itemModel, String id) {
		final IEclipseContext lclContext = getContext(itemModel);
		DirectContributionItem ci = ContextInjectionFactory.make(
				DirectContributionItem.class, lclContext);
		ci.setModel(itemModel);
		ci.setVisible(itemModel.isVisible());
		parentManager.add(ci);
		modelToContribution.put(itemModel, ci);
	}

	/**
	 * @param parentManager
	 * @param itemModel
	 */
	void processHandledItem(MenuManager parentManager,
			MHandledMenuItem itemModel) {
		final IEclipseContext lclContext = getContext(itemModel);
		HandledContributionItem ci = ContextInjectionFactory.make(
				HandledContributionItem.class, lclContext);
		ci.setModel(itemModel);
		ci.setVisible(itemModel.isVisible());
		parentManager.add(ci);
		modelToContribution.put(itemModel, ci);
	}

	private String getText(MMenu menuModel) {
		String text = menuModel.getLabel();
		if (text == null || text.length() == 0) {
			return NO_LABEL;
		}
		return text;
	}

	private ImageDescriptor getImageDescriptor(MUILabel element) {
		IEclipseContext localContext = context;
		String iconURI = element.getIconURI();
		if (iconURI != null && iconURI.length() > 0) {
			ISWTResourceUtilities resUtils = (ISWTResourceUtilities) localContext
					.get(IResourceUtilities.class.getName());
			return resUtils.imageDescriptorFromURI(URI.createURI(iconURI));
		}
		return null;
	}

	public MenuManager getManager(MMenu model) {
		return modelToManager.get(model);
	}

	public MMenu getMenuModel(MenuManager manager) {
		return managerToModel.get(manager);
	}

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




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

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import org.eclipse.e4.ui.internal.workbench.ExtensionPointProxy;
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.MMenuElement;
import org.eclipse.e4.ui.model.application.ui.menu.MRenderedMenuItem;
import org.eclipse.jface.action.ContributionItem;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Widget;

/**
 * Create a contribute part.
 */
public class RenderedMenuItemRenderer extends SWTPartRenderer {

	private static Method aboutToShow;

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

	private Map<IContributionItem, List<MenuRecord>> map = new WeakHashMap<IContributionItem, List<MenuRecord>>();

	public Object createWidget(final MUIElement element, Object parent) {
		if (!(element instanceof MRenderedMenuItem)
				|| !(parent instanceof Menu)) {
			return null;
		}

		MRenderedMenuItem menuModel = (MRenderedMenuItem) element;
		Object contribution = menuModel.getContributionItem();
		if (contribution instanceof ExtensionPointProxy) {
			ExtensionPointProxy proxy = (ExtensionPointProxy) contribution;
			Object delegate = proxy.createDelegate(menuModel);
			if (delegate != null) {
				proxy.setField("dirty", Boolean.TRUE); //$NON-NLS-1$
				return fill((IContributionItem) delegate, (Menu) parent);
			}
		} else if (contribution instanceof IContributionItem) {
			return fill((IContributionItem) contribution, (Menu) parent);
		}
		return null;
	}

	private Object fill(IContributionItem item, Menu menu) {
		ContributionItem contribution = (ContributionItem) item;
		MenuManager manager = (MenuManager) contribution.getParent();
		try {
			if (manager == null) {
				manager = new MenuManager();
				manager.add(contribution);
			}
			getAboutToShow().invoke(manager, new Object[0]);
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		}

		int itemCount = menu.getItemCount();
		List<MenuRecord> list = map.get(item);
		if (list != null) {
			for (int i = 0; i < list.size(); i++) {
				MenuRecord record = list.get(i);
				Menu storedMenu = record.getMenu();
				if (storedMenu.isDisposed()) {
					list.remove(i);
					i--;
				} else if (storedMenu == menu) {
					record.dispose();
					itemCount = menu.getItemCount();
					list.remove(i);
					break;
				}
			}
		}

		item.fill(menu, itemCount);
		int endIndex = menu.getItemCount();

		if (list == null) {
			if (itemCount != endIndex) {
				list = new ArrayList<MenuRecord>();
				MenuRecord record = new MenuRecord(menu);
				for (int i = itemCount; i < endIndex; i++) {
					record.addItem(menu.getItem(i));
				}
				list.add(record);
				map.put(item, list);
			}
		} else {
			for (int i = 0; i < list.size(); i++) {
				MenuRecord record = list.get(i);
				if (record.getMenu() == menu) {
					list.remove(i);
					record = new MenuRecord(menu);
					for (int j = itemCount; j < endIndex; j++) {
						record.addItem(menu.getItem(j));
					}
					list.add(record);
					return null;
				}
			}

			MenuRecord record = new MenuRecord(menu);
			for (int i = itemCount; i < endIndex; i++) {
				record.addItem(menu.getItem(i));
			}
			list.add(record);
			map.put(item, list);
		}
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#unbindWidget
	 * (org.eclipse.e4.ui.model.application.ui.MUIElement)
	 */
	@Override
	public Object unbindWidget(MUIElement me) {
		MRenderedMenuItem item = (MRenderedMenuItem) me;
		Object contributionItem = item.getContributionItem();
		if (contributionItem instanceof ExtensionPointProxy) {
			ExtensionPointProxy proxy = (ExtensionPointProxy) contributionItem;
			Object delegate = proxy.getDelegate();
			if (delegate instanceof IContributionItem) {
				((IContributionItem) delegate).dispose();
			}
		} else if (contributionItem instanceof IContributionItem) {
			((IContributionItem) contributionItem).dispose();
		}
		return super.unbindWidget(me);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#hideChild
	 * (org.eclipse.e4.ui.model.application.MElementContainer,
	 * org.eclipse.e4.ui.model.application.MUIElement)
	 */
	@Override
	public void hideChild(MElementContainer<MUIElement> parentElement,
			MUIElement child) {
		super.hideChild(parentElement, child);

		// Since there's no place to 'store' a child that's not in a menu
		// we'll blow it away and re-create on an add
		Widget widget = (Widget) child.getWidget();
		if (widget != null && !widget.isDisposed())
			widget.dispose();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.AbstractPartRenderer#getUIContainer
	 * (org.eclipse.e4.ui.model.application.MUIElement)
	 */
	@Override
	public Object getUIContainer(MUIElement element) {
		if (!(element instanceof MMenuElement))
			return null;

		if (element.getParent().getWidget() instanceof MenuItem) {
			MenuItem mi = (MenuItem) element.getParent().getWidget();
			if (mi.getMenu() == null) {
				mi.setMenu(new Menu(mi));
			}
			return mi.getMenu();
		}

		return super.getUIContainer(element);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#processContents
	 * (org.eclipse.e4.ui.model.application.ui.MElementContainer)
	 */
	@Override
	public void processContents(MElementContainer<MUIElement> container) {
		// We've delegated further rendering to the ContributionManager
		// it's their fault the menu items don't show up!
	}

	class MenuRecord {

		private Menu menu;
		private List<MenuItem> items = new ArrayList<MenuItem>();

		public MenuRecord(Menu menu) {
			this.menu = menu;
		}

		public Menu getMenu() {
			return menu;
		}

		public void addItem(MenuItem item) {
			items.add(item);
		}

		public void dispose() {
			for (MenuItem item : items) {
				item.dispose();
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009, 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 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.MWindow;
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.MRenderedMenu;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.jface.action.IMenuCreator;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Decorations;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Widget;

/**
 * Create a contribute part.
 */
public class RenderedMenuRenderer extends SWTPartRenderer {

	public Object createWidget(final MUIElement element, Object parent) {
		if (!(element instanceof MRenderedMenu))
			return null;

		MRenderedMenu menuModel = (MRenderedMenu) element;
		Object contributionManager = menuModel.getContributionManager();
		if (contributionManager instanceof MenuManager) {
			Menu newMenu = null;
			MenuManager mm = (MenuManager) contributionManager;
			MUIElement container = (MUIElement) ((EObject) menuModel)
					.eContainer();
			if (parent instanceof Decorations && container instanceof MWindow) {
				newMenu = mm.createMenuBar((Decorations) parent);
			} else if (parent instanceof Menu) {
				mm.update(true);
				newMenu = mm.getMenu();
			} else {
				newMenu = mm.createContextMenu((Control) parent);
			}
			mm.update(true);
			return newMenu;
		} else if (contributionManager instanceof IMenuCreator) {
			final IMenuCreator creator = (IMenuCreator) contributionManager;
			if (parent instanceof Control) {
				Control control = (Control) parent;
				return creator.getMenu(control);
			} else if (parent instanceof Menu) {
				int addIndex = calcVisibleIndex(menuModel);
				MenuItem newItem = new MenuItem((Menu) parent, SWT.CASCADE,
						addIndex);
				setItemText(menuModel, newItem);
				newItem.setImage(getImage(menuModel));
				newItem.setEnabled(menuModel.isEnabled());
				Menu menu = (Menu) parent;
				newItem.setMenu(creator.getMenu(menu));
				return newItem;
			}
		}

		return null;
	}

	private void setItemText(MMenu model, MenuItem item) {
		String text = model.getLabel();
		if (text == null) {
			text = ""; //$NON-NLS-1$
		}
		item.setText(text);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#hideChild
	 * (org.eclipse.e4.ui.model.application.MElementContainer,
	 * org.eclipse.e4.ui.model.application.MUIElement)
	 */
	@Override
	public void hideChild(MElementContainer<MUIElement> parentElement,
			MUIElement child) {
		super.hideChild(parentElement, child);

		// Since there's no place to 'store' a child that's not in a menu
		// we'll blow it away and re-create on an add
		Widget widget = (Widget) child.getWidget();
		if (widget != null && !widget.isDisposed())
			widget.dispose();
	}

	@Override
	public Object unbindWidget(MUIElement me) {
		MRenderedMenu menuModel = (MRenderedMenu) me;
		Object contributionManager = menuModel.getContributionManager();
		if (contributionManager instanceof IMenuManager) {
			((IMenuManager) contributionManager).dispose();
		}
		return super.unbindWidget(me);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.AbstractPartRenderer#getUIContainer
	 * (org.eclipse.e4.ui.model.application.MUIElement)
	 */
	@Override
	public Object getUIContainer(MUIElement element) {
		if (!(element instanceof MMenuElement))
			return null;

		if (element.getParent().getWidget() instanceof MenuItem) {
			MenuItem mi = (MenuItem) element.getParent().getWidget();
			if (mi.getMenu() == null) {
				mi.setMenu(new Menu(mi));
			}
			return mi.getMenu();
		}

		return super.getUIContainer(element);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#processContents
	 * (org.eclipse.e4.ui.model.application.ui.MElementContainer)
	 */
	@Override
	public void processContents(MElementContainer<MUIElement> container) {
		// We've delegated further rendering to the ContributionManager
		// it's their fault the menu items don't show up!
	}
}




/*******************************************************************************
 * Copyright (c) 2009, 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.util.ArrayList;
import java.util.HashMap;
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.MApplication;
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.MRenderedToolBar;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBar;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBarContribution;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBarElement;
import org.eclipse.e4.ui.workbench.IPresentationEngine;
import org.eclipse.e4.ui.workbench.modeling.ExpressionContext;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;
import org.eclipse.swt.widgets.Widget;

/**
 * Create a contribute part.
 */
public class RenderedToolBarRenderer extends SWTPartRenderer {

	public static final String TAG_VIEW_MENU = "ViewMenu"; //$NON-NLS-1$

	private MApplication application;

	@Inject
	IPresentationEngine renderer;

	HashMap<MToolBar, ArrayList<ArrayList<MToolBarElement>>> pendingCleanup = new HashMap<MToolBar, ArrayList<ArrayList<MToolBarElement>>>();

	private Image viewMenuImage;

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#init(org.eclipse
	 * .e4.core.contexts.IEclipseContext)
	 */
	@Override
	public void init(IEclipseContext context) {
		super.init(context);
		application = context.get(MApplication.class);
	}

	public Object createWidget(final MUIElement element, Object parent) {
		if (!(element instanceof MRenderedToolBar)
				|| !(parent instanceof Composite))
			return null;

		final MRenderedToolBar toolBar = (MRenderedToolBar) element;
		if (!(toolBar.getContributionManager() instanceof ToolBarManager)) {
			return null;
		}

		ToolBarManager tbm = (ToolBarManager) toolBar.getContributionManager();
		ToolBar tb = tbm.createControl((Composite) parent);
		if (tb.getParent() != parent) {
			tb.setParent((Composite) parent);
			tb.setVisible(true);
		}

		tbm.update(true);
		tb.setData(ToolBarManager.class.getName(), tbm);
		tb.addDisposeListener(new DisposeListener() {
			public void widgetDisposed(DisposeEvent e) {
				cleanUp(toolBar);
			}
		});

		tb.getParent().layout(true);

		return tb;
	}

	/**
	 * @param toolBar
	 */
	protected void cleanUp(MRenderedToolBar element) {
		ArrayList<ArrayList<MToolBarElement>> lists = pendingCleanup
				.remove(element);
		if (lists == null) {
			return;
		}
		for (ArrayList<MToolBarElement> list : lists) {
			for (MToolBarElement child : list) {
				element.getChildren().remove(child);
			}
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#hideChild
	 * (org.eclipse.e4.ui.model.application.MElementContainer,
	 * org.eclipse.e4.ui.model.application.MUIElement)
	 */
	@Override
	public void hideChild(MElementContainer<MUIElement> parentElement,
			MUIElement child) {
		super.hideChild(parentElement, child);

		// Since there's no place to 'store' a child that's not in a menu
		// we'll blow it away and re-create on an add
		Widget widget = (Widget) child.getWidget();
		if (widget != null && !widget.isDisposed())
			widget.dispose();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#processContents
	 * (org.eclipse.e4.ui.model.application.ui.MElementContainer)
	 */
	@Override
	public void processContents(MElementContainer<MUIElement> container) {
		// We've delegated further rendering to the ContributionManager
		// it's their fault the menu items don't show up!
		IEclipseContext ctx = getContext(container);
		ExpressionContext eContext = new ExpressionContext(ctx);
		ArrayList<MToolBarContribution> toContribute = new ArrayList<MToolBarContribution>();
		MElementContainer<?> toolbarObj = container;
		MToolBar toolbarModel = (MToolBar) toolbarObj;
		ContributionsAnalyzer.gatherToolBarContributions(toolbarModel,
				application.getToolBarContributions(),
				toolbarModel.getElementId(), toContribute, eContext);
		ToolBarRenderer.addToolBarContributions(toolbarModel, toContribute,
				ctx, eContext, pendingCleanup);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#postProcess
	 * (org.eclipse.e4.ui.model.application.ui.MUIElement)
	 */
	@Override
	public void postProcess(MUIElement element) {
		ToolBar tb = (ToolBar) element.getWidget();
		if (((EObject) element).eContainer() instanceof MPart) {
			MPart part = (MPart) ((EObject) element).eContainer();
			MMenu viewMenu = getViewMenu(part);

			// View menu (if any)
			if (viewMenu != null) {
				addMenuButton(part, tb, viewMenu);
			}
		}

		tb.pack();
		tb.setVisible(true);
		super.postProcess(element);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#disposeWidget
	 * (org.eclipse.e4.ui.model.application.ui.MUIElement)
	 */
	@Override
	public void disposeWidget(MUIElement element) {
		ToolBar tb = (ToolBar) element.getWidget();
		tb.setVisible(false);
		unbindWidget(element);
		tb.setData(AbstractPartRenderer.OWNING_ME, element);
	}

	/**
	 * @param tb
	 */
	private void addMenuButton(MPart part, ToolBar tb, MMenu menu) {
		ToolItem ti = new ToolItem(tb, SWT.PUSH);
		ti.setImage(getViewMenuImage());
		ti.setHotImage(null);
		ti.setToolTipText("View Menu"); //$NON-NLS-1$
		ti.setData("theMenu", menu); //$NON-NLS-1$
		ti.setData("thePart", part); //$NON-NLS-1$

		ti.addSelectionListener(new SelectionListener() {
			public void widgetSelected(SelectionEvent e) {
				showMenu((ToolItem) e.widget);
			}

			public void widgetDefaultSelected(SelectionEvent e) {
				showMenu((ToolItem) e.widget);
			}
		});
	}

	/**
	 * @param item
	 */
	protected void showMenu(ToolItem item) {
		// Create the UI for the menu
		final MMenu menuModel = (MMenu) item.getData("theMenu"); //$NON-NLS-1$
		MPart part = (MPart) item.getData("thePart"); //$NON-NLS-1$
		Control ctrl = (Control) part.getWidget();
		Menu menu = (Menu) renderer.createGui(menuModel, ctrl.getShell(),
				part.getContext());

		// ...and Show it...
		Rectangle ib = item.getBounds();
		Point displayAt = item.getParent().toDisplay(ib.x, ib.y + ib.height);
		menu.setLocation(displayAt);
		menu.setVisible(true);

		Display display = Display.getCurrent();
		while (!menu.isDisposed() && menu.isVisible()) {
			if (!display.readAndDispatch())
				display.sleep();
		}
		menu.dispose();
	}

	private Image getViewMenuImage() {
		if (viewMenuImage == null) {
			Display d = Display.getCurrent();

			Image viewMenu = new Image(d, 16, 16);
			Image viewMenuMask = new Image(d, 16, 16);

			Display display = Display.getCurrent();
			GC gc = new GC(viewMenu);
			GC maskgc = new GC(viewMenuMask);
			gc.setForeground(display
					.getSystemColor(SWT.COLOR_WIDGET_DARK_SHADOW));
			gc.setBackground(display.getSystemColor(SWT.COLOR_LIST_BACKGROUND));

			int[] shapeArray = new int[] { 6, 1, 15, 1, 11, 5, 10, 5 };
			gc.fillPolygon(shapeArray);
			gc.drawPolygon(shapeArray);

			Color black = display.getSystemColor(SWT.COLOR_BLACK);
			Color white = display.getSystemColor(SWT.COLOR_WHITE);

			maskgc.setBackground(black);
			maskgc.fillRectangle(0, 0, 16, 16);

			maskgc.setBackground(white);
			maskgc.setForeground(white);
			maskgc.fillPolygon(shapeArray);
			maskgc.drawPolygon(shapeArray);
			gc.dispose();
			maskgc.dispose();

			ImageData data = viewMenu.getImageData();
			data.transparentPixel = data.getPixel(0, 0);

			viewMenuImage = new Image(d, viewMenu.getImageData(),
					viewMenuMask.getImageData());
			viewMenu.dispose();
			viewMenuMask.dispose();
		}
		return viewMenuImage;
	}

	private MMenu getViewMenu(MPart part) {
		if (part.getMenus() == null) {
			return null;
		}
		for (MMenu menu : part.getMenus()) {
			if (menu.getTags().contains(TAG_VIEW_MENU)) {
				return menu;
			}
		}
		return null;
	}
}




import org.eclipse.e4.ui.model.application.ui.basic.MStackElement;
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.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.services.IStylingEngine;

				if (!curTB.isDisposed()) {
					MUIElement tbME = (MUIElement) curTB
							.getData(AbstractPartRenderer.OWNING_ME);
					if (tbME instanceof MRenderedToolBar)
						renderer.removeGui(tbME);
					else
						curTB.dispose();

			if (!curTB.isDisposed()) {
				MUIElement tbME = (MUIElement) curTB
						.getData(AbstractPartRenderer.OWNING_ME);
				if (tbME instanceof MRenderedToolBar)
					renderer.removeGui(tbME);
				else
					curTB.dispose();




/*******************************************************************************
 * Copyright (c) 2009 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.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import org.eclipse.e4.core.contexts.ContextInjectionFactory;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.contexts.RunAndTrack;
import org.eclipse.e4.core.services.events.IEventBroker;
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.MElementContainer;
import org.eclipse.e4.ui.model.application.ui.MUIElement;
import org.eclipse.e4.ui.model.application.ui.SideValue;
import org.eclipse.e4.ui.model.application.ui.basic.MPart;
import org.eclipse.e4.ui.model.application.ui.basic.MTrimBar;
import org.eclipse.e4.ui.model.application.ui.menu.MDirectToolItem;
import org.eclipse.e4.ui.model.application.ui.menu.MHandledToolItem;
import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBar;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBarContribution;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBarElement;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBarSeparator;
import org.eclipse.e4.ui.model.application.ui.menu.MToolControl;
import org.eclipse.e4.ui.workbench.IPresentationEngine;
import org.eclipse.e4.ui.workbench.UIEvents;
import org.eclipse.e4.ui.workbench.modeling.EModelService;
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.Separator;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.layout.RowLayoutFactory;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;
import org.eclipse.swt.widgets.Widget;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventHandler;

/**
 * Create a contribute part.
 */
public class ToolBarManagerRenderer extends SWTPartRenderer {

	private Map<MToolBar, ToolBarManager> modelToManager = new HashMap<MToolBar, ToolBarManager>();
	private Map<ToolBarManager, MToolBar> managerToModel = new HashMap<ToolBarManager, MToolBar>();

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

	private ArrayList<ContributionRecord> contributionRecords = new ArrayList<ContributionRecord>();

	// @Inject
	// private Logger logger;

	@Inject
	IPresentationEngine renderer;
	@Inject
	private MApplication application;
	@Inject
	private EModelService modelService;

	@Inject
	IEventBroker eventBroker;
	private EventHandler itemUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MMenuItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MToolBarElement))
				return;

			MToolBarElement itemModel = (MToolBarElement) event
					.getProperty(UIEvents.EventTags.ELEMENT);

			IContributionItem ici = getContribution(itemModel);
			if (ici == null) {
				return;
			}

			String attName = (String) event
					.getProperty(UIEvents.EventTags.ATTNAME);
			if (UIEvents.UILabel.LABEL.equals(attName)) {
				ici.update();
			} else if (UIEvents.UILabel.ICONURI.equals(attName)) {
				ici.update();
			} else if (UIEvents.UILabel.TOOLTIP.equals(attName)) {
				ici.update();
			}
		}
	};

	private EventHandler toBeRenderedUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MMenuItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MToolBarElement))
				return;

			MToolBarElement itemModel = (MToolBarElement) event
					.getProperty(UIEvents.EventTags.ELEMENT);
			String attName = (String) event
					.getProperty(UIEvents.EventTags.ATTNAME);
			if (UIEvents.UIElement.TOBERENDERED.equals(attName)) {
				Object obj = itemModel.getParent();
				if (!(obj instanceof MToolBar)) {
					return;
				}
				ToolBarManager parent = getManager((MToolBar) obj);
				if (itemModel.isToBeRendered()) {
					if (parent != null) {
						modelProcessSwitch(parent, itemModel);
						parent.update(true);
						ToolBar tb = parent.getControl();
						if (tb != null && !tb.isDisposed()) {
							tb.getShell().layout(new Control[] { tb },
									SWT.DEFER);
						}
					}
				} else {
					IContributionItem ici = modelToContribution
							.remove(itemModel);
					if (ici != null && parent != null) {
						parent.remove(ici);
					}
					if (ici != null) {
						ici.dispose();
					}
				}
			} else if (UIEvents.UIElement.VISIBLE.equals(attName)) {
				IContributionItem ici = getContribution(itemModel);
				if (ici == null) {
					return;
				}
				ici.setVisible(itemModel.isVisible());
				ToolBarManager parent = (ToolBarManager) ((ContributionItem) ici)
						.getParent();
				if (parent != null) {
					parent.markDirty();
					ToolBar tb = parent.getControl();
					if (tb != null && !tb.isDisposed()) {
						tb.getShell().layout(new Control[] { tb }, SWT.DEFER);
					}
				}
			}
		}
	};

	private EventHandler selectionUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MToolItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MToolBarElement))
				return;

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

	private EventHandler enabledUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MMenuItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MToolBarElement))
				return;

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

	@PostConstruct
	public void init() {
		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UILabel.TOPIC),
				itemUpdater);
		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
				UIEvents.Item.SELECTED), selectionUpdater);
		eventBroker
				.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
						UIEvents.Item.ENABLED), enabledUpdater);
		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UIElement.TOPIC,
				UIEvents.UIElement.TOBERENDERED), toBeRenderedUpdater);

	}

	@PreDestroy
	public void contextDisposed() {
		eventBroker.unsubscribe(itemUpdater);
		eventBroker.unsubscribe(selectionUpdater);
		eventBroker.unsubscribe(enabledUpdater);
		eventBroker.unsubscribe(toBeRenderedUpdater);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#createWidget
	 * (org.eclipse.e4.ui.model.application.ui.MUIElement, java.lang.Object)
	 */
	@Override
	public Object createWidget(final MUIElement element, Object parent) {
		if (!(element instanceof MToolBar) || !(parent instanceof Composite))
			return null;

		// HACK!! This should be done using a separate renderer
		Composite intermediate = new Composite((Composite) parent, SWT.NONE);
		createToolbar(element, intermediate);
		processContribution((MToolBar) element);

		return intermediate;
	}

	/**
	 * @param element
	 */
	private void processContribution(MToolBar toolbarModel) {
		final ArrayList<MToolBarContribution> toContribute = new ArrayList<MToolBarContribution>();
		ContributionsAnalyzer.XXXgatherToolBarContributions(toolbarModel,
				application.getToolBarContributions(),
				toolbarModel.getElementId(), toContribute);
		generateContributions(toolbarModel, toContribute);
	}

	/**
	 * @param toolbarModel
	 * @param toContribute
	 */
	private void generateContributions(MToolBar toolbarModel,
			ArrayList<MToolBarContribution> toContribute) {
		HashSet<String> existingSeparatorNames = new HashSet<String>();
		for (MToolBarElement child : toolbarModel.getChildren()) {
			String elementId = child.getElementId();
			if (child instanceof MToolBarSeparator && elementId != null) {
				existingSeparatorNames.add(elementId);
			}
		}

		ToolBarManager manager = getManager(toolbarModel);
		boolean done = toContribute.size() == 0;
		while (!done) {
			ArrayList<MToolBarContribution> curList = new ArrayList<MToolBarContribution>(
					toContribute);
			int retryCount = toContribute.size();
			toContribute.clear();

			for (final MToolBarContribution contribution : curList) {
				if (!processAddition(toolbarModel, manager, contribution,
						existingSeparatorNames)) {
					toContribute.add(contribution);
				}
			}
			// We're done if the retryList is now empty (everything done) or
			// if the list hasn't changed at all (no hope)
			done = (toContribute.size() == 0)
					|| (toContribute.size() == retryCount);
		}
	}

	static class ContributionRecord {
		public ContributionRecord(MToolBar toolbarModel,
				MToolBarContribution contribution, ToolBarManager manager) {
			this.toolbarModel = toolbarModel;
			this.contribution = contribution;
			this.manager = manager;
		}

		MToolBar toolbarModel;
		MToolBarContribution contribution;
		ToolBarManager manager;
		ArrayList<MToolBarElement> generatedElements = new ArrayList<MToolBarElement>();

		public void generate() {
			for (MToolBarElement element : contribution.getChildren()) {
				MToolBarElement copy = (MToolBarElement) EcoreUtil
						.copy((EObject) element);
				generatedElements.add(copy);
			}
		}

		public void updateVisibility(IEclipseContext context) {
			ExpressionContext exprContext = new ExpressionContext(context);
			boolean isVisible = ContributionsAnalyzer.isVisible(contribution,
					exprContext);
			for (MToolBarElement item : generatedElements) {
				item.setVisible(isVisible);
			}
			manager.markDirty();
		}

		public void dispose() {
			for (MToolBarElement copy : generatedElements) {
				toolbarModel.getChildren().remove(copy);
			}
		}
	}

	/**
	 * @param toolbarModel
	 * @param manager
	 * @param contribution
	 * @param existingSeparatorNames
	 * @return <code>true</code> if the contribution was successfuly processed
	 */
	private boolean processAddition(MToolBar toolbarModel,
			final ToolBarManager manager, MToolBarContribution contribution,
			HashSet<String> existingSeparatorNames) {
		int idx = getIndex(toolbarModel, contribution.getPositionInParent());
		if (idx == -1) {
			return false;
		}
		final ContributionRecord record = new ContributionRecord(toolbarModel,
				contribution, manager);
		contributionRecords.add(record);
		record.generate();
		for (MToolBarElement copy : record.generatedElements) {
			if (copy instanceof MToolBarSeparator
					&& existingSeparatorNames.contains(copy.getElementId())) {
				// skip this, it's already there
				continue;
			}
			toolbarModel.getChildren().add(idx++, copy);
			if (copy instanceof MToolBarSeparator
					&& copy.getElementId() != null) {
				existingSeparatorNames.add(copy.getElementId());
			}
		}
		if (contribution.getVisibleWhen() != null) {
			final IEclipseContext parentContext = modelService
					.getContainingContext(toolbarModel);
			parentContext.runAndTrack(new RunAndTrack() {
				@Override
				public boolean changed(IEclipseContext context) {
					record.updateVisibility(parentContext.getActiveLeaf());
					manager.update(false);
					return true;
				}
			});
		}

		return true;
	}

	private static int getIndex(MElementContainer<?> menuModel,
			String positionInParent) {
		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) {
			return menuModel.getChildren().size();
		}

		int idx = 0;
		int size = menuModel.getChildren().size();
		while (idx < size) {
			if (id.equals(menuModel.getChildren().get(idx).getElementId())) {
				if ("after".equals(modifier)) { //$NON-NLS-1$
					idx++;
				}
				return idx;
			}
			idx++;
		}
		return id.equals("additions") ? menuModel.getChildren().size() : -1; //$NON-NLS-1$
	}

	private ToolBar createToolbar(final MUIElement element,
			Composite intermediate) {
		int orientation = getOrientation(element);
		RowLayout layout = RowLayoutFactory.fillDefaults().wrap(false)
				.spacing(0).type(orientation).create();
		layout.marginLeft = 3;
		layout.center = true;
		intermediate.setLayout(layout);
		// new Label(intermediate, (orientation == SWT.HORIZONTAL ? SWT.VERTICAL
		// : SWT.HORIZONTAL) | SWT.SEPARATOR);

		ToolBar separatorToolBar = new ToolBar(intermediate, orientation
				| SWT.WRAP | SWT.FLAT | SWT.RIGHT);
		new ToolItem(separatorToolBar, SWT.SEPARATOR);
		ToolBarManager manager = getManager((MToolBar) element);
		if (manager == null) {
			manager = new ToolBarManager(orientation | SWT.WRAP | SWT.FLAT
					| SWT.RIGHT);
			linkModelToManager((MToolBar) element, manager);
		}
		ToolBar bar = manager.createControl(intermediate);
		bar.setData(manager);
		bar.getShell().layout(new Control[] { bar }, SWT.DEFER);
		bar.addDisposeListener(new DisposeListener() {
			public void widgetDisposed(DisposeEvent e) {
				cleanUp((MToolBar) element);
			}
		});
		return bar;
	}

	/**
	 * @param element
	 */
	protected void cleanUp(MToolBar toolbarModel) {
		for (ContributionRecord record : contributionRecords
				.toArray(new ContributionRecord[contributionRecords.size()])) {
			if (record.toolbarModel == toolbarModel) {
				record.dispose();
				contributionRecords.remove(record);
				for (MToolBarElement copy : record.generatedElements) {
					IContributionItem ici = modelToContribution.remove(copy);
					if (ici != null) {
						record.manager.remove(ici);
					}
				}
				record.generatedElements.clear();
			}
		}
	}

	int getOrientation(final MUIElement element) {
		MUIElement theParent = element.getParent();
		if (theParent instanceof MTrimBar) {
			MTrimBar trimContainer = (MTrimBar) theParent;
			SideValue side = trimContainer.getSide();
			if (side.getValue() == SideValue.LEFT_VALUE
					|| side.getValue() == SideValue.RIGHT_VALUE)
				return SWT.VERTICAL;
		}
		return SWT.HORIZONTAL;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#processContents
	 * (org.eclipse.e4.ui.model.application.ui.MElementContainer)
	 */
	@Override
	public void processContents(MElementContainer<MUIElement> container) {
		// I can either simply stop processing, or we can walk the model
		// ourselves like the "old" days
		// EMF gives us null lists if empty
		if (container == null)
			return;

		Object obj = container;
		ToolBarManager parentManager = getManager((MToolBar) obj);
		if (parentManager == null) {
			return;
		}
		// Process any contents of the newly created ME
		List<MUIElement> parts = container.getChildren();
		if (parts != null) {
			MUIElement[] plist = parts.toArray(new MUIElement[parts.size()]);
			for (int i = 0; i < plist.length; i++) {
				MUIElement childME = plist[i];
				modelProcessSwitch(parentManager, (MToolBarElement) childME);
			}
		}
		parentManager.update(false);

		ToolBar tb = getToolbarFrom(container.getWidget());
		if (tb != null && ((EObject) container).eContainer() instanceof MPart) {
			MPart part = (MPart) ((EObject) container).eContainer();
			MMenu viewMenu = getViewMenu(part);

			// View menu (if any)
			if (viewMenu != null) {
				addMenuButton(part, tb, viewMenu);
			}
			tb.getShell().layout(new Control[] { tb }, SWT.DEFER);
		}
	}

	/**
	 * @param widget
	 * @return
	 */
	private ToolBar getToolbarFrom(Object widget) {
		if (widget instanceof ToolBar) {
			return (ToolBar) widget;
		}
		if (widget instanceof Composite) {
			Composite intermediate = (Composite) widget;
			if (!intermediate.isDisposed()) {
				Control[] children = intermediate.getChildren();
				int length = children.length;
				if (length > 0 && children[length - 1] instanceof ToolBar) {
					return (ToolBar) children[length - 1];
				}
			}
		}
		return null;
	}

	/**
	 * @param tb
	 */
	private void addMenuButton(MPart part, ToolBar tb, MMenu menu) {
		ToolItem ti = new ToolItem(tb, SWT.PUSH);
		ti.setImage(getViewMenuImage());
		ti.setHotImage(null);
		ti.setToolTipText("View Menu"); //$NON-NLS-1$
		ti.setData("theMenu", menu); //$NON-NLS-1$
		ti.setData("thePart", part); //$NON-NLS-1$

		ti.addSelectionListener(new SelectionListener() {
			public void widgetSelected(SelectionEvent e) {
				showMenu((ToolItem) e.widget);
			}

			public void widgetDefaultSelected(SelectionEvent e) {
				showMenu((ToolItem) e.widget);
			}
		});
	}

	/**
	 * @param item
	 */
	protected void showMenu(ToolItem item) {
		// Create the UI for the menu
		final MMenu menuModel = (MMenu) item.getData("theMenu"); //$NON-NLS-1$
		MPart part = (MPart) item.getData("thePart"); //$NON-NLS-1$
		Control ctrl = (Control) part.getWidget();
		Menu menu = (Menu) renderer.createGui(menuModel, ctrl.getShell(),
				part.getContext());

		// ...and Show it...
		Rectangle ib = item.getBounds();
		Point displayAt = item.getParent().toDisplay(ib.x, ib.y + ib.height);
		menu.setLocation(displayAt);
		menu.setVisible(true);

		Display display = Display.getCurrent();
		while (!menu.isDisposed() && menu.isVisible()) {
			if (!display.readAndDispatch())
				display.sleep();
		}
		menu.dispose();
	}

	private Image getViewMenuImage() {
		if (viewMenuImage == null) {
			Display d = Display.getCurrent();

			Image viewMenu = new Image(d, 16, 16);
			Image viewMenuMask = new Image(d, 16, 16);

			Display display = Display.getCurrent();
			GC gc = new GC(viewMenu);
			GC maskgc = new GC(viewMenuMask);
			gc.setForeground(display
					.getSystemColor(SWT.COLOR_WIDGET_DARK_SHADOW));
			gc.setBackground(display.getSystemColor(SWT.COLOR_LIST_BACKGROUND));

			int[] shapeArray = new int[] { 6, 1, 15, 1, 11, 5, 10, 5 };
			gc.fillPolygon(shapeArray);
			gc.drawPolygon(shapeArray);

			Color black = display.getSystemColor(SWT.COLOR_BLACK);
			Color white = display.getSystemColor(SWT.COLOR_WHITE);

			maskgc.setBackground(black);
			maskgc.fillRectangle(0, 0, 16, 16);

			maskgc.setBackground(white);
			maskgc.setForeground(white);
			maskgc.fillPolygon(shapeArray);
			maskgc.drawPolygon(shapeArray);
			gc.dispose();
			maskgc.dispose();

			ImageData data = viewMenu.getImageData();
			data.transparentPixel = data.getPixel(0, 0);

			viewMenuImage = new Image(d, viewMenu.getImageData(),
					viewMenuMask.getImageData());
			viewMenu.dispose();
			viewMenuMask.dispose();
		}
		return viewMenuImage;
	}

	private MMenu getViewMenu(MPart part) {
		if (part.getMenus() == null) {
			return null;
		}
		for (MMenu menu : part.getMenus()) {
			if (menu.getTags().contains(StackRenderer.TAG_VIEW_MENU)) {
				return menu;
			}
		}
		return null;
	}

	boolean hasOnlySeparators(ToolBar toolbar) {
		ToolItem[] children = toolbar.getItems();
		for (ToolItem toolItem : children) {
			if ((toolItem.getStyle() & SWT.SEPARATOR) == 0) {
				return false;
			} else if (toolItem.getControl() != null
					&& toolItem.getControl().getData(OWNING_ME) instanceof MToolControl) {
				return false;
			}
		}
		return true;
	}

	@Override
	public void postProcess(MUIElement element) {
		super.postProcess(element);
		// disposeToolbarIfNecessary(element);
		ToolBar tb = getToolbarFrom(element.getWidget());
		if (tb != null && !tb.isDisposed()) {
			tb.getShell().layout(new Control[] { tb }, SWT.DEFER);
			tb.setVisible(true);
		}
	}

	public Object getUIContainer(MUIElement childElement) {
		if (childElement.getWidget() instanceof ToolBar) {
			return childElement.getWidget();
		}

		Object obj = super.getUIContainer(childElement);
		if (obj instanceof ToolBar) {
			return obj;
		}

		if (obj instanceof Composite) {
			Composite intermediate = (Composite) obj;
			if (intermediate == null || intermediate.isDisposed()) {
				return null;
			}
			ToolBar toolbar = getToolbarFrom(intermediate);
			if (toolbar == null) {
				toolbar = createToolbar(childElement.getParent(), intermediate);
			}
			return toolbar;
		}
		return null;
	}

	@Override
	public void disposeWidget(MUIElement element) {
		ToolBar tb = getToolbarFrom(element.getWidget());
		tb.setVisible(false);
		unbindWidget(element);
		tb.setData(AbstractPartRenderer.OWNING_ME, element);
	}

	@Override
	public void hideChild(MElementContainer<MUIElement> parentElement,
			MUIElement child) {
		super.hideChild(parentElement, child);

		// Since there's no place to 'store' a child that's not in a menu
		// we'll blow it away and re-create on an add
		Widget widget = (Widget) child.getWidget();
		if (widget != null && !widget.isDisposed()) {
			widget.dispose();
		}
		ToolBar toolbar = (ToolBar) getUIContainer(child);
		if (toolbar != null && !toolbar.isDisposed()) {
			toolbar.getShell().layout(new Control[] { toolbar }, SWT.DEFER);
		}
		// disposeToolbarIfNecessary(parentElement);
	}

	@Override
	public void childRendered(MElementContainer<MUIElement> parentElement,
			MUIElement element) {
		super.childRendered(parentElement, element);
		ToolBar toolbar = (ToolBar) getUIContainer(element);
		if (toolbar != null && !toolbar.isDisposed()) {
			toolbar.getShell().layout(new Control[] { toolbar }, SWT.DEFER);
		}
	}

	/**
	 * @param parentManager
	 * @param childME
	 */
	private void modelProcessSwitch(ToolBarManager parentManager,
			MToolBarElement childME) {
		if (childME instanceof MHandledToolItem) {
			MHandledToolItem itemModel = (MHandledToolItem) childME;
			processHandledItem(parentManager, itemModel);
		} else if (childME instanceof MDirectToolItem) {
			MDirectToolItem itemModel = (MDirectToolItem) childME;
			processDirectItem(parentManager, itemModel);
		} else if (childME instanceof MToolBarSeparator) {
			MToolBarSeparator itemModel = (MToolBarSeparator) childME;
			processSeparator(parentManager, itemModel);
		} else if (childME instanceof MToolControl) {
			MToolControl itemModel = (MToolControl) childME;
			processToolControl(parentManager, itemModel);
		}
	}

	/**
	 * @param parentManager
	 * @param itemModel
	 */
	private void processSeparator(ToolBarManager parentManager,
			MToolBarSeparator itemModel) {
		AbstractGroupMarker marker = null;
		if (itemModel.isVisible()) {
			marker = new Separator();
			marker.setId(itemModel.getElementId());
		} else {
			if (itemModel.getElementId() != null) {
				marker = new GroupMarker(itemModel.getElementId());
			}
		}
		parentManager.add(marker);
	}

	/**
	 * @param parentManager
	 * @param itemModel
	 */
	private void processToolControl(ToolBarManager parentManager,
			MToolControl itemModel) {
		final IEclipseContext lclContext = getContext(itemModel);
		ToolControlContribution ci = ContextInjectionFactory.make(
				ToolControlContribution.class, lclContext);
		ci.setModel(itemModel);
		parentManager.add(ci);
		modelToContribution.put(itemModel, ci);
	}

	/**
	 * @param parentManager
	 * @param itemModel
	 */
	private void processDirectItem(ToolBarManager parentManager,
			MDirectToolItem itemModel) {
		final IEclipseContext lclContext = getContext(itemModel);
		DirectContributionItem ci = ContextInjectionFactory.make(
				DirectContributionItem.class, lclContext);
		ci.setModel(itemModel);
		parentManager.add(ci);
		modelToContribution.put(itemModel, ci);
	}

	/**
	 * @param parentManager
	 * @param itemModel
	 */
	private void processHandledItem(ToolBarManager parentManager,
			MHandledToolItem itemModel) {
		final IEclipseContext lclContext = getContext(itemModel);
		HandledContributionItem ci = ContextInjectionFactory.make(
				HandledContributionItem.class, lclContext);
		ci.setModel(itemModel);
		parentManager.add(ci);
		modelToContribution.put(itemModel, ci);
	}

	public ToolBarManager getManager(MToolBar model) {
		return modelToManager.get(model);
	}

	public MToolBar getToolBarModel(ToolBarManager manager) {
		return managerToModel.get(manager);
	}

	public void linkModelToManager(MToolBar model, ToolBarManager manager) {
		modelToManager.put(model, manager);
		managerToModel.put(manager, model);
	}

	public void clearModelToManager(MToolBar model, ToolBarManager manager) {
		modelToManager.remove(model);
		managerToModel.remove(manager);
	}

	public IContributionItem getContribution(MToolBarElement element) {
		return modelToContribution.get(element);
	}
}




import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import org.eclipse.e4.core.contexts.ContextInjectionFactory;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.contexts.RunAndTrack;
import org.eclipse.e4.core.services.events.IEventBroker;
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.MElementContainer;
import org.eclipse.e4.ui.model.application.ui.MUIElement;
import org.eclipse.e4.ui.model.application.ui.SideValue;
import org.eclipse.e4.ui.model.application.ui.basic.MPart;
import org.eclipse.e4.ui.model.application.ui.basic.MTrimBar;
import org.eclipse.e4.ui.model.application.ui.menu.MDirectToolItem;
import org.eclipse.e4.ui.model.application.ui.menu.MHandledToolItem;
import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBar;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBarContribution;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBarElement;
import org.eclipse.e4.ui.model.application.ui.menu.MToolBarSeparator;
import org.eclipse.e4.ui.model.application.ui.menu.MToolControl;
import org.eclipse.e4.ui.workbench.IPresentationEngine;
import org.eclipse.e4.ui.workbench.UIEvents;
import org.eclipse.e4.ui.workbench.modeling.EModelService;
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.Separator;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.layout.RowLayoutFactory;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;
import org.eclipse.swt.widgets.Widget;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventHandler;

/**
 * Create a contribute part.
 */
public class ToolBarRenderer extends SWTPartRenderer {

	private Map<MToolBar, ToolBarManager> modelToManager = new HashMap<MToolBar, ToolBarManager>();
	private Map<ToolBarManager, MToolBar> managerToModel = new HashMap<ToolBarManager, MToolBar>();

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

	private ArrayList<ContributionRecord> contributionRecords = new ArrayList<ContributionRecord>();

	// @Inject
	// private Logger logger;

	@Inject
	IPresentationEngine renderer;
	@Inject
	private MApplication application;
	@Inject
	private EModelService modelService;

	@Inject
	IEventBroker eventBroker;
	private EventHandler itemUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MMenuItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MToolBarElement))
				return;

			MToolBarElement itemModel = (MToolBarElement) event
					.getProperty(UIEvents.EventTags.ELEMENT);

			IContributionItem ici = getContribution(itemModel);
			if (ici == null) {
				return;
			}

			String attName = (String) event
					.getProperty(UIEvents.EventTags.ATTNAME);
			if (UIEvents.UILabel.LABEL.equals(attName)) {
				ici.update();
			} else if (UIEvents.UILabel.ICONURI.equals(attName)) {
				ici.update();
			} else if (UIEvents.UILabel.TOOLTIP.equals(attName)) {
				ici.update();
			}
		}
	};

	private EventHandler toBeRenderedUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MMenuItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MToolBarElement))
				return;

			MToolBarElement itemModel = (MToolBarElement) event
					.getProperty(UIEvents.EventTags.ELEMENT);
			String attName = (String) event
					.getProperty(UIEvents.EventTags.ATTNAME);
			if (UIEvents.UIElement.TOBERENDERED.equals(attName)) {
				Object obj = itemModel.getParent();
				if (!(obj instanceof MToolBar)) {
					return;
				}
				ToolBarManager parent = getManager((MToolBar) obj);
				if (itemModel.isToBeRendered()) {
					if (parent != null) {
						modelProcessSwitch(parent, itemModel);
						parent.update(true);
						ToolBar tb = parent.getControl();
						if (tb != null && !tb.isDisposed()) {
							tb.getShell().layout(new Control[] { tb },
									SWT.DEFER);
						}
					}
				} else {
					IContributionItem ici = modelToContribution
							.remove(itemModel);
					if (ici != null && parent != null) {
						parent.remove(ici);
					}
					if (ici != null) {
						ici.dispose();
					}
				}
			} else if (UIEvents.UIElement.VISIBLE.equals(attName)) {
				IContributionItem ici = getContribution(itemModel);
				if (ici == null) {
					return;
				}
				ici.setVisible(itemModel.isVisible());
				ToolBarManager parent = (ToolBarManager) ((ContributionItem) ici)
						.getParent();
				if (parent != null) {
					parent.markDirty();
					ToolBar tb = parent.getControl();
					if (tb != null && !tb.isDisposed()) {
						tb.getShell().layout(new Control[] { tb }, SWT.DEFER);
					}
				}
			}
		}
	};

	private EventHandler selectionUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MToolItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MToolBarElement))
				return;

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

	private EventHandler enabledUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MMenuItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MToolBarElement))
				return;

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

	@PostConstruct
	public void init() {
		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UILabel.TOPIC),
				itemUpdater);
		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
				UIEvents.Item.SELECTED), selectionUpdater);
		eventBroker
				.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
						UIEvents.Item.ENABLED), enabledUpdater);
		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UIElement.TOPIC,
				UIEvents.UIElement.TOBERENDERED), toBeRenderedUpdater);

	}

	HashMap<MToolBar, ArrayList<ArrayList<MToolBarElement>>> pendingCleanup = new HashMap<MToolBar, ArrayList<ArrayList<MToolBarElement>>>();
	public void contextDisposed() {
		eventBroker.unsubscribe(itemUpdater);
		eventBroker.unsubscribe(selectionUpdater);
		eventBroker.unsubscribe(enabledUpdater);
		eventBroker.unsubscribe(toBeRenderedUpdater);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#init(org.eclipse
	 * .e4.core.contexts.IEclipseContext)
	 */
	@Override
	public void init(IEclipseContext context) {
		super.init(context);
		application = context.get(MApplication.class);
	}

	public Object createWidget(final MUIElement element, Object parent) {
		if (!(element instanceof MToolBar) || !(parent instanceof Composite))
			return null;

		// HACK!! This should be done using a separate renderer
		Composite intermediate = new Composite((Composite) parent, SWT.NONE);
		createToolbar(element, intermediate);
		intermediate.addDisposeListener(new DisposeListener() {
			public void widgetDisposed(DisposeEvent e) {
				cleanUp((MToolBar) element);
	}

	/**
	 * @param element
	 */
	private void processContribution(MToolBar toolbarModel) {
		final ArrayList<MToolBarContribution> toContribute = new ArrayList<MToolBarContribution>();
		ContributionsAnalyzer.gatherToolBarContributions(toolbarModel,
				application.getToolBarContributions(),
				toolbarModel.getElementId(), toContribute);
		generateContributions(toolbarModel, toContribute);
	}

	/**
	 * @param toolbarModel
	 * @param toContribute
	 */
	private void generateContributions(MToolBar toolbarModel,
			ArrayList<MToolBarContribution> toContribute) {
		HashSet<String> existingSeparatorNames = new HashSet<String>();
		for (MToolBarElement child : toolbarModel.getChildren()) {
			String elementId = child.getElementId();
			if (child instanceof MToolBarSeparator && elementId != null) {
				existingSeparatorNames.add(elementId);
			}
		}

		ToolBarManager manager = getManager(toolbarModel);
		boolean done = toContribute.size() == 0;
		while (!done) {
			ArrayList<MToolBarContribution> curList = new ArrayList<MToolBarContribution>(
					toContribute);
			int retryCount = toContribute.size();
			toContribute.clear();

			for (final MToolBarContribution contribution : curList) {
				if (!processAddition(toolbarModel, manager, contribution,
						existingSeparatorNames)) {
					toContribute.add(contribution);
				}
			}
			// We're done if the retryList is now empty (everything done) or
			// if the list hasn't changed at all (no hope)
			done = (toContribute.size() == 0)
					|| (toContribute.size() == retryCount);
		}
	}

	static class ContributionRecord {
		public ContributionRecord(MToolBar toolbarModel,
				MToolBarContribution contribution, ToolBarManager manager) {
			this.toolbarModel = toolbarModel;
			this.contribution = contribution;
			this.manager = manager;
		}

		MToolBar toolbarModel;
		MToolBarContribution contribution;
		ToolBarManager manager;
		ArrayList<MToolBarElement> generatedElements = new ArrayList<MToolBarElement>();

		public void generate() {
			for (MToolBarElement element : contribution.getChildren()) {
				MToolBarElement copy = (MToolBarElement) EcoreUtil
						.copy((EObject) element);
				generatedElements.add(copy);
			}
		}

		public void updateVisibility(IEclipseContext context) {
			ExpressionContext exprContext = new ExpressionContext(context);
			boolean isVisible = ContributionsAnalyzer.isVisible(contribution,
					exprContext);
			for (MToolBarElement item : generatedElements) {
				item.setVisible(isVisible);
			}
			manager.markDirty();
		}

		public void dispose() {
			for (MToolBarElement copy : generatedElements) {
				toolbarModel.getChildren().remove(copy);
			}
		}
	}

	/**
	 * @param toolbarModel
	 * @param manager
	 * @param contribution
	 * @param existingSeparatorNames
	 * @return <code>true</code> if the contribution was successfuly processed
	 */
	private boolean processAddition(MToolBar toolbarModel,
			final ToolBarManager manager, MToolBarContribution contribution,
			HashSet<String> existingSeparatorNames) {
		int idx = getIndex(toolbarModel, contribution.getPositionInParent());
		if (idx == -1) {
			return false;
		}
		final ContributionRecord record = new ContributionRecord(toolbarModel,
				contribution, manager);
		contributionRecords.add(record);
		record.generate();
		for (MToolBarElement copy : record.generatedElements) {
			if (copy instanceof MToolBarSeparator
					&& existingSeparatorNames.contains(copy.getElementId())) {
				// skip this, it's already there
				continue;
			}
			toolbarModel.getChildren().add(idx++, copy);
			if (copy instanceof MToolBarSeparator
					&& copy.getElementId() != null) {
				existingSeparatorNames.add(copy.getElementId());
			}
		});
		if (contribution.getVisibleWhen() != null) {
			final IEclipseContext parentContext = modelService
					.getContainingContext(toolbarModel);
			parentContext.runAndTrack(new RunAndTrack() {
				@Override
				public boolean changed(IEclipseContext context) {
					record.updateVisibility(parentContext.getActiveLeaf());
					manager.update(false);
					return true;
				}
			});
		}

		return true;
	}

		return intermediate;
			String positionInParent) {
		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) {
			return menuModel.getChildren().size();
		}

		int idx = 0;
		int size = menuModel.getChildren().size();
		while (idx < size) {
			if (id.equals(menuModel.getChildren().get(idx).getElementId())) {
				if ("after".equals(modifier)) { //$NON-NLS-1$
					idx++;
				}
				return idx;
			}
			idx++;
		}
		return id.equals("additions") ? menuModel.getChildren().size() : -1; //$NON-NLS-1$
	}

	ToolBar createToolbar(final MUIElement element, Composite intermediate) {
			Composite intermediate) {
		int orientation = getOrientation(element);
		RowLayout layout = RowLayoutFactory.fillDefaults().wrap(false)
				.spacing(0).type(orientation).create();

		intermediate.setLayout(layout);
		// new Label(intermediate, (orientation == SWT.HORIZONTAL ? SWT.VERTICAL
		// : SWT.HORIZONTAL) | SWT.SEPARATOR);

		ToolBar separatorToolBar = new ToolBar(intermediate, orientation
				| SWT.WRAP | SWT.FLAT | SWT.RIGHT);
		new ToolItem(separatorToolBar, SWT.SEPARATOR);
		return new ToolBar(intermediate, orientation | SWT.WRAP | SWT.FLAT
				| SWT.RIGHT);
			manager = new ToolBarManager(orientation | SWT.WRAP | SWT.FLAT
					| SWT.RIGHT);
			linkModelToManager((MToolBar) element, manager);
		}
		ToolBar bar = manager.createControl(intermediate);
		bar.setData(manager);
		bar.getShell().layout(new Control[] { bar }, SWT.DEFER);
		bar.addDisposeListener(new DisposeListener() {
			public void widgetDisposed(DisposeEvent e) {
				cleanUp((MToolBar) element);
			}
		});
		return bar;
	}

	/**
	 * @param element
	 */
	protected void cleanUp(MToolBar toolbarModel) {
		for (ContributionRecord record : contributionRecords
				.toArray(new ContributionRecord[contributionRecords.size()])) {
			if (record.toolbarModel == toolbarModel) {
				record.dispose();
				contributionRecords.remove(record);
				for (MToolBarElement copy : record.generatedElements) {
					IContributionItem ici = modelToContribution.remove(copy);
					if (ici != null) {
						record.manager.remove(ici);
					}
				}
				record.generatedElements.clear();
			}
		}
	}

	int getOrientation(final MUIElement element) {

		return SWT.HORIZONTAL;
	}

	public Object getUIContainer(MUIElement childElement) {
		Composite intermediate = (Composite) super.getUIContainer(childElement);
		if (intermediate == null || intermediate.isDisposed()) {
			return null;
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#processContents
	 * (org.eclipse.e4.ui.model.application.ui.MElementContainer)
	 */
	@Override
	public void processContents(MElementContainer<MUIElement> container) {
		// I can either simply stop processing, or we can walk the model
		// ourselves like the "old" days
		// EMF gives us null lists if empty
		if (container == null)
			return;

		Object obj = container;
		ToolBarManager parentManager = getManager((MToolBar) obj);
		if (parentManager == null) {
			return;
		}
		// Process any contents of the newly created ME
		List<MUIElement> parts = container.getChildren();
		if (parts != null) {
			MUIElement[] plist = parts.toArray(new MUIElement[parts.size()]);
			for (int i = 0; i < plist.length; i++) {
				MUIElement childME = plist[i];
				modelProcessSwitch(parentManager, (MToolBarElement) childME);
			}
		}
		parentManager.update(false);

		ToolBar tb = getToolbarFrom(container.getWidget());
		if (tb != null && ((EObject) container).eContainer() instanceof MPart) {
			MPart part = (MPart) ((EObject) container).eContainer();
			MMenu viewMenu = getViewMenu(part);

			// View menu (if any)
			if (viewMenu != null) {
				addMenuButton(part, tb, viewMenu);
			}
			tb.getShell().layout(new Control[] { tb }, SWT.DEFER);
		}
		ToolBar toolbar = findToolbar(intermediate);
		if (toolbar == null) {
			toolbar = createToolbar(childElement.getParent(), intermediate);
		}
		return toolbar;
	}

	ToolBar findToolbar(Composite intermediate) {
		if (!intermediate.isDisposed()) {
			Control[] children = intermediate.getChildren();
			int length = children.length;
			if (length > 0 && children[length - 1] instanceof ToolBar) {
				return (ToolBar) children[length - 1];
			return (ToolBar) widget;
		}
		if (widget instanceof Composite) {
			Composite intermediate = (Composite) widget;
			if (!intermediate.isDisposed()) {
				Control[] children = intermediate.getChildren();
				int length = children.length;
				if (length > 0 && children[length - 1] instanceof ToolBar) {
					return (ToolBar) children[length - 1];
				}
			}
		}
		return null;
	}

	@Override
	public void hideChild(MElementContainer<MUIElement> parentElement,
			MUIElement child) {
		super.hideChild(parentElement, child);
		ToolItem ti = new ToolItem(tb, SWT.PUSH);
		ti.setImage(getViewMenuImage());
		ti.setHotImage(null);
		ti.setToolTipText("View Menu"); //$NON-NLS-1$
		ti.setData("theMenu", menu); //$NON-NLS-1$
		ti.setData("thePart", part); //$NON-NLS-1$

		ti.addSelectionListener(new SelectionListener() {
			public void widgetSelected(SelectionEvent e) {
				showMenu((ToolItem) e.widget);
			}

			public void widgetDefaultSelected(SelectionEvent e) {
				showMenu((ToolItem) e.widget);
			}
		});
	}

		// Since there's no place to 'store' a child that's not in a menu
		// we'll blow it away and re-create on an add
		Widget widget = (Widget) child.getWidget();
		if (widget != null && !widget.isDisposed()) {
			widget.dispose();
		final MMenu menuModel = (MMenu) item.getData("theMenu"); //$NON-NLS-1$
		MPart part = (MPart) item.getData("thePart"); //$NON-NLS-1$
		Control ctrl = (Control) part.getWidget();
		Menu menu = (Menu) renderer.createGui(menuModel, ctrl.getShell(),
				part.getContext());

		// ...and Show it...
		Rectangle ib = item.getBounds();
		Point displayAt = item.getParent().toDisplay(ib.x, ib.y + ib.height);
		menu.setLocation(displayAt);
		menu.setVisible(true);

		Display display = Display.getCurrent();
		while (!menu.isDisposed() && menu.isVisible()) {
			if (!display.readAndDispatch())
				display.sleep();
		}
		menu.dispose();
	}

	private Image getViewMenuImage() {
		if (viewMenuImage == null) {
			Display d = Display.getCurrent();

			Image viewMenu = new Image(d, 16, 16);
			Image viewMenuMask = new Image(d, 16, 16);

			Display display = Display.getCurrent();
			GC gc = new GC(viewMenu);
			GC maskgc = new GC(viewMenuMask);
			gc.setForeground(display
					.getSystemColor(SWT.COLOR_WIDGET_DARK_SHADOW));
			gc.setBackground(display.getSystemColor(SWT.COLOR_LIST_BACKGROUND));

			int[] shapeArray = new int[] { 6, 1, 15, 1, 11, 5, 10, 5 };
			gc.fillPolygon(shapeArray);
			gc.drawPolygon(shapeArray);

			Color black = display.getSystemColor(SWT.COLOR_BLACK);
			Color white = display.getSystemColor(SWT.COLOR_WHITE);

			maskgc.setBackground(black);
			maskgc.fillRectangle(0, 0, 16, 16);

			maskgc.setBackground(white);
			maskgc.setForeground(white);
			maskgc.fillPolygon(shapeArray);
			maskgc.drawPolygon(shapeArray);
			gc.dispose();
			maskgc.dispose();

			ImageData data = viewMenu.getImageData();
			data.transparentPixel = data.getPixel(0, 0);

			viewMenuImage = new Image(d, viewMenu.getImageData(),
					viewMenuMask.getImageData());
			viewMenu.dispose();
			viewMenuMask.dispose();
		}
		ToolBar toolbar = (ToolBar) getUIContainer(child);
		if (toolbar != null && !toolbar.isDisposed()) {
			toolbar.getShell().layout(new Control[] { toolbar }, SWT.DEFER);
		}
		disposeToolbarIfNecessary(parentElement);
	}

	private void disposeToolbarIfNecessary(MUIElement element) {
		Composite composite = (Composite) element.getWidget();
		ToolBar toolbar = findToolbar(composite);
		if (toolbar != null && hasOnlySeparators(toolbar)) {
			toolbar.dispose();
			if (composite.getChildren().length > 0) {
				composite.getChildren()[0].dispose();
			}
		}
		return null;
	}

	boolean hasOnlySeparators(ToolBar toolbar) {

	}

	@Override
	public void postProcess(MUIElement element) {
		super.postProcess(element);
		// disposeToolbarIfNecessary(element);
		ToolBar tb = getToolbarFrom(element.getWidget());
		if (tb != null && !tb.isDisposed()) {
			tb.getShell().layout(new Control[] { tb }, SWT.DEFER);
			tb.setVisible(true);
		}
	}

	public Object getUIContainer(MUIElement childElement) {
		if (childElement.getWidget() instanceof ToolBar) {
			return childElement.getWidget();
		}

		Object obj = super.getUIContainer(childElement);
		if (obj instanceof ToolBar) {
			return obj;
		}

		if (obj instanceof Composite) {
			Composite intermediate = (Composite) obj;
			if (intermediate == null || intermediate.isDisposed()) {
				return null;
			}
			ToolBar toolbar = getToolbarFrom(intermediate);
			if (toolbar == null) {
				toolbar = createToolbar(childElement.getParent(), intermediate);
			}
			return toolbar;
		}
		return null;
	}

	@Override
	public void disposeWidget(MUIElement element) {
		ToolBar tb = getToolbarFrom(element.getWidget());
		tb.setVisible(false);
		unbindWidget(element);
		tb.setData(AbstractPartRenderer.OWNING_ME, element);
	}

	@Override
	public void hideChild(MElementContainer<MUIElement> parentElement,
			MUIElement child) {
		super.hideChild(parentElement, child);

		// Since there's no place to 'store' a child that's not in a menu
		// we'll blow it away and re-create on an add
		Widget widget = (Widget) child.getWidget();
		if (widget != null && !widget.isDisposed()) {
			widget.dispose();
		}
		ToolBar toolbar = (ToolBar) getUIContainer(child);
		if (toolbar != null && !toolbar.isDisposed()) {
			toolbar.getShell().layout(new Control[] { toolbar }, SWT.DEFER);
		}
		// disposeToolbarIfNecessary(parentElement);
	}

	@Override
	public void childRendered(MElementContainer<MUIElement> parentElement,
			MUIElement element) {
		super.childRendered(parentElement, element);

		}
	}

	@Override
	public void processContents(MElementContainer<MUIElement> container) {
		super.processContents(container);
		IEclipseContext ctx = getContext(container);
		ExpressionContext eContext = new ExpressionContext(ctx);
		ArrayList<MToolBarContribution> toContribute = new ArrayList<MToolBarContribution>();
		MElementContainer<?> toolbarObj = container;
		MToolBar toolbarModel = (MToolBar) toolbarObj;
		ContributionsAnalyzer.gatherToolBarContributions(toolbarModel,
				application.getToolBarContributions(),
				toolbarModel.getElementId(), toContribute, eContext);
		addToolBarContributions(toolbarModel, toContribute, ctx, eContext,
				pendingCleanup);
			MToolBarSeparator itemModel = (MToolBarSeparator) childME;
			processSeparator(parentManager, itemModel);
		} else if (childME instanceof MToolControl) {
			MToolControl itemModel = (MToolControl) childME;
			processToolControl(parentManager, itemModel);
		}
	}

	/**
	 * @param parentManager
	 * @param itemModel
	 */
	private void processSeparator(ToolBarManager parentManager,
			MToolBarSeparator itemModel) {
		AbstractGroupMarker marker = null;
		if (itemModel.isVisible()) {
			marker = new Separator();
			marker.setId(itemModel.getElementId());
		} else {
			if (itemModel.getElementId() != null) {
				marker = new GroupMarker(itemModel.getElementId());
			}
		}
		parentManager.add(marker);
	}

	/**
	 * @param parentManager
	 * @param itemModel
	 */
	private void processToolControl(ToolBarManager parentManager,
			MToolControl itemModel) {
		final IEclipseContext lclContext = getContext(itemModel);
		ToolControlContribution ci = ContextInjectionFactory.make(
				ToolControlContribution.class, lclContext);
		ci.setModel(itemModel);
		parentManager.add(ci);
		modelToContribution.put(itemModel, ci);
	}

	/**
	 * @param parentManager
	 * @param itemModel
	 */
	private void processDirectItem(ToolBarManager parentManager,
			MDirectToolItem itemModel) {
		final IEclipseContext lclContext = getContext(itemModel);
		DirectContributionItem ci = ContextInjectionFactory.make(
				DirectContributionItem.class, lclContext);
		ci.setModel(itemModel);
		parentManager.add(ci);
		modelToContribution.put(itemModel, ci);
	}

	/**
	 * @param parentManager
	 * @param itemModel
	 */
	private void processHandledItem(ToolBarManager parentManager,
			MHandledToolItem itemModel) {
		final IEclipseContext lclContext = getContext(itemModel);
		HandledContributionItem ci = ContextInjectionFactory.make(
				HandledContributionItem.class, lclContext);
		ci.setModel(itemModel);
		parentManager.add(ci);
		modelToContribution.put(itemModel, ci);
	}

	@Override
	public void postProcess(MUIElement element) {
		super.postProcess(element);
		disposeToolbarIfNecessary(element);
	}

	public static void addToolBarContributions(
			final MToolBar toolbarModel,
			ArrayList<MToolBarContribution> toContribute,
			IEclipseContext ctx,
			final ExpressionContext eContext,
			HashMap<MToolBar, ArrayList<ArrayList<MToolBarElement>>> pendingCleanup) {
		HashSet<String> existingSeparatorNames = new HashSet<String>();
		for (MToolBarElement child : toolbarModel.getChildren()) {
			String elementId = child.getElementId();
			if (child instanceof MToolBarSeparator && elementId != null) {
				existingSeparatorNames.add(elementId);
			}
		}
		boolean done = toContribute.size() == 0;
		while (!done) {
			ArrayList<MToolBarContribution> curList = new ArrayList<MToolBarContribution>(
					toContribute);
			int retryCount = toContribute.size();
			toContribute.clear();

			for (final MToolBarContribution contribution : curList) {
				final ArrayList<MToolBarElement> toRemove = new ArrayList<MToolBarElement>();
				if (!ContributionsAnalyzer.processAddition(toolbarModel,
						contribution, toRemove, existingSeparatorNames)) {
					toContribute.add(contribution);
				} else {
					if (contribution.getVisibleWhen() != null) {
						ctx.runAndTrack(new RunAndTrack() {
							@Override
							public boolean changed(IEclipseContext context) {
								if (!toolbarModel.isToBeRendered()
										|| !toolbarModel.isVisible()
										|| toolbarModel.getWidget() == null) {
									return false;
								}
								boolean rc = ContributionsAnalyzer.isVisible(
										contribution, eContext);
								for (MToolBarElement child : toRemove) {
									child.setToBeRendered(rc);
								}
								return true;
							}
						});
					}
					ArrayList<ArrayList<MToolBarElement>> lists = pendingCleanup
							.get(toolbarModel);
					if (lists == null) {
						lists = new ArrayList<ArrayList<MToolBarElement>>();
						pendingCleanup.put(toolbarModel, lists);
					}
					lists.add(toRemove);
				}
			}
			// We're done if the retryList is now empty (everything done) or
			// if the list hasn't changed at all (no hope)
			done = (toContribute.size() == 0)
					|| (toContribute.size() == retryCount);
		}
	}

	protected void cleanUp(MToolBar element) {
		ArrayList<ArrayList<MToolBarElement>> lists = pendingCleanup
				.remove(element);
		if (lists == null) {
			return;
		}
		for (ArrayList<MToolBarElement> list : lists) {
			for (MToolBarElement child : list) {
				element.getChildren().remove(child);
			}
		}
	}

	public IContributionItem getContribution(MToolBarElement element) {
		return modelToContribution.get(element);
	}
}




/*******************************************************************************
 * Copyright (c) 2009, 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.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import org.eclipse.core.commands.ParameterizedCommand;
import org.eclipse.core.commands.common.NotDefinedException;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.e4.core.commands.ECommandService;
import org.eclipse.e4.core.commands.EHandlerService;
import org.eclipse.e4.core.contexts.ContextInjectionFactory;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.e4.core.services.contributions.IContributionFactory;
import org.eclipse.e4.core.services.events.IEventBroker;
import org.eclipse.e4.core.services.log.Logger;
import org.eclipse.e4.ui.bindings.EBindingService;
import org.eclipse.e4.ui.internal.workbench.Activator;
import org.eclipse.e4.ui.internal.workbench.Policy;
import org.eclipse.e4.ui.model.application.MContribution;
import org.eclipse.e4.ui.model.application.commands.MParameter;
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.ItemType;
import org.eclipse.e4.ui.model.application.ui.menu.MHandledItem;
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.MToolItem;
import org.eclipse.e4.ui.workbench.IPresentationEngine;
import org.eclipse.e4.ui.workbench.UIEvents;
import org.eclipse.jface.bindings.TriggerSequence;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;
import org.eclipse.swt.widgets.Widget;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventHandler;

/**
 * Create a contribute part.
 */
public class ToolItemRenderer extends SWTPartRenderer {

	@Inject
	Logger logger;
	@Inject
	IEventBroker eventBroker;

	@Inject
	private IPresentationEngine engine;

	private EventHandler itemUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MToolItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MToolItem))
				return;

			MToolItem itemModel = (MToolItem) event
					.getProperty(UIEvents.EventTags.ELEMENT);
			ToolItem toolItem = (ToolItem) itemModel.getWidget();

			// No widget == nothing to update
			if (toolItem == null)
				return;

			String attName = (String) event
					.getProperty(UIEvents.EventTags.ATTNAME);
			if (UIEvents.UILabel.LABEL.equals(attName)) {
				setItemText(itemModel, toolItem);
			} else if (UIEvents.UILabel.ICONURI.equals(attName)) {
				toolItem.setImage(getImage(itemModel));
			} else if (UIEvents.UILabel.TOOLTIP.equals(attName)) {
				toolItem.setToolTipText(getToolTipText(itemModel));
				toolItem.setImage(getImage(itemModel));
			}
		}
	};

	private EventHandler selectionUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MToolItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MToolItem))
				return;

			MToolItem itemModel = (MToolItem) event
					.getProperty(UIEvents.EventTags.ELEMENT);
			ToolItem toolItem = (ToolItem) itemModel.getWidget();
			if (toolItem != null) {
				toolItem.setSelection(itemModel.isSelected());
			}
		}
	};

	private EventHandler enabledUpdater = new EventHandler() {
		public void handleEvent(Event event) {
			// Ensure that this event is for a MToolItem
			if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MToolItem))
				return;

			MToolItem itemModel = (MToolItem) event
					.getProperty(UIEvents.EventTags.ELEMENT);
			ToolItem toolItem = (ToolItem) itemModel.getWidget();
			if (toolItem != null) {
				toolItem.setEnabled(itemModel.isEnabled());
			}
		}
	};

	@PostConstruct
	public void init() {
		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UILabel.TOPIC),
				itemUpdater);
		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
				UIEvents.Item.SELECTED), selectionUpdater);
		eventBroker
				.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
						UIEvents.Item.ENABLED), enabledUpdater);
	}

	@PreDestroy
	public void contextDisposed() {
		eventBroker.unsubscribe(itemUpdater);
		eventBroker.unsubscribe(selectionUpdater);
		eventBroker.unsubscribe(enabledUpdater);
	}

	private ParameterizedCommand generateParameterizedCommand(
			final MHandledItem item, final IEclipseContext lclContext) {
		ECommandService cmdService = (ECommandService) lclContext
				.get(ECommandService.class.getName());
		Map<String, Object> parameters = null;
		List<MParameter> modelParms = item.getParameters();
		if (modelParms != null && !modelParms.isEmpty()) {
			parameters = new HashMap<String, Object>();
			for (MParameter mParm : modelParms) {
				parameters.put(mParm.getName(), mParm.getValue());
			}
		}
		ParameterizedCommand cmd = cmdService.createCommand(item.getCommand()
				.getElementId(), parameters);
		item.setWbCommand(cmd);
		return cmd;
	}

	private void setItemText(MToolItem model, ToolItem item) {
		String text = model.getLabel();
		if (model instanceof MHandledItem) {
			MHandledItem handledItem = (MHandledItem) model;
			IEclipseContext context = getContext(model);
			EBindingService bs = (EBindingService) context
					.get(EBindingService.class.getName());
			ParameterizedCommand cmd = handledItem.getWbCommand();
			if (cmd == null) {
				cmd = generateParameterizedCommand(handledItem, context);
			}
			TriggerSequence sequence = bs.getBestSequenceFor(handledItem
					.getWbCommand());
			if (sequence != null) {
				text = text + '\t' + sequence.format();
			}
			item.setText(text);
		} else {
			if (text == null) {
				text = ""; //$NON-NLS-1$
			}
			item.setText(text);
		}
	}

	private String getToolTipText(MItem item) {
		String text = item.getTooltip();
		if (item instanceof MHandledItem) {
			MHandledItem handledItem = (MHandledItem) item;
			IEclipseContext context = getContext(item);
			EBindingService bs = (EBindingService) context
					.get(EBindingService.class.getName());
			ParameterizedCommand cmd = handledItem.getWbCommand();
			if (cmd == null) {
				cmd = generateParameterizedCommand(handledItem, context);
			}
			TriggerSequence sequence = bs.getBestSequenceFor(handledItem
					.getWbCommand());
			if (sequence != null) {
				if (text == null) {
					try {
						text = cmd.getName();
					} catch (NotDefinedException e) {
						return null;
					}
				}
				text = text + " (" + sequence.format() + ')'; //$NON-NLS-1$
			}
			return text;
		}
		return text;
	}

	public Object createWidget(final MUIElement element, Object parent) {
		if (!(element instanceof MToolItem) || !(parent instanceof ToolBar))
			return null;

		MToolItem itemModel = (MToolItem) element;

		// determine the index at which we should create the new item
		int addIndex = calcVisibleIndex(element);

		// OK, it's a real menu item, what kind?
		MMenu menu = itemModel.getMenu();
		int flags = 0;
		if (menu != null) {
			flags |= SWT.DROP_DOWN;
		} else if (itemModel.getType() == ItemType.PUSH)
			flags |= SWT.PUSH;
		else if (itemModel.getType() == ItemType.CHECK)
			flags |= SWT.CHECK;
		else if (itemModel.getType() == ItemType.RADIO)
			flags |= SWT.RADIO;

		ToolItem newItem = new ToolItem((ToolBar) parent, flags, addIndex);
		if (itemModel.getLabel() != null)
			newItem.setText(itemModel.getLabel());

		newItem.setToolTipText(getToolTipText(itemModel));

		newItem.setImage(getImage((MUILabel) element));

		newItem.setEnabled(itemModel.isEnabled());

		newItem.setSelection(itemModel.isSelected());

		return newItem;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#hideChild
	 * (org.eclipse.e4.ui.model.application.MElementContainer,
	 * org.eclipse.e4.ui.model.application.MUIElement)
	 */
	@Override
	public void hideChild(MElementContainer<MUIElement> parentElement,
			MUIElement child) {
		super.hideChild(parentElement, child);

		// Since there's no place to 'store' a child that's not in a menu
		// we'll blow it away and re-create on an add
		Widget widget = (Widget) child.getWidget();
		if (widget != null && !widget.isDisposed())
			widget.dispose();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#hookControllerLogic
	 * (org.eclipse.e4.ui.model.application.MUIElement)
	 */
	@Override
	public void hookControllerLogic(MUIElement me) {
		// If the item is a CHECK or RADIO update the model's state to match
		if (me instanceof MItem) {
			final MItem item = (MItem) me;
			if (item.getType() == ItemType.CHECK
					|| item.getType() == ItemType.RADIO) {
				ToolItem ti = (ToolItem) me.getWidget();
				ti.addSelectionListener(new SelectionListener() {
					public void widgetSelected(SelectionEvent e) {
						item.setSelected(((ToolItem) e.widget).getSelection());
					}

					public void widgetDefaultSelected(SelectionEvent e) {
						item.setSelected(((ToolItem) e.widget).getSelection());
					}
				});
			} else if (me instanceof MToolItem) {
				final MMenu mmenu = ((MToolItem) me).getMenu();
				if (mmenu != null) {
					final ToolItem ti = (ToolItem) me.getWidget();
					ti.addSelectionListener(new SelectionAdapter() {
						public void widgetSelected(SelectionEvent e) {
							if (e.detail == SWT.ARROW) {
								Menu menu = (Menu) engine.createGui(mmenu, ti
										.getParent().getShell(), null);

								Rectangle itemBounds = ti.getBounds();
								Point displayAt = ti.getParent().toDisplay(
										itemBounds.x,
										itemBounds.y + itemBounds.height);
								menu.setLocation(displayAt);
								menu.setVisible(true);

								Display display = menu.getDisplay();
								while (menu.isVisible()) {
									if (!display.readAndDispatch()) {
										display.sleep();
									}
								}
							}
						}
					});
				}
			}
		}

		// 'Execute' the operation if possible
		if (me instanceof MContribution
				&& ((MContribution) me).getContributionURI() != null) {
			final MToolItem item = (MToolItem) me;
			final MContribution contrib = (MContribution) me;
			final IEclipseContext lclContext = getContext(me);
			ToolItem ti = (ToolItem) me.getWidget();
			ti.addSelectionListener(new SelectionListener() {
				public void widgetSelected(SelectionEvent e) {
					if (contrib.getObject() == null) {
						IContributionFactory cf = (IContributionFactory) lclContext
								.get(IContributionFactory.class.getName());
						contrib.setObject(cf.create(
								contrib.getContributionURI(), lclContext));
					}
					lclContext.set(MItem.class.getName(), item);
					ContextInjectionFactory.invoke(contrib.getObject(),
							Execute.class, lclContext);
					lclContext.remove(MItem.class.getName());
				}

				public void widgetDefaultSelected(SelectionEvent e) {
				}
			});
		} else if (me instanceof MHandledItem) {
			final MHandledItem item = (MHandledItem) me;
			final IEclipseContext lclContext = getContext(me);
			final ToolItem ti = (ToolItem) me.getWidget();
			final Display display = ti.getDisplay();
			display.timerExec(500, new Runnable() {
				boolean logged = false;

				public void run() {
					if (ti.isDisposed()) {
						return;
					}
					SafeRunner.run(new ISafeRunnable() {
						public void run() throws Exception {
							EHandlerService service = lclContext
									.get(EHandlerService.class);
							if (service == null) {
								// no localized handler service
								return;
							}
							ParameterizedCommand cmd = item.getWbCommand();
							if (cmd == null) {
								cmd = generateParameterizedCommand(item,
										lclContext);
							}
							if (cmd == null) {
								return;
							}
							item.setEnabled(service.canExecute(cmd));
						}

						public void handleException(Throwable exception) {
							if (!logged) {
								logged = true;
								logger.error(
										exception,
										"Internal error during tool item enablement updating, this is only logged once per tool item."); //$NON-NLS-1$
							}
						}
					});
					// repeat until disposed
					display.timerExec(500, this);
				}
			});
			ti.addSelectionListener(new SelectionListener() {
				public void widgetSelected(SelectionEvent e) {
					if (e.detail != SWT.ARROW) {
						EHandlerService service = (EHandlerService) lclContext
								.get(EHandlerService.class.getName());
						ParameterizedCommand cmd = item.getWbCommand();
						if (cmd == null) {
							cmd = generateParameterizedCommand(item, lclContext);
						}
						if (cmd == null) {
							Activator.trace(Policy.DEBUG_MENUS,
									"Failed to execute: " + item.getCommand(), //$NON-NLS-1$
									null);
							return;
						}
						lclContext.set(MItem.class.getName(), item);
						service.executeHandler(cmd);
						lclContext.remove(MItem.class.getName());
					}
				}

				public void widgetDefaultSelected(SelectionEvent e) {
				}
			});
		}
	}
}

Lines 14-29 Link Here

(-)src/org/eclipse/e4/ui/workbench/renderers/swt/WorkbenchRendererFactory.java (+58 lines)
14	import org.eclipse.e4.ui.model.application.ui.basic.MPartStack;	14	import org.eclipse.e4.ui.model.application.ui.basic.MPartStack;
15	import org.eclipse.e4.ui.model.application.ui.basic.MTrimBar;	15	import org.eclipse.e4.ui.model.application.ui.basic.MTrimBar;
16	import org.eclipse.e4.ui.model.application.ui.basic.MWindow;	16	import org.eclipse.e4.ui.model.application.ui.basic.MWindow;
		17	import org.eclipse.e4.ui.model.application.ui.menu.MDirectMenuItem;
		18	import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;
17	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;	19	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
		20	import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;
		21	import org.eclipse.e4.ui.model.application.ui.menu.MRenderedMenu;
		22	import org.eclipse.e4.ui.model.application.ui.menu.MRenderedMenuItem;
		23	import org.eclipse.e4.ui.model.application.ui.menu.MRenderedToolBar;
18	import org.eclipse.e4.ui.model.application.ui.menu.MToolBar;	24	import org.eclipse.e4.ui.model.application.ui.menu.MToolBar;
		25	import org.eclipse.e4.ui.model.application.ui.menu.MToolBarSeparator;
19	import org.eclipse.e4.ui.model.application.ui.menu.MToolControl;	26	import org.eclipse.e4.ui.model.application.ui.menu.MToolControl;
		27	import org.eclipse.e4.ui.model.application.ui.menu.MToolItem;
20	import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;	28	import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
21		29
22	public class WorkbenchRendererFactory implements IRendererFactory {	30	public class WorkbenchRendererFactory implements IRendererFactory {
23		31
24	private AreaRenderer areaRenderer;	32	private AreaRenderer areaRenderer;
25	private MenuRenderer menuRenderer;	33	private MenuRenderer menuRenderer;
		34	private HandledMenuItemRenderer handledMenuItemRenderer;
26	private ToolBarRenderer toolbarRenderer;	35	private ToolBarRenderer toolbarRenderer;
		36	private ToolItemRenderer toolItemRenderer;
		37	private SeparatorRenderer separatorRenderer;
27	private ContributedPartRenderer contributedPartRenderer;	38	private ContributedPartRenderer contributedPartRenderer;
28	private ElementReferenceRenderer elementRefRenderer;	39	private ElementReferenceRenderer elementRefRenderer;
29	private PerspectiveStackRenderer perspStackRenderer;	40	private PerspectiveStackRenderer perspStackRenderer;
Lines 35-40 Link Here
35	private WBWRenderer wbwRenderer;	46	private WBWRenderer wbwRenderer;
36		47
37	private IEclipseContext context;	48	private IEclipseContext context;
		49	private DirectMenuItemRenderer directMenuItemRenderer;
		50	private RenderedMenuRenderer renderedMenuRenderer;
		51	private RenderedMenuItemRenderer renderedMenuItemRenderer;
		52	private RenderedToolBarRenderer renderedToolbarRenderer;
38		53
39	public AbstractPartRenderer getRenderer(MUIElement uiElement, Object parent) {	54	public AbstractPartRenderer getRenderer(MUIElement uiElement, Object parent) {
40	if (uiElement instanceof MArea) {	55	if (uiElement instanceof MArea) {
Lines 49-66 Link Here
49	initRenderer(contributedPartRenderer);	64	initRenderer(contributedPartRenderer);
50	}	65	}
51	return contributedPartRenderer;	66	return contributedPartRenderer;
		67	} else if (uiElement instanceof MHandledMenuItem) {
		68	if (handledMenuItemRenderer == null) {
		69	handledMenuItemRenderer = new HandledMenuItemRenderer();
		70	initRenderer(handledMenuItemRenderer);
		71	}
		72	return handledMenuItemRenderer;
		73	} else if (uiElement instanceof MDirectMenuItem) {
		74	if (directMenuItemRenderer == null) {
		75	directMenuItemRenderer = new DirectMenuItemRenderer();
		76	initRenderer(directMenuItemRenderer);
		77	}
		78	return directMenuItemRenderer;
		79	} else if (uiElement instanceof MRenderedMenu) {
		80	if (renderedMenuRenderer == null) {
		81	renderedMenuRenderer = new RenderedMenuRenderer();
		82	initRenderer(renderedMenuRenderer);
		83	}
		84	return renderedMenuRenderer;
		85	} else if (uiElement instanceof MRenderedMenuItem) {
		86	if (renderedMenuItemRenderer == null) {
		87	renderedMenuItemRenderer = new RenderedMenuItemRenderer();
		88	initRenderer(renderedMenuItemRenderer);
		89	}
		90	return renderedMenuItemRenderer;
52	} else if (uiElement instanceof MMenu) {	91	} else if (uiElement instanceof MMenu) {
53	if (menuRenderer == null) {	92	if (menuRenderer == null) {
54	menuRenderer = new MenuRenderer();	93	menuRenderer = new MenuRenderer();
55	initRenderer(menuRenderer);	94	initRenderer(menuRenderer);
56	}	95	}
57	return menuRenderer;	96	return menuRenderer;
		97	} else if (uiElement instanceof MRenderedToolBar) {
		98	if (renderedToolbarRenderer == null) {
		99	renderedToolbarRenderer = new RenderedToolBarRenderer();
		100	initRenderer(renderedToolbarRenderer);
		101	}
		102	return renderedToolbarRenderer;
58	} else if (uiElement instanceof MToolBar) {	103	} else if (uiElement instanceof MToolBar) {
59	if (toolbarRenderer == null) {	104	if (toolbarRenderer == null) {
60	toolbarRenderer = new ToolBarRenderer();	105	toolbarRenderer = new ToolBarRenderer();
61	initRenderer(toolbarRenderer);	106	initRenderer(toolbarRenderer);
62	}	107	}
63	return toolbarRenderer;	108	return toolbarRenderer;
		109	} else if (uiElement instanceof MToolItem) {
		110	if (toolItemRenderer == null) {
		111	toolItemRenderer = new ToolItemRenderer();
		112	initRenderer(toolItemRenderer);
		113	}
		114	return toolItemRenderer;
		115	} else if (uiElement instanceof MMenuSeparator
		116	\|\| uiElement instanceof MToolBarSeparator) {
		117	if (separatorRenderer == null) {
		118	separatorRenderer = new SeparatorRenderer();
		119	initRenderer(separatorRenderer);
		120	}
		121	return separatorRenderer;
64	} else if (uiElement instanceof MPlaceholder) {	122	} else if (uiElement instanceof MPlaceholder) {
65	if (elementRefRenderer == null) {	123	if (elementRefRenderer == null) {
66	elementRefRenderer = new ElementReferenceRenderer();	124	elementRefRenderer = new ElementReferenceRenderer();




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;

						.eContainer();
			}

			boolean menuChild = parent instanceof MMenu;

			// If the parent isn't displayed who cares?
			if (parent == null || parent.getWidget() == null)
				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)
				return;

			String eventType = (String) event

		Object newWidget = createWidget(element, parentWidget);

		// Remember that we've created the control
		if (newWidget != null) {
			AbstractPartRenderer renderer = getRendererFor(element);
			// AbstractPartRenderer renderer = getRendererFor(element);

			// Have the renderer hook up any widget specific listeners
			renderer.hookControllerLogic(element);




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




import javax.inject.Inject;
import org.eclipse.e4.core.contexts.IEclipseContext;
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.MPopupMenu;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;

public class MenuService implements EMenuService {

		if (mmenu.getWidget() != null) {
			return false;
		}
		Menu menu = new Menu(parentControl);
		parentControl.setMenu(menu);
		mmenu.setWidget(menu);
		menu.setData(AbstractPartRenderer.OWNING_ME, mmenu);
		AbstractPartRenderer renderer = rendererFactory.getRenderer(mmenu,
				parentControl);
		IEclipseContext popupContext = myPart.getContext().createChild(
				"popup:" + mmenu.getElementId());
		mmenu.setContext(popupContext);
		menu.addListener(SWT.Dispose, new Listener() {
			public void handleEvent(Event event) {
				mmenu.getContext().dispose();
				mmenu.setContext(null);
				mmenu.setWidget(null);
			}
		});
		// Process its internal structure through the renderer that created
		// it
		Object castObject = mmenu;
		renderer.processContents((MElementContainer<MUIElement>) castObject);

		// Allow a final chance to set up
		renderer.postProcess(mmenu);

		// Now that we have a widget let the parent (if any) know
		if (mmenu.getParent() instanceof MUIElement) {
			MElementContainer<MUIElement> parentElement = mmenu.getParent();
			AbstractPartRenderer parentRenderer = rendererFactory.getRenderer(
					parentElement, null);
			if (parentRenderer != null)
				parentRenderer.childRendered(parentElement, mmenu);
		}

		return true;
	}
}




 *******************************************************************************/
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 {

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

		}
		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) {
		// System.err.println("hidePopup: " + menuModel + "\n\t" + menu);
		final IEclipseContext popupContext = menuModel.getContext();
		final IEclipseContext originalChild = (IEclipseContext) popupContext
				.get(TMP_ORIGINAL_CONTEXT);

		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.e4.ui.model.application.ui.MUIElement;
import org.eclipse.e4.ui.model.application.ui.advanced.MPlaceholder;
import org.eclipse.e4.ui.model.application.ui.basic.MPart;
import org.eclipse.e4.ui.model.application.ui.menu.MRenderedToolBar;
import org.eclipse.e4.ui.workbench.IPresentationEngine;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;

				if (tbCtrl != null && !tbCtrl.isDisposed()) {
					MUIElement tbModel = (MUIElement) tbCtrl
							.getData(AbstractPartRenderer.OWNING_ME);
					if (tbModel instanceof MRenderedToolBar) {
						// only force a rerender if the toolbar can be seen
						if (isSelected(part)) {
							Object tbParent = tbCtrl.getParent();
							if (part.getContext() != null) {
								IPresentationEngine renderer = part.getContext().get(
										IPresentationEngine.class);
								if (renderer != null) {
									renderer.removeGui(tbModel);
									renderer.createGui(tbModel, tbCtrl.getParent(),
											part.getContext());
									tbCtrl.getParent().layout();
								}
							}
						}




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.MenuRenderer;
import org.eclipse.e4.ui.workbench.renderers.swt.StackRenderer;
import org.eclipse.e4.ui.workbench.renderers.swt.ToolBarRenderer;
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();
		MRenderedMenu menu = null;
		for (MMenu me : part.getMenus()) {
			if (me.getTags().contains(StackRenderer.TAG_VIEW_MENU) && (me instanceof MRenderedMenu)) {
				menu = (MRenderedMenu) me;
				break;
			}
		}
		if (menu == null) {
			menu = MenuFactoryImpl.eINSTANCE.createRenderedMenu();
			menu.setElementId(part.getElementId());

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

			part.getMenus().add(menu);

		}
		menu.setContributionManager(mm);
		if (apr instanceof MenuRenderer) {
			((MenuRenderer) apr).linkModelToManager(menu, mm);
		}

		// Construct the toolbar (if necessary)
		MToolBar toolbar = part.getToolbar();
		if (toolbar == null) {
			toolbar = MenuFactoryImpl.eINSTANCE.createRenderedToolBar();
			toolbar.setElementId(part.getElementId());
			part.setToolbar(toolbar);
		}
		if (toolbar instanceof MRenderedToolBar) {
			((MRenderedToolBar) toolbar).setContributionManager(tbm);
			((ToolBarRenderer) apr).linkModelToManager(toolbar, tbm);
		}
	}
}

Return to bug 325392

Lines 70-76 Link Here

(-)src/org/eclipse/e4/ui/internal/workbench/ContributionsAnalyzer.java (-1 / +14 lines)
70	return false;	70	return false;
71	}	71	}
72		72
73	public static void gatherToolBarContributions(final MToolBar toolbarModel,	73	public static void XXXgatherToolBarContributions(final MToolBar toolbarModel,
74	final List<MToolBarContribution> toolbarContributionList, final String id,	74	final List<MToolBarContribution> toolbarContributionList, final String id,
75	final ArrayList<MToolBarContribution> toContribute) {	75	final ArrayList<MToolBarContribution> toContribute) {
76	for (MToolBarContribution toolBarContribution : toolbarContributionList) {	76	for (MToolBarContribution toolBarContribution : toolbarContributionList) {
Lines 83-88 Link Here
83	}	83	}
84	}	84	}
85		85
		86	public static void gatherToolBarContributions(final MToolBar toolbarModel,
		87	final List<MToolBarContribution> toolbarContributionList, final String id,
		88	final ArrayList<MToolBarContribution> toContribute, final ExpressionContext eContext) {
		89	for (MToolBarContribution toolBarContribution : toolbarContributionList) {
		90	String parentID = toolBarContribution.getParentId();
		91	boolean filtered = isFiltered(toolbarModel, toolBarContribution);
		92	if (filtered \|\| !parentID.equals(id) \|\| !toolBarContribution.isToBeRendered()) {
		93	continue;
		94	}
		95	toContribute.add(toolBarContribution);
		96	}
		97	}
		98
86	static boolean isFiltered(MToolBar toolbarModel, MToolBarContribution toolBarContribution) {	99	static boolean isFiltered(MToolBar toolbarModel, MToolBarContribution toolBarContribution) {
87	return false;	100	return false;
88	}	101	}

Added Link Here

(-)src/org/eclipse/e4/ui/workbench/renderers/swt/DirectMenuItemRenderer.java (+114 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009, 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 javax.inject.Inject;
14	import org.eclipse.e4.core.contexts.ContextInjectionFactory;
15	import org.eclipse.e4.core.contexts.IEclipseContext;
16	import org.eclipse.e4.core.di.annotations.Execute;
17	import org.eclipse.e4.core.services.contributions.IContributionFactory;
18	import org.eclipse.e4.core.services.log.Logger;
19	import org.eclipse.e4.ui.model.application.ui.MUIElement;
20	import org.eclipse.e4.ui.model.application.ui.menu.ItemType;
21	import org.eclipse.e4.ui.model.application.ui.menu.MDirectMenuItem;
22	import org.eclipse.e4.ui.model.application.ui.menu.MItem;
23	import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
24	import org.eclipse.swt.SWT;
25	import org.eclipse.swt.events.SelectionEvent;
26	import org.eclipse.swt.events.SelectionListener;
27	import org.eclipse.swt.widgets.Menu;
28	import org.eclipse.swt.widgets.MenuItem;
29
30	/**
31	* Create a contribute part.
32	*/
33	public class DirectMenuItemRenderer extends MenuItemRenderer {
34
35	@Inject
36	Logger logger;
37
38	public Object createWidget(final MUIElement element, Object parent) {
39	if (!(element instanceof MDirectMenuItem) \|\| !(parent instanceof Menu))
40	return null;
41
42	MDirectMenuItem itemModel = (MDirectMenuItem) element;
43	if (itemModel.getVisibleWhen() != null) {
44	processVisible(itemModel);
45	}
46
47	if (!itemModel.isVisible()) {
48	return null;
49	}
50
51	// determine the index at which we should create the new item
52	int addIndex = calcVisibleIndex(element);
53
54	// OK, it's a real menu item, what kind?
55	int flags = 0;
56	if (itemModel.getType() == ItemType.PUSH)
57	flags = SWT.PUSH;
58	else if (itemModel.getType() == ItemType.CHECK)
59	flags = SWT.CHECK;
60	else if (itemModel.getType() == ItemType.RADIO)
61	flags = SWT.RADIO;
62
63	MenuItem newItem = new MenuItem((Menu) parent, flags, addIndex);
64	setItemText(itemModel, newItem);
65	newItem.setImage(getImage(itemModel));
66	setEnabled(itemModel, newItem);
67	newItem.setEnabled(itemModel.isEnabled());
68	newItem.setSelection(itemModel.isSelected());
69
70	return newItem;
71	}
72
73	private void setEnabled(MDirectMenuItem itemModel, final MenuItem newItem) {
74	// TODO direct query to @CanExecute goes here
75	}
76
77	/*
78	* (non-Javadoc)
79	*
80	* @see
81	* org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#hookControllerLogic
82	* (org.eclipse.e4.ui.model.application.MUIElement)
83	*/
84	@Override
85	public void hookControllerLogic(MUIElement me) {
86	super.hookControllerLogic(me);
87
88	// 'Execute' the operation if possible
89	if (me instanceof MDirectMenuItem
90	&& ((MDirectMenuItem) me).getContributionURI() != null) {
91	final MMenuItem item = (MMenuItem) me;
92	final MDirectMenuItem contrib = (MDirectMenuItem) me;
93	final IEclipseContext lclContext = getContext(me);
94	MenuItem mi = (MenuItem) me.getWidget();
95	mi.addSelectionListener(new SelectionListener() {
96	public void widgetSelected(SelectionEvent e) {
97	if (contrib.getObject() == null) {
98	IContributionFactory cf = (IContributionFactory) lclContext
99	.get(IContributionFactory.class.getName());
100	contrib.setObject(cf.create(
101	contrib.getContributionURI(), lclContext));
102	}
103	lclContext.set(MItem.class.getName(), item);
104	ContextInjectionFactory.invoke(contrib.getObject(),
105	Execute.class, lclContext);
106	lclContext.remove(MItem.class.getName());
107	}
108
109	public void widgetDefaultSelected(SelectionEvent e) {
110	}
111	});
112	}
113	}
114	}

Added Link Here

(-)src/org/eclipse/e4/ui/workbench/renderers/swt/MenuItemRenderer.java (+236 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 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 org.eclipse.e4.ui.internal.workbench.swt.WorkbenchSWTActivator;
14
15	import java.util.HashMap;
16	import javax.annotation.PostConstruct;
17	import javax.annotation.PreDestroy;
18	import javax.inject.Inject;
19	import org.eclipse.core.expressions.EvaluationResult;
20	import org.eclipse.core.expressions.Expression;
21	import org.eclipse.core.internal.expressions.ReferenceExpression;
22	import org.eclipse.core.runtime.CoreException;
23	import org.eclipse.e4.core.contexts.IEclipseContext;
24	import org.eclipse.e4.core.contexts.RunAndTrack;
25	import org.eclipse.e4.core.services.events.IEventBroker;
26	import org.eclipse.e4.core.services.log.Logger;
27	import org.eclipse.e4.ui.model.application.ui.MCoreExpression;
28	import org.eclipse.e4.ui.model.application.ui.MElementContainer;
29	import org.eclipse.e4.ui.model.application.ui.MUIElement;
30	import org.eclipse.e4.ui.model.application.ui.menu.ItemType;
31	import org.eclipse.e4.ui.model.application.ui.menu.MItem;
32	import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
33	import org.eclipse.e4.ui.workbench.UIEvents;
34	import org.eclipse.e4.ui.workbench.modeling.ExpressionContext;
35	import org.eclipse.swt.events.SelectionEvent;
36	import org.eclipse.swt.events.SelectionListener;
37	import org.eclipse.swt.widgets.MenuItem;
38	import org.eclipse.swt.widgets.Widget;
39	import org.osgi.service.event.Event;
40	import org.osgi.service.event.EventHandler;
41
42	/**
43	* Create a contribute part.
44	*/
45	public abstract class MenuItemRenderer extends SWTPartRenderer {
46	static class VisibleRAT extends RunAndTrack {
47	Expression exp;
48	MMenuItem item;
49	ExpressionContext ec;
50	boolean participating = true;
51
52	public VisibleRAT(MMenuItem i, Expression e, IEclipseContext c) {
53	exp = e;
54	item = i;
55	ec = new ExpressionContext(c);
56	}
57
58	/*
59	* (non-Javadoc)
60	*
61	* @see
62	* org.eclipse.e4.core.contexts.RunAndTrack#changed(org.eclipse.e4.core
63	* .contexts.IEclipseContext)
64	*/
65	@Override
66	public boolean changed(IEclipseContext context) {
67	try {
68	item.setVisible(EvaluationResult.FALSE != exp.evaluate(ec));
69	} catch (CoreException e) {
70	item.setVisible(false);
71	WorkbenchSWTActivator.trace(
72	"/trace/menus", "VisibleRAT failed", e); //$NON-NLS-1$//$NON-NLS-2$
73	}
74	return participating;
75	}
76	}
77
78	private HashMap<MMenuItem, Expression> menuItemToExpression = new HashMap<MMenuItem, Expression>();
79	private HashMap<MMenuItem, VisibleRAT> menuItemToRAT = new HashMap<MMenuItem, VisibleRAT>();
80
81	@Inject
82	Logger logger;
83	@Inject
84	IEventBroker eventBroker;
85	private EventHandler itemUpdater = new EventHandler() {
86	public void handleEvent(Event event) {
87	// Ensure that this event is for a MMenuItem
88	if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
89	return;
90
91	MMenuItem itemModel = (MMenuItem) event
92	.getProperty(UIEvents.EventTags.ELEMENT);
93	MenuItem menuItem = (MenuItem) itemModel.getWidget();
94
95	// No widget == nothing to update
96	if (menuItem == null)
97	return;
98
99	String attName = (String) event
100	.getProperty(UIEvents.EventTags.ATTNAME);
101	if (UIEvents.UILabel.LABEL.equals(attName)) {
102	setItemText(itemModel, menuItem);
103	} else if (UIEvents.UILabel.ICONURI.equals(attName)) {
104	menuItem.setImage(getImage(itemModel));
105	}
106	}
107	};
108
109	private EventHandler selectionUpdater = new EventHandler() {
110	public void handleEvent(Event event) {
111	// Ensure that this event is for a MToolItem
112	if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
113	return;
114
115	MMenuItem itemModel = (MMenuItem) event
116	.getProperty(UIEvents.EventTags.ELEMENT);
117	MenuItem menuItem = (MenuItem) itemModel.getWidget();
118	if (menuItem != null) {
119	menuItem.setSelection(itemModel.isSelected());
120	}
121	}
122	};
123
124	private EventHandler enabledUpdater = new EventHandler() {
125	public void handleEvent(Event event) {
126	// Ensure that this event is for a MMenuItem
127	if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
128	return;
129
130	MMenuItem itemModel = (MMenuItem) event
131	.getProperty(UIEvents.EventTags.ELEMENT);
132	MenuItem menuItem = (MenuItem) itemModel.getWidget();
133	if (menuItem != null) {
134	menuItem.setEnabled(itemModel.isEnabled());
135	}
136	}
137	};
138
139	@PostConstruct
140	public void init() {
141	eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UILabel.TOPIC),
142	itemUpdater);
143	eventBroker.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
144	UIEvents.Item.SELECTED), selectionUpdater);
145	eventBroker
146	.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
147	UIEvents.Item.ENABLED), enabledUpdater);
148	}
149
150	@PreDestroy
151	public void contextDisposed() {
152	eventBroker.unsubscribe(itemUpdater);
153	eventBroker.unsubscribe(selectionUpdater);
154	eventBroker.unsubscribe(enabledUpdater);
155	}
156
157	protected void processVisible(MMenuItem item) {
158	if (menuItemToExpression.get(item) != null) {
159	return;
160	}
161	MCoreExpression exp = (MCoreExpression) item.getVisibleWhen();
162	Expression ref = null;
163	if (exp.getCoreExpression() instanceof Expression) {
164	ref = (Expression) exp.getCoreExpression();
165	} else {
166	ref = new ReferenceExpression(exp.getCoreExpressionId());
167	exp.setCoreExpression(ref);
168	}
169	menuItemToExpression.put(item, ref);
170	IEclipseContext itemContext = getContext(item);
171	VisibleRAT rat = new VisibleRAT(item, ref, itemContext);
172	menuItemToRAT.put(item, rat);
173	itemContext.runAndTrack(rat);
174	}
175
176	/*
177	* (non-Javadoc)
178	*
179	* @see
180	* org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#hideChild
181	* (org.eclipse.e4.ui.model.application.MElementContainer,
182	* org.eclipse.e4.ui.model.application.MUIElement)
183	*/
184	@Override
185	public void hideChild(MElementContainer<MUIElement> parentElement,
186	MUIElement child) {
187	super.hideChild(parentElement, child);
188
189	// Since there's no place to 'store' a child that's not in a menu
190	// we'll blow it away and re-create on an add
191	Widget widget = (Widget) child.getWidget();
192	if (widget != null && !widget.isDisposed())
193	widget.dispose();
194	menuItemToExpression.remove(child);
195	VisibleRAT rat = menuItemToRAT.remove(child);
196	if (rat != null) {
197	rat.participating = false;
198	}
199	}
200
201	protected void setItemText(MMenuItem model, MenuItem item) {
202	String text = model.getLabel();
203	if (text == null) {
204	text = ""; //$NON-NLS-1$
205	}
206	item.setText(text);
207	}
208
209	/*
210	* (non-Javadoc)
211	*
212	* @see
213	* org.eclipse.e4.ui.workbench.renderers.swt.SWTPartRenderer#hookControllerLogic
214	* (org.eclipse.e4.ui.model.application.MUIElement)
215	*/
216	@Override
217	public void hookControllerLogic(MUIElement me) {
218	// If the item is a CHECK or RADIO update the model's state to match
219	if (me instanceof MItem) {
220	final MItem item = (MItem) me;
221	if (item.getType() == ItemType.CHECK
222	\|\| item.getType() == ItemType.RADIO) {
223	MenuItem ti = (MenuItem) me.getWidget();
224	ti.addSelectionListener(new SelectionListener() {
225	public void widgetSelected(SelectionEvent e) {
226	item.setSelected(((MenuItem) e.widget).getSelection());
227	}
228
229	public void widgetDefaultSelected(SelectionEvent e) {
230	item.setSelected(((MenuItem) e.widget).getSelection());
231	}
232	});
233	}
234	}
235	}
236	}

Added Link Here

(-)src/org/eclipse/e4/ui/workbench/swt/modeling/MenuManagerServiceFilter.java (+193 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.swt.modeling;
12
13	import java.lang.reflect.Method;
14	import java.util.HashMap;
15	import javax.inject.Inject;
16	import org.eclipse.core.runtime.ISafeRunnable;
17	import org.eclipse.core.runtime.SafeRunner;
18	import org.eclipse.e4.core.contexts.IEclipseContext;
19	import org.eclipse.e4.core.services.log.Logger;
20	import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
21	import org.eclipse.e4.ui.internal.workbench.swt.Policy;
22	import org.eclipse.e4.ui.internal.workbench.swt.WorkbenchSWTActivator;
23	import org.eclipse.e4.ui.model.application.MApplication;
24	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
25	import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;
26	import org.eclipse.e4.ui.workbench.IPresentationEngine;
27	import org.eclipse.e4.ui.workbench.modeling.EModelService;
28	import org.eclipse.jface.action.MenuManager;
29	import org.eclipse.swt.SWT;
30	import org.eclipse.swt.widgets.Event;
31	import org.eclipse.swt.widgets.Listener;
32	import org.eclipse.swt.widgets.Menu;
33	import org.eclipse.swt.widgets.Widget;
34
35	public class MenuManagerServiceFilter implements Listener {
36	public static final String NUL_MENU_ITEM = "(None Applicable)"; //$NON-NLS-1$
37
38	private static final String TMP_ORIGINAL_CONTEXT = "MenuServiceFilter.original.context";
39
40	private static void trace(String msg, Widget menu, MMenu menuModel) {
41	WorkbenchSWTActivator.trace(Policy.MENUS, msg + ": " + menu + ": "
42	+ menuModel, null);
43	}
44
45	private static Method aboutToShow;
46
47	public static Method getAboutToShow() {
48	if (aboutToShow == null) {
49	try {
50	aboutToShow = MenuManager.class
51	.getDeclaredMethod("handleAboutToShow");
52	aboutToShow.setAccessible(true);
53	} catch (SecurityException e) {
54	// TODO Auto-generated catch block
55	e.printStackTrace();
56	} catch (NoSuchMethodException e) {
57	// TODO Auto-generated catch block
58	e.printStackTrace();
59	}
60	}
61	return aboutToShow;
62	}
63
64	@Inject
65	private MApplication application;
66
67	@Inject
68	private IPresentationEngine renderer;
69
70	@Inject
71	private Logger logger;
72
73	@Inject
74	EModelService modelService;
75
76	private HashMap<Menu, Runnable> pendingCleanup = new HashMap<Menu, Runnable>();
77
78	public void handleEvent(final Event event) {
79	// wrap the handling in a SafeRunner so that exceptions do not prevent
80	// the menu from being shown
81	SafeRunner.run(new ISafeRunnable() {
82	public void handleException(Throwable e) {
83	if (e instanceof Error) {
84	// errors are deadly, we shouldn't ignore these
85	throw (Error) e;
86	} else {
87	// log exceptions otherwise
88	if (logger != null) {
89	logger.error(e);
90	}
91	}
92	}
93
94	public void run() throws Exception {
95	safeHandleEvent(event);
96	}
97	});
98	}
99
100	private void safeHandleEvent(Event event) {
101	if (!(event.widget instanceof Menu)) {
102	return;
103	}
104	final Menu menu = (Menu) event.widget;
105	if (event.type == SWT.Dispose) {
106	trace("handleMenu.Dispose", menu, null);
107	cleanUp(menu);
108	}
109	Object obj = menu.getData(AbstractPartRenderer.OWNING_ME);
110	if (obj == null && menu.getParentItem() != null) {
111	obj = menu.getParentItem().getData(AbstractPartRenderer.OWNING_ME);
112	}
113	if (obj instanceof MPopupMenu) {
114	handleContextMenu(event, menu, (MPopupMenu) obj);
115	} else if (obj instanceof MMenu) {
116	handleMenu(event, menu, (MMenu) obj);
117	}
118	}
119
120	private void handleMenu(final Event event, final Menu menu,
121	final MMenu menuModel) {
122	if ((menu.getStyle() & SWT.BAR) != 0) {
123	// don't process the menu bar, it's not fair :-)
124	return;
125	}
126	switch (event.type) {
127	case SWT.Show:
128	cleanUp(menu);
129	showMenu(event, menu, menuModel);
130	break;
131	case SWT.Hide:
132	// TODO we'll clean up on show
133	break;
134	}
135	}
136
137	public void showMenu(final Event event, final Menu menu,
138	final MMenu menuModel) {
139	// System.err.println("showMenu: " + menuModel + "\n\t" + menu);
140	}
141
142	private void handleContextMenu(final Event event, final Menu menu,
143	final MPopupMenu menuModel) {
144	switch (event.type) {
145	case SWT.Show:
146	cleanUp(menu);
147	showPopup(event, menu, menuModel);
148	break;
149	case SWT.Hide:
150	hidePopup(event, menu, menuModel);
151	break;
152	}
153	}
154
155	public void hidePopup(Event event, Menu menu, MPopupMenu menuModel) {
156	// System.err.println("hidePopup: " + menuModel + "\n\t" + menu);
157	final IEclipseContext popupContext = menuModel.getContext();
158	final IEclipseContext originalChild = (IEclipseContext) popupContext
159	.get(TMP_ORIGINAL_CONTEXT);
160	popupContext.remove(TMP_ORIGINAL_CONTEXT);
161	if (!menu.isDisposed()) {
162	menu.getDisplay().asyncExec(new Runnable() {
163	public void run() {
164	if (originalChild == null) {
165	popupContext.deactivate();
166	} else {
167	originalChild.activate();
168	}
169	}
170	});
171	}
172	}
173
174	public void showPopup(final Event event, final Menu menu,
175	final MPopupMenu menuModel) {
176	// System.err.println("showPopup: " + menuModel + "\n\t" + menu);
177	// we need some context foolery here
178	final IEclipseContext popupContext = menuModel.getContext();
179	final IEclipseContext parentContext = popupContext.getParent();
180	final IEclipseContext originalChild = parentContext.getActiveChild();
181	popupContext.activate();
182	popupContext.set(TMP_ORIGINAL_CONTEXT, originalChild);
183
184	}
185
186	public void cleanUp(final Menu menu) {
187	// System.err.println("cleanUp: " + menu);
188	}
189
190	public void dispose() {
191	// System.err.println("dispose");
192	}
193	}

Lines 17-23 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/e4/compatibility/ActionBars.java (-5 / +4 lines)
17	import org.eclipse.e4.ui.model.application.ui.MUIElement;	17	import org.eclipse.e4.ui.model.application.ui.MUIElement;
18	import org.eclipse.e4.ui.model.application.ui.advanced.MPlaceholder;	18	import org.eclipse.e4.ui.model.application.ui.advanced.MPlaceholder;
19	import org.eclipse.e4.ui.model.application.ui.basic.MPart;	19	import org.eclipse.e4.ui.model.application.ui.basic.MPart;
20	import org.eclipse.e4.ui.model.application.ui.menu.MToolBar;	20	import org.eclipse.e4.ui.model.application.ui.menu.MRenderedToolBar;
21	import org.eclipse.e4.ui.workbench.IPresentationEngine;	21	import org.eclipse.e4.ui.workbench.IPresentationEngine;
22	import org.eclipse.jface.action.IMenuManager;	22	import org.eclipse.jface.action.IMenuManager;
23	import org.eclipse.jface.action.IToolBarManager;	23	import org.eclipse.jface.action.IToolBarManager;
Lines 84-101 Link Here
84	if (tbCtrl != null && !tbCtrl.isDisposed()) {	84	if (tbCtrl != null && !tbCtrl.isDisposed()) {
85	MUIElement tbModel = (MUIElement) tbCtrl	85	MUIElement tbModel = (MUIElement) tbCtrl
86	.getData(AbstractPartRenderer.OWNING_ME);	86	.getData(AbstractPartRenderer.OWNING_ME);
87	if (tbModel instanceof MToolBar) {	87	if (tbModel instanceof MRenderedToolBar) {
88	// only force a rerender if the toolbar can be seen	88	// only force a rerender if the toolbar can be seen
89	if (isSelected(part)) {	89	if (isSelected(part)) {
90	Object tbParent = tbCtrl.getParent();
91	if (part.getContext() != null) {	90	if (part.getContext() != null) {
92	IPresentationEngine renderer = part.getContext().get(	91	IPresentationEngine renderer = part.getContext().get(
93	IPresentationEngine.class);	92	IPresentationEngine.class);
94	if (renderer != null) {	93	if (renderer != null) {
95	renderer.removeGui(tbModel);	94	renderer.removeGui(tbModel);
96	renderer.createGui(tbModel, tbParent,	95	renderer.createGui(tbModel, tbCtrl.getParent(),
97	part.getContext());	96	part.getContext());
98	((Control) tbModel.getWidget()).getParent().layout();	97	tbCtrl.getParent().layout();
99	}	98	}
100	}	99	}
101	}	100	}

Lines 12-28 Link Here

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