/*******************************************************************************
* Copyright (c) 2005, 2008 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.wst.jsdt.internal.ui.model;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.resources.mapping.ResourceMapping;
import org.eclipse.core.resources.mapping.ResourceMappingContext;
import org.eclipse.core.resources.mapping.ResourceTraversal;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;
import org.eclipse.ltk.core.refactoring.RefactoringDescriptorProxy;
import org.eclipse.ltk.core.refactoring.history.RefactoringHistory;
import org.eclipse.ltk.ui.refactoring.model.AbstractSynchronizationContentProvider;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.team.core.diff.FastDiffFilter;
import org.eclipse.team.core.diff.IDiff;
import org.eclipse.team.core.diff.IDiffChangeEvent;
import org.eclipse.team.core.diff.IDiffTree;
import org.eclipse.team.core.diff.IDiffVisitor;
import org.eclipse.team.core.mapping.IResourceDiffTree;
import org.eclipse.team.core.mapping.ISynchronizationContext;
import org.eclipse.team.core.mapping.ISynchronizationScope;
import org.eclipse.team.core.mapping.provider.ResourceDiffTree;
import org.eclipse.ui.navigator.IPipelinedTreeContentProvider;
import org.eclipse.ui.navigator.PipelinedShapeModification;
import org.eclipse.ui.navigator.PipelinedViewerUpdate;
import org.eclipse.wst.jsdt.core.IJavaScriptUnit;
import org.eclipse.wst.jsdt.core.IJavaScriptElement;
import org.eclipse.wst.jsdt.core.IJavaScriptProject;
import org.eclipse.wst.jsdt.core.IPackageFragment;
import org.eclipse.wst.jsdt.core.IPackageFragmentRoot;
import org.eclipse.wst.jsdt.core.JavaScriptCore;
import org.eclipse.wst.jsdt.internal.corext.util.JavaElementResourceMapping;
import org.eclipse.wst.jsdt.internal.ui.JavaScriptPlugin;
/**
* Java-aware synchronization content provider.
*
*
*/
public final class JavaSynchronizationContentProvider extends AbstractSynchronizationContentProvider implements IPipelinedTreeContentProvider {
/** The refactorings folder */
// private static final String NAME_REFACTORING_FOLDER= ".refactorings"; //$NON-NLS-1$
/**
* Returns the diffs associated with the element.
*
* @param context
* the synchronization context
* @param element
* the element
* @return an array of diffs
*/
static IDiff[] getDiffs(final ISynchronizationContext context, final Object element) {
return context.getDiffTree().getDiffs(getResourceTraversals(element));
}
/**
* Returns the resource mapping for the element.
*
* @param element
* the element to get the resource mapping
* @return the resource mapping
*/
static ResourceMapping getResourceMapping(final Object element) {
if (element instanceof IJavaScriptElement)
return JavaElementResourceMapping.create((IJavaScriptElement) element);
if (element instanceof IAdaptable) {
final IAdaptable adaptable= (IAdaptable) element;
final Object adapted= adaptable.getAdapter(ResourceMapping.class);
if (adapted instanceof ResourceMapping)
return (ResourceMapping) adapted;
}
return null;
}
/**
* Returns the resource traversals for the element.
*
* @param element
* the element to get the resource traversals
* @return the resource traversals
*/
static ResourceTraversal[] getResourceTraversals(final Object element) {
final ResourceMapping mapping= getResourceMapping(element);
if (mapping != null)
try {
return mapping.getTraversals(ResourceMappingContext.LOCAL_CONTEXT, new NullProgressMonitor());
} catch (final CoreException exception) {
JavaScriptPlugin.log(exception);
}
return new ResourceTraversal[0];
}
/** The content provider, or <code>null</code> */
private ITreeContentProvider fContentProvider= null;
/** The model root, or <code>null</code> */
private Object fModelRoot= null;
/**
* Returns the java element associated with the project.
*
* @param project
* the project
* @return the associated java element, or <code>null</code> if the
* project is not a java project
*/
private IJavaScriptProject asJavaProject(final IProject project) {
try {
if (project.getDescription().hasNature(JavaScriptCore.NATURE_ID))
return JavaScriptCore.create(project);
} catch (final CoreException exception) {
// Only log the error for projects that are accessible (i.e. exist and are open)
if (project.isAccessible())
JavaScriptPlugin.log(exception);
}
return null;
}
/**
* Converts the shape modification to use java elements.
*
* @param modification
* the shape modification to convert
*/
private void convertToJavaElements(final PipelinedShapeModification modification) {
final Object parent= modification.getParent();
if (parent instanceof IResource) {
final IJavaScriptElement project= asJavaProject(((IResource) parent).getProject());
if (project != null) {
modification.getChildren().clear();
return;
}
}
if (parent instanceof ISynchronizationContext) {
final Set result= new HashSet();
for (final Iterator iterator= modification.getChildren().iterator(); iterator.hasNext();) {
final Object element= iterator.next();
if (element instanceof IProject) {
final IJavaScriptElement project= asJavaProject((IProject) element);
if (project != null) {
iterator.remove();
result.add(project);
}
}
}
modification.getChildren().addAll(result);
}
}
/**
* Converts the viewer update to use java elements.
*
* @param update
* the viewer update to convert
* @return <code>true</code> if any elements have been converted,
* <code>false</code> otherwise
*/
private boolean convertToJavaElements(final PipelinedViewerUpdate update) {
final Set result= new HashSet();
for (final Iterator iterator= update.getRefreshTargets().iterator(); iterator.hasNext();) {
final Object element= iterator.next();
if (element instanceof IProject) {
final IJavaScriptElement project= asJavaProject((IProject) element);
if (project != null) {
iterator.remove();
result.add(project);
}
}
}
update.getRefreshTargets().addAll(result);
return !result.isEmpty();
}
/**
* {@inheritDoc}
*/
public void diffsChanged(final IDiffChangeEvent event, final IProgressMonitor monitor) {
syncExec(new Runnable() {
public void run() {
handleChange(event);
}
}, getViewer().getControl());
}
/**
* Returns all the existing projects that contain additions,
* removals or deletions.
*
* @param event
* the event
* @return the projects that contain changes
*/
private IJavaScriptProject[] getChangedProjects(final IDiffChangeEvent event) {
final Set result= new HashSet();
final IDiff[] changes= event.getChanges();
for (int index= 0; index < changes.length; index++) {
final IResource resource= ResourceDiffTree.getResourceFor(changes[index]);
if (resource != null) {
final IJavaScriptProject project= asJavaProject(resource.getProject());
if (project != null)
result.add(project);
}
}
final IDiff[] additions= event.getAdditions();
for (int index= 0; index < additions.length; index++) {
final IResource resource= ResourceDiffTree.getResourceFor(additions[index]);
if (resource != null) {
final IJavaScriptProject project= asJavaProject(resource.getProject());
if (project != null)
result.add(project);
}
}
final IPath[] removals = event.getRemovals();
for (int i = 0; i < removals.length; i++) {
IPath path = removals[i];
if (path.segmentCount() > 0) {
IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(path.segment(0));
// Only consider projects that still exist
if (project.exists()) {
final IJavaScriptProject javaProject= asJavaProject(project.getProject());
if (javaProject != null)
result.add(javaProject);
}
}
}
return (IJavaScriptProject[]) result.toArray(new IJavaScriptProject[result.size()]);
}
/**
* {@inheritDoc}
*/
protected Object[] getChildrenInContext(final ISynchronizationContext context, final Object parent, final Object[] children) {
final Object[] elements= super.getChildrenInContext(context, parent, children);
if (parent instanceof IPackageFragment)
return getPackageFragmentChildren(context, parent, elements);
else if (parent instanceof IPackageFragmentRoot)
return getPackageFragmentRootChildren(context, parent, elements);
else if (parent instanceof IJavaScriptProject)
return getJavaProjectChildren(context, parent, elements);
else if (parent instanceof RefactoringHistory)
return ((RefactoringHistory) parent).getDescriptors();
// It may be the case that the elements are folders that have a corresponding
// source folder in which case they should be filtered out
return getFilteredElements(parent, elements);
}
/**
* Returns the filtered elements.
*
* @param parent
* the parent element
* @param children
* the child elements
* @return the filtered elements
*/
private Object[] getFilteredElements(final Object parent, final Object[] children) {
final List result= new ArrayList(children.length);
for (int index= 0; index < children.length; index++) {
if (children[index] instanceof IFolder) {
if (!(JavaScriptCore.create((IFolder) children[index]) instanceof IPackageFragmentRoot))
result.add(children[index]);
} else
result.add(children[index]);
}
return result.toArray();
}
/**
* {@inheritDoc}
*/
protected ITreeContentProvider getDelegateContentProvider() {
if (fContentProvider == null)
fContentProvider= new JavaModelContentProvider();
return fContentProvider;
}
/**
* Returns the projects that used to have changes in the diff tree
* but have been deleted from the workspace.
*
* @param event
* the event
* @return the deleted projects
*/
private Set getDeletedProjects(final IDiffChangeEvent event) {
final Set result= new HashSet();
final IPath[] deletions= event.getRemovals();
for (int index= 0; index < deletions.length; index++) {
final IPath path= deletions[index];
if (path.segmentCount() > 0) {
IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(path.segment(0));
if (!project.isAccessible())
result.add(project);
}
}
return result;
}
/**
* Since the this content provider overrides the resource content provider,
* this method is only invoked when the resource content provider is
* disabled. In this case, we still want the Java projects to appear at the
* root of the view.
*
* {@inheritDoc}
*/
public Object[] getElements(Object parent) {
if (parent instanceof ISynchronizationContext)
// Put the resource projects directly under the context
parent= getModelRoot();
return super.getElements(parent);
}
/**
* Returns the java project children in the current scope.
*
* @param context
* the synchronization context
* @param parent
* the parent element
* @param children
* the child elements
* @return the java project children
*/
private Object[] getJavaProjectChildren(final ISynchronizationContext context, final Object parent, final Object[] children) {
final LinkedList list= new LinkedList();
for (int index= 0; index < children.length; index++) {
if (children[index] instanceof IPackageFragment) {
final IPackageFragment fragment= (IPackageFragment) children[index];
if (getChildren(fragment).length == 0)
continue;
}
// We need to check whether a folder has non-fragment children (bug 138767)
if (children[index] instanceof IFolder) {
IFolder folder = (IFolder) children[index];
if (getChildren(folder).length == 0)
continue;
}
list.add(children[index]);
}
final IResource resource= JavaModelProvider.getResource(parent);
if (resource != null) {
final IResourceDiffTree tree= context.getDiffTree();
final IResource[] members= tree.members(resource);
for (int index= 0; index < members.length; index++) {
IResource child = members[index];
if (isVisible(context, child)) {
if (hasPhantomFolder(tree, child)) {
// Add any phantom resources that are visible
list.add(child);
}
// if (members[index] instanceof IFolder) {
// final IFolder folder= (IFolder) members[index];
// if (folder.getName().equals(NAME_REFACTORING_FOLDER)) {
// final RefactoringHistory history= getRefactorings(context, (IProject) resource, null);
// if (!history.isEmpty()) {
// list.remove(folder);
// list.addFirst(history);
// }
// }
// }
}
}
}
return list.toArray(new Object[list.size()]);
}
private boolean hasPhantomFolder(IResourceDiffTree tree, IResource child) {
if (!child.exists())
return true;
final boolean[] found = new boolean[] { false };
tree.accept(child.getFullPath(), new IDiffVisitor() {
public boolean visit(IDiff delta){
IResource treeResource = ResourceDiffTree.getResourceFor(delta);
if (treeResource.getType()==IResource.FILE && !treeResource.getParent().exists()){
found[0] = true;
return false;
}
return true;
}}, IResource.DEPTH_INFINITE);
return found[0];
}
/**
* {@inheritDoc}
*/
protected String getModelProviderId() {
return JavaModelProvider.JAVA_MODEL_PROVIDER_ID;
}
/**
* {@inheritDoc}
*/
protected Object getModelRoot() {
if (fModelRoot == null)
fModelRoot= JavaScriptCore.create(ResourcesPlugin.getWorkspace().getRoot());
return fModelRoot;
}
/**
* Returns the package fragment children in the current scope.
*
* @param context
* the synchronization context
* @param parent
* the parent element
* @param children
* the child elements
* @return the package fragment children
*/
private Object[] getPackageFragmentChildren(final ISynchronizationContext context, final Object parent, final Object[] children) {
final Set set= new HashSet();
for (int index= 0; index < children.length; index++)
set.add(children[index]);
final IResource resource= ((IPackageFragment) parent).getResource();
if (resource != null) {
final IResourceDiffTree tree= context.getDiffTree();
final IResource[] members= tree.members(resource);
for (int index= 0; index < members.length; index++) {
final int type= members[index].getType();
if (type == IResource.FILE) {
final IDiff diff= tree.getDiff(members[index]);
if (diff != null && isVisible(diff))
if (isInScope(context.getScope(), parent, members[index])) {
final IJavaScriptElement element= JavaScriptCore.create(members[index]);
if (element == null) {
set.add(members[index]);
} else {
set.add(element);
}
}
}
}
}
return set.toArray(new Object[set.size()]);
}
/**
* Returns the package fragment root children in the current scope.
*
* @param context
* the synchronization context
* @param parent
* the parent element
* @param children
* the child elements
* @return the package fragment root children
*/
private Object[] getPackageFragmentRootChildren(final ISynchronizationContext context, final Object parent, final Object[] children) {
final Set set= new HashSet();
for (int index= 0; index < children.length; index++) {
if (children[index] instanceof IPackageFragment) {
IPackageFragment fragment = (IPackageFragment) children[index];
if (fragment.isOpen() && getChildren(fragment).length == 0)
// Don't add the default package unless it has children
continue;
}
set.add(children[index]);
}
final IResource resource= JavaModelProvider.getResource(parent);
if (resource != null) {
final IResourceDiffTree tree= context.getDiffTree();
final IResource[] members= tree.members(resource);
for (int index= 0; index < members.length; index++) {
final int type= members[index].getType();
final boolean contained= isInScope(context.getScope(), parent, members[index]);
final boolean visible= isVisible(context, members[index]);
if (type == IResource.FILE && contained && visible) {
// If the file is not a compilation unit add it.
// (compilation units are always children of packages so they
// don't need to be added here)
final IJavaScriptElement element= JavaScriptCore.create((IFile) members[index]);
if (element == null)
set.add(members[index]);
} else if (type == IResource.FOLDER && contained && visible && tree.getDiff(members[index]) != null) {
// If the folder is out-of-sync, add it
final IJavaScriptElement element= JavaScriptCore.create(members[index]);
if (element != null)
set.add(element);
}
if (type == IResource.FOLDER) {
// If the folder contains java elements, add it
final IFolder folder= (IFolder) members[index];
tree.accept(folder.getFullPath(), new IDiffVisitor() {
public final boolean visit(final IDiff diff) {
if (isVisible(diff)) {
final IResource current= tree.getResource(diff);
if (current != null) {
final int kind= current.getType();
if (kind == IResource.FILE) {
final IJavaScriptElement element= JavaScriptCore.create(current.getParent());
if (element != null)
set.add(element);
} else {
final IJavaScriptElement element= JavaScriptCore.create(current);
if (element != null)
set.add(element);
}
}
}
return true;
}
}, IResource.DEPTH_INFINITE);
}
}
return set.toArray(new Object[set.size()]);
}
return children;
}
/**
* {@inheritDoc}
*/
public void getPipelinedChildren(final Object parent, final Set children) {
if (parent instanceof ISynchronizationContext) {
// When a context is the root, the resource content provider returns
// projects as direct children. We should replace any projects that
// are Java projects with an IJavaScriptProject
final Set result= new HashSet(children.size());
for (final Iterator iterator= children.iterator(); iterator.hasNext();) {
final Object element= iterator.next();
if (element instanceof IProject) {
final IJavaScriptElement java= asJavaProject((IProject) element);
if (java != null) {
iterator.remove();
result.add(java);
}
}
if (element instanceof IFolder) {
IFolder folder = (IFolder) element;
IJavaScriptElement javaElement = JavaScriptCore.create(folder);
// If the folder is also a package, don't show it
// as a folder since it will be shown as a package
if (javaElement instanceof IPackageFragmentRoot) {
iterator.remove();
}
}
}
children.addAll(result);
} else if (parent instanceof ISynchronizationScope) {
// When the root is a scope, we should return the
// Java model provider so all model providers appear
// at the root of the viewer.
children.add(getModelProvider());
} else if (parent instanceof IFolder) {
// Remove any children that are also source folders so they
// don't appear twice
for (final Iterator iterator= children.iterator(); iterator.hasNext();) {
final Object element= iterator.next();
if (element instanceof IFolder) {
IFolder folder = (IFolder) element;
IJavaScriptElement javaElement = JavaScriptCore.create(folder);
if (javaElement instanceof IPackageFragmentRoot) {
iterator.remove();
}
}
}
}
}
/**
* {@inheritDoc}
*/
public void getPipelinedElements(final Object element, final Set elements) {
getPipelinedChildren(element, elements);
}
/**
* {@inheritDoc}
*/
public Object getPipelinedParent(final Object element, final Object parent) {
if (element instanceof IJavaScriptElement)
return getParent(element);
return parent;
}
/**
* {@inheritDoc}
*/
protected ResourceTraversal[] getTraversals(final ISynchronizationContext context, final Object object) {
return getResourceTraversals(object);
}
/**
* Returns the visible projects.
*
* @return the visible projects
*/
private Set getVisibleProjects() {
final TreeItem[] children= ((TreeViewer) getViewer()).getTree().getItems();
final Set result= new HashSet();
for (int index= 0; index < children.length; index++) {
final Object data= children[index].getData();
if (data instanceof IJavaScriptProject)
result.add(data);
}
return result;
}
/**
* Handles a diff change event.
*
* @param event
* the event
*/
private void handleChange(final IDiffChangeEvent event) {
final Set existing= getVisibleProjects();
// Get all existing and open projects that contain changes
// and determine what needs to be done to the project
// (i.e. add, remove or refresh)
final IJavaScriptProject[] changed= getChangedProjects(event);
final List refreshes= new ArrayList(changed.length);
final List additions= new ArrayList(changed.length);
final List removals= new ArrayList(changed.length);
for (int index= 0; index < changed.length; index++) {
final IJavaScriptProject project= changed[index];
if (hasVisibleChanges(event.getTree(), project)) {
if (existing.contains(project))
refreshes.add(project);
else
additions.add(project);
} else
removals.add(project);
}
// Remove any java projects that correspond to deleted or closed projects
final Set removed= getDeletedProjects(event);
for (final Iterator iterator= existing.iterator(); iterator.hasNext();) {
final IJavaScriptProject element= (IJavaScriptProject) iterator.next();
if (removed.contains(element.getResource()))
removals.add(element);
}
if (!removals.isEmpty() || !additions.isEmpty() || !refreshes.isEmpty()) {
final TreeViewer viewer= (TreeViewer) getViewer();
final Tree tree= viewer.getTree();
try {
tree.setRedraw(false);
if (!additions.isEmpty())
viewer.add(viewer.getInput(), additions.toArray());
if (!removals.isEmpty())
viewer.remove(viewer.getInput(), removals.toArray());
if (!refreshes.isEmpty()) {
for (final Iterator iter= refreshes.iterator(); iter.hasNext();)
viewer.refresh(iter.next());
}
} finally {
tree.setRedraw(true);
}
}
}
/**
* {@inheritDoc}
*/
public boolean hasChildren(final Object element) {
if (element instanceof IJavaScriptUnit || element instanceof IFile || element instanceof RefactoringDescriptorProxy || element instanceof RefactoringDescriptor)
return false;
return super.hasChildren(element);
}
/**
* Returns whether the element has some children in the current scope.
*
* @param scope
* the synchronization scope
* @param element
* the element
* @param resource
* the resource
* @return <code>true</code> if it has some children, <code>false</code>
* otherwise
*/
private boolean hasChildrenInScope(final ISynchronizationScope scope, final Object element, final IResource resource) {
final IResource[] roots= scope.getRoots();
final IPath path= resource.getFullPath();
if (element instanceof IPackageFragment) {
for (int index= 0; index < roots.length; index++)
if (path.equals(roots[index].getFullPath().removeLastSegments(1)))
return true;
return false;
}
for (int index= 0; index < roots.length; index++)
if (path.isPrefixOf(roots[index].getFullPath()))
return true;
return false;
}
/**
* Has the java project visible changes?
*
* @param tree
* the diff tree
* @param project
* the java project
* @return <code>true</code> if it has visible changes, <code>false</code>
* otherwise
*/
private boolean hasVisibleChanges(final IDiffTree tree, final IJavaScriptProject project) {
return tree.hasMatchingDiffs(project.getResource().getFullPath(), new FastDiffFilter() {
public boolean select(final IDiff diff) {
return isVisible(diff);
}
});
}
/**
* {@inheritDoc}
*/
public PipelinedShapeModification interceptAdd(final PipelinedShapeModification modification) {
convertToJavaElements(modification);
return modification;
}
/**
* {@inheritDoc}
*/
public boolean interceptRefresh(final PipelinedViewerUpdate update) {
return convertToJavaElements(update);
}
/**
* {@inheritDoc}
*/
public PipelinedShapeModification interceptRemove(final PipelinedShapeModification modification) {
convertToJavaElements(modification);
return modification;
}
/**
* {@inheritDoc}
*/
public boolean interceptUpdate(final PipelinedViewerUpdate anUpdateSynchronization) {
return convertToJavaElements(anUpdateSynchronization);
}
/**
* {@inheritDoc}
*/
protected boolean isInScope(final ISynchronizationScope scope, final Object parent, final Object element) {
final IResource resource= JavaModelProvider.getResource(element);
if (resource == null)
return false;
if (scope.contains(resource))
return true;
if (hasChildrenInScope(scope, element, resource))
return true;
return false;
}
/**
* Executes the given runnable.
*
* @param runnable
* the runnable
* @param control
* the control
*/
private void syncExec(final Runnable runnable, final Control control) {
if (control != null && !control.isDisposed())
control.getDisplay().syncExec(new Runnable() {
public void run() {
if (!control.isDisposed())
BusyIndicator.showWhile(control.getDisplay(), runnable);
}
});
}
}