Attachment #180268 for bug #325392

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




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




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




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

}




/*******************************************************************************
 * 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;
	}
}




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

}

Lines 88-96 public abstract class SWTPartRenderer extends AbstractPartRenderer { Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/SWTPartRenderer.java (-3 lines)
88	// Create a bi-directional link between the widget and the model	88	// Create a bi-directional link between the widget and the model
89	me.setWidget(widget);	89	me.setWidget(widget);
90		90
91	// Remember which renderer created this widget
92	me.setRenderer(this);
93
94	if (widget instanceof Widget) {	91	if (widget instanceof Widget) {
95	((Widget) widget).setData(OWNING_ME, me);	92	((Widget) widget).setData(OWNING_ME, me);
96		93




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




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 NewMenuRenderer menuRenderer;
	private NewToolBarRenderer toolbarRenderer;
	private ToolBarRenderer toolbarRenderer;
	private ToolItemRenderer toolItemRenderer;
	private SeparatorRenderer separatorRenderer;
	private ContributedPartRenderer contributedPartRenderer;
	private ElementReferenceRenderer elementRefRenderer;
	private PerspectiveStackRenderer perspStackRenderer;

	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;

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

			return renderedMenuItemRenderer;
		} else if (uiElement instanceof MMenu) {
			if (menuRenderer == null) {
				menuRenderer = new NewMenuRenderer();
				initRenderer(menuRenderer);
			}
			return menuRenderer;

			return renderedToolbarRenderer;
		} else if (uiElement instanceof MToolBar) {
			if (toolbarRenderer == null) {
				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();

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

Lines 51-56 import org.eclipse.e4.ui.model.application.ui.MUIElement; Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/internal/workbench/swt/PartRenderingEngine.java (-4 / +12 lines)
51	import org.eclipse.e4.ui.model.application.ui.advanced.MPlaceholder;	51	import org.eclipse.e4.ui.model.application.ui.advanced.MPlaceholder;
52	import org.eclipse.e4.ui.model.application.ui.basic.MTrimmedWindow;	52	import org.eclipse.e4.ui.model.application.ui.basic.MTrimmedWindow;
53	import org.eclipse.e4.ui.model.application.ui.basic.MWindow;	53	import org.eclipse.e4.ui.model.application.ui.basic.MWindow;
		54	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
54	import org.eclipse.e4.ui.services.IStylingEngine;	55	import org.eclipse.e4.ui.services.IStylingEngine;
55	import org.eclipse.e4.ui.workbench.IPresentationEngine;	56	import org.eclipse.e4.ui.workbench.IPresentationEngine;
56	import org.eclipse.e4.ui.workbench.IResourceUtilities;	57	import org.eclipse.e4.ui.workbench.IResourceUtilities;
Lines 108-115 public class PartRenderingEngine implements IPresentationEngine { Link Here
108	.eContainer();	109	.eContainer();
109	}	110	}
110		111
		112	boolean menuChild = parent instanceof MMenu;
		113
111	// If the parent isn't displayed who cares?	114	// If the parent isn't displayed who cares?
112	if (parent == null \|\| parent.getWidget() == null)	115	if (parent == null \|\| parent.getWidget() == null \|\| menuChild)
113	return;	116	return;
114		117
115	if (changedElement.isToBeRendered()) {	118	if (changedElement.isToBeRendered()) {
Lines 162-170 public class PartRenderingEngine implements IPresentationEngine { Link Here
162	MElementContainer<MUIElement> changedElement = (MElementContainer<MUIElement>) changedObj;	165	MElementContainer<MUIElement> changedElement = (MElementContainer<MUIElement>) changedObj;
163	boolean isApplication = changedObj instanceof MApplication;	166	boolean isApplication = changedObj instanceof MApplication;
164		167
		168	boolean menuChild = changedObj instanceof MMenu;
165	// If the parent isn't in the UI then who cares?	169	// If the parent isn't in the UI then who cares?
166	AbstractPartRenderer renderer = getRendererFor(changedElement);	170	AbstractPartRenderer renderer = getRendererFor(changedElement);
167	if (!isApplication && renderer == null)	171	if ((!isApplication && renderer == null) \|\| menuChild)
168	return;	172	return;
169		173
170	String eventType = (String) event	174	String eventType = (String) event
Lines 311-316 public class PartRenderingEngine implements IPresentationEngine { Link Here
311	}	315	}
312		316
313	curFactory = factory;	317	curFactory = factory;
		318	context.set(IRendererFactory.class, curFactory);
314		319
315	// Hook up the widget life-cycle subscriber	320	// Hook up the widget life-cycle subscriber
316	if (eventBroker != null) {	321	if (eventBroker != null) {
Lines 423-430 public class PartRenderingEngine implements IPresentationEngine { Link Here
423	Object newWidget = createWidget(element, parentWidget);	428	Object newWidget = createWidget(element, parentWidget);
424		429
425	// Remember that we've created the control	430	// Remember that we've created the control
426	if (newWidget != null) {	431	AbstractPartRenderer renderer = getRendererFor(element);
427	AbstractPartRenderer renderer = getRendererFor(element);	432	if (renderer != null) {
		433	// AbstractPartRenderer renderer = getRendererFor(element);
428		434
429	// Have the renderer hook up any widget specific listeners	435	// Have the renderer hook up any widget specific listeners
430	renderer.hookControllerLogic(element);	436	renderer.hookControllerLogic(element);
Lines 578-583 public class PartRenderingEngine implements IPresentationEngine { Link Here
578	protected Object createWidget(MUIElement element, Object parent) {	584	protected Object createWidget(MUIElement element, Object parent) {
579	AbstractPartRenderer renderer = getRenderer(element, parent);	585	AbstractPartRenderer renderer = getRenderer(element, parent);
580	if (renderer != null) {	586	if (renderer != null) {
		587	// Remember which renderer is responsible for this widget
		588	element.setRenderer(renderer);
581	Object newWidget = renderer.createWidget(element, parent);	589	Object newWidget = renderer.createWidget(element, parent);
582	if (newWidget != null) {	590	if (newWidget != null) {
583	renderer.bindWidget(element, newWidget);	591	renderer.bindWidget(element, newWidget);

Lines 13-25 package org.eclipse.e4.ui.workbench.swt.modeling; Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench.swt/src/org/eclipse/e4/ui/workbench/swt/modeling/MenuService.java (-14 / +33 lines)
13	import javax.inject.Inject;	13	import javax.inject.Inject;
14	import org.eclipse.e4.core.contexts.IEclipseContext;	14	import org.eclipse.e4.core.contexts.IEclipseContext;
15	import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;	15	import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
		16	import org.eclipse.e4.ui.model.application.ui.MElementContainer;
		17	import org.eclipse.e4.ui.model.application.ui.MUIElement;
16	import org.eclipse.e4.ui.model.application.ui.basic.MPart;	18	import org.eclipse.e4.ui.model.application.ui.basic.MPart;
17	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;	19	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
18	import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;	20	import org.eclipse.e4.ui.model.application.ui.menu.MPopupMenu;
19	import org.eclipse.swt.SWT;	21	import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
20	import org.eclipse.swt.widgets.Control;	22	import org.eclipse.swt.widgets.Control;
21	import org.eclipse.swt.widgets.Event;
22	import org.eclipse.swt.widgets.Listener;
23	import org.eclipse.swt.widgets.Menu;	23	import org.eclipse.swt.widgets.Menu;
24		24
25	public class MenuService implements EMenuService {	25	public class MenuService implements EMenuService {
Lines 49-68 public class MenuService implements EMenuService { Link Here
49	if (mmenu.getWidget() != null) {	49	if (mmenu.getWidget() != null) {
50	return false;	50	return false;
51	}	51	}
52	Menu menu = new Menu(parentControl);	52	// we need to delegate to the renderer so that it "processes" the
53	parentControl.setMenu(menu);	53	// MenuManager correctly
54	mmenu.setWidget(menu);	54	IRendererFactory rendererFactory = myPart.getContext().get(
55	menu.setData(AbstractPartRenderer.OWNING_ME, mmenu);	55	IRendererFactory.class);
		56	AbstractPartRenderer renderer = rendererFactory.getRenderer(mmenu,
		57	parentControl);
56	IEclipseContext popupContext = myPart.getContext().createChild(	58	IEclipseContext popupContext = myPart.getContext().createChild(
57	"popup:" + mmenu.getElementId());	59	"popup:" + mmenu.getElementId());
58	mmenu.setContext(popupContext);	60	mmenu.setContext(popupContext);
59	menu.addListener(SWT.Dispose, new Listener() {	61	Object widget = renderer.createWidget(mmenu, parentControl);
60	public void handleEvent(Event event) {	62	if (!(widget instanceof Menu)) {
61	mmenu.getContext().dispose();	63	return false;
62	mmenu.setContext(null);	64	}
63	mmenu.setWidget(null);	65	renderer.bindWidget(mmenu, widget);
64	}	66	renderer.hookControllerLogic(mmenu);
65	});	67
		68	// Process its internal structure through the renderer that created
		69	// it
		70	Object castObject = mmenu;
		71	renderer.processContents((MElementContainer<MUIElement>) castObject);
		72
		73	// Allow a final chance to set up
		74	renderer.postProcess(mmenu);
		75
		76	// Now that we have a widget let the parent (if any) know
		77	if (mmenu.getParent() instanceof MUIElement) {
		78	MElementContainer<MUIElement> parentElement = mmenu.getParent();
		79	AbstractPartRenderer parentRenderer = rendererFactory.getRenderer(
		80	parentElement, null);
		81	if (parentRenderer != null)
		82	parentRenderer.childRendered(parentElement, mmenu);
		83	}
		84
66	return true;	85	return true;
67	}	86	}
68	}	87	}




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

		if (obj == null && menu.getParentItem() != null) {
			obj = menu.getParentItem().getData(AbstractPartRenderer.OWNING_ME);
		}
		if (obj instanceof MPopupMenu) {
			handlerRenderedMenu(event, menu, (MRenderedMenu) obj);
		} else if (obj instanceof MPopupMenu) {
			handleContextMenu(event, menu, (MPopupMenu) obj);
		} else if (obj instanceof MMenu) {
			handleMenu(event, menu, (MMenu) obj);

		}
		switch (event.type) {
		case SWT.Show:
			trace("handleMenu.Show", menu, menuModel);
			cleanUp(menu);
			showMenu(event, menu, menuModel);
			break;
		case SWT.Hide:
			trace("handleMenu.Hide", menu, menuModel);
			// TODO we'll clean up on show
			break;
		}


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

		final ArrayList<MMenuContribution> toContribute = new ArrayList<MMenuContribution>();
		final ArrayList<MMenuElement> menuContributionsToRemove = new ArrayList<MMenuElement>();
		ExpressionContext eContext = new ExpressionContext(parentContext);
		ContributionsAnalyzer.gatherMenuContributions(menuModel,
				application.getMenuContributions(), menuModel.getElementId(),
				toContribute, eContext, false);
		if (menu.getItemCount() == 1) {
			MenuItem item = menu.getItem(0);
			if (NUL_MENU_ITEM.equals(item.getText())) {
				item.dispose();
			}
		}
		ContributionsAnalyzer.addMenuContributions(menuModel, toContribute,
				menuContributionsToRemove);

		// create a cleanup routine for the Hide or next Show
		pendingCleanup.put(menu, new Runnable() {
			public void run() {
				if (!menu.isDisposed()) {
					unrender(menuContributionsToRemove);
				}
				removeMenuContributions(menuModel, menuContributionsToRemove);
			}
		});
		render(menu, menuModel);
		if (menu.getItemCount() == 0) {
			MenuItem menuItem = new MenuItem(menu, SWT.PUSH);
			menuItem.setText(NUL_MENU_ITEM);
			menuItem.setEnabled(false);
		}
	}

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

	public void hidePopup(Event event, Menu menu, MPopupMenu menuModel) {
		System.err.println("hidePopup: " + menuModel + "\n\t" + menu);

		// final IEclipseContext popupContext = menuModel.getContext();
		// final IEclipseContext 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) {
		System.err.println("showPopup: " + menuModel + "\n\t" + menu);
		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) {
		System.err.println("cleanUp: " + menu);
		if (pendingCleanup.isEmpty()) {
			return;
		}
		Runnable cleanUp = pendingCleanup.remove(menu);
		if (cleanUp != null) {
			trace("cleanUp.run()", menu, null);
			cleanUp.run();
		}
	}

	public void dispose() {
		System.err.println("dispose");
				new Menu[pendingCleanup.size()]);
		for (Menu menu : keys) {
			cleanUp(menu);
		}
	}
}




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




		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,

Lines 28-36 import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem; Link Here

(-)a/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MMenuItemTest.java (+13 lines)
28	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;	28	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
29	import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;	29	import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
30	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;	30	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
		31	import org.eclipse.jface.action.MenuManager;
31	import org.eclipse.swt.SWT;	32	import org.eclipse.swt.SWT;
32	import org.eclipse.swt.widgets.Event;	33	import org.eclipse.swt.widgets.Event;
		34	import org.eclipse.swt.widgets.Menu;
33	import org.eclipse.swt.widgets.MenuItem;	35	import org.eclipse.swt.widgets.MenuItem;
		36	import org.eclipse.swt.widgets.Widget;
34		37
35	public class MMenuItemTest extends TestCase {	38	public class MMenuItemTest extends TestCase {
36	protected IEclipseContext appContext;	39	protected IEclipseContext appContext;
Lines 74-79 public class MMenuItemTest extends TestCase { Link Here
74	wb = new E4Workbench(window, appContext);	77	wb = new E4Workbench(window, appContext);
75	wb.createAndRunUI(window);	78	wb.createAndRunUI(window);
76		79
		80	((MenuManager) ((Widget) menu.getWidget()).getData()).updateAll(true);
		81
77	Object widget = menuItem.getWidget();	82	Object widget = menuItem.getWidget();
78	assertNotNull(widget);	83	assertNotNull(widget);
79	assertTrue(widget instanceof MenuItem);	84	assertTrue(widget instanceof MenuItem);
Lines 149-154 public class MMenuItemTest extends TestCase { Link Here
149	wb = new E4Workbench(window, appContext);	154	wb = new E4Workbench(window, appContext);
150	wb.createAndRunUI(window);	155	wb.createAndRunUI(window);
151		156
		157	((MenuManager) ((Widget) menu.getWidget()).getData()).updateAll(true);
		158
152	Object widget1 = menuItem1.getWidget();	159	Object widget1 = menuItem1.getWidget();
153	assertNotNull(widget1);	160	assertNotNull(widget1);
154	assertTrue(widget1 instanceof MenuItem);	161	assertTrue(widget1 instanceof MenuItem);
Lines 204-209 public class MMenuItemTest extends TestCase { Link Here
204	wb = new E4Workbench(window, appContext);	211	wb = new E4Workbench(window, appContext);
205	wb.createAndRunUI(window);	212	wb.createAndRunUI(window);
206		213
		214	((MenuManager) ((Widget) menu.getWidget()).getData()).updateAll(true);
		215
207	Object widget1 = menuItem.getWidget();	216	Object widget1 = menuItem.getWidget();
208	assertNotNull(widget1);	217	assertNotNull(widget1);
209	assertTrue(widget1 instanceof MenuItem);	218	assertTrue(widget1 instanceof MenuItem);
Lines 237-242 public class MMenuItemTest extends TestCase { Link Here
237	wb = new E4Workbench(window, appContext);	246	wb = new E4Workbench(window, appContext);
238	wb.createAndRunUI(window);	247	wb.createAndRunUI(window);
239		248
		249	MenuManager barManager = (MenuManager) ((Menu) menu.getWidget())
		250	.getData();
		251	barManager.updateAll(true);
		252
240	Object widget1 = menuItem.getWidget();	253	Object widget1 = menuItem.getWidget();
241	assertNotNull(widget1);	254	assertNotNull(widget1);
242	assertTrue(widget1 instanceof MenuItem);	255	assertTrue(widget1 instanceof MenuItem);

Lines 31-36 import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem; Link Here

(-)a/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MWindowTest.java (-1 / +3 lines)
31	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;	31	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
32	import org.eclipse.e4.ui.services.IServiceConstants;	32	import org.eclipse.e4.ui.services.IServiceConstants;
33	import org.eclipse.e4.ui.widgets.CTabFolder;	33	import org.eclipse.e4.ui.widgets.CTabFolder;
		34	import org.eclipse.jface.action.MenuManager;
34	import org.eclipse.swt.SWT;	35	import org.eclipse.swt.SWT;
35	import org.eclipse.swt.graphics.Rectangle;	36	import org.eclipse.swt.graphics.Rectangle;
36	import org.eclipse.swt.widgets.Composite;	37	import org.eclipse.swt.widgets.Composite;
Lines 234-239 public class MWindowTest extends TestCase { Link Here
234		235
235	wb = new E4Workbench(application, appContext);	236	wb = new E4Workbench(application, appContext);
236	wb.createAndRunUI(window);	237	wb.createAndRunUI(window);
		238	((MenuManager) ((Widget) window.getMainMenu().getWidget()).getData())
		239	.updateAll(true);
237		240
238	Widget topWidget = (Widget) window.getWidget();	241	Widget topWidget = (Widget) window.getWidget();
239	assertNotNull(topWidget);	242	assertNotNull(topWidget);
240	-

Added Link Here

(-)a/bundles/org.eclipse.e4.core.commands/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.core.contexts/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.core.di.extensions/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.core.di/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.core.javascript/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.core.services.annotations/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.core.services/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ide.application/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.pde.ui/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.pde.webui/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.bindings/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.css.core/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.css.jface/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.css.legacy/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.css.nebula/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.css.swt.theme/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.css.swt/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.di/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.gadgets/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.model.workbench.edit/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.model.workbench/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.selection/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.services/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.web/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.widgets.fragment/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.widgets/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench.addons.swt/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench.fragment/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench.renderers.swt.cocoa/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench.renderers.swt.contributions/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench.swt/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench3/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/bundles/org.pushingpixels.trident/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.contacts/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.e4photo.flickr.mock/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.e4photo.flickr.service.rest/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.e4photo.flickr.service/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.e4photo.flickr/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.e4photo/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.log/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.minimal/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.modifier/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.simpleide.dialogs/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.simpleide.e4editor/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.simpleide.editor.text/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.simpleide.editor/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.simpleide.iconview/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.simpleide.jdt/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.simpleide.model/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.simpleide.navigator/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.simpleide.outline/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.simpleide.services/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.simpleide.sharedimages/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.simpleide/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.tools.simpleide/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.tools.simpleide3x/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.demo.views/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.examples.services/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.ui.examples.css.nebula/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.ui.examples.css.rcp/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.ui.examples.css/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/examples/org.eclipse.e4.ui.examples.legacy.workbench/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/features/org.eclipse.e4.master/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/features/org.eclipse.e4.sdk.runtime.feature/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/features/org.eclipse.e4.sdk.source.feature/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/features/org.eclipse.e4.ui.compatibility.feature/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/features/org.eclipse.e4.ui.css.feature/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/features/org.eclipse.e4.ui.examples.feature/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/features/org.eclipse.e4.ui.feature/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/features/org.eclipse.e4.ui.tests.feature/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/features/org.eclipse.e4.ui.web.feature/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/tests/com.google.code.atinject.tck/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/tests/org.eclipse.e4.core.commands.tests/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/tests/org.eclipse.e4.core.tests.services.annotations/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/tests/org.eclipse.e4.core.tests.services.atinject/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/tests/org.eclipse.e4.core.tests.services/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/tests/org.eclipse.e4.core.tests/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/tests/org.eclipse.e4.ui.bindings.tests/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/tests/org.eclipse.e4.ui.compatibility.tests/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/tests/org.eclipse.e4.ui.selection.tests/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/tests/org.eclipse.e4.ui.tests.css.core/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/tests/org.eclipse.e4.ui.tests.css.swt/.gitignore (+1 lines)
1	bin/

Added Link Here

(-)a/tests/org.eclipse.e4.ui.tests/.gitignore (-1 / +1 lines)
0	-	1	bin/

Added Link Here

(-)a/.gitignore (-1 / +1 lines)
0	-	1	bin/

Lines 1-6 Link Here

(-)a/examples/org.eclipse.e4.demo.simpleide/src/snippet/Snippet.java (-7 lines)
1	package snippet;
2
3	public class Snippet {
4	Bug 312938 - [Demo] Add example of a Simple-IDE
5	}
6
7	-
8	Added basically visibility based on MenuManager aboutToShow	0	Added basically visibility based on MenuManager aboutToShow




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


				if (!(obj instanceof MMenu)) {
					return;
				}
				MenuManager parent = getManager((MMenu) obj);
				if (itemModel.isToBeRendered()) {
					if (parent != null) {
						modelProcessSwitch(parent, itemModel);

			if (menuManager.getMenu() == null) {
				return;
			}
			MMenu menuModel = getMenuModel(menuManager);
			if (menuModel == null) {
				Menu menu = menuManager.getMenu();
				Object obj = menu.getData(AbstractPartRenderer.OWNING_ME);
				if (obj == null && menu.getParentItem() != null) {
					obj = menu.getParentItem().getData(
							AbstractPartRenderer.OWNING_ME);
				}
				if (!(obj instanceof MMenu)) {
					return;
				}
				menuModel = (MMenu) obj;
			}
			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 (record != null && records.add(record)) {
					record.updateVisibility(parentContext);
				}
			}

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

	}


			if (container instanceof MWindow) {
				MenuManager menuBarManager = new MenuManager(NO_LABEL,
						menuModel.getElementId());
				linkModelToManager(menuModel, menuBarManager);
				menuBarManager.addMenuListener(visibilityCalculationListener);
				newMenu = menuBarManager.createMenuBar((Decorations) parent);
				((Decorations) parent).setMenuBar(newMenu);

			} else {
				MenuManager popupManager = new MenuManager(NO_LABEL,
						menuModel.getElementId());
				linkModelToManager(menuModel, popupManager);
				popupManager.addMenuListener(visibilityCalculationListener);
				newMenu = popupManager.createContextMenu((Control) parent);
				((Control) parent).setMenu(newMenu);

		} else if (parent instanceof Control) {
			MenuManager popupManager = new MenuManager(NO_LABEL,
					menuModel.getElementId());
			linkModelToManager(menuModel, popupManager);
			popupManager.addMenuListener(visibilityCalculationListener);
			newMenu = popupManager.createContextMenu((Control) parent);
			((Control) parent).setMenu(newMenu);

			}
		}

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

		if (container == null)
			return;

		// this is in direct violation of good programming
		MenuManager parentManager = getManager((MMenu) ((Object) container));
		if (parentManager == null) {
			return;
		}

		ImageDescriptor desc = getImageDescriptor(menuModel);
		MenuManager menuManager = new MenuManager(menuText, desc,
				menuModel.getElementId());
		linkModelToManager(menuModel, menuManager);
		menuManager.addMenuListener(visibilityCalculationListener);
		parentManager.add(menuManager);
		processContributions(menuModel);

	 * @param childME
	 */
	void modelProcessSwitch(MenuManager menuManager, MMenuElement childME) {
		if (!childME.isToBeRendered()) {
			return;
		}
		if (childME instanceof MHandledMenuItem) {
			MHandledMenuItem itemModel = (MHandledMenuItem) childME;
			processHandledItem(menuManager, itemModel);

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

Lines 28-34 Require-Bundle: org.eclipse.emf.ecore.xmi;bundle-version="2.4.0", Link Here

(-)a/tests/org.eclipse.e4.ui.tests/META-INF/MANIFEST.MF (-1 / +2 lines)
28	org.eclipse.emf.ecore.change;bundle-version="2.5.0",	28	org.eclipse.emf.ecore.change;bundle-version="2.5.0",
29	org.eclipse.e4.ui.di;bundle-version="0.9.0",	29	org.eclipse.e4.ui.di;bundle-version="0.9.0",
30	org.eclipse.e4.core.di.extensions;bundle-version="0.9.0",	30	org.eclipse.e4.core.di.extensions;bundle-version="0.9.0",
31	org.eclipse.e4.ui.widgets;bundle-version="1.0.0"	31	org.eclipse.e4.ui.widgets;bundle-version="1.0.0",
		32	org.eclipse.core.expressions;bundle-version="3.4.200"
32	Bundle-RequiredExecutionEnvironment: J2SE-1.5	33	Bundle-RequiredExecutionEnvironment: J2SE-1.5
33	Bundle-ActivationPolicy: lazy	34	Bundle-ActivationPolicy: lazy
34	Import-Package: javax.annotation;version="1.0.0",	35	Import-Package: javax.annotation;version="1.0.0",




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

Lines 15-33 import junit.framework.TestCase; Link Here

(-)a/tests/org.eclipse.e4.ui.tests/src/org/eclipse/e4/ui/tests/workbench/MMenuItemTest.java (-1 / +309 lines)
15	import org.eclipse.e4.core.contexts.IEclipseContext;	15	import org.eclipse.e4.core.contexts.IEclipseContext;
16	import org.eclipse.e4.core.di.IDisposable;	16	import org.eclipse.e4.core.di.IDisposable;
17	import org.eclipse.e4.ui.internal.workbench.E4Workbench;	17	import org.eclipse.e4.ui.internal.workbench.E4Workbench;
		18	import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
18	import org.eclipse.e4.ui.internal.workbench.swt.E4Application;	19	import org.eclipse.e4.ui.internal.workbench.swt.E4Application;
19	import org.eclipse.e4.ui.internal.workbench.swt.PartRenderingEngine;	20	import org.eclipse.e4.ui.internal.workbench.swt.PartRenderingEngine;
20	import org.eclipse.e4.ui.model.application.MApplication;	21	import org.eclipse.e4.ui.model.application.MApplication;
21	import org.eclipse.e4.ui.model.application.commands.MCommand;	22	import org.eclipse.e4.ui.model.application.commands.MCommand;
22	import org.eclipse.e4.ui.model.application.commands.impl.CommandsFactoryImpl;	23	import org.eclipse.e4.ui.model.application.commands.impl.CommandsFactoryImpl;
23	import org.eclipse.e4.ui.model.application.impl.ApplicationFactoryImpl;	24	import org.eclipse.e4.ui.model.application.impl.ApplicationFactoryImpl;
		25	import org.eclipse.e4.ui.model.application.ui.MCoreExpression;
		26	import org.eclipse.e4.ui.model.application.ui.MUIElement;
24	import org.eclipse.e4.ui.model.application.ui.basic.MWindow;	27	import org.eclipse.e4.ui.model.application.ui.basic.MWindow;
25	import org.eclipse.e4.ui.model.application.ui.basic.impl.BasicFactoryImpl;	28	import org.eclipse.e4.ui.model.application.ui.basic.impl.BasicFactoryImpl;
		29	import org.eclipse.e4.ui.model.application.ui.impl.UiFactoryImpl;
26	import org.eclipse.e4.ui.model.application.ui.menu.ItemType;	30	import org.eclipse.e4.ui.model.application.ui.menu.ItemType;
27	import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;	31	import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;
28	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;	32	import org.eclipse.e4.ui.model.application.ui.menu.MMenu;
		33	import org.eclipse.e4.ui.model.application.ui.menu.MMenuContribution;
29	import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;	34	import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
		35	import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;
30	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;	36	import org.eclipse.e4.ui.model.application.ui.menu.impl.MenuFactoryImpl;
		37	import org.eclipse.e4.ui.workbench.renderers.swt.NewMenuRenderer;
		38	import org.eclipse.e4.ui.workbench.swt.factories.IRendererFactory;
		39	import org.eclipse.jface.action.IContributionItem;
31	import org.eclipse.jface.action.MenuManager;	40	import org.eclipse.jface.action.MenuManager;
32	import org.eclipse.swt.SWT;	41	import org.eclipse.swt.SWT;
33	import org.eclipse.swt.widgets.Event;	42	import org.eclipse.swt.widgets.Event;
Lines 257-260 public class MMenuItemTest extends TestCase { Link Here
257	MenuItem menuItemWidget = (MenuItem) widget1;	266	MenuItem menuItemWidget = (MenuItem) widget1;
258	assertTrue(menuItemWidget.getSelection());	267	assertTrue(menuItemWidget.getSelection());
259	}	268	}
		269
		270	public void testSubMenuCreation() throws Exception {
		271	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
		272	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
		273	menuBar.setElementId("org.eclipse.ui.main.menu");
		274	window.setMainMenu(menuBar);
		275
		276	MMenu fileMenu = MenuFactoryImpl.eINSTANCE.createMenu();
		277	fileMenu.setElementId("file");
		278	fileMenu.setLabel("File");
		279	menuBar.getChildren().add(fileMenu);
		280
		281	MMenuItem item1 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
		282	item1.setElementId("item1");
		283	item1.setLabel("item1");
		284	fileMenu.getChildren().add(item1);
		285
		286	MMenuSeparator sep = MenuFactoryImpl.eINSTANCE.createMenuSeparator();
		287	sep.setElementId("group1");
		288	fileMenu.getChildren().add(sep);
		289
		290	MMenuItem item2 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
		291	item2.setElementId("item2");
		292	item2.setLabel("item2");
		293	fileMenu.getChildren().add(item2);
		294
		295	MApplication application = ApplicationFactoryImpl.eINSTANCE
		296	.createApplication();
		297	application.getChildren().add(window);
		298	application.setContext(appContext);
		299	appContext.set(MApplication.class.getName(), application);
		300
		301	wb = new E4Workbench(window, appContext);
		302	wb.createAndRunUI(window);
		303
		304	NewMenuRenderer renderer = getRenderer(appContext, menuBar);
		305	MenuManager manager = renderer.getManager(menuBar);
		306	assertNotNull("failed to create menu bar manager", manager);
		307
		308	assertEquals(1, manager.getSize());
		309
		310	MenuManager fileManager = (MenuManager) manager.getItems()[0];
		311	MenuManager fileR = renderer.getManager(fileMenu);
		312	assertEquals(fileManager, fileR);
		313
		314	assertEquals(3, fileManager.getSize());
		315	}
		316
		317	public void testTbrItem() throws Exception {
		318	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
		319	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
		320	menuBar.setElementId("org.eclipse.ui.main.menu");
		321	window.setMainMenu(menuBar);
		322
		323	MMenu fileMenu = MenuFactoryImpl.eINSTANCE.createMenu();
		324	fileMenu.setElementId("file");
		325	fileMenu.setLabel("File");
		326	menuBar.getChildren().add(fileMenu);
		327
		328	MMenuItem item1 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
		329	item1.setElementId("item1");
		330	item1.setLabel("item1");
		331	fileMenu.getChildren().add(item1);
		332
333	MMenuSeparator sep = MenuFactoryImpl.eINSTANCE.createMenuSeparator();
334	sep.setElementId("group1");
335	fileMenu.getChildren().add(sep);
336
337	MMenuItem item2 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
338	item2.setElementId("item2");
339	item2.setLabel("item2");
340	fileMenu.getChildren().add(item2);
341	item2.setToBeRendered(false);
342
343	MApplication application = ApplicationFactoryImpl.eINSTANCE
344	.createApplication();
345	application.getChildren().add(window);
346	application.setContext(appContext);
347	appContext.set(MApplication.class.getName(), application);
348
349	wb = new E4Workbench(window, appContext);
350	wb.createAndRunUI(window);
351
352	NewMenuRenderer renderer = getRenderer(appContext, menuBar);
353	MenuManager manager = renderer.getManager(menuBar);
354	assertNotNull("failed to create menu bar manager", manager);
355
356	assertEquals(1, manager.getSize());
357
358	MenuManager fileManager = (MenuManager) manager.getItems()[0];
359	MenuManager fileR = renderer.getManager(fileMenu);
360	assertEquals(fileManager, fileR);
361
362	assertEquals(2, fileManager.getSize());
363	}
364
365	public void testInvisibleItem() throws Exception {
366	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
367	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
368	menuBar.setElementId("org.eclipse.ui.main.menu");
369	window.setMainMenu(menuBar);
370
371	MMenu fileMenu = MenuFactoryImpl.eINSTANCE.createMenu();
372	fileMenu.setElementId("file");
373	fileMenu.setLabel("File");
374	menuBar.getChildren().add(fileMenu);
375
376	MMenuItem item1 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
377	item1.setElementId("item1");
378	item1.setLabel("item1");
379	fileMenu.getChildren().add(item1);
380
381	MMenuSeparator sep = MenuFactoryImpl.eINSTANCE.createMenuSeparator();
382	sep.setElementId("group1");
383	fileMenu.getChildren().add(sep);
384
385	MMenuItem item2 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
386	item2.setElementId("item2");
387	item2.setLabel("item2");
388	fileMenu.getChildren().add(item2);
389	item2.setVisible(false);
390
391	MApplication application = ApplicationFactoryImpl.eINSTANCE
392	.createApplication();
393	application.getChildren().add(window);
394	application.setContext(appContext);
395	appContext.set(MApplication.class.getName(), application);
396
397	wb = new E4Workbench(window, appContext);
398	wb.createAndRunUI(window);
399
400	NewMenuRenderer renderer = getRenderer(appContext, menuBar);
401	MenuManager manager = renderer.getManager(menuBar);
402	assertNotNull("failed to create menu bar manager", manager);
403
404	assertEquals(1, manager.getSize());
405
406	MenuManager fileManager = (MenuManager) manager.getItems()[0];
407	MenuManager fileR = renderer.getManager(fileMenu);
408	assertEquals(fileManager, fileR);
409
410	assertEquals(3, fileManager.getSize());
411
412	assertEquals(false, fileManager.getItems()[2].isVisible());
413	}
414
415	public void testMenuContribution() throws Exception {
416	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
417	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
418	menuBar.setElementId("org.eclipse.ui.main.menu");
419	window.setMainMenu(menuBar);
420
421	MMenu fileMenu = MenuFactoryImpl.eINSTANCE.createMenu();
422	fileMenu.setElementId("file");
423	fileMenu.setLabel("File");
424	menuBar.getChildren().add(fileMenu);
425
426	MMenuItem item1 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
427	item1.setElementId("item1");
428	item1.setLabel("item1");
429	fileMenu.getChildren().add(item1);
430
431	MMenuSeparator sep = MenuFactoryImpl.eINSTANCE.createMenuSeparator();
432	sep.setElementId("group1");
433	fileMenu.getChildren().add(sep);
434
435	MMenuItem item2 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
436	item2.setElementId("item2");
437	item2.setLabel("item2");
438	fileMenu.getChildren().add(item2);
439
440	MApplication application = ApplicationFactoryImpl.eINSTANCE
441	.createApplication();
442	application.getChildren().add(window);
443	application.setContext(appContext);
444	appContext.set(MApplication.class.getName(), application);
445	application.getMenuContributions().add(createContribution(false));
446
447	wb = new E4Workbench(window, appContext);
448	wb.createAndRunUI(window);
449
450	NewMenuRenderer renderer = getRenderer(appContext, menuBar);
451
452	MenuManager fileManager = renderer.getManager(fileMenu);
453	assertNotNull("No file menu?", fileManager);
454
455	assertEquals(4, fileManager.getSize());
456
457	assertEquals("mmc.item1", fileManager.getItems()[3].getId());
458	}
459
460	public void testWithVisible() throws Exception {
461	MWindow window = BasicFactoryImpl.eINSTANCE.createWindow();
462	MMenu menuBar = MenuFactoryImpl.eINSTANCE.createMenu();
463	menuBar.setElementId("org.eclipse.ui.main.menu");
464	window.setMainMenu(menuBar);
465
466	MMenu fileMenu = MenuFactoryImpl.eINSTANCE.createMenu();
467	fileMenu.setElementId("file");
468	fileMenu.setLabel("File");
469	menuBar.getChildren().add(fileMenu);
470
471	MMenuItem item1 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
472	item1.setElementId("item1");
473	item1.setLabel("item1");
474	fileMenu.getChildren().add(item1);
475
476	MMenuSeparator sep = MenuFactoryImpl.eINSTANCE.createMenuSeparator();
477	sep.setElementId("group1");
478	fileMenu.getChildren().add(sep);
479
480	MMenuItem item2 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
481	item2.setElementId("item2");
482	item2.setLabel("item2");
483	fileMenu.getChildren().add(item2);
484
485	MApplication application = ApplicationFactoryImpl.eINSTANCE
486	.createApplication();
487	application.getChildren().add(window);
488	application.setContext(appContext);
489	appContext.set(MApplication.class.getName(), application);
490	application.getMenuContributions().add(createContribution(true));
491
492	wb = new E4Workbench(window, appContext);
493	wb.createAndRunUI(window);
494
495	NewMenuRenderer renderer = getRenderer(appContext, menuBar);
496
497	MenuManager fileManager = renderer.getManager(fileMenu);
498	assertNotNull("No file menu?", fileManager);
499
500	assertEquals(4, fileManager.getSize());
501
502	IContributionItem mmcItem = fileManager.getItems()[3];
503	assertEquals("mmc.item1", mmcItem.getId());
504	assertEquals("before the first show, we have no context to evaluate",
505	true, mmcItem.isVisible());
506
507	MenuManager manager = renderer.getManager(menuBar);
508	manager.updateAll(true);
509	Menu fileWidget = fileManager.getMenu();
510	assertNotNull(fileWidget);
511
512	Event show = new Event();
513	show.widget = fileWidget;
514	show.type = SWT.Show;
515
516	Event hide = new Event();
517	hide.widget = fileWidget;
518	hide.type = SWT.Hide;
519
520	fileWidget.notifyListeners(SWT.Show, show);
521
522	assertEquals("after the first show, it should not be visible", false,
523	mmcItem.isVisible());
524
525	fileWidget.notifyListeners(SWT.Hide, hide);
526
527	appContext.set("mmc1", Boolean.TRUE);
528
529	assertEquals("Change should not show up until next show", false,
530	mmcItem.isVisible());
531
532	fileWidget.notifyListeners(SWT.Show, show);
533
534	assertEquals(true, mmcItem.isVisible());
535
536	fileWidget.notifyListeners(SWT.Hide, hide);
537	}
538
539	private MMenuContribution createContribution(boolean withVisibleWhen) {
540	MMenuContribution mmc = MenuFactoryImpl.eINSTANCE
541	.createMenuContribution();
542	mmc.setElementId("test.contrib1");
543	mmc.setParentId("file");
544	mmc.setPositionInParent("after=additions");
545
546	MMenuItem item1 = MenuFactoryImpl.eINSTANCE.createDirectMenuItem();
547	item1.setElementId("mmc.item1");
548	item1.setLabel("mmc.item1");
549	mmc.getChildren().add(item1);
550
551	if (withVisibleWhen) {
552	MCoreExpression exp = UiFactoryImpl.eINSTANCE
553	.createCoreExpression();
554	exp.setCoreExpressionId("org.eclipse.e4.ui.tests.withMmc1");
555	mmc.setVisibleWhen(exp);
556	}
557
558	return mmc;
559	}
560
561	private NewMenuRenderer getRenderer(IEclipseContext context,
562	MUIElement element) {
563	IRendererFactory rendererFactory = context.get(IRendererFactory.class);
564	AbstractPartRenderer renderer = rendererFactory.getRenderer(element,
565	null);
566	assertEquals(NewMenuRenderer.class, renderer.getClass());
567	return (NewMenuRenderer) renderer;
568	}
260	}	569	}
261	-

