/*******************************************************************************
 * Copyright (c) 2008, 2015 Mia-Software and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *    Nicolas Bros (Mia-Software) - initial API and implementation
 *    Nicolas Payneau (Mia-Software) - Enable editability
 *    Nicolas Guyomar (Mia-Software) - Code Synchronization
 *    Nicolas Guyomar (Mia_software) - Bug 333651 Remove of the MoDisco EPackage view and of the metamodel browsing button
 *    Gregoire Dupe (Mia-Software) - Bug 404263 - EditingDomainProvider does not work when using IResourceEditorInput
 *    Grégoire Dupé (Mia-Software) - Bug 471096 - MetaclassInstance features have to be moved to an EMF dedicated plug-in
 *    Gregoire Dupe (Mia-Software) - Bug 472182 - Missing debug information in EcoreBrowser.handleChangedResources(2636)
 *******************************************************************************/
package org.eclipse.modisco.infra.browser.editors;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.EventObject;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CancellationException;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.emf.common.command.BasicCommandStack;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CommandStack;
import org.eclipse.emf.common.command.CommandStackListener;
import org.eclipse.emf.common.command.CommandWrapper;
import org.eclipse.emf.common.command.CompoundCommand;
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.common.ui.MarkerHelper;
import org.eclipse.emf.common.ui.viewer.IViewerProvider;
import org.eclipse.emf.common.util.BasicDiagnostic;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.TreeIterator;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.EValidator;
import org.eclipse.emf.ecore.plugin.EcorePlugin;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.util.EContentAdapter;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.edit.command.AddCommand;
import org.eclipse.emf.edit.command.CreateChildCommand;
import org.eclipse.emf.edit.command.DeleteCommand;
import org.eclipse.emf.edit.command.RemoveCommand;
import org.eclipse.emf.edit.command.SetCommand;
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.domain.IEditingDomainProvider;
import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
import org.eclipse.emf.edit.provider.IItemPropertySource;
import org.eclipse.emf.edit.provider.ReflectiveItemProviderAdapterFactory;
import org.eclipse.emf.edit.provider.resource.ResourceItemProviderAdapterFactory;
import org.eclipse.emf.edit.ui.dnd.EditingDomainViewerDropAdapter;
import org.eclipse.emf.edit.ui.dnd.LocalTransfer;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
import org.eclipse.emf.edit.ui.provider.PropertyDescriptor;
import org.eclipse.emf.edit.ui.provider.PropertySource;
import org.eclipse.emf.edit.ui.util.EditUIMarkerHelper;
import org.eclipse.emf.edit.ui.util.EditUIUtil;
import org.eclipse.emf.edit.ui.view.ExtendedPropertySheetPage;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.FontDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.ITreeSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.TreePath;
import org.eclipse.jface.viewers.TreeSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.modisco.facet.util.core.Logger;
import org.eclipse.modisco.infra.browser.Messages;
import org.eclipse.modisco.infra.browser.MoDiscoBrowserPlugin;
import org.eclipse.modisco.infra.browser.actions.LoadFacetsAction;
import org.eclipse.modisco.infra.browser.core.DragAndDropOnLinkCommand;
import org.eclipse.modisco.infra.browser.core.DragAndDropOnModelElementCommand;
import org.eclipse.modisco.infra.browser.core.InstancesForMetaclass;
import org.eclipse.modisco.infra.browser.core.InstancesForMetaclasses;
import org.eclipse.modisco.infra.browser.core.MetaclassList;
import org.eclipse.modisco.infra.browser.core.ModelElementItemEx;
import org.eclipse.modisco.infra.browser.core.QueryItem;
import org.eclipse.modisco.infra.browser.core.SearchResults;
import org.eclipse.modisco.infra.browser.core.InstancesForMetaclasses.MetaclassesChangeListener;
import org.eclipse.modisco.infra.browser.custom.MetamodelView;
import org.eclipse.modisco.infra.browser.custom.core.CustomizationsCatalog;
import org.eclipse.modisco.infra.browser.dialogs.ErrorsDialog;
import org.eclipse.modisco.infra.browser.extensions.LoadingDepthRegistry;
import org.eclipse.modisco.infra.browser.extensions.listeners.DoubleClickListener;
import org.eclipse.modisco.infra.browser.preferences.PreferenceConstants;
import org.eclipse.modisco.infra.browser.queries.SelectedQueriesManager;
import org.eclipse.modisco.infra.browser.queries.SelectedQuery;
import org.eclipse.modisco.infra.browser.uicore.ChangeListener;
import org.eclipse.modisco.infra.browser.uicore.UnwrappingSelectionProvider;
import org.eclipse.modisco.infra.browser.uicore.internal.Activator;
import org.eclipse.modisco.infra.browser.uicore.internal.AppearanceConfiguration;
import org.eclipse.modisco.infra.browser.uicore.internal.CustomTreePainter;
import org.eclipse.modisco.infra.browser.uicore.internal.customization.CustomizationEngine;
import org.eclipse.modisco.infra.browser.uicore.internal.model.AttributeItem;
import org.eclipse.modisco.infra.browser.uicore.internal.model.BigListItem;
import org.eclipse.modisco.infra.browser.uicore.internal.model.ITreeElement;
import org.eclipse.modisco.infra.browser.uicore.internal.model.LinkItem;
import org.eclipse.modisco.infra.browser.uicore.internal.model.ModelElementItem;
import org.eclipse.modisco.infra.browser.uicore.internal.util.EMFUtil;
import org.eclipse.modisco.infra.browser.uicore.internal.util.ImageProvider;
import org.eclipse.modisco.infra.common.core.internal.builder.AbstractMoDiscoCatalog.ModiscoCatalogChangeListener;
import org.eclipse.modisco.infra.common.core.logging.MoDiscoLogger;
import org.eclipse.modisco.infra.common.ui.internal.controls.FormStyleSashForm;
import org.eclipse.modisco.infra.common.ui.internal.controls.Tooltip;
import org.eclipse.modisco.infra.common.ui.internal.editorInputs.IResourceEditorInput;
import org.eclipse.modisco.infra.common.ui.internal.util.DialogUtils;
import org.eclipse.modisco.infra.facet.Facet;
import org.eclipse.modisco.infra.facet.FacetSet;
import org.eclipse.modisco.infra.facet.core.FacetSetCatalog;
import org.eclipse.modisco.infra.facet.core.adapters.instances.MetaclassInstancesAdapterFactoryWithFacet;
import org.eclipse.modisco.infra.facet.core.adapters.instances.MetaclassInstancesAdapterWithFacet;
import org.eclipse.modisco.util.emf.core.internal.allinstances.MetaclassInstances;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.INavigationLocation;
import org.eclipse.ui.INavigationLocationProvider;
import org.eclipse.ui.IPartListener;
import org.eclipse.ui.IStorageEditorInput;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.WorkspaceModifyOperation;
import org.eclipse.ui.contexts.IContextActivation;
import org.eclipse.ui.contexts.IContextService;
import org.eclipse.ui.dialogs.SaveAsDialog;
import org.eclipse.ui.forms.widgets.ExpandableComposite;
import org.eclipse.ui.forms.widgets.Form;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.Section;
import org.eclipse.ui.ide.IGotoMarker;
import org.eclipse.ui.part.EditorPart;
import org.eclipse.ui.part.FileEditorInput;
import org.eclipse.ui.progress.IWorkbenchSiteProgressService;
import org.eclipse.ui.views.properties.IPropertyDescriptor;
import org.eclipse.ui.views.properties.IPropertySheetPage;
import org.eclipse.ui.views.properties.IPropertySource;
import org.eclipse.ui.views.properties.PropertySheet;
import org.eclipse.ui.views.properties.PropertySheetPage;
import org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetPage;

/**
 * MoDisco model editor: a two pane editor. The left pane shows the list of
 * metaclasses and the right pane shows the list of instances of the metaclass
 * selected in the left pane.
 * <p>
 * The following pop-up menus can be contributed to this part:
 * <ul>
 * <li>{@link EcoreBrowser#MENU_ID}
 * <li>{@link MetaclassViewer#MENU_ID}
 * </ul>
 */
