plugins/org.eclipse.jst.servlet.ui/servlet_ui/org/eclipse/jst/servlet/ui/internal/navigator/WebJavaContentProvider.java

/***************************************************************************************************
 * Copyright (c) 2003, 2004 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.jst.servlet.ui.internal.navigator;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.resources.IResource;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.navigator.CommonViewer;
import org.eclipse.ui.navigator.ICommonContentExtensionSite;
import org.eclipse.ui.navigator.INavigatorContentExtension;
import org.eclipse.ui.navigator.INavigatorContentService;
import org.eclipse.ui.navigator.IPipelinedTreeContentProvider;
import org.eclipse.ui.navigator.PipelinedShapeModification;
import org.eclipse.ui.navigator.PipelinedViewerUpdate;

public class WebJavaContentProvider implements IPipelinedTreeContentProvider  {

	private static final Object[] NO_CHILDREN = new Object[0];
	private static final String JAVA_EXTENSION_ID = "org.eclipse.jdt.java.ui.javaContent"; //$NON-NLS-1$

	/*
	 * JDT likes to make it interesting so just one of their viewer types is made internal To avoid
	 * the dependency, we use some reflection here to filter the type.
	 */

	private static Class INTERNAL_CONTAINER_CLASS;
	static {
		try {
			INTERNAL_CONTAINER_CLASS = Class.forName("org.eclipse.jdt.internal.ui.packageview.ClassPathContainer"); //$NON-NLS-1$
		} catch (Throwable t) {
			// ignore if the class has been removed or renamed.
			INTERNAL_CONTAINER_CLASS = null;
		}
	}


	private CommonViewer commonViewer;
	private ITreeContentProvider delegateContentProvider;
	private final Map compressedNodes = new HashMap();

	public void getPipelinedChildren(Object aParent, Set theCurrentChildren) {
		if (aParent instanceof IJavaProject) {
			cleanJavaContribution(theCurrentChildren);
			theCurrentChildren.add(getCompressedNode((IJavaProject) aParent));
		} 
	}

	private void cleanJavaContribution(Set theCurrentChildren) {
		IJavaElement element = null;
		for (Iterator iter = theCurrentChildren.iterator(); iter.hasNext();) {
			Object child = iter.next();
			if (child instanceof IResource && ((element = JavaCore.create((IResource) child)) != null) && element.exists())
				iter.remove();
			else if (child instanceof IJavaElement)
				iter.remove();
			else if (INTERNAL_CONTAINER_CLASS != null && INTERNAL_CONTAINER_CLASS.isInstance(child))
				iter.remove();
		}
	}

	private CompressedJavaProject getCompressedNode(IJavaProject project) {
		CompressedJavaProject result = (CompressedJavaProject) compressedNodes.get(project);
		if (result == null) {
			compressedNodes.put(project, result = new CompressedJavaProject(commonViewer, project));
		}
		return result;
	}

	public void getPipelinedElements(Object anInput, Set theCurrentElements) { 

	}

	public Object getPipelinedParent(Object anObject, Object aSuggestedParent) {

		if (anObject instanceof IPackageFragmentRoot) {
			IPackageFragmentRoot root = (IPackageFragmentRoot) anObject;
			if (!root.isExternal() && aSuggestedParent instanceof IJavaProject) {
				return getCompressedNode((IJavaProject) aSuggestedParent);
			}
		} else if(INTERNAL_CONTAINER_CLASS.isInstance(anObject) && aSuggestedParent instanceof IJavaProject) {
			return getCompressedNode( (IJavaProject) aSuggestedParent ).getCompressedJavaLibraries();
		}
		
		return null;
	}

	public PipelinedShapeModification interceptAdd(PipelinedShapeModification anAddModification) {
		Object parent = anAddModification.getParent();
		
		if (parent instanceof IPackageFragmentRoot) {
			IPackageFragmentRoot sourceFolder = (IPackageFragmentRoot) parent;
			CompressedJavaProject compressedNode = getCompressedNode(sourceFolder.getJavaProject());
			if(compressedNode.isFlatteningSourceFolder()) {
				anAddModification.setParent(compressedNode);
			}
			
		} 
		
		return anAddModification;
	}
	

	public PipelinedShapeModification interceptRemove(PipelinedShapeModification aRemoveModification) {

		Object parent = aRemoveModification.getParent();
		
		if (parent instanceof IPackageFragmentRoot) {
			IPackageFragmentRoot sourceFolder = (IPackageFragmentRoot) parent;
			CompressedJavaProject compressedNode = getCompressedNode(sourceFolder.getJavaProject());
			if(compressedNode.isFlatteningSourceFolder()) {
				aRemoveModification.setParent(compressedNode);
			}
			
		} 
		
		return aRemoveModification;
	}

	public boolean interceptRefresh(PipelinedViewerUpdate aRefreshSynchronization) {
		
		Set refreshTargets = aRefreshSynchronization.getRefreshTargets();
		for (Iterator iter = refreshTargets.iterator(); iter.hasNext();) {
			Object refreshTarget = iter.next();
			if (refreshTarget instanceof IPackageFragmentRoot) {
				IPackageFragmentRoot sourceFolder = (IPackageFragmentRoot) refreshTarget;
				CompressedJavaProject compressedNode = getCompressedNode(sourceFolder.getJavaProject());
				if(compressedNode.isFlatteningSourceFolder()) {
					iter.remove(); // voids the iter but is okay because we're done with it
					refreshTargets.add(compressedNode);
					return true;
				}
				
			}
		}
		
		return false;
	}


	public boolean interceptUpdate(PipelinedViewerUpdate anUpdateSynchronization) {
		Set refreshTargets = anUpdateSynchronization.getRefreshTargets();
		for (Iterator iter = refreshTargets.iterator(); iter.hasNext();) {
			Object refreshTarget = iter.next();
			if (refreshTarget instanceof IPackageFragmentRoot) {
				IPackageFragmentRoot sourceFolder = (IPackageFragmentRoot) refreshTarget;
				if (sourceFolder.getJavaProject()!=null && sourceFolder.getJavaProject().exists() && sourceFolder.getJavaProject().isOpen()) {
					CompressedJavaProject compressedNode = getCompressedNode(sourceFolder.getJavaProject());
					if(compressedNode.isFlatteningSourceFolder()) {
						iter.remove(); // voids the iterator; but is okay because we're done with it
						refreshTargets.add(compressedNode);
						return true;
					}
				}
			}
		}
		
		return false; 
	}

	public void init(ICommonContentExtensionSite aSite) { 
	}

	public Object[] getChildren(Object parentElement) {
		if (delegateContentProvider != null) {
			if (parentElement instanceof CompressedJavaProject) {
				return ((CompressedJavaProject)parentElement).getChildren(delegateContentProvider);
			} else if (parentElement instanceof CompressedJavaLibraries) { 
				return ((CompressedJavaLibraries)parentElement).getChildren(delegateContentProvider);
			}
		}
		return NO_CHILDREN;
	}

	public Object getParent(Object element) {
		if (element instanceof CompressedJavaProject)
			return ((CompressedJavaProject) element).getProject();
		if (element instanceof CompressedJavaLibraries) 
			return ((CompressedJavaLibraries) element).getCompressedProject();
		return null;
	}

	public boolean hasChildren(Object element) {
		return (element instanceof CompressedJavaProject || element instanceof CompressedJavaLibraries);
	}

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

	public void dispose() { 
		compressedNodes.clear(); 
	}

	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
		if (viewer instanceof CommonViewer) {
			commonViewer = (CommonViewer) viewer;
			INavigatorContentService service = commonViewer.getNavigatorContentService();
			INavigatorContentExtension javaext = service.getContentExtensionById(JAVA_EXTENSION_ID);
			if (javaext != null)
				delegateContentProvider = javaext.getContentProvider();
			compressedNodes.clear();
		}

	}

	public void restoreState(IMemento aMemento) {

	}

	public void saveState(IMemento aMemento) {

	}
	
	public boolean isClasspathContainer(Object o) {		
		return INTERNAL_CONTAINER_CLASS != null && INTERNAL_CONTAINER_CLASS.isInstance(o);
	} 

}