Bug 128950 [Model Sync] Compress layout operations should match depth

8 files changed, 343 insertions, 210 deletions

diff --git a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceMarkAsMergedHandler.java b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceMarkAsMergedHandler.java
index 835628151..a59ace279 100644
--- a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceMarkAsMergedHandler.java
+++ b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceMarkAsMergedHandler.java
@@ -40,7 +40,7 @@ public class ResourceMarkAsMergedHandler extends MergeActionHandler {
 	protected synchronized SynchronizationOperation getOperation() {
 		if (operation == null) {
 			operation = new ResourceModelProviderOperation(getConfiguration(),
-						getStructuredSelection().toArray()) {
+						getStructuredSelection()) {
 				/* (non-Javadoc)
 				 * @see org.eclipse.jface.operation.IRunnableWithProgress#run(org.eclipse.core.runtime.IProgressMonitor)
 				 */
@@ -48,7 +48,7 @@ public class ResourceMarkAsMergedHandler extends MergeActionHandler {
 						throws InvocationTargetException, InterruptedException {
 					try {
 						final IMergeContext context = (IMergeContext) getContext();
-						final IDiff[] deltas = getFileDeltas(getElements());
+						final IDiff[] deltas = getTargetDiffs();
 						ISchedulingRule rule = getMergeRule(context, deltas);
 						context.run(new IWorkspaceRunnable() {
 							public void run(IProgressMonitor monitor)
diff --git a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceMergeHandler.java b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceMergeHandler.java
index c4c1f8462..f12743063 100644
--- a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceMergeHandler.java
+++ b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceMergeHandler.java
@@ -35,7 +35,7 @@ public class ResourceMergeHandler extends MergeActionHandler {
 	 */
 	protected synchronized SynchronizationOperation getOperation() {
 		if (operation == null) {
-			operation = new ResourceModelProviderOperation(getConfiguration(), getStructuredSelection().toArray()) {
+			operation = new ResourceModelProviderOperation(getConfiguration(), getStructuredSelection()) {
 				/* (non-Javadoc)
 				 * @see org.eclipse.jface.operation.IRunnableWithProgress#run(org.eclipse.core.runtime.IProgressMonitor)
 				 */
@@ -43,7 +43,7 @@ public class ResourceMergeHandler extends MergeActionHandler {
 						InterruptedException {
 					try {
 						IMergeContext context = (IMergeContext)getContext();
-						IDiff[] diffs = getFileDeltas(getElements());
+						IDiff[] diffs = getTargetDiffs();
 						IStatus status = context.merge(diffs, overwrite, monitor);
 						if (!status.isOK())
 							throw new CoreException(status);
diff --git a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceModelContentProvider.java b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceModelContentProvider.java
index ba6d01858..8e2065498 100644
--- a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceModelContentProvider.java
+++ b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceModelContentProvider.java
@@ -15,7 +15,6 @@ import java.util.*;
 import org.eclipse.core.resources.*;
 import org.eclipse.core.resources.mapping.*;
 import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.Path;
 import org.eclipse.jface.util.PropertyChangeEvent;
 import org.eclipse.jface.viewers.*;
 import org.eclipse.team.core.diff.IDiff;
@@ -41,23 +40,6 @@ public class ResourceModelContentProvider extends SynchronizationContentProvider
 
 	private WorkbenchContentProvider provider;
 
-	public static String getLayout() {
-		return TeamUIPlugin.getPlugin().getPreferenceStore().getString(IPreferenceIds.SYNCVIEW_DEFAULT_LAYOUT);
-	}
-	
-	public static int getLayoutDepth(IResource resource) {
-		if (resource.getType() == IResource.PROJECT)
-			return IResource.DEPTH_INFINITE;
-		if (resource.getType() == IResource.FILE) 
-			return IResource.DEPTH_ZERO;
-		if (getLayout().equals(IPreferenceIds.FLAT_LAYOUT)) {
-			return IResource.DEPTH_ZERO;
-		} else if (getLayout().equals(IPreferenceIds.COMPRESSED_LAYOUT)) {
-			return IResource.DEPTH_ONE;
-		}
-		return IResource.DEPTH_INFINITE;
-	}
-	
 	/* (non-Javadoc)
 	 * @see org.eclipse.team.internal.ui.mapping.AbstractTeamAwareContentProvider#getDelegateContentProvider()
 	 */
@@ -118,6 +100,7 @@ public class ResourceModelContentProvider extends SynchronizationContentProvider
 	public void init(ICommonContentExtensionSite site) {
 		super.init(site);
 		TeamUIPlugin.getPlugin().getPreferenceStore().addPropertyChangeListener(this);
+		getConfiguration().setProperty(ResourceModelTraversalCalculator.PROP_TRAVERSAL_CALCULATOR, new ResourceModelTraversalCalculator());
 	}
 	
 	/* (non-Javadoc)
@@ -142,109 +125,15 @@ public class ResourceModelContentProvider extends SynchronizationContentProvider
 	protected Object[] getChildrenInContext(ISynchronizationContext context, Object parent, Object[] children) {
 		if (parent instanceof IResource) {
 			IResource resource = (IResource) parent;
-			if (resource.getType() != IResource.ROOT && !resource.getProject().isAccessible())
+			if (resource.getType() == IResource.PROJECT && !resource.getProject().isAccessible())
 				return new Object[0];
 			IResourceDiffTree diffTree = context.getDiffTree();
-			Object[] allChildren = filterChildren(diffTree, resource, children);
+			Object[] allChildren = getTraversalCalculator().filterChildren(diffTree, resource, children);
 			return super.getChildrenInContext(context, parent, allChildren);
 		}
 		return super.getChildrenInContext(context, parent, children);
 	}
 
-	protected Object[] filterChildren(IResourceDiffTree diffTree, IResource resource, Object[] children) {
-		Object[] allChildren;
-		if (getLayout().equals(IPreferenceIds.FLAT_LAYOUT) && resource.getType() == IResource.PROJECT) {
-			allChildren = getFlatChildren(diffTree, resource);
-		} else if (getLayout().equals(IPreferenceIds.COMPRESSED_LAYOUT) && resource.getType() == IResource.PROJECT) {
-			allChildren = getCompressedChildren(diffTree, (IProject)resource, children);
-		} else if (getLayout().equals(IPreferenceIds.COMPRESSED_LAYOUT) && resource.getType() == IResource.FOLDER) {
-			allChildren = getCompressedChildren(diffTree, (IFolder)resource, children);
-		} else {
-			allChildren = getTreeChildren(diffTree, resource, children);
-		}
-		return allChildren;
-	}
-
-	private Object[] getCompressedChildren(IResourceDiffTree diffTree, IProject project, Object[] children) {
-		Set result = new HashSet();
-		IDiff[] diffs = diffTree.getDiffs(project, IResource.DEPTH_INFINITE);
-		for (int i = 0; i < diffs.length; i++) {
-			IDiff diff = diffs[i];
-			IResource resource = diffTree.getResource(diff);
-			if (resource.getType() == IResource.FILE) {
-				IContainer parent = resource.getParent();
-				if (parent.getType() == IResource.FOLDER)
-					result.add(parent);
-				else 
-					result.add(resource);
-			} else if (resource.getType() == IResource.FOLDER)
-				result.add(resource);
-		}
-		return result.toArray();
-	}
-
-	/*
-	 * Only return the files that are direct children of the folder
-	 */
-	private Object[] getCompressedChildren(IResourceDiffTree diffTree, IFolder folder, Object[] children) {
-		Set result = new HashSet();
-		for (int i = 0; i < children.length; i++) {
-			Object object = children[i];
-			if (object instanceof IResource) {
-				IResource resource = (IResource) object;
-				if (resource.getType() == IResource.FILE)
-					result.add(resource);
-			}
-		}
-		IDiff[] diffs = diffTree.getDiffs(folder, IResource.DEPTH_ONE);
-		for (int i = 0; i < diffs.length; i++) {
-			IDiff diff = diffs[i];
-			IResource resource = diffTree.getResource(diff);
-			if (resource.getType() == IResource.FILE)
-				result.add(resource);
-		}
-		return result.toArray();
-	}
-
-	private Object[] getFlatChildren(IResourceDiffTree diffTree, IResource resource) {
-		Object[] allChildren;
-		IDiff[] diffs = diffTree.getDiffs(resource, IResource.DEPTH_INFINITE);
-		ArrayList result = new ArrayList();
-		for (int i = 0; i < diffs.length; i++) {
-			IDiff diff = diffs[i];
-			result.add(diffTree.getResource(diff));
-		}
-		allChildren = result.toArray();
-		return allChildren;
-	}
-
-	private Object[] getTreeChildren(IResourceDiffTree diffTree, IResource resource, Object[] children) {
-		Set result = new HashSet();
-		for (int i = 0; i < children.length; i++) {
-			Object object = children[i];
-			result.add(object);
-		}
-		IPath[] childPaths = diffTree.getChildren(resource.getFullPath());
-		for (int i = 0; i < childPaths.length; i++) {
-			IPath path = childPaths[i];
-			IDiff delta = diffTree.getDiff(path);
-			IResource child;
-			if (delta == null) {
-				// the path has descendent deltas so it must be a folder
-				if (path.segmentCount() == 1) {
-					child = ((IWorkspaceRoot)resource).getProject(path.lastSegment());
-				} else {
-					child = ((IContainer)resource).getFolder(new Path(path.lastSegment()));
-				}
-			} else {
-				child = diffTree.getResource(delta);
-			}
-			result.add(child);
-		}
-		Object[] allChildren = result.toArray(new Object[result.size()]);
-		return allChildren;
-	}
-
 	protected ResourceTraversal[] getTraversals(ISynchronizationContext context, Object object) {
 		ISynchronizationScope scope = context.getScope();
 		// First see if the object is a root of the scope
@@ -428,4 +317,12 @@ public class ResourceModelContentProvider extends SynchronizationContentProvider
 		if (resources.length > 0)
 			((AbstractTreeViewer)getViewer()).update(resources, null);
 	}
+	
+	protected ResourceModelTraversalCalculator getTraversalCalculator() {
+		return (ResourceModelTraversalCalculator)getConfiguration().getProperty(ResourceModelTraversalCalculator.PROP_TRAVERSAL_CALCULATOR);
+	}
+	
+	protected boolean isVisible(IDiff diff) {
+		return super.isVisible(diff);
+	}
 }
\ No newline at end of file
diff --git a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceModelProviderOperation.java b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceModelProviderOperation.java
index 929acf62b..e2a3243a1 100644
--- a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceModelProviderOperation.java
+++ b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceModelProviderOperation.java
@@ -15,18 +15,29 @@ import java.util.*;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.mapping.*;
 import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.NullProgressMonitor;
-import org.eclipse.team.core.diff.*;
-import org.eclipse.team.core.mapping.*;
+import org.eclipse.jface.viewers.*;
+import org.eclipse.team.core.diff.FastDiffFilter;
+import org.eclipse.team.core.diff.IDiff;
+import org.eclipse.team.core.mapping.IResourceDiffTree;
+import org.eclipse.team.core.mapping.ISynchronizationContext;
+import org.eclipse.team.internal.core.subscribers.DiffChangeSet;
 import org.eclipse.team.internal.ui.TeamUIPlugin;
 import org.eclipse.team.internal.ui.Utils;
+import org.eclipse.team.internal.ui.synchronize.SynchronizePageConfiguration;
 import org.eclipse.team.ui.mapping.SynchronizationOperation;
 import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;
 
 public abstract class ResourceModelProviderOperation extends SynchronizationOperation {
 
-	protected ResourceModelProviderOperation(ISynchronizePageConfiguration configuration, Object[] elements) {
-		super(configuration, elements);
+	private final IStructuredSelection selection;
+
+	protected ResourceModelProviderOperation(ISynchronizePageConfiguration configuration, IStructuredSelection selection) {
+		super(configuration, getElements(selection));
+		this.selection = selection;
+	}
+
+	private static Object[] getElements(IStructuredSelection selection) {
+		return selection.toArray();
 	}
 
 	/**
@@ -36,43 +47,34 @@ public abstract class ResourceModelProviderOperation extends SynchronizationOper
 	 * @param elements the selected elements
 	 * @return the file deltas contained in or descended from the selection
 	 */
-	protected IDiff[] getFileDeltas(Object[] elements) {
+	private IDiff[] getFileDeltas(Object[] pathOrElements) {
 		Set result = new HashSet();
-		for (int j = 0; j < elements.length; j++) {
-			Object element = elements[j];
-			IDiff[] diffs = getFileDeltas(element);
-			for (int i = 0; i < diffs.length; i++) {
-				IDiff node = diffs[i];
+		for (int i = 0; i < pathOrElements.length; i++) {
+			Object pathOrElement = pathOrElements[i];
+			IDiff[] diffs = getFileDeltas(pathOrElement);
+			for (int j = 0; j < diffs.length; j++) {
+				IDiff node = diffs[j];
 				result.add(node);
 			}
 		}
 		return (IDiff[]) result.toArray(new IDiff[result.size()]);
 	}
 	
-	private IDiff[] getFileDeltas(Object o) {
-		IResource resource = Utils.getResource(o);
-		if (resource != null) {
+	private IDiff[] getFileDeltas(Object pathOrElement) {
+		List result = new ArrayList();
+		ResourceTraversal[] traversals = getTraversals(pathOrElement);
+		if (traversals.length > 0) {
 			ISynchronizationContext context = getContext();
 			final IResourceDiffTree diffTree = context.getDiffTree();
-			if (resource.getType() == IResource.FILE) {
-				IDiff delta = diffTree.getDiff(resource);
-				if (getDiffFilter().select(delta))
-					return new IDiff[] { delta };
-			} else {
-				// Find all the deltas for the folder
-				ResourceTraversal[] traversals = getTraversals(o);
-				IDiff[] diffs = diffTree.getDiffs(traversals);
-				// Now filter the diffs by the mode of the configuration
-				List result = new ArrayList();
-				for (int i = 0; i < diffs.length; i++) {
-					IDiff node = diffs[i];
-					if (isVisible(node) && getDiffFilter().select(node))
-						result.add(node);
-				}
-				return (IDiff[]) result.toArray(new IDiff[result.size()]);
+			IDiff[] diffs = diffTree.getDiffs(traversals);
+			// Now filter the by the mode of the configuration
+			for (int i = 0; i < diffs.length; i++) {
+				IDiff node = diffs[i];
+				if (isVisible(node) && getDiffFilter().select(node))
+					result.add(node);
 			}
 		}
-		return new IDiff[0];
+		return (IDiff[]) result.toArray(new IDiff[result.size()]);
 	}
 	
 	/**
@@ -82,45 +84,43 @@ public abstract class ResourceModelProviderOperation extends SynchronizationOper
 	 * @return whether the given node is visible in the page
 	 */
 	protected boolean isVisible(IDiff node) {
-		ISynchronizePageConfiguration configuration = getConfiguration();
-		if (configuration.getComparisonType() == ISynchronizePageConfiguration.THREE_WAY 
-				&& node instanceof IThreeWayDiff) {
-			IThreeWayDiff twd = (IThreeWayDiff) node;
-			int mode = configuration.getMode();
-			switch (mode) {
-			case ISynchronizePageConfiguration.INCOMING_MODE:
-				if (twd.getDirection() == IThreeWayDiff.CONFLICTING || twd.getDirection() == IThreeWayDiff.INCOMING) {
-					return true;
-				}
-				break;
-			case ISynchronizePageConfiguration.OUTGOING_MODE:
-				if (twd.getDirection() == IThreeWayDiff.CONFLICTING || twd.getDirection() == IThreeWayDiff.OUTGOING) {
-					return true;
-				}
-				break;
-			case ISynchronizePageConfiguration.CONFLICTING_MODE:
-				if (twd.getDirection() == IThreeWayDiff.CONFLICTING) {
-					return true;
-				}
-				break;
-			case ISynchronizePageConfiguration.BOTH_MODE:
-				return true;
-			}
-		}
-		return configuration.getComparisonType() == ISynchronizePageConfiguration.TWO_WAY && node instanceof IResourceDiff;
+		return ((SynchronizePageConfiguration)getConfiguration()).isVisible(node);
 	}
 
-	private ResourceTraversal[] getTraversals(Object o) {
-		ResourceMapping mapping = Utils.getResourceMapping(o);
+	private ResourceTraversal[] getTraversals(Object pathOrElement) {
+		// First check to see if the element is a tree path
+		Object element;
+		if (pathOrElement instanceof TreePath) {
+			TreePath tp = (TreePath) pathOrElement;
+			Object o = tp.getFirstSegment();
+			if (o instanceof DiffChangeSet) {
+				// Special handling for change sets
+				DiffChangeSet dcs = (DiffChangeSet) o;
+				return getTraversalCalculator().getTraversals(dcs, tp);
+			}
+			element = tp.getLastSegment();
+		} else {
+			element = pathOrElement;
+		}
+		
+		// Check for resources and adjust the depth to match the provider depth
+		if (isResourcePath(pathOrElement)) {
+			IResource resource = (IResource) element;
+			return getTraversalCalculator().getTraversals(resource);
+		}
+		
+		// Finally, just get the traversals from the mapping.
+		ResourceMapping mapping = Utils.getResourceMapping(element);
 		if (mapping != null) {
 			// First, check if we have already calculated the traversal
 			ResourceTraversal[] traversals = getContext().getScope().getTraversals(mapping);
 			if (traversals != null)
 				return traversals;
-			// We need to determine the traversals from the mapping
-			// TODO: this is not right: see bug 120114
+			// We need to determine the traversals from the mapping.
+			// By default, use the local context. Models will need to provide
+			// custom handlers if this doesn't work for them
 			try {
-				return mapping.getTraversals(ResourceMappingContext.LOCAL_CONTEXT, new NullProgressMonitor());
+				return mapping.getTraversals(ResourceMappingContext.LOCAL_CONTEXT, null);
 			} catch (CoreException e) {
 				TeamUIPlugin.log(e);
 			}
@@ -128,6 +128,14 @@ public abstract class ResourceModelProviderOperation extends SynchronizationOper
 		return new ResourceTraversal[0];
 	}
 	
+	private boolean isResourcePath(Object pathOrElement) {
+		if (pathOrElement instanceof TreePath) {
+			TreePath tp = (TreePath) pathOrElement;
+			return getTraversalCalculator().isResourcePath(tp);
+		}
+		return false;
+	}
+
 	/**
 	 * Return the filter used to match diffs to which this action applies.
 	 * @return the filter used to match diffs to which this action applies
@@ -139,14 +147,30 @@ public abstract class ResourceModelProviderOperation extends SynchronizationOper
 	 */
 	public boolean shouldRun() {
 		// TODO: may be too long for enablement
-		return getFileDeltas(getElements()).length > 0;
+		return getTargetDiffs().length > 0;
 	}
 	
+	protected IDiff[] getTargetDiffs() {
+		return getFileDeltas(getTreePathsOrElements());
+	}
+
+	private Object[] getTreePathsOrElements() {
+		if (selection instanceof ITreeSelection) {
+			ITreeSelection ts = (ITreeSelection) selection;
+			return ts.getPaths();
+		}
+		return getElements();
+	}
+
 	/* (non-Javadoc)
 	 * @see org.eclipse.team.ui.TeamOperation#canRunAsJob()
 	 */
 	protected boolean canRunAsJob() {
 		return true;
 	}
+	
+	protected ResourceModelTraversalCalculator getTraversalCalculator() {
+		return (ResourceModelTraversalCalculator)getConfiguration().getProperty(ResourceModelTraversalCalculator.PROP_TRAVERSAL_CALCULATOR);
+	}
 
 }
diff --git a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceModelTraversalCalculator.java b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceModelTraversalCalculator.java
new file mode 100644
index 000000000..eb931c854
--- /dev/null
+++ b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceModelTraversalCalculator.java
@@ -0,0 +1,180 @@
+/*******************************************************************************
+ * Copyright (c) 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.team.internal.ui.mapping;
+
+import java.util.*;
+
+import org.eclipse.core.resources.*;
+import org.eclipse.core.resources.mapping.ResourceTraversal;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jface.viewers.TreePath;
+import org.eclipse.team.core.diff.IDiff;
+import org.eclipse.team.core.mapping.IResourceDiffTree;
+import org.eclipse.team.core.mapping.provider.ResourceDiffTree;
+import org.eclipse.team.internal.core.subscribers.DiffChangeSet;
+import org.eclipse.team.internal.ui.IPreferenceIds;
+import org.eclipse.team.internal.ui.TeamUIPlugin;
+
+public class ResourceModelTraversalCalculator {
+
+	public static final String PROP_TRAVERSAL_CALCULATOR = "org.eclipse.team.ui.resourceModelraversalCalculator"; //$NON-NLS-1$
+
+	public int getLayoutDepth(IResource resource) {
+		if (resource.getType() == IResource.PROJECT)
+			return IResource.DEPTH_INFINITE;
+		if (resource.getType() == IResource.FILE) 
+			return IResource.DEPTH_ZERO;
+		if (getLayout().equals(IPreferenceIds.FLAT_LAYOUT)) {
+			return IResource.DEPTH_ZERO;
+		} else if (getLayout().equals(IPreferenceIds.COMPRESSED_LAYOUT)) {
+			return IResource.DEPTH_ONE;
+		}
+		return IResource.DEPTH_INFINITE;
+	}
+
+	public String getLayout() {
+		return TeamUIPlugin.getPlugin().getPreferenceStore().getString(IPreferenceIds.SYNCVIEW_DEFAULT_LAYOUT);
+	}
+	
+	public Object[] filterChildren(IResourceDiffTree diffTree, IResource resource, Object[] children) {
+		Object[] allChildren;
+		if (getLayout().equals(IPreferenceIds.FLAT_LAYOUT) && resource.getType() == IResource.PROJECT) {
+			allChildren = getFlatChildren(diffTree, resource);
+		} else if (getLayout().equals(IPreferenceIds.COMPRESSED_LAYOUT) && resource.getType() == IResource.PROJECT) {
+			allChildren = getCompressedChildren(diffTree, (IProject)resource, children);
+		} else if (getLayout().equals(IPreferenceIds.COMPRESSED_LAYOUT) && resource.getType() == IResource.FOLDER) {
+			allChildren = getCompressedChildren(diffTree, (IFolder)resource, children);
+		} else {
+			allChildren = getTreeChildren(diffTree, resource, children);
+		}
+		return allChildren;
+	}
+	
+	private Object[] getCompressedChildren(IResourceDiffTree diffTree, IProject project, Object[] children) {
+		Set result = new HashSet();
+		IDiff[] diffs = diffTree.getDiffs(project, IResource.DEPTH_INFINITE);
+		for (int i = 0; i < diffs.length; i++) {
+			IDiff diff = diffs[i];
+			IResource resource = diffTree.getResource(diff);
+			if (resource.getType() == IResource.FILE) {
+				IContainer parent = resource.getParent();
+				if (parent.getType() == IResource.FOLDER)
+					result.add(parent);
+				else 
+					result.add(resource);
+			} else if (resource.getType() == IResource.FOLDER)
+				result.add(resource);
+		}
+		return result.toArray();
+	}
+
+	/*
+	 * Only return the files that are direct children of the folder
+	 */
+	private Object[] getCompressedChildren(IResourceDiffTree diffTree, IFolder folder, Object[] children) {
+		Set result = new HashSet();
+		for (int i = 0; i < children.length; i++) {
+			Object object = children[i];
+			if (object instanceof IResource) {
+				IResource resource = (IResource) object;
+				if (resource.getType() == IResource.FILE)
+					result.add(resource);
+			}
+		}
+		IDiff[] diffs = diffTree.getDiffs(folder, IResource.DEPTH_ONE);
+		for (int i = 0; i < diffs.length; i++) {
+			IDiff diff = diffs[i];
+			IResource resource = diffTree.getResource(diff);
+			if (resource.getType() == IResource.FILE)
+				result.add(resource);
+		}
+		return result.toArray();
+	}
+
+	private Object[] getFlatChildren(IResourceDiffTree diffTree, IResource resource) {
+		Object[] allChildren;
+		IDiff[] diffs = diffTree.getDiffs(resource, IResource.DEPTH_INFINITE);
+		ArrayList result = new ArrayList();
+		for (int i = 0; i < diffs.length; i++) {
+			IDiff diff = diffs[i];
+			result.add(diffTree.getResource(diff));
+		}
+		allChildren = result.toArray();
+		return allChildren;
+	}
+
+	private Object[] getTreeChildren(IResourceDiffTree diffTree, IResource resource, Object[] children) {
+		Set result = new HashSet();
+		for (int i = 0; i < children.length; i++) {
+			Object object = children[i];
+			result.add(object);
+		}
+		IPath[] childPaths = diffTree.getChildren(resource.getFullPath());
+		for (int i = 0; i < childPaths.length; i++) {
+			IPath path = childPaths[i];
+			IDiff delta = diffTree.getDiff(path);
+			IResource child;
+			if (delta == null) {
+				// the path has descendent deltas so it must be a folder
+				if (path.segmentCount() == 1) {
+					child = ((IWorkspaceRoot)resource).getProject(path.lastSegment());
+				} else {
+					child = ((IContainer)resource).getFolder(new Path(path.lastSegment()));
+				}
+			} else {
+				child = diffTree.getResource(delta);
+			}
+			result.add(child);
+		}
+		Object[] allChildren = result.toArray(new Object[result.size()]);
+		return allChildren;
+	}
+
+	public ResourceTraversal[] getTraversals(DiffChangeSet dcs, TreePath tp) {
+		IResource[] resources = getResource(dcs, tp);
+		return new ResourceTraversal[] { new ResourceTraversal(resources, IResource.DEPTH_ZERO, IResource.NONE) };
+	}
+
+	private IResource[] getResource(DiffChangeSet dcs, TreePath tp) {
+		if (tp.getSegmentCount() == 1 && tp.getFirstSegment() == dcs) {
+			return dcs.getResources();
+		}
+		Set result = new HashSet();
+		Object o = tp.getLastSegment();
+		if (o instanceof IResource) {
+			IResource resource = (IResource) o;
+			int depth = getLayoutDepth(resource);
+			IDiff[] diffs = dcs.getDiffTree().getDiffs(resource, depth);
+			for (int i = 0; i < diffs.length; i++) {
+				IDiff diff = diffs[i];
+				IResource r = ResourceDiffTree.getResourceFor(diff);
+				if (r != null)
+					result.add(r);
+			}
+		}
+		return (IResource[]) result.toArray(new IResource[result.size()]);
+	}
+
+	public ResourceTraversal[] getTraversals(IResource resource) {
+		return new ResourceTraversal[] { new ResourceTraversal(new IResource[] { resource }, getLayoutDepth(resource), IResource.NONE) };
+	}
+
+	public boolean isResourcePath(TreePath path) {
+		for (int i = 0; i < path.getSegmentCount(); i++) {
+			Object o = path.getSegment(i);
+			if (!(o instanceof IResource)) {
+				return false;
+			}
+		}
+		return true;
+	}
+}
diff --git a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/synchronize/SynchronizePageConfiguration.java b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/synchronize/SynchronizePageConfiguration.java
index 110cdaae9..caad919b7 100644
--- a/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/synchronize/SynchronizePageConfiguration.java
+++ b/bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/synchronize/SynchronizePageConfiguration.java
@@ -19,6 +19,9 @@ import org.eclipse.jface.operation.IRunnableContext;
 import org.eclipse.jface.util.IPropertyChangeListener;
 import org.eclipse.jface.util.PropertyChangeEvent;
 import org.eclipse.jface.viewers.ILabelDecorator;
+import org.eclipse.team.core.diff.IDiff;
+import org.eclipse.team.core.diff.IThreeWayDiff;
+import org.eclipse.team.core.mapping.IResourceDiff;
 import org.eclipse.team.core.synchronize.SyncInfoSet;
 import org.eclipse.team.internal.ui.TeamUIPlugin;
 import org.eclipse.team.internal.ui.mapping.CommonViewerAdvisor;
@@ -594,4 +597,45 @@ public class SynchronizePageConfiguration extends SynchronizePageActionGroup imp
 			return viewerId;
 		return CommonViewerAdvisor.TEAM_NAVIGATOR_CONTENT;
 	}
+	
+	/**
+	 * Return whether the given node is visible in the page based
+	 * on the mode in the configuration.
+	 * @param node a diff node
+	 * @return whether the given node is visible in the page
+	 */
+	public boolean isVisible(IDiff node) {
+		if (getComparisonType() == ISynchronizePageConfiguration.THREE_WAY 
+				&& node instanceof IThreeWayDiff) {
+			IThreeWayDiff twd = (IThreeWayDiff) node;
+			return includeDirection(twd.getDirection());
+		}
+		return getComparisonType() == ISynchronizePageConfiguration.TWO_WAY && node instanceof IResourceDiff;
+	}
+	
+	/**
+	 * Return whether elements with the given direction should be included in
+	 * the contents.
+	 * 
+	 * @param direction
+	 *            the synchronization direction
+	 * @return whether elements with the given synchronization kind should be
+	 *         included in the contents
+	 */
+	public boolean includeDirection(int direction) {
+		int mode = getMode();
+		switch (mode) {
+		case ISynchronizePageConfiguration.BOTH_MODE:
+			return true;
+		case ISynchronizePageConfiguration.CONFLICTING_MODE:
+			return direction == IThreeWayDiff.CONFLICTING;
+		case ISynchronizePageConfiguration.INCOMING_MODE:
+			return direction == IThreeWayDiff.CONFLICTING || direction == IThreeWayDiff.INCOMING;
+		case ISynchronizePageConfiguration.OUTGOING_MODE:
+			return direction == IThreeWayDiff.CONFLICTING || direction == IThreeWayDiff.OUTGOING;
+		default:
+			break;
+		}
+		return true;
+	}
 }
diff --git a/bundles/org.eclipse.team.ui/src/org/eclipse/team/ui/mapping/SynchronizationContentProvider.java b/bundles/org.eclipse.team.ui/src/org/eclipse/team/ui/mapping/SynchronizationContentProvider.java
index 3ebae10c3..736c418ea 100644
--- a/bundles/org.eclipse.team.ui/src/org/eclipse/team/ui/mapping/SynchronizationContentProvider.java
+++ b/bundles/org.eclipse.team.ui/src/org/eclipse/team/ui/mapping/SynchronizationContentProvider.java
@@ -19,11 +19,12 @@ import org.eclipse.jface.util.IPropertyChangeListener;
 import org.eclipse.jface.util.PropertyChangeEvent;
 import org.eclipse.jface.viewers.*;
 import org.eclipse.team.core.diff.*;
-import org.eclipse.team.core.mapping.*;
-import org.eclipse.team.core.synchronize.SyncInfo;
+import org.eclipse.team.core.mapping.ISynchronizationContext;
+import org.eclipse.team.core.mapping.ISynchronizationScope;
 import org.eclipse.team.internal.core.TeamPlugin;
 import org.eclipse.team.internal.ui.Utils;
 import org.eclipse.team.internal.ui.mapping.SynchronizationResourceMappingContext;
+import org.eclipse.team.internal.ui.synchronize.SynchronizePageConfiguration;
 import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;
 import org.eclipse.ui.IMemento;
 import org.eclipse.ui.navigator.*;
@@ -286,34 +287,23 @@ public abstract class SynchronizationContentProvider implements ICommonContentPr
 	}
 	
 	/**
-	 * Return whether elements with the given synchronization kind (as define in
-	 * the {@link SyncInfo} class) should be included in the contents. This
-	 * method is invoked by the {@link #getChildrenInContext(ISynchronizationContext, Object, Object[])}
-	 * method to filter the list of children returned when {@link #getChildren(Object) }
-	 * is called. It accessing the <code>ISynchronizePageConfiguration.P_MODE</code>
-	 * property on the state model provided by the view to determine what kinds
-	 * should be included.
+	 * Return whether elements with the given direction should be included in
+	 * the contents. The direction is one of {@link IThreeWayDiff#INCOMING},
+	 * {@link IThreeWayDiff#OUTGOING} or {@link IThreeWayDiff#CONFLICTING}.
+	 * This method is invoked by the
+	 * {@link #getChildrenInContext(ISynchronizationContext, Object, Object[])}
+	 * method to filter the list of children returned when
+	 * {@link #getChildren(Object) } is called. It accessing the
+	 * <code>ISynchronizePageConfiguration.P_MODE</code> property on the state
+	 * model provided by the view to determine what kinds should be included.
 	 * 
-	 * @param direction the synchronization kind as described in the {@link SyncInfo}
-	 *            class
+	 * @param direction
+	 *            the synchronization direction
 	 * @return whether elements with the given synchronization kind should be
 	 *         included in the contents
 	 */
 	protected boolean includeDirection(int direction) {
-		int mode = getConfiguration().getMode();
-		switch (mode) {
-		case ISynchronizePageConfiguration.BOTH_MODE:
-			return true;
-		case ISynchronizePageConfiguration.CONFLICTING_MODE:
-			return direction == IThreeWayDiff.CONFLICTING;
-		case ISynchronizePageConfiguration.INCOMING_MODE:
-			return direction == IThreeWayDiff.CONFLICTING || direction == IThreeWayDiff.INCOMING;
-		case ISynchronizePageConfiguration.OUTGOING_MODE:
-			return direction == IThreeWayDiff.CONFLICTING || direction == IThreeWayDiff.OUTGOING;
-		default:
-			break;
-		}
-		return true;
+		return ((SynchronizePageConfiguration)getConfiguration()).includeDirection(direction);
 	}
 	
 	/**
@@ -540,10 +530,7 @@ public abstract class SynchronizationContentProvider implements ICommonContentPr
 	protected boolean isVisible(IDiff diff) {
 		if (diff instanceof IThreeWayDiff) {
 			IThreeWayDiff twd = (IThreeWayDiff) diff;
-			if (includeDirection(twd.getDirection())) {
-				return true;
-			}
-			return false;
+			return includeDirection(twd.getDirection());
 		}
 		return diff.getKind() != IDiff.NO_CHANGE;
 	}
diff --git a/bundles/org.eclipse.team.ui/src/org/eclipse/team/ui/mapping/SynchronizationOperation.java b/bundles/org.eclipse.team.ui/src/org/eclipse/team/ui/mapping/SynchronizationOperation.java
index 52b3d66f9..c974413a5 100644
--- a/bundles/org.eclipse.team.ui/src/org/eclipse/team/ui/mapping/SynchronizationOperation.java
+++ b/bundles/org.eclipse.team.ui/src/org/eclipse/team/ui/mapping/SynchronizationOperation.java
@@ -141,6 +141,7 @@ public abstract class SynchronizationOperation extends TeamOperation {
 
 	private void setContextBusy(final IProgressMonitor monitor) {
 		try {
+			// TODO: This may miss setting some diffs (i.e. those that don't exist locally)
 			ResourceTraversal[] traversals = Utils.getTraversals(getElements());
 			final IResourceDiffTree diffTree = getContext().getDiffTree();
 			IDiff[] diffs = diffTree.getDiffs(traversals);