Return to bug 325392

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/DirectContributionItem.java (+412 lines)
1	package org.eclipse.e4.ui.workbench.renderers.swt;
2
3	import javax.inject.Inject;
4	import org.eclipse.e4.core.contexts.ContextInjectionFactory;
5	import org.eclipse.e4.core.contexts.IEclipseContext;
6	import org.eclipse.e4.core.di.annotations.CanExecute;
7	import org.eclipse.e4.core.di.annotations.Execute;
8	import org.eclipse.e4.core.services.contributions.IContributionFactory;
9	import org.eclipse.e4.ui.internal.workbench.Activator;
10	import org.eclipse.e4.ui.internal.workbench.Policy;
11	import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
12	import org.eclipse.e4.ui.model.application.MContribution;
13	import org.eclipse.e4.ui.model.application.ui.MContext;
14	import org.eclipse.e4.ui.model.application.ui.MUIElement;
15	import org.eclipse.e4.ui.model.application.ui.MUILabel;
16	import org.eclipse.e4.ui.model.application.ui.menu.ItemType;
17	import org.eclipse.e4.ui.model.application.ui.menu.MItem;
18	import org.eclipse.e4.ui.workbench.IResourceUtilities;
19	import org.eclipse.e4.ui.workbench.modeling.EModelService;
20	import org.eclipse.e4.ui.workbench.swt.util.ISWTResourceUtilities;
21	import org.eclipse.emf.common.util.URI;
22	import org.eclipse.jface.action.ContributionItem;
23	import org.eclipse.jface.action.IContributionManager;
24	import org.eclipse.jface.action.IMenuListener;
25	import org.eclipse.jface.action.IMenuManager;
26	import org.eclipse.jface.resource.DeviceResourceException;
27	import org.eclipse.jface.resource.ImageDescriptor;
28	import org.eclipse.jface.resource.JFaceResources;
29	import org.eclipse.jface.resource.LocalResourceManager;
30	import org.eclipse.swt.SWT;
31	import org.eclipse.swt.widgets.Event;
32	import org.eclipse.swt.widgets.Listener;
33	import org.eclipse.swt.widgets.Menu;
34	import org.eclipse.swt.widgets.MenuItem;
35	import org.eclipse.swt.widgets.ToolBar;
36	import org.eclipse.swt.widgets.ToolItem;
37	import org.eclipse.swt.widgets.Widget;
38
39	public class DirectContributionItem extends ContributionItem {
40	private MItem model;
41	private Widget widget;
42	private Listener menuItemListener;
43	private LocalResourceManager localResourceManager;
44
45	@Inject
46	private IContributionFactory contribFactory;
47
48	@Inject
49	private EModelService modelService;
50
51	private ISWTResourceUtilities resUtils = null;
52
53	@Inject
54	void setResourceUtils(IResourceUtilities utils) {
55	resUtils = (ISWTResourceUtilities) utils;
56	}
57
58	private IMenuListener menuListener = new IMenuListener() {
59	public void menuAboutToShow(IMenuManager manager) {
60	update(null);
61	}
62	};
63
64	public void setModel(MItem item) {
65	model = item;
66	setId(model.getElementId());
67	updateVisible();
68	}
69
70	/*
71	* (non-Javadoc)
72	*
73	* @see
74	* org.eclipse.jface.action.ContributionItem#fill(org.eclipse.swt.widgets
75	* .Menu, int)
76	*/
77	@Override
78	public void fill(Menu menu, int index) {
79	if (model == null) {
80	return;
81	}
82	if (widget != null) {
83	return;
84	}
85	int style = SWT.PUSH;
86	if (model.getType() == ItemType.PUSH)
87	style = SWT.PUSH;
88	else if (model.getType() == ItemType.CHECK)
89	style = SWT.CHECK;
90	else if (model.getType() == ItemType.RADIO)
91	style = SWT.RADIO;
92	MenuItem item = null;
93	if (index >= 0) {
94	item = new MenuItem(menu, style, index);
95	} else {
96	item = new MenuItem(menu, style);
97	}
98	item.setData(this);
99
100	item.addListener(SWT.Dispose, getItemListener());
101	item.addListener(SWT.Selection, getItemListener());
102	item.addListener(SWT.DefaultSelection, getItemListener());
103
104	widget = item;
105	model.setWidget(widget);
106	widget.setData(AbstractPartRenderer.OWNING_ME, model);
107
108	update(null);
109	updateIcons();
110	}
111
112	/*
113	* (non-Javadoc)
114	*
115	* @see
116	* org.eclipse.jface.action.ContributionItem#fill(org.eclipse.swt.widgets
117	* .ToolBar, int)
118	*/
119	@Override
120	public void fill(ToolBar parent, int index) {
121	if (model == null) {
122	return;
123	}
124	if (widget != null) {
125	return;
126	}
127	int style = SWT.PUSH;
128	if (model.getType() == ItemType.PUSH)
129	style = SWT.PUSH;
130	else if (model.getType() == ItemType.CHECK)
131	style = SWT.CHECK;
132	else if (model.getType() == ItemType.RADIO)
133	style = SWT.RADIO;
134	ToolItem item = null;
135	if (index >= 0) {
136	item = new ToolItem(parent, style, index);
137	} else {
138	item = new ToolItem(parent, style);
139	}
140	item.setData(this);
141
142	item.addListener(SWT.Dispose, getItemListener());
143	item.addListener(SWT.Selection, getItemListener());
144	item.addListener(SWT.DefaultSelection, getItemListener());
145
146	widget = item;
147	model.setWidget(widget);
148	widget.setData(AbstractPartRenderer.OWNING_ME, model);
149
150	update(null);
151	updateIcons();
152	}
153
154	private void updateVisible() {
155	setVisible((model).isVisible());
156	final IContributionManager parent = getParent();
157	if (parent != null) {
158	parent.markDirty();
159	}
160	}
161
162	/*
163	* (non-Javadoc)
164	*
165	* @see org.eclipse.jface.action.ContributionItem#update()
166	*/
167	@Override
168	public void update() {
169	update(null);
170	}
171
172	/*
173	* (non-Javadoc)
174	*
175	* @see org.eclipse.jface.action.ContributionItem#update(java.lang.String)
176	*/
177	@Override
178	public void update(String id) {
179	if (widget instanceof MenuItem) {
180	updateMenuItem();
181	} else if (widget instanceof ToolItem) {
182	updateToolItem();
183	}
184	}
185
186	private void updateMenuItem() {
187	MenuItem item = (MenuItem) widget;
188	String text = model.getLabel();
189	if (text != null) {
190	item.setText(text);
191	} else {
192	item.setText(""); //$NON-NLS-1$
193	}
194	item.setSelection(model.isSelected());
195	item.setEnabled(model.isEnabled());
196	}
197
198	private void updateToolItem() {
199	ToolItem item = (ToolItem) widget;
200	final String text = model.getLabel();
201	if (text != null) {
202	item.setText(text);
203	} else {
204	item.setText(""); //$NON-NLS-1$
205	}
206	final String tooltip = model.getTooltip();
207	item.setToolTipText(tooltip);
208
209	item.setSelection(model.isSelected());
210	item.setEnabled(model.isEnabled());
211	}
212
213	private void updateIcons() {
214	if (widget instanceof MenuItem) {
215	MenuItem item = (MenuItem) widget;
216	LocalResourceManager m = new LocalResourceManager(
217	JFaceResources.getResources());
218	String iconURI = model.getIconURI();
219	ImageDescriptor icon = getImageDescriptor(model);
220	try {
221	item.setImage(icon == null ? null : m.createImage(icon));
222	} catch (DeviceResourceException e) {
223	icon = ImageDescriptor.getMissingImageDescriptor();
224	item.setImage(m.createImage(icon));
225	// as we replaced the failed icon, log the message once.
226	Activator.trace(Policy.DEBUG_MENUS,
227	"failed to create image " + iconURI, e); //$NON-NLS-1$
228	}
229	disposeOldImages();
230	localResourceManager = m;
231	} else if (widget instanceof ToolItem) {
232	ToolItem item = (ToolItem) widget;
233	LocalResourceManager m = new LocalResourceManager(
234	JFaceResources.getResources());
235	String iconURI = model.getIconURI();
236	ImageDescriptor icon = getImageDescriptor(model);
237	try {
238	item.setImage(icon == null ? null : m.createImage(icon));
239	} catch (DeviceResourceException e) {
240	icon = ImageDescriptor.getMissingImageDescriptor();
241	item.setImage(m.createImage(icon));
242	// as we replaced the failed icon, log the message once.
243	Activator.trace(Policy.DEBUG_MENUS,
244	"failed to create image " + iconURI, e); //$NON-NLS-1$
245	}
246	disposeOldImages();
247	localResourceManager = m;
248	}
249	}
250
251	private void disposeOldImages() {
252	if (localResourceManager != null) {
253	localResourceManager.dispose();
254	localResourceManager = null;
255	}
256	}
257
258	private Listener getItemListener() {
259	if (menuItemListener == null) {
260	menuItemListener = new Listener() {
261	public void handleEvent(Event event) {
262	switch (event.type) {
263	case SWT.Dispose:
264	handleWidgetDispose(event);
265	break;
266	case SWT.DefaultSelection:
267	case SWT.Selection:
268	if (event.widget != null) {
269	handleWidgetSelection(event);
270	}
271	break;
272	}
273	}
274	};
275	}
276	return menuItemListener;
277	}
278
279	private void handleWidgetDispose(Event event) {
280	if (event.widget == widget) {
281	widget.removeListener(SWT.Selection, getItemListener());
282	widget.removeListener(SWT.Dispose, getItemListener());
283	widget.removeListener(SWT.DefaultSelection, getItemListener());
284	widget = null;
285	model.setWidget(null);
286	disposeOldImages();
287	}
288	}
289
290	/*
291	* (non-Javadoc)
292	*
293	* @see org.eclipse.jface.action.ContributionItem#dispose()
294	*/
295	@Override
296	public void dispose() {
297	if (widget != null) {
298	widget.dispose();
299	widget = null;
300	model.setWidget(null);
301	}
302	}
303
304	private void handleWidgetSelection(Event event) {
305	if (widget != null && !widget.isDisposed()) {
306	if (model.getType() == ItemType.CHECK
307	\|\| model.getType() == ItemType.RADIO) {
308	boolean selection = false;
309	if (widget instanceof MenuItem) {
310	selection = ((MenuItem) widget).getSelection();
311	} else if (widget instanceof ToolItem) {
312	selection = ((ToolItem) widget).getSelection();
313	}
314	model.setSelected(selection);
315	}
316	if (canExecuteItem()) {
317	executeItem();
318	}
319	}
320	}
321
322	private void executeItem() {
323	final IEclipseContext lclContext = getContext(model);
324	if (!checkContribution(lclContext)) {
325	return;
326	}
327	MContribution contrib = (MContribution) model;
328	lclContext.set(MItem.class, model);
329	ContextInjectionFactory.invoke(contrib.getObject(), Execute.class,
330	lclContext);
331	lclContext.remove(MItem.class);
332	}
333
334	private boolean canExecuteItem() {
335	final IEclipseContext lclContext = getContext(model);
336	if (!checkContribution(lclContext)) {
337	return false;
338	}
339	MContribution contrib = (MContribution) model;
340	lclContext.set(MItem.class, model);
341	try {
342	Boolean result = ((Boolean) ContextInjectionFactory.invoke(
343	contrib.getObject(), CanExecute.class, lclContext,
344	Boolean.TRUE));
345	return result.booleanValue();
346	} finally {
347	lclContext.remove(MItem.class);
348	}
349	}
350
351	private boolean checkContribution(IEclipseContext lclContext) {
352	if (!(model instanceof MContribution)) {
353	return false;
354	}
355	MContribution contrib = (MContribution) model;
356	if (contrib.getObject() == null) {
357	contrib.setObject(contribFactory.create(
358	contrib.getContributionURI(), lclContext));
359	}
360	return contrib.getObject() != null;
361	}
362
363	public void setParent(IContributionManager parent) {
364	if (getParent() instanceof IMenuManager) {
365	IMenuManager menuMgr = (IMenuManager) getParent();
366	menuMgr.removeMenuListener(menuListener);
367	}
368	if (parent instanceof IMenuManager) {
369	IMenuManager menuMgr = (IMenuManager) parent;
370	menuMgr.addMenuListener(menuListener);
371	}
372	super.setParent(parent);
373	}
374
375	private ImageDescriptor getImageDescriptor(MUILabel element) {
376	String iconURI = element.getIconURI();
377	if (iconURI != null && iconURI.length() > 0) {
378	return resUtils.imageDescriptorFromURI(URI.createURI(iconURI));
379	}
380	return null;
381	}
382
383	/**
384	* Return a parent context for this part.
385	*
386	* @param element
387	* the part to start searching from
388	* @return the parent's closest context, or global context if none in the
389	* hierarchy
390	*/
391	protected IEclipseContext getContextForParent(MUIElement element) {
392	return modelService.getContainingContext(element);
393	}
394
395	/**
396	* Return a context for this part.
397	*
398	* @param part
399	* the part to start searching from
400	* @return the closest context, or global context if none in the hierarchy
401	*/
402	protected IEclipseContext getContext(MUIElement part) {
403	if (part instanceof MContext) {
404	return ((MContext) part).getContext();
405	}
406	return getContextForParent(part);
407	}
408
409	public Widget getWidget() {
410	return widget;
411	}
412	}

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/HandledContributionItem.java (+443 lines)
1	package org.eclipse.e4.ui.workbench.renderers.swt;
2
3	import java.util.HashMap;
4	import java.util.List;
5	import javax.inject.Inject;
6	import org.eclipse.core.commands.ParameterizedCommand;
7	import org.eclipse.e4.core.commands.ECommandService;
8	import org.eclipse.e4.core.commands.EHandlerService;
9	import org.eclipse.e4.core.contexts.IEclipseContext;
10	import org.eclipse.e4.ui.bindings.EBindingService;
11	import org.eclipse.e4.ui.internal.workbench.Activator;
12	import org.eclipse.e4.ui.internal.workbench.Policy;
13	import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
14	import org.eclipse.e4.ui.model.application.commands.MParameter;
15	import org.eclipse.e4.ui.model.application.ui.MContext;
16	import org.eclipse.e4.ui.model.application.ui.MUIElement;
17	import org.eclipse.e4.ui.model.application.ui.MUILabel;
18	import org.eclipse.e4.ui.model.application.ui.menu.ItemType;
19	import org.eclipse.e4.ui.model.application.ui.menu.MHandledItem;
20	import org.eclipse.e4.ui.model.application.ui.menu.MItem;
21	import org.eclipse.e4.ui.workbench.IResourceUtilities;
22	import org.eclipse.e4.ui.workbench.modeling.EModelService;
23	import org.eclipse.e4.ui.workbench.swt.util.ISWTResourceUtilities;
24	import org.eclipse.emf.common.util.URI;
25	import org.eclipse.jface.action.ContributionItem;
26	import org.eclipse.jface.action.IContributionManager;
27	import org.eclipse.jface.action.IMenuListener;
28	import org.eclipse.jface.action.IMenuManager;
29	import org.eclipse.jface.bindings.TriggerSequence;
30	import org.eclipse.jface.resource.DeviceResourceException;
31	import org.eclipse.jface.resource.ImageDescriptor;
32	import org.eclipse.jface.resource.JFaceResources;
33	import org.eclipse.jface.resource.LocalResourceManager;
34	import org.eclipse.swt.SWT;
35	import org.eclipse.swt.widgets.Event;
36	import org.eclipse.swt.widgets.Listener;
37	import org.eclipse.swt.widgets.Menu;
38	import org.eclipse.swt.widgets.MenuItem;
39	import org.eclipse.swt.widgets.ToolBar;
40	import org.eclipse.swt.widgets.ToolItem;
41	import org.eclipse.swt.widgets.Widget;
42
43	public class HandledContributionItem extends ContributionItem {
44	private MHandledItem model;
45	private Widget widget;
46	private Listener menuItemListener;
47	private LocalResourceManager localResourceManager;
48
49	@Inject
50	private ECommandService commandService;
51
52	@Inject
53	private EModelService modelService;
54
55	@Inject
56	private EBindingService bindingService;
57
58	private ISWTResourceUtilities resUtils = null;
59
60	@Inject
61	void setResourceUtils(IResourceUtilities utils) {
62	resUtils = (ISWTResourceUtilities) utils;
63	}
64
65	private IMenuListener menuListener = new IMenuListener() {
66	public void menuAboutToShow(IMenuManager manager) {
67	update(null);
68	}
69	};
70
71	public void setModel(MHandledItem item) {
72	model = item;
73	setId(model.getElementId());
74	generateCommand();
75	updateVisible();
76	}
77
78	/**
79	*
80	*/
81	private void generateCommand() {
82	if (model.getCommand() == null) {
83	return;
84	}
85	if (model.getWbCommand() == null) {
86	String cmdId = model.getCommand().getElementId();
87	final List<MParameter> modelParms = model.getParameters();
88	if (modelParms.isEmpty()) {
89	final ParameterizedCommand parmCmd = commandService
90	.createCommand(cmdId, null);
91	Activator
92	.trace(Policy.DEBUG_MENUS, "command: " + parmCmd, null); //$NON-NLS-1$
93	model.setWbCommand(parmCmd);
94	return;
95	}
96	HashMap<String, String> parms = new HashMap<String, String>();
97	for (MParameter parm : modelParms) {
98	parms.put(parm.getName(), parm.getValue());
99	}
100	final ParameterizedCommand parmCmd = commandService.createCommand(
101	cmdId, parms);
102	Activator.trace(Policy.DEBUG_MENUS, "command: " + parmCmd, null); //$NON-NLS-1$
103	model.setWbCommand(parmCmd);
104	}
105	}
106
107	/*
108	* (non-Javadoc)
109	*
110	* @see
111	* org.eclipse.jface.action.ContributionItem#fill(org.eclipse.swt.widgets
112	* .Menu, int)
113	*/
114	@Override
115	public void fill(Menu menu, int index) {
116	if (model == null) {
117	return;
118	}
119	if (widget != null) {
120	return;
121	}
122	int style = SWT.PUSH;
123	if (model.getType() == ItemType.PUSH)
124	style = SWT.PUSH;
125	else if (model.getType() == ItemType.CHECK)
126	style = SWT.CHECK;
127	else if (model.getType() == ItemType.RADIO)
128	style = SWT.RADIO;
129	MenuItem item = null;
130	if (index >= 0) {
131	item = new MenuItem(menu, style, index);
132	} else {
133	item = new MenuItem(menu, style);
134	}
135	item.setData(this);
136
137	item.addListener(SWT.Dispose, getItemListener());
138	item.addListener(SWT.Selection, getItemListener());
139	item.addListener(SWT.DefaultSelection, getItemListener());
140
141	widget = item;
142	model.setWidget(widget);
143	widget.setData(AbstractPartRenderer.OWNING_ME, model);
144
145	update(null);
146	updateIcons();
147	}
148
149	/*
150	* (non-Javadoc)
151	*
152	* @see
153	* org.eclipse.jface.action.ContributionItem#fill(org.eclipse.swt.widgets
154	* .ToolBar, int)
155	*/
156	@Override
157	public void fill(ToolBar parent, int index) {
158	if (model == null) {
159	return;
160	}
161	if (widget != null) {
162	return;
163	}
164	int style = SWT.PUSH;
165	if (model.getType() == ItemType.PUSH)
166	style = SWT.PUSH;
167	else if (model.getType() == ItemType.CHECK)
168	style = SWT.CHECK;
169	else if (model.getType() == ItemType.RADIO)
170	style = SWT.RADIO;
171	ToolItem item = null;
172	if (index >= 0) {
173	item = new ToolItem(parent, style, index);
174	} else {
175	item = new ToolItem(parent, style);
176	}
177	item.setData(this);
178
179	item.addListener(SWT.Dispose, getItemListener());
180	item.addListener(SWT.Selection, getItemListener());
181	item.addListener(SWT.DefaultSelection, getItemListener());
182
183	widget = item;
184	model.setWidget(widget);
185	widget.setData(AbstractPartRenderer.OWNING_ME, model);
186
187	update(null);
188	updateIcons();
189	}
190
191	private void updateVisible() {
192	setVisible((model).isVisible());
193	final IContributionManager parent = getParent();
194	if (parent != null) {
195	parent.markDirty();
196	}
197	}
198
199	/*
200	* (non-Javadoc)
201	*
202	* @see org.eclipse.jface.action.ContributionItem#update()
203	*/
204	@Override
205	public void update() {
206	update(null);
207	}
208
209	/*
210	* (non-Javadoc)
211	*
212	* @see org.eclipse.jface.action.ContributionItem#update(java.lang.String)
213	*/
214	@Override
215	public void update(String id) {
216	if (widget instanceof MenuItem) {
217	updateMenuItem();
218	} else if (widget instanceof ToolItem) {
219	updateToolItem();
220	}
221	}
222
223	private void updateMenuItem() {
224	MenuItem item = (MenuItem) widget;
225	String text = model.getLabel();
226	ParameterizedCommand parmCmd = model.getWbCommand();
227	String keyBindingText = null;
228	if (parmCmd != null) {
229	if (bindingService != null) {
230	TriggerSequence binding = bindingService
231	.getBestSequenceFor(parmCmd);
232	if (binding != null)
233	keyBindingText = binding.format();
234	}
235	}
236	if (text != null) {
237	if (keyBindingText == null)
238	item.setText(text);
239	else
240	item.setText(text + '\t' + keyBindingText);
241	} else {
242	item.setText(""); //$NON-NLS-1$
243	}
244	item.setSelection(model.isSelected());
245	item.setEnabled(model.isEnabled());
246	}
247
248	private void updateToolItem() {
249	ToolItem item = (ToolItem) widget;
250	final String text = model.getLabel();
251	if (text != null) {
252	item.setText(text);
253	} else {
254	item.setText(""); //$NON-NLS-1$
255	}
256	final String tooltip = model.getTooltip();
257	item.setToolTipText(tooltip);
258	item.setSelection(model.isSelected());
259	item.setEnabled(model.isEnabled());
260	}
261
262	private void updateIcons() {
263	if (widget instanceof MenuItem) {
264	MenuItem item = (MenuItem) widget;
265	LocalResourceManager m = new LocalResourceManager(
266	JFaceResources.getResources());
267	String iconURI = model.getIconURI();
268	ImageDescriptor icon = getImageDescriptor(model);
269	try {
270	item.setImage(icon == null ? null : m.createImage(icon));
271	} catch (DeviceResourceException e) {
272	icon = ImageDescriptor.getMissingImageDescriptor();
273	item.setImage(m.createImage(icon));
274	// as we replaced the failed icon, log the message once.
275	Activator.trace(Policy.DEBUG_MENUS,
276	"failed to create image " + iconURI, e); //$NON-NLS-1$
277	}
278	disposeOldImages();
279	localResourceManager = m;
280	} else if (widget instanceof ToolItem) {
281	ToolItem item = (ToolItem) widget;
282	LocalResourceManager m = new LocalResourceManager(
283	JFaceResources.getResources());
284	String iconURI = model.getIconURI();
285	ImageDescriptor icon = getImageDescriptor(model);
286	try {
287	item.setImage(icon == null ? null : m.createImage(icon));
288	} catch (DeviceResourceException e) {
289	icon = ImageDescriptor.getMissingImageDescriptor();
290	item.setImage(m.createImage(icon));
291	// as we replaced the failed icon, log the message once.
292	Activator.trace(Policy.DEBUG_MENUS,
293	"failed to create image " + iconURI, e); //$NON-NLS-1$
294	}
295	disposeOldImages();
296	localResourceManager = m;
297	}
298	}
299
300	private void disposeOldImages() {
301	if (localResourceManager != null) {
302	localResourceManager.dispose();
303	localResourceManager = null;
304	}
305	}
306
307	private Listener getItemListener() {
308	if (menuItemListener == null) {
309	menuItemListener = new Listener() {
310	public void handleEvent(Event event) {
311	switch (event.type) {
312	case SWT.Dispose:
313	handleWidgetDispose(event);
314	break;
315	case SWT.DefaultSelection:
316	case SWT.Selection:
317	if (event.widget != null) {
318	handleWidgetSelection(event);
319	}
320	break;
321	}
322	}
323	};
324	}
325	return menuItemListener;
326	}
327
328	private void handleWidgetDispose(Event event) {
329	if (event.widget == widget) {
330	widget.removeListener(SWT.Selection, getItemListener());
331	widget.removeListener(SWT.Dispose, getItemListener());
332	widget.removeListener(SWT.DefaultSelection, getItemListener());
333	widget = null;
334	model.setWidget(null);
335	disposeOldImages();
336	}
337	}
338
339	/*
340	* (non-Javadoc)
341	*
342	* @see org.eclipse.jface.action.ContributionItem#dispose()
343	*/
344	@Override
345	public void dispose() {
346	if (widget != null) {
347	widget.dispose();
348	widget = null;
349	model.setWidget(null);
350	}
351	}
352
353	private void handleWidgetSelection(Event event) {
354	if (widget != null && !widget.isDisposed()) {
355	if (model.getType() == ItemType.CHECK
356	\|\| model.getType() == ItemType.RADIO) {
357	boolean selection = false;
358	if (widget instanceof MenuItem) {
359	selection = ((MenuItem) widget).getSelection();
360	} else if (widget instanceof ToolItem) {
361	selection = ((ToolItem) widget).getSelection();
362	}
363	model.setSelected(selection);
364	}
365	if (canExecuteItem()) {
366	executeItem();
367	}
368	}
369	}
370
371	private void executeItem() {
372	ParameterizedCommand cmd = model.getWbCommand();
373	if (cmd == null) {
374	return;
375	}
376	final IEclipseContext lclContext = getContext(model);
377	EHandlerService service = (EHandlerService) lclContext
378	.get(EHandlerService.class.getName());
379	lclContext.set(MItem.class.getName(), model);
380	service.executeHandler(cmd);
381	lclContext.remove(MItem.class.getName());
382	}
383
384	private boolean canExecuteItem() {
385	ParameterizedCommand cmd = model.getWbCommand();
386	if (cmd == null) {
387	return false;
388	}
389	final IEclipseContext lclContext = getContext(model);
390	EHandlerService service = lclContext.get(EHandlerService.class);
391	return service.canExecute(cmd);
392	}
393
394	public void setParent(IContributionManager parent) {
395	if (getParent() instanceof IMenuManager) {
396	IMenuManager menuMgr = (IMenuManager) getParent();
397	menuMgr.removeMenuListener(menuListener);
398	}
399	if (parent instanceof IMenuManager) {
400	IMenuManager menuMgr = (IMenuManager) parent;
401	menuMgr.addMenuListener(menuListener);
402	}
403	super.setParent(parent);
404	}
405
406	private ImageDescriptor getImageDescriptor(MUILabel element) {
407	String iconURI = element.getIconURI();
408	if (iconURI != null && iconURI.length() > 0) {
409	return resUtils.imageDescriptorFromURI(URI.createURI(iconURI));
410	}
411	return null;
412	}
413
414	/**
415	* Return a parent context for this part.
416	*
417	* @param element
418	* the part to start searching from
419	* @return the parent's closest context, or global context if none in the
420	* hierarchy
421	*/
422	protected IEclipseContext getContextForParent(MUIElement element) {
423	return modelService.getContainingContext(element);
424	}
425
426	/**
427	* Return a context for this part.
428	*
429	* @param part
430	* the part to start searching from
431	* @return the closest context, or global context if none in the hierarchy
432	*/
433	protected IEclipseContext getContext(MUIElement part) {
434	if (part instanceof MContext) {
435	return ((MContext) part).getContext();
436	}
437	return getContextForParent(part);
438	}
439
440	public Widget getWidget() {
441	return widget;
442	}
443	}

