ViewService.java

/******************************************************************************
 * Copyright (c) 2002, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    IBM Corporation - initial API and implementation 
 ****************************************************************************/

package org.eclipse.gmf.runtime.diagram.core.services;

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

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.gmf.runtime.common.core.service.ExecutionStrategy;
import org.eclipse.gmf.runtime.common.core.service.IOperation;
import org.eclipse.gmf.runtime.common.core.service.Service;
import org.eclipse.gmf.runtime.diagram.core.internal.DiagramPlugin;
import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint;
import org.eclipse.gmf.runtime.diagram.core.providers.IViewProvider;
import org.eclipse.gmf.runtime.diagram.core.providers.ViewProviderConfiguration;
import org.eclipse.gmf.runtime.diagram.core.services.view.CreateChildViewOperation;
import org.eclipse.gmf.runtime.diagram.core.services.view.CreateDiagramViewOperation;
import org.eclipse.gmf.runtime.diagram.core.services.view.CreateEdgeViewOperation;
import org.eclipse.gmf.runtime.diagram.core.services.view.CreateNodeViewOperation;
import org.eclipse.gmf.runtime.diagram.core.services.view.CreateViewForKindOperation;
import org.eclipse.gmf.runtime.diagram.core.services.view.CreateViewOperation;
import org.eclipse.gmf.runtime.diagram.core.util.ViewUtil;
import org.eclipse.gmf.runtime.emf.core.util.EObjectAdapter;
import org.eclipse.gmf.runtime.emf.type.core.requests.CreateElementRequest;
import org.eclipse.gmf.runtime.notation.Diagram;
import org.eclipse.gmf.runtime.notation.Edge;
import org.eclipse.gmf.runtime.notation.Node;
import org.eclipse.gmf.runtime.notation.View;

/**
 ** A service for manipulating the notational models
 * @author melaasar, mmostafa
 */
