plugins/org.eclipse.app4mc.visualization.ui/src/org/eclipse/app4mc/visualization/ui/VisualizationPart.java - app4mc/org.eclipse.app4mc - Git at Google

 /*********************************************************************************
  * Copyright (c) 2020-2021 Robert Bosch GmbH and others.
  *
  * This program and the accompanying materials are made
  * available under the terms of the Eclipse Public License 2.0
  * which is available at https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Robert Bosch GmbH - initial API and implementation
  ********************************************************************************
  */

 package org.eclipse.app4mc.visualization.ui;

 import java.util.ArrayList;
 import java.util.Collections;
 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 javax.inject.Named;

 import org.apache.commons.lang.ClassUtils;
 import org.eclipse.app4mc.visualization.ui.registry.ModelVisualization;
 import org.eclipse.app4mc.visualization.ui.registry.ModelVisualizationRegistry;
 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.core.di.extensions.Service;
 import org.eclipse.e4.ui.di.PersistState;
 import org.eclipse.e4.ui.model.application.ui.basic.MPart;
 import org.eclipse.e4.ui.model.application.ui.menu.MDirectToolItem;
 import org.eclipse.e4.ui.model.application.ui.menu.MToolBarElement;
 import org.eclipse.e4.ui.services.IServiceConstants;
 import org.eclipse.emf.common.notify.Adapter;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.impl.AdapterImpl;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.jface.viewers.TreeSelection;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.layout.FillLayout;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Label;

 @SuppressWarnings("restriction")
 public class VisualizationPart {

 	/**
 	 * The ID that is used in the model fragment for this part.
 	 */
 	public static final String ID = "org.eclipse.app4mc.visualization.ui.partdescriptor.app4mcvisualizations";

 	private static final String LAST_SELECTED_STATE = "LAST_SELECTED";

 	@Inject
 	@Service
 	ModelVisualizationRegistry registry;

 	/**
 	 * The {@link IEclipseContext} of this part.
 	 */
 	@Inject
 	IEclipseContext partContext;

 	/**
 	 * The parent {@link Composite} of this part.
 	 */
 	Composite parentComposite;

 	/**
 	 * The {@link Composite} on which the visualization is rendered.
 	 */
 	Composite visualizationComposite;

 	/**
 	 * The model type that should be visualized.
 	 */
 	List<Class<?>> activeTypes;

 	/**
 	 * The model elements that are used for the visualization.
 	 */
 	List<?> activeModelElements;

 	/**
 	 * The current active rendered visualization.
 	 */
 	ModelVisualization activeVisualization;

 	/**
 	 * The list of all available visualizations available for the current {@link #activeType}.
 	 */
 	List<ModelVisualization> availableModelVisualizations;

 	/**
 	 * The {@link IEclipseContext} that is created for the visualization rendering.
 	 */
 	IEclipseContext activeContext;

 	/**
 	 * <code>true</code> if the selection listener is disabled, <code>false</code>
 	 * if the visualization is updated on selection changes.
 	 */
 	boolean pinned = false;

 	/**
 	 * Mapping of model type to visualization id to remember the last selected visualization.
 	 */
 	HashMap<String, String> lastSelected = new HashMap<>();

 	private boolean adapterEnabled = true;
 	/**
 	 * EMF Adapter to reload the visualization on model property changes.
 	 */
 	Adapter updateViewAdapter = new AdapterImpl() {

 		@Override
 		public void notifyChanged(Notification msg) {
 			if (adapterEnabled && activeVisualization != null) {
 				showVisualization(activeVisualization.getId());
 			}
 		}
 	};

 	@PostConstruct
 	public void postConstruct(Composite parent, MPart part,
 			@Optional @Named(IServiceConstants.ACTIVE_SELECTION) ISelection selection) {
 		parentComposite = parent;
 		parentComposite.setLayout(new FillLayout());
 		parentComposite.setBackground(Display.getDefault().getSystemColor(SWT.COLOR_WHITE));

 		if (visualizationComposite == null) {
 			visualizationComposite = new Composite(parent, SWT.NONE);
 			visualizationComposite.setLayout(new FillLayout());
 			if (selection != null) {
 				handleSelection(selection);
 			} else {
 				showEmpty(visualizationComposite);
 			}
 		}

 		// load previous selected states
 		Map<String, String> state = part.getPersistedState();

 		String lastSelectedString = state.get(LAST_SELECTED_STATE);
 		if (lastSelectedString != null) {
 			lastSelectedString = lastSelectedString.substring(1, lastSelectedString.length() - 1);
 			String[] keyValues = lastSelectedString.split(",");
 			for (String entry : keyValues) {
 				String[] keyValue = entry.split("=");
 				if (keyValue.length == 2) {
 					lastSelected.put(keyValue[0], keyValue[1]);
 				}
 			}
 		}

 		// ensure the checked state of the pin tool item is reset
 		for (MToolBarElement element : part.getToolbar().getChildren()) {
 			if (element.getElementId().equals("org.eclipse.app4mc.visualization.ui.directtoolitem.pin")) {
 				MDirectToolItem toolItem = (MDirectToolItem) element;
 				toolItem.setSelected(pinned);
 			}
 		}
 	}

 	/**
 	 * Disposes a current visualization and renders the visualization for the
 	 * current active model element.
 	 *
 	 * @param visualizationId The ID of the visualization to show. Can be
 	 *                        <code>null</code> which results in showing the first
 	 *                        available visualization.
 	 */
 	public void showVisualization(String visualizationId) {
 		showVisualization(visualizationId, false);
 	}

 	/**
 	 * Disposes a current visualization and renders the visualization for the
 	 * current active model element.
 	 *
 	 * @param visualizationId The ID of the visualization to show. Can be
 	 *                        <code>null</code> which results in showing the first
 	 *                        available visualization.
 	 * @param reload          <code>true</code> if this method is called to reload a
 	 *                        visualization, <code>false</code> if a new
 	 *                        visualization should be opened.
 	 */
 	public void showVisualization(String visualizationId, boolean reload) {
 		if (parentComposite == null || (!reload && isPinned())) {
 			return;
 		}

 		// clear any current active visualization
 		if (visualizationComposite != null) {
 			if (activeContext != null && activeVisualization != null) {
 				ContextInjectionFactory.invoke(activeVisualization, PreDestroy.class, activeContext, null);
 				activeContext.dispose();
 			}
 			visualizationComposite.dispose();
 		}

 		// create a new Composite as parent for the visualization
 		visualizationComposite = new Composite(parentComposite, SWT.NONE);
 		visualizationComposite.setLayout(new FillLayout());

 		// find the visualization for the current active model type and the given id
 		availableModelVisualizations = registry.getVisualizations(activeTypes);
 		if (!availableModelVisualizations.isEmpty()) {

 			if (visualizationId != null) {
 				activeVisualization = availableModelVisualizations.stream()
 						.filter(mv -> mv.getId().equals(visualizationId))
 						.findFirst()
 						.orElse(null);

 				// only handle if there is a visualization for the given id
 				if (activeVisualization != null) {
 					lastSelected.put(activeTypes.get(0).getName(), visualizationId);	// ???
 				} else {
 					// take the first returned available visualization
 					activeVisualization = availableModelVisualizations.get(0);
 				}
 			} else {
 				// take the first returned available visualization
 				activeVisualization = availableModelVisualizations.get(0);
 			}

 			if (activeVisualization != null) {
 				activeContext = partContext.createChild(activeTypes.get(0) + " Visualization");	// ???
 				activeContext.set(Composite.class, visualizationComposite);

 				activeContext.set(activeVisualization.getType(), activeModelElements.get(0));
 				activeContext.set(List.class, activeModelElements);

 				ContextInjectionFactory.invoke(activeVisualization.getVisualization(), PostConstruct.class, activeContext);
 				parentComposite.layout(true);
 			} else {
 				showEmpty(visualizationComposite);
 			}
 		} else {
 			showEmpty(visualizationComposite);
 		}
 	}

 	@Inject
 	@Optional
 	void handleSelection(@Named(IServiceConstants.ACTIVE_SELECTION) ISelection selection) {
 		if (!pinned) {

 			// ensure that we are able to remove the adapter from a previous selection
 			EObject previous = null;
 			if (activeModelElements != null
 					&& activeModelElements.size() == 1
 					&& activeModelElements.get(0) instanceof EObject) {
 				previous = (EObject) activeModelElements.get(0);
 			}

 			if (selection instanceof TreeSelection && !selection.isEmpty()) {
 				TreeSelection s = (TreeSelection) selection;

 				activeModelElements = s.toList();

 				activeTypes = getNearestCommonTypes(activeModelElements);

 				availableModelVisualizations = null;

 				// remove the adapter from a previous selection
 				if (previous != null) {
 					adapterEnabled = false;
 					previous.eAdapters().remove(updateViewAdapter);
 				}

 				if (!activeTypes.isEmpty() && activeModelElements.size() == 1
 						&& activeModelElements.get(0) instanceof EObject) {
 					((EObject) activeModelElements.get(0)).eAdapters().add(updateViewAdapter);
 					adapterEnabled = true;
 				}

 				// check if there is a default visualization already configured
 				showVisualization(!activeTypes.isEmpty() ? lastSelected.get(activeTypes.get(0).getName()) : null);	// ???
 			}
 		}
 	}

 	private List<Class<?>> getNearestCommonTypes(List<?> modelElements) {
 		if (modelElements.isEmpty()) {
 			return Collections.emptyList();
 		}

 		// get type candidate
 		Class<? extends Object> class1 = modelElements.get(0).getClass();
 		Class<?>[] interfaces = class1.getInterfaces();
 		final Class<?> typeCandidate = interfaces.length > 0 ? interfaces[0] : class1;

 		// one model element
 		if (modelElements.size() == 1) {
 			return Collections.singletonList(typeCandidate);
 		}

 		// multiple model elements

 		boolean sameModelType = modelElements.stream().allMatch(element -> {
 			Class<? extends Object> elementClass = element.getClass();
 			Class<?>[] elementInterfaces = elementClass.getInterfaces();
 			return elementInterfaces.length > 0 && elementInterfaces[0].equals(typeCandidate);
 		});

 		// all elements are of the same type
 		if (sameModelType) {
 			return Collections.singletonList(typeCandidate);
 		}

 		// compute common interfaces

 		// for class1:
 		//  - compute all interfaces
 		//  - keep interfaces in the same package
 		//  - keep EObject as common super interface
 		@SuppressWarnings("unchecked")
 		List<Class<?>> allInterfaces = ClassUtils.getAllInterfaces(class1);
 		final String name = class1.getPackage().getName();
 		final String prefix = (name.endsWith(".impl")) ? name.substring(0, name.length() - 5) : name;
 		allInterfaces.removeIf( i -> ! (i.equals(EObject.class) || i.getPackage().getName().startsWith(prefix)) );
 		// compute intersection with interfaces of other model elements
 		for (int i = 1; i < modelElements.size(); i++) {
 			allInterfaces.retainAll(ClassUtils.getAllInterfaces(modelElements.get(i).getClass()));
 		}
 		// remove super interfaces
 		List<Class<?>> commonInterfaces = new ArrayList<>();
 		for (Class<?> tmpInterface : allInterfaces) {
 			List<Class<?>> otherInterfaces = new ArrayList<>(allInterfaces);
 			otherInterfaces.remove(tmpInterface);
 			if (otherInterfaces.stream().noneMatch(other -> tmpInterface.isAssignableFrom(other))) {
 				commonInterfaces.add(tmpInterface);
 			}
 		}

 		return commonInterfaces;
 	}

 	/**
 	 *
 	 * @param parent The parent {@link Composite}, should be the {@link #visualizationComposite}.
 	 */
 	private void showEmpty(Composite parent) {
 		Label label = new Label(parent, SWT.NONE);
 		if (hasActiveModelElement()) {
 			StringBuilder sb = new StringBuilder("There is no visualization available for the active selection.");
 			if (activeTypes.isEmpty()) {
 				sb.append("\n\n - no common types detected - ");
 			} else {
 				sb.append("\n\ndetected ");
 				sb.append((activeModelElements.size() == 1) ? "" : "common " );
 				sb.append((activeTypes.size() == 1) ? "type:" : "types:" );
 				activeTypes.forEach(t -> sb.append("\n - " + t.getSimpleName()));
 			}
 			label.setText(sb.toString());
 		} else {
 			label.setText("There is no active selection.");
 		}
 		parent.getParent().layout(true);
 	}

 	@PreDestroy
 	public void preDestroy() {
 		if (visualizationComposite != null) {
 			visualizationComposite.dispose();
 		}
 		if (activeContext != null) {
 			activeContext.dispose();
 		}
 	}

 	/**
 	 *
 	 * @return The model type that should be visualized.
 	 */
 	public List<Class<?>> getActiveModelTypes() {
 		return activeTypes;
 	}

 	/**
 	 *
 	 * @return The model elements that are used for the visualization.
 	 */
 	public List<?> getActiveModelElements() {
 		return activeModelElements;
 	}

 	/**
 	 *
 	 * @return <code>true</code> if an active model element is set,
 	 *         <code>false</code> if no active model element is available.
 	 */
 	public boolean hasActiveModelElement() {
 		return activeModelElements != null && !activeModelElements.isEmpty();
 	}

 	/**
 	 *
 	 * @return The current active rendered visualization.
 	 */
 	public ModelVisualization getActiveVisualization() {
 		return activeVisualization;
 	}

 	/**
 	 *
 	 * @return The list of all available visualizations available for the current
 	 *         {@link #activeType}.
 	 */
 	public List<ModelVisualization> getAvailableModelVisualizations() {
 		return availableModelVisualizations != null ? availableModelVisualizations : Collections.emptyList();
 	}

 	/**
 	 *
 	 * @return <code>true</code> if the selection listener is disabled,
 	 *         <code>false</code> if the visualization is updated on
 	 *         selection changes.
 	 */
 	public boolean isPinned() {
 		return pinned;
 	}

 	/**
 	 *
 	 * @param pinned <code>true</code> if the selection listener should be disabled,
 	 *               <code>false</code> if the visualization should be updated on
 	 *               selection changes.
 	 */
 	public void setPinned(boolean pinned) {
 		this.pinned = pinned;
 	}

 	/**
 	 * Persist the local state.
 	 *
 	 * @param part The part to which this instance is connected.
 	 */
 	@PersistState
 	public void persistState(MPart part) {
 		Map<String, String> state = part.getPersistedState();
 		state.put(LAST_SELECTED_STATE, lastSelected.toString());
 	}

 }
	/*********************************************************************************
	* Copyright (c) 2020-2021 Robert Bosch GmbH and others.
	*
	* This program and the accompanying materials are made
	* available under the terms of the Eclipse Public License 2.0
	* which is available at https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* Robert Bosch GmbH - initial API and implementation
	********************************************************************************
	*/

	package org.eclipse.app4mc.visualization.ui;

	import java.util.ArrayList;
	import java.util.Collections;
	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 javax.inject.Named;

	import org.apache.commons.lang.ClassUtils;
	import org.eclipse.app4mc.visualization.ui.registry.ModelVisualization;
	import org.eclipse.app4mc.visualization.ui.registry.ModelVisualizationRegistry;
	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.core.di.extensions.Service;
	import org.eclipse.e4.ui.di.PersistState;
	import org.eclipse.e4.ui.model.application.ui.basic.MPart;
	import org.eclipse.e4.ui.model.application.ui.menu.MDirectToolItem;
	import org.eclipse.e4.ui.model.application.ui.menu.MToolBarElement;
	import org.eclipse.e4.ui.services.IServiceConstants;
	import org.eclipse.emf.common.notify.Adapter;
	import org.eclipse.emf.common.notify.Notification;
	import org.eclipse.emf.common.notify.impl.AdapterImpl;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.jface.viewers.ISelection;
	import org.eclipse.jface.viewers.TreeSelection;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.layout.FillLayout;
	import org.eclipse.swt.widgets.Composite;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.Label;

	@SuppressWarnings("restriction")
	public class VisualizationPart {

	/**
	* The ID that is used in the model fragment for this part.
	*/
	public static final String ID = "org.eclipse.app4mc.visualization.ui.partdescriptor.app4mcvisualizations";

	private static final String LAST_SELECTED_STATE = "LAST_SELECTED";

	@Inject
	@Service
	ModelVisualizationRegistry registry;

	/**
	* The {@link IEclipseContext} of this part.
	*/
	@Inject
	IEclipseContext partContext;

	/**
	* The parent {@link Composite} of this part.
	*/
	Composite parentComposite;

	/**
	* The {@link Composite} on which the visualization is rendered.
	*/
	Composite visualizationComposite;

	/**
	* The model type that should be visualized.
	*/
	List<Class<?>> activeTypes;

	/**
	* The model elements that are used for the visualization.
	*/
	List<?> activeModelElements;

	/**
	* The current active rendered visualization.
	*/
	ModelVisualization activeVisualization;

	/**
	* The list of all available visualizations available for the current {@link #activeType}.
	*/
	List<ModelVisualization> availableModelVisualizations;

	/**
	* The {@link IEclipseContext} that is created for the visualization rendering.
	*/
	IEclipseContext activeContext;

	/**
	* <code>true</code> if the selection listener is disabled, <code>false</code>
	* if the visualization is updated on selection changes.
	*/
	boolean pinned = false;

	/**
	* Mapping of model type to visualization id to remember the last selected visualization.
	*/
	HashMap<String, String> lastSelected = new HashMap<>();

	private boolean adapterEnabled = true;
	/**
	* EMF Adapter to reload the visualization on model property changes.
	*/
	Adapter updateViewAdapter = new AdapterImpl() {

	@Override
	public void notifyChanged(Notification msg) {
	if (adapterEnabled && activeVisualization != null) {
	showVisualization(activeVisualization.getId());
	}
	}
	};

	@PostConstruct
	public void postConstruct(Composite parent, MPart part,
	@Optional @Named(IServiceConstants.ACTIVE_SELECTION) ISelection selection) {
	parentComposite = parent;
	parentComposite.setLayout(new FillLayout());
	parentComposite.setBackground(Display.getDefault().getSystemColor(SWT.COLOR_WHITE));

	if (visualizationComposite == null) {
	visualizationComposite = new Composite(parent, SWT.NONE);
	visualizationComposite.setLayout(new FillLayout());
	if (selection != null) {
	handleSelection(selection);
	} else {
	showEmpty(visualizationComposite);
	}
	}

	// load previous selected states
	Map<String, String> state = part.getPersistedState();

	String lastSelectedString = state.get(LAST_SELECTED_STATE);
	if (lastSelectedString != null) {
	lastSelectedString = lastSelectedString.substring(1, lastSelectedString.length() - 1);
	String[] keyValues = lastSelectedString.split(",");
	for (String entry : keyValues) {
	String[] keyValue = entry.split("=");
	if (keyValue.length == 2) {
	lastSelected.put(keyValue[0], keyValue[1]);
	}
	}
	}

	// ensure the checked state of the pin tool item is reset
	for (MToolBarElement element : part.getToolbar().getChildren()) {
	if (element.getElementId().equals("org.eclipse.app4mc.visualization.ui.directtoolitem.pin")) {
	MDirectToolItem toolItem = (MDirectToolItem) element;
	toolItem.setSelected(pinned);
	}
	}
	}

	/**
	* Disposes a current visualization and renders the visualization for the
	* current active model element.
	*
	* @param visualizationId The ID of the visualization to show. Can be
	* <code>null</code> which results in showing the first
	* available visualization.
	*/
	public void showVisualization(String visualizationId) {
	showVisualization(visualizationId, false);
	}

	/**
	* Disposes a current visualization and renders the visualization for the
	* current active model element.
	*
	* @param visualizationId The ID of the visualization to show. Can be
	* <code>null</code> which results in showing the first
	* available visualization.
	* @param reload <code>true</code> if this method is called to reload a
	* visualization, <code>false</code> if a new
	* visualization should be opened.
	*/
	public void showVisualization(String visualizationId, boolean reload) {
	if (parentComposite == null \|\| (!reload && isPinned())) {
	return;
	}

	// clear any current active visualization
	if (visualizationComposite != null) {
	if (activeContext != null && activeVisualization != null) {
	ContextInjectionFactory.invoke(activeVisualization, PreDestroy.class, activeContext, null);
	activeContext.dispose();
	}
	visualizationComposite.dispose();
	}

	// create a new Composite as parent for the visualization
	visualizationComposite = new Composite(parentComposite, SWT.NONE);
	visualizationComposite.setLayout(new FillLayout());

	// find the visualization for the current active model type and the given id
	availableModelVisualizations = registry.getVisualizations(activeTypes);
	if (!availableModelVisualizations.isEmpty()) {

	if (visualizationId != null) {
	activeVisualization = availableModelVisualizations.stream()
	.filter(mv -> mv.getId().equals(visualizationId))
	.findFirst()
	.orElse(null);

	// only handle if there is a visualization for the given id
	if (activeVisualization != null) {
	lastSelected.put(activeTypes.get(0).getName(), visualizationId); // ???
	} else {
	// take the first returned available visualization
	activeVisualization = availableModelVisualizations.get(0);
	}
	} else {
	// take the first returned available visualization
	activeVisualization = availableModelVisualizations.get(0);
	}

	if (activeVisualization != null) {
	activeContext = partContext.createChild(activeTypes.get(0) + " Visualization"); // ???
	activeContext.set(Composite.class, visualizationComposite);

	activeContext.set(activeVisualization.getType(), activeModelElements.get(0));
	activeContext.set(List.class, activeModelElements);

	ContextInjectionFactory.invoke(activeVisualization.getVisualization(), PostConstruct.class, activeContext);
	parentComposite.layout(true);
	} else {
	showEmpty(visualizationComposite);
	}
	} else {
	showEmpty(visualizationComposite);
	}
	}

	@Inject
	@Optional
	void handleSelection(@Named(IServiceConstants.ACTIVE_SELECTION) ISelection selection) {
	if (!pinned) {

	// ensure that we are able to remove the adapter from a previous selection
	EObject previous = null;
	if (activeModelElements != null
	&& activeModelElements.size() == 1
	&& activeModelElements.get(0) instanceof EObject) {
	previous = (EObject) activeModelElements.get(0);
	}

	if (selection instanceof TreeSelection && !selection.isEmpty()) {
	TreeSelection s = (TreeSelection) selection;

	activeModelElements = s.toList();

	activeTypes = getNearestCommonTypes(activeModelElements);

	availableModelVisualizations = null;

	// remove the adapter from a previous selection
	if (previous != null) {
	adapterEnabled = false;
	previous.eAdapters().remove(updateViewAdapter);
	}

	if (!activeTypes.isEmpty() && activeModelElements.size() == 1
	&& activeModelElements.get(0) instanceof EObject) {
	((EObject) activeModelElements.get(0)).eAdapters().add(updateViewAdapter);
	adapterEnabled = true;
	}

	// check if there is a default visualization already configured
	showVisualization(!activeTypes.isEmpty() ? lastSelected.get(activeTypes.get(0).getName()) : null); // ???
	}
	}
	}

	private List<Class<?>> getNearestCommonTypes(List<?> modelElements) {
	if (modelElements.isEmpty()) {
	return Collections.emptyList();
	}

	// get type candidate
	Class<? extends Object> class1 = modelElements.get(0).getClass();
	Class<?>[] interfaces = class1.getInterfaces();
	final Class<?> typeCandidate = interfaces.length > 0 ? interfaces[0] : class1;

	// one model element
	if (modelElements.size() == 1) {
	return Collections.singletonList(typeCandidate);
	}

	// multiple model elements

	boolean sameModelType = modelElements.stream().allMatch(element -> {
	Class<? extends Object> elementClass = element.getClass();
	Class<?>[] elementInterfaces = elementClass.getInterfaces();
	return elementInterfaces.length > 0 && elementInterfaces[0].equals(typeCandidate);
	});

	// all elements are of the same type
	if (sameModelType) {
	return Collections.singletonList(typeCandidate);
	}

	// compute common interfaces

	// for class1:
	// - compute all interfaces
	// - keep interfaces in the same package
	// - keep EObject as common super interface
	@SuppressWarnings("unchecked")
	List<Class<?>> allInterfaces = ClassUtils.getAllInterfaces(class1);
	final String name = class1.getPackage().getName();
	final String prefix = (name.endsWith(".impl")) ? name.substring(0, name.length() - 5) : name;
	allInterfaces.removeIf( i -> ! (i.equals(EObject.class) \|\| i.getPackage().getName().startsWith(prefix)) );
	// compute intersection with interfaces of other model elements
	for (int i = 1; i < modelElements.size(); i++) {
	allInterfaces.retainAll(ClassUtils.getAllInterfaces(modelElements.get(i).getClass()));
	}
	// remove super interfaces
	List<Class<?>> commonInterfaces = new ArrayList<>();
	for (Class<?> tmpInterface : allInterfaces) {
	List<Class<?>> otherInterfaces = new ArrayList<>(allInterfaces);
	otherInterfaces.remove(tmpInterface);
	if (otherInterfaces.stream().noneMatch(other -> tmpInterface.isAssignableFrom(other))) {
	commonInterfaces.add(tmpInterface);
	}
	}

	return commonInterfaces;
	}

	/**
	*
	* @param parent The parent {@link Composite}, should be the {@link #visualizationComposite}.
	*/
	private void showEmpty(Composite parent) {
	Label label = new Label(parent, SWT.NONE);
	if (hasActiveModelElement()) {
	StringBuilder sb = new StringBuilder("There is no visualization available for the active selection.");
	if (activeTypes.isEmpty()) {
	sb.append("\n\n - no common types detected - ");
	} else {
	sb.append("\n\ndetected ");
	sb.append((activeModelElements.size() == 1) ? "" : "common " );
	sb.append((activeTypes.size() == 1) ? "type:" : "types:" );
	activeTypes.forEach(t -> sb.append("\n - " + t.getSimpleName()));
	}
	label.setText(sb.toString());
	} else {
	label.setText("There is no active selection.");
	}
	parent.getParent().layout(true);
	}

	@PreDestroy
	public void preDestroy() {
	if (visualizationComposite != null) {
	visualizationComposite.dispose();
	}
	if (activeContext != null) {
	activeContext.dispose();
	}
	}

	/**
	*
	* @return The model type that should be visualized.
	*/
	public List<Class<?>> getActiveModelTypes() {
	return activeTypes;
	}

	/**
	*
	* @return The model elements that are used for the visualization.
	*/
	public List<?> getActiveModelElements() {
	return activeModelElements;
	}

	/**
	*
	* @return <code>true</code> if an active model element is set,
	* <code>false</code> if no active model element is available.
	*/
	public boolean hasActiveModelElement() {
	return activeModelElements != null && !activeModelElements.isEmpty();
	}

	/**
	*
	* @return The current active rendered visualization.
	*/
	public ModelVisualization getActiveVisualization() {
	return activeVisualization;
	}

	/**
	*
	* @return The list of all available visualizations available for the current
	* {@link #activeType}.
	*/
	public List<ModelVisualization> getAvailableModelVisualizations() {
	return availableModelVisualizations != null ? availableModelVisualizations : Collections.emptyList();
	}

	/**
	*
	* @return <code>true</code> if the selection listener is disabled,
	* <code>false</code> if the visualization is updated on
	* selection changes.
	*/
	public boolean isPinned() {
	return pinned;
	}

	/**
	*
	* @param pinned <code>true</code> if the selection listener should be disabled,
	* <code>false</code> if the visualization should be updated on
	* selection changes.
	*/
	public void setPinned(boolean pinned) {
	this.pinned = pinned;
	}

	/**
	* Persist the local state.
	*
	* @param part The part to which this instance is connected.
	*/
	@PersistState
	public void persistState(MPart part) {
	Map<String, String> state = part.getPersistedState();
	state.put(LAST_SELECTED_STATE, lastSelected.toString());
	}

	}