Attachment 180268 Details for Bug 325392 – patch of work so far.

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

[patch] patch of work so far.

menu.patch (text/plain), 149.78 KB, created by Paul Webster

on 2010-10-05 14:06:38 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Paul Webster

Created: 2010-10-05 14:06:38 EDT

Size: 149.78 KB

patch

obsolete

>From 7ee7596dfb6248a7bc8d4d7fa19427732ffceb86 Mon Sep 17 00:00:00 2001
>From: Paul Webster <pwebster@ca.ibm.com>
>Date: Fri, 1 Oct 2010 14:58:22 -0400
>Subject: [PATCH 1/5] Bug 325392 -  Render menu and toolbar contributions using the ContributionManagers
> Moving to git to allow much easier re-base of
> CVS HEAD (in this case, mapped to origin not master)
>
>
>diff --git a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/DirectContributionItem.java b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/DirectContributionItem.java
>new file mode 100644
>index 0000000..3670a00
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/DirectContributionItem.java
>@@ -0,0 +1,412 @@
>+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.CanExecute;
>+import org.eclipse.e4.core.di.annotations.Execute;
>+import org.eclipse.e4.core.services.contributions.IContributionFactory;
>+import org.eclipse.e4.ui.internal.workbench.Activator;
>+import org.eclipse.e4.ui.internal.workbench.Policy;
>+import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
>+import org.eclipse.e4.ui.model.application.MContribution;
>+import org.eclipse.e4.ui.model.application.ui.MContext;
>+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.MItem;
>+import org.eclipse.e4.ui.workbench.IResourceUtilities;
>+import org.eclipse.e4.ui.workbench.modeling.EModelService;
>+import org.eclipse.e4.ui.workbench.swt.util.ISWTResourceUtilities;
>+import org.eclipse.emf.common.util.URI;
>+import org.eclipse.jface.action.ContributionItem;
>+import org.eclipse.jface.action.IContributionManager;
>+import org.eclipse.jface.action.IMenuListener;
>+import org.eclipse.jface.action.IMenuManager;
>+import org.eclipse.jface.resource.DeviceResourceException;
>+import org.eclipse.jface.resource.ImageDescriptor;
>+import org.eclipse.jface.resource.JFaceResources;
>+import org.eclipse.jface.resource.LocalResourceManager;
>+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.ToolBar;
>+import org.eclipse.swt.widgets.ToolItem;
>+import org.eclipse.swt.widgets.Widget;
>+
>+public class DirectContributionItem extends ContributionItem {
>+	private MItem model;
>+	private Widget widget;
>+	private Listener menuItemListener;
>+	private LocalResourceManager localResourceManager;
>+
>+	@Inject
>+	private IContributionFactory contribFactory;
>+
>+	@Inject
>+	private EModelService modelService;
>+
>+	private ISWTResourceUtilities resUtils = null;
>+
>+	@Inject
>+	void setResourceUtils(IResourceUtilities utils) {
>+		resUtils = (ISWTResourceUtilities) utils;
>+	}
>+
>+	private IMenuListener menuListener = new IMenuListener() {
>+		public void menuAboutToShow(IMenuManager manager) {
>+			update(null);
>+		}
>+	};
>+
>+	public void setModel(MItem item) {
>+		model = item;
>+		setId(model.getElementId());
>+		updateVisible();
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see
>+	 * org.eclipse.jface.action.ContributionItem#fill(org.eclipse.swt.widgets
>+	 * .Menu, int)
>+	 */
>+	@Override
>+	public void fill(Menu menu, int index) {
>+		if (model == null) {
>+			return;
>+		}
>+		if (widget != null) {
>+			return;
>+		}
>+		int style = SWT.PUSH;
>+		if (model.getType() == ItemType.PUSH)
>+			style = SWT.PUSH;
>+		else if (model.getType() == ItemType.CHECK)
>+			style = SWT.CHECK;
>+		else if (model.getType() == ItemType.RADIO)
>+			style = SWT.RADIO;
>+		MenuItem item = null;
>+		if (index >= 0) {
>+			item = new MenuItem(menu, style, index);
>+		} else {
>+			item = new MenuItem(menu, style);
>+		}
>+		item.setData(this);
>+
>+		item.addListener(SWT.Dispose, getItemListener());
>+		item.addListener(SWT.Selection, getItemListener());
>+		item.addListener(SWT.DefaultSelection, getItemListener());
>+
>+		widget = item;
>+		model.setWidget(widget);
>+		widget.setData(AbstractPartRenderer.OWNING_ME, model);
>+
>+		update(null);
>+		updateIcons();
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see
>+	 * org.eclipse.jface.action.ContributionItem#fill(org.eclipse.swt.widgets
>+	 * .ToolBar, int)
>+	 */
>+	@Override
>+	public void fill(ToolBar parent, int index) {
>+		if (model == null) {
>+			return;
>+		}
>+		if (widget != null) {
>+			return;
>+		}
>+		int style = SWT.PUSH;
>+		if (model.getType() == ItemType.PUSH)
>+			style = SWT.PUSH;
>+		else if (model.getType() == ItemType.CHECK)
>+			style = SWT.CHECK;
>+		else if (model.getType() == ItemType.RADIO)
>+			style = SWT.RADIO;
>+		ToolItem item = null;
>+		if (index >= 0) {
>+			item = new ToolItem(parent, style, index);
>+		} else {
>+			item = new ToolItem(parent, style);
>+		}
>+		item.setData(this);
>+
>+		item.addListener(SWT.Dispose, getItemListener());
>+		item.addListener(SWT.Selection, getItemListener());
>+		item.addListener(SWT.DefaultSelection, getItemListener());
>+
>+		widget = item;
>+		model.setWidget(widget);
>+		widget.setData(AbstractPartRenderer.OWNING_ME, model);
>+
>+		update(null);
>+		updateIcons();
>+	}
>+
>+	private void updateVisible() {
>+		setVisible((model).isVisible());
>+		final IContributionManager parent = getParent();
>+		if (parent != null) {
>+			parent.markDirty();
>+		}
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.jface.action.ContributionItem#update()
>+	 */
>+	@Override
>+	public void update() {
>+		update(null);
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.jface.action.ContributionItem#update(java.lang.String)
>+	 */
>+	@Override
>+	public void update(String id) {
>+		if (widget instanceof MenuItem) {
>+			updateMenuItem();
>+		} else if (widget instanceof ToolItem) {
>+			updateToolItem();
>+		}
>+	}
>+
>+	private void updateMenuItem() {
>+		MenuItem item = (MenuItem) widget;
>+		String text = model.getLabel();
>+		if (text != null) {
>+			item.setText(text);
>+		} else {
>+			item.setText(""); //$NON-NLS-1$
>+		}
>+		item.setSelection(model.isSelected());
>+		item.setEnabled(model.isEnabled());
>+	}
>+
>+	private void updateToolItem() {
>+		ToolItem item = (ToolItem) widget;
>+		final String text = model.getLabel();
>+		if (text != null) {
>+			item.setText(text);
>+		} else {
>+			item.setText(""); //$NON-NLS-1$
>+		}
>+		final String tooltip = model.getTooltip();
>+		item.setToolTipText(tooltip);
>+
>+		item.setSelection(model.isSelected());
>+		item.setEnabled(model.isEnabled());
>+	}
>+
>+	private void updateIcons() {
>+		if (widget instanceof MenuItem) {
>+			MenuItem item = (MenuItem) widget;
>+			LocalResourceManager m = new LocalResourceManager(
>+					JFaceResources.getResources());
>+			String iconURI = model.getIconURI();
>+			ImageDescriptor icon = getImageDescriptor(model);
>+			try {
>+				item.setImage(icon == null ? null : m.createImage(icon));
>+			} catch (DeviceResourceException e) {
>+				icon = ImageDescriptor.getMissingImageDescriptor();
>+				item.setImage(m.createImage(icon));
>+				// as we replaced the failed icon, log the message once.
>+				Activator.trace(Policy.DEBUG_MENUS,
>+						"failed to create image " + iconURI, e); //$NON-NLS-1$
>+			}
>+			disposeOldImages();
>+			localResourceManager = m;
>+		} else if (widget instanceof ToolItem) {
>+			ToolItem item = (ToolItem) widget;
>+			LocalResourceManager m = new LocalResourceManager(
>+					JFaceResources.getResources());
>+			String iconURI = model.getIconURI();
>+			ImageDescriptor icon = getImageDescriptor(model);
>+			try {
>+				item.setImage(icon == null ? null : m.createImage(icon));
>+			} catch (DeviceResourceException e) {
>+				icon = ImageDescriptor.getMissingImageDescriptor();
>+				item.setImage(m.createImage(icon));
>+				// as we replaced the failed icon, log the message once.
>+				Activator.trace(Policy.DEBUG_MENUS,
>+						"failed to create image " + iconURI, e); //$NON-NLS-1$
>+			}
>+			disposeOldImages();
>+			localResourceManager = m;
>+		}
>+	}
>+
>+	private void disposeOldImages() {
>+		if (localResourceManager != null) {
>+			localResourceManager.dispose();
>+			localResourceManager = null;
>+		}
>+	}
>+
>+	private Listener getItemListener() {
>+		if (menuItemListener == null) {
>+			menuItemListener = new Listener() {
>+				public void handleEvent(Event event) {
>+					switch (event.type) {
>+					case SWT.Dispose:
>+						handleWidgetDispose(event);
>+						break;
>+					case SWT.DefaultSelection:
>+					case SWT.Selection:
>+						if (event.widget != null) {
>+							handleWidgetSelection(event);
>+						}
>+						break;
>+					}
>+				}
>+			};
>+		}
>+		return menuItemListener;
>+	}
>+
>+	private void handleWidgetDispose(Event event) {
>+		if (event.widget == widget) {
>+			widget.removeListener(SWT.Selection, getItemListener());
>+			widget.removeListener(SWT.Dispose, getItemListener());
>+			widget.removeListener(SWT.DefaultSelection, getItemListener());
>+			widget = null;
>+			model.setWidget(null);
>+			disposeOldImages();
>+		}
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.jface.action.ContributionItem#dispose()
>+	 */
>+	@Override
>+	public void dispose() {
>+		if (widget != null) {
>+			widget.dispose();
>+			widget = null;
>+			model.setWidget(null);
>+		}
>+	}
>+
>+	private void handleWidgetSelection(Event event) {
>+		if (widget != null && !widget.isDisposed()) {
>+			if (model.getType() == ItemType.CHECK
>+					|| model.getType() == ItemType.RADIO) {
>+				boolean selection = false;
>+				if (widget instanceof MenuItem) {
>+					selection = ((MenuItem) widget).getSelection();
>+				} else if (widget instanceof ToolItem) {
>+					selection = ((ToolItem) widget).getSelection();
>+				}
>+				model.setSelected(selection);
>+			}
>+			if (canExecuteItem()) {
>+				executeItem();
>+			}
>+		}
>+	}
>+
>+	private void executeItem() {
>+		final IEclipseContext lclContext = getContext(model);
>+		if (!checkContribution(lclContext)) {
>+			return;
>+		}
>+		MContribution contrib = (MContribution) model;
>+		lclContext.set(MItem.class, model);
>+		ContextInjectionFactory.invoke(contrib.getObject(), Execute.class,
>+				lclContext);
>+		lclContext.remove(MItem.class);
>+	}
>+
>+	private boolean canExecuteItem() {
>+		final IEclipseContext lclContext = getContext(model);
>+		if (!checkContribution(lclContext)) {
>+			return false;
>+		}
>+		MContribution contrib = (MContribution) model;
>+		lclContext.set(MItem.class, model);
>+		try {
>+			Boolean result = ((Boolean) ContextInjectionFactory.invoke(
>+					contrib.getObject(), CanExecute.class, lclContext,
>+					Boolean.TRUE));
>+			return result.booleanValue();
>+		} finally {
>+			lclContext.remove(MItem.class);
>+		}
>+	}
>+
>+	private boolean checkContribution(IEclipseContext lclContext) {
>+		if (!(model instanceof MContribution)) {
>+			return false;
>+		}
>+		MContribution contrib = (MContribution) model;
>+		if (contrib.getObject() == null) {
>+			contrib.setObject(contribFactory.create(
>+					contrib.getContributionURI(), lclContext));
>+		}
>+		return contrib.getObject() != null;
>+	}
>+
>+	public void setParent(IContributionManager parent) {
>+		if (getParent() instanceof IMenuManager) {
>+			IMenuManager menuMgr = (IMenuManager) getParent();
>+			menuMgr.removeMenuListener(menuListener);
>+		}
>+		if (parent instanceof IMenuManager) {
>+			IMenuManager menuMgr = (IMenuManager) parent;
>+			menuMgr.addMenuListener(menuListener);
>+		}
>+		super.setParent(parent);
>+	}
>+
>+	private ImageDescriptor getImageDescriptor(MUILabel element) {
>+		String iconURI = element.getIconURI();
>+		if (iconURI != null && iconURI.length() > 0) {
>+			return resUtils.imageDescriptorFromURI(URI.createURI(iconURI));
>+		}
>+		return null;
>+	}
>+
>+	/**
>+	 * Return a parent context for this part.
>+	 * 
>+	 * @param element
>+	 *            the part to start searching from
>+	 * @return the parent's closest context, or global context if none in the
>+	 *         hierarchy
>+	 */
>+	protected IEclipseContext getContextForParent(MUIElement element) {
>+		return modelService.getContainingContext(element);
>+	}
>+
>+	/**
>+	 * Return a context for this part.
>+	 * 
>+	 * @param part
>+	 *            the part to start searching from
>+	 * @return the closest context, or global context if none in the hierarchy
>+	 */
>+	protected IEclipseContext getContext(MUIElement part) {
>+		if (part instanceof MContext) {
>+			return ((MContext) part).getContext();
>+		}
>+		return getContextForParent(part);
>+	}
>+
>+	public Widget getWidget() {
>+		return widget;
>+	}
>+}
>\ No newline at end of file
>diff --git a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/HandledContributionItem.java b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/HandledContributionItem.java
>new file mode 100644
>index 0000000..dc94518
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/HandledContributionItem.java
>@@ -0,0 +1,443 @@
>+package org.eclipse.e4.ui.workbench.renderers.swt;
>+
>+import java.util.HashMap;
>+import java.util.List;
>+import javax.inject.Inject;
>+import org.eclipse.core.commands.ParameterizedCommand;
>+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.ui.bindings.EBindingService;
>+import org.eclipse.e4.ui.internal.workbench.Activator;
>+import org.eclipse.e4.ui.internal.workbench.Policy;
>+import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
>+import org.eclipse.e4.ui.model.application.commands.MParameter;
>+import org.eclipse.e4.ui.model.application.ui.MContext;
>+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.workbench.IResourceUtilities;
>+import org.eclipse.e4.ui.workbench.modeling.EModelService;
>+import org.eclipse.e4.ui.workbench.swt.util.ISWTResourceUtilities;
>+import org.eclipse.emf.common.util.URI;
>+import org.eclipse.jface.action.ContributionItem;
>+import org.eclipse.jface.action.IContributionManager;
>+import org.eclipse.jface.action.IMenuListener;
>+import org.eclipse.jface.action.IMenuManager;
>+import org.eclipse.jface.bindings.TriggerSequence;
>+import org.eclipse.jface.resource.DeviceResourceException;
>+import org.eclipse.jface.resource.ImageDescriptor;
>+import org.eclipse.jface.resource.JFaceResources;
>+import org.eclipse.jface.resource.LocalResourceManager;
>+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.ToolBar;
>+import org.eclipse.swt.widgets.ToolItem;
>+import org.eclipse.swt.widgets.Widget;
>+
>+public class HandledContributionItem extends ContributionItem {
>+	private MHandledItem model;
>+	private Widget widget;
>+	private Listener menuItemListener;
>+	private LocalResourceManager localResourceManager;
>+
>+	@Inject
>+	private ECommandService commandService;
>+
>+	@Inject
>+	private EModelService modelService;
>+
>+	@Inject
>+	private EBindingService bindingService;
>+
>+	private ISWTResourceUtilities resUtils = null;
>+
>+	@Inject
>+	void setResourceUtils(IResourceUtilities utils) {
>+		resUtils = (ISWTResourceUtilities) utils;
>+	}
>+
>+	private IMenuListener menuListener = new IMenuListener() {
>+		public void menuAboutToShow(IMenuManager manager) {
>+			update(null);
>+		}
>+	};
>+
>+	public void setModel(MHandledItem item) {
>+		model = item;
>+		setId(model.getElementId());
>+		generateCommand();
>+		updateVisible();
>+	}
>+
>+	/**
>+	 * 
>+	 */
>+	private void generateCommand() {
>+		if (model.getCommand() == null) {
>+			return;
>+		}
>+		if (model.getWbCommand() == null) {
>+			String cmdId = model.getCommand().getElementId();
>+			final List<MParameter> modelParms = model.getParameters();
>+			if (modelParms.isEmpty()) {
>+				final ParameterizedCommand parmCmd = commandService
>+						.createCommand(cmdId, null);
>+				Activator
>+						.trace(Policy.DEBUG_MENUS, "command: " + parmCmd, null); //$NON-NLS-1$
>+				model.setWbCommand(parmCmd);
>+				return;
>+			}
>+			HashMap<String, String> parms = new HashMap<String, String>();
>+			for (MParameter parm : modelParms) {
>+				parms.put(parm.getName(), parm.getValue());
>+			}
>+			final ParameterizedCommand parmCmd = commandService.createCommand(
>+					cmdId, parms);
>+			Activator.trace(Policy.DEBUG_MENUS, "command: " + parmCmd, null); //$NON-NLS-1$
>+			model.setWbCommand(parmCmd);
>+		}
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see
>+	 * org.eclipse.jface.action.ContributionItem#fill(org.eclipse.swt.widgets
>+	 * .Menu, int)
>+	 */
>+	@Override
>+	public void fill(Menu menu, int index) {
>+		if (model == null) {
>+			return;
>+		}
>+		if (widget != null) {
>+			return;
>+		}
>+		int style = SWT.PUSH;
>+		if (model.getType() == ItemType.PUSH)
>+			style = SWT.PUSH;
>+		else if (model.getType() == ItemType.CHECK)
>+			style = SWT.CHECK;
>+		else if (model.getType() == ItemType.RADIO)
>+			style = SWT.RADIO;
>+		MenuItem item = null;
>+		if (index >= 0) {
>+			item = new MenuItem(menu, style, index);
>+		} else {
>+			item = new MenuItem(menu, style);
>+		}
>+		item.setData(this);
>+
>+		item.addListener(SWT.Dispose, getItemListener());
>+		item.addListener(SWT.Selection, getItemListener());
>+		item.addListener(SWT.DefaultSelection, getItemListener());
>+
>+		widget = item;
>+		model.setWidget(widget);
>+		widget.setData(AbstractPartRenderer.OWNING_ME, model);
>+
>+		update(null);
>+		updateIcons();
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see
>+	 * org.eclipse.jface.action.ContributionItem#fill(org.eclipse.swt.widgets
>+	 * .ToolBar, int)
>+	 */
>+	@Override
>+	public void fill(ToolBar parent, int index) {
>+		if (model == null) {
>+			return;
>+		}
>+		if (widget != null) {
>+			return;
>+		}
>+		int style = SWT.PUSH;
>+		if (model.getType() == ItemType.PUSH)
>+			style = SWT.PUSH;
>+		else if (model.getType() == ItemType.CHECK)
>+			style = SWT.CHECK;
>+		else if (model.getType() == ItemType.RADIO)
>+			style = SWT.RADIO;
>+		ToolItem item = null;
>+		if (index >= 0) {
>+			item = new ToolItem(parent, style, index);
>+		} else {
>+			item = new ToolItem(parent, style);
>+		}
>+		item.setData(this);
>+
>+		item.addListener(SWT.Dispose, getItemListener());
>+		item.addListener(SWT.Selection, getItemListener());
>+		item.addListener(SWT.DefaultSelection, getItemListener());
>+
>+		widget = item;
>+		model.setWidget(widget);
>+		widget.setData(AbstractPartRenderer.OWNING_ME, model);
>+
>+		update(null);
>+		updateIcons();
>+	}
>+
>+	private void updateVisible() {
>+		setVisible((model).isVisible());
>+		final IContributionManager parent = getParent();
>+		if (parent != null) {
>+			parent.markDirty();
>+		}
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.jface.action.ContributionItem#update()
>+	 */
>+	@Override
>+	public void update() {
>+		update(null);
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.jface.action.ContributionItem#update(java.lang.String)
>+	 */
>+	@Override
>+	public void update(String id) {
>+		if (widget instanceof MenuItem) {
>+			updateMenuItem();
>+		} else if (widget instanceof ToolItem) {
>+			updateToolItem();
>+		}
>+	}
>+
>+	private void updateMenuItem() {
>+		MenuItem item = (MenuItem) widget;
>+		String text = model.getLabel();
>+		ParameterizedCommand parmCmd = model.getWbCommand();
>+		String keyBindingText = null;
>+		if (parmCmd != null) {
>+			if (bindingService != null) {
>+				TriggerSequence binding = bindingService
>+						.getBestSequenceFor(parmCmd);
>+				if (binding != null)
>+					keyBindingText = binding.format();
>+			}
>+		}
>+		if (text != null) {
>+			if (keyBindingText == null)
>+				item.setText(text);
>+			else
>+				item.setText(text + '\t' + keyBindingText);
>+		} else {
>+			item.setText(""); //$NON-NLS-1$
>+		}
>+		item.setSelection(model.isSelected());
>+		item.setEnabled(model.isEnabled());
>+	}
>+
>+	private void updateToolItem() {
>+		ToolItem item = (ToolItem) widget;
>+		final String text = model.getLabel();
>+		if (text != null) {
>+			item.setText(text);
>+		} else {
>+			item.setText(""); //$NON-NLS-1$
>+		}
>+		final String tooltip = model.getTooltip();
>+		item.setToolTipText(tooltip);
>+		item.setSelection(model.isSelected());
>+		item.setEnabled(model.isEnabled());
>+	}
>+
>+	private void updateIcons() {
>+		if (widget instanceof MenuItem) {
>+			MenuItem item = (MenuItem) widget;
>+			LocalResourceManager m = new LocalResourceManager(
>+					JFaceResources.getResources());
>+			String iconURI = model.getIconURI();
>+			ImageDescriptor icon = getImageDescriptor(model);
>+			try {
>+				item.setImage(icon == null ? null : m.createImage(icon));
>+			} catch (DeviceResourceException e) {
>+				icon = ImageDescriptor.getMissingImageDescriptor();
>+				item.setImage(m.createImage(icon));
>+				// as we replaced the failed icon, log the message once.
>+				Activator.trace(Policy.DEBUG_MENUS,
>+						"failed to create image " + iconURI, e); //$NON-NLS-1$
>+			}
>+			disposeOldImages();
>+			localResourceManager = m;
>+		} else if (widget instanceof ToolItem) {
>+			ToolItem item = (ToolItem) widget;
>+			LocalResourceManager m = new LocalResourceManager(
>+					JFaceResources.getResources());
>+			String iconURI = model.getIconURI();
>+			ImageDescriptor icon = getImageDescriptor(model);
>+			try {
>+				item.setImage(icon == null ? null : m.createImage(icon));
>+			} catch (DeviceResourceException e) {
>+				icon = ImageDescriptor.getMissingImageDescriptor();
>+				item.setImage(m.createImage(icon));
>+				// as we replaced the failed icon, log the message once.
>+				Activator.trace(Policy.DEBUG_MENUS,
>+						"failed to create image " + iconURI, e); //$NON-NLS-1$
>+			}
>+			disposeOldImages();
>+			localResourceManager = m;
>+		}
>+	}
>+
>+	private void disposeOldImages() {
>+		if (localResourceManager != null) {
>+			localResourceManager.dispose();
>+			localResourceManager = null;
>+		}
>+	}
>+
>+	private Listener getItemListener() {
>+		if (menuItemListener == null) {
>+			menuItemListener = new Listener() {
>+				public void handleEvent(Event event) {
>+					switch (event.type) {
>+					case SWT.Dispose:
>+						handleWidgetDispose(event);
>+						break;
>+					case SWT.DefaultSelection:
>+					case SWT.Selection:
>+						if (event.widget != null) {
>+							handleWidgetSelection(event);
>+						}
>+						break;
>+					}
>+				}
>+			};
>+		}
>+		return menuItemListener;
>+	}
>+
>+	private void handleWidgetDispose(Event event) {
>+		if (event.widget == widget) {
>+			widget.removeListener(SWT.Selection, getItemListener());
>+			widget.removeListener(SWT.Dispose, getItemListener());
>+			widget.removeListener(SWT.DefaultSelection, getItemListener());
>+			widget = null;
>+			model.setWidget(null);
>+			disposeOldImages();
>+		}
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see org.eclipse.jface.action.ContributionItem#dispose()
>+	 */
>+	@Override
>+	public void dispose() {
>+		if (widget != null) {
>+			widget.dispose();
>+			widget = null;
>+			model.setWidget(null);
>+		}
>+	}
>+
>+	private void handleWidgetSelection(Event event) {
>+		if (widget != null && !widget.isDisposed()) {
>+			if (model.getType() == ItemType.CHECK
>+					|| model.getType() == ItemType.RADIO) {
>+				boolean selection = false;
>+				if (widget instanceof MenuItem) {
>+					selection = ((MenuItem) widget).getSelection();
>+				} else if (widget instanceof ToolItem) {
>+					selection = ((ToolItem) widget).getSelection();
>+				}
>+				model.setSelected(selection);
>+			}
>+			if (canExecuteItem()) {
>+				executeItem();
>+			}
>+		}
>+	}
>+
>+	private void executeItem() {
>+		ParameterizedCommand cmd = model.getWbCommand();
>+		if (cmd == null) {
>+			return;
>+		}
>+		final IEclipseContext lclContext = getContext(model);
>+		EHandlerService service = (EHandlerService) lclContext
>+				.get(EHandlerService.class.getName());
>+		lclContext.set(MItem.class.getName(), model);
>+		service.executeHandler(cmd);
>+		lclContext.remove(MItem.class.getName());
>+	}
>+
>+	private boolean canExecuteItem() {
>+		ParameterizedCommand cmd = model.getWbCommand();
>+		if (cmd == null) {
>+			return false;
>+		}
>+		final IEclipseContext lclContext = getContext(model);
>+		EHandlerService service = lclContext.get(EHandlerService.class);
>+		return service.canExecute(cmd);
>+	}
>+
>+	public void setParent(IContributionManager parent) {
>+		if (getParent() instanceof IMenuManager) {
>+			IMenuManager menuMgr = (IMenuManager) getParent();
>+			menuMgr.removeMenuListener(menuListener);
>+		}
>+		if (parent instanceof IMenuManager) {
>+			IMenuManager menuMgr = (IMenuManager) parent;
>+			menuMgr.addMenuListener(menuListener);
>+		}
>+		super.setParent(parent);
>+	}
>+
>+	private ImageDescriptor getImageDescriptor(MUILabel element) {
>+		String iconURI = element.getIconURI();
>+		if (iconURI != null && iconURI.length() > 0) {
>+			return resUtils.imageDescriptorFromURI(URI.createURI(iconURI));
>+		}
>+		return null;
>+	}
>+
>+	/**
>+	 * Return a parent context for this part.
>+	 * 
>+	 * @param element
>+	 *            the part to start searching from
>+	 * @return the parent's closest context, or global context if none in the
>+	 *         hierarchy
>+	 */
>+	protected IEclipseContext getContextForParent(MUIElement element) {
>+		return modelService.getContainingContext(element);
>+	}
>+
>+	/**
>+	 * Return a context for this part.
>+	 * 
>+	 * @param part
>+	 *            the part to start searching from
>+	 * @return the closest context, or global context if none in the hierarchy
>+	 */
>+	protected IEclipseContext getContext(MUIElement part) {
>+		if (part instanceof MContext) {
>+			return ((MContext) part).getContext();
>+		}
>+		return getContextForParent(part);
>+	}
>+
>+	public Widget getWidget() {
>+		return widget;
>+	}
>+}
>\ No newline at end of file
>diff --git a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/MenuItemRenderer.java b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/MenuItemRenderer.java
>index 2aef15d..20bcfa1 100644
>--- a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/MenuItemRenderer.java
>+++ b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/MenuItemRenderer.java
>@@ -10,8 +10,6 @@
>  *******************************************************************************/
> 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;
>@@ -24,6 +22,7 @@ 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.swt.WorkbenchSWTActivator;
> 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;
>diff --git a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewHandledMenuItemRenderer.java b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewHandledMenuItemRenderer.java
>new file mode 100644
>index 0000000..2b42abe
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewHandledMenuItemRenderer.java
>@@ -0,0 +1,151 @@
>+/*******************************************************************************
>+ * Copyright (c) 2010 IBM Corporation and others.
>+ * All rights reserved. This program and the accompanying materials
>+ * are made available under the terms of the Eclipse Public License v1.0
>+ * which accompanies this distribution, and is available at
>+ * http://www.eclipse.org/legal/epl-v10.html
>+ *
>+ * Contributors:
>+ *     IBM Corporation - initial API and implementation
>+ ******************************************************************************/
>+
>+package org.eclipse.e4.ui.workbench.renderers.swt;
>+
>+import 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.services.events.IEventBroker;
>+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.MHandledMenuItem;
>+import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
>+import org.eclipse.e4.ui.workbench.UIEvents;
>+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.osgi.service.event.Event;
>+import org.osgi.service.event.EventHandler;
>+
>+/**
>+ *
>+ */
>+public class NewHandledMenuItemRenderer extends SWTPartRenderer {
>+
>+	@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;
>+			Object data = menuItem.getData();
>+			if (!(data instanceof IContributionItem)) {
>+				return;
>+			}
>+
>+			IContributionItem ici = (IContributionItem) data;
>+			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 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) {
>+				Object data = menuItem.getData();
>+				if (data instanceof IContributionItem) {
>+					((IContributionItem) data).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);
>+			MenuItem menuItem = (MenuItem) itemModel.getWidget();
>+			if (menuItem != null) {
>+				Object data = menuItem.getData();
>+				if (data instanceof IContributionItem) {
>+					((IContributionItem) data).update();
>+				}
>+			}
>+		}
>+	};
>+
>+	@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);
>+	}
>+
>+	/*
>+	 * (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 MHandledMenuItem) || !(parent instanceof Menu))
>+			return null;
>+
>+		Object data = ((Menu) parent).getData();
>+		if (!(data instanceof MenuManager)) {
>+			return null;
>+		}
>+		MenuManager parentManager = (MenuManager) data;
>+		MHandledMenuItem itemModel = (MHandledMenuItem) element;
>+		final IEclipseContext lclContext = getContext(itemModel);
>+		HandledContributionItem ci = ContextInjectionFactory.make(
>+				HandledContributionItem.class, lclContext);
>+		ci.setModel(itemModel);
>+		parentManager.add(ci);
>+		// parentManager.update(false);
>+		return ci.getWidget();
>+	}
>+
>+}
>diff --git a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewMenuRenderer.java b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewMenuRenderer.java
>new file mode 100644
>index 0000000..e86f465
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewMenuRenderer.java
>@@ -0,0 +1,576 @@
>+/*******************************************************************************
>+ * Copyright (c) 2010 IBM Corporation and others.
>+ * All rights reserved. This program and the accompanying materials
>+ * are made available under the terms of the Eclipse Public License v1.0
>+ * which accompanies this distribution, and is available at
>+ * http://www.eclipse.org/legal/epl-v10.html
>+ *
>+ * Contributors:
>+ *     IBM Corporation - initial API and implementation
>+ ******************************************************************************/
>+
>+package org.eclipse.e4.ui.workbench.renderers.swt;
>+
>+import java.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.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.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.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;
>+
>+/**
>+ *
>+ */
>+public class NewMenuRenderer extends SWTPartRenderer {
>+	private static final String NO_LABEL = "UnLabled"; //$NON-NLS-1$
>+
>+	private Map<MMenu, MenuManager> modelToManager = new HashMap<MMenu, MenuManager>();
>+
>+	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 = modelToContribution.get(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) {
>+			// 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);
>+			String attName = (String) event
>+					.getProperty(UIEvents.EventTags.ATTNAME);
>+			if (UIEvents.UIElement.TOBERENDERED.equals(attName)) {
>+				Object obj = itemModel.getParent();
>+				if (!(obj instanceof MMenu)) {
>+					return;
>+				}
>+				MenuManager parent = modelToManager.get(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();
>+					}
>+				}
>+			} else if (UIEvents.UIElement.VISIBLE.equals(attName)) {
>+				IContributionItem ici = modelToContribution.get(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;
>+			}
>+			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;
>+			}
>+			MMenu menuModel = (MMenu) obj;
>+			final IEclipseContext parentContext = modelService
>+					.getContainingContext(menuModel);
>+			HashSet<ContributionRecord> records = new HashSet<ContributionRecord>();
>+			for (MMenuElement element : menuModel.getChildren()) {
>+				ContributionRecord record = modelContributionToRecord
>+						.get(element);
>+				if (records.add(record)) {
>+					record.updateVisibility(parentContext);
>+				}
>+			}
>+		}
>+	};
>+
>+	@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(MUIElement element, Object parent) {
>+		if (!(element instanceof MMenu))
>+			return null;
>+
>+		final MMenu menuModel = (MMenu) element;
>+		Menu newMenu = null;
>+
>+		if (parent instanceof Decorations) {
>+			MUIElement container = (MUIElement) ((EObject) element)
>+					.eContainer();
>+			if (container instanceof MWindow) {
>+				MenuManager menuBarManager = new MenuManager(NO_LABEL,
>+						menuModel.getElementId());
>+				modelToManager.put(menuModel, menuBarManager);
>+				menuBarManager.addMenuListener(visibilityCalculationListener);
>+				newMenu = menuBarManager.createMenuBar((Decorations) parent);
>+				((Decorations) parent).setMenuBar(newMenu);
>+				newMenu.setData(menuBarManager);
>+			} else {
>+				MenuManager popupManager = new MenuManager(NO_LABEL,
>+						menuModel.getElementId());
>+				modelToManager.put(menuModel, popupManager);
>+				popupManager.addMenuListener(visibilityCalculationListener);
>+				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 = new MenuManager(NO_LABEL,
>+					menuModel.getElementId());
>+			modelToManager.put(menuModel, popupManager);
>+			popupManager.addMenuListener(visibilityCalculationListener);
>+			newMenu = popupManager.createContextMenu((Control) parent);
>+			((Control) parent).setMenu(newMenu);
>+			newMenu.setData(popupManager);
>+		}
>+		processContributions(menuModel);
>+		return newMenu;
>+	}
>+
>+	/**
>+	 * @param menuModel
>+	 */
>+	private void processContributions(MMenu menuModel) {
>+		final ArrayList<MMenuContribution> toContribute = new ArrayList<MMenuContribution>();
>+		ContributionsAnalyzer.XXXgatherMenuContributions(menuModel,
>+				application.getMenuContributions(), menuModel.getElementId(),
>+				toContribute, null, menuModel instanceof MPopupMenu);
>+		generateContributions(menuModel, toContribute);
>+	}
>+
>+	/**
>+	 * @param menuModel
>+	 * @param toContribute
>+	 */
>+	private void generateContributions(MMenu menuModel,
>+			ArrayList<MMenuContribution> toContribute) {
>+		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 = modelToManager.get(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)) {
>+					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, MenuManager manager,
>+			MMenuContribution menuContribution,
>+			final HashSet<String> existingMenuIds,
>+			HashSet<String> existingSeparatorNames) {
>+		int idx = getIndex(menuModel, menuContribution.getPositionInParent());
>+		if (idx == -1) {
>+			return false;
>+		}
>+		ContributionRecord record = new ContributionRecord(menuModel,
>+				menuContribution);
>+		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());
>+			}
>+		}
>+		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>();
>+
>+		public ContributionRecord(MMenu menuModel,
>+				MMenuContribution contribution) {
>+			this.menuModel = menuModel;
>+			this.menuContribution = contribution;
>+		}
>+
>+		/**
>+		 * @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);
>+			}
>+		}
>+
>+		public void generate() {
>+			for (MMenuElement item : menuContribution.getChildren()) {
>+				MMenuElement copy = (MMenuElement) EcoreUtil
>+						.copy((EObject) item);
>+				generatedElements.add(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;
>+
>+		MenuManager parentManager = modelToManager.get(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());
>+		modelToManager.put(menuModel, menuManager);
>+		menuManager.addMenuListener(visibilityCalculationListener);
>+		parentManager.add(menuManager);
>+		processContributions(menuModel);
>+		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 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);
>+		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);
>+		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;
>+	}
>+}
>diff --git a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewToolBarRenderer.java b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewToolBarRenderer.java
>new file mode 100644
>index 0000000..ec44958
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewToolBarRenderer.java
>@@ -0,0 +1,337 @@
>+/*******************************************************************************
>+ * Copyright (c) 2010 IBM Corporation and others.
>+ * All rights reserved. This program and the accompanying materials
>+ * are made available under the terms of the Eclipse Public License v1.0
>+ * which accompanies this distribution, and is available at
>+ * http://www.eclipse.org/legal/epl-v10.html
>+ *
>+ * Contributors:
>+ *     IBM Corporation - initial API and implementation
>+ ******************************************************************************/
>+
>+package org.eclipse.e4.ui.workbench.renderers.swt;
>+
>+import java.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.e4.core.contexts.ContextInjectionFactory;
>+import org.eclipse.e4.core.contexts.IEclipseContext;
>+import org.eclipse.e4.core.services.events.IEventBroker;
>+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.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.MToolBar;
>+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.UIEvents;
>+import org.eclipse.jface.action.AbstractGroupMarker;
>+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.layout.RowLayout;
>+import org.eclipse.swt.widgets.Composite;
>+import org.eclipse.swt.widgets.ToolBar;
>+import org.eclipse.swt.widgets.ToolItem;
>+import org.osgi.service.event.Event;
>+import org.osgi.service.event.EventHandler;
>+
>+/**
>+ *
>+ */
>+public class NewToolBarRenderer extends SWTPartRenderer {
>+
>+	private Map<MToolBar, ToolBarManager> modelToManager = new HashMap<MToolBar, ToolBarManager>();
>+	private Map<MToolBarElement, IContributionItem> modelToContribution = new HashMap<MToolBarElement, IContributionItem>();
>+
>+	// @Inject
>+	// private 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 MToolBarElement))
>+				return;
>+
>+			MToolBarElement itemModel = (MToolBarElement) event
>+					.getProperty(UIEvents.EventTags.ELEMENT);
>+
>+			IContributionItem ici = modelToContribution.get(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 = modelToManager.get(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();
>+					}
>+				}
>+			}
>+		}
>+	};
>+
>+	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 = 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 MToolBarElement))
>+				return;
>+
>+			MToolBarElement itemModel = (MToolBarElement) event
>+					.getProperty(UIEvents.EventTags.ELEMENT);
>+			IContributionItem ici = modelToContribution.get(itemModel);
>+			if (ici != null) {
>+				ici.update();
>+			}
>+		}
>+	};
>+
>+	@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);
>+
>+		return intermediate;
>+	}
>+
>+	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 = new ToolBarManager(orientation | SWT.WRAP
>+				| SWT.FLAT | SWT.RIGHT);
>+		modelToManager.put((MToolBar) element, manager);
>+		ToolBar bar = manager.createControl(intermediate);
>+		bar.setData(manager);
>+		return bar;
>+	}
>+
>+	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;
>+
>+		ToolBarManager parentManager = modelToManager.get(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, (MToolBarElement) childME);
>+			}
>+		}
>+		parentManager.update(false);
>+	}
>+
>+	/**
>+	 * @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);
>+	}
>+
>+}
>diff --git a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/SWTPartRenderer.java b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/SWTPartRenderer.java
>index 4312844..881af9b 100644
>--- a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/SWTPartRenderer.java
>+++ b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/SWTPartRenderer.java
>@@ -88,9 +88,6 @@ public abstract class SWTPartRenderer extends AbstractPartRenderer {
> 		// Create a bi-directional link between the widget and the model
> 		me.setWidget(widget);
> 
>-		// Remember which renderer created this widget
>-		me.setRenderer(this);
>-
> 		if (widget instanceof Widget) {
> 			((Widget) widget).setData(OWNING_ME, me);
> 
>diff --git a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/ToolControlContribution.java b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/ToolControlContribution.java
>new file mode 100644
>index 0000000..5f911cc
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/ToolControlContribution.java
>@@ -0,0 +1,71 @@
>+/*******************************************************************************
>+ * Copyright (c) 2010 IBM Corporation and others.
>+ * All rights reserved. This program and the accompanying materials
>+ * are made available under the terms of the Eclipse Public License v1.0
>+ * which accompanies this distribution, and is available at
>+ * http://www.eclipse.org/legal/epl-v10.html
>+ *
>+ * Contributors:
>+ *     IBM Corporation - initial API and implementation
>+ ******************************************************************************/
>+
>+package org.eclipse.e4.ui.workbench.renderers.swt;
>+
>+import javax.inject.Inject;
>+import org.eclipse.e4.core.contexts.EclipseContextFactory;
>+import org.eclipse.e4.core.contexts.IEclipseContext;
>+import org.eclipse.e4.core.services.contributions.IContributionFactory;
>+import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
>+import org.eclipse.e4.ui.model.application.ui.menu.MToolControl;
>+import org.eclipse.jface.action.ControlContribution;
>+import org.eclipse.swt.SWT;
>+import org.eclipse.swt.widgets.Composite;
>+import org.eclipse.swt.widgets.Control;
>+
>+public class ToolControlContribution extends ControlContribution {
>+
>+	private MToolControl model;
>+
>+	@Inject
>+	private IContributionFactory contribFactory;
>+
>+	@Inject
>+	private IEclipseContext parentContext;
>+
>+	public ToolControlContribution() {
>+		super(null);
>+	}
>+
>+	/*
>+	 * (non-Javadoc)
>+	 * 
>+	 * @see
>+	 * org.eclipse.jface.action.ControlContribution#createControl(org.eclipse
>+	 * .swt.widgets.Composite)
>+	 */
>+	@Override
>+	protected Control createControl(Composite parent) {
>+		IEclipseContext localContext = EclipseContextFactory.create();
>+
>+		final Composite newComposite = new Composite(parent, SWT.NONE);
>+		localContext.set(Composite.class.getName(), newComposite);
>+		localContext.set(MToolControl.class.getName(), model);
>+
>+		if (model.getObject() == null) {
>+			Object tcImpl = contribFactory.create(model.getContributionURI(),
>+					parentContext, localContext);
>+			model.setObject(tcImpl);
>+		}
>+
>+		model.setWidget(newComposite);
>+		newComposite.setData(AbstractPartRenderer.OWNING_ME, model);
>+		newComposite.setData(this);
>+
>+		return newComposite;
>+	}
>+
>+	public void setModel(MToolControl c) {
>+		model = c;
>+		setId(model.getElementId());
>+	}
>+}
>diff --git a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/WorkbenchRendererFactory.java b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/WorkbenchRendererFactory.java
>index ffac6a9..8966cb4 100644
>--- a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/WorkbenchRendererFactory.java
>+++ b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/WorkbenchRendererFactory.java
>@@ -14,27 +14,18 @@ import org.eclipse.e4.ui.model.application.ui.basic.MPartSashContainer;
> import org.eclipse.e4.ui.model.application.ui.basic.MPartStack;
> import org.eclipse.e4.ui.model.application.ui.basic.MTrimBar;
> import org.eclipse.e4.ui.model.application.ui.basic.MWindow;
>-import org.eclipse.e4.ui.model.application.ui.menu.MDirectMenuItem;
>-import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;
> import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
>-import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;
> import org.eclipse.e4.ui.model.application.ui.menu.MRenderedMenu;
> import org.eclipse.e4.ui.model.application.ui.menu.MRenderedMenuItem;
> import org.eclipse.e4.ui.model.application.ui.menu.MRenderedToolBar;
> import org.eclipse.e4.ui.model.application.ui.menu.MToolBar;
>-import org.eclipse.e4.ui.model.application.ui.menu.MToolBarSeparator;
>-import org.eclipse.e4.ui.model.application.ui.menu.MToolControl;
>-import org.eclipse.e4.ui.model.application.ui.menu.MToolItem;
> import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
> 
> public class WorkbenchRendererFactory implements IRendererFactory {
> 
> 	private AreaRenderer areaRenderer;
>-	private MenuRenderer menuRenderer;
>-	private HandledMenuItemRenderer handledMenuItemRenderer;
>-	private ToolBarRenderer toolbarRenderer;
>-	private ToolItemRenderer toolItemRenderer;
>-	private SeparatorRenderer separatorRenderer;
>+	private NewMenuRenderer menuRenderer;
>+	private NewToolBarRenderer toolbarRenderer;
> 	private ContributedPartRenderer contributedPartRenderer;
> 	private ElementReferenceRenderer elementRefRenderer;
> 	private PerspectiveStackRenderer perspStackRenderer;
>@@ -42,11 +33,9 @@ public class WorkbenchRendererFactory implements IRendererFactory {
> 	private SashRenderer partSashRenderer;
> 	private StackRenderer stackRenderer;
> 	private TrimBarRenderer trimBarRenderer;
>-	private ToolControlRenderer toolControlRenderer;
> 	private WBWRenderer wbwRenderer;
> 
> 	private IEclipseContext context;
>-	private DirectMenuItemRenderer directMenuItemRenderer;
> 	private RenderedMenuRenderer renderedMenuRenderer;
> 	private RenderedMenuItemRenderer renderedMenuItemRenderer;
> 	private RenderedToolBarRenderer renderedToolbarRenderer;
>@@ -64,18 +53,6 @@ public class WorkbenchRendererFactory implements IRendererFactory {
> 				initRenderer(contributedPartRenderer);
> 			}
> 			return contributedPartRenderer;
>-		} else if (uiElement instanceof MHandledMenuItem) {
>-			if (handledMenuItemRenderer == null) {
>-				handledMenuItemRenderer = new HandledMenuItemRenderer();
>-				initRenderer(handledMenuItemRenderer);
>-			}
>-			return handledMenuItemRenderer;
>-		} else if (uiElement instanceof MDirectMenuItem) {
>-			if (directMenuItemRenderer == null) {
>-				directMenuItemRenderer = new DirectMenuItemRenderer();
>-				initRenderer(directMenuItemRenderer);
>-			}
>-			return directMenuItemRenderer;
> 		} else if (uiElement instanceof MRenderedMenu) {
> 			if (renderedMenuRenderer == null) {
> 				renderedMenuRenderer = new RenderedMenuRenderer();
>@@ -90,7 +67,7 @@ public class WorkbenchRendererFactory implements IRendererFactory {
> 			return renderedMenuItemRenderer;
> 		} else if (uiElement instanceof MMenu) {
> 			if (menuRenderer == null) {
>-				menuRenderer = new MenuRenderer();
>+				menuRenderer = new NewMenuRenderer();
> 				initRenderer(menuRenderer);
> 			}
> 			return menuRenderer;
>@@ -102,23 +79,10 @@ public class WorkbenchRendererFactory implements IRendererFactory {
> 			return renderedToolbarRenderer;
> 		} else if (uiElement instanceof MToolBar) {
> 			if (toolbarRenderer == null) {
>-				toolbarRenderer = new ToolBarRenderer();
>+				toolbarRenderer = new NewToolBarRenderer();
> 				initRenderer(toolbarRenderer);
> 			}
> 			return toolbarRenderer;
>-		} else if (uiElement instanceof MToolItem) {
>-			if (toolItemRenderer == null) {
>-				toolItemRenderer = new ToolItemRenderer();
>-				initRenderer(toolItemRenderer);
>-			}
>-			return toolItemRenderer;
>-		} else if (uiElement instanceof MMenuSeparator
>-				|| uiElement instanceof MToolBarSeparator) {
>-			if (separatorRenderer == null) {
>-				separatorRenderer = new SeparatorRenderer();
>-				initRenderer(separatorRenderer);
>-			}
>-			return separatorRenderer;
> 		} else if (uiElement instanceof MPlaceholder) {
> 			if (elementRefRenderer == null) {
> 				elementRefRenderer = new ElementReferenceRenderer();
>@@ -155,12 +119,6 @@ public class WorkbenchRendererFactory implements IRendererFactory {
> 				initRenderer(trimBarRenderer);
> 			}
> 			return trimBarRenderer;
>-		} else if (uiElement instanceof MToolControl) {
>-			if (toolControlRenderer == null) {
>-				toolControlRenderer = new ToolControlRenderer();
>-				initRenderer(toolControlRenderer);
>-			}
>-			return toolControlRenderer;
> 		} else if (uiElement instanceof MWindow) {
> 			if (wbwRenderer == null) {
> 				wbwRenderer = new WBWRenderer();
>diff --git a/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/internal/workbench/swt/PartRenderingEngine.java b/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/internal/workbench/swt/PartRenderingEngine.java
>index cb65187..401d79d 100644
>--- a/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/internal/workbench/swt/PartRenderingEngine.java
>+++ b/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/internal/workbench/swt/PartRenderingEngine.java
>@@ -51,6 +51,7 @@ 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.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;
>@@ -108,8 +109,10 @@ public class PartRenderingEngine implements IPresentationEngine {
> 						.eContainer();
> 			}
> 
>+			boolean menuChild = parent instanceof MMenu;
>+
> 			// If the parent isn't displayed who cares?
>-			if (parent == null || parent.getWidget() == null)
>+			if (parent == null || parent.getWidget() == null || menuChild)
> 				return;
> 
> 			if (changedElement.isToBeRendered()) {
>@@ -162,9 +165,10 @@ public class PartRenderingEngine implements IPresentationEngine {
> 			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)
>+			if ((!isApplication && renderer == null) || menuChild)
> 				return;
> 
> 			String eventType = (String) event
>@@ -311,6 +315,7 @@ public class PartRenderingEngine implements IPresentationEngine {
> 		}
> 
> 		curFactory = factory;
>+		context.set(IRendererFactory.class, curFactory);
> 
> 		// Hook up the widget life-cycle subscriber
> 		if (eventBroker != null) {
>@@ -423,8 +428,9 @@ public class PartRenderingEngine implements IPresentationEngine {
> 		Object newWidget = createWidget(element, parentWidget);
> 
> 		// Remember that we've created the control
>-		if (newWidget != null) {
>-			AbstractPartRenderer renderer = getRendererFor(element);
>+		AbstractPartRenderer renderer = getRendererFor(element);
>+		if (renderer != null) {
>+			// AbstractPartRenderer renderer = getRendererFor(element);
> 
> 			// Have the renderer hook up any widget specific listeners
> 			renderer.hookControllerLogic(element);
>@@ -578,6 +584,8 @@ public class PartRenderingEngine implements IPresentationEngine {
> 	protected Object createWidget(MUIElement element, Object parent) {
> 		AbstractPartRenderer renderer = getRenderer(element, parent);
> 		if (renderer != null) {
>+			// Remember which renderer is responsible for this widget
>+			element.setRenderer(renderer);
> 			Object newWidget = renderer.createWidget(element, parent);
> 			if (newWidget != null) {
> 				renderer.bindWidget(element, newWidget);
>diff --git a/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/workbench/swt/modeling/MenuService.java b/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/workbench/swt/modeling/MenuService.java
>index a989779..f394fc4 100644
>--- a/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/workbench/swt/modeling/MenuService.java
>+++ b/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/workbench/swt/modeling/MenuService.java
>@@ -13,13 +13,13 @@ package org.eclipse.e4.ui.workbench.swt.modeling;
> 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.e4.ui.workbench.swt.factories.IRendererFactory;
> 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 {
>@@ -49,20 +49,39 @@ 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);
>+		// we need to delegate to the renderer so that it "processes" the
>+		// MenuManager correctly
>+		IRendererFactory rendererFactory = myPart.getContext().get(
>+				IRendererFactory.class);
>+		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);
>-			}
>-		});
>+		Object widget = renderer.createWidget(mmenu, parentControl);
>+		if (!(widget instanceof Menu)) {
>+			return false;
>+		}
>+		renderer.bindWidget(mmenu, widget);
>+		renderer.hookControllerLogic(mmenu);
>+
>+		// 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;
> 	}
> }
>diff --git a/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/workbench/swt/modeling/MenuServiceFilter.java b/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/workbench/swt/modeling/MenuServiceFilter.java
>index 5c958c8..9f825a7 100644
>--- a/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/workbench/swt/modeling/MenuServiceFilter.java
>+++ b/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/workbench/swt/modeling/MenuServiceFilter.java
>@@ -10,39 +10,25 @@
>  *******************************************************************************/
> 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.IContextConstants;
>-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 {
>@@ -123,9 +109,7 @@ 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) {
>+		if (obj instanceof MPopupMenu) {
> 			handleContextMenu(event, menu, (MPopupMenu) obj);
> 		} else if (obj instanceof MMenu) {
> 			handleMenu(event, menu, (MMenu) obj);
>@@ -140,12 +124,10 @@ public class MenuServiceFilter implements Listener {
> 		}
> 		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;
> 		}
>@@ -153,215 +135,50 @@ public class MenuServiceFilter implements Listener {
> 
> 	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);
>-		}
>+		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:
>-			trace("handleContextMenu.Show", menu, menuModel);
> 			cleanUp(menu);
> 			showPopup(event, menu, menuModel);
> 			break;
> 		case SWT.Hide:
>-			trace("handleContextMenu.Hide", menu, menuModel);
> 			hidePopup(event, menu, menuModel);
> 			break;
> 		}
> 	}
> 
> 	public void hidePopup(Event event, Menu menu, MPopupMenu menuModel) {
>-		final IEclipseContext popupContext = menuModel.getContext();
>-		final IEclipseContext parentContext = popupContext.getParent();
>-		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() {
>-					parentContext.set(IContextConstants.ACTIVE_CHILD,
>-							originalChild);
>-				}
>-			});
>-		}
>+		System.err.println("hidePopup: " + menuModel + "\n\t" + menu);
>+
>+		// final IEclipseContext popupContext = menuModel.getContext();
>+		// final IEclipseContext parentContext = popupContext.getParent();
>+		// 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() {
>+		// parentContext.set(IContextConstants.ACTIVE_CHILD,
>+		// originalChild);
>+		// }
>+		// });
>+		// }
> 	}
> 
> 	public void showPopup(final Event event, final Menu menu,
> 			final MPopupMenu menuModel) {
>-		final IEclipseContext popupContext = menuModel.getContext();
>-		final IEclipseContext parentContext = popupContext.getParent();
>-		final IEclipseContext originalChild = (IEclipseContext) parentContext
>-				.getLocal(IContextConstants.ACTIVE_CHILD);
>-		parentContext.set(IContextConstants.ACTIVE_CHILD, popupContext);
>-		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;
>+		System.err.println("showPopup: " + menuModel + "\n\t" + menu);
> 	}
> 
> 	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();
>-		}
>+		System.err.println("cleanUp: " + menu);
> 	}
> 
> 	public void dispose() {
>-		Menu[] keys = pendingCleanup.keySet().toArray(
>-				new Menu[pendingCleanup.size()]);
>-		for (Menu menu : keys) {
>-			cleanUp(menu);
>-		}
>+		System.err.println("dispose");
> 	}
> }
>diff --git a/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/workbench/swt/modeling/OldMenuServiceFilter.java b/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/workbench/swt/modeling/OldMenuServiceFilter.java
>new file mode 100644
>index 0000000..683b4ad
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/workbench/swt/modeling/OldMenuServiceFilter.java
>@@ -0,0 +1,367 @@
>+/*******************************************************************************
>+ * Copyright (c) 2010 IBM Corporation and others.
>+ * All rights reserved. This program and the accompanying materials
>+ * are made available under the terms of the Eclipse Public License v1.0
>+ * which accompanies this distribution, and is available at
>+ * http://www.eclipse.org/legal/epl-v10.html
>+ *
>+ * Contributors:
>+ *     IBM Corporation - initial API and implementation
>+ *******************************************************************************/
>+package org.eclipse.e4.ui.workbench.swt.modeling;
>+
>+import java.lang.reflect.InvocationTargetException;
>+import java.lang.reflect.Method;
>+import java.util.ArrayList;
>+import java.util.HashMap;
>+import java.util.List;
>+import javax.inject.Inject;
>+import org.eclipse.core.commands.ParameterizedCommand;
>+import org.eclipse.core.runtime.ISafeRunnable;
>+import org.eclipse.core.runtime.SafeRunner;
>+import org.eclipse.e4.core.commands.EHandlerService;
>+import org.eclipse.e4.core.contexts.IContextConstants;
>+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 OldMenuServiceFilter implements Listener {
>+	public static final String NUL_MENU_ITEM = "(None Applicable)"; //$NON-NLS-1$
>+
>+	private static final String TMP_ORIGINAL_CONTEXT = "MenuServiceFilter.original.context";
>+
>+	private static void trace(String msg, Widget menu, MMenu menuModel) {
>+		WorkbenchSWTActivator.trace(Policy.MENUS, msg + ": " + menu + ": "
>+				+ menuModel, null);
>+	}
>+
>+	private static Method aboutToShow;
>+
>+	public static Method getAboutToShow() {
>+		if (aboutToShow == null) {
>+			try {
>+				aboutToShow = MenuManager.class
>+						.getDeclaredMethod("handleAboutToShow");
>+				aboutToShow.setAccessible(true);
>+			} catch (SecurityException e) {
>+				// TODO Auto-generated catch block
>+				e.printStackTrace();
>+			} catch (NoSuchMethodException e) {
>+				// TODO Auto-generated catch block
>+				e.printStackTrace();
>+			}
>+		}
>+		return aboutToShow;
>+	}
>+
>+	@Inject
>+	private MApplication application;
>+
>+	@Inject
>+	private IPresentationEngine renderer;
>+
>+	@Inject
>+	private Logger logger;
>+
>+	@Inject
>+	EModelService modelService;
>+
>+	private HashMap<Menu, Runnable> pendingCleanup = new HashMap<Menu, Runnable>();
>+
>+	public void handleEvent(final Event event) {
>+		// wrap the handling in a SafeRunner so that exceptions do not prevent
>+		// the menu from being shown
>+		SafeRunner.run(new ISafeRunnable() {
>+			public void handleException(Throwable e) {
>+				if (e instanceof Error) {
>+					// errors are deadly, we shouldn't ignore these
>+					throw (Error) e;
>+				} else {
>+					// log exceptions otherwise
>+					if (logger != null) {
>+						logger.error(e);
>+					}
>+				}
>+			}
>+
>+			public void run() throws Exception {
>+				safeHandleEvent(event);
>+			}
>+		});
>+	}
>+
>+	private void safeHandleEvent(Event event) {
>+		if (!(event.widget instanceof Menu)) {
>+			return;
>+		}
>+		final Menu menu = (Menu) event.widget;
>+		if (event.type == SWT.Dispose) {
>+			trace("handleMenu.Dispose", menu, null);
>+			cleanUp(menu);
>+		}
>+		Object obj = menu.getData(AbstractPartRenderer.OWNING_ME);
>+		if (obj == null && menu.getParentItem() != null) {
>+			obj = menu.getParentItem().getData(AbstractPartRenderer.OWNING_ME);
>+		}
>+		if (obj instanceof MRenderedMenu) {
>+			handlerRenderedMenu(event, menu, (MRenderedMenu) obj);
>+		} else if (obj instanceof MPopupMenu) {
>+			handleContextMenu(event, menu, (MPopupMenu) obj);
>+		} else if (obj instanceof MMenu) {
>+			handleMenu(event, menu, (MMenu) obj);
>+		}
>+	}
>+
>+	private void handleMenu(final Event event, final Menu menu,
>+			final MMenu menuModel) {
>+		if ((menu.getStyle() & SWT.BAR) != 0) {
>+			// don't process the menu bar, it's not fair :-)
>+			return;
>+		}
>+		switch (event.type) {
>+		case SWT.Show:
>+			trace("handleMenu.Show", menu, menuModel);
>+			cleanUp(menu);
>+			showMenu(event, menu, menuModel);
>+			break;
>+		case SWT.Hide:
>+			trace("handleMenu.Hide", menu, menuModel);
>+			// TODO we'll clean up on show
>+			break;
>+		}
>+	}
>+
>+	public void showMenu(final Event event, final Menu menu,
>+			final MMenu menuModel) {
>+		final IEclipseContext parentContext = modelService
>+				.getContainingContext(menuModel);
>+
>+		final ArrayList<MMenuContribution> toContribute = new ArrayList<MMenuContribution>();
>+		final ArrayList<MMenuElement> menuContributionsToRemove = new ArrayList<MMenuElement>();
>+		ExpressionContext eContext = new ExpressionContext(parentContext);
>+		ContributionsAnalyzer.gatherMenuContributions(menuModel,
>+				application.getMenuContributions(), menuModel.getElementId(),
>+				toContribute, eContext, false);
>+		if (menu.getItemCount() == 1) {
>+			MenuItem item = menu.getItem(0);
>+			if (NUL_MENU_ITEM.equals(item.getText())) {
>+				item.dispose();
>+			}
>+		}
>+		ContributionsAnalyzer.addMenuContributions(menuModel, toContribute,
>+				menuContributionsToRemove);
>+
>+		// create a cleanup routine for the Hide or next Show
>+		pendingCleanup.put(menu, new Runnable() {
>+			public void run() {
>+				if (!menu.isDisposed()) {
>+					unrender(menuContributionsToRemove);
>+				}
>+				removeMenuContributions(menuModel, menuContributionsToRemove);
>+			}
>+		});
>+		render(menu, menuModel);
>+		if (menu.getItemCount() == 0) {
>+			MenuItem menuItem = new MenuItem(menu, SWT.PUSH);
>+			menuItem.setText(NUL_MENU_ITEM);
>+			menuItem.setEnabled(false);
>+		}
>+	}
>+
>+	private void handleContextMenu(final Event event, final Menu menu,
>+			final MPopupMenu menuModel) {
>+		switch (event.type) {
>+		case SWT.Show:
>+			trace("handleContextMenu.Show", menu, menuModel);
>+			cleanUp(menu);
>+			showPopup(event, menu, menuModel);
>+			break;
>+		case SWT.Hide:
>+			trace("handleContextMenu.Hide", menu, menuModel);
>+			hidePopup(event, menu, menuModel);
>+			break;
>+		}
>+	}
>+
>+	public void hidePopup(Event event, Menu menu, MPopupMenu menuModel) {
>+		final IEclipseContext popupContext = menuModel.getContext();
>+		final IEclipseContext parentContext = popupContext.getParent();
>+		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() {
>+					parentContext.set(IContextConstants.ACTIVE_CHILD,
>+							originalChild);
>+				}
>+			});
>+		}
>+	}
>+
>+	public void showPopup(final Event event, final Menu menu,
>+			final MPopupMenu menuModel) {
>+		final IEclipseContext popupContext = menuModel.getContext();
>+		final IEclipseContext parentContext = popupContext.getParent();
>+		final IEclipseContext originalChild = (IEclipseContext) parentContext
>+				.getLocal(IContextConstants.ACTIVE_CHILD);
>+		parentContext.set(IContextConstants.ACTIVE_CHILD, popupContext);
>+		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);
>+		}
>+	}
>+}
>diff --git a/bundles/org.eclipse.e4.ui.workbench/src/org/eclipse/e4/ui/internal/workbench/ContributionsAnalyzer.java b/bundles/org.eclipse.e4.ui.workbench/src/org/eclipse/e4/ui/internal/workbench/ContributionsAnalyzer.java
>index 3adfe1b..9d4696a 100644
>--- a/bundles/org.eclipse.e4.ui.workbench/src/org/eclipse/e4/ui/internal/workbench/ContributionsAnalyzer.java
>+++ b/bundles/org.eclipse.e4.ui.workbench/src/org/eclipse/e4/ui/internal/workbench/ContributionsAnalyzer.java
>@@ -87,6 +87,26 @@ public final class ContributionsAnalyzer {
> 		return false;
> 	}
> 
>+	public static void XXXgatherMenuContributions(final MMenu menuModel,
>+			final List<MMenuContribution> menuContributionList, final String id,
>+			final ArrayList<MMenuContribution> toContribute, final ExpressionContext eContext,
>+			boolean includePopups) {
>+		for (MMenuContribution menuContribution : menuContributionList) {
>+			String parentID = menuContribution.getParentId();
>+			if (parentID == null) {
>+				// it doesn't make sense for this to be null, temporary workaround for bug 320790
>+				continue;
>+			}
>+			boolean popup = parentID.equals(POPUP_PARENT_ID) && (menuModel instanceof MPopupMenu)
>+					&& includePopups;
>+			boolean filtered = isFiltered(menuModel, menuContribution);
>+			if (filtered || (!popup && !parentID.equals(id)) || !menuContribution.isToBeRendered()) {
>+				continue;
>+			}
>+			toContribute.add(menuContribution);
>+		}
>+	}
>+
> 	public static void gatherMenuContributions(final MMenu menuModel,
> 			final List<MMenuContribution> menuContributionList, final String id,
> 			final ArrayList<MMenuContribution> toContribute, final ExpressionContext eContext,
>diff --git a/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MMenuItemTest.java b/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MMenuItemTest.java
>index f4bbecd..3bc05dd 100644
>--- a/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MMenuItemTest.java
>+++ b/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MMenuItemTest.java
>@@ -28,9 +28,12 @@ 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.MMenuItem;
> import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
>+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;
>@@ -74,6 +77,8 @@ public class MMenuItemTest extends TestCase {
> 		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);
>@@ -149,6 +154,8 @@ public class MMenuItemTest extends TestCase {
> 		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);
>@@ -204,6 +211,8 @@ public class MMenuItemTest extends TestCase {
> 		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);
>@@ -237,6 +246,10 @@ public class MMenuItemTest extends TestCase {
> 		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);
>diff --git a/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MWindowTest.java b/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MWindowTest.java
>index 2cf2319..13103d5 100644
>--- a/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MWindowTest.java
>+++ b/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MWindowTest.java
>@@ -31,6 +31,7 @@ import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
> import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
> import org.eclipse.e4.ui.services.IServiceConstants;
> import org.eclipse.e4.ui.widgets.CTabFolder;
>+import org.eclipse.jface.action.MenuManager;
> import org.eclipse.swt.SWT;
> import org.eclipse.swt.graphics.Rectangle;
> import org.eclipse.swt.widgets.Composite;
>@@ -234,6 +235,8 @@ public class MWindowTest extends TestCase {
> 
> 		wb = new E4Workbench(application, appContext);
> 		wb.createAndRunUI(window);
>+		((MenuManager) ((Widget) window.getMainMenu().getWidget()).getData())
>+				.updateAll(true);
> 
> 		Widget topWidget = (Widget) window.getWidget();
> 		assertNotNull(topWidget);
>-- 
>1.7.0.3
>
>
>From 6eb770d06ffc0fc44c5a07cb5703b01cf1c0fd02 Mon Sep 17 00:00:00 2001
>From: Paul Webster <pwebster@ca.ibm.com>
>Date: Fri, 1 Oct 2010 16:40:17 -0400
>Subject: [PATCH 2/5] Update to add the gitignore ... don't kill ourselves with bin
>
>
>diff --git a/bundles/org.eclipse.e4.core.commands/.gitignore b/bundles/org.eclipse.e4.core.commands/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.core.commands/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.core.contexts/.gitignore b/bundles/org.eclipse.e4.core.contexts/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.core.contexts/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.core.di.extensions/.gitignore b/bundles/org.eclipse.e4.core.di.extensions/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.core.di.extensions/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.core.di/.gitignore b/bundles/org.eclipse.e4.core.di/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.core.di/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.core.javascript/.gitignore b/bundles/org.eclipse.e4.core.javascript/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.core.javascript/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.core.services.annotations/.gitignore b/bundles/org.eclipse.e4.core.services.annotations/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.core.services.annotations/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.core.services/.gitignore b/bundles/org.eclipse.e4.core.services/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.core.services/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ide.application/.gitignore b/bundles/org.eclipse.e4.ide.application/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ide.application/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.pde.ui/.gitignore b/bundles/org.eclipse.e4.pde.ui/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.pde.ui/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.pde.webui/.gitignore b/bundles/org.eclipse.e4.pde.webui/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.pde.webui/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.bindings/.gitignore b/bundles/org.eclipse.e4.ui.bindings/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.bindings/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.css.core/.gitignore b/bundles/org.eclipse.e4.ui.css.core/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.css.core/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.css.jface/.gitignore b/bundles/org.eclipse.e4.ui.css.jface/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.css.jface/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.css.legacy/.gitignore b/bundles/org.eclipse.e4.ui.css.legacy/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.css.legacy/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.css.nebula/.gitignore b/bundles/org.eclipse.e4.ui.css.nebula/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.css.nebula/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.css.swt.theme/.gitignore b/bundles/org.eclipse.e4.ui.css.swt.theme/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.css.swt.theme/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.css.swt/.gitignore b/bundles/org.eclipse.e4.ui.css.swt/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.css.swt/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.di/.gitignore b/bundles/org.eclipse.e4.ui.di/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.di/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.gadgets/.gitignore b/bundles/org.eclipse.e4.ui.gadgets/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.gadgets/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.model.workbench.edit/.gitignore b/bundles/org.eclipse.e4.ui.model.workbench.edit/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.model.workbench.edit/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.model.workbench/.gitignore b/bundles/org.eclipse.e4.ui.model.workbench/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.model.workbench/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.selection/.gitignore b/bundles/org.eclipse.e4.ui.selection/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.selection/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.services/.gitignore b/bundles/org.eclipse.e4.ui.services/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.services/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.web/.gitignore b/bundles/org.eclipse.e4.ui.web/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.web/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.widgets.fragment/.gitignore b/bundles/org.eclipse.e4.ui.widgets.fragment/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.widgets.fragment/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.widgets/.gitignore b/bundles/org.eclipse.e4.ui.widgets/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.widgets/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.workbench.addons.swt/.gitignore b/bundles/org.eclipse.e4.ui.workbench.addons.swt/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench.addons.swt/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.workbench.fragment/.gitignore b/bundles/org.eclipse.e4.ui.workbench.fragment/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench.fragment/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.workbench.renderers.swt.cocoa/.gitignore b/bundles/org.eclipse.e4.ui.workbench.renderers.swt.cocoa/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench.renderers.swt.cocoa/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.workbench.renderers.swt.contributions/.gitignore b/bundles/org.eclipse.e4.ui.workbench.renderers.swt.contributions/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench.renderers.swt.contributions/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/.gitignore b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.workbench.swt/.gitignore b/bundles/org.eclipse.e4.ui.workbench.swt/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench.swt/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.workbench/.gitignore b/bundles/org.eclipse.e4.ui.workbench/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.eclipse.e4.ui.workbench3/.gitignore b/bundles/org.eclipse.e4.ui.workbench3/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.eclipse.e4.ui.workbench3/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/bundles/org.pushingpixels.trident/.gitignore b/bundles/org.pushingpixels.trident/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/bundles/org.pushingpixels.trident/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.contacts/.gitignore b/examples/org.eclipse.e4.demo.contacts/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.contacts/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.e4photo.flickr.mock/.gitignore b/examples/org.eclipse.e4.demo.e4photo.flickr.mock/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.e4photo.flickr.mock/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.e4photo.flickr.service.rest/.gitignore b/examples/org.eclipse.e4.demo.e4photo.flickr.service.rest/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.e4photo.flickr.service.rest/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.e4photo.flickr.service/.gitignore b/examples/org.eclipse.e4.demo.e4photo.flickr.service/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.e4photo.flickr.service/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.e4photo.flickr/.gitignore b/examples/org.eclipse.e4.demo.e4photo.flickr/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.e4photo.flickr/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.e4photo/.gitignore b/examples/org.eclipse.e4.demo.e4photo/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.e4photo/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.log/.gitignore b/examples/org.eclipse.e4.demo.log/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.log/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.minimal/.gitignore b/examples/org.eclipse.e4.demo.minimal/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.minimal/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.modifier/.gitignore b/examples/org.eclipse.e4.demo.modifier/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.modifier/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.simpleide.dialogs/.gitignore b/examples/org.eclipse.e4.demo.simpleide.dialogs/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.simpleide.dialogs/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.simpleide.e4editor/.gitignore b/examples/org.eclipse.e4.demo.simpleide.e4editor/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.simpleide.e4editor/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.simpleide.editor.text/.gitignore b/examples/org.eclipse.e4.demo.simpleide.editor.text/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.simpleide.editor.text/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.simpleide.editor/.gitignore b/examples/org.eclipse.e4.demo.simpleide.editor/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.simpleide.editor/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.simpleide.iconview/.gitignore b/examples/org.eclipse.e4.demo.simpleide.iconview/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.simpleide.iconview/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.simpleide.jdt/.gitignore b/examples/org.eclipse.e4.demo.simpleide.jdt/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.simpleide.jdt/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.simpleide.model/.gitignore b/examples/org.eclipse.e4.demo.simpleide.model/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.simpleide.model/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.simpleide.navigator/.gitignore b/examples/org.eclipse.e4.demo.simpleide.navigator/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.simpleide.navigator/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.simpleide.outline/.gitignore b/examples/org.eclipse.e4.demo.simpleide.outline/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.simpleide.outline/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.simpleide.services/.gitignore b/examples/org.eclipse.e4.demo.simpleide.services/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.simpleide.services/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.simpleide.sharedimages/.gitignore b/examples/org.eclipse.e4.demo.simpleide.sharedimages/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.simpleide.sharedimages/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.simpleide/.gitignore b/examples/org.eclipse.e4.demo.simpleide/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.simpleide/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.tools.simpleide/.gitignore b/examples/org.eclipse.e4.demo.tools.simpleide/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.tools.simpleide/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.tools.simpleide3x/.gitignore b/examples/org.eclipse.e4.demo.tools.simpleide3x/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.tools.simpleide3x/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.demo.views/.gitignore b/examples/org.eclipse.e4.demo.views/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.demo.views/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.examples.services/.gitignore b/examples/org.eclipse.e4.examples.services/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.examples.services/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.ui.examples.css.nebula/.gitignore b/examples/org.eclipse.e4.ui.examples.css.nebula/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.ui.examples.css.nebula/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.ui.examples.css.rcp/.gitignore b/examples/org.eclipse.e4.ui.examples.css.rcp/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.ui.examples.css.rcp/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.ui.examples.css/.gitignore b/examples/org.eclipse.e4.ui.examples.css/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.ui.examples.css/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/examples/org.eclipse.e4.ui.examples.legacy.workbench/.gitignore b/examples/org.eclipse.e4.ui.examples.legacy.workbench/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/examples/org.eclipse.e4.ui.examples.legacy.workbench/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/features/org.eclipse.e4.master/.gitignore b/features/org.eclipse.e4.master/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/features/org.eclipse.e4.master/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/features/org.eclipse.e4.sdk.runtime.feature/.gitignore b/features/org.eclipse.e4.sdk.runtime.feature/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/features/org.eclipse.e4.sdk.runtime.feature/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/features/org.eclipse.e4.sdk.source.feature/.gitignore b/features/org.eclipse.e4.sdk.source.feature/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/features/org.eclipse.e4.sdk.source.feature/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/features/org.eclipse.e4.ui.compatibility.feature/.gitignore b/features/org.eclipse.e4.ui.compatibility.feature/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/features/org.eclipse.e4.ui.compatibility.feature/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/features/org.eclipse.e4.ui.css.feature/.gitignore b/features/org.eclipse.e4.ui.css.feature/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/features/org.eclipse.e4.ui.css.feature/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/features/org.eclipse.e4.ui.examples.feature/.gitignore b/features/org.eclipse.e4.ui.examples.feature/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/features/org.eclipse.e4.ui.examples.feature/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/features/org.eclipse.e4.ui.feature/.gitignore b/features/org.eclipse.e4.ui.feature/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/features/org.eclipse.e4.ui.feature/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/features/org.eclipse.e4.ui.tests.feature/.gitignore b/features/org.eclipse.e4.ui.tests.feature/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/features/org.eclipse.e4.ui.tests.feature/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/features/org.eclipse.e4.ui.web.feature/.gitignore b/features/org.eclipse.e4.ui.web.feature/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/features/org.eclipse.e4.ui.web.feature/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/tests/com.google.code.atinject.tck/.gitignore b/tests/com.google.code.atinject.tck/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/tests/com.google.code.atinject.tck/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/tests/org.eclipse.e4.core.commands.tests/.gitignore b/tests/org.eclipse.e4.core.commands.tests/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/tests/org.eclipse.e4.core.commands.tests/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/tests/org.eclipse.e4.core.tests.services.annotations/.gitignore b/tests/org.eclipse.e4.core.tests.services.annotations/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/tests/org.eclipse.e4.core.tests.services.annotations/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/tests/org.eclipse.e4.core.tests.services.atinject/.gitignore b/tests/org.eclipse.e4.core.tests.services.atinject/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/tests/org.eclipse.e4.core.tests.services.atinject/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/tests/org.eclipse.e4.core.tests.services/.gitignore b/tests/org.eclipse.e4.core.tests.services/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/tests/org.eclipse.e4.core.tests.services/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/tests/org.eclipse.e4.core.tests/.gitignore b/tests/org.eclipse.e4.core.tests/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/tests/org.eclipse.e4.core.tests/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/tests/org.eclipse.e4.ui.bindings.tests/.gitignore b/tests/org.eclipse.e4.ui.bindings.tests/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/tests/org.eclipse.e4.ui.bindings.tests/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/tests/org.eclipse.e4.ui.compatibility.tests/.gitignore b/tests/org.eclipse.e4.ui.compatibility.tests/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/tests/org.eclipse.e4.ui.compatibility.tests/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/tests/org.eclipse.e4.ui.selection.tests/.gitignore b/tests/org.eclipse.e4.ui.selection.tests/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/tests/org.eclipse.e4.ui.selection.tests/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/tests/org.eclipse.e4.ui.tests.css.core/.gitignore b/tests/org.eclipse.e4.ui.tests.css.core/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/tests/org.eclipse.e4.ui.tests.css.core/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/tests/org.eclipse.e4.ui.tests.css.swt/.gitignore b/tests/org.eclipse.e4.ui.tests.css.swt/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/tests/org.eclipse.e4.ui.tests.css.swt/.gitignore
>@@ -0,0 +1 @@
>+bin/
>diff --git a/tests/org.eclipse.e4.ui.tests/.gitignore b/tests/org.eclipse.e4.ui.tests/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/tests/org.eclipse.e4.ui.tests/.gitignore
>@@ -0,0 +1 @@
>+bin/
>-- 
>1.7.0.3
>
>
>From 8f3f3aa18f8fd27201fcd4e42a8c9ac9a6556cf7 Mon Sep 17 00:00:00 2001
>From: Paul Webster <pwebster@ca.ibm.com>
>Date: Tue, 5 Oct 2010 09:59:15 -0400
>Subject: [PATCH 3/5] Add a global .gitignore
>
>
>diff --git a/.gitignore b/.gitignore
>new file mode 100644
>index 0000000..e660fd9
>--- /dev/null
>+++ b/.gitignore
>@@ -0,0 +1 @@
>+bin/
>-- 
>1.7.0.3
>
>
>From c28e4a4e2d84ad1b5235f5166bfd70dfdfc0de01 Mon Sep 17 00:00:00 2001
>From: Paul Webster <pwebster@ca.ibm.com>
>Date: Tue, 5 Oct 2010 10:15:23 -0400
>Subject: [PATCH 4/5] remove the incorrect Snippet commit
>
>
>diff --git a/examples/org.eclipse.e4.demo.simpleide/src/snippet/Snippet.java b/examples/org.eclipse.e4.demo.simpleide/src/snippet/Snippet.java
>deleted file mode 100644
>index 8f233c0..0000000
>--- a/examples/org.eclipse.e4.demo.simpleide/src/snippet/Snippet.java
>+++ /dev/null
>@@ -1,6 +0,0 @@
>-package snippet;
>-
>-public class Snippet {
>-	 Bug 312938 -  [Demo] Add example of a Simple-IDE
>-}
>-
>-- 
>1.7.0.3
>
>
>From 24ec5559f13ba04a4aa99f750a39d4381620807b Mon Sep 17 00:00:00 2001
>From: Paul Webster <pwebster@ca.ibm.com>
>Date: Tue, 5 Oct 2010 13:55:48 -0400
>Subject: [PATCH 5/5] Bug 325392 -  Render menu and toolbar contributions using the ContributionManagers
> Added basically visibility based on MenuManager aboutToShow
>
>
>diff --git a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewMenuRenderer.java b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewMenuRenderer.java
>index e86f465..8ce2a40 100644
>--- a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewMenuRenderer.java
>+++ b/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewMenuRenderer.java
>@@ -66,6 +66,7 @@ public class NewMenuRenderer 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>();
> 
>@@ -118,7 +119,7 @@ public class NewMenuRenderer extends SWTPartRenderer {
> 				if (!(obj instanceof MMenu)) {
> 					return;
> 				}
>-				MenuManager parent = modelToManager.get(obj);
>+				MenuManager parent = getManager((MMenu) obj);
> 				if (itemModel.isToBeRendered()) {
> 					if (parent != null) {
> 						modelProcessSwitch(parent, itemModel);
>@@ -179,23 +180,26 @@ public class NewMenuRenderer extends SWTPartRenderer {
> 			if (menuManager.getMenu() == null) {
> 				return;
> 			}
>-			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;
>+			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;
> 			}
>-			MMenu menuModel = (MMenu) obj;
> 			final IEclipseContext parentContext = modelService
> 					.getContainingContext(menuModel);
> 			HashSet<ContributionRecord> records = new HashSet<ContributionRecord>();
> 			for (MMenuElement element : menuModel.getChildren()) {
> 				ContributionRecord record = modelContributionToRecord
> 						.get(element);
>-				if (records.add(record)) {
>+				if (record != null && records.add(record)) {
> 					record.updateVisibility(parentContext);
> 				}
> 			}
>@@ -211,8 +215,8 @@ public class NewMenuRenderer extends SWTPartRenderer {
> 		eventBroker
> 				.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
> 						UIEvents.Item.ENABLED), enabledUpdater);
>-		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UIElement.TOPIC,
>-				UIEvents.UIElement.TOBERENDERED), toBeRenderedUpdater);
>+		eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UIElement.TOPIC),
>+				toBeRenderedUpdater);
> 
> 	}
> 
>@@ -245,7 +249,7 @@ public class NewMenuRenderer extends SWTPartRenderer {
> 			if (container instanceof MWindow) {
> 				MenuManager menuBarManager = new MenuManager(NO_LABEL,
> 						menuModel.getElementId());
>-				modelToManager.put(menuModel, menuBarManager);
>+				linkModelToManager(menuModel, menuBarManager);
> 				menuBarManager.addMenuListener(visibilityCalculationListener);
> 				newMenu = menuBarManager.createMenuBar((Decorations) parent);
> 				((Decorations) parent).setMenuBar(newMenu);
>@@ -253,7 +257,7 @@ public class NewMenuRenderer extends SWTPartRenderer {
> 			} else {
> 				MenuManager popupManager = new MenuManager(NO_LABEL,
> 						menuModel.getElementId());
>-				modelToManager.put(menuModel, popupManager);
>+				linkModelToManager(menuModel, popupManager);
> 				popupManager.addMenuListener(visibilityCalculationListener);
> 				newMenu = popupManager.createContextMenu((Control) parent);
> 				((Control) parent).setMenu(newMenu);
>@@ -267,7 +271,7 @@ public class NewMenuRenderer extends SWTPartRenderer {
> 		} else if (parent instanceof Control) {
> 			MenuManager popupManager = new MenuManager(NO_LABEL,
> 					menuModel.getElementId());
>-			modelToManager.put(menuModel, popupManager);
>+			linkModelToManager(menuModel, popupManager);
> 			popupManager.addMenuListener(visibilityCalculationListener);
> 			newMenu = popupManager.createContextMenu((Control) parent);
> 			((Control) parent).setMenu(newMenu);
>@@ -305,7 +309,7 @@ public class NewMenuRenderer extends SWTPartRenderer {
> 			}
> 		}
> 
>-		MenuManager manager = modelToManager.get(menuModel);
>+		MenuManager manager = getManager(menuModel);
> 		boolean done = toContribute.size() == 0;
> 		while (!done) {
> 			ArrayList<MMenuContribution> curList = new ArrayList<MMenuContribution>(
>@@ -447,7 +451,8 @@ public class NewMenuRenderer extends SWTPartRenderer {
> 		if (container == null)
> 			return;
> 
>-		MenuManager parentManager = modelToManager.get(container);
>+		// this is in direct violation of good programming
>+		MenuManager parentManager = getManager((MMenu) ((Object) container));
> 		if (parentManager == null) {
> 			return;
> 		}
>@@ -472,7 +477,7 @@ public class NewMenuRenderer extends SWTPartRenderer {
> 		ImageDescriptor desc = getImageDescriptor(menuModel);
> 		MenuManager menuManager = new MenuManager(menuText, desc,
> 				menuModel.getElementId());
>-		modelToManager.put(menuModel, menuManager);
>+		linkModelToManager(menuModel, menuManager);
> 		menuManager.addMenuListener(visibilityCalculationListener);
> 		parentManager.add(menuManager);
> 		processContributions(menuModel);
>@@ -492,6 +497,9 @@ public class NewMenuRenderer extends SWTPartRenderer {
> 	 * @param childME
> 	 */
> 	void modelProcessSwitch(MenuManager menuManager, MMenuElement childME) {
>+		if (!childME.isToBeRendered()) {
>+			return;
>+		}
> 		if (childME instanceof MHandledMenuItem) {
> 			MHandledMenuItem itemModel = (MHandledMenuItem) childME;
> 			processHandledItem(menuManager, itemModel);
>@@ -573,4 +581,26 @@ public class NewMenuRenderer extends SWTPartRenderer {
> 		}
> 		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);
>+	}
>+
>+	public void clearModelToManager(MMenu model, MenuManager manager) {
>+		modelToManager.remove(model);
>+		managerToModel.remove(manager);
>+	}
>+
>+	public IContributionItem getContribution(MMenuElement model) {
>+		return modelToContribution.get(model);
>+	}
> }
>diff --git a/tests/org.eclipse.e4.ui.tests/META-INF/MANIFEST.MF b/tests/org.eclipse.e4.ui.tests/META-INF/MANIFEST.MF
>index 6bcc783..91d9e91 100644
>--- a/tests/org.eclipse.e4.ui.tests/META-INF/MANIFEST.MF
>+++ b/tests/org.eclipse.e4.ui.tests/META-INF/MANIFEST.MF
>@@ -28,7 +28,8 @@ Require-Bundle: org.eclipse.emf.ecore.xmi;bundle-version="2.4.0",
>  org.eclipse.emf.ecore.change;bundle-version="2.5.0",
>  org.eclipse.e4.ui.di;bundle-version="0.9.0",
>  org.eclipse.e4.core.di.extensions;bundle-version="0.9.0",
>- org.eclipse.e4.ui.widgets;bundle-version="1.0.0"
>+ org.eclipse.e4.ui.widgets;bundle-version="1.0.0",
>+ org.eclipse.core.expressions;bundle-version="3.4.200"
> Bundle-RequiredExecutionEnvironment: J2SE-1.5
> Bundle-ActivationPolicy: lazy
> Import-Package: javax.annotation;version="1.0.0",
>diff --git a/tests/org.eclipse.e4.ui.tests/plugin.xml b/tests/org.eclipse.e4.ui.tests/plugin.xml
>index 243ceb2..2c271b8 100644
>--- a/tests/org.eclipse.e4.ui.tests/plugin.xml
>+++ b/tests/org.eclipse.e4.ui.tests/plugin.xml
>@@ -48,5 +48,17 @@
>          </element>
>       </processor>
>    </extension>
>+   <extension
>+         point="org.eclipse.core.expressions.definitions">
>+      <definition
>+            id="org.eclipse.e4.ui.tests.withMmc1">
>+         <with
>+               variable="mmc1">
>+            <equals
>+                  value="true">
>+            </equals>
>+         </with>
>+      </definition>
>+   </extension>
> 
> </plugin>
>diff --git a/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MMenuItemTest.java b/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MMenuItemTest.java
>index 3bc05dd..699dded 100644
>--- a/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MMenuItemTest.java
>+++ b/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MMenuItemTest.java
>@@ -15,19 +15,28 @@ import junit.framework.TestCase;
> import org.eclipse.e4.core.contexts.IEclipseContext;
> import org.eclipse.e4.core.di.IDisposable;
> import org.eclipse.e4.ui.internal.workbench.E4Workbench;
>+import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
> import org.eclipse.e4.ui.internal.workbench.swt.E4Application;
> import org.eclipse.e4.ui.internal.workbench.swt.PartRenderingEngine;
> import org.eclipse.e4.ui.model.application.MApplication;
> import org.eclipse.e4.ui.model.application.commands.MCommand;
> import org.eclipse.e4.ui.model.application.commands.impl.CommandsFactoryImpl;
> import org.eclipse.e4.ui.model.application.impl.ApplicationFactoryImpl;
>+import org.eclipse.e4.ui.model.application.ui.MCoreExpression;
>+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.basic.impl.BasicFactoryImpl;
>+import org.eclipse.e4.ui.model.application.ui.impl.UiFactoryImpl;
> import org.eclipse.e4.ui.model.application.ui.menu.ItemType;
> 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.MMenuItem;
>+import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;
> import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
>+import org.eclipse.e4.ui.workbench.renderers.swt.NewMenuRenderer;
>+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;
>@@ -257,4 +266,304 @@ public class MMenuItemTest extends TestCase {
> 		MenuItem menuItemWidget = (MenuItem) widget1;
> 		assertTrue(menuItemWidget.getSelection());
> 	}
>+
>+	public void testSubMenuCreation() throws Exception {
>+		MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
>+		MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
>+		menuBar.setElementId("org.eclipse.ui.main.menu");
>+		window.setMainMenu(menuBar);
>+
>+		MMenu fileMenu = MenuFactoryImpl.eINSTANCE.createMenu();
>+		fileMenu.setElementId("file");
>+		fileMenu.setLabel("File");
>+		menuBar.getChildren().add(fileMenu);
>+
>+		MMenuItem item1 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
>+		item1.setElementId("item1");
>+		item1.setLabel("item1");
>+		fileMenu.getChildren().add(item1);
>+
>+		MMenuSeparator sep = MenuFactoryImpl.eINSTANCE.createMenuSeparator();
>+		sep.setElementId("group1");
>+		fileMenu.getChildren().add(sep);
>+
>+		MMenuItem item2 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
>+		item2.setElementId("item2");
>+		item2.setLabel("item2");
>+		fileMenu.getChildren().add(item2);
>+
>+		MApplication application = ApplicationFactoryImpl.eINSTANCE
>+				.createApplication();
>+		application.getChildren().add(window);
>+		application.setContext(appContext);
>+		appContext.set(MApplication.class.getName(), application);
>+
>+		wb = new E4Workbench(window, appContext);
>+		wb.createAndRunUI(window);
>+
>+		NewMenuRenderer 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 testTbrItem() throws Exception {
>+		MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
>+		MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
>+		menuBar.setElementId("org.eclipse.ui.main.menu");
>+		window.setMainMenu(menuBar);
>+
>+		MMenu fileMenu = MenuFactoryImpl.eINSTANCE.createMenu();
>+		fileMenu.setElementId("file");
>+		fileMenu.setLabel("File");
>+		menuBar.getChildren().add(fileMenu);
>+
>+		MMenuItem item1 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
>+		item1.setElementId("item1");
>+		item1.setLabel("item1");
>+		fileMenu.getChildren().add(item1);
>+
>+		MMenuSeparator sep = MenuFactoryImpl.eINSTANCE.createMenuSeparator();
>+		sep.setElementId("group1");
>+		fileMenu.getChildren().add(sep);
>+
>+		MMenuItem item2 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
>+		item2.setElementId("item2");
>+		item2.setLabel("item2");
>+		fileMenu.getChildren().add(item2);
>+		item2.setToBeRendered(false);
>+
>+		MApplication application = ApplicationFactoryImpl.eINSTANCE
>+				.createApplication();
>+		application.getChildren().add(window);
>+		application.setContext(appContext);
>+		appContext.set(MApplication.class.getName(), application);
>+
>+		wb = new E4Workbench(window, appContext);
>+		wb.createAndRunUI(window);
>+
>+		NewMenuRenderer 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 testInvisibleItem() throws Exception {
>+		MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
>+		MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
>+		menuBar.setElementId("org.eclipse.ui.main.menu");
>+		window.setMainMenu(menuBar);
>+
>+		MMenu fileMenu = MenuFactoryImpl.eINSTANCE.createMenu();
>+		fileMenu.setElementId("file");
>+		fileMenu.setLabel("File");
>+		menuBar.getChildren().add(fileMenu);
>+
>+		MMenuItem item1 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
>+		item1.setElementId("item1");
>+		item1.setLabel("item1");
>+		fileMenu.getChildren().add(item1);
>+
>+		MMenuSeparator sep = MenuFactoryImpl.eINSTANCE.createMenuSeparator();
>+		sep.setElementId("group1");
>+		fileMenu.getChildren().add(sep);
>+
>+		MMenuItem item2 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
>+		item2.setElementId("item2");
>+		item2.setLabel("item2");
>+		fileMenu.getChildren().add(item2);
>+		item2.setVisible(false);
>+
>+		MApplication application = ApplicationFactoryImpl.eINSTANCE
>+				.createApplication();
>+		application.getChildren().add(window);
>+		application.setContext(appContext);
>+		appContext.set(MApplication.class.getName(), application);
>+
>+		wb = new E4Workbench(window, appContext);
>+		wb.createAndRunUI(window);
>+
>+		NewMenuRenderer 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 testMenuContribution() throws Exception {
>+		MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
>+		MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
>+		menuBar.setElementId("org.eclipse.ui.main.menu");
>+		window.setMainMenu(menuBar);
>+
>+		MMenu fileMenu = MenuFactoryImpl.eINSTANCE.createMenu();
>+		fileMenu.setElementId("file");
>+		fileMenu.setLabel("File");
>+		menuBar.getChildren().add(fileMenu);
>+
>+		MMenuItem item1 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
>+		item1.setElementId("item1");
>+		item1.setLabel("item1");
>+		fileMenu.getChildren().add(item1);
>+
>+		MMenuSeparator sep = MenuFactoryImpl.eINSTANCE.createMenuSeparator();
>+		sep.setElementId("group1");
>+		fileMenu.getChildren().add(sep);
>+
>+		MMenuItem item2 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
>+		item2.setElementId("item2");
>+		item2.setLabel("item2");
>+		fileMenu.getChildren().add(item2);
>+
>+		MApplication application = ApplicationFactoryImpl.eINSTANCE
>+				.createApplication();
>+		application.getChildren().add(window);
>+		application.setContext(appContext);
>+		appContext.set(MApplication.class.getName(), application);
>+		application.getMenuContributions().add(createContribution(false));
>+
>+		wb = new E4Workbench(window, appContext);
>+		wb.createAndRunUI(window);
>+
>+		NewMenuRenderer 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 testWithVisible() throws Exception {
>+		MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
>+		MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
>+		menuBar.setElementId("org.eclipse.ui.main.menu");
>+		window.setMainMenu(menuBar);
>+
>+		MMenu fileMenu = MenuFactoryImpl.eINSTANCE.createMenu();
>+		fileMenu.setElementId("file");
>+		fileMenu.setLabel("File");
>+		menuBar.getChildren().add(fileMenu);
>+
>+		MMenuItem item1 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
>+		item1.setElementId("item1");
>+		item1.setLabel("item1");
>+		fileMenu.getChildren().add(item1);
>+
>+		MMenuSeparator sep = MenuFactoryImpl.eINSTANCE.createMenuSeparator();
>+		sep.setElementId("group1");
>+		fileMenu.getChildren().add(sep);
>+
>+		MMenuItem item2 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
>+		item2.setElementId("item2");
>+		item2.setLabel("item2");
>+		fileMenu.getChildren().add(item2);
>+
>+		MApplication application = ApplicationFactoryImpl.eINSTANCE
>+				.createApplication();
>+		application.getChildren().add(window);
>+		application.setContext(appContext);
>+		appContext.set(MApplication.class.getName(), application);
>+		application.getMenuContributions().add(createContribution(true));
>+
>+		wb = new E4Workbench(window, appContext);
>+		wb.createAndRunUI(window);
>+
>+		NewMenuRenderer 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);
>+	}
>+
>+	private MMenuContribution createContribution(boolean withVisibleWhen) {
>+		MMenuContribution mmc = MenuFactoryImpl.eINSTANCE
>+				.createMenuContribution();
>+		mmc.setElementId("test.contrib1");
>+		mmc.setParentId("file");
>+		mmc.setPositionInParent("after=additions");
>+
>+		MMenuItem item1 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
>+		item1.setElementId("mmc.item1");
>+		item1.setLabel("mmc.item1");
>+		mmc.getChildren().add(item1);
>+
>+		if (withVisibleWhen) {
>+			MCoreExpression exp = UiFactoryImpl.eINSTANCE
>+					.createCoreExpression();
>+			exp.setCoreExpressionId("org.eclipse.e4.ui.tests.withMmc1");
>+			mmc.setVisibleWhen(exp);
>+		}
>+
>+		return mmc;
>+	}
>+
>+	private NewMenuRenderer getRenderer(IEclipseContext context,
>+			MUIElement element) {
>+		IRendererFactory rendererFactory = context.get(IRendererFactory.class);
>+		AbstractPartRenderer renderer = rendererFactory.getRenderer(element,
>+				null);
>+		assertEquals(NewMenuRenderer.class, renderer.getClass());
>+		return (NewMenuRenderer) renderer;
>+	}
> }
>-- 
>1.7.0.3
>

Actions: View | Diff

Attachments on bug 325392: 179140 | 180268 | 180514 | 180901 | 181172 | 181191 | 181226 | 182202 | 182509 | 182904 | 183010