Lines 10-17 Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/MenuItemRenderer.java (-2 / +1 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.e4.ui.workbench.renderers.swt;	11	package org.eclipse.e4.ui.workbench.renderers.swt;
12		12
13	import org.eclipse.e4.ui.internal.workbench.swt.WorkbenchSWTActivator;
14
15	import java.util.HashMap;	13	import java.util.HashMap;
16	import javax.annotation.PostConstruct;	14	import javax.annotation.PostConstruct;
17	import javax.annotation.PreDestroy;	15	import javax.annotation.PreDestroy;
Lines 24-29 import org.eclipse.e4.core.contexts.IEclipseContext; Link Here
24	import org.eclipse.e4.core.contexts.RunAndTrack;	22	import org.eclipse.e4.core.contexts.RunAndTrack;
25	import org.eclipse.e4.core.services.events.IEventBroker;	23	import org.eclipse.e4.core.services.events.IEventBroker;
26	import org.eclipse.e4.core.services.log.Logger;	24	import org.eclipse.e4.core.services.log.Logger;
		25	import org.eclipse.e4.ui.internal.workbench.swt.WorkbenchSWTActivator;
27	import org.eclipse.e4.ui.model.application.ui.MCoreExpression;	26	import org.eclipse.e4.ui.model.application.ui.MCoreExpression;
28	import org.eclipse.e4.ui.model.application.ui.MElementContainer;	27	import org.eclipse.e4.ui.model.application.ui.MElementContainer;
29	import org.eclipse.e4.ui.model.application.ui.MUIElement;	28	import org.eclipse.e4.ui.model.application.ui.MUIElement;

Added Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewHandledMenuItemRenderer.java (+151 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.e4.ui.workbench.renderers.swt;
13
14	import javax.annotation.PostConstruct;
15	import javax.annotation.PreDestroy;
16	import javax.inject.Inject;
17	import org.eclipse.e4.core.contexts.ContextInjectionFactory;
18	import org.eclipse.e4.core.contexts.IEclipseContext;
19	import org.eclipse.e4.core.services.events.IEventBroker;
20	import org.eclipse.e4.core.services.log.Logger;
21	import org.eclipse.e4.ui.model.application.ui.MUIElement;
22	import org.eclipse.e4.ui.model.application.ui.menu.MHandledMenuItem;
23	import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
24	import org.eclipse.e4.ui.workbench.UIEvents;
25	import org.eclipse.jface.action.IContributionItem;
26	import org.eclipse.jface.action.MenuManager;
27	import org.eclipse.swt.widgets.Menu;
28	import org.eclipse.swt.widgets.MenuItem;
29	import org.osgi.service.event.Event;
30	import org.osgi.service.event.EventHandler;
31
32	/**
33	*
34	*/
35	public class NewHandledMenuItemRenderer extends SWTPartRenderer {
36
37	@Inject
38	Logger logger;
39	@Inject
40	IEventBroker eventBroker;
41	private EventHandler itemUpdater = new EventHandler() {
42	public void handleEvent(Event event) {
43	// Ensure that this event is for a MMenuItem
44	if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
45	return;
46
47	MMenuItem itemModel = (MMenuItem) event
48	.getProperty(UIEvents.EventTags.ELEMENT);
49	MenuItem menuItem = (MenuItem) itemModel.getWidget();
50
51	// No widget == nothing to update
52	if (menuItem == null)
53	return;
54	Object data = menuItem.getData();
55	if (!(data instanceof IContributionItem)) {
56	return;
57	}
58
59	IContributionItem ici = (IContributionItem) data;
60	String attName = (String) event
61	.getProperty(UIEvents.EventTags.ATTNAME);
62	if (UIEvents.UILabel.LABEL.equals(attName)) {
63	ici.update();
64	} else if (UIEvents.UILabel.ICONURI.equals(attName)) {
65	ici.update();
66	}
67	}
68	};
69
70	private EventHandler selectionUpdater = new EventHandler() {
71	public void handleEvent(Event event) {
72	// Ensure that this event is for a MToolItem
73	if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
74	return;
75
76	MMenuItem itemModel = (MMenuItem) event
77	.getProperty(UIEvents.EventTags.ELEMENT);
78	MenuItem menuItem = (MenuItem) itemModel.getWidget();
79	if (menuItem != null) {
80	Object data = menuItem.getData();
81	if (data instanceof IContributionItem) {
82	((IContributionItem) data).update();
83	}
84	}
85	}
86	};
87
88	private EventHandler enabledUpdater = new EventHandler() {
89	public void handleEvent(Event event) {
90	// Ensure that this event is for a MMenuItem
91	if (!(event.getProperty(UIEvents.EventTags.ELEMENT) instanceof MMenuItem))
92	return;
93
94	MMenuItem itemModel = (MMenuItem) event
95	.getProperty(UIEvents.EventTags.ELEMENT);
96	MenuItem menuItem = (MenuItem) itemModel.getWidget();
97	if (menuItem != null) {
98	Object data = menuItem.getData();
99	if (data instanceof IContributionItem) {
100	((IContributionItem) data).update();
101	}
102	}
103	}
104	};
105
106	@PostConstruct
107	public void init() {
108	eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UILabel.TOPIC),
109	itemUpdater);
110	eventBroker.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
111	UIEvents.Item.SELECTED), selectionUpdater);
112	eventBroker
113	.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
114	UIEvents.Item.ENABLED), enabledUpdater);
115	}
116
117	@PreDestroy
118	public void contextDisposed() {
119	eventBroker.unsubscribe(itemUpdater);
120	eventBroker.unsubscribe(selectionUpdater);
121	eventBroker.unsubscribe(enabledUpdater);
122	}
123
124	/*
125	* (non-Javadoc)
126	*
127	* @see
128	* org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer#createWidget
129	* (org.eclipse.e4.ui.model.application.ui.MUIElement, java.lang.Object)
130	*/
131	@Override
132	public Object createWidget(MUIElement element, Object parent) {
133	if (!(element instanceof MHandledMenuItem) \|\| !(parent instanceof Menu))
134	return null;
135
136	Object data = ((Menu) parent).getData();
137	if (!(data instanceof MenuManager)) {
138	return null;
139	}
140	MenuManager parentManager = (MenuManager) data;
141	MHandledMenuItem itemModel = (MHandledMenuItem) element;
142	final IEclipseContext lclContext = getContext(itemModel);
143	HandledContributionItem ci = ContextInjectionFactory.make(
144	HandledContributionItem.class, lclContext);
145	ci.setModel(itemModel);
146	parentManager.add(ci);
147	// parentManager.update(false);
148	return ci.getWidget();
149	}
150
151	}