public class EcoreBrowser extends EditorPart implements ISelectionProvider, IMenuListener,
		IViewerProvider, INavigationLocationProvider, MetaclassesChangeListener,
		IEditingDomainProvider, IGotoMarker {

	public static final String MENU_ID = EcoreBrowser.EDITOR_ID + ".menu"; //$NON-NLS-1$

	private static final int MAIN_FORM_MARGIN_HEIGHT = 6;
	private static final int MAIN_FORM_MARGIN_WIDTH = 4;
	private static final int RIGHT_PANE_SASH_WEIGHT = 65;
	private static final int LEFT_PANE_SASH_WEIGHT = 35;
	private static final int SASH_WIDTH = 4;
	public static final String EDITOR_ID = "org.eclipse.modisco.infra.browser.editorID"; //$NON-NLS-1$
	private static final String PROPERTY_VIEW_ID = "org.eclipse.ui.views.PropertySheet"; //$NON-NLS-1$

	private ResourceSet fResourceSet;

	private Resource model;

	/** An adapter factory that uses the registry */
	private ComposedAdapterFactory adapterFactoryWithRegistry;

	/** The property sheet page. */
	private IPropertySheetPage propertySheetPage;

	/** The tree part of the model editor. */
	private TreeViewer treeViewer;

	private BrowserContentProvider fContentProvider;
	private BrowserLabelProvider fLabelProvider;

	/** The tree component (instances pane) */
	private Tree fTree;

	/** The list of metaclasses that appears in the left pane of the editor */
	private MetaclassViewer metaclassViewer;

	/** This listens to the tree viewer's selection. */
	private ISelectionChangedListener selectionChangedListener;

	/**
	 * This keeps track of all the
	 * {@link org.eclipse.jface.viewers.ISelectionChangedListener}s that are
	 * listening to this editor.
	 */
	private final Collection<ISelectionChangedListener> selectionChangedListeners = new ArrayList<ISelectionChangedListener>();

	/** This keeps track of the selection of the editor as a whole. */
	private ISelection editorSelection = StructuredSelection.EMPTY;

	/**
	 * Resources that have been removed since last activation.
	 */
	private final Collection<Resource> removedResources = new ArrayList<Resource>();

	/**
	 * Resources that have been changed since last activation.
	 */
	private final Collection<Resource> changedResources = new ArrayList<Resource>();

	private final Collection<Resource> savedResources = new ArrayList<Resource>();

	/** This listens for workspace changes. */
	private final IResourceChangeListener resourceChangeListener;

	private Job openModelJob = null;

	/**
	 * Controls whether the problem indication should be updated.
	 */
	private boolean updateProblemIndication = true;

	/**
	 * Map to store the diagnostic associated with a resource.
	 */
	private final Map<Resource, Diagnostic> resourceToDiagnosticMap = new LinkedHashMap<Resource, Diagnostic>();

	/**
	 * The MarkerHelper is responsible for creating workspace resource markers
	 * presented in Eclipse's Problems View.
	 */
	private final MarkerHelper markerHelper = new EditUIMarkerHelper();

	/** Whether the Browser has finished loading */
	private boolean loaded = false;

	/** List of actions that must be done once the browser is loaded */
	private final List<Runnable> doWhenLoaded = new ArrayList<Runnable>();

	private Collection<EPackage> referencedEPackages = null;

	private Composite typesPaneComposite;

	private Composite instancesPaneComposite;

	private Button errorsButton;

	/**
	 * This keeps track of the editing domain that is used to track all changes
	 * to the model.
	 */
	private AdapterFactoryEditingDomain editingDomain;
	/**
	 * The configuration of this editor, which is passed to the adapters, so
	 * that they can use it to change their behavior accordingly
	 */
	private final BrowserConfiguration browserConfiguration;

	/** The composite in which the editor is displayed */
	private Composite parentComposite;

	/** The search box */
	private Text searchBox;

	/** The search job, to allow cancellation in case of a big model */
	private Job searchJob = null;

	/**
	 * The input of the tree viewer, saved before filtering by search, and
	 * restored afterwards
	 */
	private Object savedInput;

	/** A listener on changes to fonts settings */
	private IPropertyChangeListener fontChangeListener;

	/** Listens to changes in the loaded customizations, and updates the viewers */
	private ChangeListener fCustomizationEngineChangeListener = null;

	/** Listens to changes in the Facet catalog, and updates the viewers */
	private ModiscoCatalogChangeListener fFacetsChangeListener = null;

	/** Allows optimized refreshes of the viewer */
	private Job refreshJob = null;

	private FormStyleSashForm sashForm;
	// Initialize to HORIZONTAL representation
	private int styleSashForm = SWT.HORIZONTAL;
	private CustomTreePainter customTreePainter;

	private FormToolkit fFormToolkit;
	private Form form;
	private LeftPane leftPane;
	private TreeToolBar instancesToolBar;

	private BrowserSettingsPersistence settingsPersistence;

	/** Indicates the editor is being disposed */
	private boolean disposing = false;

	private BasicDiagnostic fDiagnostic;

	/**
	 * This listens for when the Properties view becomes active
	 */
	private final IPartListener partListener = new IPartListener() {
		public void partActivated(final IWorkbenchPart p) {
			if (p instanceof PropertySheet) {
				if (((PropertySheet) p).getCurrentPage() == EcoreBrowser.this
						.getPropertySheetPage()) {
					getActionBarContributor().setActiveEditor(EcoreBrowser.this);
					handleActivate();
				}
			} else if (p == EcoreBrowser.this) {
				handleActivate();
			}
		}

		public void partBroughtToTop(final IWorkbenchPart p) {
			// Ignore.
		}

		public void partClosed(final IWorkbenchPart p) {
			// Ignore.
		}

		public void partDeactivated(final IWorkbenchPart p) {
			// Ignore.
		}

		public void partOpened(final IWorkbenchPart p) {
			// Ignore.
		}
	};

	/** Create the Mia Ecore model editor. */
	public EcoreBrowser() {
		super();
		this.browserConfiguration = new BrowserConfiguration(this);

		// load user settings
		this.browserConfiguration.getAppearanceConfiguration().load();

		this.resourceChangeListener = new WorkspaceChangeListener(this);
	}

	/** Set the selection into the tree viewer */
	public void setSelectionToViewer(final Collection<?> selection) {
		final Collection<?> theSelection = selection;

		if (theSelection != null && !theSelection.isEmpty()) {
			Runnable runnable = new Runnable() {
				public void run() {
					if (EcoreBrowser.this.treeViewer != null) {
						EcoreBrowser.this.treeViewer.setSelection(new StructuredSelection(
								theSelection.toArray()), true);
					}
				}
			};
			getSite().getShell().getDisplay().asyncExec(runnable);
		}
	}

	/** @return the viewer as required by the {@link IViewerProvider} interface. */
	public Viewer getViewer() {
		return this.treeViewer;
	}

	public MetaclassViewer getMetaclassViewer() {
		return this.metaclassViewer;
	}

	/**
	 * Create a context menu for the viewer, add a listener, and register the
	 * menu for extension.
	 */
	protected void createContextMenuFor(final StructuredViewer viewer) {
		final MenuManager contextMenu = new MenuManager("#PopUp"); //$NON-NLS-1$
		contextMenu.setRemoveAllWhenShown(true);
		contextMenu.addMenuListener(this);
		final Menu menu = contextMenu.createContextMenu(viewer.getControl());
		viewer.getControl().setMenu(menu);
		getSite().registerContextMenu(EcoreBrowser.MENU_ID, contextMenu,
				new UnwrappingSelectionProvider(viewer));
	}

	/** Load a resource based on the editor's input. */
	protected Resource createModel() {
		Resource result = null;
		Exception exception = null;
		// this.fResourceSet.setURIConverter(createURIConverter());
		this.fResourceSet.getURIConverter().getURIMap().putAll(EcorePlugin.computePlatformURIMap());
		final URI resourceURI = EditUIUtil.getURI(getEditorInput());
		try {
			final IEditorInput editorInput = getEditorInput();
			if (editorInput instanceof FileEditorInput) {
				// Load the resource
				ResourceSet resourceSet = this.editingDomain.getResourceSet();
				synchronized (resourceSet) {
					result = resourceSet.getResource(resourceURI, true);
				}
				this.fResourceSet = this.editingDomain.getResourceSet();
			} else if (editorInput instanceof IResourceEditorInput) {
				IResourceEditorInput resourceEditorInput = (IResourceEditorInput) editorInput;
				result = resourceEditorInput.getResource();
				// this.fResourceSet.getResources().add(result);
				ResourceSet resourceSet = result.getResourceSet();
				if (resourceSet != null) {
					this.fResourceSet = resourceSet;
				}
				setPartName(resourceEditorInput.getName());
			} else if (editorInput instanceof IStorageEditorInput) {
				IStorageEditorInput storageEditorInput = (IStorageEditorInput) editorInput;
				IStorage storage = storageEditorInput.getStorage();
				InputStream inputStream = storage.getContents();
				Resource resource = this.fResourceSet.createResource(URI.createURI(resourceURI
						.toString()));
				resource.load(inputStream, Collections.emptyMap());
				result = resource;
			} else {
				final String resolveURI = resourceURI.toString();
				final EPackage ePackage = this.fResourceSet.getPackageRegistry().getEPackage(
						resolveURI);
				if (ePackage != null) {
					result = ePackage.eResource();
					if (result != null) {
						this.fResourceSet.getResources().add(result);
						setPartName(ePackage.getName());
					}
				} else {
					Display.getDefault().asyncExec(new Runnable() {
						public void run() {
							MessageDialog.openWarning(getSite().getShell(),
									Messages.EcoreBrowser_cannotOpenModelFromURI, NLS.bind(
											Messages.EcoreBrowser_cannotFindEPackageWithThatURI,
											resolveURI));
						}
					});
				}
			}
			initializeEditingDomain(this.fResourceSet);
		} catch (final Exception e) {
			exception = e;
			MoDiscoBrowserPlugin.logException(e);
			Display.getDefault().asyncExec(new Runnable() {
				public void run() {
					MessageDialog.openError(EcoreBrowser.this.parentComposite.getShell(),
							Messages.EcoreBrowser_errorLoadingModel, e.toString());
				}
			});
			this.fResourceSet.getResource(resourceURI, false);
		}
		this.fResourceSet.setURIConverter(BrowserUtils.createURIConverter());

		// look for errors in the Resource
		if (result != null) {
			Diagnostic diagnostic = analyzeResourceProblems(result, exception);
			if (diagnostic.getSeverity() != Diagnostic.OK) {
				this.resourceToDiagnosticMap.put(result, diagnostic);
			}
		}

		this.editingDomain.getResourceSet().eAdapters().add(this.problemIndicationAdapter);

		return result;
	}

	@Override
	protected void setPartName(final String partName) {
		Display.getDefault().syncExec(new Runnable() {
			public void run() {
				EcoreBrowser.super.setPartName(partName);
			}
		});
	}

	protected static final String LOADING_MESSAGE = Messages.EcoreBrowser_loadingModelPlaceholder;

	public static final String HUMAN_READABLE_NAME = Messages.EcoreBrowser_MoDisco_Model_Browser;

	/** Create the editor composite. */
	@Override
	public void createPartControl(final Composite parent) {

		this.fFormToolkit = new FormToolkit(parent.getDisplay());
		this.form = this.fFormToolkit.createForm(parent);

		this.parentComposite = parent;
		parent.setLayout(new FillLayout());

		initializeEditingDomain();

		final FillLayout fillLayout = new FillLayout();
		fillLayout.marginWidth = EcoreBrowser.MAIN_FORM_MARGIN_WIDTH;
		fillLayout.marginHeight = EcoreBrowser.MAIN_FORM_MARGIN_HEIGHT;
		this.form.getBody().setLayout(fillLayout);

		// use an adapter factory that looks in the registry
		this.browserConfiguration.getAppearanceConfiguration().setAdapterFactory(
				this.adapterFactoryWithRegistry);

		this.browserConfiguration.setSelectedQueriesManager(new SelectedQueriesManager());
		this.sashForm = new FormStyleSashForm(this.form.getBody(), this.styleSashForm,
				this.fFormToolkit) {
			@Override
			protected void createContents() {
				createLeftPane(this);
				createTreePane(this);
			}
		};
		this.sashForm.setSashWidth(EcoreBrowser.SASH_WIDTH);

		setupInitialTreeFont();

		this.sashForm.setWeights(new int[] { EcoreBrowser.LEFT_PANE_SASH_WEIGHT,
				EcoreBrowser.RIGHT_PANE_SASH_WEIGHT });

		// keep track of the selection, to be able to restore it when using the
		// "back" button
		addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(final SelectionChangedEvent event) {
				markNavigationLocation();
			}
		});

		createContextMenuFor(this.treeViewer);
		DragAdapter.create(this.treeViewer);

		int dndOperations = DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK;
		Transfer[] transfers = new Transfer[] { LocalTransfer.getInstance() };
		EditingDomainViewerDropAdapter editingDomainViewerDropAdapter = new EditingDomainViewerDropAdapter(
				this.editingDomain, this.treeViewer);
		this.treeViewer.addDropSupport(dndOperations, transfers, editingDomainViewerDropAdapter);

		getMetaclassViewer().setInput(EcoreBrowser.LOADING_MESSAGE);
		this.treeViewer.setInput(EcoreBrowser.LOADING_MESSAGE);

		createAttributeItemTooltip();
	}

	private void createAttributeItemTooltip() {
		Tooltip tooltip = new Tooltip() {
			@Override
			protected String getText(final TreeItem item) {
				Object data = item.getData();
				if (data instanceof AttributeItem) {
					AttributeItem attributeItem = (AttributeItem) data;
					if (!attributeItem.getText().contains(attributeItem.getValueText())) {
						return attributeItem.getValueText();
					}
				}
				return null;
			}

			@Override
			protected void positionTooltip(final TreeItem treeItem, final Point pt,
					final Point tooltipSize) {
				Point point = EcoreBrowser.this.treeViewer.getTree().toDisplay(
						treeItem.getBounds().x, treeItem.getBounds().y);
				pt.x = point.x;
				pt.y = point.y;
			}
		};
		tooltip.installOn(this.treeViewer.getTree());
	}

	/**
	 * Load the model in the background, to avoid freezing the UI during this
	 * long-running operation.
	 * <p>
	 * <b>see</b>: Bug 325120 - [Model Browser] don't freeze UI while loading
	 * model
	 *
	 * @param monitor
	 */
	protected boolean backgroundOpenModel(final IProgressMonitor monitor) {
		try {
			checkCancelled(monitor);
			initResourceSet();
			checkCancelled(monitor);
			checkResourceSet();

			if (this.model == null) {
				return false;
			}

			Display.getDefault().syncExec(new Runnable() {
				public void run() {
					getMetaclassViewer().setInput(
							getBrowserConfiguration().getInstancesForMetaclasses());
					/*
					 * Select the metaclass corresponding to the 'root' element
					 * (that is, the 'model' element). This in turn sets the
					 * input of the treeview.
					 */
					getMetaclassViewer().selectRootElement();
				}
			});

			loadDefaultFacetSets(this.model);

			IDialogSettings settingsForCurrentMetamodel = getSettingsPersistence()
					.loadLastSettingsForCurrentMetamodel();

			List<Facet> lastFacets = getSettingsPersistence().getLastFacets(
					settingsForCurrentMetamodel);

			LoadFacetsAction.loadFacets(lastFacets, this);
			// for (Facet facet : lastFacets) {
			// this.browserConfiguration.getAppearanceConfiguration().loadFacet(facet);
			// checkCancelled(monitor);
			// }

			checkCancelled(monitor);
			List<MetamodelView> lastCustomizations = getSettingsPersistence()
					.getLastCustomizations(settingsForCurrentMetamodel);
			if (lastCustomizations.size() > 0) {
				loadCustomizations(lastCustomizations);
			} else {
				loadDefaultCustomizations();
			}

			checkCancelled(monitor);

			// note: must be done after adding or removing facets too
			this.browserConfiguration.getInstancesForMetaclasses().buildDerivationTree();

			// add a listener to reload when Facets are modified
			reloadOnFacetChange();

			checkCancelled(monitor);
		} catch (CancellationException e) {
			// canceled : nothing more to do
			return false;
		} catch (ThreadDeath e) {
			// canceled : nothing more to do
			return false;
		}
		finishedLoading();
		return true;
	}

	private void checkResourceSet() {
		for (Resource resource : this.fResourceSet.getResources()) {
			if (resource.getURI() == null) {
				MoDiscoLogger.logError(
						"The ResourceSet opened in the browser contains a Resource with a null URI. " //$NON-NLS-1$
								+ "This can be the cause of NullPointerExceptions.", //$NON-NLS-1$
						MoDiscoBrowserPlugin.getPlugin());
			}
		}
	}

	private void finishedLoading() {
		for (Runnable runnable : this.doWhenLoaded) {
			try {
				Display.getDefault().syncExec(runnable);
			} catch (Exception e) {
				MoDiscoLogger.logError(e, Activator.getDefault());
			}
		}
		this.getSite().getShell().getDisplay().asyncExec(new Runnable() {
			public void run() {
				firePropertyChange(PROP_INPUT);
			}
		});
	}

	private void checkCancelled(final IProgressMonitor monitor) {
		if (monitor.isCanceled() || this.treeViewer.getTree().isDisposed()) {
			throw new CancellationException();
		}
	}

	public BrowserSettingsPersistence getSettingsPersistence() {
		if (this.settingsPersistence == null) {
			this.settingsPersistence = new BrowserSettingsPersistence(getMetamodelURI(), this,
					this.browserConfiguration);
		}
		return this.settingsPersistence;
	}

	/**
	 * @return the URI of the EPackage corresponding to the EClass of the main
	 *         resource's root element
	 */
	public String getMetamodelURI() {
		if (this.model == null) {
			return ""; //$NON-NLS-1$
		}
		try {
			EList<EObject> contents = this.model.getContents();
			if (contents.size() > 0) {
				EObject eObject = contents.get(0);
				EClass eClass = eObject.eClass();
				if (eClass != null) {
					return eClass.getEPackage().getNsURI();
				}
			}
		} catch (Exception e) {
			MoDiscoLogger.logError(e, MoDiscoBrowserPlugin.getPlugin());
		}
		return ""; //$NON-NLS-1$
	}

	/**
	 * @return {@link EPackage}s of {@link EClass}es from the model's main
	 *         {@link Resource}
	 */
	public Collection<EPackage> getReferencedEPackages() {
		if (this.referencedEPackages != null) {
			return this.referencedEPackages;
		}
		Set<EPackage> ePackages = new HashSet<EPackage>();
		try {
			if (this.model != null) {
				TreeIterator<EObject> allContents = this.model.getAllContents();
				while (allContents.hasNext()) {
					EObject eObject = allContents.next();
					EClass eClass = eObject.eClass();
					if (eClass != null) {
						EPackage ePackage = eClass.getEPackage();
						if (ePackage != null) {
							ePackages.add(ePackage);
						}
					}
				}
			}
		} catch (Exception e) {
			MoDiscoLogger.logError(e, MoDiscoBrowserPlugin.getPlugin());
		}
		this.referencedEPackages = ePackages;
		return ePackages;
	}

	protected void initResourceSet() {
		// create an empty resource set
		this.fResourceSet = createResourceSet();

		HashSet<Resource> browsedResources = new HashSet<Resource>();
		Resource mainResource;
		this.model = createModel();
		mainResource = this.model;
		if (mainResource != null) {
			browsedResources.add(mainResource);
		}
		this.browserConfiguration.setResourceSet(this.fResourceSet);

		addReferencedResources(mainResource, browsedResources);
		this.browserConfiguration.setBrowsedResources(browsedResources);
		this.browserConfiguration.getAppearanceConfiguration().getFacetContext()
				.setResources(browsedResources);

		final InstancesForMetaclasses instancesForMetaclasses = createInstancesForMetaclasses(browsedResources);
		this.browserConfiguration.setInstancesForMetaclasses(instancesForMetaclasses);

		instancesForMetaclasses.addListener(this);

		// see Bug 322985 - resources lazy loading and dynamic type panel
		// completion
		// watch ResourceSet to be notified when a Resource is lazy-loaded
		// when that happens, add its elements to the Types panel
		this.fResourceSet.eAdapters().add(new AdapterImpl() {
			@Override
			public void notifyChanged(final Notification notification) {
				if (notification.getFeatureID(ResourceSet.class) == ResourceSet.RESOURCE_SET__RESOURCES) {
					int eventType = notification.getEventType();
					if (eventType == Notification.ADD) {
						Object newValue = notification.getNewValue();
						if (newValue instanceof Resource) {
							Resource resource = (Resource) newValue;
							EcoreBrowser.this.browserConfiguration.addBrowsedResource(resource);
							instancesForMetaclasses.watchResource(resource);
							EcoreBrowser.this.browserConfiguration.getAppearanceConfiguration()
									.touch();
							refreshDelayed(true);
						}
					}
					if (eventType == Notification.REMOVE) {
						Object oldValue = notification.getOldValue();
						if (oldValue instanceof Resource) {
							Resource resource = (Resource) oldValue;
							EcoreBrowser.this.browserConfiguration.removeBrowsedResource(resource);
							instancesForMetaclasses.unwatchResource(resource);
							EcoreBrowser.this.browserConfiguration.getAppearanceConfiguration()
									.touch();
							refreshDelayed(true);
						}
					}
				}
			}
		});
	}

	protected InstancesForMetaclasses createInstancesForMetaclasses(
			final Set<Resource> browsedResources) {
		return new InstancesForMetaclasses(this.browserConfiguration, browsedResources);
	}

	/**
	 * Create the resourceSet. This method can be overridden by subclasses.
	 *
	 * @return The ResourceSet.
	 */
	protected ResourceSet createResourceSet() {
		return new ResourceSetImpl();
	}

	/**
	 * Load FacetSet defined as default for the root EPackage of root elements
	 * in the given resource
	 */
	private void loadDefaultFacetSets(final Resource resource) {
		synchronized (resource) {
			for (EObject root : resource.getContents()) {
				EPackage rootEPackage = root.eClass().getEPackage();
				Set<FacetSet> defaultFacetSets = FacetSetCatalog.getSingleton()
						.getDefaultFacetSets(rootEPackage);
				if (defaultFacetSets != null) {
					Set<Facet> facetsToLoad = new HashSet<Facet>();
					for (FacetSet facetSet : defaultFacetSets) {
						if (facetSet != null) {
							facetsToLoad.addAll(facetSet.getFacets());
						}
					}
				}
			}
		}
	}

	/**
	 * If proxies are found, ask the user whether to load resources referenced
	 * by proxies found in the given resource, and up to which depth.
	 *
	 * @param resource
	 *            the resource in which to look for proxies to resolve
	 * @param allResources
	 *            the set of resources to which to add resources referenced by
	 *            proxies
	 */
	private void addReferencedResources(final Resource resource, final Set<Resource> allResources) {
		IPreferenceStore preferenceStore = MoDiscoBrowserPlugin.getPlugin().getPreferenceStore();
		// only walk through the resource contents if necessary
		int registryLoadingDepth = LoadingDepthRegistry.getInstance().getLoadingDepth(
				getMetamodelURI());
		if (preferenceStore.getInt(PreferenceConstants.P_BROWSER_LOADING_DEPTH) != 0
				|| preferenceStore.getBoolean(PreferenceConstants.P_BROWSER_ASK_LOADING_DEPTH)
				|| (registryLoadingDepth != LoadingDepthRegistry.UNDEFINED && registryLoadingDepth != 0)) {
			addReferencedResourcesInternal(resource, allResources, 1);
		}
	}

	/**
	 * Adds resources referenced by proxies found in the given resources to the
	 * set <code>allResources</code>
	 *
	 * @param resource
	 *            the resource in which to look for proxies to resolve
	 * @param allResources
	 *            the set of resources to which to add resources referenced by
	 *            proxies
	 * @param currentDepth
	 *            the current depth
	 *
	 * @see EcoreBrowser#addReferencedResources(Resource, Set)
	 */
	private void addReferencedResourcesInternal(final Resource resource,
			final Set<Resource> allResources, final int currentDepth) {

		final Set<Resource> directReferencedResources = new HashSet<Resource>();

		synchronized (resource) {
			for (EObject root : resource.getContents()) {
				Map<EObject, Collection<EStructuralFeature.Setting>> externalReferences = EcoreUtil.ExternalCrossReferencer
						.find(root);
				if (!externalReferences.isEmpty()) {
					int loadingDepth = this.browserConfiguration
							.getReferencedResourcesLoadingDepth();
					if (loadingDepth == BrowserConfiguration.NOT_YET_ASKED) {
						int registryLoadingDepth = LoadingDepthRegistry.getInstance()
								.getLoadingDepth(getMetamodelURI());
						// whether user settings override registry settings
						boolean overridden = MoDiscoBrowserPlugin
								.getPlugin()
								.getPreferenceStore()
								.getBoolean(
										PreferenceConstants.P_BROWSER_OVERRIDE_METAMODEL_SPECIFIC_SETTINGS);

						if (registryLoadingDepth == LoadingDepthRegistry.UNDEFINED || overridden) {
							final int defaultLoadingDepth = MoDiscoBrowserPlugin.getPlugin()
									.getPreferenceStore()
									.getInt(PreferenceConstants.P_BROWSER_LOADING_DEPTH);
							if (MoDiscoBrowserPlugin.getPlugin().getPreferenceStore()
									.getBoolean(PreferenceConstants.P_BROWSER_ASK_LOADING_DEPTH)) {
								// get shell on UI thread
								final Shell[] shell = new Shell[1];
								Display.getDefault().syncExec(new Runnable() {
									public void run() {
										shell[0] = getSite().getShell();
									}
								});
								loadingDepth = BrowserUtils
										.askUserForDepthToLoadReferencedResources(
												defaultLoadingDepth, shell[0]);
							} else {
								loadingDepth = defaultLoadingDepth;
								if (loadingDepth < -1) {
									loadingDepth = 0;
								}
							}
						} else {
							loadingDepth = registryLoadingDepth;
						}
						this.browserConfiguration.setReferencedResourcesLoadingDepth(loadingDepth);
					}
					if (loadingDepth != -1 && loadingDepth < currentDepth) {
						return;
					}
					for (EObject external : externalReferences.keySet()) {
						Resource externalResource;
						if (external.eIsProxy()) {
							externalResource = EcoreUtil.resolve(external, root).eResource();
						} else {
							externalResource = external.eResource();
						}
						if (externalResource != null) {
							directReferencedResources.add(externalResource);
						} else {
							MoDiscoLogger
									.logError(
											"Failed to load an external element: " + external.eClass().getName() //$NON-NLS-1$
													+ " " + EcoreUtil.getURI(external), //$NON-NLS-1$
											MoDiscoBrowserPlugin.getPlugin());
						}
					}
				}
			}
		}

		int loadingDepth = this.browserConfiguration.getReferencedResourcesLoadingDepth();

		// recurse on sub-resources
		for (Resource directlyReferencedResource : directReferencedResources) {
			if (directlyReferencedResource == null) {
				continue;
			}
			// avoid infinite recursion in the case of mutually referencing
			// resources
			if (!allResources.contains(directlyReferencedResource)) {
				allResources.add(directlyReferencedResource);
				if (loadingDepth == -1 || currentDepth + 1 <= loadingDepth) {
					addReferencedResourcesInternal(directlyReferencedResource, allResources,
							currentDepth + 1);
				}
			}
		}
	}

	/**
	 * Create the left pane, containing the metaclass viewer.
	 *
	 * @param parent
	 *            the parent composite
	 */
	protected void createLeftPane(final Composite parent) {
		final Section section = this.fFormToolkit.createSection(parent,
				ExpandableComposite.TITLE_BAR | ExpandableComposite.EXPANDED);
		section.setText(Messages.EcoreBrowser_metaclasses);
		this.typesPaneComposite = this.fFormToolkit.createComposite(section);
		section.setClient(this.typesPaneComposite);
		this.leftPane = initLeftPane(section, this.fFormToolkit);
		final Composite toolBar = this.leftPane.getToolBarComposite();
		section.setTextClient(toolBar);
		this.typesPaneComposite.setLayout(new FillLayout());
		this.metaclassViewer = this.leftPane.getMetaclassViewer();
		this.metaclassViewer
				.addSelectionChangedListener(new MetaclassListViewerSelectionChangedListener());
	}

	protected LeftPane initLeftPane(final Section section, final FormToolkit formToolkit) {
		return new LeftPane(section, (Composite) section.getClient(), this.browserConfiguration,
				formToolkit, getSite());
	}

	/**
	 * Create the tree and its viewer
	 *
	 * @param parent
	 *            the parent composite of the tree
	 */
	protected void createTreePane(final Composite parent) {

		final Section section = this.fFormToolkit.createSection(parent,
				ExpandableComposite.TITLE_BAR | ExpandableComposite.EXPANDED);
		section.setText(Messages.EcoreBrowser_instances);
		this.instancesPaneComposite = this.fFormToolkit.createComposite(section, SWT.NONE);
		section.setClient(this.instancesPaneComposite);

		final GridLayout layout = new GridLayout();
		layout.marginHeight = 0;
		layout.marginWidth = 0;
		this.instancesPaneComposite.setLayout(layout);

		final Composite treeToolBar = createTreeToolBar(section);
		section.setTextClient(treeToolBar);

		this.errorsButton = new Button(this.instancesPaneComposite, SWT.PUSH);
		this.errorsButton.setText(Messages.EcoreBrowser_errorsAndWarnings);
		this.errorsButton.setToolTipText(Messages.EcoreBrowser_errorsAndWarnings);
		this.errorsButton.setImage(ImageProvider.getInstance().getErrorIcon());
		this.errorsButton.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(final SelectionEvent e) {
				final ErrorsDialog errorsDialog = new ErrorsDialog(getSite().getShell(),
						EcoreBrowser.this.fDiagnostic);
				errorsDialog.open();
			}
		});
		this.errorsButton.setVisible(false);

		final GridData errorsButtonGridData = new GridData();
		errorsButtonGridData.exclude = true;
		this.errorsButton.setLayoutData(errorsButtonGridData);

		createSearchPanel(this.instancesPaneComposite);

		this.fTree = this.fFormToolkit.createTree(this.instancesPaneComposite, SWT.MULTI
				| SWT.BORDER);
		final GridData treeGridData = new GridData();
		treeGridData.grabExcessHorizontalSpace = true;
		treeGridData.grabExcessVerticalSpace = true;
		treeGridData.horizontalAlignment = SWT.FILL;
		treeGridData.verticalAlignment = SWT.FILL;
		this.fTree.setLayoutData(treeGridData);

		this.fTree.addKeyListener(new KeyAdapter() {
			@Override
			public void keyPressed(final KeyEvent e) {
				if (e.keyCode == SWT.ESC) {
					// Escape on the tree: restore view (after search)
					EcoreBrowser.this.searchBox.setText(""); //$NON-NLS-1$
					search();
				} else if (e.keyCode == SWT.CR) {
					// Enter: browse selected item
					handleEnter();
				} else if (e.keyCode == 'c' && e.stateMask == SWT.CTRL) {
					// Ctrl+C : copy element text to clipboard
					BrowserUtils.handleCopyToClipboard(getEditorSelection());
				} else if (e.keyCode == SWT.DEL) {
					handleDel();
				}
			}
		});

		this.customTreePainter = new CustomTreePainter(this.fTree,
				this.browserConfiguration.getAppearanceConfiguration());
		// create a tooltip to show facet names
		FacetTooltip.create(this.fTree, this.customTreePainter);

		this.treeViewer = new TreeViewer(this.fTree);
		// speeds up all operations on a big model
		this.treeViewer.setUseHashlookup(true);

		hookViewerToSelection(this.treeViewer);

		this.fContentProvider = new BrowserContentProvider(this);
		this.treeViewer.setContentProvider(this.fContentProvider);
		this.fLabelProvider = new BrowserLabelProvider(this);
		this.treeViewer.setLabelProvider(this.fLabelProvider);

		registerShowPropertyViewOnDblClick(this.fTree);
	}

	/**
	 * The user pressed the "Enter" key : if selected element is a model
	 * element, then browse to it. If it is an attribute, then open properties
	 * view.
	 */
	protected void handleEnter() {
		final ISelection selection = getEditorSelection();
		if (selection instanceof ITreeSelection) {
			final ITreeSelection treeSelection = (ITreeSelection) selection;
			final Object selectedElement = treeSelection.getFirstElement();
			if (selectedElement instanceof ModelElementItem) {
				browse();
			} else if (selectedElement instanceof AttributeItem
					|| selectedElement instanceof LinkItem) {
				openPropertiesView();
			} else if (selectedElement instanceof QueryItem) {
				QueryItem queryItem = (QueryItem) selectedElement;
				SelectedQuery query = queryItem.getQuery();
				query.executeQuery();
			}
		}
	}

	/** The user pressed the "Delete" key */
	protected void handleDel() {
		final ISelection selection = getEditorSelection();
		if (selection instanceof ITreeSelection) {
			final ITreeSelection treeSelection = (ITreeSelection) selection;
			Iterator<?> iterator = treeSelection.iterator();
			while (iterator.hasNext()) {
				Object selectedElement = iterator.next();
				if (selectedElement instanceof QueryItem) {
					QueryItem queryItem = (QueryItem) selectedElement;
					this.browserConfiguration.getSelectedQueriesManager().remove(
							queryItem.getQuery());
				}
			}
		}
	}

	/**
	 * Set the initial font using saved user preferences, and add a listener to
	 * be notified of changes in the preferences
	 */
	private void setupInitialTreeFont() {
		setupPreferredFont();

		this.fontChangeListener = new IPropertyChangeListener() {
			public void propertyChange(final PropertyChangeEvent event) {
				if (event.getProperty().equals(JFaceResources.DIALOG_FONT)) {
					setupPreferredFont();
				}
			}
		};
		JFaceResources.getFontRegistry().addListener(this.fontChangeListener);
	}

	/** Set the user preferred font on the editor */
	private void setupPreferredFont() {
		FontDescriptor descriptor = FontDescriptor.createFrom(JFaceResources.getDialogFont());
		descriptor = descriptor.increaseHeight(this.browserConfiguration
				.getAppearanceConfiguration().getFontSizeDelta());
		final Font customFont = descriptor.createFont(Display.getDefault());
		descriptor = descriptor.setStyle(SWT.ITALIC);
		final Font customItalicFont = descriptor.createFont(Display.getDefault());
		this.browserConfiguration.getAppearanceConfiguration().setCustomFont(customFont);
		this.browserConfiguration.getAppearanceConfiguration()
				.setCustomItalicFont(customItalicFont);
		this.fTree.setFont(customFont);
		this.treeViewer.refresh();
		this.metaclassViewer.setFont(customFont);
		this.metaclassViewer.refresh();
	}

	protected Composite createTreeToolBar(final Composite parent) {
		final Composite treeToolBarComposite = new Composite(parent, SWT.WRAP);
		this.instancesToolBar = TreeToolBar.create(treeToolBarComposite, this);
		return treeToolBarComposite;
	}

	/**
	 * Register a listener to show the property view or execute a query when the
	 * tree is double-clicked
	 */
	private void registerShowPropertyViewOnDblClick(final Tree tree) {
		tree.addMouseListener(new MouseAdapter() {
			@Override
			public void mouseDoubleClick(final MouseEvent event) {
				boolean handled = false;
				if (event.button == 1) {
					TreeItem[] selection = tree.getSelection();
					for (TreeItem treeItem : selection) {
						Object element = treeItem.getData();
						if (element instanceof QueryItem) {
							QueryItem queryItem = (QueryItem) element;
							SelectedQuery query = queryItem.getQuery();
							query.executeQuery();
							handled = true;
						}

						// If the user has activated the code synchronization
						if (EcoreBrowser.this.browserConfiguration.getAppearanceConfiguration()
								.isSynchronizeSourceCode()) {
							EObject eObject = (EObject) Platform.getAdapterManager().getAdapter(
									element, EObject.class);

							IStatusLineManager statusLineManager = getActionBars()
									.getStatusLineManager();

							if (eObject != null) {
								// Look for an extension declaring the
								// doubleClickListener extension point
								IExtensionRegistry registry = Platform.getExtensionRegistry();
								IExtensionPoint extPointDblClick = registry
										.getExtensionPoint("org.eclipse.modisco.infra.browser.doubleClickListener"); //$NON-NLS-1$

								if (extPointDblClick != null) {
									for (IExtension ext : extPointDblClick.getExtensions()) {
										for (IConfigurationElement configElt : ext
												.getConfigurationElements()) {
											String classAttribute = configElt.getAttribute("class"); //$NON-NLS-1$
											if (classAttribute != null) {
												try {
													DoubleClickListener listener = (DoubleClickListener) configElt
															.createExecutableExtension("class"); //$NON-NLS-1$
													// Synchronize this eObject
													// with its source code
													listener.synchronizeEObject(eObject,
															statusLineManager);
												} catch (CoreException e) {
													MoDiscoLogger.logError(e,
															MoDiscoBrowserPlugin.getPlugin());
												} finally {
													handled = true;
												}
											}
										}
									}
								} else {
									if (statusLineManager != null) {
										statusLineManager
												.setErrorMessage(Messages.EcoreBrowser_noSynchronisationExtensionFound);
									} else {
										MoDiscoLogger
												.logWarning(
														Messages.EcoreBrowser_noSynchronisationExtensionFound,
														MoDiscoBrowserPlugin.getPlugin());
									}

								}
							}
						}

					}
					if (!handled) {
						openPropertiesView();
					}
				}
			}
		});
	}

	public boolean isSynchronizeSourceCode() {
		return this.browserConfiguration.getAppearanceConfiguration().isSynchronizeSourceCode();
	}

	public void setSynchronizeSourceCode(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setSynchronizeSourceCode(value);
		internalRefreshTree();
	}

	/**
	 * Create the search panel, containing a label and search field.
	 *
	 * @param parent
	 *            the parent composite, which must have a GridLayout
	 */
	protected void createSearchPanel(final Composite parent) {
		final Composite searchPanel = new Composite(parent, SWT.NONE);
		searchPanel.setLayout(new GridLayout());

		searchPanel.setLayout(new FillLayout());
		final GridData searchPanelGridData = new GridData();
		searchPanelGridData.grabExcessHorizontalSpace = true;
		searchPanelGridData.horizontalAlignment = SWT.FILL;
		searchPanel.setLayoutData(searchPanelGridData);

		// Label searchLabel = new Label(searchPanel, SWT.NONE);
		// searchLabel.setText("&Search:");

		this.searchBox = new Text(searchPanel, SWT.SEARCH);
		this.searchBox.addKeyListener(new KeyAdapter() {
			@Override
			public void keyPressed(final KeyEvent e) {
				if (e.keyCode == SWT.CR || e.keyCode == SWT.KEYPAD_CR) {
					// ENTER: start a search
					search();
				} else if (e.keyCode == SWT.ESC) {
					// ESCAPE: restore the view after a search
					EcoreBrowser.this.searchBox.setText(""); //$NON-NLS-1$
					search();
				}
			}
		});

		this.searchBox.setMessage(Messages.EcoreBrowser_typeFilterText);
		this.searchBox.setData("org.eclipse.swtbot.widget.key", "EcoreBrowser.searchBox"); //$NON-NLS-1$//$NON-NLS-2$
		fixClipboardCommands(this.searchBox);
	}

	/**
	 * Called when the user initiates a search. Find the list of all the
	 * instances of the selected metaclass that have a name containing the
	 * search string (entered by the user in the search box), in a case
	 * insensitive way. Set this list as input of the tree viewer.
	 * <p>
	 * Do the search in a Job that can be canceled by the user.
	 * <p>
	 * If the search box is empty, then restore the previous tree viewer input.
	 */
	protected void search() {
		final String searchText = this.searchBox.getText().toLowerCase();

		if (searchText.trim().length() == 0) {
			if (this.savedInput != null && this.savedInput != this.treeViewer.getInput()) {
				this.treeViewer.setInput(this.savedInput);
			}
			return;
		}

		final List<EClass> selectedMetaclasses = findSelectedEClasses();
		if (selectedMetaclasses.isEmpty()) {
			return;
		}

		this.searchJob = new Job(Messages.EcoreBrowser_jobName_SearchInModelEditor) {
			@Override
			protected IStatus run(final IProgressMonitor monitor) {

				final ResourceSet resourceSet = EcoreBrowser.this.fResourceSet;
				final EList<Resource> resources = resourceSet.getResources();
				if (resources.size() < 1) {
					return Status.OK_STATUS;
				}

				// the search results : will become the input of the tree viewer
				final SearchResults searchResults = new SearchResults(
						EcoreBrowser.this.browserConfiguration);

				InstancesForMetaclasses instancesForMetaclasses = EcoreBrowser.this.browserConfiguration
						.getInstancesForMetaclasses();
				for (EClass eClass : selectedMetaclasses) {
					ArrayList<EObject> elements = instancesForMetaclasses.getInstancesForMetaclass(
							eClass).getElements();
					for (EObject eObject : elements) {
						final ModelElementItem modelElementItem = new ModelElementItemEx(eObject,
								null, EcoreBrowser.this.browserConfiguration);
						final String objectText = modelElementItem.getName().toLowerCase();
						if (objectText.contains(searchText)) {
							searchResults.add(eObject);
						}
						// if the user canceled the search
						if (monitor.isCanceled()) {
							return Status.CANCEL_STATUS;
						}
					}
				}

				// do only the minimum amount of work in the UI thread
				Display.getDefault().syncExec(new Runnable() {
					public void run() {
						// do not try to restore selection
						EcoreBrowser.this.treeViewer.setSelection(null);
						EcoreBrowser.this.treeViewer.setInput(searchResults);
					}
				});
				return Status.OK_STATUS;
			}
		};
		this.searchJob.setUser(true);
		this.searchJob.setPriority(Job.LONG);
		this.searchJob.schedule();
	}

	/**
	 * @return the {@link EClass}es corresponding to the metaclasses selected in
	 *         the metaclass list (empty list if none)
	 */
	private List<EClass> findSelectedEClasses() {

		final ArrayList<EClass> selectedMetaclasses = new ArrayList<EClass>();

		final ISelection selection = this.metaclassViewer.getSelection();
		if (selection instanceof IStructuredSelection) {
			final IStructuredSelection structuredSelection = (IStructuredSelection) selection;

			final Iterator<?> iterator = structuredSelection.iterator();
			while (iterator.hasNext()) {
				final Object element = iterator.next();
				if (element instanceof EClass) {
					final EClass eClass = (EClass) element;
					addMetaclassToSelection(eClass, selectedMetaclasses, this.browserConfiguration
							.getAppearanceConfiguration().isDisplayInstancesOfSubclasses());
				}
			}
		}
		return selectedMetaclasses;
	}

	/**
	 * Adds the given metaclass to the given selection.
	 *
	 * @param addSubclasses
	 *            also adds subclasses
	 */
	private void addMetaclassToSelection(final EClass eClass,
			final ArrayList<EClass> selectedMetaclasses, final boolean addSubclasses) {
		selectedMetaclasses.add(eClass);
		// add subclasses recursively
		if (addSubclasses) {
			InstancesForMetaclasses instancesForMetaclasses = this.browserConfiguration
					.getInstancesForMetaclasses();
			InstancesForMetaclass instancesForMetaclass = instancesForMetaclasses
					.getInstancesForMetaclass(eClass);
			if (instancesForMetaclass != null) {
				InstancesForMetaclass[] subclasses = instancesForMetaclass.getSubclasses();
				for (InstancesForMetaclass subclass : subclasses) {
					addMetaclassToSelection(subclass.getEClass(), selectedMetaclasses,
							addSubclasses);
				}
			} else {
				MoDiscoLogger.logError("Could not find subclasses of '" + eClass.getName() + "'", //$NON-NLS-1$ //$NON-NLS-2$
						MoDiscoBrowserPlugin.getPlugin());
			}

		}
	}

	/**
	 * Listen to selection changes in the metaclass list viewer, and update the
	 * tree viewer accordingly.
	 */
	private final class MetaclassListViewerSelectionChangedListener implements
			ISelectionChangedListener {

		/** Memorize the tree selection for each metaclass */
		private final HashMap<EClass, ITreeSelection> selections = new HashMap<EClass, ITreeSelection>();
		/** The metaclass that was selected before the selection changed */
		private EClass lastSelectedMetaclass = null;

		/**
		 * Get the selected entries corresponding to the given selection in the
		 * metaclass viewer (may be empty)
		 */
		private InstancesForMetaclass[] getEntriesForSelection(final ISelection selection) {
			final ArrayList<InstancesForMetaclass> instancesForMetaclasses = new ArrayList<InstancesForMetaclass>();

			if (selection instanceof IStructuredSelection) {
				final IStructuredSelection structuredSelection = (IStructuredSelection) selection;

				for (final Iterator<?> iterator = structuredSelection.iterator(); iterator
						.hasNext();) {
					final Object element = iterator.next();
					if (element instanceof InstancesForMetaclass) {
						final InstancesForMetaclass instancesForMetaclass = (InstancesForMetaclass) element;
						instancesForMetaclasses.add(instancesForMetaclass);
					}
				}
			}

			return instancesForMetaclasses
					.toArray(new InstancesForMetaclass[instancesForMetaclasses.size()]);
		}

		/**
		 * Updates the tree viewer when the selection changes in the metaclass
		 * viewer. Keeps track of the tree selection for each metaclass, and
		 * restores it when possible.
		 */
		public void selectionChanged(final SelectionChangedEvent event) {

			// save the selection
			if (this.lastSelectedMetaclass != null) {
				this.selections.put(this.lastSelectedMetaclass,
						(ITreeSelection) EcoreBrowser.this.treeViewer.getSelection());
			}

			final ISelection metaclassSelection = event.getSelection();
			final InstancesForMetaclass[] entries = getEntriesForSelection(metaclassSelection);

			ITreeSelection savedSelection = null;
			Object input = null;
			if (entries.length > 0) {
				savedSelection = this.selections.get(entries[0].getEClass());

				final EClass[] selectedMetaclasses = new EClass[entries.length];
				int i = 0;
				for (final InstancesForMetaclass entry : entries) {
					selectedMetaclasses[i++] = entry.getEClass();
				}

				input = new MetaclassList(EcoreBrowser.this.browserConfiguration,
						selectedMetaclasses);
				this.lastSelectedMetaclass = entries[0].getEClass();
			} else {
				this.lastSelectedMetaclass = null;
			}

			try {
				// speedup and avoid flickering
				EcoreBrowser.this.treeViewer.getTree().setRedraw(false);

				if (EcoreBrowser.this.searchBox != null) {
					EcoreBrowser.this.searchBox.setText(""); //$NON-NLS-1$
				}

				// do not restore selection twice
				EcoreBrowser.this.treeViewer.setSelection(null);

				// set the list of model elements as the input of the treeview
				EcoreBrowser.this.treeViewer.setInput(input);
				EcoreBrowser.this.savedInput = input;
				EcoreBrowser.this.treeViewer.setSelection(savedSelection, true);
			} finally {
				EcoreBrowser.this.treeViewer.getTree().setRedraw(true);
			}

			markNavigationLocation();
		}
	}

	public void setShowEmptyLinks(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setShowEmptyLinks(value);
		internalRefreshTree();
	}

	public boolean isShowEmptyLinks() {
		return this.browserConfiguration.getAppearanceConfiguration().isShowEmptyLinks();
	}

	public void setSortInstances(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setSortInstances(value);
		internalRefreshTree();
	}

	public boolean isSortInstances() {
		return this.browserConfiguration.getAppearanceConfiguration().isSortInstances();
	}

	public void setShowDerivedLinks(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setShowDerivedLinks(value);
		internalRefreshTree();
	}

	public boolean isShowDerivedLinks() {
		return this.browserConfiguration.getAppearanceConfiguration().isShowDerivedLinks();
	}

	public void setShowFullQualifiedNames(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setShowFullQualifiedNames(value);
		internalRefreshTree();
		this.metaclassViewer.refresh();
	}

	public boolean isShowFullQualifiedNames() {
		return this.browserConfiguration.getAppearanceConfiguration().isShowFullQualifiedNames();
	}

	public void setShowMultiplicity(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setShowMultiplicity(value);
		internalRefreshTree();
	}

	public boolean isShowMultiplicity() {
		return this.browserConfiguration.getAppearanceConfiguration().isShowMultiplicity();
	}

	public void setShowOppositeLinks(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setShowOppositeLinks(value);
		internalRefreshTree();
	}

	public boolean isShowOppositeLinks() {
		return this.browserConfiguration.getAppearanceConfiguration().isShowOppositeLinks();
	}

	public void setShowContainer(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setShowContainer(value);
		internalRefreshTree();
	}

	public boolean isShowContainer() {
		return this.browserConfiguration.getAppearanceConfiguration().isShowContainer();
	}

	public void setSortLinks(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setSortLinks(value);
		internalRefreshTree();
	}

	public boolean isSortLinks() {
		return this.browserConfiguration.getAppearanceConfiguration().isSortLinks();
	}

	public void setSortLinksByType(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setSortLinksByType(value);
		internalRefreshTree();
	}

	public boolean isSortLinksByType() {
		return this.browserConfiguration.getAppearanceConfiguration().isSortLinksByType();
	}

	public void setShowAttributes(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setShowAttributes(value);
		internalRefreshTree();
	}

	public boolean isShowAttributes() {
		return this.browserConfiguration.getAppearanceConfiguration().isShowAttributes();
	}

	public void setShowEmptyAttributes(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setShowEmptyAttributes(value);
		internalRefreshTree();
	}

	public boolean isShowEmptyAttributes() {
		return this.browserConfiguration.getAppearanceConfiguration().isShowEmptyAttributes();
	}

	public void setFontSizeDelta(final int value) {
		this.browserConfiguration.getAppearanceConfiguration().setFontSizeDelta(value);
		setupPreferredFont();
	}

	public int getFontSizeDelta() {
		return this.browserConfiguration.getAppearanceConfiguration().getFontSizeDelta();
	}

	public void setShowOrdering(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setShowOrdering(value);
		internalRefreshTree();
	}

	public boolean isShowOrdering() {
		return this.browserConfiguration.getAppearanceConfiguration().isShowOrdering();
	}

	public void setShowTypeOfLinks(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setShowTypeOfLinks(value);
		internalRefreshTree();
	}

	public boolean isShowTypeOfLinks() {
		return this.browserConfiguration.getAppearanceConfiguration().isShowTypeOfLinks();
	}

	public void setShowElementIDs(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setShowElementIDs(value);
		internalRefreshTree();
	}

	public boolean isShowElementIDs() {
		return this.browserConfiguration.getAppearanceConfiguration().isShowElementIDs();
	}

	public void setShowURI(final boolean value) {
		this.browserConfiguration.getAppearanceConfiguration().setShowURI(value);
		internalRefreshTree();
	}

	public boolean isShowURI() {
		return this.browserConfiguration.getAppearanceConfiguration().isShowURI();
	}

	public void showOnlyInstancesPanel() {
		this.sashForm.setSashWidth(0);
		this.sashForm.setWeights(new int[] { 0, 1 });
	}

	public void showOnlyTypesPanel() {
		this.sashForm.setSashWidth(0);
		this.sashForm.setWeights(new int[] { 1, 0 });
	}

	public void showBothPanels() {
		this.sashForm.setSashWidth(EcoreBrowser.SASH_WIDTH);
		this.sashForm.setWeights(new int[] { EcoreBrowser.LEFT_PANE_SASH_WEIGHT,
				EcoreBrowser.RIGHT_PANE_SASH_WEIGHT });
	}

	/** This is how the framework determines which interfaces we implement. */
	@SuppressWarnings("unchecked")
	@Override
	public Object getAdapter(final Class key) {
		if (key.equals(IPropertySheetPage.class)) {
			// Store the propertySheetPage to be able to call dispose() on it.
			if (this.propertySheetPage == null) {
				this.propertySheetPage = getPropertySheetPage();
			}
			return getPropertySheetPage();
		}
		return super.getAdapter(key);
	}

	/** This accesses a cached version of the property sheet page. */
	public IPropertySheetPage getPropertySheetPage() {
		if (this.propertySheetPage == null) {
			this.propertySheetPage = new ExtendedPropertySheetPage(this.editingDomain) {
				@Override
				public void setSelectionToViewer(final List<?> selection) {
					EcoreBrowser.this.setSelectionToViewer(selection);
					EcoreBrowser.this.setFocus();
				}

				@Override
				public void setActionBars(final IActionBars actionBars) {
					super.setActionBars(actionBars);
					getActionBarContributor().shareGlobalActions(this, actionBars);
				}

				@Override
				public void selectionChanged(final IWorkbenchPart part, final ISelection selection0) {
					ISelection selection = EcoreBrowser.this.getEditorSelection();

					boolean selectionNotified = false;
					if (selection instanceof IStructuredSelection) {
						if (((IStructuredSelection) selection).toArray().length == 1) {
							Object objSelected = ((IStructuredSelection) selection)
									.getFirstElement();
							if (objSelected instanceof ModelElementItem) {
								ModelElementItem modelElementItem = (ModelElementItem) objSelected;
								super.selectionChanged(part, new StructuredSelection(
										modelElementItem.getEObject()));
								selectionNotified = true;
							} else if (objSelected instanceof AttributeItem) {
								super.selectionChanged(part, new StructuredSelection(
										((AttributeItem) objSelected).getAttribute()));
								selectionNotified = true;
							} else if (objSelected instanceof LinkItem) {
								super.selectionChanged(part, new StructuredSelection(
										((LinkItem) objSelected).getReference()));
								selectionNotified = true;
							}
						}
					}
					if (!selectionNotified) {
						super.selectionChanged(part, StructuredSelection.EMPTY);
					}
				}
			};
			if (this.propertySheetPage instanceof PropertySheetPage) {
				((PropertySheetPage) this.propertySheetPage)
						.setPropertySourceProvider(new AdapterFactoryContentProvider(
								this.adapterFactoryWithRegistry) {
							@Override
							protected IPropertySource createPropertySource(final Object object,
									final IItemPropertySource itemPropertySource) {
								return new PropertySource(object, itemPropertySource) {
									@Override
									protected IPropertyDescriptor createPropertyDescriptor(
											final IItemPropertyDescriptor itemPropertyDescriptor) {
										return new PropertyDescriptor(this.object,
												itemPropertyDescriptor);
									}
								};
							}
						});
			}
		}
		return this.propertySheetPage;
	}

	@Override
	public boolean isDirty() {
		if (isReadOnly()) {
			return false;
		}
		return ((BasicCommandStack) this.editingDomain.getCommandStack()).isSaveNeeded();
	}

	/**
	 * This is for implementing {@link org.eclipse.ui.IEditorPart} : saves the
	 * model file.
	 */
	@Override
	public void doSave(final IProgressMonitor progressMonitor) {
		if (isReadOnly()) {
			return;
		}

		// Save only resources that have actually changed.
		final Map<Object, Object> saveOptions = new HashMap<Object, Object>();
		saveOptions.put(Resource.OPTION_SAVE_ONLY_IF_CHANGED,
				Resource.OPTION_SAVE_ONLY_IF_CHANGED_MEMORY_BUFFER);

		// Do the work within an operation because this is a long running
		// activity that modifies the workbench.
		WorkspaceModifyOperation operation = new WorkspaceModifyOperation() {
			// This is the method that gets invoked when the operation runs.
			@Override
			public void execute(final IProgressMonitor monitor) {
				// Save the resources to the file system.
				boolean first = true;
				for (Resource resource : EcoreBrowser.this.editingDomain.getResourceSet()
						.getResources()) {
					// see Bug 311005 - UnknownServiceException when trying to
					// save a UML model
					synchronized (resource) {
						URI uri = resource.getURI();
						if ((first || !resource.getContents().isEmpty() || isPersisted(resource))
								&& !EcoreBrowser.this.editingDomain.isReadOnly(resource)
								&& uri != null && (uri.isPlatformResource() || uri.isFile())) {
							try {
								long timeStamp = resource.getTimeStamp();
								resource.save(saveOptions);
								if (resource.getTimeStamp() != timeStamp) {
									EcoreBrowser.this.savedResources.add(resource);
								}
							} catch (final Exception e) {
								MoDiscoLogger.logError(e, MoDiscoBrowserPlugin.getPlugin());
								DialogUtils.openErrorDialog(getSite().getShell(), e,
										Messages.EcoreBrowser_errorSavingResource);
								EcoreBrowser.this.resourceToDiagnosticMap.put(resource,
										analyzeResourceProblems(resource, e));
							}
							first = false;
						}
					}
				}
			}
		};

		this.updateProblemIndication = false;
		try {
			// This runs the options, and shows progress.
			new ProgressMonitorDialog(getSite().getShell()).run(true, false, operation);

			// Refresh the necessary state.
			((BasicCommandStack) this.editingDomain.getCommandStack()).saveIsDone();
			firePropertyChange(IEditorPart.PROP_DIRTY);
		} catch (Exception exception) {
			// Something went wrong that shouldn't.
			MoDiscoBrowserPlugin.getPlugin().log(exception);
		}
		this.updateProblemIndication = true;
		updateProblemIndication();
	}

	@Override
	public void doSaveAs() {
		SaveAsDialog saveAsDialog = new SaveAsDialog(getSite().getShell());
		saveAsDialog.open();
		IPath path = saveAsDialog.getResult();
		if (path != null) {
			IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(path);
			if (file != null) {
				doSaveAs(URI.createPlatformResourceURI(file.getFullPath().toString(), true),
						new FileEditorInput(file));
			}
		}
	}

	protected void doSaveAs(final URI uri, final IEditorInput editorInput) {
		this.editingDomain.getResourceSet().getResources().get(0).setURI(uri);
		setInputWithNotify(editorInput);
		setPartName(editorInput.getName());
		IProgressMonitor progressMonitor;
		IStatusLineManager statusLineManager = getActionBars().getStatusLineManager();
		if (statusLineManager != null) {
			progressMonitor = statusLineManager.getProgressMonitor();
		} else {
			progressMonitor = new NullProgressMonitor();
		}
		doSave(progressMonitor);
	}

	@Override
	public boolean isSaveAsAllowed() {
		return !isReadOnly();
	}

	/**
	 * This returns whether something has been persisted to the URI of the
	 * specified resource. The implementation uses the URI converter from the
	 * editor's resource set to try to open an input stream.
	 */
	protected boolean isPersisted(final Resource resource) {
		boolean result = false;
		try {
			InputStream stream = this.editingDomain.getResourceSet().getURIConverter()
					.createInputStream(resource.getURI());
			if (stream != null) {
				result = true;
				stream.close();
			}
		} catch (IOException e) {
			result = false;
		}
		return result;
	}

	/**
	 * This is called during startup to initialize the editor with its site and
	 * input.
	 */
	@Override
	public void init(final IEditorSite site, final IEditorInput editorInput) {
		// TODO: check input is of expected type
		try {
			setSite(site);
			setInputWithNotify(editorInput);
			setPartName(editorInput.getName());
			site.setSelectionProvider(this);
			site.getPage().addPartListener(this.partListener);
			ResourcesPlugin.getWorkspace().addResourceChangeListener(this.resourceChangeListener,
					IResourceChangeEvent.POST_CHANGE);
		} catch (final Exception e) {
			MoDiscoLogger.logError(e, MoDiscoBrowserPlugin.getPlugin());
		}
	}

	/** Focus the tree viewer when the editor is focused */
	@Override
	public void setFocus() {
		// Done in setFocus because we don't want the job to start until the
		// editor is visible. Otherwise it still hangs the UI.
		if (this.openModelJob == null) {
			this.openModelJob = new Job(Messages.EcoreBrowser_jobOpeningModelInMoDiscoBrowser) {
				@Override
				protected IStatus run(final IProgressMonitor monitor) {
					boolean result = backgroundOpenModel(monitor);
					EcoreBrowser.this.loaded = result;
					if (result) {
						return Status.OK_STATUS;
					}
					return Status.CANCEL_STATUS;
				}
			};
			this.openModelJob.setPriority(Job.LONG);
			getProgressService().schedule(this.openModelJob);
		} else if (this.treeViewer != null) {
			this.treeViewer.getTree().setFocus();
		}
	}

	/** This implements {@link org.eclipse.jface.viewers.ISelectionProvider}. */
	public void addSelectionChangedListener(final ISelectionChangedListener listener) {
		this.selectionChangedListeners.add(listener);
	}

	/** This implements {@link org.eclipse.jface.viewers.ISelectionProvider}. */
	public void removeSelectionChangedListener(final ISelectionChangedListener listener) {
		this.selectionChangedListeners.remove(listener);
	}

	/**
	 * Returns the "unwrapped" selection of the editor, with Ecore elements
	 * instead of the proxies used internally
	 */
	public ISelection getSelection() {
		return BrowserUtils.unwrapSelection(this.editorSelection);
	}

	/** @return the "real" selection, with proxy objects (ModelElementItem, etc.) */
	public ISelection getEditorSelection() {
		return this.editorSelection;
	}

	/**
	 * This implements {@link org.eclipse.jface.viewers.ISelectionProvider} to
	 * set this editor's overall selection. Calling this result will notify the
	 * listeners.
	 */
	public void setSelection(final ISelection selection) {
		this.editorSelection = selection;

		for (final ISelectionChangedListener listener : this.selectionChangedListeners) {
			// depending on the listener type, unwrap the selection
			if (listener instanceof IBrowserSelectionChangedListener) {
				// expose the proxy objects
				listener.selectionChanged(new SelectionChangedEvent(this, selection));
			} else {
				// expose the underlying Ecore elements
				listener.selectionChanged(new SelectionChangedEvent(this, BrowserUtils
						.unwrapSelection(selection)));
			}
		}
		setStatusLineMessage(selection);
	}

	/** Connect the given viewer to the editor's selection */
	private void hookViewerToSelection(final Viewer viewer) {
		if (viewer == null) {
			return;
		}

		if (this.selectionChangedListener == null) {
			// Create the listener on demand
			this.selectionChangedListener = new ISelectionChangedListener() {
				// This just notifies those things that are affected by the
				// selection
				public void selectionChanged(final SelectionChangedEvent selectionChangedEvent) {
					setSelection(selectionChangedEvent.getSelection());
				}
			};
		}

		viewer.addSelectionChangedListener(this.selectionChangedListener);

		// Set the editor's selection based on the viewer's selection
		setSelection(viewer.getSelection());
	}

	/** Set the status line message depending on the given selection */
	public void setStatusLineMessage(final ISelection selection) {
		// TODO: maybe display more useful information?
		final IStatusLineManager statusLineManager = getActionBars().getStatusLineManager();

		if (statusLineManager != null) {
			if (selection instanceof IStructuredSelection) {
				final Collection<?> collection = ((IStructuredSelection) selection).toList();
				switch (collection.size()) {
				case 0:
					statusLineManager.setMessage(Messages.EcoreBrowser_noObjectSelected);
					break;
				case 1:
					final Object object = collection.iterator().next();
					if (object instanceof ITreeElement) {
						final ITreeElement treeElement = (ITreeElement) object;
						statusLineManager.setMessage(NLS.bind(
								Messages.EcoreBrowser_singleObjectSelected, treeElement.getText()));
					}
					break;
				default:
					statusLineManager.setMessage(NLS.bind(
							Messages.EcoreBrowser_multiObjectSelected,
							Integer.toString(collection.size())));
					break;
				}
			} else {
				statusLineManager.setMessage(""); //$NON-NLS-1$
			}
		}
	}

	/**
	 * This implements {@link org.eclipse.jface.action.IMenuListener} to help
	 * fill the context menus with contributions from the Edit menu.
	 */
	public void menuAboutToShow(final IMenuManager menuManager) {
		((IMenuListener) getEditorSite().getActionBarContributor()).menuAboutToShow(menuManager);
	}

	public BrowserActionBarContributor getActionBarContributor() {
		return (BrowserActionBarContributor) getEditorSite().getActionBarContributor();
	}

	public IActionBars getActionBars() {
		return getActionBarContributor().getActionBars();
	}

	/** Clean up */
	@Override
	public void dispose() {
		stopOpeningModel();

		this.disposing = true;
		ResourcesPlugin.getWorkspace().removeResourceChangeListener(this.resourceChangeListener);
		getSite().getPage().removePartListener(this.partListener);

		this.adapterFactoryWithRegistry.dispose();
		this.sashForm.dispose();

		if (getActionBarContributor().getActiveEditor() == this) {
			getActionBarContributor().setActiveEditor(null);
		}

		if (this.propertySheetPage != null) {
			this.propertySheetPage.dispose();
		}

		if (this.treeViewer != null && this.selectionChangedListener != null) {
			this.treeViewer.removeSelectionChangedListener(this.selectionChangedListener);
			this.selectionChangedListener = null;
		}

		// dispose fonts
		this.browserConfiguration.getAppearanceConfiguration().setCustomFont(null);
		this.browserConfiguration.getAppearanceConfiguration().setCustomItalicFont(null);

		// avoid leaking editor
		this.browserConfiguration.dispose();

		JFaceResources.getFontRegistry().removeListener(this.fontChangeListener);

		this.customTreePainter.dispose();
		// dispose the customization engine, which removes listeners too
		this.browserConfiguration.getAppearanceConfiguration().getCustomizationEngine().dispose();
		this.fCustomizationEngineChangeListener = null;

		FacetSetCatalog.getSingleton().removeChangeListener(this.fFacetsChangeListener);

		this.fFormToolkit.dispose();

		// avoid memory leak for EMF registry resources since a new
		// adapter is created each time the same resource is opened
		// in a different editor
		Set<Resource> browsedResources = this.browserConfiguration.getBrowsedResources();
		if (browsedResources != null) {
			for (Resource resource : browsedResources) {
				ListIterator<Adapter> listIterator = resource.eAdapters().listIterator();
				while (listIterator.hasNext()) {
					Adapter adapter = listIterator.next();
					if (adapter instanceof MetaclassInstancesAdapterWithFacet) {
						MetaclassInstancesAdapterWithFacet adapterWithFacet = (MetaclassInstancesAdapterWithFacet) adapter;
						if (adapterWithFacet.getFacetContext() == getBrowserConfiguration()
								.getAppearanceConfiguration().getFacetContext()) {
							listIterator.remove();
						}
					}
				}
			}
		}
		// let the FacetContext be GCed
		MetaclassInstancesAdapterFactoryWithFacet.getInstance().setFacetContext(null);

		// if (!isReadOnly()) {
		// // unload all resources
		// final EList<Resource> resources = this.fResourceSet.getResources();
		// final Job cleanupJob = new
		// Job(Messages.EcoreBrowser_jobName_UnloadResources) {
		// @Override
		// protected IStatus run(final IProgressMonitor monitor) {
		// for (final Resource resource : resources) {
		// resource.unload();
		// }
		// return Status.OK_STATUS;
		// }
		// };
		// cleanupJob.setPriority(Job.DECORATE);
		// cleanupJob.setSystem(true);
		// cleanupJob.schedule();
		// }

		super.dispose();
	}

	@SuppressWarnings("deprecation")
	private void stopOpeningModel() {
		if (this.openModelJob != null && this.openModelJob.getState() == Job.RUNNING) {
			this.openModelJob.cancel();
			Thread thread = this.openModelJob.getThread();
			if (thread != null) {
				thread.stop();
			}
		}
	}

	/** Open the selected element in the list of elements of the same metaclass */
	public void browse() {
		final ISelection selection = getEditorSelection();
		if (selection instanceof ITreeSelection) {
			final ITreeSelection treeSelection = (ITreeSelection) selection;
			final Object selectedElement = treeSelection.getFirstElement();
			if (selectedElement instanceof ModelElementItem) {
				final ModelElementItem modelElementItem = (ModelElementItem) selectedElement;
				browseTo(modelElementItem);
			}
		}
	}

	/** Open the given element in the list of elements of the same metaclass */
	public void browseTo(final ModelElementItem modelElementItem) {
		final EObject modelElement = modelElementItem.getEObject();
		browseTo(modelElement);
	}

	/** Open the given element in the list of elements of the same metaclass */
	public void browseTo(final EObject modelElement) {
		browseTo(modelElement, modelElement.eClass());
	}

	/**
	 * Open the given element in the list of elements of the given metaclass
	 * (which can be a Facet).
	 */
	public void browseTo(final EObject modelElement, final EClass eClass) {
		markNavigationLocation();
		// Select the metaclass in the metaclass list viewer
		this.metaclassViewer.selectMetaclass(eClass);

		TreePath treePath = findTreePathForElement(modelElement);
		if (treePath != null) {
			// deselect any previously selected elements
			this.treeViewer.setSelection(null);
			this.treeViewer.setSelection(new TreeSelection(treePath), true);
			if (this.treeViewer.getSelection().isEmpty()) {
				delayedBrowseTo(modelElement);
			} else {
				markNavigationLocation();
			}
		} else {
			delayedBrowseTo(modelElement);
		}
	}

	/**
	 * delayed because the browser doesn't always update synchronously
	 * (temporary "loading..." nodes)
	 */
	private void delayedBrowseTo(final EObject modelElement) {
		Listener refreshListener = new Listener() {
			public void handleEvent(final Event event) {
				removeRefreshListener(this);
				Display.getDefault().asyncExec(new Runnable() {
					public void run() {
						TreePath treePath2 = findTreePathForElement(modelElement);
						EcoreBrowser.this.treeViewer.setSelection(null);
						EcoreBrowser.this.treeViewer.setSelection(new TreeSelection(treePath2),
								true);
						markNavigationLocation();
					}
				});
			}
		};
		addRefreshListener(refreshListener);
	}

	public boolean browseToByURI(final String uriFragment) {
		EObject eObject = EMFUtil.findElementByURI(uriFragment, this.fResourceSet);
		if (eObject != null) {
			browseTo(eObject);
			return true;
		}
		return false;
	}

	/**
	 * Finds the path of the given element in the tree viewer. The element is
	 * looked for at the root and under BigListItemProviders in the case the
	 * elements are split.
	 *
	 * @return the path or <code>null</code> if the element was not found
	 */
	private TreePath findTreePathForElement(final EObject eObject) {
		final Object input = this.treeViewer.getInput();
		if (input instanceof MetaclassList) {
			final MetaclassList metaclassListItemProvider = (MetaclassList) input;
			final Collection<?> elements = metaclassListItemProvider.getElements();
			for (final Object element : elements) {
				// if the elements are split
				if (element instanceof BigListItem) {
					final BigListItem bigListItemProvider = (BigListItem) element;
					final Collection<?> subElements = bigListItemProvider.getChildren();
					for (final Object subElement : subElements) {
						if (subElement instanceof ModelElementItem) {
							final ModelElementItem other = (ModelElementItem) subElement;
							if (other.getEObject().equals(eObject)) {
								return new TreePath(new Object[] { subElement });
							}
						}
					}
				}

				if (element instanceof ModelElementItem) {
					final ModelElementItem other = (ModelElementItem) element;
					if (other.getEObject().equals(eObject)) {
						return new TreePath(new Object[] { element });
					}
				}
			}
		}
		return null;
	}

	/** Implements {@link INavigationLocationProvider} */
	public INavigationLocation createEmptyNavigationLocation() {
		return new BrowserNavigationLocation(this);
	}

	/**
	 * Implements {@link INavigationLocationProvider}. Create a location that
	 * can be navigated back to, using the "back" button
	 */
	public INavigationLocation createNavigationLocation() {
		// navigation to the first element of the selection
		final EClass firstSelectedMetaclass = this.metaclassViewer.getFirstSelectedMetaclass();
		return new BrowserNavigationLocation(this, firstSelectedMetaclass,
				(ITreeSelection) this.treeViewer.getSelection());
	}

	/** Mark a location that can be navigated back to, using the "back" button */
	protected void markNavigationLocation() {
		getSite().getPage().getNavigationHistory().markLocation(this);
	}

	/**
	 * Restore a location (used for implementing history).
	 *
	 * @param eClass
	 *            the metaclass viewer's selection
	 * @param selection
	 *            the tree viewer's selection
	 */
	public void restoreLocation(final EClass eClass, final ITreeSelection selection) {
		this.metaclassViewer.selectMetaclass(eClass);
		this.treeViewer.setSelection(selection);
	}

	private final List<Listener> refreshListeners = new ArrayList<Listener>();

	public void addRefreshListener(final Listener refreshListener) {
		if (!this.refreshListeners.contains(refreshListener)) {
			this.refreshListeners.add(refreshListener);
		}
	}

	public void removeRefreshListener(final Listener refreshListener) {
		this.refreshListeners.remove(refreshListener);
	}

	public void notifyRefresh() {
		for (Listener listener : new ArrayList<Listener>(this.refreshListeners)) {
			listener.handleEvent(new Event());
		}
	}

	/**
	 * Refresh the editor
	 *
	 * @param metaclassViewerToo
	 *            whether the metaclass view must be refreshed too, or only the
	 *            tree viewer
	 */
	public void refreshDelayed(final boolean metaclassViewerToo) {
		if (this.disposing) {
			return;
		}
		if (this.refreshJob == null) {
			this.refreshJob = new Job(Messages.EcoreBrowser_refreshingModelViewers) {
				@Override
				protected IStatus run(final IProgressMonitor monitor) {
					Display.getDefault().syncExec(new Runnable() {
						public void run() {
							internalRefreshTree();
							if (metaclassViewerToo) {
								getMetaclassViewer().refresh();
							}
							notifyRefresh();
						}
					});
					return Status.OK_STATUS;
				}
			};
		} else {
			/*
			 * If refreshTreeDelayed is called again before the job delay
			 * passed, then cancel the job and re-schedule a new one.
			 */
			this.refreshJob.cancel();
		}
		// we don't want to keep refreshing while computing children,
		// because it slows down the computation
		if (this.fContentProvider.isComputing()) {
			final int delay = 100;
			this.refreshJob.setPriority(Job.DECORATE);
			this.refreshJob.schedule(delay);
		} else {
			this.refreshJob.setPriority(Job.INTERACTIVE);
			this.refreshJob.schedule();
		}
	}

	public void clearInstancesCache() {
		AppearanceConfiguration appearanceConfiguration = this.browserConfiguration
				.getAppearanceConfiguration();
		MetaclassInstancesAdapterFactoryWithFacet.getInstance().setFacetContext(
				appearanceConfiguration.getFacetContext());
		Set<Resource> browsedResources = this.browserConfiguration.getBrowsedResources();
		if (browsedResources != null) {
			for (Resource resource : browsedResources) {
				MetaclassInstances instances = (MetaclassInstances) MetaclassInstancesAdapterFactoryWithFacet
						.getInstance().adapt(resource, MetaclassInstances.class);
				instances.clearCache();
			}
		}
	}

	private void internalRefreshTree() {
		if (!this.treeViewer.getTree().isDisposed()) {
			try {
				this.treeViewer.getTree().setRedraw(false);
				this.treeViewer.refresh();
			} finally {
				this.treeViewer.getTree().setRedraw(true);
			}
		}
	}

	public BrowserConfiguration getBrowserConfiguration() {
		return this.browserConfiguration;
	}

	private void openPropertiesView() {
		try {
			getEditorSite().getPage().showView(EcoreBrowser.PROPERTY_VIEW_ID);
		} catch (final PartInitException e) {
			MoDiscoBrowserPlugin.logException(e);
		}
	}

	public ResourceSet getResourceSet() {
		return this.fResourceSet;
		// return getEditingDomain().getResourceSet();
	}

	public void loadCustomizations(final Collection<MetamodelView> customizationsToLoad) {
		final CustomizationEngine customizationEngine = this.browserConfiguration
				.getAppearanceConfiguration().getCustomizationEngine();

		if (this.fCustomizationEngineChangeListener == null) {
			this.fCustomizationEngineChangeListener = new ChangeListener() {
				public void changed() {
					Display.getDefault().asyncExec(new Runnable() {
						public void run() {
							refreshDelayed(true);
						}
					});
				}
			};
			customizationEngine.addChangeListener(this.fCustomizationEngineChangeListener);
		}

		customizationEngine.clear();
		for (final MetamodelView customizationToLoad : customizationsToLoad) {
			customizationEngine.registerCustomization(customizationToLoad);
		}
		customizationEngine.loadCustomizations();
	}

	private void loadDefaultCustomizations() {
		Collection<MetamodelView> customizations = CustomizationsCatalog.filterForMetamodel(
				CustomizationsCatalog.getInstance().getRegistryDefaultCustomizations(),
				getReferencedEPackages());
		if (customizations.size() > 0) {
			loadCustomizations(customizations);
		}
	}

	/** used by unit tests */
	protected TreeToolBar getInstancesToolBar() {
		return this.instancesToolBar;
	}

	protected void reloadOnFacetChange() {
		if (this.fFacetsChangeListener == null) {
			this.fFacetsChangeListener = new ModiscoCatalogChangeListener() {
				private void changed() {
					if (!EcoreBrowser.this.loaded) {
						return;
					}
					Job reloadFacetsJob = new Job(Messages.EcoreBrowser_ReloadingFacets) {
						@Override
						protected IStatus run(final IProgressMonitor monitor) {
							// reloading Facets by name, since the elements are
							// different after a FacetSet model reload
							List<String> facetsToReload = new ArrayList<String>();
							Collection<Facet> loadedFacets = getBrowserConfiguration()
									.getAppearanceConfiguration().getLoadedFacets();
							for (Facet facet : loadedFacets) {
								FacetSet facetSet = facet.getFacetSet();
								facetsToReload.add(facetSet.getName() + "#" + facet.getName()); //$NON-NLS-1$
							}
							getBrowserConfiguration().getAppearanceConfiguration().clearFacets();

							Collection<FacetSet> allFacetSets = FacetSetCatalog.getSingleton()
									.getAllFacetSets();

							for (FacetSet facetSet : allFacetSets) {
								EList<Facet> facets = facetSet.getFacets();
								for (Facet facet : facets) {
									for (String fullname : facetsToReload) {
										if (fullname.equals(facetSet.getName() + "#" //$NON-NLS-1$
												+ facet.getName())) {
											getBrowserConfiguration().getAppearanceConfiguration()
													.loadFacet(facet);
											break;
										}
									}
								}
							}
							// for modified facets
							getBrowserConfiguration().getInstancesForMetaclasses()
									.buildDerivationTree();
							return Status.OK_STATUS;
						}
					};
					reloadFacetsJob.setPriority(Job.DECORATE);
					reloadFacetsJob.schedule();
				}

				public void removed(final IFile file) {
					changed();
				}

				public void changed(final EObject eObject, final IFile file) {
					changed();
				}

				public void added(final EObject eObject, final IFile file) {
					changed();
				}
			};
			FacetSetCatalog.getSingleton().addChangeListener(this.fFacetsChangeListener);
		}
	}

	public void modelChanged() {
		getBrowserConfiguration().getAppearanceConfiguration().touch();
		refreshDelayed(true);
	}

	/**
	 * Handles activation of the editor or it's associated views.
	 */
	protected void handleActivate() {
		// Recompute the read only state.
		if (this.editingDomain.getResourceToReadOnlyMap() != null) {
			this.editingDomain.getResourceToReadOnlyMap().clear();

			// Refresh any actions that may become enabled or disabled.
			setSelection(getEditorSelection());
		}

		if (!this.removedResources.isEmpty()) {
			if (handleDirtyConflict()) {
				getSite().getPage().closeEditor(EcoreBrowser.this, false);
			} else {
				this.removedResources.clear();
				this.changedResources.clear();
				this.savedResources.clear();
			}
		} else if (!this.changedResources.isEmpty()) {
			this.changedResources.removeAll(this.savedResources);
			handleChangedResources();
			this.changedResources.clear();
			this.savedResources.clear();
		}
	}

	/**
	 * Shows a dialog that asks if conflicting changes should be discarded.
	 */
	protected boolean handleDirtyConflict() {
		return MessageDialog.openQuestion(getSite().getShell(), Messages.UI_FileConflict_label,
				Messages.WARN_FileConflict);
	}

	/**
	 * Handles what to do with changed resources on activation.
	 */
	protected void handleChangedResources() {
		if (!this.changedResources.isEmpty() && (!isDirty() || handleDirtyConflict())) {
			if (isDirty()) {
				this.changedResources.addAll(this.editingDomain.getResourceSet().getResources());
			}
			this.editingDomain.getCommandStack().flush();

			this.updateProblemIndication = false;
			for (Resource resource : this.changedResources) {
				if (resource.isLoaded()) {
					resource.unload();
					try {
						resource.load(Collections.EMPTY_MAP);
					} catch (IOException e) {
						final URI uri = resource.getURI();
						final String uristr = uri.toString();
						final String logMsg = String.format(
								"The MoDisco browser failed to reload the resource %s.", //$NON-NLS-1$
								uristr);
						Logger.logError(
								e, logMsg , MoDiscoBrowserPlugin.getPlugin());
						final String userMsg = String.format(
								"%s, cf. %s", //$NON-NLS-1$
								Messages.EcoreBrowser_errorLoadingResource,
								uristr);
						DialogUtils.openErrorDialog(getSite().getShell(), e,
								userMsg);
						if (!this.resourceToDiagnosticMap.containsKey(resource)) {
							this.resourceToDiagnosticMap.put(resource,
									analyzeResourceProblems(resource, e));
						}
					}
				}
			}

			if (AdapterFactoryEditingDomain.isStale(this.editorSelection)) {
				setSelection(StructuredSelection.EMPTY);
			}

			this.updateProblemIndication = true;
			updateProblemIndication();
		}
	}

	/**
	 * Updates the problems indication with the information described in the
	 * specified diagnostic.
	 */
	protected void updateProblemIndication() {
		if (this.updateProblemIndication) {
			BasicDiagnostic diagnostic = new BasicDiagnostic(Diagnostic.OK,
					MoDiscoBrowserPlugin.PLUGIN_ID, 0, null,
					new Object[] { this.editingDomain.getResourceSet() });
			int nWarnings = 0;
			int nErrors = 0;
			int nInfo = 0;

			for (Diagnostic childDiagnostic : this.resourceToDiagnosticMap.values()) {
				if (childDiagnostic.getSeverity() != Diagnostic.OK) {
					diagnostic.add(childDiagnostic);
					if (childDiagnostic.getSeverity() == Diagnostic.WARNING) {
						nWarnings++;
					} else if (childDiagnostic.getSeverity() == Diagnostic.ERROR) {
						nErrors++;
					} else if (childDiagnostic.getSeverity() == Diagnostic.INFO) {
						nInfo++;
					}
				}
			}

			StringBuilder builder = new StringBuilder();

			if (nErrors == 1) {
				builder.append(NLS.bind(Messages.EcoreBrowser_error, nErrors));
			} else if (nErrors > 1) {
				builder.append(NLS.bind(Messages.EcoreBrowser_errors, nErrors));
			}

			if (nWarnings == 1) {
				if (builder.length() > 0) {
					builder.append(Messages.EcoreBrowser_separator);
				}
				builder.append(NLS.bind(Messages.EcoreBrowser_warning, nWarnings));
			} else if (nWarnings > 1) {
				if (builder.length() > 0) {
					builder.append(Messages.EcoreBrowser_separator);
				}
				builder.append(NLS.bind(Messages.EcoreBrowser_warnings, nWarnings));
			}

			if (nInfo == 1) {
				if (builder.length() > 0) {
					builder.append(Messages.EcoreBrowser_separator);
				}
				builder.append(NLS.bind(Messages.EcoreBrowser_info, nInfo));
			} else if (nInfo > 1) {
				if (builder.length() > 0) {
					builder.append(Messages.EcoreBrowser_separator);
				}
				builder.append(NLS.bind(Messages.EcoreBrowser_infos, nInfo));
			}

			if (!this.errorsButton.isDisposed()) {
				if (builder.length() > 0) {
					this.errorsButton.setText(builder.toString());
					this.errorsButton.setVisible(true);
				} else {
					this.errorsButton.setVisible(false);
				}

				final GridData errorsButtonGridData = new GridData();
				if (this.errorsButton.isVisible()) {
					this.errorsButton.setSize(this.errorsButton.computeSize(SWT.DEFAULT,
							SWT.DEFAULT));
					errorsButtonGridData.exclude = false;
				} else {
					errorsButtonGridData.exclude = true;
				}
				this.errorsButton.setLayoutData(errorsButtonGridData);
				this.errorsButton.getParent().layout();
			}

			this.fDiagnostic = diagnostic;

			if (this.markerHelper.hasMarkers(this.editingDomain.getResourceSet())) {
				this.markerHelper.deleteMarkers(this.editingDomain.getResourceSet());
				if (diagnostic.getSeverity() != Diagnostic.OK) {
					try {
						this.markerHelper.createMarkers(diagnostic);
					} catch (CoreException exception) {
						MoDiscoBrowserPlugin.getPlugin().log(exception);
					}
				}
			}
		}
	}

	/**
	 * Returns a diagnostic describing the errors and warnings listed in the
	 * resource and the specified exception (if any).
	 */
	public Diagnostic analyzeResourceProblems(final Resource resource, final Exception exception) {
		if (!resource.getErrors().isEmpty() || !resource.getWarnings().isEmpty()) {
			Object errorData;
			if (exception == null) {
				errorData = resource;
			} else {
				errorData = exception;
			}
			BasicDiagnostic basicDiagnostic = new BasicDiagnostic(Diagnostic.ERROR,
					MoDiscoBrowserPlugin.PLUGIN_ID, 0, NLS.bind(Messages.UI_ErrorFile_message,
							resource.getURI()), new Object[] { errorData });
			basicDiagnostic.merge(EcoreUtil.computeDiagnostic(resource, true));
			return basicDiagnostic;
		} else if (exception != null) {
			return new BasicDiagnostic(Diagnostic.ERROR, MoDiscoBrowserPlugin.PLUGIN_ID, 0,
					NLS.bind(Messages.UI_ErrorFile_message, resource.getURI()),
					new Object[] { exception });
		} else {
			return Diagnostic.OK_INSTANCE;
		}
	}

	class BrowserAdapterFactory extends ComposedAdapterFactory implements IEditingDomainProvider {
		public BrowserAdapterFactory(final ComposedAdapterFactory.Descriptor.Registry registry) {
			super(registry);
		}

		public EditingDomain getEditingDomain() {
			return EcoreBrowser.this.getEditingDomain();
		}
	}

	/**
	 * This sets up the editing domain for the model editor
	 */
	protected void initializeEditingDomain() {
		if (this.fResourceSet == null) {
			initializeEditingDomain(new ResourceSetImpl());
		}
	}

	protected void initializeEditingDomain(final ResourceSet resourceSet) {
			// Create an adapter factory that yields item providers.
			this.adapterFactoryWithRegistry = new BrowserAdapterFactory(
					ComposedAdapterFactory.Descriptor.Registry.INSTANCE);
			this.adapterFactoryWithRegistry
					.addAdapterFactory(new ResourceItemProviderAdapterFactory());
			this.adapterFactoryWithRegistry
					.addAdapterFactory(new ReflectiveItemProviderAdapterFactory());
			final CommandStack commandStack = createCommandStack();
			// Create the editing domain with a special command stack.
			final BrowserEditingDomain newEditingDomain = new BrowserEditingDomain(
					this.adapterFactoryWithRegistry, commandStack, resourceSet, this);
			setEditingDomain(newEditingDomain);
	}

	private CommandStack createCommandStack() {
		// Create the command stack that will notify this editor as commands
		// are executed.
		CommandStack commandStack;
		if (isReadOnly()) {
			commandStack = new ReadOnlyCommandStack();
		} else {
			commandStack = new BasicCommandStack();
		}
		commandStack.addCommandStackListener(new CommandStackListener() {
			public void commandStackChanged(final EventObject event) {
				getParentComposite().getDisplay().asyncExec(new Runnable() {
					public void run() {
						firePropertyChange(IEditorPart.PROP_DIRTY);
						// Try to select the affected objects.
						final Command mostRecentCommand = ((CommandStack) event.getSource())
								.getMostRecentCommand();
						if (mostRecentCommand != null) {
							// asyncExec is to make it happen after the
							// refresh
							Display.getDefault().asyncExec(new Runnable() {
								public void run() {
									try {
										// avoid the view jumping around as
										// the selection changes
										// several times
										EcoreBrowser.this.treeViewer.getTree().setRedraw(false);
										selectAffectedElements(mostRecentCommand);
									} finally {
										EcoreBrowser.this.treeViewer.getTree().setRedraw(true);
									}
								}
							});
						}
						IPropertySheetPage page = EcoreBrowser.this.getPropertySheetPage();
						if (page != null && page.getControl() != null
								&& !page.getControl().isDisposed()) {
							if (page instanceof PropertySheetPage) {
								PropertySheetPage propertyPage = (PropertySheetPage) page;
								propertyPage.refresh();
							} else if (page instanceof TabbedPropertySheetPage) {
								TabbedPropertySheetPage tabbedPropertyPage = (TabbedPropertySheetPage) page;
								if (tabbedPropertyPage.getCurrentTab() != null) {
									tabbedPropertyPage.refresh();
								}
							}
						}
					}
				});
			}
		});
		return commandStack;
	}

	/** added for integration into Papyrus */
	protected void setEditingDomain(final AdapterFactoryEditingDomain editingDomain) {
		this.editingDomain = editingDomain;
	}

	/** This is here for the listener to be able to call it. */
	@Override
	protected void firePropertyChange(final int action) {
		super.firePropertyChange(action);
	}

	/**
	 * Implements {@link IGotoMarker}. Select the EObject corresponding to the
	 * given marker
	 */
	public void gotoMarker(final IMarker marker) {
		try {
			if (marker.getType().equals(EValidator.MARKER)) {
				String uriAttribute = marker.getAttribute(EValidator.URI_ATTRIBUTE, null);
				if (uriAttribute != null) {
					URI uri = URI.createURI(uriAttribute);
					EObject eObject = this.fResourceSet.getEObject(uri, true);
					if (eObject != null) {
						browseTo(eObject);
					}
				}
			}
		} catch (Exception e) {
			MoDiscoLogger.logError(e, MoDiscoBrowserPlugin.getPlugin());
		}
	}

	public Composite getParentComposite() {
		return this.parentComposite;
	}

	public EditingDomain getEditingDomain() {
		return this.editingDomain;
	}

	public Collection<Resource> getSavedResources() {
		return this.savedResources;
	}

	public Collection<Resource> getChangedResources() {
		return this.changedResources;
	}

	public Collection<Resource> getRemovedResources() {
		return this.removedResources;
	}

	/**
	 * If <code>true</code>, prevent modification or save. For example, if the
	 * resource being viewed comes from the package registry, it must not be
	 * saved.
	 */
	public boolean isReadOnly() {
		return !(getEditorInput() instanceof FileEditorInput);
	}

	public TreeViewer getTreeViewer() {
		return this.treeViewer;
	}

	public void setStyleSashForm(final int styleSashForm) {
		this.styleSashForm = styleSashForm;
	}

	protected void selectAffectedElements(final Command command) {
		if (command instanceof DragAndDropOnLinkCommand) {
			DragAndDropOnLinkCommand dragAndDropOnLinkCommand = (DragAndDropOnLinkCommand) command;
			Command dropCommand = dragAndDropOnLinkCommand.getDropCommand();
			selectAffectedElements(dropCommand, null, dragAndDropOnLinkCommand.getLinkItem());
		} else if (command instanceof DragAndDropOnModelElementCommand) {
			DragAndDropOnModelElementCommand dragAndDropOnModelElementCommand = (DragAndDropOnModelElementCommand) command;
			Command dropCommand = dragAndDropOnModelElementCommand.getDropCommand();
			selectAffectedElements(dropCommand,
					dragAndDropOnModelElementCommand.getModelElementItem(), null);
		} else if (this.editingDomain instanceof BrowserEditingDomain) {
			BrowserEditingDomain browserEditingDomain = (BrowserEditingDomain) this.editingDomain;
			Object selectedElementForCommand = browserEditingDomain
					.getEditorSelectionForCommand(command);
			if (selectedElementForCommand instanceof ModelElementItem) {
				ModelElementItem selectedModelElementItem = (ModelElementItem) selectedElementForCommand;
				selectAffectedElements(command, selectedModelElementItem, null);
			} else if (selectedElementForCommand instanceof LinkItem) {
				LinkItem linkItem = (LinkItem) selectedElementForCommand;
				selectAffectedElements(command, (ModelElementItem) linkItem.getTreeParent(),
						linkItem);
			}
		}
	}

	private void selectAffectedElements(final Command command,
			final ModelElementItem contextModelElementItem, final LinkItem contextLinkItem) {
		if (command instanceof AddCommand) {
			AddCommand addCommand = (AddCommand) command;
			if (contextLinkItem != null) {
				boolean result = selectElements(contextLinkItem, addCommand.getCollection());
				if (!result) {
					setSelection(Collections.singletonList(contextLinkItem), true);
					this.treeViewer.expandToLevel(contextLinkItem, 1);
				}
			} else if (contextModelElementItem != null) {
				selectElements(contextModelElementItem, addCommand.getFeature(),
						addCommand.getCollection());
			} else {
				selectElements(addCommand.getOwner(), addCommand.getFeature(),
						addCommand.getCollection());
			}
		} else if (command instanceof SetCommand) {
			SetCommand setCommand = (SetCommand) command;
			if (contextModelElementItem != null) {
				boolean result = selectElements(contextModelElementItem, setCommand.getFeature(),
						Collections.singleton(setCommand.getValue()));
				if (!result) {
					ITreeElement treeParent = contextModelElementItem.getTreeParent();
					setSelection(Collections.singletonList(treeParent), true);
					this.treeViewer.expandToLevel(treeParent, 1);
				}
			} else {
				selectElements(setCommand.getOwner(), setCommand.getFeature(),
						Collections.singleton(setCommand.getValue()));
			}
		} else if (command instanceof CreateChildCommand) {
			CreateChildCommand createChildCommand = (CreateChildCommand) command;
			Command command2 = createChildCommand.getCommand();
			selectAffectedElements(command2, contextModelElementItem, contextLinkItem);
		} else if (command instanceof DeleteCommand) {
			DeleteCommand deleteCommand = (DeleteCommand) command;
			List<Command> commandList = deleteCommand.getCommandList();
			if (commandList.size() > 0) {
				selectAffectedElements(commandList.get(0), contextModelElementItem, contextLinkItem);
			}
		} else if (command instanceof RemoveCommand) {
			RemoveCommand removeCommand = (RemoveCommand) command;
			LinkItem linkItem = null;
			if (contextModelElementItem != null) {
				ITreeElement parent = contextModelElementItem.getTreeParent();
				if (parent instanceof LinkItem) {
					linkItem = (LinkItem) parent;
				} else if (parent instanceof ModelElementItem) {
					// ↑ possible with "collapse" customization
					ModelElementItem modelElementItem = (ModelElementItem) parent;
					setSelection(Collections.singletonList(modelElementItem), true);
					return;
				}
			}
			if (linkItem == null) {
				browseTo(removeCommand.getOwner());
				ModelElementItem modelElementItem = getSelectedModelElementItem();
				linkItem = getLink(modelElementItem, removeCommand.getFeature());
			}
			if (linkItem != null) {
				this.treeViewer.expandToLevel(linkItem, 1);
				setSelection(Collections.singletonList(linkItem), true);
			}
		} else if (command instanceof CompoundCommand) {
			CompoundCommand compoundCommand = (CompoundCommand) command;
			List<Command> commandList = compoundCommand.getCommandList();
			if (commandList.size() > 0) {
				selectAffectedElements(commandList.get(commandList.size() - 1),
						contextModelElementItem, contextLinkItem);
			}
		} else if (command instanceof CommandWrapper) {
			CommandWrapper commandWrapper = (CommandWrapper) command;
			selectAffectedElements(commandWrapper.getCommand(), contextModelElementItem,
					contextLinkItem);
		}

		// PasteFromClipboardCommand : deliberately not handled, to let the user
		// paste multiple times, without having to reselect the parent element
		// each time
	}

	protected void selectElements(final EObject owner, final EStructuralFeature feature,
			final Collection<?> collection) {
		// TreePath treePath = findTreePathForElement(owner);
		// Object lastSegment = treePath.getLastSegment();
		browseTo(owner);
		ModelElementItem modelElementItem = getSelectedModelElementItem();
		selectElements(modelElementItem, feature, collection);
	}

	protected boolean selectElements(final ModelElementItem modelElementItem,
			final EStructuralFeature feature, final Collection<?> collection) {
		if (modelElementItem != null) {
			LinkItem linkItem = getLink(modelElementItem, feature);
			if (linkItem != null) {
				boolean result = selectElements(linkItem, collection);
				if (!result) {
					setSelection(Collections.singletonList(linkItem), true);
					this.treeViewer.expandToLevel(linkItem, 1);
				}
				return true;
			}
		}
		return false;
	}

	protected boolean selectElements(final LinkItem linkItem, final Collection<?> collection) {
		List<ModelElementItem> elementItems = new ArrayList<ModelElementItem>();
		for (Object object : collection) {
			if (object instanceof EObject) {
				EObject eObject = (EObject) object;
				ModelElementItem elementItem = getElement(linkItem, eObject);
				if (elementItem != null) {
					elementItems.add(elementItem);
				}
			}
		}
		if (!elementItems.isEmpty()) {
			setSelection(elementItems, true);
			return true;
		}
		return false;
	}

	protected void setSelection(final List<? extends ITreeElement> treeElements,
			final boolean reveal) {
		List<TreePath> treePaths = new ArrayList<TreePath>();
		for (ITreeElement treeElement : treeElements) {
			List<ITreeElement> segments = new ArrayList<ITreeElement>();
			ITreeElement current = treeElement;
			while (current != null) {
				segments.add(current);
				current = current.getTreeParent();
			}

			if (segments.size() > 0) {
				ITreeElement[] segmentsArray = new ITreeElement[segments.size()];
				for (int i = 0; i < segments.size(); i++) {
					segmentsArray[i] = segments.get(segments.size() - i - 1);
				}
				treePaths.add(new TreePath(segmentsArray));
			}
		}

		if (!treePaths.isEmpty()) {
			this.treeViewer.setSelection(
					new TreeSelection(treePaths.toArray(new TreePath[treePaths.size()])), reveal);
		}
	}

	protected LinkItem getLink(final ModelElementItem selectedModelElementItem,
			final EStructuralFeature feature) {
		ITreeContentProvider contentProvider = (ITreeContentProvider) this.treeViewer
				.getContentProvider();
		Object[] children = contentProvider.getChildren(selectedModelElementItem);
		for (Object child : children) {
			if (child instanceof LinkItem) {
				LinkItem linkItem = (LinkItem) child;
				if (linkItem.getReference() == feature) {
					return linkItem;
				}
			}
		}
		return null;
	}

	protected ModelElementItem getElement(final LinkItem linkItem, final EObject eObject) {
		ITreeContentProvider contentProvider = (ITreeContentProvider) this.treeViewer
				.getContentProvider();
		Object[] children = contentProvider.getChildren(linkItem);
		for (Object child : children) {
			if (child instanceof ModelElementItem) {
				ModelElementItem modelElementItem = (ModelElementItem) child;
				if (EcoreUtil.getURI(modelElementItem.getEObject()).equals(
						EcoreUtil.getURI(eObject))) {
					return modelElementItem;
				}
			}
		}
		return null;
	}

	protected ModelElementItem getSelectedModelElementItem() {
		ITreeSelection selection = (ITreeSelection) this.treeViewer.getSelection();
		Object firstElement = selection.getFirstElement();
		if (firstElement instanceof ModelElementItemEx) {
			ModelElementItemEx modelElementItem = (ModelElementItemEx) firstElement;
			return modelElementItem;
		}
		return null;
	}

	public void doWhenLoaded(final Runnable runnable) {
		if (this.loaded) {
			Display.getDefault().syncExec(runnable);
		} else {
			this.doWhenLoaded.add(runnable);
		}
	}

	/**
	 * Replace the default context by a dummy one when the given widget is
	 * focused. The dummy context is used to redefine the "Ctrl+X", "Ctrl+C" and
	 * "Ctrl+V" key bindings to a command which does nothing. This is useful to
	 * prevent these commands associated to the existing context from being
	 * executed when this widget is focused.
	 */
	private void fixClipboardCommands(final Control control) {
		final IWorkbench workbench = PlatformUI.getWorkbench();
		final IContextService contextService = (IContextService) workbench
				.getService(IContextService.class);

		control.addFocusListener(new FocusListener() {
			private IContextActivation contextActivation = null;

			public void focusGained(final FocusEvent event) {
				this.contextActivation = contextService
						.activateContext("org.eclipse.modisco.infra.browser.dummyContext"); //$NON-NLS-1$
			}

			public void focusLost(final FocusEvent event) {
				if (this.contextActivation != null) {
					contextService.deactivateContext(this.contextActivation);
				}
			}
		});
	}

	/**
	 * * Adapter used to update the problem indication when resources are
	 * demanded loaded.
	 */
	private final EContentAdapter problemIndicationAdapter = new EContentAdapter() {
		@Override
		public void notifyChanged(final Notification notification) {
			if (notification.getNotifier() instanceof Resource) {
				switch (notification.getFeatureID(Resource.class)) {
				case Resource.RESOURCE__IS_LOADED:
				case Resource.RESOURCE__ERRORS:
				case Resource.RESOURCE__WARNINGS:
					Resource resource = (Resource) notification.getNotifier();
					Diagnostic diagnostic = analyzeResourceProblems(resource, null);
					if (diagnostic.getSeverity() != Diagnostic.OK) {
						EcoreBrowser.this.resourceToDiagnosticMap.put(resource, diagnostic);
					} else {
						EcoreBrowser.this.resourceToDiagnosticMap.remove(resource);
					}

					if (EcoreBrowser.this.updateProblemIndication) {
						getSite().getShell().getDisplay().asyncExec(new Runnable() {
							public void run() {
								updateProblemIndication();
							}
						});
					}
					break;
				default:
				}
			} else {
				super.notifyChanged(notification);
			}
		}

		@Override
		protected void setTarget(final Resource theTarget) {
			basicSetTarget(theTarget);
		}

		@Override
		protected void unsetTarget(final Resource theTarget) {
			basicUnsetTarget(theTarget);
		}
	};

	/**
	 * Refreshes the selection (checked) state of actions in the Browser's
	 * toolbar.
	 */
	public void refreshToolbar() {
		this.instancesToolBar.refresh();
	}

	protected Text getSearchBox() {
		return this.searchBox;
	}

	protected void setSearchBox(final Text searchBox) {
		this.searchBox = searchBox;
	}

	public IWorkbenchSiteProgressService getProgressService() {
		IWorkbenchSiteProgressService service = null;
		Object siteService = getSite().getAdapter(IWorkbenchSiteProgressService.class);
		if (siteService != null) {
			service = (IWorkbenchSiteProgressService) siteService;
		}
		return service;
	}

	public boolean isRefreshing() {
		return this.refreshJob != null && this.refreshJob.getState() != Job.NONE;
	}
}