bundles/org.eclipse.jst.ws.jaxws.dom.integration/src/org/eclipse/jst/ws/jaxws/dom/integration/navigator/DOMAdapterFactoryContentProvider.java - webservices/webtools.webservices.jaxws - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009 by SAP AG, Walldorf.
  * 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:
  *     SAP AG - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.ws.jaxws.dom.integration.navigator;

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

 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.emf.common.notify.AdapterFactory;
 import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
 import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
 import org.eclipse.jst.ws.jaxws.dom.integration.internal.util.ProjectExplorerUtil;
 import org.eclipse.jst.ws.jaxws.dom.integration.navigator.ILoadingWsProject.ILoadingCanceled;
 import org.eclipse.jst.ws.jaxws.dom.integration.navigator.ILoadingWsProject.ILoadingDummy;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.IDOM;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.IServiceEndpointInterface;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebMethod;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebParam;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebService;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebServiceProject;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWsDOMRuntimeExtension;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWsDomLoadListener;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.WsDOMLoadCanceledException;
 import org.eclipse.jst.ws.jaxws.dom.runtime.api.WsDOMRuntimeManager;
 import org.eclipse.jst.ws.jaxws.dom.runtime.registry.IWsDOMRuntimeInfo;
 import org.eclipse.jst.ws.jaxws.dom.runtime.registry.WsDOMRuntimeRegistry;
 import org.eclipse.jst.ws.jaxws.utils.ContractChecker;
 import org.eclipse.jst.ws.jaxws.utils.facets.FacetUtils;
 import org.eclipse.jst.ws.jaxws.utils.logging.Logger;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.TreeItem;
 import org.eclipse.ui.IViewPart;
 import org.eclipse.ui.navigator.CommonNavigator;
 import org.eclipse.ui.navigator.CommonViewer;

 /**
  * Content provider for DOM related objects
  *
  * @author
  */
 public class DOMAdapterFactoryContentProvider extends AdapterFactoryContentProvider
 {
 	private Map<IWsDOMRuntimeExtension, IWsDomLoadListener> loadListeners = new HashMap<IWsDOMRuntimeExtension, IWsDomLoadListener>();

 	/**
 	 * Constructor
 	 */
 	public DOMAdapterFactoryContentProvider()
 	{
 		this(CustomDomItemProviderAdapterFactory.INSTANCE);
 	}

 	/**
 	 * Constructor
 	 * @param adapterFactory
 	 */
 	public DOMAdapterFactoryContentProvider(AdapterFactory adapterFactory)
 	{
 		super(adapterFactory);
 	}

 	@Override
 	public Object[] getChildren(final Object context)
 	{
 		if (context instanceof IAdaptable)
 		{
 			return getWsProject((IProject)((IAdaptable) context).getAdapter(IProject.class));
 		}
 		else if(context instanceof ILoadingWsProject)
 		{
 			return new Object[] { ((ILoadingWsProject)context).isLoadCanceled() ? new ILoadingCanceled(){} : new ILoadingDummy(){} };
 		}
 		else if(context instanceof IWebServiceProject)
 		{
 			return new Object[]{ adapterFactory.adapt(context, ISEIChildList.class),
 					adapterFactory.adapt(context, IWebServiceChildList.class) };
 		}
 		else if(context instanceof IWebServiceChildList)
 		{
 			Object[] webServices = ((IWebServiceChildList)context).getWSChildList().toArray();

 			for(int ii=0; ii<webServices.length; ii++)
 			{
 				adapterFactory.adapt(webServices[ii], ITreeItemContentProvider.class);
 			}

 			return webServices;
 		}
 		else if(context instanceof ISEIChildList)
 		{
 			Object[] sEIs = ((ISEIChildList)context).getSEIChildList().toArray();

 			for(int ii=0; ii<sEIs.length; ii++)
 			{
 				adapterFactory.adapt(sEIs[ii], ITreeItemContentProvider.class);
 			}

 			return sEIs;
 		}
 		else if(context instanceof IWebService)
 		{
 			final IServiceEndpointInterface sei = ((IWebService)context).getServiceEndpoint();
 			if (sei == null) {
 				return new Object[0];
 			}

 			adapterFactory.adapt(sei, ITreeItemContentProvider.class);
 			return new Object[]{ sei };
 		}
 		else if(context instanceof IServiceEndpointInterface) {
 			return extractMethods((IServiceEndpointInterface) context);
 		}
 		else if (context instanceof IWebMethod) {
 			return extractParams((IWebMethod)context);
 		}

 		return new Object[0];
 	}

 	protected Object[] getWsProject(final IProject project)
 	{
 		try {
 			final IWsDOMRuntimeExtension runtime = getSupportingRuntime(project);
 			if (runtime == null) {
 				return new Object[0];
 			}

 			// WS project is loaded already
 			final IWebServiceProject wsProject = getWsProject(runtime.getDOM(), project);
 			if (wsProject != null)
 			{
 				adapterFactory.adapt(wsProject, ITreeItemContentProvider.class);
 				return new Object[] { wsProject };
 			}

 			addRuntimeLoadListener(runtime);
 			return new Object[] { new LoadingWsProject(project, false) };
 		}
 		catch (WsDOMLoadCanceledException e) { // $JL-EXC$
 			return new Object[] { new LoadingWsProject(project, true) };
 		}
 	}

 	protected IWsDomLoadListener addRuntimeLoadListener(final IWsDOMRuntimeExtension runtime)
 	{
 		IWsDomLoadListener loadListener = loadListeners.get(runtime);
 		if (loadListener!=null) {
 			return loadListener;
 		}

 		loadListener = new LoadListener(runtime);
 		loadListeners.put(runtime, loadListener);
 		runtime.addLoadListener(loadListener);

 		return loadListener;
 	}

 	protected Object[] extractMethods(final IServiceEndpointInterface sei)
 	{
 		final List<IWebMethod> webMethods = sei.getWebMethods();
 		for (IWebMethod webMethod : webMethods) {
 			adapterFactory.adapt(webMethod, ITreeItemContentProvider.class);
 		}

 		return webMethods.toArray();
 	}

 	protected Object[] extractParams(final IWebMethod method)
 	{
 		final List<IWebParam> params = method.getParameters();
 		for (IWebParam webParam : params) {
 			adapterFactory.adapt(webParam, ITreeItemContentProvider.class);
 		}

 		return params.toArray();
 	}

 	@Override
 	public boolean hasChildren(Object element)
 	{
 		if (element instanceof IWebServiceProject)
 		{
 			return true;
 		}
 		else if(element instanceof ILoadingWsProject)
 		{
 			return true;
 		}
 		else if(element instanceof IWebServiceChildList)
 		{
 			return !((IWebServiceChildList)element).getWSChildList().isEmpty();
 		}
 		else if(element instanceof ISEIChildList)
 		{
 			return !((ISEIChildList)element).getSEIChildList().isEmpty();
 		}
 		else if (element instanceof IWebService)
 		{
 			return ((IWebService) element).getServiceEndpoint() != null;
 		}
 		else if (element instanceof IServiceEndpointInterface)
 		{
 			return !((IServiceEndpointInterface)element).getWebMethods().isEmpty();
 		}
 		else if (element instanceof IWebMethod)
 		{
 			return !((IWebMethod)element).getParameters().isEmpty();
 		}

 		return false;
 	}

 	protected IWebServiceProject getWsProject(final IDOM dom, final IProject project)
 	{
 		if (dom == null) {
 			return null;
 		}

 		for (IWebServiceProject wsProject : dom.getWebServiceProjects()) {
 			if(wsProject.getName().equals(project.getName())) {
 				return wsProject;
 			}
 		}

 		return null;
 	}

 	protected IWsDOMRuntimeExtension getSupportingRuntime(final IProject project)
 	{
 		final Collection<IWsDOMRuntimeInfo> domRuntimeInfos = WsDOMRuntimeRegistry.getRegisteredRuntimesInfo();
 		Map<String, String> facets;
 		for (IWsDOMRuntimeInfo domRuntimeInfo : domRuntimeInfos)
 		{
 			facets = domRuntimeInfo.getProjectFacets();
 			if (hasFacet(facets, project)) {
 				return getDomRuntime(domRuntimeInfo.getId());
 			}
 		}

 		return null;
 	}

 	protected boolean hasFacet(final Map<String, String> facets, final IProject project)
 	{
 		for (String facetId : facets.keySet())
 		{
 			if (facetId == null || facets.get(facetId) == null) {
 				continue;
 			}

 			try {
 				if ((new FacetUtils()).hasFacetWithVersion(project, facets.get(facetId), facetId, true)){
 					return true;
 				}
 			}
 			catch (CoreException e) {
 				(new Logger()).logError(e.getMessage(), e);
 			}
 		}

 		return false;
 	}

 	protected IWsDOMRuntimeExtension getDomRuntime(String runtimeId) {
 		return WsDOMRuntimeManager.instance().getDOMRuntime(runtimeId);
 	}

 	/**
 	 * Class that is used to listen when the DOM load will be finished. After the load has finished
 	 * this class traverses the project explorers tree in order to find all instances of
 	 * {@link ILoadingWsProject} and substitute them with loaded {@link IWebServiceProject}
 	 *
 	 * @author Georgi Vachkov
 	 */
 	protected class LoadListener implements IWsDomLoadListener
 	{
 		private final IWsDOMRuntimeExtension runtime;

 		public LoadListener(final IWsDOMRuntimeExtension runtime)
 		{
 			ContractChecker.nullCheckParam(runtime, "runtime"); //$NON-NLS-1$
 			this.runtime = runtime;
 		}

 		public void finished()
 		{
 			Display.getDefault().asyncExec(new Runnable()
 			{
 				public void run()
 				{
 					final IViewPart viewPart = ProjectExplorerUtil.INSTANCE.findProjectExplorer();
 					if (viewPart instanceof CommonNavigator)
 					{
 						final CommonViewer commonViewer = ((CommonNavigator)viewPart).getCommonViewer();
 						for (TreeItem item : commonViewer.getTree().getItems()) {
 							exchangeDummy(item, commonViewer);
 						}
 					}
 				}
 			});
 		}

 		protected void exchangeDummy(final TreeItem treeItem, final CommonViewer commonViewer)
 		{
 			if (treeItem == null || treeItem.getData() instanceof IWebServiceProject) {
 				return;
 			}

 			if (treeItem.getData() instanceof ILoadingWsProject) {
 				exchangeTreeItemData(treeItem, commonViewer);
 			}
 			else {
 				for (TreeItem child : treeItem.getItems()) {
 					exchangeDummy(child, commonViewer);
 				}
 			}
 		}

 		private void exchangeTreeItemData(final TreeItem treeItem, final CommonViewer commonViewer)
 		{
 			final ILoadingWsProject loadingProject = (ILoadingWsProject)treeItem.getData();
 			try {
 				final IWebServiceProject wsProject = getWsProject(runtime.getDOM(), loadingProject.getProject());
 				adapterFactory.adapt(wsProject, ITreeItemContentProvider.class);
 				treeItem.setData(wsProject);

 			} catch (WsDOMLoadCanceledException e) { // $JL-EXC$
 				treeItem.setData(new LoadingWsProject(loadingProject.getProject(), true));
 			}

 			commonViewer.refresh(loadingProject.getProject());
 		}

 		public void started() {
 			// nothing to do here
 		}
 	}

 	private class LoadingWsProject implements ILoadingWsProject
 	{
 		final IProject project;
 		final boolean isCanceled;

 		public LoadingWsProject(final IProject project, final boolean isCanceled) {
 			ContractChecker.nullCheckParam(project, "project"); //$NON-NLS-1$
 			this.project = project;
 			this.isCanceled = isCanceled;
 		}

 		public IProject getProject() {
 			return project;
 		}

 		public boolean isLoadCanceled() {
 			return isCanceled;
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2009 by SAP AG, Walldorf.
	* 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:
	* SAP AG - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jst.ws.jaxws.dom.integration.navigator;

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

	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.emf.common.notify.AdapterFactory;
	import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
	import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
	import org.eclipse.jst.ws.jaxws.dom.integration.internal.util.ProjectExplorerUtil;
	import org.eclipse.jst.ws.jaxws.dom.integration.navigator.ILoadingWsProject.ILoadingCanceled;
	import org.eclipse.jst.ws.jaxws.dom.integration.navigator.ILoadingWsProject.ILoadingDummy;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.IDOM;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.IServiceEndpointInterface;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebMethod;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebParam;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebService;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWebServiceProject;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWsDOMRuntimeExtension;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.IWsDomLoadListener;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.WsDOMLoadCanceledException;
	import org.eclipse.jst.ws.jaxws.dom.runtime.api.WsDOMRuntimeManager;
	import org.eclipse.jst.ws.jaxws.dom.runtime.registry.IWsDOMRuntimeInfo;
	import org.eclipse.jst.ws.jaxws.dom.runtime.registry.WsDOMRuntimeRegistry;
	import org.eclipse.jst.ws.jaxws.utils.ContractChecker;
	import org.eclipse.jst.ws.jaxws.utils.facets.FacetUtils;
	import org.eclipse.jst.ws.jaxws.utils.logging.Logger;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.TreeItem;
	import org.eclipse.ui.IViewPart;
	import org.eclipse.ui.navigator.CommonNavigator;
	import org.eclipse.ui.navigator.CommonViewer;

	/**
	* Content provider for DOM related objects
	*
	* @author
	*/
	public class DOMAdapterFactoryContentProvider extends AdapterFactoryContentProvider
	{
	private Map<IWsDOMRuntimeExtension, IWsDomLoadListener> loadListeners = new HashMap<IWsDOMRuntimeExtension, IWsDomLoadListener>();

	/**
	* Constructor
	*/
	public DOMAdapterFactoryContentProvider()
	{
	this(CustomDomItemProviderAdapterFactory.INSTANCE);
	}

	/**
	* Constructor
	* @param adapterFactory
	*/
	public DOMAdapterFactoryContentProvider(AdapterFactory adapterFactory)
	{
	super(adapterFactory);
	}

	@Override
	public Object[] getChildren(final Object context)
	{
	if (context instanceof IAdaptable)
	{
	return getWsProject((IProject)((IAdaptable) context).getAdapter(IProject.class));
	}
	else if(context instanceof ILoadingWsProject)
	{
	return new Object[] { ((ILoadingWsProject)context).isLoadCanceled() ? new ILoadingCanceled(){} : new ILoadingDummy(){} };
	}
	else if(context instanceof IWebServiceProject)
	{
	return new Object[]{ adapterFactory.adapt(context, ISEIChildList.class),
	adapterFactory.adapt(context, IWebServiceChildList.class) };
	}
	else if(context instanceof IWebServiceChildList)
	{
	Object[] webServices = ((IWebServiceChildList)context).getWSChildList().toArray();

	for(int ii=0; ii<webServices.length; ii++)
	{
	adapterFactory.adapt(webServices[ii], ITreeItemContentProvider.class);
	}

	return webServices;
	}
	else if(context instanceof ISEIChildList)
	{
	Object[] sEIs = ((ISEIChildList)context).getSEIChildList().toArray();

	for(int ii=0; ii<sEIs.length; ii++)
	{
	adapterFactory.adapt(sEIs[ii], ITreeItemContentProvider.class);
	}

	return sEIs;
	}
	else if(context instanceof IWebService)
	{
	final IServiceEndpointInterface sei = ((IWebService)context).getServiceEndpoint();
	if (sei == null) {
	return new Object[0];
	}

	adapterFactory.adapt(sei, ITreeItemContentProvider.class);
	return new Object[]{ sei };
	}
	else if(context instanceof IServiceEndpointInterface) {
	return extractMethods((IServiceEndpointInterface) context);
	}
	else if (context instanceof IWebMethod) {
	return extractParams((IWebMethod)context);
	}

	return new Object[0];
	}

	protected Object[] getWsProject(final IProject project)
	{
	try {
	final IWsDOMRuntimeExtension runtime = getSupportingRuntime(project);
	if (runtime == null) {
	return new Object[0];
	}

	// WS project is loaded already
	final IWebServiceProject wsProject = getWsProject(runtime.getDOM(), project);
	if (wsProject != null)
	{
	adapterFactory.adapt(wsProject, ITreeItemContentProvider.class);
	return new Object[] { wsProject };
	}

	addRuntimeLoadListener(runtime);
	return new Object[] { new LoadingWsProject(project, false) };
	}
	catch (WsDOMLoadCanceledException e) { // $JL-EXC$
	return new Object[] { new LoadingWsProject(project, true) };
	}
	}

	protected IWsDomLoadListener addRuntimeLoadListener(final IWsDOMRuntimeExtension runtime)
	{
	IWsDomLoadListener loadListener = loadListeners.get(runtime);
	if (loadListener!=null) {
	return loadListener;
	}

	loadListener = new LoadListener(runtime);
	loadListeners.put(runtime, loadListener);
	runtime.addLoadListener(loadListener);

	return loadListener;
	}

	protected Object[] extractMethods(final IServiceEndpointInterface sei)
	{
	final List<IWebMethod> webMethods = sei.getWebMethods();
	for (IWebMethod webMethod : webMethods) {
	adapterFactory.adapt(webMethod, ITreeItemContentProvider.class);
	}

	return webMethods.toArray();
	}

	protected Object[] extractParams(final IWebMethod method)
	{
	final List<IWebParam> params = method.getParameters();
	for (IWebParam webParam : params) {
	adapterFactory.adapt(webParam, ITreeItemContentProvider.class);
	}

	return params.toArray();
	}

	@Override
	public boolean hasChildren(Object element)
	{
	if (element instanceof IWebServiceProject)
	{
	return true;
	}
	else if(element instanceof ILoadingWsProject)
	{
	return true;
	}
	else if(element instanceof IWebServiceChildList)
	{
	return !((IWebServiceChildList)element).getWSChildList().isEmpty();
	}
	else if(element instanceof ISEIChildList)
	{
	return !((ISEIChildList)element).getSEIChildList().isEmpty();
	}
	else if (element instanceof IWebService)
	{
	return ((IWebService) element).getServiceEndpoint() != null;
	}
	else if (element instanceof IServiceEndpointInterface)
	{
	return !((IServiceEndpointInterface)element).getWebMethods().isEmpty();
	}
	else if (element instanceof IWebMethod)
	{
	return !((IWebMethod)element).getParameters().isEmpty();
	}

	return false;
	}

	protected IWebServiceProject getWsProject(final IDOM dom, final IProject project)
	{
	if (dom == null) {
	return null;
	}

	for (IWebServiceProject wsProject : dom.getWebServiceProjects()) {
	if(wsProject.getName().equals(project.getName())) {
	return wsProject;
	}
	}

	return null;
	}

	protected IWsDOMRuntimeExtension getSupportingRuntime(final IProject project)
	{
	final Collection<IWsDOMRuntimeInfo> domRuntimeInfos = WsDOMRuntimeRegistry.getRegisteredRuntimesInfo();
	Map<String, String> facets;
	for (IWsDOMRuntimeInfo domRuntimeInfo : domRuntimeInfos)
	{
	facets = domRuntimeInfo.getProjectFacets();
	if (hasFacet(facets, project)) {
	return getDomRuntime(domRuntimeInfo.getId());
	}
	}

	return null;
	}

	protected boolean hasFacet(final Map<String, String> facets, final IProject project)
	{
	for (String facetId : facets.keySet())
	{
	if (facetId == null \|\| facets.get(facetId) == null) {
	continue;
	}

	try {
	if ((new FacetUtils()).hasFacetWithVersion(project, facets.get(facetId), facetId, true)){
	return true;
	}
	}
	catch (CoreException e) {
	(new Logger()).logError(e.getMessage(), e);
	}
	}

	return false;
	}

	protected IWsDOMRuntimeExtension getDomRuntime(String runtimeId) {
	return WsDOMRuntimeManager.instance().getDOMRuntime(runtimeId);
	}

	/**
	* Class that is used to listen when the DOM load will be finished. After the load has finished
	* this class traverses the project explorers tree in order to find all instances of
	* {@link ILoadingWsProject} and substitute them with loaded {@link IWebServiceProject}
	*
	* @author Georgi Vachkov
	*/
	protected class LoadListener implements IWsDomLoadListener
	{
	private final IWsDOMRuntimeExtension runtime;

	public LoadListener(final IWsDOMRuntimeExtension runtime)
	{
	ContractChecker.nullCheckParam(runtime, "runtime"); //$NON-NLS-1$
	this.runtime = runtime;
	}

	public void finished()
	{
	Display.getDefault().asyncExec(new Runnable()
	{
	public void run()
	{
	final IViewPart viewPart = ProjectExplorerUtil.INSTANCE.findProjectExplorer();
	if (viewPart instanceof CommonNavigator)
	{
	final CommonViewer commonViewer = ((CommonNavigator)viewPart).getCommonViewer();
	for (TreeItem item : commonViewer.getTree().getItems()) {
	exchangeDummy(item, commonViewer);
	}
	}
	}
	});
	}

	protected void exchangeDummy(final TreeItem treeItem, final CommonViewer commonViewer)
	{
	if (treeItem == null \|\| treeItem.getData() instanceof IWebServiceProject) {
	return;
	}

	if (treeItem.getData() instanceof ILoadingWsProject) {
	exchangeTreeItemData(treeItem, commonViewer);
	}
	else {
	for (TreeItem child : treeItem.getItems()) {
	exchangeDummy(child, commonViewer);
	}
	}
	}

	private void exchangeTreeItemData(final TreeItem treeItem, final CommonViewer commonViewer)
	{
	final ILoadingWsProject loadingProject = (ILoadingWsProject)treeItem.getData();
	try {
	final IWebServiceProject wsProject = getWsProject(runtime.getDOM(), loadingProject.getProject());
	adapterFactory.adapt(wsProject, ITreeItemContentProvider.class);
	treeItem.setData(wsProject);

	} catch (WsDOMLoadCanceledException e) { // $JL-EXC$
	treeItem.setData(new LoadingWsProject(loadingProject.getProject(), true));
	}

	commonViewer.refresh(loadingProject.getProject());
	}

	public void started() {
	// nothing to do here
	}
	}

	private class LoadingWsProject implements ILoadingWsProject
	{
	final IProject project;
	final boolean isCanceled;

	public LoadingWsProject(final IProject project, final boolean isCanceled) {
	ContractChecker.nullCheckParam(project, "project"); //$NON-NLS-1$
	this.project = project;
	this.isCanceled = isCanceled;
	}

	public IProject getProject() {
	return project;
	}

	public boolean isLoadCanceled() {
	return isCanceled;
	}
	}
	}