Java tutorial
/******************************************************************************* * Copyright (c) 2006, 2011 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.ui.ide.undo; import java.net.URI; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import org.eclipse.core.commands.operations.IUndoContext; import org.eclipse.core.commands.operations.ObjectUndoContext; import org.eclipse.core.filesystem.URIUtil; import org.eclipse.core.resources.IContainer; 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.IResourceStatus; import org.eclipse.core.resources.IWorkspace; import org.eclipse.core.resources.IWorkspaceRoot; import org.eclipse.core.resources.ResourcesPlugin; 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.IStatus; import org.eclipse.core.runtime.MultiStatus; import org.eclipse.core.runtime.NullProgressMonitor; import org.eclipse.core.runtime.OperationCanceledException; import org.eclipse.core.runtime.Status; import org.eclipse.core.runtime.SubProgressMonitor; import org.eclipse.jface.dialogs.IDialogConstants; import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.osgi.util.NLS; import org.eclipse.swt.SWT; import org.eclipse.swt.widgets.Shell; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.internal.WorkbenchPlugin; import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin; import org.eclipse.ui.internal.ide.undo.ContainerDescription; import org.eclipse.ui.internal.ide.undo.FileDescription; import org.eclipse.ui.internal.ide.undo.UndoMessages; /** * WorkspaceUndoUtil defines common utility methods and constants used by * clients who create undoable workspace operations. * * @since 3.3 */ public class WorkspaceUndoUtil { private static ObjectUndoContext tasksUndoContext; private static ObjectUndoContext bookmarksUndoContext; private static ObjectUndoContext problemsUndoContext; /** * Return the undo context that should be used for workspace-wide operations * * @return the undo context suitable for workspace-level operations. */ public static IUndoContext getWorkspaceUndoContext() { return WorkbenchPlugin.getDefault().getOperationSupport().getUndoContext(); } /** * Return the undo context that should be used for operations involving * tasks. * * @return the tasks undo context */ public static IUndoContext getTasksUndoContext() { if (tasksUndoContext == null) { tasksUndoContext = new ObjectUndoContext(new Object(), "Tasks Context"); //$NON-NLS-1$ tasksUndoContext.addMatch(getWorkspaceUndoContext()); } return tasksUndoContext; } /** * Return the undo context that should be used for operations involving * bookmarks. * * @return the bookmarks undo context */ public static IUndoContext getBookmarksUndoContext() { if (bookmarksUndoContext == null) { bookmarksUndoContext = new ObjectUndoContext(new Object(), "Bookmarks Context"); //$NON-NLS-1$ bookmarksUndoContext.addMatch(getWorkspaceUndoContext()); } return bookmarksUndoContext; } /** * Return the undo context that should be used for operations involving * problems. * * @return the problems undo context * @since 3.7 */ public static IUndoContext getProblemsUndoContext() { if (problemsUndoContext == null) { problemsUndoContext = new ObjectUndoContext(new Object(), "Problems Context"); //$NON-NLS-1$ problemsUndoContext.addMatch(getWorkspaceUndoContext()); } return problemsUndoContext; } /** * Make an <code>IAdaptable</code> that adapts to the specified shell, * suitable for passing for passing to any * {@link org.eclipse.core.commands.operations.IUndoableOperation} or * {@link org.eclipse.core.commands.operations.IOperationHistory} method * that requires an {@link org.eclipse.core.runtime.IAdaptable} * <code>uiInfo</code> parameter. * * @param shell * the shell that should be returned by the IAdaptable when asked * to adapt a shell. If this parameter is <code>null</code>, * the returned shell will also be <code>null</code>. * * @return an IAdaptable that will return the specified shell. */ public static IAdaptable getUIInfoAdapter(final Shell shell) { return new IAdaptable() { public Object getAdapter(Class clazz) { if (clazz == Shell.class) { return shell; } return null; } }; } private WorkspaceUndoUtil() { // should not construct } /** * Delete all of the specified resources, returning resource descriptions * that can be used to restore them. * * @param resourcesToDelete * an array of resources to be deleted * @param monitor * the progress monitor to use to show the operation's progress * @param uiInfo * the IAdaptable (or <code>null</code>) provided by the * caller in order to supply UI information for prompting the * user if necessary. When this parameter is not * <code>null</code>, it contains an adapter for the * org.eclipse.swt.widgets.Shell.class * * @param deleteContent * a boolean indicating whether project content should be deleted * when a project resource is to be deleted * @return an array of ResourceDescriptions that can be used to restore the * deleted resources. * @throws CoreException * propagates any CoreExceptions thrown from the resources API */ static ResourceDescription[] delete(IResource[] resourcesToDelete, IProgressMonitor monitor, IAdaptable uiInfo, boolean deleteContent) throws CoreException { final List exceptions = new ArrayList(); boolean forceOutOfSyncDelete = false; ResourceDescription[] returnedResourceDescriptions = new ResourceDescription[resourcesToDelete.length]; monitor.beginTask("", resourcesToDelete.length); //$NON-NLS-1$ monitor.setTaskName(UndoMessages.AbstractResourcesOperation_DeleteResourcesProgress); try { for (int i = 0; i < resourcesToDelete.length; ++i) { if (monitor.isCanceled()) { throw new OperationCanceledException(); } IResource resource = resourcesToDelete[i]; try { returnedResourceDescriptions[i] = delete(resource, new SubProgressMonitor(monitor, 1), uiInfo, forceOutOfSyncDelete, deleteContent); } catch (CoreException e) { if (resource.getType() == IResource.FILE) { IStatus[] children = e.getStatus().getChildren(); if (children.length == 1 && children[0].getCode() == IResourceStatus.OUT_OF_SYNC_LOCAL) { int result = queryDeleteOutOfSync(resource, uiInfo); if (result == IDialogConstants.YES_ID) { // retry the delete with a force out of sync delete(resource, new SubProgressMonitor(monitor, 1), uiInfo, true, deleteContent); } else if (result == IDialogConstants.YES_TO_ALL_ID) { // all future attempts should force out of // sync forceOutOfSyncDelete = true; delete(resource, new SubProgressMonitor(monitor, 1), uiInfo, forceOutOfSyncDelete, deleteContent); } else if (result == IDialogConstants.CANCEL_ID) { throw new OperationCanceledException(); } else { exceptions.add(e); } } else { exceptions.add(e); } } else { exceptions.add(e); } } } IStatus result = createResult(exceptions); if (!result.isOK()) { throw new CoreException(result); } } finally { monitor.done(); } return returnedResourceDescriptions; } /** * Copies the resources to the given destination. This method can be called * recursively to merge folders during folder copy. * * @param resources * the resources to be copied * @param destination * the destination path for the resources, relative to the * workspace * @param resourcesAtDestination * A list used to record the new copies. * @param monitor * the progress monitor used to show progress * @param uiInfo * the IAdaptable (or <code>null</code>) provided by the * caller in order to supply UI information for prompting the * user if necessary. When this parameter is not * <code>null</code>, it contains an adapter for the * org.eclipse.swt.widgets.Shell.class * @param pathIncludesName * a boolean that indicates whether the specified path includes * the resource's name at the destination. If this value is * <code>true</code>, the destination will contain the desired * name of the resource (usually only desired when only one * resource is being copied). If this value is <code>false</code>, * each resource's name will be appended to the destination. * @return an array of ResourceDescriptions describing any resources that * were overwritten by the copy operation * @throws CoreException * propagates any CoreExceptions thrown from the resources API */ static ResourceDescription[] copy(IResource[] resources, IPath destination, List resourcesAtDestination, IProgressMonitor monitor, IAdaptable uiInfo, boolean pathIncludesName) throws CoreException { return copy(resources, destination, resourcesAtDestination, monitor, uiInfo, pathIncludesName, false, false, null); } /** * Copies the resources to the given destination. This method can be called * recursively to merge folders during folder copy. * * @param resources * the resources to be copied * @param destination * the destination path for the resources, relative to the * workspace * @param resourcesAtDestination * A list used to record the new copies. * @param monitor * the progress monitor used to show progress * @param uiInfo * the IAdaptable (or <code>null</code>) provided by the * caller in order to supply UI information for prompting the * user if necessary. When this parameter is not * <code>null</code>, it contains an adapter for the * org.eclipse.swt.widgets.Shell.class * @param pathIncludesName * a boolean that indicates whether the specified path includes * the resource's name at the destination. If this value is * <code>true</code>, the destination will contain the desired * name of the resource (usually only desired when only one * resource is being copied). If this value is <code>false</code>, * each resource's name will be appended to the destination. * @param createVirtual * a boolean that indicates whether virtual folders should be * created instead of folders when a hierarchy of files is * copied. * @param createLinks * a boolean that indicates whether linked resources should be * created instead of files and folders (if createGroups is * false) when copied. * @param relativeToVariable * a String that indicates relative to which variable linked * resources should be created, if createLinks is set to true. * Absolute linked resources will be created if null is passed * otherwise (and createLinks is set to true). * @return an array of ResourceDescriptions describing any resources that * were overwritten by the copy operation * @throws CoreException * propagates any CoreExceptions thrown from the resources API */ static ResourceDescription[] copy(IResource[] resources, IPath destination, List resourcesAtDestination, IProgressMonitor monitor, IAdaptable uiInfo, boolean pathIncludesName, boolean createVirtual, boolean createLinks, String relativeToVariable) throws CoreException { monitor.beginTask("", resources.length); //$NON-NLS-1$ monitor.setTaskName(UndoMessages.AbstractResourcesOperation_CopyingResourcesProgress); List overwrittenResources = new ArrayList(); for (int i = 0; i < resources.length; i++) { IResource source = resources[i]; IPath destinationPath; if (pathIncludesName) { destinationPath = destination; } else { destinationPath = destination.append(source.getName()); } IWorkspaceRoot workspaceRoot = getWorkspaceRoot(); IResource existing = workspaceRoot.findMember(destinationPath); if (source.getType() == IResource.FOLDER && existing != null) { // The resource is a folder and it exists in the destination. // Copy its children to the existing destination. if ((source.isLinked() && existing.isLinked()) || (source.isVirtual() && existing.isVirtual()) || (!source.isLinked() && !existing.isLinked() && !source.isVirtual() && !existing.isVirtual())) { IResource[] children = ((IContainer) source).members(); // copy only linked resource children (267173) if (source.isLinked() && source.getLocation().equals(existing.getLocation())) children = filterNonLinkedResources(children); ResourceDescription[] overwritten = copy(children, destinationPath, resourcesAtDestination, new SubProgressMonitor(monitor, 1), uiInfo, false, createVirtual, createLinks, relativeToVariable); // We don't record the copy since this recursive call will // do so. Just record the overwrites. for (int j = 0; j < overwritten.length; j++) { overwrittenResources.add(overwritten[j]); } } else { // delete the destination folder, copying a linked folder // over an unlinked one or vice versa. Fixes bug 28772. ResourceDescription[] deleted = delete(new IResource[] { existing }, new SubProgressMonitor(monitor, 0), uiInfo, false); if ((createLinks || createVirtual) && (source.isLinked() == false) && (source.isVirtual() == false)) { IFolder folder = workspaceRoot.getFolder(destinationPath); if (createVirtual) { folder.create(IResource.VIRTUAL, true, new SubProgressMonitor(monitor, 1)); IResource[] members = ((IContainer) source).members(); if (members.length > 0) { overwrittenResources.addAll(Arrays.asList(copy(members, destinationPath, resourcesAtDestination, new SubProgressMonitor(monitor, 1), uiInfo, false, createVirtual, createLinks, relativeToVariable))); } } else folder.createLink( createRelativePath(source.getLocationURI(), relativeToVariable, folder), 0, new SubProgressMonitor(monitor, 1)); } else source.copy(destinationPath, IResource.SHALLOW, new SubProgressMonitor(monitor, 1)); // Record the copy resourcesAtDestination.add(getWorkspace().getRoot().findMember(destinationPath)); for (int j = 0; j < deleted.length; j++) { overwrittenResources.add(deleted[j]); } } } else { if (existing != null) { // source is a FILE and destination EXISTS if ((createLinks || createVirtual) && (source.isLinked() == false)) { // we create a linked file, and overwrite the // destination ResourceDescription[] deleted = delete(new IResource[] { existing }, new SubProgressMonitor(monitor, 0), uiInfo, false); if (source.getType() == IResource.FILE) { IFile file = workspaceRoot.getFile(destinationPath); file.createLink(createRelativePath(source.getLocationURI(), relativeToVariable, file), 0, new SubProgressMonitor(monitor, 1)); } else { IFolder folder = workspaceRoot.getFolder(destinationPath); if (createVirtual) { folder.create(IResource.VIRTUAL, true, new SubProgressMonitor(monitor, 1)); IResource[] members = ((IContainer) source).members(); if (members.length > 0) { overwrittenResources.addAll(Arrays.asList(copy(members, destinationPath, resourcesAtDestination, new SubProgressMonitor(monitor, 1), uiInfo, false, createVirtual, createLinks, relativeToVariable))); } } else folder.createLink( createRelativePath(source.getLocationURI(), relativeToVariable, folder), 0, new SubProgressMonitor(monitor, 1)); } resourcesAtDestination.add(getWorkspace().getRoot().findMember(destinationPath)); for (int j = 0; j < deleted.length; j++) { overwrittenResources.add(deleted[j]); } } else { if (source.isLinked() == existing.isLinked()) { overwrittenResources.add(copyOverExistingResource(source, existing, new SubProgressMonitor(monitor, 1), uiInfo, false)); // Record the "copy" resourcesAtDestination.add(existing); } else { // Copying a linked resource over unlinked or vice // versa. Can't use setContents here. Fixes bug // 28772. ResourceDescription[] deleted = delete(new IResource[] { existing }, new SubProgressMonitor(monitor, 0), uiInfo, false); source.copy(destinationPath, IResource.SHALLOW, new SubProgressMonitor(monitor, 1)); // Record the copy resourcesAtDestination.add(getWorkspace().getRoot().findMember(destinationPath)); for (int j = 0; j < deleted.length; j++) { overwrittenResources.add(deleted[j]); } } } } else { // source is a FILE or FOLDER // no resources are being overwritten // ensure the destination path exists IPath parentPath = destination; if (pathIncludesName) { parentPath = destination.removeLastSegments(1); } IContainer generatedParent = generateContainers(parentPath); if ((createLinks || createVirtual) && (source.isLinked() == false)) { if (source.getType() == IResource.FILE) { IFile file = workspaceRoot.getFile(destinationPath); file.createLink(createRelativePath(source.getLocationURI(), relativeToVariable, file), 0, new SubProgressMonitor(monitor, 1)); } else { IFolder folder = workspaceRoot.getFolder(destinationPath); if (createVirtual) { folder.create(IResource.VIRTUAL, true, new SubProgressMonitor(monitor, 1)); IResource[] members = ((IContainer) source).members(); if (members.length > 0) { overwrittenResources.addAll(Arrays.asList(copy(members, destinationPath, resourcesAtDestination, new SubProgressMonitor(monitor, 1), uiInfo, false, createVirtual, createLinks, relativeToVariable))); } } else folder.createLink( createRelativePath(source.getLocationURI(), relativeToVariable, folder), 0, new SubProgressMonitor(monitor, 1)); } } else source.copy(destinationPath, IResource.SHALLOW, new SubProgressMonitor(monitor, 1)); // Record the copy. If we had to generate a parent // folder, that should be recorded as part of the copy if (generatedParent == null) { resourcesAtDestination.add(getWorkspace().getRoot().findMember(destinationPath)); } else { resourcesAtDestination.add(generatedParent); } } if (monitor.isCanceled()) { throw new OperationCanceledException(); } } } monitor.done(); return (ResourceDescription[]) overwrittenResources .toArray(new ResourceDescription[overwrittenResources.size()]); } /** * Transform an absolute path URI to a relative path one (i.e. from * "C:\foo\bar\file.txt" to "VAR\file.txt" granted that the relativeVariable * is "VAR" and points to "C:\foo\bar\"). * * @param locationURI * @param resource * @return an URI that was made relative to a variable */ static private URI createRelativePath(URI locationURI, String relativeVariable, IResource resource) { if (relativeVariable == null) return locationURI; IPath location = URIUtil.toPath(locationURI); IPath result; try { result = URIUtil.toPath(resource.getPathVariableManager().convertToRelative(URIUtil.toURI(location), true, relativeVariable)); } catch (CoreException e) { return locationURI; } return URIUtil.toURI(result); } /** * Moves the resources to the given destination. This method can be called * recursively to merge folders during folder move. * * @param resources * the resources to be moved * @param destination * the destination path for the resources, relative to the * workspace * @param resourcesAtDestination * A list used to record each moved resource. * @param reverseDestinations * A list used to record each moved resource's original location * @param monitor * the progress monitor used to show progress * @param uiInfo * the IAdaptable (or <code>null</code>) provided by the * caller in order to supply UI information for prompting the * user if necessary. When this parameter is not * <code>null</code>, it contains an adapter for the * org.eclipse.swt.widgets.Shell.class * @param pathIncludesName * a boolean that indicates whether the specified path includes * the resource's name at the destination. If this value is * <code>true</code>, the destination will contain the desired * name of the resource (usually only desired when only one * resource is being moved). If this value is <code>false</code>, * each resource's name will be appended to the destination. * @return an array of ResourceDescriptions describing any resources that * were overwritten by the move operation * @throws CoreException * propagates any CoreExceptions thrown from the resources API */ static ResourceDescription[] move(IResource[] resources, IPath destination, List resourcesAtDestination, List reverseDestinations, IProgressMonitor monitor, IAdaptable uiInfo, boolean pathIncludesName) throws CoreException { monitor.beginTask("", resources.length); //$NON-NLS-1$ monitor.setTaskName(UndoMessages.AbstractResourcesOperation_MovingResources); List overwrittenResources = new ArrayList(); for (int i = 0; i < resources.length; i++) { IResource source = resources[i]; IPath destinationPath; if (pathIncludesName) { destinationPath = destination; } else { destinationPath = destination.append(source.getName()); } IWorkspaceRoot workspaceRoot = getWorkspaceRoot(); IResource existing = workspaceRoot.findMember(destinationPath); if (source.getType() == IResource.FOLDER && existing != null) { // The resource is a folder and it exists in the destination. // Move its children to the existing destination. if (source.isLinked() == existing.isLinked()) { IResource[] children = ((IContainer) source).members(); // move only linked resource children (267173) if (source.isLinked() && source.getLocation().equals(existing.getLocation())) children = filterNonLinkedResources(children); ResourceDescription[] overwritten = move(children, destinationPath, resourcesAtDestination, reverseDestinations, new SubProgressMonitor(monitor, 1), uiInfo, false); // We don't record the moved resources since the recursive // call has done so. Just record the overwrites. for (int j = 0; j < overwritten.length; j++) { overwrittenResources.add(overwritten[j]); } // Delete the source. No need to record it since it // will get moved back. delete(source, monitor, uiInfo, false, false); } else { // delete the destination folder, moving a linked folder // over an unlinked one or vice versa. Fixes bug 28772. ResourceDescription[] deleted = delete(new IResource[] { existing }, new SubProgressMonitor(monitor, 0), uiInfo, false); // Record the original path reverseDestinations.add(source.getFullPath()); source.move(destinationPath, IResource.SHALLOW | IResource.KEEP_HISTORY, new SubProgressMonitor(monitor, 1)); // Record the resource at its destination resourcesAtDestination.add(getWorkspace().getRoot().findMember(destinationPath)); for (int j = 0; j < deleted.length; j++) { overwrittenResources.add(deleted[j]); } } } else { if (existing != null) { if (source.isLinked() == existing.isLinked()) { // Record the original path reverseDestinations.add(source.getFullPath()); overwrittenResources.add(copyOverExistingResource(source, existing, new SubProgressMonitor(monitor, 1), uiInfo, true)); resourcesAtDestination.add(existing); } else { // Moving a linked resource over unlinked or vice // versa. Can't use setContents here. Fixes bug 28772. ResourceDescription[] deleted = delete(new IResource[] { existing }, new SubProgressMonitor(monitor, 0), uiInfo, false); reverseDestinations.add(source.getFullPath()); source.move(destinationPath, IResource.SHALLOW | IResource.KEEP_HISTORY, new SubProgressMonitor(monitor, 1)); // Record the resource at its destination resourcesAtDestination.add(getWorkspace().getRoot().findMember(destinationPath)); for (int j = 0; j < deleted.length; j++) { overwrittenResources.add(deleted[j]); } } } else { // No resources are being overwritten. // First record the source path reverseDestinations.add(source.getFullPath()); // ensure the destination path exists IPath parentPath = destination; if (pathIncludesName) { parentPath = destination.removeLastSegments(1); } IContainer generatedParent = generateContainers(parentPath); source.move(destinationPath, IResource.SHALLOW | IResource.KEEP_HISTORY, new SubProgressMonitor(monitor, 1)); // Record the move. If we had to generate a parent // folder, that should be recorded as part of the copy if (generatedParent == null) { resourcesAtDestination.add(getWorkspace().getRoot().findMember(destinationPath)); } else { resourcesAtDestination.add(generatedParent); } } if (monitor.isCanceled()) { throw new OperationCanceledException(); } } } monitor.done(); return (ResourceDescription[]) overwrittenResources .toArray(new ResourceDescription[overwrittenResources.size()]); } /** * Returns only the linked resources out of an array of resources * @param resources The resources to filter * @return The linked resources */ private static IResource[] filterNonLinkedResources(IResource[] resources) { List result = new ArrayList(); for (int i = 0; i < resources.length; i++) { if (resources[i].isLinked()) result.add(resources[i]); } return (IResource[]) result.toArray(new IResource[0]); } /** * Recreate the resources from the specified resource descriptions. * * @param resourcesToRecreate * the ResourceDescriptions describing resources to be recreated * @param monitor * the progress monitor used to show progress * @param uiInfo * the IAdaptable (or <code>null</code>) provided by the * caller in order to supply UI information for prompting the * user if necessary. When this parameter is not * <code>null</code>, it contains an adapter for the * org.eclipse.swt.widgets.Shell.class * @return an array of resources that were created * @throws CoreException * propagates any CoreExceptions thrown from the resources API */ static IResource[] recreate(ResourceDescription[] resourcesToRecreate, IProgressMonitor monitor, IAdaptable uiInfo) throws CoreException { final List exceptions = new ArrayList(); IResource[] resourcesToReturn = new IResource[resourcesToRecreate.length]; monitor.beginTask("", resourcesToRecreate.length); //$NON-NLS-1$ monitor.setTaskName(UndoMessages.AbstractResourcesOperation_CreateResourcesProgress); try { for (int i = 0; i < resourcesToRecreate.length; ++i) { if (monitor.isCanceled()) { throw new OperationCanceledException(); } try { resourcesToReturn[i] = resourcesToRecreate[i] .createResource(new SubProgressMonitor(monitor, 1)); } catch (CoreException e) { exceptions.add(e); } } IStatus result = WorkspaceUndoUtil.createResult(exceptions); if (!result.isOK()) { throw new CoreException(result); } } finally { monitor.done(); } return resourcesToReturn; } /** * Delete the specified resources, returning a resource description that can * be used to restore it. * * @param resourceToDelete * the resource to be deleted * @param monitor * the progress monitor to use to show the operation's progress * @param uiInfo * the IAdaptable (or <code>null</code>) provided by the * caller in order to supply UI information for prompting the * user if necessary. When this parameter is not * <code>null</code>, it contains an adapter for the * org.eclipse.swt.widgets.Shell.class * @param forceOutOfSyncDelete * a boolean indicating whether a resource should be deleted even * if it is out of sync with the file system * @param deleteContent * a boolean indicating whether project content should be deleted * when a project resource is to be deleted * @return a ResourceDescription that can be used to restore the deleted * resource. * @throws CoreException * propagates any CoreExceptions thrown from the resources API */ static ResourceDescription delete(IResource resourceToDelete, IProgressMonitor monitor, IAdaptable uiInfo, boolean forceOutOfSyncDelete, boolean deleteContent) throws CoreException { ResourceDescription resourceDescription = ResourceDescription.fromResource(resourceToDelete); if (resourceToDelete.getType() == IResource.PROJECT) { // it is a project monitor.setTaskName(UndoMessages.AbstractResourcesOperation_DeleteResourcesProgress); IProject project = (IProject) resourceToDelete; project.delete(deleteContent, forceOutOfSyncDelete, monitor); } else { // if it's not a project, just delete it monitor.beginTask("", 2); //$NON-NLS-1$ monitor.setTaskName(UndoMessages.AbstractResourcesOperation_DeleteResourcesProgress); int updateFlags; if (forceOutOfSyncDelete) { updateFlags = IResource.KEEP_HISTORY | IResource.FORCE; } else { updateFlags = IResource.KEEP_HISTORY; } resourceToDelete.delete(updateFlags, new SubProgressMonitor(monitor, 1)); resourceDescription.recordStateFromHistory(resourceToDelete, new SubProgressMonitor(monitor, 1)); monitor.done(); } return resourceDescription; } /* * Copy the content of the specified resource to the existing resource, * returning a ResourceDescription that can be used to restore the original * content. Do nothing if the resources are not files. */ private static ResourceDescription copyOverExistingResource(IResource source, IResource existing, IProgressMonitor monitor, IAdaptable uiInfo, boolean deleteSourceFile) throws CoreException { if (!(source instanceof IFile && existing instanceof IFile)) { return null; } IFile file = (IFile) source; IFile existingFile = (IFile) existing; monitor.beginTask(UndoMessages.AbstractResourcesOperation_CopyingResourcesProgress, 3); if (file != null && existingFile != null) { if (validateEdit(file, existingFile, getShell(uiInfo))) { // Remember the state of the existing file so it can be // restored. FileDescription fileDescription = new FileDescription(existingFile); // Reset the contents to that of the file being moved existingFile.setContents(file.getContents(), IResource.KEEP_HISTORY, new SubProgressMonitor(monitor, 1)); fileDescription.recordStateFromHistory(existingFile, new SubProgressMonitor(monitor, 1)); // Now delete the source file if requested // We don't need to remember anything about it, because // any undo involving this operation will move the original // content back to it. if (deleteSourceFile) { file.delete(IResource.KEEP_HISTORY, new SubProgressMonitor(monitor, 1)); } monitor.done(); return fileDescription; } } monitor.done(); return null; } /* * Check for existence of the specified path and generate any containers * that do not yet exist. Return any generated containers, or null if no * container had to be generated. */ private static IContainer generateContainers(IPath path) throws CoreException { IResource container; if (path.segmentCount() == 0) { // nothing to generate return null; } container = getWorkspaceRoot().findMember(path); // Nothing to generate because container exists if (container != null) { return null; } // Now make a non-existent handle representing the desired container if (path.segmentCount() == 1) { container = ResourcesPlugin.getWorkspace().getRoot().getProject(path.segment(0)); } else { container = ResourcesPlugin.getWorkspace().getRoot().getFolder(path); } ContainerDescription containerDescription = ContainerDescription.fromContainer((IContainer) container); container = containerDescription.createResourceHandle(); containerDescription.createExistentResourceFromHandle(container, new NullProgressMonitor()); return (IContainer) container; } /* * Ask the user whether the given resource should be deleted despite being * out of sync with the file system. * * Return one of the IDialogConstants constants indicating which of the Yes, * Yes to All, No, Cancel options has been selected by the user. */ private static int queryDeleteOutOfSync(IResource resource, IAdaptable uiInfo) { Shell shell = getShell(uiInfo); final MessageDialog dialog = new MessageDialog(shell, UndoMessages.AbstractResourcesOperation_deletionMessageTitle, null, NLS.bind(UndoMessages.AbstractResourcesOperation_outOfSyncQuestion, resource.getName()), MessageDialog.QUESTION, new String[] { IDialogConstants.YES_LABEL, IDialogConstants.YES_TO_ALL_LABEL, IDialogConstants.NO_LABEL, IDialogConstants.CANCEL_LABEL }, 0) { protected int getShellStyle() { return super.getShellStyle() | SWT.SHEET; } }; shell.getDisplay().syncExec(new Runnable() { public void run() { dialog.open(); } }); int result = dialog.getReturnCode(); if (result == 0) { return IDialogConstants.YES_ID; } if (result == 1) { return IDialogConstants.YES_TO_ALL_ID; } if (result == 2) { return IDialogConstants.NO_ID; } return IDialogConstants.CANCEL_ID; } /* * Creates and return a result status appropriate for the given list of * exceptions. */ private static IStatus createResult(List exceptions) { if (exceptions.isEmpty()) { return Status.OK_STATUS; } final int exceptionCount = exceptions.size(); if (exceptionCount == 1) { return ((CoreException) exceptions.get(0)).getStatus(); } CoreException[] children = (CoreException[]) exceptions.toArray(new CoreException[exceptionCount]); boolean outOfSync = false; for (int i = 0; i < children.length; i++) { if (children[i].getStatus().getCode() == IResourceStatus.OUT_OF_SYNC_LOCAL) { outOfSync = true; break; } } String title = outOfSync ? UndoMessages.AbstractResourcesOperation_outOfSyncError : UndoMessages.AbstractResourcesOperation_deletionExceptionMessage; final MultiStatus multi = new MultiStatus(IDEWorkbenchPlugin.IDE_WORKBENCH, 0, title, null); for (int i = 0; i < exceptionCount; i++) { CoreException exception = children[i]; IStatus status = exception.getStatus(); multi.add(new Status(status.getSeverity(), status.getPlugin(), status.getCode(), status.getMessage(), exception)); } return multi; } /* * Return the workspace. */ private static IWorkspace getWorkspace() { return ResourcesPlugin.getWorkspace(); } /* * Return the workspace root. */ private static IWorkspaceRoot getWorkspaceRoot() { return getWorkspace().getRoot(); } /* * Validate the destination file if it is read-only and additionally the * source file if both are read-only. Returns true if both files could be * made writeable. */ private static boolean validateEdit(IFile source, IFile destination, Shell shell) { if (destination.isReadOnly()) { IWorkspace workspace = WorkspaceUndoUtil.getWorkspace(); IStatus status; if (source.isReadOnly()) { status = workspace.validateEdit(new IFile[] { source, destination }, shell); } else { status = workspace.validateEdit(new IFile[] { destination }, shell); } return status.isOK(); } return true; } /** * Return the shell described by the specified adaptable, or the active * shell if no shell has been specified in the adaptable. * * @param uiInfo * the IAdaptable (or <code>null</code>) provided by the * caller in order to supply UI information for prompting the * user if necessary. When this parameter is not * <code>null</code>, it contains an adapter for the * org.eclipse.swt.widgets.Shell.class * * @return the Shell that can be used to show information */ public static Shell getShell(IAdaptable uiInfo) { if (uiInfo != null) { Shell shell = (Shell) uiInfo.getAdapter(Shell.class); if (shell != null) { return shell; } } return PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(); } }