core/plugins/org.eclipse.mdht.uml.ui.navigator/src/org/eclipse/mdht/uml/ui/navigator/internal/UMLNavigatorContentProvider.java - mdht/org.eclipse.mdht - Git at Google

 /*******************************************************************************
  * Copyright (c) 2006, 2011 David A Carlson.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     David A Carlson (XMLmodeling.com) - initial API and implementation
  *     Kenn Hussey - removing operation history listener upon disposal
  *
  * $Id$
  *******************************************************************************/
 package org.eclipse.mdht.uml.ui.navigator.internal;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Hashtable;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import org.eclipse.core.commands.operations.IOperationHistory;
 import org.eclipse.core.commands.operations.IOperationHistoryListener;
 import org.eclipse.core.commands.operations.OperationHistoryEvent;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
 import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
 import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
 import org.eclipse.emf.transaction.DemultiplexingListener;
 import org.eclipse.emf.transaction.NotificationFilter;
 import org.eclipse.emf.transaction.ResourceSetChangeEvent;
 import org.eclipse.emf.transaction.ResourceSetListener;
 import org.eclipse.emf.transaction.ResourceSetListenerImpl;
 import org.eclipse.emf.transaction.TransactionalEditingDomain;
 import org.eclipse.emf.workspace.IWorkspaceCommandStack;
 import org.eclipse.emf.workspace.ResourceUndoContext;
 import org.eclipse.jface.viewers.StructuredViewer;
 import org.eclipse.jface.viewers.Viewer;
 import org.eclipse.mdht.uml.common.ui.saveable.ModelDocument;
 import org.eclipse.mdht.uml.common.ui.saveable.ModelManager;
 import org.eclipse.mdht.uml.common.ui.util.IResourceConstants;
 import org.eclipse.mdht.uml.ui.navigator.UMLAbstractNavigatorItem;
 import org.eclipse.mdht.uml.ui.navigator.UMLDomainNavigatorItem;
 import org.eclipse.mdht.uml.ui.navigator.internal.l10n.Messages;
 import org.eclipse.mdht.uml.ui.navigator.internal.plugin.Logger;
 import org.eclipse.mdht.uml.ui.navigator.internal.providers.NavigatorUMLItemProviderAdapterFactory;
 import org.eclipse.swt.SWTException;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.ui.IMemento;
 import org.eclipse.ui.Saveable;
 import org.eclipse.ui.navigator.ICommonContentExtensionSite;
 import org.eclipse.ui.navigator.ICommonContentProvider;
 import org.eclipse.ui.navigator.SaveablesProvider;
 import org.eclipse.uml2.uml.Association;
 import org.eclipse.uml2.uml.Element;
 import org.eclipse.uml2.uml.NamedElement;
 import org.eclipse.uml2.uml.Package;
 import org.eclipse.uml2.uml.resource.UML22UMLResource;
 import org.eclipse.uml2.uml.resource.UMLResource;
 import org.eclipse.uml2.uml.resource.XMI2UMLResource;

 public class UMLNavigatorContentProvider extends SaveablesProvider implements ICommonContentProvider, IAdaptable {

 	private static final Object[] EMPTY_ARRAY = new Object[0];

 	/** The source of content displayed in this navigator. */
 	private TransactionalEditingDomain editingDomain;

 	/** This is the one adapter factory used for providing views of the model. */
 	private ComposedAdapterFactory adapterFactory;

 	private AdapterFactoryContentProvider treeContentProvider;

 	private StructuredViewer viewer;

 	/** a flag indicating if this viewer got disposed */
 	protected boolean disposed = false;

 	/**
 	 * model event listener
 	 */
 	protected DemultiplexingListener eventListener = new DemultiplexingListener(getFilter()) {

 		@Override
 		protected void handleNotification(TransactionalEditingDomain domain, Notification notification) {
 			update(domain, notification);
 		}
 	};

 	private IOperationHistoryListener historyListener = new IOperationHistoryListener() {
 		public void historyNotification(final OperationHistoryEvent event) {
 			if (event.getEventType() == OperationHistoryEvent.DONE ||
 					event.getEventType() == OperationHistoryEvent.UNDONE ||
 					event.getEventType() == OperationHistoryEvent.REDONE) {

 				final Set<Resource> affectedResources = ResourceUndoContext.getAffectedResources(event.getOperation());

 				if (!affectedResources.isEmpty()) {
 					List<Saveable> saveables = new ArrayList<Saveable>();
 					for (Resource resource : affectedResources) {
 						Saveable saveable = ModelManager.getManager().getModelDocument(resource);
 						if (saveable != null) {
 							saveables.add(saveable);
 						}
 					}

 					fireSaveablesDirtyChanged(saveables.toArray(new Saveable[] {}));

 					Display.getDefault().syncExec(new Runnable() {
 						public void run() {
 							if (!viewer.getControl().isDisposed()) {
 								viewer.refresh();
 							}
 						}
 					});

 				}
 			}
 		}
 	};

 	/**
 	 * Support for saveables.
 	 * fire SaveablesLifecycleEvent from this ISaveablesSource
 	 */
 	private ResourceSetListener resourceLoadListener = new ResourceSetListenerImpl(
 		NotificationFilter.RESOURCE_LOADED.or(NotificationFilter.RESOURCE_UNLOADED)) {
 		@Override
 		public void resourceSetChanged(ResourceSetChangeEvent event) {
 			for (Notification notification : event.getNotifications()) {
 				final Resource resource = (Resource) notification.getNotifier();
 				final ModelDocument saveable = ModelManager.getManager().getModelDocument(resource);

 				if (NotificationFilter.RESOURCE_LOADED.matches(notification)) {

 					Display.getDefault().asyncExec(new Runnable() {
 						public void run() {

 							if (saveable != null) {
 								if (ModelManager.getManager().getChangedResources().contains(resource)) {
 									fireSaveablesDirtyChanged(new Saveable[] { saveable });
 								} else {
 									fireSaveablesOpened(new Saveable[] { saveable });
 								}

 								IFile file = saveable.getFile();
 								if (file != null) {
 									try {
 										file.getParent().refreshLocal(
 											IResource.DEPTH_INFINITE, new NullProgressMonitor());
 									} catch (CoreException e) {
 									}
 									viewer.refresh(file, true);

 									/*
 									 * If used, causes ALL dependent models to be expanded and shown
 									 */
 									// expose the model contents in Project Explorer
 									// List items = wrapItems(resource.getContents(), file);
 									// IStructuredSelection selection = new StructuredSelection(items);
 									// viewer.setSelection(selection, true);
 								}
 							}
 						}
 					});
 				} else if (NotificationFilter.RESOURCE_UNLOADED.matches(notification)) {
 					Display.getDefault().asyncExec(new Runnable() {
 						public void run() {
 							if (saveable != null) {
 								if (!ModelManager.getManager().getChangedResources().contains(resource)) {
 									fireSaveablesClosed(new Saveable[] { saveable });
 								}
 							}

 							if (!viewer.getControl().isDisposed()) {
 								viewer.refresh();
 							}
 						}
 					});
 				}
 			}
 		}
 	};

 	public UMLNavigatorContentProvider() {
 		editingDomain = TransactionalEditingDomain.Registry.INSTANCE.getEditingDomain(
 			IResourceConstants.EDITING_DOMAIN_ID);

 		if ((editingDomain instanceof AdapterFactoryEditingDomain) &&
 				((AdapterFactoryEditingDomain) editingDomain).getResourceToReadOnlyMap() == null) {
 			((AdapterFactoryEditingDomain) editingDomain).setResourceToReadOnlyMap(new Hashtable<Resource, Boolean>());
 		}

 		ModelManager.getManager().manage(editingDomain);

 		// add support for .xmi files and legacy .uml2 files
 		ResourceSet resourceSet = editingDomain.getResourceSet();
 		Map<String, Object> extensionToFactoryMap = resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap();
 		extensionToFactoryMap.put(UML22UMLResource.FILE_EXTENSION, UML22UMLResource.Factory.INSTANCE);
 		extensionToFactoryMap.put(XMI2UMLResource.FILE_EXTENSION, XMI2UMLResource.Factory.INSTANCE);

 		adapterFactory = createAdapterFactory();

 		treeContentProvider = new AdapterFactoryContentProvider(adapterFactory);

 		editingDomain.addResourceSetListener(getEventListener());
 		editingDomain.addResourceSetListener(resourceLoadListener);

 		getOperationHistory().addOperationHistoryListener(historyListener);

 		try {
 			loadUMLProfiles();
 		} catch (Exception e) {
 			// don't let missing profiles interfere with initialization
 			Logger.logException(e);
 		}
 	}

 	protected ComposedAdapterFactory createAdapterFactory() {
 		adapterFactory = new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE);
 		adapterFactory.addAdapterFactory(new NavigatorUMLItemProviderAdapterFactory());
 		return adapterFactory;
 	}

 	/**
 	 * This is a both helper and hack.
 	 *
 	 * Preload datatypes so that they are available.
 	 */
 	protected void loadUMLProfiles() {
 		ResourceSet resourceSet = editingDomain.getResourceSet();

 		// TODO Need an extension point for UML library registration
 		String umlLibURI = UMLResource.UML_PRIMITIVE_TYPES_LIBRARY_URI;

 		try {
 			resourceSet.getResource(URI.createURI(umlLibURI), true);
 		} catch (Exception e) {
 			// ignore if missing
 		}
 	}

 	private IOperationHistory getOperationHistory() {
 		return ((IWorkspaceCommandStack) editingDomain.getCommandStack()).getOperationHistory();
 	}

 	@Override
 	public void dispose() {
 		adapterFactory.dispose();
 		editingDomain.removeResourceSetListener(getEventListener());
 		editingDomain.removeResourceSetListener(resourceLoadListener);

 		getOperationHistory().removeOperationHistoryListener(historyListener);

 		disposed = true;
 	}

 	/**
 	 * @return Returns the disposed.
 	 */
 	protected boolean isDisposed() {
 		return disposed;
 	}

 	public void inputChanged(final Viewer viewer, Object oldInput, Object newInput) {
 		this.viewer = (StructuredViewer) viewer;

 		ModelManager.getManager().setShell(viewer.getControl().getShell());

 		// gets rid of '+' expansion icons on all unopened model files
 		// only needed first time navigator is opened, but don't know where to put this...
 		Display.getDefault().asyncExec(new Runnable() {
 			public void run() {
 				if (!viewer.getControl().isDisposed()) {
 					viewer.refresh();
 				}
 			}
 		});
 	}

 	public Object[] getElements(Object inputElement) {
 		return getChildren(inputElement);
 	}

 	public Object[] getChildren(Object parentElement) {
 		if (parentElement instanceof IFile) {
 			Resource resource = ModelManager.getManager().getResource((IFile) parentElement);
 			if (resource != null) {
 				List<UMLAbstractNavigatorItem> result = wrapModelElements(getResourceContents(resource), parentElement);
 				return result.toArray();
 			}
 		} else if (parentElement instanceof UMLAbstractNavigatorItem) {
 			UMLAbstractNavigatorItem abstractNavigatorItem = (UMLAbstractNavigatorItem) parentElement;

 			if (abstractNavigatorItem instanceof UMLDomainNavigatorItem) {
 				UMLDomainNavigatorItem navigatorItem = (UMLDomainNavigatorItem) abstractNavigatorItem;
 				Object[] children = treeContentProvider.getChildren(navigatorItem.getEObject());
 				return wrapItems(children, parentElement);

 			} else if (abstractNavigatorItem instanceof UMLNavigatorGroup) {
 				UMLNavigatorGroup group = (UMLNavigatorGroup) parentElement;
 				return group.getChildren();
 			}

 		}
 		return EMPTY_ARRAY;
 	}

 	private List<EObject> getResourceContents(Resource resource) {
 		List<EObject> contents = new ArrayList<EObject>();
 		// filter out stereotype applications
 		for (EObject eObject : resource.getContents()) {
 			if (eObject instanceof Element) {
 				contents.add(eObject);
 			}
 		}
 		return contents;
 	}

 	public Object getParent(Object element) {
 		if (element instanceof UMLDomainNavigatorItem) {
 			UMLDomainNavigatorItem abstractNavigatorItem = (UMLDomainNavigatorItem) element;

 			return abstractNavigatorItem.getParent();
 		}
 		return null;
 	}

 	public boolean hasChildren(Object element) {
 		if (element instanceof IFile) {
 			return ModelManager.getManager().getModelDocument((IFile) element) != null;
 		} else {
 			return getChildren(element).length > 0;
 		}
 	}

 	public void init(ICommonContentExtensionSite aConfig) {
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.ui.navigator.SaveablesProvider#doInit()
 	 */
 	@Override
 	protected void doInit() {
 		super.doInit();
 	}

 	public void restoreState(IMemento aMemento) {
 	}

 	public void saveState(IMemento aMemento) {
 	}

 	@SuppressWarnings("rawtypes")
 	public Object getAdapter(Class adapter) {
 		if (SaveablesProvider.class == adapter) {
 			return this;
 		}

 		return null;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.ui.navigator.SaveablesProvider#getElements(org.eclipse.ui.Saveable)
 	 */
 	@Override
 	public Object[] getElements(Saveable saveable) {
 		// This method MUST return an object that is in the navigator tree,
 		// returning Resource does not work.
 		if (saveable instanceof ModelDocument) {
 			IFile file = ((ModelDocument) saveable).getFile();
 			if (file != null) {
 				return new Object[] { file };
 			}
 		}
 		return EMPTY_ARRAY;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.ui.navigator.SaveablesProvider#getSaveable(java.lang.Object)
 	 */
 	@Override
 	public Saveable getSaveable(Object element) {
 		EObject eObject = null;
 		if (element instanceof EObject) {
 			eObject = (EObject) element;
 		} else if (element instanceof IAdaptable) {
 			eObject = ((IAdaptable) element).getAdapter(EObject.class);
 		}

 		ModelDocument saveable = null;
 		if (eObject != null) {
 			Resource resource = eObject.eResource();
 			saveable = ModelManager.getManager().getModelDocument(resource);
 		} else if (element instanceof Resource) {
 			saveable = ModelManager.getManager().getModelDocument((Resource) element);
 		}
 		return saveable;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.ui.navigator.SaveablesProvider#getSaveables()
 	 */
 	@Override
 	public Saveable[] getSaveables() {
 		// returns all writable resources
 		Collection<ModelDocument> saveables = ModelManager.getManager().getDocuments();
 		Saveable[] array = new Saveable[saveables.size()];
 		saveables.toArray(array);
 		return array;
 	}

 	private List<UMLAbstractNavigatorItem> wrapModelElements(List<EObject> items, Object parentElement) {
 		List<UMLAbstractNavigatorItem> wrappedItems = new ArrayList<UMLAbstractNavigatorItem>();
 		for (EObject item : items) {
 			// this will omit stereotype applications when iterating over Resource
 			if (item instanceof Element) {
 				wrappedItems.add(new UMLDomainNavigatorItem(item, parentElement, treeContentProvider));
 			}
 		}
 		return wrappedItems;
 	}

 	private UMLAbstractNavigatorItem[] wrapItems(Object[] items, Object parentElement) {
 		List<UMLAbstractNavigatorItem> wrappedItems = new ArrayList<UMLAbstractNavigatorItem>();
 		if (parentElement instanceof UMLDomainNavigatorItem &&
 				((UMLDomainNavigatorItem) parentElement).getEObject() instanceof Package) {
 			UMLNavigatorGroup group = getAssociations(
 				(Package) ((UMLDomainNavigatorItem) parentElement).getEObject(), parentElement);
 			if (group != null) {
 				wrappedItems.add(group);
 			}
 		}
 		for (int i = 0; i < items.length; i++) {
 			if (items[i] instanceof Element && !(items[i] instanceof Association)) {
 				wrappedItems.add(new UMLDomainNavigatorItem((Element) items[i], parentElement, treeContentProvider));
 			}
 		}
 		return wrappedItems.toArray(new UMLAbstractNavigatorItem[wrappedItems.size()]);
 	}

 	private UMLNavigatorGroup getAssociations(Package umlPackage, Object parentElement) {
 		UMLNavigatorGroup group = null;
 		List<EObject> associations = new ArrayList<EObject>();
 		for (NamedElement element : umlPackage.getOwnedMembers()) {
 			if (element instanceof Association) {
 				associations.add(element);
 			}
 		}
 		if (!associations.isEmpty()) {
 			group = new UMLNavigatorGroup(
 				Messages.NavigatorGroupName_associations, "icons/associationsNavigatorGroup.gif", parentElement);
 			group.addChildren(wrapModelElements(associations, group));
 		}
 		return group;
 	}

 	/**
 	 * @return Returns the eventListener.
 	 */
 	protected DemultiplexingListener getEventListener() {
 		return eventListener;
 	}

 	/**
 	 * Subclasses overriding this method should remember to override {@link #update(TransactionalEditingDomain, Notification)} as required.
 	 * The default implementation of {@link #update(TransactionalEditingDomain, Notification)} will only
 	 * update if the notifier is an <code>EObject</code>.
 	 *
 	 * @return the filter for events used by my <code>eventListener</code>.
 	 */
 	public NotificationFilter getFilter() {
 		// return NotificationFilter.createEventTypeFilter(Notification.SET).or(
 		// NotificationFilter.createEventTypeFilter(Notification.UNSET)).and(
 		// NotificationFilter.createNotifierTypeFilter(EObject.class));

 		return NotificationFilter.NOT_TOUCH;
 	}

 	/**
 	 * Update if necessary, upon receiving the model event. This event will only
 	 * be processed when the receiver is visible (the default behavior is not to
 	 * listen to the model events while not showing). Therefore it is safe to
 	 * refresh the UI. Sublclasses, which will choose to override event
 	 * listening behavior should take into account that the model events are
 	 * sent all the time - regardless of the section visibility. Thus special
 	 * care should be taken by the section that will choose to listen to such
 	 * events all the time. Also, the default implementation of this method
 	 * synchronizes on the GUI thread. The subclasses that overwrite it should
 	 * do the same if they perform any GUI work (because events may be sent from
 	 * a non-GUI thread).
 	 *
 	 * @see #aboutToBeShown()
 	 * @see #aboutToBeHidden()
 	 *
 	 * @param notification
 	 *            notification object
 	 * @param element
 	 *            element that has changed
 	 */
 	public void update(final Notification notification, final EObject element) {
 		if (!isDisposed() && !isNotifierDeleted(notification)) {
 			postUpdateRequest(new Runnable() {

 				public void run() {
 					if (!isDisposed() && !viewer.getControl().isDisposed() && !isNotifierDeleted(notification)) {
 						try {
 							if (element instanceof Element) {
 								viewer.refresh(new UMLDomainNavigatorItem(element, null, treeContentProvider));
 							} else {
 								viewer.refresh(element);
 							}
 						} catch (SWTException e) {
 							// ignore tree item widget disposed exception.
 							// cannot find its source when some tree items are deleted
 						}
 					}

 				}
 			});
 		}
 	}

 	/**
 	 * Updates me if the notifier is an <code>EObject</code> by calling {@link #update(Notification, EObject)}. Does nothing otherwise.
 	 * Subclasses should override this method if they need to update based on
 	 * non-EObject notifiers.
 	 *
 	 * @param domain
 	 *            the editing domain
 	 * @param notification
 	 *            the event notification
 	 */
 	protected void update(TransactionalEditingDomain domain, Notification notification) {

 		Object notifier = notification.getNotifier();

 		if (notifier instanceof EObject) {
 			update(notification, (EObject) notifier);
 		} else if (notifier instanceof Resource) {
 			if (Resource.RESOURCE__IS_MODIFIED == notification.getFeatureID(null)) {
 				// toggle the '*' dirty flag
 				Saveable saveable = ModelManager.getManager().getModelDocument((Resource) notifier);
 				if (saveable != null) {
 					fireSaveablesDirtyChanged(new Saveable[] { saveable });
 				}

 				Display.getDefault().syncExec(new Runnable() {
 					public void run() {
 						if (viewer != null && !viewer.getControl().isDisposed()) {
 							viewer.refresh();
 						}
 					}
 				});

 			}
 		}
 	}

 	/**
 	 * Returns whether or not the notifier for a particular notification has been
 	 * deleted from its parent.
 	 *
 	 * This is a fix for RATLC00535181. What happens is that during deletion of
 	 * an element from the diagram, the element first deletes related elements
 	 * which causes a modification of the element itself. When the modification occurs
 	 * the event handling mechanism posts a request to the UI queue to refresh the UI.
 	 * A race condition occurs where by the time the posted request runs, the element
 	 * in question may or may not have already been deleted from its container. If
 	 * the element has been deleted from its container, we should not refresh the
 	 * property section.
 	 *
 	 * @param notification
 	 * @return <code>true</code> if notification has been deleted from its parent, <code>false</code> otherwise
 	 */
 	protected boolean isNotifierDeleted(Notification notification) {
 		if (!(notification.getNotifier() instanceof EObject)) {
 			return false;
 		}
 		EObject obj = (EObject) notification.getNotifier();
 		return obj.eResource() == null;
 	}

 	/**
 	 * Execute request in the UI thread.
 	 *
 	 * @param updateRequest
 	 *            -
 	 *            runnable update code
 	 */
 	protected void postUpdateRequest(Runnable updateRequest) {
 		Display.getDefault().syncExec(updateRequest);
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.gmf.runtime.emf.core.edit.IDemuxedMListener#handleElementModifiedEvent(org.eclipse.emf.common.notify.Notification,
 	 * org.eclipse.emf.ecore.EObject)
 	 */
 	public void handleElementModifiedEvent(final Notification notification, final EObject element) {
 		update(notification, element);
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2006, 2011 David A Carlson.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* David A Carlson (XMLmodeling.com) - initial API and implementation
	* Kenn Hussey - removing operation history listener upon disposal
	*
	* $Id$
	*******************************************************************************/
	package org.eclipse.mdht.uml.ui.navigator.internal;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Hashtable;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import org.eclipse.core.commands.operations.IOperationHistory;
	import org.eclipse.core.commands.operations.IOperationHistoryListener;
	import org.eclipse.core.commands.operations.OperationHistoryEvent;
	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.emf.common.notify.Notification;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.emf.ecore.resource.ResourceSet;
	import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
	import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
	import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
	import org.eclipse.emf.transaction.DemultiplexingListener;
	import org.eclipse.emf.transaction.NotificationFilter;
	import org.eclipse.emf.transaction.ResourceSetChangeEvent;
	import org.eclipse.emf.transaction.ResourceSetListener;
	import org.eclipse.emf.transaction.ResourceSetListenerImpl;
	import org.eclipse.emf.transaction.TransactionalEditingDomain;
	import org.eclipse.emf.workspace.IWorkspaceCommandStack;
	import org.eclipse.emf.workspace.ResourceUndoContext;
	import org.eclipse.jface.viewers.StructuredViewer;
	import org.eclipse.jface.viewers.Viewer;
	import org.eclipse.mdht.uml.common.ui.saveable.ModelDocument;
	import org.eclipse.mdht.uml.common.ui.saveable.ModelManager;
	import org.eclipse.mdht.uml.common.ui.util.IResourceConstants;
	import org.eclipse.mdht.uml.ui.navigator.UMLAbstractNavigatorItem;
	import org.eclipse.mdht.uml.ui.navigator.UMLDomainNavigatorItem;
	import org.eclipse.mdht.uml.ui.navigator.internal.l10n.Messages;
	import org.eclipse.mdht.uml.ui.navigator.internal.plugin.Logger;
	import org.eclipse.mdht.uml.ui.navigator.internal.providers.NavigatorUMLItemProviderAdapterFactory;
	import org.eclipse.swt.SWTException;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.ui.IMemento;
	import org.eclipse.ui.Saveable;
	import org.eclipse.ui.navigator.ICommonContentExtensionSite;
	import org.eclipse.ui.navigator.ICommonContentProvider;
	import org.eclipse.ui.navigator.SaveablesProvider;
	import org.eclipse.uml2.uml.Association;
	import org.eclipse.uml2.uml.Element;
	import org.eclipse.uml2.uml.NamedElement;
	import org.eclipse.uml2.uml.Package;
	import org.eclipse.uml2.uml.resource.UML22UMLResource;
	import org.eclipse.uml2.uml.resource.UMLResource;
	import org.eclipse.uml2.uml.resource.XMI2UMLResource;

	public class UMLNavigatorContentProvider extends SaveablesProvider implements ICommonContentProvider, IAdaptable {

	private static final Object[] EMPTY_ARRAY = new Object[0];

	/** The source of content displayed in this navigator. */
	private TransactionalEditingDomain editingDomain;

	/** This is the one adapter factory used for providing views of the model. */
	private ComposedAdapterFactory adapterFactory;

	private AdapterFactoryContentProvider treeContentProvider;

	private StructuredViewer viewer;

	/** a flag indicating if this viewer got disposed */
	protected boolean disposed = false;

	/**
	* model event listener
	*/
	protected DemultiplexingListener eventListener = new DemultiplexingListener(getFilter()) {

	@Override
	protected void handleNotification(TransactionalEditingDomain domain, Notification notification) {
	update(domain, notification);
	}
	};

	private IOperationHistoryListener historyListener = new IOperationHistoryListener() {
	public void historyNotification(final OperationHistoryEvent event) {
	if (event.getEventType() == OperationHistoryEvent.DONE \|\|
	event.getEventType() == OperationHistoryEvent.UNDONE \|\|
	event.getEventType() == OperationHistoryEvent.REDONE) {

	final Set<Resource> affectedResources = ResourceUndoContext.getAffectedResources(event.getOperation());

	if (!affectedResources.isEmpty()) {
	List<Saveable> saveables = new ArrayList<Saveable>();
	for (Resource resource : affectedResources) {
	Saveable saveable = ModelManager.getManager().getModelDocument(resource);
	if (saveable != null) {
	saveables.add(saveable);
	}
	}

	fireSaveablesDirtyChanged(saveables.toArray(new Saveable[] {}));

	Display.getDefault().syncExec(new Runnable() {
	public void run() {
	if (!viewer.getControl().isDisposed()) {
	viewer.refresh();
	}
	}
	});

	}
	}
	}
	};

	/**
	* Support for saveables.
	* fire SaveablesLifecycleEvent from this ISaveablesSource
	*/
	private ResourceSetListener resourceLoadListener = new ResourceSetListenerImpl(
	NotificationFilter.RESOURCE_LOADED.or(NotificationFilter.RESOURCE_UNLOADED)) {
	@Override
	public void resourceSetChanged(ResourceSetChangeEvent event) {
	for (Notification notification : event.getNotifications()) {
	final Resource resource = (Resource) notification.getNotifier();
	final ModelDocument saveable = ModelManager.getManager().getModelDocument(resource);

	if (NotificationFilter.RESOURCE_LOADED.matches(notification)) {

	Display.getDefault().asyncExec(new Runnable() {
	public void run() {

	if (saveable != null) {
	if (ModelManager.getManager().getChangedResources().contains(resource)) {
	fireSaveablesDirtyChanged(new Saveable[] { saveable });
	} else {
	fireSaveablesOpened(new Saveable[] { saveable });
	}

	IFile file = saveable.getFile();
	if (file != null) {
	try {
	file.getParent().refreshLocal(
	IResource.DEPTH_INFINITE, new NullProgressMonitor());
	} catch (CoreException e) {
	}
	viewer.refresh(file, true);

	/*
	* If used, causes ALL dependent models to be expanded and shown
	*/
	// expose the model contents in Project Explorer
	// List items = wrapItems(resource.getContents(), file);
	// IStructuredSelection selection = new StructuredSelection(items);
	// viewer.setSelection(selection, true);
	}
	}
	}
	});
	} else if (NotificationFilter.RESOURCE_UNLOADED.matches(notification)) {
	Display.getDefault().asyncExec(new Runnable() {
	public void run() {
	if (saveable != null) {
	if (!ModelManager.getManager().getChangedResources().contains(resource)) {
	fireSaveablesClosed(new Saveable[] { saveable });
	}
	}

	if (!viewer.getControl().isDisposed()) {
	viewer.refresh();
	}
	}
	});
	}
	}
	}
	};

	public UMLNavigatorContentProvider() {
	editingDomain = TransactionalEditingDomain.Registry.INSTANCE.getEditingDomain(
	IResourceConstants.EDITING_DOMAIN_ID);

	if ((editingDomain instanceof AdapterFactoryEditingDomain) &&
	((AdapterFactoryEditingDomain) editingDomain).getResourceToReadOnlyMap() == null) {
	((AdapterFactoryEditingDomain) editingDomain).setResourceToReadOnlyMap(new Hashtable<Resource, Boolean>());
	}

	ModelManager.getManager().manage(editingDomain);

	// add support for .xmi files and legacy .uml2 files
	ResourceSet resourceSet = editingDomain.getResourceSet();
	Map<String, Object> extensionToFactoryMap = resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap();
	extensionToFactoryMap.put(UML22UMLResource.FILE_EXTENSION, UML22UMLResource.Factory.INSTANCE);
	extensionToFactoryMap.put(XMI2UMLResource.FILE_EXTENSION, XMI2UMLResource.Factory.INSTANCE);

	adapterFactory = createAdapterFactory();

	treeContentProvider = new AdapterFactoryContentProvider(adapterFactory);

	editingDomain.addResourceSetListener(getEventListener());
	editingDomain.addResourceSetListener(resourceLoadListener);

	getOperationHistory().addOperationHistoryListener(historyListener);

	try {
	loadUMLProfiles();
	} catch (Exception e) {
	// don't let missing profiles interfere with initialization
	Logger.logException(e);
	}
	}

	protected ComposedAdapterFactory createAdapterFactory() {
	adapterFactory = new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE);
	adapterFactory.addAdapterFactory(new NavigatorUMLItemProviderAdapterFactory());
	return adapterFactory;
	}

	/**
	* This is a both helper and hack.
	*
	* Preload datatypes so that they are available.
	*/
	protected void loadUMLProfiles() {
	ResourceSet resourceSet = editingDomain.getResourceSet();

	// TODO Need an extension point for UML library registration
	String umlLibURI = UMLResource.UML_PRIMITIVE_TYPES_LIBRARY_URI;

	try {
	resourceSet.getResource(URI.createURI(umlLibURI), true);
	} catch (Exception e) {
	// ignore if missing
	}
	}

	private IOperationHistory getOperationHistory() {
	return ((IWorkspaceCommandStack) editingDomain.getCommandStack()).getOperationHistory();
	}

	@Override
	public void dispose() {
	adapterFactory.dispose();
	editingDomain.removeResourceSetListener(getEventListener());
	editingDomain.removeResourceSetListener(resourceLoadListener);

	getOperationHistory().removeOperationHistoryListener(historyListener);

	disposed = true;
	}

	/**
	* @return Returns the disposed.
	*/
	protected boolean isDisposed() {
	return disposed;
	}

	public void inputChanged(final Viewer viewer, Object oldInput, Object newInput) {
	this.viewer = (StructuredViewer) viewer;

	ModelManager.getManager().setShell(viewer.getControl().getShell());

	// gets rid of '+' expansion icons on all unopened model files
	// only needed first time navigator is opened, but don't know where to put this...
	Display.getDefault().asyncExec(new Runnable() {
	public void run() {
	if (!viewer.getControl().isDisposed()) {
	viewer.refresh();
	}
	}
	});
	}

	public Object[] getElements(Object inputElement) {
	return getChildren(inputElement);
	}

	public Object[] getChildren(Object parentElement) {
	if (parentElement instanceof IFile) {
	Resource resource = ModelManager.getManager().getResource((IFile) parentElement);
	if (resource != null) {
	List<UMLAbstractNavigatorItem> result = wrapModelElements(getResourceContents(resource), parentElement);
	return result.toArray();
	}
	} else if (parentElement instanceof UMLAbstractNavigatorItem) {
	UMLAbstractNavigatorItem abstractNavigatorItem = (UMLAbstractNavigatorItem) parentElement;

	if (abstractNavigatorItem instanceof UMLDomainNavigatorItem) {
	UMLDomainNavigatorItem navigatorItem = (UMLDomainNavigatorItem) abstractNavigatorItem;
	Object[] children = treeContentProvider.getChildren(navigatorItem.getEObject());
	return wrapItems(children, parentElement);

	} else if (abstractNavigatorItem instanceof UMLNavigatorGroup) {
	UMLNavigatorGroup group = (UMLNavigatorGroup) parentElement;
	return group.getChildren();
	}

	}
	return EMPTY_ARRAY;
	}

	private List<EObject> getResourceContents(Resource resource) {
	List<EObject> contents = new ArrayList<EObject>();
	// filter out stereotype applications
	for (EObject eObject : resource.getContents()) {
	if (eObject instanceof Element) {
	contents.add(eObject);
	}
	}
	return contents;
	}

	public Object getParent(Object element) {
	if (element instanceof UMLDomainNavigatorItem) {
	UMLDomainNavigatorItem abstractNavigatorItem = (UMLDomainNavigatorItem) element;

	return abstractNavigatorItem.getParent();
	}
	return null;
	}

	public boolean hasChildren(Object element) {
	if (element instanceof IFile) {
	return ModelManager.getManager().getModelDocument((IFile) element) != null;
	} else {
	return getChildren(element).length > 0;
	}
	}

	public void init(ICommonContentExtensionSite aConfig) {
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.ui.navigator.SaveablesProvider#doInit()
	*/
	@Override
	protected void doInit() {
	super.doInit();
	}

	public void restoreState(IMemento aMemento) {
	}

	public void saveState(IMemento aMemento) {
	}

	@SuppressWarnings("rawtypes")
	public Object getAdapter(Class adapter) {
	if (SaveablesProvider.class == adapter) {
	return this;
	}

	return null;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.ui.navigator.SaveablesProvider#getElements(org.eclipse.ui.Saveable)
	*/
	@Override
	public Object[] getElements(Saveable saveable) {
	// This method MUST return an object that is in the navigator tree,
	// returning Resource does not work.
	if (saveable instanceof ModelDocument) {
	IFile file = ((ModelDocument) saveable).getFile();
	if (file != null) {
	return new Object[] { file };
	}
	}
	return EMPTY_ARRAY;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.ui.navigator.SaveablesProvider#getSaveable(java.lang.Object)
	*/
	@Override
	public Saveable getSaveable(Object element) {
	EObject eObject = null;
	if (element instanceof EObject) {
	eObject = (EObject) element;
	} else if (element instanceof IAdaptable) {
	eObject = ((IAdaptable) element).getAdapter(EObject.class);
	}

	ModelDocument saveable = null;
	if (eObject != null) {
	Resource resource = eObject.eResource();
	saveable = ModelManager.getManager().getModelDocument(resource);
	} else if (element instanceof Resource) {
	saveable = ModelManager.getManager().getModelDocument((Resource) element);
	}
	return saveable;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.ui.navigator.SaveablesProvider#getSaveables()
	*/
	@Override
	public Saveable[] getSaveables() {
	// returns all writable resources
	Collection<ModelDocument> saveables = ModelManager.getManager().getDocuments();
	Saveable[] array = new Saveable[saveables.size()];
	saveables.toArray(array);
	return array;
	}

	private List<UMLAbstractNavigatorItem> wrapModelElements(List<EObject> items, Object parentElement) {
	List<UMLAbstractNavigatorItem> wrappedItems = new ArrayList<UMLAbstractNavigatorItem>();
	for (EObject item : items) {
	// this will omit stereotype applications when iterating over Resource
	if (item instanceof Element) {
	wrappedItems.add(new UMLDomainNavigatorItem(item, parentElement, treeContentProvider));
	}
	}
	return wrappedItems;
	}

	private UMLAbstractNavigatorItem[] wrapItems(Object[] items, Object parentElement) {
	List<UMLAbstractNavigatorItem> wrappedItems = new ArrayList<UMLAbstractNavigatorItem>();
	if (parentElement instanceof UMLDomainNavigatorItem &&
	((UMLDomainNavigatorItem) parentElement).getEObject() instanceof Package) {
	UMLNavigatorGroup group = getAssociations(
	(Package) ((UMLDomainNavigatorItem) parentElement).getEObject(), parentElement);
	if (group != null) {
	wrappedItems.add(group);
	}
	}
	for (int i = 0; i < items.length; i++) {
	if (items[i] instanceof Element && !(items[i] instanceof Association)) {
	wrappedItems.add(new UMLDomainNavigatorItem((Element) items[i], parentElement, treeContentProvider));
	}
	}
	return wrappedItems.toArray(new UMLAbstractNavigatorItem[wrappedItems.size()]);
	}

	private UMLNavigatorGroup getAssociations(Package umlPackage, Object parentElement) {
	UMLNavigatorGroup group = null;
	List<EObject> associations = new ArrayList<EObject>();
	for (NamedElement element : umlPackage.getOwnedMembers()) {
	if (element instanceof Association) {
	associations.add(element);
	}
	}
	if (!associations.isEmpty()) {
	group = new UMLNavigatorGroup(
	Messages.NavigatorGroupName_associations, "icons/associationsNavigatorGroup.gif", parentElement);
	group.addChildren(wrapModelElements(associations, group));
	}
	return group;
	}

	/**
	* @return Returns the eventListener.
	*/
	protected DemultiplexingListener getEventListener() {
	return eventListener;
	}

	/**
	* Subclasses overriding this method should remember to override {@link #update(TransactionalEditingDomain, Notification)} as required.
	* The default implementation of {@link #update(TransactionalEditingDomain, Notification)} will only
	* update if the notifier is an <code>EObject</code>.
	*
	* @return the filter for events used by my <code>eventListener</code>.
	*/
	public NotificationFilter getFilter() {
	// return NotificationFilter.createEventTypeFilter(Notification.SET).or(
	// NotificationFilter.createEventTypeFilter(Notification.UNSET)).and(
	// NotificationFilter.createNotifierTypeFilter(EObject.class));

	return NotificationFilter.NOT_TOUCH;
	}

	/**
	* Update if necessary, upon receiving the model event. This event will only
	* be processed when the receiver is visible (the default behavior is not to
	* listen to the model events while not showing). Therefore it is safe to
	* refresh the UI. Sublclasses, which will choose to override event
	* listening behavior should take into account that the model events are
	* sent all the time - regardless of the section visibility. Thus special
	* care should be taken by the section that will choose to listen to such
	* events all the time. Also, the default implementation of this method
	* synchronizes on the GUI thread. The subclasses that overwrite it should
	* do the same if they perform any GUI work (because events may be sent from
	* a non-GUI thread).
	*
	* @see #aboutToBeShown()
	* @see #aboutToBeHidden()
	*
	* @param notification
	* notification object
	* @param element
	* element that has changed
	*/
	public void update(final Notification notification, final EObject element) {
	if (!isDisposed() && !isNotifierDeleted(notification)) {
	postUpdateRequest(new Runnable() {

	public void run() {
	if (!isDisposed() && !viewer.getControl().isDisposed() && !isNotifierDeleted(notification)) {
	try {
	if (element instanceof Element) {
	viewer.refresh(new UMLDomainNavigatorItem(element, null, treeContentProvider));
	} else {
	viewer.refresh(element);
	}
	} catch (SWTException e) {
	// ignore tree item widget disposed exception.
	// cannot find its source when some tree items are deleted
	}
	}

	}
	});
	}
	}

	/**
	* Updates me if the notifier is an <code>EObject</code> by calling {@link #update(Notification, EObject)}. Does nothing otherwise.
	* Subclasses should override this method if they need to update based on
	* non-EObject notifiers.
	*
	* @param domain
	* the editing domain
	* @param notification
	* the event notification
	*/
	protected void update(TransactionalEditingDomain domain, Notification notification) {

	Object notifier = notification.getNotifier();

	if (notifier instanceof EObject) {
	update(notification, (EObject) notifier);
	} else if (notifier instanceof Resource) {
	if (Resource.RESOURCE__IS_MODIFIED == notification.getFeatureID(null)) {
	// toggle the '*' dirty flag
	Saveable saveable = ModelManager.getManager().getModelDocument((Resource) notifier);
	if (saveable != null) {
	fireSaveablesDirtyChanged(new Saveable[] { saveable });
	}

	Display.getDefault().syncExec(new Runnable() {
	public void run() {
	if (viewer != null && !viewer.getControl().isDisposed()) {
	viewer.refresh();
	}
	}
	});

	}
	}
	}

	/**
	* Returns whether or not the notifier for a particular notification has been
	* deleted from its parent.
	*
	* This is a fix for RATLC00535181. What happens is that during deletion of
	* an element from the diagram, the element first deletes related elements
	* which causes a modification of the element itself. When the modification occurs
	* the event handling mechanism posts a request to the UI queue to refresh the UI.
	* A race condition occurs where by the time the posted request runs, the element
	* in question may or may not have already been deleted from its container. If
	* the element has been deleted from its container, we should not refresh the
	* property section.
	*
	* @param notification
	* @return <code>true</code> if notification has been deleted from its parent, <code>false</code> otherwise
	*/
	protected boolean isNotifierDeleted(Notification notification) {
	if (!(notification.getNotifier() instanceof EObject)) {
	return false;
	}
	EObject obj = (EObject) notification.getNotifier();
	return obj.eResource() == null;
	}

	/**
	* Execute request in the UI thread.
	*
	* @param updateRequest
	* -
	* runnable update code
	*/
	protected void postUpdateRequest(Runnable updateRequest) {
	Display.getDefault().syncExec(updateRequest);
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.gmf.runtime.emf.core.edit.IDemuxedMListener#handleElementModifiedEvent(org.eclipse.emf.common.notify.Notification,
	* org.eclipse.emf.ecore.EObject)
	*/
	public void handleElementModifiedEvent(final Notification notification, final EObject element) {
	update(notification, element);
	}

	}