final public class ViewService
	extends Service
	implements IViewProvider {

	/**
	 * A descriptor for <code>ISemanticProvider</code> defined
	 * by a configuration element.
	 */
	protected static class ProviderDescriptor
		extends Service.ProviderDescriptor {

		/** the provider configuration parsed from XML */
		private ViewProviderConfiguration providerConfiguration;

		/**
		 * Constructs a <code>ISemanticProvider</code> descriptor for
		 * the specified configuration element.
		 * 
		 * @param element The configuration element describing the provider.
		 */
		public ProviderDescriptor(IConfigurationElement element) {
			super(element);

			this.providerConfiguration = ViewProviderConfiguration
				.parse(element);
			assert null != providerConfiguration : "Null providerConfiguration in ProviderDescriptor";//$NON-NLS-1$
		}

		/**
		 * @see org.eclipse.gmf.runtime.common.core.service.IProvider#provides(org.eclipse.gmf.runtime.common.core.service.IOperation)
		 */
		public boolean provides(IOperation operation) {
			if (!policyInitialized){
				policy = getPolicy();
				policyInitialized = true;
			}
			if (policy != null)
				return policy.provides(operation);
			if (provider == null) {
				if (isSupportedInExtention(operation)) {
					providerConfiguration = null;
					return getProvider().provides(operation);
				}
				return false;
			}
			return getProvider().provides(operation);
		}

		/**
		 * Cheks if the operation is supported by the XML extension
		 * @param operation
		 * @return
		 */
		private boolean isSupportedInExtention(IOperation operation) {
			if (operation instanceof CreateViewOperation) {
				CreateViewOperation o = (CreateViewOperation) operation;
				Class viewKind = o.getViewKind();
				IAdaptable semanticAdapter = o.getSemanticAdapter();
				String semanticHint = o.getSemanticHint();
				View containerView = null;
				if (o instanceof CreateChildViewOperation) {
					CreateChildViewOperation cvo = (CreateChildViewOperation) o;
					containerView = cvo.getContainerView();
				}

				return providerConfiguration.supports(viewKind,
					semanticAdapter, containerView, semanticHint);
			}
			return false;
		}

		/** 
		 * the default implementation is overriden here to make it easier to debug
		 * XML providers, now when you select the ProviderDescriptor in the debug
		 * window the provider class name will be displayed
		 * @return the provider class name
		 */
		public String toString() {
			return getElement().getAttribute("class"); 	 //$NON-NLS-1$
			//return (super.toString();
		}

	}

	/**
	 * The singleton instance of the notation service.
	 */
	private final static ViewService instance = new ViewService();

	static {
		instance.configureProviders(DiagramPlugin.getPluginId(), "viewProviders"); //$NON-NLS-1$
	}
	
	/**
	 * Retrieves the singleton instance of the notation service.
	 * 
	 * @return The notation service singleton.
	 */
	public static ViewService getInstance() {
		return instance;
	}

	/**
	 * creates an instance
	 */
	protected ViewService() {
		super(true, false);
	}

	/**
	 * @see org.eclipse.gmf.runtime.common.core.service.Service#newProviderDescriptor(org.eclipse.core.runtime.IConfigurationElement)
	 */
	protected Service.ProviderDescriptor newProviderDescriptor(
		IConfigurationElement element) {
		return new ProviderDescriptor(element);
	}

	/**
	 * @see org.eclipse.gmf.runtime.common.core.service.Service#createPriorityCache()
	 */
	protected Map createPriorityCache() {
		return new HashMap();
	}

	/**
	 * @see org.eclipse.gmf.runtime.common.core.service.Service#getCacheKey(org.eclipse.gmf.runtime.common.core.service.IOperation)
	 */
	protected Object getCachingKey(IOperation operation) {
		return ((CreateViewOperation) operation).getCachingKey();
	}

	/**
	 * Executes the specified operation using the FIRST execution
	 * strategy.
	 * @return The result of executing the model operation.
	 * @param operation The model operation to be executed.
	 */
	private Object execute(IOperation operation) {
		List results = execute(ExecutionStrategy.FIRST, operation);
		return results.isEmpty() ? null : results.get(0);
	}

	/**
	 * A convenience method to determine whether there is a provider 
	 * that can create a view with the given parameters
	 * @param viewKind
	 * @param semanticAdapter adapts to either <code>Integer<code> or <code>IReference</code>
	 * @param containerView
	 * @param semanticHint
	 * @param index
	 * @param preferencesHint
	 *            The preference hint that is to be used to find the appropriate
	 *            preference store from which to retrieve diagram preference
	 *            values. The preference hint is mapped to a preference store in
	 *            the preference registry <@link DiagramPreferencesRegistry>.
	 * @return boolean
	 */
	public final boolean provides(Class viewKind, IAdaptable semanticAdapter,
		View containerView, String semanticHint, int index,
		boolean persisted, PreferencesHint preferencesHint) {
		
		assert (viewKind == Diagram.class ||
				viewKind == Edge.class ||
				viewKind == Node.class ) :
				"The default View service does not support " + viewKind.getName() + " as a view kind";//$NON-NLS-1$ //$NON-NLS-2$

		/* if the semantic adapter adapters to the semantic kind */
		if (semanticAdapter != null) {
			if (semanticAdapter.getAdapter(CreateElementRequest.class) != null) {
				return providerExistsFor(new CreateViewForKindOperation(
					viewKind, semanticAdapter, containerView, semanticHint,
					index, preferencesHint));
			}
		}
		if (viewKind == Diagram.class)
			return providerExistsFor(new CreateDiagramViewOperation(
				semanticAdapter, semanticHint, preferencesHint));
		else if (viewKind == Edge.class)
			return providerExistsFor(new CreateEdgeViewOperation(
				semanticAdapter, containerView, semanticHint, index, persisted, preferencesHint));
		else if (viewKind == Node.class)
			return providerExistsFor(new CreateNodeViewOperation(
				semanticAdapter, containerView, semanticHint, index, persisted, preferencesHint));
		return false;
	}

	private boolean providerExistsFor(IOperation operation) {
		return provides(operation);
	}

	/**
	 * A convenience method to create a view with the given parameters
	 * @param viewKind
	 * @param semanticAdapter adapts to <code>IReference<code>
	 * @param containerView
	 * @param semanticHint
	 * @param index
	 * @param preferencesHint
	 *            The preference hint that is to be used to find the appropriate
	 *            preference store from which to retrieve diagram preference
	 *            values. The preference hint is mapped to a preference store in
	 *            the preference registry <@link DiagramPreferencesRegistry>.
	 * @return IView
	 */
	public final View createView(Class viewKind, IAdaptable semanticAdapter,
		View containerView, String semanticHint, int index,
		boolean persisted, PreferencesHint preferencesHint) {
		
		assert (viewKind == Diagram.class ||
				viewKind == Edge.class ||
				viewKind == Node.class ) :
			    "The default View service does not support " + viewKind.getName() + " as a view kind";//$NON-NLS-1$ //$NON-NLS-2$

		if (viewKind == Diagram.class)
			return createDiagram(semanticAdapter, semanticHint, preferencesHint);
		else if (viewKind == Edge.class)
			return createEdge(semanticAdapter, containerView,
				semanticHint, index, persisted, preferencesHint);
		else if (viewKind == Node.class)
			return createNode(semanticAdapter, containerView, semanticHint,
				index, persisted, preferencesHint);
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.gmf.runtime.diagram.core.providers.IViewProvider#createDiagram(org.eclipse.core.runtime.IAdaptable, java.lang.String, org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint)
	 */
	public final Diagram createDiagram(IAdaptable semanticAdapter,
		String diagramKindType, PreferencesHint preferencesHint) {
		Diagram view = (Diagram) execute(new CreateDiagramViewOperation(
			semanticAdapter, diagramKindType, preferencesHint));
		return view;
	}
	
	/**
	 * Creates a diagram with the given context and kind
	 * 
	 * @param context
	 *            The diagram element context
	 * @param kind
	 *            diagram kind, check {@link ViewType} for predefined values
	 * @param preferencesHint
	 *            The preference hint that is to be used to find the appropriate
	 *            preference store from which to retrieve diagram preference
	 *            values. The preference hint is mapped to a preference store in
	 *            the preference registry <@link DiagramPreferencesRegistry>.
	 * @return A newly created <code>Diagram</code>
	 */
	public static Diagram createDiagram(EObject context, String kind,
			PreferencesHint preferencesHint) {
		IAdaptable viewModel = (context != null) ? new EObjectAdapter(context)
				: null;
		String viewType = (kind != null) ? kind : ""; //$NON-NLS-1$
		return ViewService.getInstance().createDiagram(viewModel, viewType,
				preferencesHint);
	}
	
	/**
	 * Creates a diagram with a kind
	 * @param kind
	 *            diagram kind, check {@link ViewType} for predefined values
	 * @param preferencesHint
	 *            The preference hint that is to be used to find the appropriate
	 *            preference store from which to retrieve diagram preference
	 *            values. The preference hint is mapped to a preference store in
	 *            the preference registry <@link DiagramPreferencesRegistry>.
	 * @return A newly created <code>Diagram</code>
	 */
	public static Diagram createDiagram(String kind,
			PreferencesHint preferencesHint) {
		return ViewService.createDiagram((EObject)null, kind,
				preferencesHint);
	}
	
	/**
	 * Creates a node for a given eObject and with a given type and inserts it
	 * into a given container
	 * 
	 * @param container
	 *            The node view container
	 * @param eObject
	 *            The node view object context
	 * @param type
	 *            The node view type, check {@link ViewType} for predefined
	 *            values
	 * @param preferencesHint
	 *            The preference hint that is to be used to find the appropriate
	 *            preference store from which to retrieve diagram preference
	 *            values. The preference hint is mapped to a preference store in
	 *            the preference registry <@link DiagramPreferencesRegistry>.
	 * @return A newly created <code>Node</code>
	 */
	public static Node createNode(View container, EObject eObject, String type,
			PreferencesHint preferencesHint) {
		assert null != container : "The container is null";//$NON-NLS-1$
		IAdaptable viewModel = (eObject != null) ? new EObjectAdapter(eObject)
				: null;
		String viewType = (type != null) ? type : ""; //$NON-NLS-1$
		View view = ViewService.getInstance().createNode(viewModel, container,
				viewType, ViewUtil.APPEND, preferencesHint);
		return (view != null) ? (Node) view : null;
	}
	
	/**
	 * Creates a node for a with a given type and inserts it thegiven container
	 * 
	 * @param container
	 *            The node view container
	 * @param type
	 *            The node view type, check {@link ViewType} for predefined
	 *            values
	 * @param preferencesHint
	 *            The preference hint that is to be used to find the appropriate
	 *            preference store from which to retrieve diagram preference
	 *            values. The preference hint is mapped to a preference store in
	 *            the preference registry <@link DiagramPreferencesRegistry>.
	 * @return A newly created <code>Node</code>
	 */
	public static Node createNode(View container,String type,
			PreferencesHint preferencesHint) {
		return ViewService.createNode(container,(EObject)null,type,
			 preferencesHint);
	}
	
	
	/**
	 * Creates an edge for a given eObject and with a given type and connects it
	 * between a given source and a given target
	 * 
	 * @param source
	 *            The edge's source view
	 * @param target
	 *            The edge's target view
	 * @param eObject
	 *            The edge view object context
	 * @param type
	 *            The edge view type, check {@link ViewType} for predefined
	 *            values
	 * @param preferencesHint
	 *            The preference hint that is to be used to find the appropriate
	 *            preference store from which to retrieve diagram preference
	 *            values. The preference hint is mapped to a preference store in
	 *            the preference registry <@link DiagramPreferencesRegistry>.
	 * @return A newly created <code>Edge</code>
	 */
	public static Edge createEdge(View source, View target, EObject eObject,
			String type, PreferencesHint preferencesHint) {
		assert source != null : "The source is null"; //$NON-NLS-1$
		assert target != null : "The target is null"; //$NON-NLS-1$
		assert source.getDiagram() !=null : "The source is detached"; //$NON-NLS-1$
		assert target.getDiagram() !=null : "The target is detached"; //$NON-NLS-1$
		IAdaptable viewModel = (eObject != null) ? new EObjectAdapter(eObject)
				: null;
		Edge edge = (Edge)ViewService.getInstance().createEdge(viewModel,source.getDiagram(),
				type, ViewUtil.APPEND, preferencesHint);
		if (edge != null) {
			edge.setSource(source);
			edge.setTarget(target);
		}
		return edge;
	}
	
	/**
	 * Creates an edge with a given type and connects it between the given 
	 * source and  target
	 * 
	 * @param source
	 *            The edge's source view
	 * @param target
	 *            The edge's target view
	 * @param type
	 *            The edge view type, check {@link ViewType} for predefined
	 *            values
	 * @param preferencesHint
	 *            The preference hint that is to be used to find the appropriate
	 *            preference store from which to retrieve diagram preference
	 *            values. The preference hint is mapped to a preference store in
	 *            the preference registry <@link DiagramPreferencesRegistry>.
	 * @return A newly created <code>Edge</code>
	 */
	public static Edge createEdge(View source, View target,
			String type, PreferencesHint preferencesHint) {
		return ViewService.createEdge(source,target,(EObject)null,
			type,preferencesHint);
	}

	

	/* (non-Javadoc)
	 * @see org.eclipse.gmf.runtime.diagram.core.providers.IViewProvider#createEdge(org.eclipse.core.runtime.IAdaptable, org.eclipse.gmf.runtime.notation.View, java.lang.String, int, boolean, org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint)
	 */
	public final Edge createEdge(IAdaptable semanticAdapter,
		View containerView, String semanticHint, int index,
		boolean persisted, PreferencesHint preferencesHint) {
		Edge edge = (Edge) execute(new CreateEdgeViewOperation(
			semanticAdapter, containerView, semanticHint, index, persisted, preferencesHint));
		return edge;
	}

	/**
	 * @param semanticAdapter
	 * @param containerView
	 * @param semanticHint
	 * @param index
	 * @param preferencesHint
	 *            The preference hint that is to be used to find the appropriate
	 *            preference store from which to retrieve diagram preference
	 *            values. The preference hint is mapped to a preference store in
	 *            the preference registry <@link DiagramPreferencesRegistry>.
	 * @return
	 */
	public final View createEdge(IAdaptable semanticAdapter,
		View containerView, String semanticHint, int index, PreferencesHint preferencesHint) {
		return createEdge(semanticAdapter, containerView,
			semanticHint, index, true, preferencesHint);
	}

	/**
	 * creates a persisted Node
	 * @param semanticElement
	 * @param containerView
	 * @param semanticHint
	 * @param index
	 * @param preferencesHint
	 *            The preference hint that is to be used to find the appropriate
	 *            preference store from which to retrieve diagram preference
	 *            values. The preference hint is mapped to a preference store in
	 *            the preference registry <@link DiagramPreferencesRegistry>.
	 * @return the created node
	 */
	public final Node createNode(IAdaptable semanticElement,
		View containerView, String semanticHint, int index, PreferencesHint preferencesHint) {
		return createNode(semanticElement, containerView, semanticHint,
			index, true, preferencesHint);
	}

	/**
	 * creates a Node
	 * @param semanticElement
	 * @param containerView
	 * @param semanticHint
	 * @param persisted
	 * @param index
	 * @param preferencesHint
	 *            The preference hint that is to be used to find the appropriate
	 *            preference store from which to retrieve diagram preference
	 *            values. The preference hint is mapped to a preference store in
	 *            the preference registry <@link DiagramPreferencesRegistry>.
	 * @return the created node
	 */
	public Node createNode(IAdaptable semanticAdapter,
			View containerView, String semanticHint, int index,
			boolean persisted, PreferencesHint preferencesHint) {
		Node node = (Node) execute(new CreateNodeViewOperation(
			semanticAdapter, containerView, semanticHint, index, persisted, preferencesHint));
		return node;
	}
}