From 49985e24992409f834acbad021110349212643bd Mon Sep 17 00:00:00 2001 From: Michael Valenta Date: Mon, 13 Mar 2006 21:50:35 +0000 Subject: Bug 128950 [Model Sync] Compress layout operations should match depth --- .../ui/mapping/ResourceMarkAsMergedHandler.java | 4 +- .../internal/ui/mapping/ResourceMergeHandler.java | 4 +- .../ui/mapping/ResourceModelContentProvider.java | 125 ++------------ .../ui/mapping/ResourceModelProviderOperation.java | 150 +++++++++-------- .../mapping/ResourceModelTraversalCalculator.java | 180 +++++++++++++++++++++ .../synchronize/SynchronizePageConfiguration.java | 44 +++++ .../ui/mapping/SynchronizationContentProvider.java | 45 ++---- .../team/ui/mapping/SynchronizationOperation.java | 1 + 8 files changed, 343 insertions(+), 210 deletions(-) create mode 100644 bundles/org.eclipse.team.ui/src/org/eclipse/team/internal/ui/mapping/ResourceModelTraversalCalculator.java (limited to 'bundles/org.eclipse.team.ui/src') 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 ISynchronizePageConfiguration.P_MODE - * 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 + * ISynchronizePageConfiguration.P_MODE 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); -- cgit v1.2.3