Lines 66-71 public class NewMenuRenderer extends SWTPartRenderer { Link Here

(-)a/bundles/org.eclipse.e4.ui.workbench.renderers.swt/src/org/eclipse/e4/ui/workbench/renderers/swt/NewMenuRenderer.java (-19 / +49 lines)
66	private static final String NO_LABEL = "UnLabled"; //$NON-NLS-1$	66	private static final String NO_LABEL = "UnLabled"; //$NON-NLS-1$
67		67
68	private Map<MMenu, MenuManager> modelToManager = new HashMap<MMenu, MenuManager>();	68	private Map<MMenu, MenuManager> modelToManager = new HashMap<MMenu, MenuManager>();
		69	private Map<MenuManager, MMenu> managerToModel = new HashMap<MenuManager, MMenu>();
69		70
70	private Map<MMenuItem, IContributionItem> modelToContribution = new HashMap<MMenuItem, IContributionItem>();	71	private Map<MMenuItem, IContributionItem> modelToContribution = new HashMap<MMenuItem, IContributionItem>();
71		72
Lines 118-124 public class NewMenuRenderer extends SWTPartRenderer { Link Here
118	if (!(obj instanceof MMenu)) {	119	if (!(obj instanceof MMenu)) {
119	return;	120	return;
120	}	121	}
121	MenuManager parent = modelToManager.get(obj);	122	MenuManager parent = getManager((MMenu) obj);
122	if (itemModel.isToBeRendered()) {	123	if (itemModel.isToBeRendered()) {
123	if (parent != null) {	124	if (parent != null) {
124	modelProcessSwitch(parent, itemModel);	125	modelProcessSwitch(parent, itemModel);
Lines 179-201 public class NewMenuRenderer extends SWTPartRenderer { Link Here
179	if (menuManager.getMenu() == null) {	180	if (menuManager.getMenu() == null) {
180	return;	181	return;
181	}	182	}
182	Menu menu = menuManager.getMenu();	183	MMenu menuModel = getMenuModel(menuManager);
183	Object obj = menu.getData(AbstractPartRenderer.OWNING_ME);	184	if (menuModel == null) {
184	if (obj == null && menu.getParentItem() != null) {	185	Menu menu = menuManager.getMenu();
185	obj = menu.getParentItem().getData(	186	Object obj = menu.getData(AbstractPartRenderer.OWNING_ME);
186	AbstractPartRenderer.OWNING_ME);	187	if (obj == null && menu.getParentItem() != null) {
187	}	188	obj = menu.getParentItem().getData(
188	if (!(obj instanceof MMenu)) {	189	AbstractPartRenderer.OWNING_ME);
189	return;	190	}
		191	if (!(obj instanceof MMenu)) {
		192	return;
		193	}
		194	menuModel = (MMenu) obj;
190	}	195	}
191	MMenu menuModel = (MMenu) obj;
192	final IEclipseContext parentContext = modelService	196	final IEclipseContext parentContext = modelService
193	.getContainingContext(menuModel);	197	.getContainingContext(menuModel);
194	HashSet<ContributionRecord> records = new HashSet<ContributionRecord>();	198	HashSet<ContributionRecord> records = new HashSet<ContributionRecord>();
195	for (MMenuElement element : menuModel.getChildren()) {	199	for (MMenuElement element : menuModel.getChildren()) {
196	ContributionRecord record = modelContributionToRecord	200	ContributionRecord record = modelContributionToRecord
197	.get(element);	201	.get(element);
198	if (records.add(record)) {	202	if (record != null && records.add(record)) {
199	record.updateVisibility(parentContext);	203	record.updateVisibility(parentContext);
200	}	204	}
201	}	205	}
Lines 211-218 public class NewMenuRenderer extends SWTPartRenderer { Link Here
211	eventBroker	215	eventBroker
212	.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,	216	.subscribe(UIEvents.buildTopic(UIEvents.Item.TOPIC,
213	UIEvents.Item.ENABLED), enabledUpdater);	217	UIEvents.Item.ENABLED), enabledUpdater);
214	eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UIElement.TOPIC,	218	eventBroker.subscribe(UIEvents.buildTopic(UIEvents.UIElement.TOPIC),
215	UIEvents.UIElement.TOBERENDERED), toBeRenderedUpdater);	219	toBeRenderedUpdater);
216		220
217	}	221	}
218		222
Lines 245-251 public class NewMenuRenderer extends SWTPartRenderer { Link Here
245	if (container instanceof MWindow) {	249	if (container instanceof MWindow) {
246	MenuManager menuBarManager = new MenuManager(NO_LABEL,	250	MenuManager menuBarManager = new MenuManager(NO_LABEL,
247	menuModel.getElementId());	251	menuModel.getElementId());
248	modelToManager.put(menuModel, menuBarManager);	252	linkModelToManager(menuModel, menuBarManager);
249	menuBarManager.addMenuListener(visibilityCalculationListener);	253	menuBarManager.addMenuListener(visibilityCalculationListener);
250	newMenu = menuBarManager.createMenuBar((Decorations) parent);	254	newMenu = menuBarManager.createMenuBar((Decorations) parent);
251	((Decorations) parent).setMenuBar(newMenu);	255	((Decorations) parent).setMenuBar(newMenu);
Lines 253-259 public class NewMenuRenderer extends SWTPartRenderer { Link Here
253	} else {	257	} else {
254	MenuManager popupManager = new MenuManager(NO_LABEL,	258	MenuManager popupManager = new MenuManager(NO_LABEL,
255	menuModel.getElementId());	259	menuModel.getElementId());
256	modelToManager.put(menuModel, popupManager);	260	linkModelToManager(menuModel, popupManager);
257	popupManager.addMenuListener(visibilityCalculationListener);	261	popupManager.addMenuListener(visibilityCalculationListener);
258	newMenu = popupManager.createContextMenu((Control) parent);	262	newMenu = popupManager.createContextMenu((Control) parent);
259	((Control) parent).setMenu(newMenu);	263	((Control) parent).setMenu(newMenu);
Lines 267-273 public class NewMenuRenderer extends SWTPartRenderer { Link Here
267	} else if (parent instanceof Control) {	271	} else if (parent instanceof Control) {
268	MenuManager popupManager = new MenuManager(NO_LABEL,	272	MenuManager popupManager = new MenuManager(NO_LABEL,
269	menuModel.getElementId());	273	menuModel.getElementId());
270	modelToManager.put(menuModel, popupManager);	274	linkModelToManager(menuModel, popupManager);
271	popupManager.addMenuListener(visibilityCalculationListener);	275	popupManager.addMenuListener(visibilityCalculationListener);
272	newMenu = popupManager.createContextMenu((Control) parent);	276	newMenu = popupManager.createContextMenu((Control) parent);
273	((Control) parent).setMenu(newMenu);	277	((Control) parent).setMenu(newMenu);
Lines 305-311 public class NewMenuRenderer extends SWTPartRenderer { Link Here
305	}	309	}
306	}	310	}
307		311
308	MenuManager manager = modelToManager.get(menuModel);	312	MenuManager manager = getManager(menuModel);
309	boolean done = toContribute.size() == 0;	313	boolean done = toContribute.size() == 0;
310	while (!done) {	314	while (!done) {
311	ArrayList<MMenuContribution> curList = new ArrayList<MMenuContribution>(	315	ArrayList<MMenuContribution> curList = new ArrayList<MMenuContribution>(
Lines 447-453 public class NewMenuRenderer extends SWTPartRenderer { Link Here
447	if (container == null)	451	if (container == null)
448	return;	452	return;
449		453
450	MenuManager parentManager = modelToManager.get(container);	454	// this is in direct violation of good programming
		455	MenuManager parentManager = getManager((MMenu) ((Object) container));
451	if (parentManager == null) {	456	if (parentManager == null) {
452	return;	457	return;
453	}	458	}
Lines 472-478 public class NewMenuRenderer extends SWTPartRenderer { Link Here
472	ImageDescriptor desc = getImageDescriptor(menuModel);	477	ImageDescriptor desc = getImageDescriptor(menuModel);
473	MenuManager menuManager = new MenuManager(menuText, desc,	478	MenuManager menuManager = new MenuManager(menuText, desc,
474	menuModel.getElementId());	479	menuModel.getElementId());
475	modelToManager.put(menuModel, menuManager);	480	linkModelToManager(menuModel, menuManager);
476	menuManager.addMenuListener(visibilityCalculationListener);	481	menuManager.addMenuListener(visibilityCalculationListener);
477	parentManager.add(menuManager);	482	parentManager.add(menuManager);
478	processContributions(menuModel);	483	processContributions(menuModel);
Lines 492-497 public class NewMenuRenderer extends SWTPartRenderer { Link Here
492	* @param childME	497	* @param childME
493	*/	498	*/
494	void modelProcessSwitch(MenuManager menuManager, MMenuElement childME) {	499	void modelProcessSwitch(MenuManager menuManager, MMenuElement childME) {
		500	if (!childME.isToBeRendered()) {
		501	return;
		502	}
495	if (childME instanceof MHandledMenuItem) {	503	if (childME instanceof MHandledMenuItem) {
496	MHandledMenuItem itemModel = (MHandledMenuItem) childME;	504	MHandledMenuItem itemModel = (MHandledMenuItem) childME;
497	processHandledItem(menuManager, itemModel);	505	processHandledItem(menuManager, itemModel);
Lines 573-576 public class NewMenuRenderer extends SWTPartRenderer { Link Here
573	}	581	}
574	return null;	582	return null;
575	}	583	}
		584
		585	public MenuManager getManager(MMenu model) {
		586	return modelToManager.get(model);
		587	}
		588
		589	public MMenu getMenuModel(MenuManager manager) {
		590	return managerToModel.get(manager);
		591	}
		592
		593	public void linkModelToManager(MMenu model, MenuManager manager) {
		594	modelToManager.put(model, manager);
		595	managerToModel.put(manager, model);
		596	}
		597
		598	public void clearModelToManager(MMenu model, MenuManager manager) {
		599	modelToManager.remove(model);
		600	managerToModel.remove(manager);
		601	}
		602
		603	public IContributionItem getContribution(MMenuElement model) {
		604	return modelToContribution.get(model);
		605	}
576	}	606	}

Lines 48-52 Link Here

(-)a/tests/org.eclipse.e4.ui.tests/plugin.xml (+12 lines)
48	</element>	48	</element>
49	</processor>	49	</processor>
50	</extension>	50	</extension>
		51	<extension
		52	point="org.eclipse.core.expressions.definitions">
		53	<definition
		54	id="org.eclipse.e4.ui.tests.withMmc1">
		55	<with
		56	variable="mmc1">
		57	<equals
		58	value="true">
		59	</equals>
		60	</with>
		61	</definition>
		62	</extension>
51		63
52	</plugin>	64	</plugin>