org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/StackRenderer.java - osbp/org.eclipse.osbp.vaaclipse - Git at Google

 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
  *******************************************************************************/

 package org.eclipse.osbp.vaaclipse.presentation.renderers;

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;

 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.di.annotations.Optional;
 import org.eclipse.e4.ui.model.application.MApplication;
 import org.eclipse.e4.ui.model.application.ui.MDirtyable;
 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.advanced.MPlaceholder;
 import org.eclipse.e4.ui.model.application.ui.basic.MPart;
 import org.eclipse.e4.ui.model.application.ui.basic.MPartStack;
 import org.eclipse.e4.ui.model.application.ui.basic.MStackElement;
 import org.eclipse.e4.ui.model.application.ui.basic.MWindow;
 import org.eclipse.e4.ui.services.internal.events.EventBroker;
 import org.eclipse.e4.ui.workbench.IPresentationEngine;
 import org.eclipse.e4.ui.workbench.UIEvents;
 import org.eclipse.e4.ui.workbench.UIEvents.EventTags;
 import org.eclipse.e4.ui.workbench.modeling.EModelService;
 import org.eclipse.e4.ui.workbench.modeling.EPartService;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.edit.domain.EditingDomain;
 import org.eclipse.osbp.runtime.designer.api.IDesignerService;
 import org.eclipse.osbp.runtime.designer.api.IWidgetDesignConfigurator;
 import org.eclipse.osbp.vaaclipse.api.VaadinExecutorService;
 import org.eclipse.osbp.vaaclipse.presentation.dnd.VaadinDropHandler;
 import org.eclipse.osbp.vaaclipse.publicapi.change.SimpleCommand;
 import org.eclipse.osbp.vaaclipse.publicapi.resources.ResourceHelper;
 import org.eclipse.osbp.vaaclipse.widgets.StackWidget;
 import org.eclipse.osbp.vaaclipse.widgets.StackWidget.StateListener;
 import org.osgi.service.event.Event;
 import org.osgi.service.event.EventHandler;

 import com.vaadin.server.Resource;
 import com.vaadin.ui.Component;
 import com.vaadin.ui.TabSheet;
 import com.vaadin.ui.TabSheet.CloseHandler;
 import com.vaadin.ui.TabSheet.SelectedTabChangeEvent;
 import com.vaadin.ui.TabSheet.SelectedTabChangeListener;
 import com.vaadin.ui.TabSheet.Tab;

 import fi.jasoft.dragdroplayouts.client.ui.LayoutDragMode;

 @SuppressWarnings("restriction")
 public class StackRenderer extends VaadinRenderer implements IDesignerService.IDesignListener {

 	@Inject
 	private EventBroker eventBroker;
 	@Inject
 	private EModelService modelService;
 	@Inject
 	private EditingDomain editingDomain;
 	@Inject
 	private EPartService partService;
 	private Map<Component, MStackElement> vaatab2Element = new HashMap<Component, MStackElement>();
 	private boolean ignoreTabSelChanges = false;

 	@Inject
 	VaadinExecutorService communicationManager;

 	@Inject
 	@Optional
 	private IDesignerService designerService;

 	private EventHandler tagListener = new EventHandler() {
 		@Override
 		public void handleEvent(Event event) {

 			Object changedObj = event.getProperty(EventTags.ELEMENT);
 			String eventType = (String) event.getProperty(UIEvents.EventTags.TYPE);
 			String tag = (String) event.getProperty(UIEvents.EventTags.NEW_VALUE);

 			int location = modelService.getElementLocation((MUIElement) changedObj);
 			if (!(changedObj instanceof MPartStack) || location == EModelService.IN_SHARED_AREA) {
 				return;
 			}

 			final MPartStack stack = (MPartStack) changedObj;
 			StackWidget stackWidget = (StackWidget) stack.getWidget();

 			if (UIEvents.EventTypes.ADD.equals(eventType)) {
 				if (IPresentationEngine.MINIMIZED.equals(tag)) {
 					stackWidget.setState(-1);
 				} else if (IPresentationEngine.MAXIMIZED.equals(tag)) {
 					stackWidget.setState(1);
 				}
 			} else if (UIEvents.EventTypes.REMOVE.equals(eventType)) {
 				stackWidget.setState(0);
 			}
 		}
 	};

 	private EventHandler selectElementHandler = new EventHandler() {

 		public void handleEvent(Event event) {
 			Object element = event.getProperty(UIEvents.EventTags.ELEMENT);

 			if (!(element instanceof MPartStack))
 				return;

 			MPartStack stack = (MPartStack) element;
 			if (stack.getRenderer() != StackRenderer.this)
 				return;

 			if (stack.getSelectedElement() != null) {
 				if (stack.getSelectedElement().getWidget() == null) {
 					IPresentationEngine engine = (IPresentationEngine) context.get(IPresentationEngine.class.getName());
 					engine.createGui(stack.getSelectedElement());

 					int i = 0;
 					for (MStackElement e : stack.getChildren()) {
 						if (e == stack.getSelectedElement())
 							break;

 						if (e.getWidget() != null)
 							i++;
 					}

 					addTab((TabSheet) stack.getWidget(), stack.getSelectedElement(), i);
 				}

 				if (stack.getSelectedElement() instanceof MPart) {
 					MPart selected = (MPart) stack.getSelectedElement();
 					if (selected.getObject() == null) {
 						PartRenderer.renderPartContent(selected, selected.getContext());
 					}
 				}

 				ignoreTabSelChanges = true;
 				((TabSheet) stack.getWidget()).setSelectedTab((Component) stack.getSelectedElement().getWidget());
 				ignoreTabSelChanges = false;
 			}
 		}
 	};

 	EventHandler itemUpdater = new EventHandler() {
 		public void handleEvent(Event event) {
 			MUIElement element = (MUIElement) event.getProperty(UIEvents.EventTags.ELEMENT);
 			if (!(element instanceof MPart))
 				return;

 			MPart part = (MPart) element;

 			String attName = (String) event.getProperty(UIEvents.EventTags.ATTNAME);
 			Object newValue = event.getProperty(UIEvents.EventTags.NEW_VALUE);

 			MPartStack stack = null;
 			// is this a direct child of the stack?
 			MPlaceholder placeholder = null;
 			if (element.getParent() != null && element.getParent().getRenderer() == StackRenderer.this) {
 				stack = (MPartStack) (MElementContainer<?>) element.getParent();
 			} else {
 				// Do we have any stacks with place holders for the element
 				// that's changed?
 				MWindow win = modelService.getTopLevelWindowFor(part);
 				List<MPlaceholder> refs = modelService.findElements(win, null, MPlaceholder.class, null);
 				if (refs != null) {
 					for (MPlaceholder ref : refs) {
 						if (ref.getRef() != part)
 							continue;

 						MElementContainer<?> refParent = ref.getParent();
 						// can be null, see bug 328296
 						if (refParent != null && refParent.getRenderer() instanceof StackRenderer) {
 							placeholder = ref;
 							stack = (MPartStack) refParent;
 						}
 					}
 				}
 			}

 			if (stack != null) {
 				Tab tab = ((StackWidget) stack.getWidget())
 						.getTab((Component) (placeholder == null ? part.getWidget() : placeholder.getWidget()));
 				if (tab != null)
 					updateTab(tab, part, attName, newValue);
 			}
 		}
 	};

 	private void updateTab(Tab tab, MPart part, String attName, Object newValue) {
 		if (UIEvents.UILabel.LABEL.equals(attName)) {
 			String newName = (String) newValue;
 			tab.setCaption(getLabel(part, newName));
 		} else if (UIEvents.UILabel.ICONURI.equals(attName)) {
 			Resource icon = part.getIconURI() != null ? ResourceHelper.createResource(part.getIconURI()) : null;
 			tab.setIcon(icon);
 		} else if (UIEvents.UILabel.TOOLTIP.equals(attName)) {
 			String newTTip = (String) newValue;
 			tab.setDescription(newTTip);
 		} else if (UIEvents.UILabel.LOCALIZED_LABEL.equals(attName)) {
 			String newName = (String) newValue;
 			tab.setCaption(getLabel(part, newName));
 		} else if (UIEvents.UILabel.LOCALIZED_TOOLTIP.equals(attName)) {
 			String newTTip = (String) newValue;
 			tab.setDescription(newTTip);
 		} else if (UIEvents.Dirtyable.DIRTY.equals(attName)) {
 			Boolean dirtyState = (Boolean) newValue;
 			String text = tab.getCaption();
 			boolean hasAsterisk = text.length() > 0 && text.charAt(0) == '*';
 			if (dirtyState.booleanValue()) {
 				if (!hasAsterisk) {
 					tab.setCaption('*' + text);
 				}
 			} else if (hasAsterisk) {
 				tab.setCaption(text.substring(1));
 			}
 		}
 	}

 	private String getLabel(MUILabel itemPart, String newName) {
 		if (newName == null) {
 			newName = ""; //$NON-NLS-1$
 		}
 		if (itemPart instanceof MDirtyable && ((MDirtyable) itemPart).isDirty()) {
 			newName = '*' + newName;
 		}
 		return newName;
 	}

 	@PostConstruct
 	public void postConstruct() {
 		eventBroker.subscribe(UIEvents.ApplicationElement.TOPIC_TAGS, tagListener);
 		eventBroker.subscribe(UIEvents.ElementContainer.TOPIC_SELECTEDELEMENT, selectElementHandler);
 		eventBroker.subscribe(UIEvents.UILabel.TOPIC_ALL, itemUpdater);
 		eventBroker.subscribe(UIEvents.Dirtyable.TOPIC_DIRTY, itemUpdater);
 		eventBroker.subscribe(UIEvents.ElementContainer.TOPIC_CHILDREN, childrenMoveUpdater);
 	}

 	@Override
 	public void notify(IDesignerService.DesignEvent event) {
 		updateDesigner(event.getType() == IDesignerService.EventType.ENABLED);
 	}

 	private void updateDesigner(boolean enabled) {
 		IWidgetDesignConfigurator designConfigurator = context.get(IWidgetDesignConfigurator.class);
 		if (designConfigurator != null) {
 			for (Entry<Component, MStackElement> entry : vaatab2Element.entrySet()) {
 				designConfigurator.configure(entry.getKey(), (EObject) entry.getValue(), enabled);
 			}
 		}
 	}

 	@PreDestroy
 	public void preDestroy() {

 		if (designerService != null) {
 			designerService.removeListener(this);
 		}

 		eventBroker.unsubscribe(tagListener);
 		eventBroker.unsubscribe(selectElementHandler);
 		eventBroker.unsubscribe(itemUpdater);
 		eventBroker.unsubscribe(childrenMoveUpdater);
 	}

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

 			@SuppressWarnings("unchecked")
 			MElementContainer<MUIElement> stack = (MElementContainer<MUIElement>) event
 					.getProperty(UIEvents.EventTags.ELEMENT);
 			String type = (String) event.getProperty(UIEvents.EventTags.TYPE);

 			if (UIEvents.EventTypes.MOVE.equals(type)) {
 				StackWidget stackWidget = (StackWidget) stack.getWidget();
 				stackWidget.removeAllComponents();

 				processContents(stack);
 			}
 		}
 	};

 	@Override
 	public void createWidget(MUIElement element, MElementContainer<MUIElement> parent) {
 		if (!(element instanceof MPartStack))
 			return;

 		MPartStack stack = (MPartStack) element;
 		StackWidget stackWidget = new StackWidget();
 		stackWidget.setDragMode(LayoutDragMode.CLONE);

 		stackWidget.setSizeFull();
 		element.setWidget(stackWidget);

 		IEclipseContext context = modelService.getContainingContext(stack).createChild();
 		context.set(MPartStack.class, stack);

 		VaadinDropHandler dropHandler = ContextInjectionFactory.make(VaadinDropHandler.class, context);
 		stackWidget.setDropHandler(dropHandler);

 		if (designerService != null) {
 			designerService.addListener(this);

 			if (designerService.isDesignMode()) {
 				updateDesigner(true);
 			}
 		}
 	}

 	@Override
 	public void processContents(final MElementContainer<MUIElement> container) {
 		MPartStack stack = (MPartStack) (MElementContainer<?>) container;
 		StackWidget stackWidget = (StackWidget) stack.getWidget();
 		for (MStackElement element : stack.getChildren()) {
 			if (element.isToBeRendered())
 				addTab(stackWidget, (MStackElement) element, stackWidget.getComponentCount());
 		}

 		// if there are childs in stack and the selected element is not
 		// specified for stack, set the first child as selected
 		if (stack.getChildren().size() > 0 && stack.getSelectedElement() == null) {
 			if (stack.getChildren().get(0).isVisible() && stack.getChildren().get(0).isToBeRendered()) {
 				stack.setSelectedElement(stack.getChildren().get(0));
 			}
 		}

 		if (stack.getSelectedElement() != null) {
 			Component stackSelectedComponent = (Component) stack.getSelectedElement().getWidget();
 			stackWidget.setSelectedTab(stackSelectedComponent);
 		}
 	}

 	private void addTab(TabSheet parentPane, MStackElement element, int pos) {
 		MUILabel mLabel;
 		if (element instanceof MPlaceholder)
 			mLabel = (MUILabel) ((MPlaceholder) element).getRef();
 		else
 			mLabel = (MUILabel) element;

 		boolean closable = false;
 		if (mLabel instanceof MPart)
 			closable = ((MPart) mLabel).isCloseable();

 		// Tab tab = parentPane.addTab((com.vaadin.ui.Component)
 		// element.getWidget(), mLabel.getLocalizedLabel(), icon, pos);
 		Tab tab = parentPane.addTab((com.vaadin.ui.Component) element.getWidget(), pos);
 		tab.setCaption(mLabel.getLocalizedLabel());
 		Resource icon = (mLabel.getIconURI() != null && !mLabel.getIconURI().trim().equals(""))
 				? ResourceHelper.createResource(mLabel.getIconURI()) : null;
 		if (icon != null) {
 			tab.setIcon(icon);
 		}
 		tab.setClosable(closable);
 		tab.setDescription(mLabel.getLocalizedTooltip());

 		vaatab2Element.put((Component) element.getWidget(), element);

 		if (designerService != null && designerService.isDesignMode()) {
 			updateDesigner(designerService.isDesignMode());
 		}
 	}

 	@SuppressWarnings("serial")
 	@Override
 	public void hookControllerLogic(final MUIElement element) {
 		final StackWidget sw = (StackWidget) element.getWidget();

 		int location = modelService.getElementLocation(element);
 		if (location != EModelService.IN_SHARED_AREA) // if the stack not in
 														// shared area
 		{
 			sw.addStateListener(new StateListener() {

 				@Override
 				public void stateChanged(int newState, int oldState) {
 					if (oldState == 0 && newState == 1)
 						setState(element, IPresentationEngine.MAXIMIZED);
 					else if (oldState == 1 && newState == 0)
 						setState(element, null);
 					else if (oldState == 1 && newState == -1) {
 						element.getTags().remove(IPresentationEngine.MINIMIZED);
 						element.getTags().remove(IPresentationEngine.MAXIMIZED);
 						element.getTags().add(IPresentationEngine.MINIMIZED);
 					} else if (oldState == -1 && newState == 0) {
 						element.getTags().remove(IPresentationEngine.MINIMIZED_BY_ZOOM);
 						element.getTags().remove(IPresentationEngine.MINIMIZED);
 					} else if (oldState == 0 && newState == -1)
 						setState(element, IPresentationEngine.MINIMIZED);
 				}

 				private void setState(MUIElement element, String state) {
 					element.getTags().remove(IPresentationEngine.MINIMIZED_BY_ZOOM);
 					if (IPresentationEngine.MINIMIZED.equals(state)) {
 						element.getTags().remove(IPresentationEngine.MAXIMIZED);
 						element.getTags().add(IPresentationEngine.MINIMIZED);
 					} else if (IPresentationEngine.MAXIMIZED.equals(state)) {
 						element.getTags().remove(IPresentationEngine.MINIMIZED);
 						element.getTags().add(IPresentationEngine.MAXIMIZED);
 					} else {
 						element.getTags().remove(IPresentationEngine.MINIMIZED);
 						element.getTags().remove(IPresentationEngine.MAXIMIZED);
 					}
 				}
 			});
 		}

 		sw.addSelectedTabChangeListener(new SelectedTabChangeListener() {
 			public void selectedTabChange(SelectedTabChangeEvent event) {
 				final MStackElement stackElement = vaatab2Element.get(sw.getSelectedTab());
 				if (stackElement != null) {
 					if (ignoreTabSelChanges)
 						return;

 					final MPartStack stack = (MPartStack) (MElementContainer<?>) stackElement.getParent();
 					if (stack != null && stack.getSelectedElement() != stackElement) {

 						SimpleCommand command = new SimpleCommand("Switch stack element") {
 							final MStackElement oldStackElement = stack.getSelectedElement();

 							@Override
 							protected void doUndo() {
 								stack.setSelectedElement(oldStackElement);
 								activateStack(stack);
 							}

 							@Override
 							protected void doExecute() {
 								stack.setSelectedElement(stackElement);
 								activateStack(stack);
 							}
 						};
 						editingDomain.getCommandStack().execute(command);
 					}
 				}
 			}
 		});

 		sw.setCloseHandler(new CloseHandler() {

 			public void onTabClose(TabSheet tabsheet, Component tabContent) {
 				MStackElement stackElement = vaatab2Element.get(tabContent);
 				closePart(stackElement);
 			}
 		});
 	}

 	private void activateStack(MPartStack stack) {
 		communicationManager.invokeLater(new ActivationRunnable(stack));
 	}

 	private class ActivationRunnable implements Runnable {

 		private MPartStack stack;

 		public ActivationRunnable(MPartStack stack) {
 			this.stack = stack;
 		}

 		@Override
 		public void run() {
 			MStackElement stackElement = stack.getSelectedElement();
 			// Ensure we're activating a stack in the current perspective,
 			// when using a dialog to open a perspective
 			// we end up in the situation where this stack is in the
 			// previously active perspective
 			int location = modelService.getElementLocation(stack);
 			if ((location & EModelService.IN_ACTIVE_PERSPECTIVE) == 0
 					&& (location & EModelService.OUTSIDE_PERSPECTIVE) == 0
 					&& (location & EModelService.IN_SHARED_AREA) == 0)
 				return;

 			if (!isValid(stackElement))
 				return;

 			if (stackElement instanceof MPlaceholder)
 				stackElement = (MStackElement) ((MPlaceholder) stackElement).getRef();

 			IEclipseContext curContext = getContext(stackElement);
 			if (curContext != null) {
 				EPartService ps = (EPartService) curContext.get(EPartService.class.getName());
 				if (ps != null)
 					ps.activate((MPart) stackElement, true);
 			}
 		}
 	}

 	private boolean isValid(MUIElement element) {
 		if (element == null || !element.isToBeRendered()) {
 			return false;
 		}

 		if (element instanceof MApplication) {
 			return true;
 		}

 		MUIElement parent = element.getParent();
 		if (parent == null && element instanceof MWindow) {
 			// might be a detached window
 			parent = (MUIElement) ((EObject) element).eContainer();
 		}

 		if (parent == null) {
 			// might be a shared part, try to find the placeholder
 			MWindow window = modelService.getTopLevelWindowFor(element);
 			return window == null ? false : isValid(modelService.findPlaceholderFor(window, element));
 		}

 		return isValid(parent);
 	}

 	private boolean isClosable(MPart part) {
 		// if it's a shared part check its current ref
 		if (part.getCurSharedRef() != null) {
 			return !(part.getCurSharedRef().getTags().contains(IPresentationEngine.NO_CLOSE));
 		}

 		return part.isCloseable();
 	}

 	private boolean closePart(MStackElement stackElement) {

 		MPart part = (MPart) ((stackElement instanceof MPart) ? stackElement : ((MPlaceholder) stackElement).getRef());
 		if (!isClosable(part)) {
 			return false;
 		}

 		IEclipseContext partContext = part.getContext();
 		IEclipseContext parentContext = getContextForParent(part);
 		// a part may not have a context if it hasn't been rendered
 		IEclipseContext context = partContext == null ? parentContext : partContext;
 		// Allow closes to be 'canceled'
 		EPartService partService = (EPartService) context.get(EPartService.class.getName());
 		if (partService.savePart(part, true)) {
 			partService.hidePart(part);
 			return true;
 		}
 		// the user has canceled out of the save operation, so don't close the
 		// part
 		return false;
 	}

 	@Override
 	public void setVisible(MUIElement changedElement, boolean visible) {
 		TabSheet tabPane = (TabSheet) changedElement.getWidget();
 		tabPane.setVisible(visible);
 	}

 	@Override
 	public void addChildGui(MUIElement child, MElementContainer<MUIElement> element) {
 		if (!(child instanceof MStackElement))
 			return;

 		StackWidget sw = (StackWidget) element.getWidget();
 		int index = indexOf(child, element);
 		addTab(sw, (MStackElement) child, index);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2012 Rushan R. Gilmullin and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* Rushan R. Gilmullin - initial API and implementation
	*******************************************************************************/

	package org.eclipse.osbp.vaaclipse.presentation.renderers;

	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Map.Entry;

	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.di.annotations.Optional;
	import org.eclipse.e4.ui.model.application.MApplication;
	import org.eclipse.e4.ui.model.application.ui.MDirtyable;
	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.advanced.MPlaceholder;
	import org.eclipse.e4.ui.model.application.ui.basic.MPart;
	import org.eclipse.e4.ui.model.application.ui.basic.MPartStack;
	import org.eclipse.e4.ui.model.application.ui.basic.MStackElement;
	import org.eclipse.e4.ui.model.application.ui.basic.MWindow;
	import org.eclipse.e4.ui.services.internal.events.EventBroker;
	import org.eclipse.e4.ui.workbench.IPresentationEngine;
	import org.eclipse.e4.ui.workbench.UIEvents;
	import org.eclipse.e4.ui.workbench.UIEvents.EventTags;
	import org.eclipse.e4.ui.workbench.modeling.EModelService;
	import org.eclipse.e4.ui.workbench.modeling.EPartService;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.edit.domain.EditingDomain;
	import org.eclipse.osbp.runtime.designer.api.IDesignerService;
	import org.eclipse.osbp.runtime.designer.api.IWidgetDesignConfigurator;
	import org.eclipse.osbp.vaaclipse.api.VaadinExecutorService;
	import org.eclipse.osbp.vaaclipse.presentation.dnd.VaadinDropHandler;
	import org.eclipse.osbp.vaaclipse.publicapi.change.SimpleCommand;
	import org.eclipse.osbp.vaaclipse.publicapi.resources.ResourceHelper;
	import org.eclipse.osbp.vaaclipse.widgets.StackWidget;
	import org.eclipse.osbp.vaaclipse.widgets.StackWidget.StateListener;
	import org.osgi.service.event.Event;
	import org.osgi.service.event.EventHandler;

	import com.vaadin.server.Resource;
	import com.vaadin.ui.Component;
	import com.vaadin.ui.TabSheet;
	import com.vaadin.ui.TabSheet.CloseHandler;
	import com.vaadin.ui.TabSheet.SelectedTabChangeEvent;
	import com.vaadin.ui.TabSheet.SelectedTabChangeListener;
	import com.vaadin.ui.TabSheet.Tab;

	import fi.jasoft.dragdroplayouts.client.ui.LayoutDragMode;

	@SuppressWarnings("restriction")
	public class StackRenderer extends VaadinRenderer implements IDesignerService.IDesignListener {

	@Inject
	private EventBroker eventBroker;
	@Inject
	private EModelService modelService;
	@Inject
	private EditingDomain editingDomain;
	@Inject
	private EPartService partService;
	private Map<Component, MStackElement> vaatab2Element = new HashMap<Component, MStackElement>();
	private boolean ignoreTabSelChanges = false;

	@Inject
	VaadinExecutorService communicationManager;

	@Inject
	@Optional
	private IDesignerService designerService;

	private EventHandler tagListener = new EventHandler() {
	@Override
	public void handleEvent(Event event) {

	Object changedObj = event.getProperty(EventTags.ELEMENT);
	String eventType = (String) event.getProperty(UIEvents.EventTags.TYPE);
	String tag = (String) event.getProperty(UIEvents.EventTags.NEW_VALUE);

	int location = modelService.getElementLocation((MUIElement) changedObj);
	if (!(changedObj instanceof MPartStack) \|\| location == EModelService.IN_SHARED_AREA) {
	return;
	}

	final MPartStack stack = (MPartStack) changedObj;
	StackWidget stackWidget = (StackWidget) stack.getWidget();

	if (UIEvents.EventTypes.ADD.equals(eventType)) {
	if (IPresentationEngine.MINIMIZED.equals(tag)) {
	stackWidget.setState(-1);
	} else if (IPresentationEngine.MAXIMIZED.equals(tag)) {
	stackWidget.setState(1);
	}
	} else if (UIEvents.EventTypes.REMOVE.equals(eventType)) {
	stackWidget.setState(0);
	}
	}
	};

	private EventHandler selectElementHandler = new EventHandler() {

	public void handleEvent(Event event) {
	Object element = event.getProperty(UIEvents.EventTags.ELEMENT);

	if (!(element instanceof MPartStack))
	return;

	MPartStack stack = (MPartStack) element;
	if (stack.getRenderer() != StackRenderer.this)
	return;

	if (stack.getSelectedElement() != null) {
	if (stack.getSelectedElement().getWidget() == null) {
	IPresentationEngine engine = (IPresentationEngine) context.get(IPresentationEngine.class.getName());
	engine.createGui(stack.getSelectedElement());

	int i = 0;
	for (MStackElement e : stack.getChildren()) {
	if (e == stack.getSelectedElement())
	break;

	if (e.getWidget() != null)
	i++;
	}

	addTab((TabSheet) stack.getWidget(), stack.getSelectedElement(), i);
	}

	if (stack.getSelectedElement() instanceof MPart) {
	MPart selected = (MPart) stack.getSelectedElement();
	if (selected.getObject() == null) {
	PartRenderer.renderPartContent(selected, selected.getContext());
	}
	}

	ignoreTabSelChanges = true;
	((TabSheet) stack.getWidget()).setSelectedTab((Component) stack.getSelectedElement().getWidget());
	ignoreTabSelChanges = false;
	}
	}
	};

	EventHandler itemUpdater = new EventHandler() {
	public void handleEvent(Event event) {
	MUIElement element = (MUIElement) event.getProperty(UIEvents.EventTags.ELEMENT);
	if (!(element instanceof MPart))
	return;

	MPart part = (MPart) element;

	String attName = (String) event.getProperty(UIEvents.EventTags.ATTNAME);
	Object newValue = event.getProperty(UIEvents.EventTags.NEW_VALUE);

	MPartStack stack = null;
	// is this a direct child of the stack?
	MPlaceholder placeholder = null;
	if (element.getParent() != null && element.getParent().getRenderer() == StackRenderer.this) {
	stack = (MPartStack) (MElementContainer<?>) element.getParent();
	} else {
	// Do we have any stacks with place holders for the element
	// that's changed?
	MWindow win = modelService.getTopLevelWindowFor(part);
	List<MPlaceholder> refs = modelService.findElements(win, null, MPlaceholder.class, null);
	if (refs != null) {
	for (MPlaceholder ref : refs) {
	if (ref.getRef() != part)
	continue;

	MElementContainer<?> refParent = ref.getParent();
	// can be null, see bug 328296
	if (refParent != null && refParent.getRenderer() instanceof StackRenderer) {
	placeholder = ref;
	stack = (MPartStack) refParent;
	}
	}
	}
	}

	if (stack != null) {
	Tab tab = ((StackWidget) stack.getWidget())
	.getTab((Component) (placeholder == null ? part.getWidget() : placeholder.getWidget()));
	if (tab != null)
	updateTab(tab, part, attName, newValue);
	}
	}
	};

	private void updateTab(Tab tab, MPart part, String attName, Object newValue) {
	if (UIEvents.UILabel.LABEL.equals(attName)) {
	String newName = (String) newValue;
	tab.setCaption(getLabel(part, newName));
	} else if (UIEvents.UILabel.ICONURI.equals(attName)) {
	Resource icon = part.getIconURI() != null ? ResourceHelper.createResource(part.getIconURI()) : null;
	tab.setIcon(icon);
	} else if (UIEvents.UILabel.TOOLTIP.equals(attName)) {
	String newTTip = (String) newValue;
	tab.setDescription(newTTip);
	} else if (UIEvents.UILabel.LOCALIZED_LABEL.equals(attName)) {
	String newName = (String) newValue;
	tab.setCaption(getLabel(part, newName));
	} else if (UIEvents.UILabel.LOCALIZED_TOOLTIP.equals(attName)) {
	String newTTip = (String) newValue;
	tab.setDescription(newTTip);
	} else if (UIEvents.Dirtyable.DIRTY.equals(attName)) {
	Boolean dirtyState = (Boolean) newValue;
	String text = tab.getCaption();
	boolean hasAsterisk = text.length() > 0 && text.charAt(0) == '*';
	if (dirtyState.booleanValue()) {
	if (!hasAsterisk) {
	tab.setCaption('*' + text);
	}
	} else if (hasAsterisk) {
	tab.setCaption(text.substring(1));
	}
	}
	}

	private String getLabel(MUILabel itemPart, String newName) {
	if (newName == null) {
	newName = ""; //$NON-NLS-1$
	}
	if (itemPart instanceof MDirtyable && ((MDirtyable) itemPart).isDirty()) {
	newName = '*' + newName;
	}
	return newName;
	}

	@PostConstruct
	public void postConstruct() {
	eventBroker.subscribe(UIEvents.ApplicationElement.TOPIC_TAGS, tagListener);
	eventBroker.subscribe(UIEvents.ElementContainer.TOPIC_SELECTEDELEMENT, selectElementHandler);
	eventBroker.subscribe(UIEvents.UILabel.TOPIC_ALL, itemUpdater);
	eventBroker.subscribe(UIEvents.Dirtyable.TOPIC_DIRTY, itemUpdater);
	eventBroker.subscribe(UIEvents.ElementContainer.TOPIC_CHILDREN, childrenMoveUpdater);
	}

	@Override
	public void notify(IDesignerService.DesignEvent event) {
	updateDesigner(event.getType() == IDesignerService.EventType.ENABLED);
	}

	private void updateDesigner(boolean enabled) {
	IWidgetDesignConfigurator designConfigurator = context.get(IWidgetDesignConfigurator.class);
	if (designConfigurator != null) {
	for (Entry<Component, MStackElement> entry : vaatab2Element.entrySet()) {
	designConfigurator.configure(entry.getKey(), (EObject) entry.getValue(), enabled);
	}
	}
	}

	@PreDestroy
	public void preDestroy() {

	if (designerService != null) {
	designerService.removeListener(this);
	}

	eventBroker.unsubscribe(tagListener);
	eventBroker.unsubscribe(selectElementHandler);
	eventBroker.unsubscribe(itemUpdater);
	eventBroker.unsubscribe(childrenMoveUpdater);
	}

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

	@SuppressWarnings("unchecked")
	MElementContainer<MUIElement> stack = (MElementContainer<MUIElement>) event
	.getProperty(UIEvents.EventTags.ELEMENT);
	String type = (String) event.getProperty(UIEvents.EventTags.TYPE);

	if (UIEvents.EventTypes.MOVE.equals(type)) {
	StackWidget stackWidget = (StackWidget) stack.getWidget();
	stackWidget.removeAllComponents();

	processContents(stack);
	}
	}
	};

	@Override
	public void createWidget(MUIElement element, MElementContainer<MUIElement> parent) {
	if (!(element instanceof MPartStack))
	return;

	MPartStack stack = (MPartStack) element;
	StackWidget stackWidget = new StackWidget();
	stackWidget.setDragMode(LayoutDragMode.CLONE);

	stackWidget.setSizeFull();
	element.setWidget(stackWidget);

	IEclipseContext context = modelService.getContainingContext(stack).createChild();
	context.set(MPartStack.class, stack);

	VaadinDropHandler dropHandler = ContextInjectionFactory.make(VaadinDropHandler.class, context);
	stackWidget.setDropHandler(dropHandler);

	if (designerService != null) {
	designerService.addListener(this);

	if (designerService.isDesignMode()) {
	updateDesigner(true);
	}
	}
	}

	@Override
	public void processContents(final MElementContainer<MUIElement> container) {
	MPartStack stack = (MPartStack) (MElementContainer<?>) container;
	StackWidget stackWidget = (StackWidget) stack.getWidget();
	for (MStackElement element : stack.getChildren()) {
	if (element.isToBeRendered())
	addTab(stackWidget, (MStackElement) element, stackWidget.getComponentCount());
	}

	// if there are childs in stack and the selected element is not
	// specified for stack, set the first child as selected
	if (stack.getChildren().size() > 0 && stack.getSelectedElement() == null) {
	if (stack.getChildren().get(0).isVisible() && stack.getChildren().get(0).isToBeRendered()) {
	stack.setSelectedElement(stack.getChildren().get(0));
	}
	}

	if (stack.getSelectedElement() != null) {
	Component stackSelectedComponent = (Component) stack.getSelectedElement().getWidget();
	stackWidget.setSelectedTab(stackSelectedComponent);
	}
	}

	private void addTab(TabSheet parentPane, MStackElement element, int pos) {
	MUILabel mLabel;
	if (element instanceof MPlaceholder)
	mLabel = (MUILabel) ((MPlaceholder) element).getRef();
	else
	mLabel = (MUILabel) element;

	boolean closable = false;
	if (mLabel instanceof MPart)
	closable = ((MPart) mLabel).isCloseable();

	// Tab tab = parentPane.addTab((com.vaadin.ui.Component)
	// element.getWidget(), mLabel.getLocalizedLabel(), icon, pos);
	Tab tab = parentPane.addTab((com.vaadin.ui.Component) element.getWidget(), pos);
	tab.setCaption(mLabel.getLocalizedLabel());
	Resource icon = (mLabel.getIconURI() != null && !mLabel.getIconURI().trim().equals(""))
	? ResourceHelper.createResource(mLabel.getIconURI()) : null;
	if (icon != null) {
	tab.setIcon(icon);
	}
	tab.setClosable(closable);
	tab.setDescription(mLabel.getLocalizedTooltip());

	vaatab2Element.put((Component) element.getWidget(), element);

	if (designerService != null && designerService.isDesignMode()) {
	updateDesigner(designerService.isDesignMode());
	}
	}

	@SuppressWarnings("serial")
	@Override
	public void hookControllerLogic(final MUIElement element) {
	final StackWidget sw = (StackWidget) element.getWidget();

	int location = modelService.getElementLocation(element);
	if (location != EModelService.IN_SHARED_AREA) // if the stack not in
	// shared area
	{
	sw.addStateListener(new StateListener() {

	@Override
	public void stateChanged(int newState, int oldState) {
	if (oldState == 0 && newState == 1)
	setState(element, IPresentationEngine.MAXIMIZED);
	else if (oldState == 1 && newState == 0)
	setState(element, null);
	else if (oldState == 1 && newState == -1) {
	element.getTags().remove(IPresentationEngine.MINIMIZED);
	element.getTags().remove(IPresentationEngine.MAXIMIZED);
	element.getTags().add(IPresentationEngine.MINIMIZED);
	} else if (oldState == -1 && newState == 0) {
	element.getTags().remove(IPresentationEngine.MINIMIZED_BY_ZOOM);
	element.getTags().remove(IPresentationEngine.MINIMIZED);
	} else if (oldState == 0 && newState == -1)
	setState(element, IPresentationEngine.MINIMIZED);
	}

	private void setState(MUIElement element, String state) {
	element.getTags().remove(IPresentationEngine.MINIMIZED_BY_ZOOM);
	if (IPresentationEngine.MINIMIZED.equals(state)) {
	element.getTags().remove(IPresentationEngine.MAXIMIZED);
	element.getTags().add(IPresentationEngine.MINIMIZED);
	} else if (IPresentationEngine.MAXIMIZED.equals(state)) {
	element.getTags().remove(IPresentationEngine.MINIMIZED);
	element.getTags().add(IPresentationEngine.MAXIMIZED);
	} else {
	element.getTags().remove(IPresentationEngine.MINIMIZED);
	element.getTags().remove(IPresentationEngine.MAXIMIZED);
	}
	}
	});
	}

	sw.addSelectedTabChangeListener(new SelectedTabChangeListener() {
	public void selectedTabChange(SelectedTabChangeEvent event) {
	final MStackElement stackElement = vaatab2Element.get(sw.getSelectedTab());
	if (stackElement != null) {
	if (ignoreTabSelChanges)
	return;

	final MPartStack stack = (MPartStack) (MElementContainer<?>) stackElement.getParent();
	if (stack != null && stack.getSelectedElement() != stackElement) {

	SimpleCommand command = new SimpleCommand("Switch stack element") {
	final MStackElement oldStackElement = stack.getSelectedElement();

	@Override
	protected void doUndo() {
	stack.setSelectedElement(oldStackElement);
	activateStack(stack);
	}

	@Override
	protected void doExecute() {
	stack.setSelectedElement(stackElement);
	activateStack(stack);
	}
	};
	editingDomain.getCommandStack().execute(command);
	}
	}
	}
	});

	sw.setCloseHandler(new CloseHandler() {

	public void onTabClose(TabSheet tabsheet, Component tabContent) {
	MStackElement stackElement = vaatab2Element.get(tabContent);
	closePart(stackElement);
	}
	});
	}

	private void activateStack(MPartStack stack) {
	communicationManager.invokeLater(new ActivationRunnable(stack));
	}

	private class ActivationRunnable implements Runnable {

	private MPartStack stack;

	public ActivationRunnable(MPartStack stack) {
	this.stack = stack;
	}

	@Override
	public void run() {
	MStackElement stackElement = stack.getSelectedElement();
	// Ensure we're activating a stack in the current perspective,
	// when using a dialog to open a perspective
	// we end up in the situation where this stack is in the
	// previously active perspective
	int location = modelService.getElementLocation(stack);
	if ((location & EModelService.IN_ACTIVE_PERSPECTIVE) == 0
	&& (location & EModelService.OUTSIDE_PERSPECTIVE) == 0
	&& (location & EModelService.IN_SHARED_AREA) == 0)
	return;

	if (!isValid(stackElement))
	return;

	if (stackElement instanceof MPlaceholder)
	stackElement = (MStackElement) ((MPlaceholder) stackElement).getRef();

	IEclipseContext curContext = getContext(stackElement);
	if (curContext != null) {
	EPartService ps = (EPartService) curContext.get(EPartService.class.getName());
	if (ps != null)
	ps.activate((MPart) stackElement, true);
	}
	}
	}

	private boolean isValid(MUIElement element) {
	if (element == null \|\| !element.isToBeRendered()) {
	return false;
	}

	if (element instanceof MApplication) {
	return true;
	}

	MUIElement parent = element.getParent();
	if (parent == null && element instanceof MWindow) {
	// might be a detached window
	parent = (MUIElement) ((EObject) element).eContainer();
	}

	if (parent == null) {
	// might be a shared part, try to find the placeholder
	MWindow window = modelService.getTopLevelWindowFor(element);
	return window == null ? false : isValid(modelService.findPlaceholderFor(window, element));
	}

	return isValid(parent);
	}

	private boolean isClosable(MPart part) {
	// if it's a shared part check its current ref
	if (part.getCurSharedRef() != null) {
	return !(part.getCurSharedRef().getTags().contains(IPresentationEngine.NO_CLOSE));
	}

	return part.isCloseable();
	}

	private boolean closePart(MStackElement stackElement) {

	MPart part = (MPart) ((stackElement instanceof MPart) ? stackElement : ((MPlaceholder) stackElement).getRef());
	if (!isClosable(part)) {
	return false;
	}

	IEclipseContext partContext = part.getContext();
	IEclipseContext parentContext = getContextForParent(part);
	// a part may not have a context if it hasn't been rendered
	IEclipseContext context = partContext == null ? parentContext : partContext;
	// Allow closes to be 'canceled'
	EPartService partService = (EPartService) context.get(EPartService.class.getName());
	if (partService.savePart(part, true)) {
	partService.hidePart(part);
	return true;
	}
	// the user has canceled out of the save operation, so don't close the
	// part
	return false;
	}

	@Override
	public void setVisible(MUIElement changedElement, boolean visible) {
	TabSheet tabPane = (TabSheet) changedElement.getWidget();
	tabPane.setVisible(visible);
	}

	@Override
	public void addChildGui(MUIElement child, MElementContainer<MUIElement> element) {
	if (!(child instanceof MStackElement))
	return;

	StackWidget sw = (StackWidget) element.getWidget();
	int index = indexOf(child, element);
	addTab(sw, (MStackElement) child, index);
	}
	}