Attachment #51440 for bug #123674

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




import java.lang.reflect.InvocationTargetException;
import java.util.Iterator;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;

import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.ide.undo.CreateFileOperation;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.ide.IIDEHelpContextIds;

     * @param monitor the progress monitor to show visual progress with
     * @exception CoreException if the operation fails
     * @exception OperationCanceledException if the operation is canceled
     * 
     * @deprecated As of 3.3, use or override {@link #createNewFile()} which uses the
     *   undoable operation support.  To supply customized file content for
     *   a subclass, use {@link #getInitialContents()}.  
     */
    protected void createFile(IFile fileHandle, InputStream contents,
            IProgressMonitor monitor) throws CoreException {

        final InputStream initialContents = getInitialContents();

        createLinkTarget();
		IRunnableWithProgress op = new IRunnableWithProgress() {
			public void run(IProgressMonitor monitor) {
				CreateFileOperation op = new CreateFileOperation(
						newFileHandle, linkTargetPath, initialContents,
						IDEWorkbenchMessages.WizardNewFileCreationPage_title);
				try {
					PlatformUI.getWorkbench().getOperationSupport()
							.getOperationHistory().execute(op, monitor,
									new IAdaptable() {
										public Object getAdapter(Class clazz) {
											if (clazz == Shell.class) {
												return getContainer()
														.getShell();
											}
											return null;
										}
									});
				} catch (ExecutionException e) {
					IDEWorkbenchPlugin.log(e.getMessage(), e);
				}
			}
		};

        try {
            getContainer().run(true, true, op);
        } catch (InterruptedException e) {
            return null;
        } catch (InvocationTargetException e) {
        	// Execution Exceptions are handled above but we may still get unexpected runtime errors.
            IDEWorkbenchPlugin.log(getClass(),
                    "createNewFile()", e.getTargetException()); //$NON-NLS-1$
            MessageDialog
                    .openError(
                            getContainer().getShell(),
                            IDEWorkbenchMessages.WizardNewFileCreationPage_internalErrorTitle, NLS.bind(IDEWorkbenchMessages.WizardNewFileCreationPage_internalErrorMessage, e.getTargetException().getMessage()));
            
            } else {
                // CoreExceptions are handled above, but unexpected runtime exceptions and errors may still occur.
                IDEWorkbenchPlugin.log(getClass(),
                        "createNewFile()", e.getTargetException()); //$NON-NLS-1$
                MessageDialog
                        .openError(
                                getContainer().getShell(),
                                IDEWorkbenchMessages.WizardNewFileCreationPage_internalErrorTitle, NLS.bind(IDEWorkbenchMessages.WizardNewFileCreationPage_internalErrorMessage, e.getTargetException().getMessage()));
            }
            return null;
        }





import java.lang.reflect.InvocationTargetException;
import java.util.Iterator;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceStatus;

import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.ide.undo.CreateFolderOperation;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.ide.IIDEHelpContextIds;

 * <p>
 * Subclasses may extend
 * <ul>
 * <li><code>handleEvent</code></li>
 * </ul>
 * </p>
 */
public class WizardNewFolderMainPage extends WizardPage implements Listener {
	private static final int SIZING_CONTAINER_GROUP_HEIGHT = 250;

	private IStructuredSelection currentSelection;

	private IFolder newFolder;

	// link target location
	private IPath linkTargetPath;

	// widgets
	private ResourceAndContainerGroup resourceGroup;

	private Button advancedButton;

	private CreateLinkedResourceGroup linkedResourceGroup;

	private Composite linkedResourceParent;

	private Composite linkedResourceComposite;

	/**
	 * Height of the "advanced" linked resource group. Set when the advanced
	 * group is first made visible.
	 */
	private int linkedResourceGroupHeight = -1;

	/**
	 * First time the advanced group is validated.
	 */
	private boolean firstLinkCheck = true;

	/**
	 * Creates a new folder creation wizard page. If the initial resource
	 * selection contains exactly one container resource then it will be used as
	 * the default container resource.
	 * 
	 * @param pageName
	 *            the name of the page
	 * @param selection
	 *            the current resource selection
	 */
	public WizardNewFolderMainPage(String pageName,
			IStructuredSelection selection) {
		super("newFolderPage1");//$NON-NLS-1$
		setTitle(pageName);
		setDescription(IDEWorkbenchMessages.WizardNewFolderMainPage_description);
		this.currentSelection = selection;
	}

	/**
	 * Creates the widget for advanced options.
	 * 
	 * @param parent
	 *            the parent composite
	 */
	protected void createAdvancedControls(Composite parent) {
		Preferences preferences = ResourcesPlugin.getPlugin()
				.getPluginPreferences();

		if (preferences.getBoolean(ResourcesPlugin.PREF_DISABLE_LINKING) == false) {
			linkedResourceParent = new Composite(parent, SWT.NONE);
			linkedResourceParent.setFont(parent.getFont());
			linkedResourceParent.setLayoutData(new GridData(
					GridData.FILL_HORIZONTAL));
			GridLayout layout = new GridLayout();
			layout.marginHeight = 0;
			layout.marginWidth = 0;
			linkedResourceParent.setLayout(layout);

			advancedButton = new Button(linkedResourceParent, SWT.PUSH);
			advancedButton.setFont(linkedResourceParent.getFont());
			advancedButton.setText(IDEWorkbenchMessages.showAdvanced);
			GridData data = setButtonLayoutData(advancedButton);
			data.horizontalAlignment = GridData.BEGINNING;
			advancedButton.setLayoutData(data);
			advancedButton.addSelectionListener(new SelectionAdapter() {
				public void widgetSelected(SelectionEvent e) {
					handleAdvancedButtonSelect();
				}
			});
		}
		linkedResourceGroup = new CreateLinkedResourceGroup(IResource.FOLDER,
				new Listener() {
					public void handleEvent(Event e) {
						setPageComplete(validatePage());
						firstLinkCheck = false;
					}
				}, new CreateLinkedResourceGroup.IStringValue() {
					public String getValue() {
						return resourceGroup.getResource();
					}

					public void setValue(String string) {
						resourceGroup.setResource(string);
					}
				});
	}

	/**
	 * (non-Javadoc) Method declared on IDialogPage.
	 */
	public void createControl(Composite parent) {
		initializeDialogUnits(parent);
		// top level group
		Composite composite = new Composite(parent, SWT.NONE);
		composite.setFont(parent.getFont());
		composite.setLayout(new GridLayout());
		composite.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_FILL
				| GridData.HORIZONTAL_ALIGN_FILL));

		PlatformUI.getWorkbench().getHelpSystem().setHelp(composite,
				IIDEHelpContextIds.NEW_FOLDER_WIZARD_PAGE);

		resourceGroup = new ResourceAndContainerGroup(composite, this,
				IDEWorkbenchMessages.WizardNewFolderMainPage_folderName,
				IDEWorkbenchMessages.WizardNewFolderMainPage_folderLabel,
				false, SIZING_CONTAINER_GROUP_HEIGHT);
		resourceGroup.setAllowExistingResources(false);
		createAdvancedControls(composite);
		initializePage();
		validatePage();
		// Show description on opening
		setErrorMessage(null);
		setMessage(null);
		setControl(composite);
	}

	/**
	 * Creates a folder resource given the folder handle.
	 * 
	 * @param folderHandle
	 *            the folder handle to create a folder resource for
	 * @param monitor
	 *            the progress monitor to show visual progress with
	 * @exception CoreException
	 *                if the operation fails
	 * @exception OperationCanceledException
	 *                if the operation is canceled
	 *                
	 * @deprecated As of 3.3, use {@link #createNewFolder()} which uses the 
	 *   undoable operation support.
	 */
	protected void createFolder(IFolder folderHandle, IProgressMonitor monitor)
			throws CoreException {
		try {
			// Create the folder resource in the workspace
			// Update: Recursive to create any folders which do not exist
			// already
			if (!folderHandle.exists()) {
				if (linkTargetPath != null) {
					folderHandle.createLink(linkTargetPath,
							IResource.ALLOW_MISSING_LOCAL, monitor);
				} else {
					IPath path = folderHandle.getFullPath();
					IWorkspaceRoot root = ResourcesPlugin.getWorkspace()
							.getRoot();
					int numSegments = path.segmentCount();
					if (numSegments > 2
							&& !root.getFolder(path.removeLastSegments(1))
									.exists()) {
						// If the direct parent of the path doesn't exist, try
						// to create the
						// necessary directories.
						for (int i = numSegments - 2; i > 0; i--) {
							IFolder folder = root.getFolder(path
									.removeLastSegments(i));
							if (!folder.exists()) {
								folder.create(false, true, monitor);
							}
						}
					}
					folderHandle.create(false, true, monitor);
				}
			}
		} catch (CoreException e) {
			// If the folder already existed locally, just refresh to get
			// contents
			if (e.getStatus().getCode() == IResourceStatus.PATH_OCCUPIED) {
				folderHandle.refreshLocal(IResource.DEPTH_INFINITE,
						new SubProgressMonitor(monitor, 500));
			} else {
				throw e;
			}
		}

		if (monitor.isCanceled()) {
			throw new OperationCanceledException();
		}
	}

	/**
	 * Creates a folder resource handle for the folder with the given workspace
	 * path. This method does not create the folder resource; this is the
	 * responsibility of <code>createFolder</code>.
	 * 
	 * @param folderPath
	 *            the path of the folder resource to create a handle for
	 * @return the new folder resource handle
	 * @see #createFolder
	 */
	protected IFolder createFolderHandle(IPath folderPath) {
		return IDEWorkbenchPlugin.getPluginWorkspace().getRoot().getFolder(
				folderPath);
	}

	/**
	 * Creates the link target path if a link target has been specified.
	 */
	protected void createLinkTarget() {
		String linkTarget = linkedResourceGroup.getLinkTarget();
		if (linkTarget != null) {
			linkTargetPath = new Path(linkTarget);
		} else {
			linkTargetPath = null;
		}
	}

	/**
	 * Creates a new folder resource in the selected container and with the
	 * selected name. Creates any missing resource containers along the path;
	 * does nothing if the container resources already exist.
	 * <p>
	 * In normal usage, this method is invoked after the user has pressed Finish
	 * on the wizard; the enablement of the Finish button implies that all
	 * controls on this page currently contain valid values.
	 * </p>
	 * <p>
	 * Note that this page caches the new folder once it has been successfully
	 * created; subsequent invocations of this method will answer the same
	 * folder resource without attempting to create it again.
	 * </p>
	 * <p>
	 * This method should be called within a workspace modify operation since it
	 * creates resources.
	 * </p>
	 * 
	 * @return the created folder resource, or <code>null</code> if the folder
	 *         was not created
	 */
	public IFolder createNewFolder() {
		if (newFolder != null) {
			return newFolder;
		}

		// create the new folder and cache it if successful
		final IPath containerPath = resourceGroup.getContainerFullPath();
		IPath newFolderPath = containerPath.append(resourceGroup.getResource());
		final IFolder newFolderHandle = createFolderHandle(newFolderPath);

		createLinkTarget();
		IRunnableWithProgress op = new IRunnableWithProgress() {
			public void run(IProgressMonitor monitor) {
				CreateFolderOperation op = new CreateFolderOperation(
						newFolderHandle, linkTargetPath,
						IDEWorkbenchMessages.WizardNewFolderCreationPage_title);
				try {
					PlatformUI.getWorkbench().getOperationSupport()
							.getOperationHistory().execute(op, monitor,
									new IAdaptable() {
										public Object getAdapter(Class clazz) {
											if (clazz == Shell.class) {
												return getContainer()
														.getShell();
											}
											return null;
										}
									});
				} catch (ExecutionException e) {
					IDEWorkbenchPlugin.log(e.getMessage(), e);
				}
			}
		};

		try {
			getContainer().run(true, true, op);
		} catch (InterruptedException e) {
			return null;
		} catch (InvocationTargetException e) {
			// ExecutionExceptions are handled above, but unexpected runtime
			// exceptions and errors may still occur.
			IDEWorkbenchPlugin.log(getClass(),
					"createNewFolder()", e.getTargetException()); //$NON-NLS-1$
            MessageDialog
				.openError(
					getContainer().getShell(),
					IDEWorkbenchMessages.WizardNewFolderCreationPage_internalErrorTitle, NLS.bind(IDEWorkbenchMessages.WizardNewFolder_internalError, e.getTargetException().getMessage()));
			return null;
		}

		newFolder = newFolderHandle;

		return newFolder;
	}

	/**
	 * Shows/hides the advanced option widgets.
	 */
	protected void handleAdvancedButtonSelect() {
		Shell shell = getShell();
		Point shellSize = shell.getSize();
		Composite composite = (Composite) getControl();

		if (linkedResourceComposite != null) {
			linkedResourceComposite.dispose();
			linkedResourceComposite = null;
			composite.layout();
			shell.setSize(shellSize.x, shellSize.y - linkedResourceGroupHeight);
			advancedButton.setText(IDEWorkbenchMessages.showAdvanced);
		} else {
			linkedResourceComposite = linkedResourceGroup
					.createContents(linkedResourceParent);
			if (linkedResourceGroupHeight == -1) {
				Point groupSize = linkedResourceComposite.computeSize(
						SWT.DEFAULT, SWT.DEFAULT, true);
				linkedResourceGroupHeight = groupSize.y;
			}
			shell.setSize(shellSize.x, shellSize.y + linkedResourceGroupHeight);
			composite.layout();
			advancedButton.setText(IDEWorkbenchMessages.hideAdvanced);
		}
	}

	/**
	 * The <code>WizardNewFolderCreationPage</code> implementation of this
	 * <code>Listener</code> method handles all events and enablements for
	 * controls on this page. Subclasses may extend.
	 */
	public void handleEvent(Event ev) {
		setPageComplete(validatePage());
	}

	/**
	 * Initializes this page's controls.
	 */
	protected void initializePage() {
		Iterator it = currentSelection.iterator();
		if (it.hasNext()) {
			Object next = it.next();
			IResource selectedResource = null;
			if (next instanceof IResource) {
				selectedResource = (IResource) next;
			} else if (next instanceof IAdaptable) {
				selectedResource = (IResource) ((IAdaptable) next)
						.getAdapter(IResource.class);
			}
			if (selectedResource != null) {
				if (selectedResource.getType() == IResource.FILE) {
    	}
		return resource.getWorkspace().getRoot();
	}

    /**
     * Shows/hides the advanced option widgets. 
     */
    protected void handleAdvancedButtonSelect() {
        Shell shell = getShell();
        Point shellSize = shell.getSize();
        Composite composite = (Composite) getControl();

        if (linkedResourceComposite != null) {
            linkedResourceComposite.dispose();
            linkedResourceComposite = null;
            composite.layout();
            shell.setSize(shellSize.x, shellSize.y - linkedResourceGroupHeight);
            advancedButton.setText(IDEWorkbenchMessages.showAdvanced);
        } else {
            linkedResourceComposite = linkedResourceGroup
                    .createContents(linkedResourceParent);
            if (linkedResourceGroupHeight == -1) {
                Point groupSize = linkedResourceComposite.computeSize(
                        SWT.DEFAULT, SWT.DEFAULT, true);
                linkedResourceGroupHeight = groupSize.y;
            }
            shell.setSize(shellSize.x, shellSize.y + linkedResourceGroupHeight);
            composite.layout();
            advancedButton.setText(IDEWorkbenchMessages.hideAdvanced);
        }
    }

    /**
     * The <code>WizardNewFolderCreationPage</code> implementation of this 
     * <code>Listener</code> method handles all events and enablements for controls
     * on this page. Subclasses may extend.
     */
    public void handleEvent(Event ev) {
        setPageComplete(validatePage());
    }

    /**
     * Initializes this page's controls.
     */
    protected void initializePage() {
        Iterator it = currentSelection.iterator();
        if (it.hasNext()) {
            Object next = it.next();
            IResource selectedResource = null;
            if (next instanceof IResource) {
                selectedResource = (IResource) next;
            } else if (next instanceof IAdaptable) {
                selectedResource = (IResource) ((IAdaptable) next)
                        .getAdapter(IResource.class);
            }
            if (selectedResource != null) {
                if (selectedResource.getType() == IResource.FILE) {
					selectedResource = selectedResource.getParent();
				}
				if (selectedResource.isAccessible()) {
					resourceGroup.setContainerFullPath(selectedResource
							.getFullPath());
				}
			}
		}

		setPageComplete(false);
	}

	/*
	 * @see DialogPage.setVisible(boolean)
	 */
	public void setVisible(boolean visible) {
		super.setVisible(visible);
		if (visible) {
			resourceGroup.setFocus();
		}
	}

	/**
	 * Checks whether the linked resource target is valid. Sets the error
	 * message accordingly and returns the status.
	 * 
	 * @return IStatus validation result from the CreateLinkedResourceGroup
	 */
	protected IStatus validateLinkedResource() {
		IPath containerPath = resourceGroup.getContainerFullPath();
		IPath newFolderPath = containerPath.append(resourceGroup.getResource());
		IFolder newFolderHandle = createFolderHandle(newFolderPath);
		IStatus status = linkedResourceGroup
				.validateLinkLocation(newFolderHandle);

		if (status.getSeverity() == IStatus.ERROR) {
			if (firstLinkCheck) {
				setMessage(status.getMessage());
			} else {
				setErrorMessage(status.getMessage());
			}
		} else if (status.getSeverity() == IStatus.WARNING) {
			setMessage(status.getMessage(), WARNING);
			setErrorMessage(null);
		}
		return status;
	}

	/**
	 * Returns whether this page's controls currently all contain valid values.
	 * 
	 * @return <code>true</code> if all controls are valid, and
	 *         <code>false</code> if at least one is invalid
	 */
	protected boolean validatePage() {
		boolean valid = true;

		if (!resourceGroup.areAllValuesValid()) {
			// if blank name then fail silently
			if (resourceGroup.getProblemType() == ResourceAndContainerGroup.PROBLEM_RESOURCE_EMPTY
					|| resourceGroup.getProblemType() == ResourceAndContainerGroup.PROBLEM_CONTAINER_EMPTY) {
				setMessage(resourceGroup.getProblemMessage());
				setErrorMessage(null);
			} else {
				setErrorMessage(resourceGroup.getProblemMessage());
			}
			valid = false;
		}

		IStatus linkedResourceStatus = null;
		if (valid) {
			linkedResourceStatus = validateLinkedResource();
			if (linkedResourceStatus.getSeverity() == IStatus.ERROR) {
            if (linkedResourceStatus.getSeverity() == IStatus.ERROR) {
				valid = false;
			}
		}
		// validateLinkedResource sets messages itself
		if (valid
				&& (linkedResourceStatus == null || linkedResourceStatus.isOK())) {
			setMessage(null);
			setErrorMessage(null);
		}
		return valid;
	}

}





	public static String AbstractWorkspaceOperation_RedoSideEffectsWarningMessage;
	public static String AbstractWorkspaceOperation_ErrorInvalidMessage;
	public static String AbstractWorkspaceOperation_GenericWarningMessage;
	
	public static String AbstractResourcesOperation_ResourcesDoNotExist;
	public static String AbstractResourcesOperation_NotEnoughInfo;
	public static String AbstractResourcesOperation_InvalidRestoreInfo;
	public static String AbstractResourcesOperation_DeleteResourcesProgress;
	public static String AbstractResourcesOperation_CreateResourcesProgress;
	public static String AbstractResourcesOperation_CopyingResourcesProgress;
	public static String AbstractResourcesOperation_MovingResources;
	public static String AbstractResourcesOperation_outOfSyncError;
	public static String AbstractResourcesOperation_outOfSyncQuestion;
	public static String AbstractResourcesOperation_deletionMessageTitle;
	public static String AbstractResourcesOperation_deletionExceptionMessage;
	public static String AbstractResourcesOperation_overwriteTitle;
	public static String AbstractResourcesOperation_overwriteError;
	public static String AbstractResourcesOperation_overwriteQuestion;
	
	public static String MoveOrCopyResourceOperation_SameNameOrLocation;
	public static String MoveOrCopyResourceOperation_ResourceDoesNotExist;
	public static String MoveOrCopyResourceOperation_ReadOnly;

	public static String DeleteResourcesOperation_DeletingProjectContentWarning;
	public static String CreateProjectOperation_caseVariantExistsError;
	
	public static String ProjectDescription_NewProjectProgress;
	public static String FileDescription_NewFileProgress;
	public static String FileDescription_SavingUndoInfoProgress;
	public static String FileDescription_ContentsCouldNotBeRestored;
	public static String FolderDescription_NewFolderProgress;
	public static String FolderDescription_SavingUndoInfoProgress;
	

	public static String MarkerOperation_ResourceDoesNotExist;
	public static String MarkerOperation_MarkerDoesNotExist;
	public static String MarkerOperation_NotEnoughInfo;	
	
	public static String RenameResourceOperation_SameName;
	public static String RenameResourceOperation_NameAlreadyExists;
	public static String RenameResourceOperation_ResourceDoesNotExist;
	public static String RenameResourceOperation_ReadOnly;
	public static String RenameResourceOperation_ResourceAlreadyExists;
}




AbstractWorkspaceOperation_UndoSideEffectsWarningMessage=Undoing "{0}" may have undesirable side effects.
AbstractWorkspaceOperation_RedoSideEffectsWarningMessage=Redoing "{0}" may have undesirable side effects.

AbstractResourcesOperation_ResourcesDoNotExist=Cannot complete operation because resources no longer exist.
AbstractResourcesOperation_NotEnoughInfo=There is not enough information to complete the resource operation.
AbstractResourcesOperation_InvalidRestoreInfo=There is no longer enough information to restore the resource.
AbstractResourcesOperation_DeleteResourcesProgress=Deleting resources...
AbstractResourcesOperation_CreateResourcesProgress=Creating resources...
AbstractResourcesOperation_CopyingResourcesProgress=Copying resources...
AbstractResourcesOperation_MovingResources=Moving resources...
AbstractResourcesOperation_outOfSyncError = Resource is out of sync with the file system. Refresh and try again.
AbstractResourcesOperation_outOfSyncQuestion = Resource ''{0}'' is out of sync with the file system. Do you want to delete it anyway?
AbstractResourcesOperation_deletionMessageTitle = Problems deleting
AbstractResourcesOperation_deletionExceptionMessage=Multiple problems occurred while deleting resources.
AbstractResourcesOperation_overwriteTitle = Resource already exists
AbstractResourcesOperation_overwriteError = Could not complete operation without overwriting resources.
AbstractResourcesOperation_overwriteQuestion = Resource ''{0}'' already exists. Do you want to overwrite it?



DeleteResourcesOperation_DeletingProjectContentWarning=Deleting project content will erase all of the file and folder history for the project.  Undo will not restore the content.

CreateProjectOperation_caseVariantExistsError = The underlying file system is case insensitive. There is an existing project which conflicts with ''{0}''.

ProjectDescription_NewProjectProgress=Creating new project...
FileDescription_NewFileProgress=Creating new file...
FileDescription_ContentsCouldNotBeRestored=Unexpected error.  File contents could not be restored from local history during undo/redo.
FileDescription_SavingUndoInfoProgress=Saving file info...
FolderDescription_NewFolderProgress=Creating new folder...
FolderDescription_SavingUndoInfoProgress=Saving folder info...
	
MarkerOperation_ResourceDoesNotExist=Cannot complete operation because resource no longer exists.
MarkerOperation_MarkerDoesNotExist=Cannot complete operation because marker no longer exists.
MarkerOperation_NotEnoughInfo=There is not enough information to perform the marker operation.

MoveOrCopyResourceOperation_ReadOnly=The resource {0} is read only.
MoveOrCopyResourceOperation_SameNameOrLocation=Resource cannot be moved or copied to the same location and name.
MoveOrCopyResourceOperation_ResourceDoesNotExist=Resource no longer exists in the workspace.
RenameResourceOperation_ResourceDoesNotExist=Resource no longer exists in the workspace.
RenameResourceOperation_ResourceAlreadyExists=A resource named {0} already exists.  It will be overwritten.




/*******************************************************************************
 * 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.ui.ide.undo;

import java.util.Map;

import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;

/**
 * MarkerDescription is a lightweight description of a marker that can be used
 * to describe a marker to be created or updated.
 * 
 * This class is not intended to be instantiated or used by clients.
 * 
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as part
 * of a work in progress. This API may change at any given time. Please do not
 * use this API without consulting with the Platform/UI team.
 * 
 * @since 3.3
 * 
 */
class MarkerDescription {
	String type;

	Map attributes;

	IResource resource;

	/*
	 * Create a marker description from the specified marker.
	 */
	MarkerDescription(IMarker marker) throws CoreException {
		this.type = marker.getType();
		this.attributes = marker.getAttributes();
		this.resource = marker.getResource();

	}

	/*
	 * Create a marker description from the specified marker type, attributes,
	 * and resource.
	 */
	MarkerDescription(String type, Map attributes, IResource resource) {
		this.type = type;
		this.attributes = attributes;
		this.resource = resource;
	}

	/*
	 * Create a marker from the marker description.
	 */
	protected IMarker createMarker() throws CoreException {
		IMarker marker = resource.createMarker(type);
		marker.setAttributes(attributes);
		return marker;
	}

	/*
	 * Update an existing marker using the attributes in the marker description.
	 */
	protected void updateMarker(IMarker marker) throws CoreException {
		marker.setAttributes(attributes);
	}
}




import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.ui.internal.ide.undo.MarkerDescription;
import org.eclipse.ui.internal.ide.undo.UndoMessages;

/**

			if (markerDescriptions != null) {
				resources = new IResource[markerDescriptions.length];
				for (int i = 0; i < markerDescriptions.length; i++) {
					resources[i] = markerDescriptions[i].getResource();
				}
			}
		} else {

			if (markerDescriptions != null) {
				types = new String[markerDescriptions.length];
				for (int i = 0; i < markerDescriptions.length; i++) {
					types[i] = markerDescriptions[i].getType();
				}
			}
		} else {





	private static String ELLIPSIS = "..."; //$NON-NLS-1$

	protected static int EXECUTE = 1;

	protected static int UNDO = 2;

	protected static int REDO = 3;

	protected IResource[] resources;



	String[] modelProviderIds;

	/*
	 * Return the shell described by the specified adaptable, or the active
	 * shell if no shell has been specified in the adaptable.
	 */
	protected static Shell getShell(IAdaptable info) {
		if (info != null) {
			Shell shell = (Shell) info.getAdapter(Shell.class);
			if (shell != null) {
				return shell;
			}
		}
		return PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
	}

	/**
	 * Create an AbstractWorkspaceOperation with the specified name.
	 * 

	public boolean canExecute() {
		return isValid();
	}

	/*
	 * (non-Javadoc)
	 * 

				public void run(IProgressMonitor monitor) throws CoreException {
					doExecute(monitor, info);
				}
			}, null, IWorkspace.AVOID_UPDATE, null);
		} catch (final CoreException e) {
			final boolean[] propagateException = new boolean[1];
			getShell(info).getDisplay().syncExec(new Runnable() {
				public void run() {
					propagateException[0] = handleCoreException(
							e,
							getShell(info),
							NLS
									.bind(
											UndoMessages.AbstractWorkspaceOperation_ExecuteErrorTitle,
											getLabel()));
											.getStatus());

				}

			});
			if (propagateException[0]) {
				throw new ExecutionException(
						NLS
								.bind(
										UndoMessages.AbstractWorkspaceOperation_ExecuteErrorTitle,
										getLabel()), e);
			}
		}
		isValid = true;
		return Status.OK_STATUS;

				}
			}, null);
		} catch (final CoreException e) {
			final boolean[] propagateException = new boolean[1];
			getShell(info).getDisplay().syncExec(new Runnable() {
				public void run() {
					propagateException[0] = handleCoreException(
							e,
							getShell(info),
							NLS
									.bind(
											UndoMessages.AbstractWorkspaceOperation_RedoErrorTitle,
											getLabel()));
											.getStatus());

				}

			});
			if (propagateException[0]) {
				throw new ExecutionException(NLS.bind(
						UndoMessages.AbstractWorkspaceOperation_RedoErrorTitle,
						getLabel()), e);
			}
		}
		isValid = true;
		return Status.OK_STATUS;

				}
			}, null);
		} catch (final CoreException e) {
			final boolean[] propagateException = new boolean[1];
			getShell(info).getDisplay().syncExec(new Runnable() {
				public void run() {
					propagateException[0] = handleCoreException(
							e,
							getShell(info),
							NLS
									.bind(
											UndoMessages.AbstractWorkspaceOperation_UndoErrorTitle,
											getLabel()));
											.getStatus());

				}

			});
			if (propagateException[0]) {
				throw new ExecutionException(NLS.bind(
						UndoMessages.AbstractWorkspaceOperation_UndoErrorTitle,
						getLabel()), e);
			}
		}
		isValid = true;
		return Status.OK_STATUS;

	protected abstract void doExecute(IProgressMonitor monitor, IAdaptable info)
			throws CoreException;

	/*
	 * Return the shell described by the specified adaptable, or the active
	 * shell if no shell has been specified in the adaptable.
	 */
	protected Shell getShell(IAdaptable info) {
		if (info != null) {
			Shell shell = (Shell) info.getAdapter(Shell.class);
			if (shell != null) {
				return shell;
			}
		}
		return PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
	}

	/**
	 * Return whether the proposed operation is valid. The default
	 * implementation simply checks to see if the flag has been marked as
	 * invalid, relying on subclasses to mark the flag invalid when appropriate.
	 * appropriate.
	 * 
	 */
	protected boolean isValid() {

	public Object[] getAffectedObjects() {
		return resources;
	}

	/*
	 * Return a status indicating the projected outcome of executing the
	 * receiver. This method is not called by the operation history, but instead
	 * is used by clients (such as implementers of {@link IOperationApprover2})
	 * who wish to perform advanced validation of an operation before attempting
	 * to execute it.
	 * 
	 * If an ERROR status is returned, the operation will not proceed and the
	 * user notified if deemed necessary by the caller. The validity flag on the
	 * operation should be marked as invalid. If an OK status is returned, the
	 * operation will proceed. The caller must interpret any other returned
	 * status severity, and may choose to prompt the user as to how to proceed.
	 * 
	 * If there are multiple conditions that result in an ambiguous status
	 * severity, it is best for the implementor of this method to consult the
	 * user as to how to proceed for each one, and return an OK or ERROR status
	 * that accurately reflects the user's wishes, or to return a multi-status
	 * that accurately describes all of the issues at hand, so that the caller
	 * may potentially consult the user.
	 * 
	 * This implementation computes the validity of execution by computing the
	 * resource delta that would be generated on execution, and checking whether
	 * any registered model providers are affected by the operation.
	 * 
	 * @see org.eclipse.core.commands.operations.IAdvancedUndoableOperation#computeUndoableStatus(org.eclipse.core.runtime.IProgressMonitor)
	 */


	/*
	 * Return a status indicating the projected outcome of undoing the receiver.
	 * This method is not called by the operation history, but instead is used
	 * by clients (such as implementers of {@link IOperationApprover2}) who
	 * wish to perform advanced validation of an operation before attempting to
	 * undo it.
	 * 
	 * If an ERROR status is returned, the undo will not proceed and the user
	 * notified if deemed necessary by the caller. The validity flag on the
	 * operation should be marked as invalid. If an OK status is returned, the
	 * undo will proceed. The caller must interpret any other returned status
	 * severity, and may choose to prompt the user as to how to proceed.
	 * 
	 * If there are multiple conditions that result in an ambiguous status
	 * severity, it is best for the implementor of this method to consult the
	 * user as to how to proceed for each one, and return an OK or ERROR status
	 * that accurately reflects the user's wishes, or to return a multi-status
	 * that accurately describes all of the issues at hand, so that the caller
	 * may potentially consult the user.
	 * 
	 * This implementation computes the validity of undo by computing the
	 * resource delta that would be generated on undo, and checking whether any
	 * registered model providers are affected by the operation. *
	 * 
	 * @see org.eclipse.core.commands.operations.IAdvancedUndoableOperation#computeUndoableStatus(org.eclipse.core.runtime.IProgressMonitor)
	 */


	/*
	 * Return a status indicating the projected outcome of redoing the receiver.
	 * This method is not called by the operation history, but instead is used
	 * by clients (such as implementers of {@link IOperationApprover2}) who
	 * wish to perform advanced validation of an operation before attempting to
	 * redo it.
	 * 
	 * If an ERROR status is returned, the redo will not proceed and the user
	 * notified if deemed necessary by the caller. The validity flag on the
	 * operation should be marked as invalid. If an OK status is returned, the
	 * redo will proceed. The caller must interpret any other returned status
	 * severity, and may choose to prompt the user as to how to proceed.
	 * 
	 * If there are multiple conditions that result in an ambiguous status
	 * severity, it is best for the implementor of this method to consult the
	 * user as to how to proceed for each one, and return an OK or ERROR status
	 * that accurately reflects the user's wishes, or to return a multi-status
	 * that accurately describes all of the issues at hand, so that the caller
	 * may potentially consult the user.
	 * 
	 * This implementation computes the validity of redo by computing the
	 * resource delta that would be generated on redo, and checking whether any
	 * registered model providers are affected by the operation.
	 * 
	 * @see org.eclipse.core.commands.operations.IAdvancedUndoableOperation#computeUndoableStatus(org.eclipse.core.runtime.IProgressMonitor)
	 */

		}
		return true;
	}

	/**
	 * Return whether the resources known by this operation contain any
	 * projects.
	 * 
	 * @return <code>true</code> if there is one or more projects known by
	 *         this operation and false if there are no projects.
	 */
	protected boolean resourcesIncludesProjects() {
		if (resources == null || resources.length == 0) {
			return false;
		}
		for (int i = 0; i < resources.length; i++) {
			if (resources[i].getType() == IResource.PROJECT) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Handle the core exception that occurred while trying to execute, undo, or
	 * redo the operation, returning a boolean to indicate whether this
	 * exception should cuase a {@link ExecutionException} to be thrown.
	 * 
	 * It is safe to access UI in this method. The default implementation is to
	 * show an error dialog, but callers may choose to swallow certain
	 * exceptions or show them differently.
	 * 
	 * If the only difference in handling the exception is to show a different
	 * error message, callers should override
	 * {@link #getErrorMessage(CoreException)} instead.
	 */
	protected boolean handleCoreException(CoreException e, Shell shell,
			String errorTitle) {
		ErrorDialog.openError(shell, errorTitle, getErrorMessage(e), e
				.getStatus());
		return true;
	}

	/**
	 * Return the specific error message to use when the specified core
	 * exception occurs, or <code>null</code> to indicate that the the
	 * exception's message should be used.
	 */
	protected String getErrorMessage(CoreException e) {
		return null;
	}
}

Lines 19-24 Link Here

(-)src/org/eclipse/ui/ide/undo/CreateMarkersOperation.java (+1 lines)
19	import org.eclipse.core.runtime.IProgressMonitor;	19	import org.eclipse.core.runtime.IProgressMonitor;
20	import org.eclipse.core.runtime.IStatus;	20	import org.eclipse.core.runtime.IStatus;
21	import org.eclipse.core.runtime.NullProgressMonitor;	21	import org.eclipse.core.runtime.NullProgressMonitor;
		22	import org.eclipse.ui.internal.ide.undo.MarkerDescription;
22		23
23	/**	24	/**
24	* A CreateMarkersOperation represents an undoable operation for creating one or	25	* A CreateMarkersOperation represents an undoable operation for creating one or




 *******************************************************************************/
package org.eclipse.ui.actions;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceRuleFactory;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.resources.mapping.ResourceChangeValidator;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.MultiRule;

import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.ide.undo.DeleteResourcesOperation;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.ide.IIDEHelpContextIds;

	private boolean deleteContent = false;

	/**
	 * Whether or not to automatically delete out of sync resources
	 */
	private boolean forceOutOfSyncDelete = false;

	/**
	 * Flag that allows testing mode ... it won't pop up the project delete
	 * dialog, and will return "delete all content".
	 */

	}

	/**
	 * Creates and returns a result status appropriate for the given list of
	 * exceptions.
	 * 
	 * @param exceptions
	 *            The list of exceptions that occurred (may be empty)
	 * @return The result status for the deletion
	 */
	private 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 ? IDEWorkbenchMessages.DeleteResourceAction_outOfSyncError
				: IDEWorkbenchMessages.DeleteResourceAction_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;
	}

	/**
	 * Asks the user to confirm a delete operation.
	 * 
	 * @param resources

	 *         <code>false</code> if the deletion should be abandoned
	 */
	private boolean confirmDelete(IResource[] resources) {
		if (containsOnlyProjects(resources)) {
			return confirmDeleteProjects(resources);
				return confirmDeleteProjects(resources);
			}
			return confirmDeleteNonProjects(resources);
		}
		return confirmDeleteNonProjects(resources);
		
	}

	/**

		return code == 0; // YES
	}

	/**
	 * Deletes the given resources.
	 */
	private void delete(IResource[] resourcesToDelete, IProgressMonitor monitor)
			throws CoreException {
		final List exceptions = new ArrayList();
		forceOutOfSyncDelete = false;
		monitor.beginTask("", resourcesToDelete.length); //$NON-NLS-1$
		try {
			for (int i = 0; i < resourcesToDelete.length; ++i) {
				if (monitor.isCanceled()) {
					throw new OperationCanceledException();
				}
				try {
					delete(resourcesToDelete[i], new SubProgressMonitor(
							monitor, 1,
							SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK));
				} catch (CoreException e) {
					exceptions.add(e);
				}
			}
			IStatus result = createResult(exceptions);
			if (!result.isOK()) {
				throw new CoreException(result);
			}
		} finally {
			monitor.done();
		}
	}


	 * Deletes the given resource.
	 */
	private void delete(IResource resourceToDelete, IProgressMonitor monitor)
			throws CoreException {
		boolean force = false; // don't force deletion of out-of-sync resources
		try {
			if (resourceToDelete.getType() == IResource.PROJECT) {
				// if it's a project, ask whether content should be deleted too
				IProject project = (IProject) resourceToDelete;
				project.delete(deleteContent, force, monitor);
			} else {
				// if it's not a project, just delete it
				resourceToDelete.delete(IResource.KEEP_HISTORY, monitor);
			}
		} catch (CoreException exception) {
			if (resourceToDelete.getType() == IResource.FILE) {
				IStatus[] children = exception.getStatus().getChildren();

				if (children.length == 1
						&& children[0].getCode() == IResourceStatus.OUT_OF_SYNC_LOCAL) {
					if (forceOutOfSyncDelete) {
						resourceToDelete.delete(IResource.KEEP_HISTORY
								| IResource.FORCE, monitor);
					} else {
						int result = queryDeleteOutOfSync(resourceToDelete);

						if (result == IDialogConstants.YES_ID) {
							resourceToDelete.delete(IResource.KEEP_HISTORY
									| IResource.FORCE, monitor);
						} else if (result == IDialogConstants.YES_TO_ALL_ID) {
							forceOutOfSyncDelete = true;
							resourceToDelete.delete(IResource.KEEP_HISTORY
									| IResource.FORCE, monitor);
						} else if (result == IDialogConstants.CANCEL_ID) {
							throw new OperationCanceledException();
						}
					}
				} else {
					throw exception;
				}
			} else {
				throw exception;
			}
		}
	}

	/**
	 * Return an array of the currently selected resources.

				IDEWorkbenchMessages.DeleteResourceAction_jobName) {
			public IStatus run(IProgressMonitor monitor) {
				try {
					DeleteResourcesOperation op = 
						new DeleteResourcesOperation(resourcesToDelete, getText(), deleteContent);
					op.setModelProviderIds(getModelProviderIds());
					return PlatformUI.getWorkbench().getOperationSupport()
					.getOperationHistory().execute(op, monitor, new IAdaptable() {
	   					public Object getAdapter(Class clazz) {
	   						if (clazz == Shell.class) {
	   							return shell;
	   						}
	   						return null;
	   					}
	   				});
				} catch (ExecutionException e) {
					IDEWorkbenchPlugin.log(e.getMessage(), e);
					return new Status(IStatus.ERROR, IDEWorkbenchPlugin.IDE_WORKBENCH, e.getMessage(),e);
				}
				return Status.OK_STATUS;
			}

			/*

	}

	/**
	 * Ask the user whether the given resource should be deleted despite being
	 * out of sync with the file system.
	 * 
	 * @param resource
	 *            the out of sync resource
	 * @return One of the IDialogConstants constants indicating which of the
	 *         Yes, Yes to All, No, Cancel options has been selected by the
	 *         user.
	 */
	private int queryDeleteOutOfSync(IResource resource) {
		final MessageDialog dialog = new MessageDialog(
				shell,
				IDEWorkbenchMessages.DeleteResourceAction_messageTitle,
				null,
				NLS
						.bind(
								IDEWorkbenchMessages.DeleteResourceAction_outOfSyncQuestion,
								resource.getName()), MessageDialog.QUESTION,
				new String[] { IDialogConstants.YES_LABEL,
						IDialogConstants.YES_TO_ALL_LABEL,
						IDialogConstants.NO_LABEL,
						IDialogConstants.CANCEL_LABEL }, 0);
		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;
	}

	/**
	 * Validates the operation against the model providers.
	 * 
	 * @param resources
	 *            the resources to be deleted
	 * @return whether the operation should proceed
	 */
	private boolean validateDelete(IResource[] resources) {
		IResourceChangeDescriptionFactory factory = ResourceChangeValidator
				.getValidator().createDeltaFactory();
		for (int i = 0; i < resources.length; i++) {
			IResource resource = resources[i];
			factory.delete(resource);
		}
		return IDE.promptToConfirm(shell,
				IDEWorkbenchMessages.DeleteResourceAction_confirm,
				IDEWorkbenchMessages.DeleteResourceAction_warning, factory
						.getDelta(), getModelProviderIds(), false /*
																	 * no need
																	 * to
																	 * syncExec
																	 */);
	}

	/**
	 * Returns the model provider ids that are known to the client that
	 * instantiated this operation.
	 * 





import java.lang.reflect.InvocationTargetException;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
import org.eclipse.core.resources.mapping.ResourceChangeValidator;
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.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.window.Window;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.ProjectLocationSelectionDialog;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.ide.undo.CopyResourcesOperation;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.progress.ProgressMonitorJobsDialog;

/**

     * (and can hence be ignored)
     * @return whether the operation should proceed
     * @since 3.2
     * @deprecated As of 3.3, validation is performed in the undoable operation 
     * executed by this operation.
     */
    protected static boolean validateCopy(Shell shell, IProject project, String newName, String[] modelProviderIds) {
    	IResourceChangeDescriptionFactory factory = ResourceChangeValidator.getValidator().createDeltaFactory();


        String newName = (String) destinationPaths[0];
        IPath newLocation = new Path((String) destinationPaths[1]);

        if (!validateCopy(parentShell, project, newName, getModelProviderIds())) {
			return;
		}
        
        boolean completed = performProjectCopy(project, newName, newLocation);


     */
    private boolean performProjectCopy(final IProject project,
            final String projectName, final IPath newLocation) {
        IRunnableWithProgress op = new IRunnableWithProgress() {
            public void run(IProgressMonitor monitor) {
            	CopyResourcesOperation op = new CopyResourcesOperation(project, 
            			newLocation.append(projectName), 
            			IDEWorkbenchMessages.CopyProjectOperation_copyProject);
    			op.setModelProviderIds(getModelProviderIds());
    			try {
    				PlatformUI.getWorkbench().getOperationSupport()
    						.getOperationHistory().execute(op, monitor, new IAdaptable() {
    		   					public Object getAdapter(Class clazz) {
    		   						if (clazz == Shell.class) {
    		   							return parentShell;
    		   						}
    		   						return null;
    		   					}
    		   				});
    			} catch (ExecutionException e) {
    				// Error message already shown to user by the operation
    				IDEWorkbenchPlugin.log(e.getMessage(), e);
    			}
            }
        };


    }

    /**
     * Create a new IProjectDescription for the copy using the auto-generated
     * name and path.
     * 
     * @return IProjectDescription
     * @param project the source project
     * @param projectName the name for the new project
     * @param rootLocation the path the new project will be stored under.
     * @throws CoreException
     */
    private IProjectDescription createProjectDescription(IProject project,
            String projectName, IPath rootLocation) throws CoreException {
        //Get a copy of the current description and modify it
        IProjectDescription newDescription = project.getDescription();
        newDescription.setName(projectName);

        //If the location is the default then set the location to null
        if (rootLocation.equals(Platform.getLocation())) {
			newDescription.setLocation(null);
		} else {
			newDescription.setLocation(rootLocation);
		}

        return newDescription;
    }

    /**
     * Records the core exception to be displayed to the user
     * once the action is finished.
     *
     * @param error a <code>CoreException</code>
     */
    private void recordError(CoreException error) {

        if (errorStatus == null) {
			errorStatus = new MultiStatus(
                    PlatformUI.PLUGIN_ID,
                    IStatus.ERROR,
                    IDEWorkbenchMessages.CopyProjectOperation_copyFailedMessage,
                    error);
		}

        errorStatus.merge(error.getStatus());
    }

    /**
     * Returns the model provider ids that are known to the client
     * that instantiated this operation.
     * 





import java.lang.reflect.InvocationTargetException;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.resources.mapping.ResourceChangeValidator;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.ProjectLocationMoveDialog;
import org.eclipse.ui.ide.undo.MoveResourcesOperation;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.ide.IIDEHelpContextIds;


	private static String PROBLEMS_TITLE = IDEWorkbenchMessages.MoveProjectAction_dialogTitle;

	private static String MOVE_PROGRESS_TITLE = IDEWorkbenchMessages.MoveProjectAction_progressMessage;

	/**
	 * The id of this action.
	 */

	 * Return the title of the errors dialog.
	 * 
	 * @return java.lang.String
	 * 
	 * @deprecated As of 3.3, the error handling is performed by the undoable 
	 * operation which handles the move.
	 */
	protected String getErrorsTitle() {
		return PROBLEMS_TITLE;

	 * Moves the project to the new values.
	 * 
	 * @param project
	 *            the project to move
	 * @param projectName
	 *            the name of the copy
	 * @param newLocation
	 *            IPath
	 * @return <code>true</code> if the copy operation completed, and
	 *         <code>false</code> if it was abandoned part way
	 */
	boolean performMove(final IProject project, 
			final IPath newLocation) {
		
		IRunnableWithProgress op =  new IRunnableWithProgress() {
    		public void run(IProgressMonitor monitor) {
    			MoveResourcesOperation op = new MoveResourcesOperation(new IResource[] {project}, newLocation, getText());
    			op.setModelProviderIds(getModelProviderIds());
    			try {
    				PlatformUI.getWorkbench().getOperationSupport()
    						.getOperationHistory().execute(op, monitor, new IAdaptable() {
    		   					public Object getAdapter(Class clazz) {
    		   						if (clazz == Shell.class) {
    		   							return shell;
    		   						}
    		   						return null;
    		   					}
    		   				});
    			} catch (ExecutionException e) {
    				IDEWorkbenchPlugin.log(e.getMessage(), e);
    			}
    		}
    	};
		
		};

		try {
			new ProgressMonitorJobsDialog(shell).run(true, true, op);
		} catch (InterruptedException e) {
			return false;
		} catch (InvocationTargetException e) {
			// CoreExceptions are collected by the operation, but unexpected runtime
			// exceptions and errors may still occur.
			IDEWorkbenchPlugin.log(getClass(),
                    "performMove()", e.getTargetException()); //$NON-NLS-1$

			return;
		}

		String projectName = (String) destinationPaths[0];
		IPath newLocation = new Path((String) destinationPaths[1]);

		if (!validateMove(project, projectName)) {
			return;
		}
		
		performMove(project, newLocation);

		if (!completed) {
			return; // not appropriate to show errors
		}

		// If errors occurred, open an Error dialog
		if (errorStatus != null) {
			ErrorDialog
					.openError(this.shell, PROBLEMS_TITLE, null, errorStatus);
			errorStatus = null;
		}
	}
	
	/**
	 * Validates the operation against the model providers.
	 *
	 * @param project the project to move
	 * @param newName the new name
	 * @return whether the operation should proceed
	 * @since 3.2
	 */
    private boolean validateMove(IProject project, String newName) {
    	if (project.getName().equals(newName)) {
    		// Only the location changed
    		return true;
    	}
    	IResourceChangeDescriptionFactory factory = ResourceChangeValidator.getValidator().createDeltaFactory();
    	factory.move(project, new Path(newName));
		return IDE.promptToConfirm(shell, IDEWorkbenchMessages.CopyProjectAction_confirm, NLS.bind(IDEWorkbenchMessages.CopyProjectAction_warning, project.getName()), factory.getDelta(), getModelProviderIds(), false /* no need to syncExec */);
	}
}




import java.lang.reflect.InvocationTargetException;
import java.util.List;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
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.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.ProjectLocationSelectionDialog;
import org.eclipse.ui.ide.undo.CopyResourcesOperation;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.ide.IIDEHelpContextIds;
import org.eclipse.ui.internal.progress.ProgressMonitorJobsDialog;
import org.eclipse.ui.plugin.AbstractUIPlugin;


    private static String COPY_TITLE = IDEWorkbenchMessages.CopyProjectAction_title;

    private static String COPY_PROGRESS_TITLE = IDEWorkbenchMessages.CopyProjectAction_progressTitle;

    private static String PROBLEMS_TITLE = IDEWorkbenchMessages.CopyProjectAction_copyFailedTitle;

    /**

    /**
     * Return the title of the errors dialog.
     * @return java.lang.String
     * 
     * @deprecated As of 3.3, the undoable operation created by this action
     * handles error dialogs.
     */
    protected String getErrorsTitle() {
        return PROBLEMS_TITLE;

     */
    boolean performCopy(final IProject project, final String projectName,
            final IPath newLocation) {
        IRunnableWithProgress op = new IRunnableWithProgress() {
            public void run(IProgressMonitor monitor) {
            	CopyResourcesOperation op = new CopyResourcesOperation(project, newLocation.append(projectName), getText());
    			op.setModelProviderIds(getModelProviderIds());
    			try {
    				PlatformUI.getWorkbench().getOperationSupport()
    						.getOperationHistory().execute(op, monitor, new IAdaptable() {
    		   					public Object getAdapter(Class clazz) {
    		   						if (clazz == Shell.class) {
    		   							return shell;
    		   						}
    		   						return null;
    		   					}
    		   				});
    			} catch (ExecutionException e) {
    				IDEWorkbenchPlugin.log(e.getMessage(), e);
    			}
                    monitor.worked(50);

                } catch (CoreException e) {
                    recordError(e); // log error
                } finally {
                    monitor.done();
                }
            }
        };



        String newName = (String) destinationPaths[0];
        IPath newLocation = new Path((String) destinationPaths[1]);
        if (!CopyProjectOperation.validateCopy(shell, project, newName, getModelProviderIds())) {
			return;
		}

        performCopy(project, newName, newLocation);

        if (!completed) {
			return; // not appropriate to show errors
		}

        // If errors occurred, open an Error dialog
        if (errorStatus != null) {
            ErrorDialog.openError(this.shell, getErrorsTitle(), null,
                    errorStatus);
            errorStatus = null;
        }
    }

	/**




import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.internal.progress.ProgressMonitorJobsDialog;

/**
 * The abstract superclass for actions which invoke commands implemented in
 * org.eclipse.core.* on a set of selected resources.
 * 
 * It iterates over all selected resources; errors are collected and displayed
 * to the user via a problems dialog at the end of the operation. User requests
 * to cancel the operation are passed along to the core.
 * <p>
 * Subclasses must implement the following methods:
 * <ul>
 * <li><code>invokeOperation</code> - to perform the operation on one of the
 * selected resources</li>
 * <li><code>getOperationMessage</code> - to furnish a title for the progress
 * dialog</li>
 * </ul>
 * </p>
 * <p>
 * Subclasses may override the following methods:
 * <ul>
 * <li><code>shouldPerformResourcePruning</code> - reimplement to turn off</li>
 * <li><code>updateSelection</code> - extend to refine enablement criteria</li>
 * <li><code>getProblemsTitle</code> - reimplement to furnish a title for the
 * problems dialog</li>
 * <li><code>getProblemsMessage</code> - reimplement to furnish a message for
 * the problems dialog</li>
 * <li><code>run</code> - extend to </li>
 * </ul>
 * </p>
 */
public abstract class WorkspaceAction extends SelectionListenerAction {
	/**
	 * The shell in which to show the progress and problems dialog.
	 */
	private final Shell shell;

	/**
	 * Creates a new action with the given text.
	 * 
	 * @param shell
	 *            the shell (for the modal progress dialog and error messages)
	 * @param text
	 *            the string used as the text for the action, or
	 *            <code>null</code> if there is no text
	 */
	protected WorkspaceAction(Shell shell, String text) {
		super(text);
		if (shell == null) {
			throw new IllegalArgumentException();
		}
		this.shell = shell;
	}

	/**
	 * Opens an error dialog to display the given message.
	 * <p>
	 * Note that this method must be called from UI thread.
	 * </p>
	 * 
	 * @param message
	 *            the message
	 */
	void displayError(String message) {
		if (message == null) {
			message = IDEWorkbenchMessages.WorkbenchAction_internalError;
		}
		MessageDialog.openError(shell, getProblemsTitle(), message);
	}

	/**
	 * Runs <code>invokeOperation</code> on each of the selected resources,
	 * reporting progress and fielding cancel requests from the given progress
	 * monitor.
	 * <p>
	 * Note that if an action is running in the background, the same action
	 * instance can be executed multiple times concurrently. This method must
	 * not access or modify any mutable state on action class.
	 * 
	 * @param monitor
	 *            a progress monitor
	 * @return The result of the execution
	 */
	final IStatus execute(List resources, IProgressMonitor monitor) {
		MultiStatus errors = null;
		// 1FTIMQN: ITPCORE:WIN - clients required to do too much iteration work
		if (shouldPerformResourcePruning()) {
			resources = pruneResources(resources);
		}
		// 1FV0B3Y: ITPUI:ALL - sub progress monitors granularity issues
		monitor.beginTask("", resources.size() * 1000); //$NON-NLS-1$
		// Fix for bug 31768 - Don't provide a task name in beginTask
		// as it will be appended to each subTask message. Need to
		// call setTaskName as its the only was to assure the task name is
		// set in the monitor (see bug 31824)
		monitor.setTaskName(getOperationMessage());
		Iterator resourcesEnum = resources.iterator();
		try {
			while (resourcesEnum.hasNext()) {
				IResource resource = (IResource) resourcesEnum.next();
				try {
					// 1FV0B3Y: ITPUI:ALL - sub progress monitors granularity
					// issues
					invokeOperation(resource, new SubProgressMonitor(monitor,
							1000));
				} catch (CoreException e) {
					errors = recordError(errors, e);
				}
				if (monitor.isCanceled()) {
					throw new OperationCanceledException();
				}
            }
            return errors == null ? Status.OK_STATUS : errors;
        } finally {
            monitor.done();
        }
    }

    /**
     * Returns the string to display for this action's operation.
     * <p>
     * Note that this hook method is invoked in a non-UI thread.
     * </p>
     * <p>
     * Subclasses must implement this method.
     * </p>
     *
     * @return the message
     * 
     * @since 3.1
     */
    protected abstract String getOperationMessage();

    /**
     * Returns the string to display for this action's problems dialog.
     * <p>
     * The <code>WorkspaceAction</code> implementation of this method returns a
     * vague message (localized counterpart of something like "The following 
     * problems occurred."). Subclasses may reimplement to provide something more
     * suited to the particular action.
     * </p>
     *
     * @return the problems message
     * 
     * @since 3.1
     */
    protected String getProblemsMessage() {
        return IDEWorkbenchMessages.WorkbenchAction_problemsMessage;
    }

    /**
     * Returns the title for this action's problems dialog.
     * <p>
     * The <code>WorkspaceAction</code> implementation of this method returns a
     * generic title (localized counterpart of "Problems"). Subclasses may 
     * reimplement to provide something more suited to the particular action.
     * </p>
     *
     * @return the problems dialog title
     * 
     * @since 3.1
     */
    protected String getProblemsTitle() {
        return IDEWorkbenchMessages.WorkspaceAction_problemsTitle;
    }

    /**
     * Returns the shell for this action. This shell is used for the modal progress
     * and error dialogs.
     *
     * @return the shell
     */
    Shell getShell() {
        return shell;
    }

    /**
     * Performs this action's operation on each of the selected resources, reporting
     * progress to, and fielding cancel requests from, the given progress monitor.
     * <p>
     * Note that this method is invoked in a non-UI thread.
     * </p>
     * <p>
     * Subclasses must implement this method.
     * </p>
     *
     * @param resource one of the selected resources
     * @param monitor a progress monitor
     * @exception CoreException if the operation fails
     * 
     * @since 3.1
     */
    protected abstract void invokeOperation(IResource resource, IProgressMonitor monitor)
            throws CoreException;

    /**
     * Returns whether the given resource is a descendent of any of the resources
     * in the given list.
     *
     * @param resources the list of resources (element type: <code>IResource</code>)
     * @param child the resource to check
     * @return <code>true</code> if <code>child</code> is a descendent of any of the
     *   elements of <code>resources</code>
     */
    boolean isDescendent(List resources, IResource child) {
        IResource parent = child.getParent();
        return parent != null
                && (resources.contains(parent) || isDescendent(resources,
                        parent));
    }

    /**
     * Performs pruning on the given list of resources, as described in 
     * <code>shouldPerformResourcePruning</code>.
     *
     * @param resourceCollection the list of resources (element type: 
     *    <code>IResource</code>)
     * @return the list of resources (element type: <code>IResource</code>)
     *		after pruning. 
     * @see #shouldPerformResourcePruning
     */
    List pruneResources(List resourceCollection) {
        List prunedList = new ArrayList(resourceCollection);
        Iterator elementsEnum = prunedList.iterator();
        while (elementsEnum.hasNext()) {
            IResource currentResource = (IResource) elementsEnum.next();
            if (isDescendent(prunedList, currentResource)) {
				elementsEnum.remove(); //Removes currentResource
			}
			return errors == null ? Status.OK_STATUS : errors;
		} finally {
			monitor.done();
		}
	}

	/**
	 * Returns the string to display for this action's operation.
	 * <p>
	 * Note that this hook method is invoked in a non-UI thread.
	 * </p>
	 * <p>
	 * Subclasses must implement this method.
	 * </p>
	 * 
	 * @return the message
	 * 
	 * @since 3.1
	 */
	protected abstract String getOperationMessage();

	/**
	 * Returns the string to display for this action's problems dialog.
	 * <p>
	 * The <code>WorkspaceAction</code> implementation of this method returns
	 * a vague message (localized counterpart of something like "The following
	 * problems occurred."). Subclasses may reimplement to provide something
	 * more suited to the particular action.
	 * </p>
	 * 
	 * @return the problems message
	 * 
	 * @since 3.1
	 */
	protected String getProblemsMessage() {
		return IDEWorkbenchMessages.WorkbenchAction_problemsMessage;
	}

	/**
	 * Returns the title for this action's problems dialog.
	 * <p>
	 * The <code>WorkspaceAction</code> implementation of this method returns
	 * a generic title (localized counterpart of "Problems"). Subclasses may
	 * reimplement to provide something more suited to the particular action.
	 * </p>
	 * 
	 * @return the problems dialog title
	 * 
	 * @since 3.1
	 */
	protected String getProblemsTitle() {
		return IDEWorkbenchMessages.WorkspaceAction_problemsTitle;
	}

	/**
	 * Returns the shell for this action. This shell is used for the modal
	 * progress and error dialogs.
	 * 
	 * @return the shell
	 */
	Shell getShell() {
		return shell;
	}

	/**
	 * Performs this action's operation on each of the selected resources,
	 * reporting progress to, and fielding cancel requests from, the given
	 * progress monitor.
	 * <p>
	 * Note that this method is invoked in a non-UI thread.
	 * </p>
	 * <p>
	 * Subclasses must implement this method.
	 * <p>
	 * @deprecated Since 3.3, subclasses should instead implement the method
	 * {@link #createOperation(IStatus[])} and provide an empty implementation
	 * for this method.
	 * </p>
	 * 
	 * @param resource
	 *            one of the selected resources
	 * @param monitor
	 *            a progress monitor
	 * @exception CoreException
	 *                if the operation fails
	 * 
	 * @since 3.1
	 */
	protected abstract void invokeOperation(IResource resource,
			IProgressMonitor monitor) throws CoreException;

	/**
	 * Returns whether the given resource is a descendent of any of the
	 * resources in the given list.
	 * 
	 * @param resources
	 *            the list of resources (element type: <code>IResource</code>)
	 * @param child
	 *            the resource to check
	 * @return <code>true</code> if <code>child</code> is a descendent of
	 *         any of the elements of <code>resources</code>
	 */
	boolean isDescendent(List resources, IResource child) {
		IResource parent = child.getParent();
		return parent != null
				&& (resources.contains(parent) || isDescendent(resources,
						parent));
	}

	/**
	 * Performs pruning on the given list of resources, as described in
	 * <code>shouldPerformResourcePruning</code>.
	 * 
	 * @param resourceCollection
	 *            the list of resources (element type: <code>IResource</code>)
	 * @return the list of resources (element type: <code>IResource</code>)
	 *         after pruning.
	 * @see #shouldPerformResourcePruning
	 */
	List pruneResources(List resourceCollection) {
		List prunedList = new ArrayList(resourceCollection);
		Iterator elementsEnum = prunedList.iterator();
		while (elementsEnum.hasNext()) {
			IResource currentResource = (IResource) elementsEnum.next();
			if (isDescendent(prunedList, currentResource)) {
				elementsEnum.remove(); // Removes currentResource
			}
		}
		return prunedList;
	}

	/**
	 * Records the core exception to be displayed to the user once the action is
	 * finished.
	 * 
	 * @param error
	 *            a <code>CoreException</code>
	 */
	MultiStatus recordError(MultiStatus errors, CoreException error) {
		if (errors == null) {
			errors = new MultiStatus(IDEWorkbenchPlugin.IDE_WORKBENCH,
					IStatus.ERROR, getProblemsMessage(), null);
		}
		errors.merge(error.getStatus());
		return errors;
	}

	/**
	 * The <code>CoreWrapperAction</code> implementation of this
	 * <code>IAction</code> method uses a <code>ProgressMonitorDialog</code>
	 * to run the operation. The operation calls <code>execute</code> (which,
	 * in turn, calls <code>invokeOperation</code>). Afterwards, any
	 * <code>CoreException</code>s encountered while running the operation
	 * are reported to the user via a problems dialog.
	 * <p>
	 * Subclasses may extend this method.
	 * </p>
	 */
	public void run() {
		IStatus[] errorStatus = new IStatus[1];
		try {
			new ProgressMonitorJobsDialog(shell).run(true, true,
					createOperation(errorStatus));
		} catch (InterruptedException e) {
			return;
		} catch (InvocationTargetException e) {
			// we catch CoreException in execute(), but unexpected runtime
			// exceptions or errors may still occur
			String msg = NLS.bind(
					IDEWorkbenchMessages.WorkspaceAction_logTitle, getClass()
							.getName(), e.getTargetException());
			IDEWorkbenchPlugin.log(msg, StatusUtil.newStatus(IStatus.ERROR,
					msg, e.getTargetException()));
			displayError(e.getTargetException().getMessage());
		}
		// If errors occurred, open an Error dialog & build a multi status error
		// for it
		if (errorStatus[0] != null && !errorStatus[0].isOK()) {
			ErrorDialog.openError(shell, getProblemsTitle(), null, // no
					// special
					// message
					errorStatus[0]);
		}
	}

	/**
	 * Returns whether this action should attempt to optimize the resources
	 * being operated on. This kind of pruning makes sense when the operation
	 * has depth infinity semantics (when the operation is applied explicitly to
	 * a resource then it is also applied implicitly to all the resource's
	 * descendents).
	 * <p>
	 * The <code>WorkspaceAction</code> implementation of this method returns
	 * <code>true</code>. Subclasses should reimplement to return
	 * <code>false</code> if pruning is not required.
	 * </p>
	 * 
	 * @return <code>true</code> if pruning should be performed, and
	 *         <code>false</code> if pruning is not desired
	 * 
	 * @since 3.1
	 */
	protected boolean shouldPerformResourcePruning() {
		return true;
	}

	/**
	 * The <code>WorkspaceAction</code> implementation of this
	 * <code>SelectionListenerAction</code> method ensures that this action is
	 * disabled if any of the selected resources are inaccessible. Subclasses
	 * may extend to react to selection changes; however, if the super method
	 * returns <code>false</code>, the overriding method should also return
	 * <code>false</code>.
	 */
	protected boolean updateSelection(IStructuredSelection selection) {
		if (!super.updateSelection(selection) || selection.isEmpty()) {
			return false;
		}
		for (Iterator i = getSelectedResources().iterator(); i.hasNext();) {
			IResource r = (IResource) i.next();
			if (!r.isAccessible()) {
				return false;
			}
		}
		return true;
	}

	/**
	 * Returns the elements that the action is to be performed on. By default
	 * return the selected resources.
	 * <p>
	 * Subclasses may override this method.
	 * 
	 * @return list of resource elements (element type: <code>IResource</code>)
	 */
	protected List getActionResources() {
		return getSelectedResources();
	}

	/**
	 * Run the action in the background rather than with the progress dialog.
	 * 
	 * @param rule
	 *            The rule to apply to the background job or <code>null</code>
	 *            if there isn't one.
	 */
	public void runInBackground(ISchedulingRule rule) {
		runInBackground(rule, (Object[]) null);
	}

	/**
	 * Run the action in the background rather than with the progress dialog.
	 * 
	 * @param rule
	 *            The rule to apply to the background job or <code>null</code>
	 *            if there isn't one.
	 * @param jobFamily
	 *            a single family that the job should belong to or
	 *            <code>null</code> if none.
	 * 
	 * @since 3.1
	 */
	public void runInBackground(ISchedulingRule rule, Object jobFamily) {
		if (jobFamily == null) {
			runInBackground(rule, (Object[]) null);
     * By default return the selected resources.
     * <p>
     * Subclasses may override this method.
     *
     * @return list of resource elements (element type: <code>IResource</code>)
     */
    protected List getActionResources() {
        return getSelectedResources();
    }

    /**
     * Run the action in the background rather than with the
     * progress dialog.
     * @param rule The rule to apply to the background job or
     * <code>null</code> if there isn't one.
     */
    public void runInBackground(ISchedulingRule rule) {
    	runInBackground(rule, (Object []) null);
    }
 
    /**
     * Run the action in the background rather than with the
     * progress dialog.
     * @param rule The rule to apply to the background job or
     * <code>null</code> if there isn't one.
     * @param jobFamily a single family that the job should 
     * belong to or <code>null</code> if none.
     * 
     * @since 3.1
     */
    public void runInBackground(ISchedulingRule rule, Object jobFamily) {
    	if (jobFamily == null) {
			runInBackground(rule, (Object []) null);
		} else {
			runInBackground(rule, new Object[] { jobFamily });
		}
	}

	/**
	 * Run the action in the background rather than with the progress dialog.
	 * 
	 * @param rule
	 *            The rule to apply to the background job or <code>null</code>
	 *            if there isn't one.
	 * @param jobFamilies
	 *            the families the job should belong to or <code>null</code>
	 *            if none.
	 * 
	 * @since 3.1
	 */
	public void runInBackground(ISchedulingRule rule, final Object[] jobFamilies) {
		// obtain a copy of the selected resources before the job is forked
		final List resources = new ArrayList(getActionResources());
		Job job = new WorkspaceJob(removeMnemonics(getText())) {

			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.core.runtime.jobs.Job#belongsTo(java.lang.Object)
			 */
			public boolean belongsTo(Object family) {

				}
				return false;
			}

			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.core.resources.WorkspaceJob#runInWorkspace(org.eclipse.core.runtime.IProgressMonitor)
			 */
			public IStatus runInWorkspace(IProgressMonitor monitor) {
				return WorkspaceAction.this.execute(resources, monitor);
			}
		};
		if (rule != null) {
			job.setRule(rule);
		}
		job.setUser(true);
		job.schedule();
	}

	/**
	 * Returns the operation to perform when this action runs. The returned
	 * operation must be an {@link IRunnableWithProgress} that will perform the
	 * action's work. The default implementation returns an operation that will
	 * iterate over the selected resources and call
	 * {@link #invokeOperation(IResource, IProgressMonitor)} for each resource.
	 * Subclasses must either implement
	 * {@link #invokeOperation(IResource, IProgressMonitor)} or override this
	 * method to provide a different operation. Subclasses typically override
	 * this method when an undoable operation is to be provided.
	 * 
	 * @param errorStatus
	 *            an array of error status objects to which the result of
	 *            running the operation should be added.
	 * 
	 * @return the operation to perform when this action runs.
	 * @since 3.3
	 */
	protected IRunnableWithProgress createOperation(final IStatus[] errorStatus) {
		return new WorkspaceModifyOperation() {
			public void execute(IProgressMonitor monitor) {
				errorStatus[0] = WorkspaceAction.this.execute(
						getActionResources(), monitor);
			}
		};
	}

}




 *******************************************************************************/
package org.eclipse.ui.actions;

import com.ibm.icu.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourceAttributes;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
import org.eclipse.core.resources.mapping.ResourceChangeValidator;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jface.dialogs.IInputValidator;
import org.eclipse.jface.dialogs.InputDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.window.Window;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.TreeEditor;
import org.eclipse.swt.events.FocusAdapter;

import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.ide.undo.MoveResourcesOperation;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.ide.IIDEHelpContextIds;

import com.ibm.icu.text.MessageFormat;

/**
 * Standard action for renaming the selected resources.
 * <p>


    private static final String CHECK_RENAME_MESSAGE = IDEWorkbenchMessages.RenameResourceAction_readOnlyCheck;

    private static String RESOURCE_EXISTS_TITLE = IDEWorkbenchMessages.RenameResourceAction_resourceExists;

    private static String RESOURCE_EXISTS_MESSAGE = IDEWorkbenchMessages.RenameResourceAction_overwriteQuestion;

    private static String RENAMING_MESSAGE = IDEWorkbenchMessages.RenameResourceAction_progressMessage;

    /**
     * Creates a new action. Using this constructor directly will rename using a
     * dialog rather than the inline editor of a ResourceNavigator.

        this.treeEditor = new TreeEditor(tree);
    }

   /**
     * Check if the user wishes to overwrite the supplied resource
     * @returns true if there is no collision or delete was successful
     * @param shell the shell to create the dialog in 
     * @param destination - the resource to be overwritten
     */
    private boolean checkOverwrite(final Shell shell,
            final IResource destination) {

        final boolean[] result = new boolean[1];

        //Run it inside of a runnable to make sure we get to parent off of the shell as we are not
        //in the UI thread.

        Runnable query = new Runnable() {
            public void run() {
                String pathName = destination.getFullPath().makeRelative()
                        .toString();
                result[0] = MessageDialog.openQuestion(shell,
                        RESOURCE_EXISTS_TITLE, MessageFormat.format(
                                RESOURCE_EXISTS_MESSAGE,
                                new Object[] { pathName }));
            }

        };

        shell.getDisplay().syncExec(query);
        return result[0];
    }

    /**
     * Check if the supplied resource is read only or null. If it is then ask the user if they want
     * to continue. Return true if the resource is not read only or if the user has given
     * permission.

        
        return true;
    }

    Composite createParent() {
        Tree tree = getTree();
        Composite result = new Composite(tree, SWT.NONE);


    /* (non-Javadoc)
     * Method declared on WorkspaceAction.
     * Since 3.3, this method is not used, but an implementation is still
     * provided for compatibility.  All work is now done in the operation
     * created in createOperation(IStatus[]).
     */
    protected void invokeOperation(IResource resource, IProgressMonitor monitor) {
            throws CoreException {

    	if (!validateMove(resource, newPath)) {
    		return;
    	}
        monitor.beginTask(RENAMING_MESSAGE, 100);
        IWorkspaceRoot workspaceRoot = resource.getWorkspace().getRoot();

        IResource newResource = workspaceRoot.findMember(newPath);
        if (newResource != null) {
            if (checkOverwrite(getShell(), newResource)) {
                if (resource.getType() == IResource.FILE
                        && newResource.getType() == IResource.FILE) {
                    IFile file = (IFile) resource;
                    IFile newFile = (IFile) newResource;
                    if (validateEdit(file, newFile, getShell())) {
                        IProgressMonitor subMonitor = new SubProgressMonitor(
                                monitor, 50);
                        newFile.setContents(file.getContents(),
                                IResource.KEEP_HISTORY, subMonitor);
                        file.delete(IResource.KEEP_HISTORY, subMonitor);
                    }
                    monitor.worked(100);
                    return;
                } 
                newResource.delete(IResource.KEEP_HISTORY,
                        new SubProgressMonitor(monitor, 50));
            } else {
                monitor.worked(100);
                return;
            }
        }
        if (resource.getType() == IResource.PROJECT) {
            IProject project = (IProject) resource;
            IProjectDescription description = project.getDescription();
            description.setName(newPath.segment(0));
            project.move(description, IResource.FORCE | IResource.SHALLOW,
                    monitor);
        } else {
			resource.move(newPath, IResource.KEEP_HISTORY | IResource.SHALLOW,
                    new SubProgressMonitor(monitor, 50));
		}
    }

	/**
	 * Validates the operation against the model providers.
	 *
	 * @param resource the resource to move
	 * @param path the new path
	 * @return whether the operation should proceed
	 * @since 3.2
	 */
    private boolean validateMove(IResource resource, IPath path) {
    	IResourceChangeDescriptionFactory factory = ResourceChangeValidator.getValidator().createDeltaFactory();
    	factory.move(resource, path);
		return IDE.promptToConfirm(getShell(), IDEWorkbenchMessages.RenameResourceAction_confirm, NLS.bind(IDEWorkbenchMessages.RenameResourceAction_warning, resource.getName()), factory.getDelta(), modelProviderIds, true /* syncExec */);
	}

	/**
     * Return the new name to be given to the target resource.
     *
     * @return java.lang.String

            if (currentResource == null || !currentResource.exists()) {
				return;
			}
			//Do a quick read only and null check
            if (!checkReadOnlyAndNull(currentResource)) {
				return;
			}

        if (!checkReadOnlyAndNull(currentResource)) {
			return;
		}

        queryNewResourceNameInline(currentResource);

    }
    
    /**

        textActionHandler = actionHandler;
    }


     * Validates 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.
     * 
     * @param source source file
     * @param destination destination file
     * @param shell ui context for the validation
     * @return boolean <code>true</code> both files could be made writeable.
     * 	<code>false</code> either one or both files were not made writeable  
     */
    boolean validateEdit(IFile source, IFile destination, Shell shell) {
        if (destination.isReadOnly()) {
            IWorkspace workspace = ResourcesPlugin.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;
    }
    
    /**
     * Returns the model provider ids that are known to the client
     * that instantiated this operation.

	public void setModelProviderIds(String[] modelProviderIds) {
		this.modelProviderIds = modelProviderIds;
	}
	
	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.actions.WorkspaceAction#createOperation(org.eclipse.core.runtime.IStatus[])
	 * 
	 * Overridden to create and execute an undoable operation that 
	 * performs the rename.
	 * @since 3.3
	 */
    protected IRunnableWithProgress createOperation(final IStatus [] errorStatus) {
    	return new IRunnableWithProgress() {
    		public void run(IProgressMonitor monitor) {
    			IResource [] resources = (IResource [])getSelectedResources().toArray(new IResource [getSelectedResources().size()]);
    			// Rename is only valid for a single resource.  This has already been validated.
    			if (resources.length == 1) {
	    			MoveResourcesOperation op = new MoveResourcesOperation(resources[0], newPath, getText());
	    			op.setModelProviderIds(getModelProviderIds());
	    			try {
	    				errorStatus[0] = PlatformUI.getWorkbench().getOperationSupport()
	    						.getOperationHistory().execute(op, monitor, new IAdaptable() {
	    		   					public Object getAdapter(Class clazz) {
	    		   						if (clazz == Shell.class) {
	    		   							return getShell();
	    		   						}
	    		   						return null;
	    		   					}
	    		   				});
	    			} catch (ExecutionException e) {
	    				IDEWorkbenchPlugin.log(e.getMessage(), e);
	    			}
    			}
    		}
    	};
    }
}




import java.util.Arrays;
import java.util.List;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileInfo;
import org.eclipse.core.filesystem.IFileStore;

import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.resources.WorkspaceJob;
import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
import org.eclipse.core.resources.mapping.ResourceChangeValidator;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;

import org.eclipse.jface.dialogs.IInputValidator;
import org.eclipse.jface.dialogs.InputDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.window.Window;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.ContainerGenerator;
import org.eclipse.ui.dialogs.IOverwriteQuery;
import org.eclipse.ui.ide.undo.AbstractCopyOrMoveResourcesOperation;
import org.eclipse.ui.ide.undo.CopyResourcesOperation;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.ide.StatusUtil;

	 *            destination to which resources will be copied
	 * @param subMonitor
	 *            a progress monitor for showing progress and for cancelation
	 *          
	 * @deprecated As of 3.3, the work is performed in the undoable operation
	 * created in {@link #performCopy(IResource[], IPath, IProgressMonitor)}
	 */
	protected void copy(IResource[] resources, IPath destination,
			IProgressMonitor subMonitor) throws CoreException {

			return copiedResources[0];
		}

		IRunnableWithProgress op = new IRunnableWithProgress() {
			public void run(IProgressMonitor monitor) {
				copyResources(resources, destinationPath, copiedResources,
						monitor);
		if (fork) {
			WorkspaceModifyOperation op = new WorkspaceModifyOperation() {
				public void execute(IProgressMonitor monitor) {
					copyResources(resources, destinationPath, copiedResources,
							monitor);
				}
			};

			try {
				PlatformUI.getWorkbench().getProgressService().run(true, true,
						op);
			} catch (InterruptedException e) {
				return copiedResources[0];
			} catch (InvocationTargetException e) {
				display(e);
			}
		};

		try {
			PlatformUI.getWorkbench().getProgressService().run(fork, true,
					op);
		} catch (InterruptedException e) {
			return copiedResources[0];
		} catch (InvocationTargetException e) {
			display(e);
		}

		// If errors occurred, open an Error dialog

			displayError(errorStatus);
			errorStatus = null;
		}
		
		return copiedResources[0];
	}

	/**
	 * Validates the copy or move operation.
	 * 
	 * @param resources
	 *            the resources being copied or moved
	 * @param destinationPath
	 *            the destination of the copy or move
	 * @return whether the operation should proceed
	 * @since 3.2
	 */
	private boolean validateOperation(IResource[] resources,
			IPath destinationPath) {
		IResourceChangeDescriptionFactory factory = ResourceChangeValidator
				.getValidator().createDeltaFactory();
		for (int i = 0; i < resources.length; i++) {
			IResource resource = resources[i];
			if (isMove()) {
				factory.move(resource, destinationPath.append(resource
						.getName()));
			} else {
				factory.copy(resource, destinationPath.append(resource
						.getName()));
			}
		}
		String title;
		String message;
		if (isMove()) {
			title = IDEWorkbenchMessages.CopyFilesAndFoldersOperation_confirmMove;
			message = IDEWorkbenchMessages.CopyFilesAndFoldersOperation_warningMove;
		} else {
			title = IDEWorkbenchMessages.CopyFilesAndFoldersOperation_confirmCopy;
			message = IDEWorkbenchMessages.CopyFilesAndFoldersOperation_warningCopy;
		}
		return IDE.promptToConfirm(messageShell, title, message, factory
				.getDelta(), modelProviderIds, true /* syncExec */);
	}

	/**
	 * Return whether the operation is a move or a copy
	 * 
	 * @return whether the operation is a move or a copy

	private boolean performCopy(IResource[] resources, IPath destination,
			IProgressMonitor monitor) {
		try {
			AbstractCopyOrMoveResourcesOperation op = getUndoableCopyOrMoveOperation(
					resources, destination);
			op.setModelProviderIds(getModelProviderIds());
			PlatformUI.getWorkbench().getOperationSupport()
					.getOperationHistory().execute(op, monitor, new IAdaptable() {
	   					public Object getAdapter(Class clazz) {
	   						if (clazz == Shell.class) {
	   							return messageShell;
	   						}
	   						return null;
	   					}
	   				});
		} catch (ExecutionException e) {
			IDEWorkbenchPlugin.log(e.getMessage(), e);
			return false;
		} 
			monitor.done();
		}
		return true;
	}


	private boolean performCopyWithAutoRename(IResource[] resources,
			IPath destination, IProgressMonitor monitor) {
		IWorkspace workspace = resources[0].getWorkspace();
		IPath [] destinationPaths = new IPath[resources.length];
		try {
			ContainerGenerator generator = new ContainerGenerator(destination);
			generator.generateContainer(new SubProgressMonitor(monitor, 10));

			IProgressMonitor subMonitor = new SubProgressMonitor(monitor, 75);
			subMonitor.beginTask(getOperationTitle(), resources.length);

			for (int i = 0; i < resources.length; i++) {
				IResource source = resources[i];
				destinationPaths[i] = destination.append(source.getName());

				if (workspace.getRoot().exists(destinationPaths[i])) {
					destinationPaths[i] = getNewNameFor(destinationPaths[i], workspace);
				}
				if (destinationPath != null) {
					try {
						source.copy(destinationPath, IResource.SHALLOW,
								new SubProgressMonitor(subMonitor, 0));
					} catch (CoreException e) {
						recordError(e); // log error
						return false;
					}
				}
				subMonitor.worked(1);
				if (subMonitor.isCanceled()) {
					throw new OperationCanceledException();
				}
			}
			CopyResourcesOperation op = new CopyResourcesOperation(resources, destinationPaths, 
					IDEWorkbenchMessages.CopyFilesAndFoldersOperation_copyTitle);
			op.setModelProviderIds(getModelProviderIds());
			PlatformUI.getWorkbench().getOperationSupport()
					.getOperationHistory().execute(op, monitor, new IAdaptable() {
	   					public Object getAdapter(Class clazz) {
	   						if (clazz == Shell.class) {
	   							return messageShell;
	   						}
	   						return null;
	   					}
	   				});
		} catch (ExecutionException e) {
			IDEWorkbenchPlugin.log(e.getMessage(), e);
			return false;
		} finally {
			monitor.done();
		}

		return true;
	}


	public void setModelProviderIds(String[] modelProviderIds) {
		this.modelProviderIds = modelProviderIds;
	}
	
	/**
	 * Returns an IUndoableOperation suitable for performing the move or copy
	 * operation that will move or copy the given resources to the given 
	 * destination path.
	 * 
	 * @param resources
	 * 			the resources to be moved or copied
	 * @param destinationPath
	 * 			the destination path to which the resources should be moved
	 * @return the operation that should be used to perform the move or cop
	 */
	protected AbstractCopyOrMoveResourcesOperation getUndoableCopyOrMoveOperation(IResource[] resources, IPath destinationPath) {
		return new CopyResourcesOperation(resources, destinationPath, 
				IDEWorkbenchMessages.CopyFilesAndFoldersOperation_copyTitle);
		
	}
}

Lines 22-27 Link Here

(-)extensions/org/eclipse/ui/actions/MoveFilesAndFoldersOperation.java (+25 lines)
22	import org.eclipse.core.runtime.SubProgressMonitor;	22	import org.eclipse.core.runtime.SubProgressMonitor;
23	import org.eclipse.osgi.util.NLS;	23	import org.eclipse.osgi.util.NLS;
24	import org.eclipse.swt.widgets.Shell;	24	import org.eclipse.swt.widgets.Shell;
		25	import org.eclipse.ui.ide.undo.AbstractCopyOrMoveResourcesOperation;
		26	import org.eclipse.ui.ide.undo.MoveResourcesOperation;
25	import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;	27	import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
26		28
27	/**	29	/**
Lines 61-66 Link Here
61	* @param resources the resources to move	63	* @param resources the resources to move
62	* @param destination destination to which resources will be moved	64	* @param destination destination to which resources will be moved
63	* @param subMonitor a progress monitor for showing progress and for cancelation	65	* @param subMonitor a progress monitor for showing progress and for cancelation
		66	*
		67	* @deprecated As of 3.3, the work is performed in the undoable operation
		68	* created in {@link #performCopy(IResource[], IPath, IProgressMonitor)}
		69
64	*/	70	*/
65	protected void copy(IResource[] resources, IPath destination,	71	protected void copy(IResource[] resources, IPath destination,
66	IProgressMonitor subMonitor) throws CoreException {	72	IProgressMonitor subMonitor) throws CoreException {
Lines 169-174 Link Here
169	* @param existing existing file to set the source content in	175	* @param existing existing file to set the source content in
170	* @param subMonitor a progress monitor for showing progress and for cancelation	176	* @param subMonitor a progress monitor for showing progress and for cancelation
171	* @throws CoreException setContents failed	177	* @throws CoreException setContents failed
		178	* @deprecated As of 3.3, this method is not called.
172	*/	179	*/
173	private void moveExisting(IResource source, IResource existing,	180	private void moveExisting(IResource source, IResource existing,
174	IProgressMonitor subMonitor) throws CoreException {	181	IProgressMonitor subMonitor) throws CoreException {
Lines 223-226 Link Here
223	protected boolean isMove() {	230	protected boolean isMove() {
224	return true;	231	return true;
225	}	232	}
		233
		234	/**
		235	* Returns an IUndoableOperation suitable for performing the move or copy
		236	* operation that will move or copy the given resources to the given
		237	* destination path.
		238	*
		239	* @param resources
		240	* the resources to be moved or copied
		241	* @param destinationPath
		242	* the destination path to which the resources should be moved
		243	* @return the operation that should be used to perform the move or copy
		244	* @since 3.3
		245	*/
		246	protected AbstractCopyOrMoveResourcesOperation getUndoableCopyOrMoveOperation(IResource[] resources, IPath destinationPath) {
		247	return new MoveResourcesOperation(resources, destinationPath,
		248	IDEWorkbenchMessages.CopyFilesAndFoldersOperation_moveTitle);
		249
		250	}
226	}	251	}

Lines 34-40 Link Here

(-)src/org/eclipse/ui/internal/wizards/newresource/ResourceMessages.java (-1 lines)
34	public static String NewProject_errorOpeningWindow;	34	public static String NewProject_errorOpeningWindow;
35	public static String NewProject_errorMessage;	35	public static String NewProject_errorMessage;
36	public static String NewProject_internalError;	36	public static String NewProject_internalError;
37	public static String NewProject_caseVariantExistsError;
38	public static String NewProject_perspSwitchTitle;	37	public static String NewProject_perspSwitchTitle;
39	/**	38	/**
40	* Combines a perspective name and text for introducing a perspective switch	39	* Combines a perspective name and text for introducing a perspective switch

Lines 31-37 Link Here

(-)src/org/eclipse/ui/internal/wizards/newresource/messages.properties (-1 lines)
31	NewProject_errorOpeningWindow = Problems Opening Window	31	NewProject_errorOpeningWindow = Problems Opening Window
32	NewProject_errorMessage = Creation Problems	32	NewProject_errorMessage = Creation Problems
33	NewProject_internalError = Internal error: {0}	33	NewProject_internalError = Internal error: {0}
34	NewProject_caseVariantExistsError = The underlying file system is case insensitive. There is an existing project which conflicts with ''{0}''.
35	NewProject_perspSwitchTitle = Open Associated Perspective?	34	NewProject_perspSwitchTitle = Open Associated Perspective?
36	NewProject_perspSwitchMessage = This kind of project is associated with the {0} perspective. Do you want to open this perspective now?	35	NewProject_perspSwitchMessage = This kind of project is associated with the {0} perspective. Do you want to open this perspective now?
37	NewProject_perspSwitchMessageWithDesc = This kind of project is associated with the {0} perspective.\n\n{1}\n\nDo you want to open this perspective now?	36	NewProject_perspSwitchMessageWithDesc = This kind of project is associated with the {0} perspective.\n\n{1}\n\nDo you want to open this perspective now?




	public static String MoveProjectAction_text;
	public static String MoveProjectAction_toolTip;
	public static String MoveProjectAction_moveTitle;
	public static String MoveProjectAction_progressMessage;
	public static String MoveProjectAction_dialogTitle;
	public static String MoveProjectAction_internalError;


	public static String RenameResourceAction_inputDialogMessage;
	public static String RenameResourceAction_checkTitle;
	public static String RenameResourceAction_readOnlyCheck;
	public static String RenameResourceAction_resourceExists;
	public static String RenameResourceAction_nameExists;
	public static String RenameResourceAction_overwriteQuestion;
	public static String RenameResourceAction_progressMessage;
	public static String RenameResourceAction_problemTitle;
	public static String RenameResourceAction_progress;
	public static String RenameResourceAction_nameMustBeDifferent;

	public static String DeleteResourceAction_confirmLinkedResource1;
	public static String DeleteResourceAction_confirmLinkedResourceN;
	public static String DeleteResourceAction_readOnlyQuestion;
	public static String DeleteResourceAction_messageTitle;
	public static String DeleteResourceAction_outOfSyncError;
	public static String DeleteResourceAction_outOfSyncQuestion;
	public static String DeleteResourceAction_deletionExceptionMessage;
	public static String DeleteResourceAction_jobName;
	public static String DeleteResourceAction_checkJobName;


	public static String CopyFilesAndFoldersOperation_CopyResourcesTask;
	public static String CopyFilesAndFoldersOperation_parentNotEqual;
	public static String CopyFilesAndFoldersOperation_infoNotFound;
	public static String CopyFilesAndFoldersOperation_copyTitle;
	public static String CopyFilesAndFoldersOperation_moveTitle;

	public static String MoveFilesAndFoldersOperation_sameSourceAndDest;
	public static String MoveFilesAndFoldersOperation_moveFailedTitle;

	public static String WizardNewFolderCreationPage_progress;
	public static String WizardNewFolderCreationPage_errorTitle;
	public static String WizardNewFolderCreationPage_internalErrorTitle;
	public static String WizardNewFolderCreationPage_title;
	public static String WizardNewFolder_internalError;

	// --- New File ---

	public static String WizardNewFileCreationPage_file;
	public static String WizardNewFileCreationPage_internalErrorTitle;
	public static String WizardNewFileCreationPage_internalErrorMessage;
	public static String WizardNewFileCreationPage_title;


	// --- Linked Resource ---
	public static String WizardNewLinkPage_linkFileButton;




MoveProjectAction_text = Mo&ve...
MoveProjectAction_toolTip = Move Project
MoveProjectAction_moveTitle = Move Project
MoveProjectAction_progressMessage = Moving
MoveProjectAction_dialogTitle = Move Problems
MoveProjectAction_internalError = Internal error: {0}


RenameResourceAction_inputDialogMessage = Enter the new resource name:
RenameResourceAction_checkTitle = Check Rename
RenameResourceAction_readOnlyCheck = ''{0}'' is read only. Do you still wish to rename it?
RenameResourceAction_resourceExists = Resource Exists
RenameResourceAction_nameExists = A resource with that name already exists
RenameResourceAction_overwriteQuestion = ''{0}'' exists. Do you wish to overwrite?
RenameResourceAction_progressMessage = Renaming...
RenameResourceAction_problemTitle = Rename Problems
RenameResourceAction_progress = Renaming:
RenameResourceAction_nameMustBeDifferent = You must use a different name

DeleteResourceAction_confirmLinkedResource1 = Are you sure you want to delete linked resource ''{0}''?\nOnly the workspace link will be deleted. Link target will remain unchanged.
DeleteResourceAction_confirmLinkedResourceN = Are you sure you want to delete these {0} resources?\n\nSelection contains linked resources.\nOnly the workspace links will be deleted. Link targets will remain unchanged.
DeleteResourceAction_readOnlyQuestion = ''{0}'' is read only. Do you still wish to delete it?
DeleteResourceAction_messageTitle = Problems deleting
DeleteResourceAction_outOfSyncError = Resource is out of sync with the file system. Refresh and try again.
DeleteResourceAction_outOfSyncQuestion = Resource ''{0}'' is out of sync with the file system. Do you want to delete it anyway?
DeleteResourceAction_deletionExceptionMessage=Multiple problems occurred while deleting resources.
DeleteResourceAction_checkJobName = Checking resources
DeleteResourceAction_jobName = Deleting resources


CopyFilesAndFoldersOperation_CopyResourcesTask=Copying Resources
CopyFilesAndFoldersOperation_parentNotEqual = The resources must have the same parent.
CopyFilesAndFoldersOperation_infoNotFound = Information for {0} could not be read. Please check the .log file for details.
CopyFilesAndFoldersOperation_copyTitle= Copy Resources
CopyFilesAndFoldersOperation_moveTitle= Move Resources

MoveFilesAndFoldersOperation_sameSourceAndDest = Cannot move ''{0}''. The source and destination are the same.
MoveFilesAndFoldersOperation_moveFailedTitle = Move Problems

WizardNewFolderCreationPage_progress = Creating
WizardNewFolderCreationPage_errorTitle = Creation Problems
WizardNewFolderCreationPage_internalErrorTitle = Creation problems
WizardNewFolderCreationPage_title = New Folder
WizardNewFolder_internalError = Internal error: {0}

# --- New File ---

WizardNewFileCreationPage_file = file
WizardNewFileCreationPage_internalErrorTitle = Creation problems
WizardNewFileCreationPage_internalErrorMessage = Internal error: {0}
WizardNewFileCreationPage_title = New File

# --- Linked Resource ---
WizardNewLinkPage_linkFileButton = &Link to file on the file system




import java.util.Set;
import java.util.StringTokenizer;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExecutableExtension;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.MessageDialogWithToggle;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IPerspectiveRegistry;
import org.eclipse.ui.IPluginContribution;

import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.WorkbenchException;
import org.eclipse.ui.actions.WorkspaceModifyOperation;
import org.eclipse.ui.activities.IActivityManager;
import org.eclipse.ui.activities.IIdentifier;
import org.eclipse.ui.activities.IWorkbenchActivitySupport;

import org.eclipse.ui.dialogs.WizardNewProjectCreationPage;
import org.eclipse.ui.dialogs.WizardNewProjectReferencePage;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.ide.undo.CreateProjectOperation;
import org.eclipse.ui.internal.IPreferenceConstants;
import org.eclipse.ui.internal.WorkbenchPlugin;
import org.eclipse.ui.internal.ide.IDEInternalPreferences;

        }

        // create the new project operation
        IRunnableWithProgress op = new IRunnableWithProgress() {
    		public void run(IProgressMonitor monitor) {
    			CreateProjectOperation op = new CreateProjectOperation(
    					description, ResourceMessages.NewProject_windowTitle);
    			try {
    				PlatformUI.getWorkbench().getOperationSupport()
    						.getOperationHistory().execute(op, monitor, new IAdaptable() {
    		   					public Object getAdapter(Class clazz) {
    		   						if (clazz == Shell.class) {
    		   							return getShell();
    		   						}
    		   						return null;
    		   					}
    		   				});
    			} catch (ExecutionException e) {
    				IDEWorkbenchPlugin.log(e.getMessage(), e);
    			}
    		}
    	
        };
                

        // run the new project creation operation
        try {

        } catch (InterruptedException e) {
            return null;
        } catch (InvocationTargetException e) {
            Throwable t = e.getTargetException();        
            // Exceptions are handled in the operation, but unexpected runtime
            // exceptions and errors may still occur.
            IDEWorkbenchPlugin.getDefault().getLog().log(
                    new Status(IStatus.ERROR,
                            IDEWorkbenchPlugin.IDE_WORKBENCH, 0, t
                                    .toString(), t));
            MessageDialog.openError(
                    getShell(),
                    ResourceMessages.NewProject_errorMessage,
                    NLS.bind(ResourceMessages.NewProject_internalError, t.getMessage()));

                            null, // no special message
                            ((CoreException) t).getStatus());
                }
            } else {
                // CoreExceptions are handled above, but unexpected runtime
                // exceptions and errors may still occur.
                IDEWorkbenchPlugin.getDefault().getLog().log(
                        new Status(IStatus.ERROR,
                                IDEWorkbenchPlugin.IDE_WORKBENCH, 0, t
                                        .toString(), t));
                MessageDialog
                        .openError(
                                getShell(),
                                ResourceMessages.NewProject_errorMessage,
                                NLS.bind(ResourceMessages.NewProject_internalError, t.getMessage()));
            }
            return null;
        }


    }

    /**
     * Creates a project resource given the project handle and description.
     * 
     * @param description
     *            the project description to create a project resource for
     * @param projectHandle
     *            the project handle to create a project resource for
     * @param monitor
     *            the progress monitor to show visual progress with
     * 
     * @exception CoreException
     *                if the operation fails
     * @exception OperationCanceledException
     *                if the operation is canceled
     */
    void createProject(IProjectDescription description, IProject projectHandle,
            IProgressMonitor monitor) throws CoreException,
            OperationCanceledException {
        try {
            monitor.beginTask("", 2000);//$NON-NLS-1$

            projectHandle.create(description, new SubProgressMonitor(monitor,
                    1000));

            if (monitor.isCanceled()) {
				throw new OperationCanceledException();
			}

            projectHandle.open(IResource.BACKGROUND_REFRESH, new SubProgressMonitor(monitor, 1000));

        } finally {
            monitor.done();
        }
    }

    /**
     * Returns the newly created project.
     * 
     * @return the created project, or <code>null</code> if project not




/*******************************************************************************
 * 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.ui.internal.ide.undo;

import java.io.InputStream;
import java.io.StringBufferInputStream;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFileState;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.SubProgressMonitor;

/**
 * FileDescription is a lightweight description that describes a file to be
 * created.
 * 
 * This class is not intended to be instantiated or used by clients.
 * 
 * @since 3.3
 * 
 */
public class FileDescription extends ResourceDescription {

	String name;

	IPath location;

	private IFileState fileState;

	public FileDescription(IFile file) {
		super(file);
		this.name = file.getName();
		if (file.isLinked()) {
			location = file.getLocation();
		}

	}

	/*
	 * Create a file description from the specified file handle. The handle does
	 * not exist, so no information should be derived from it. If a location
	 * path is specified, this file should represent a link to another
	 * location. The IFileState describes any state that should be used when the
	 * file resource is created.
	 */
	public FileDescription(IFile file, IPath linkLocation, IFileState fileState) {
		super(file);
		this.name = file.getName();
		this.location = linkLocation;
		this.fileState = fileState;
	}

	public void recordLastHistory(IResource resource,
			IProgressMonitor monitor) throws CoreException {
		Assert.isLegal(resource.getType() == IResource.FILE);

		if (location != null) {
			// file is linked, no need to record any history
			return;
		}
		IFileState[] states = ((IFile) resource).getHistory(monitor);
		if (states.length > 0) {
			this.fileState = states[0];
		}
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.internal.ide.undo.ResourceDescription#createResourceHandle()
	 */
	public IResource createResourceHandle() {
		IWorkspaceRoot workspaceRoot = parent.getWorkspace().getRoot();
		IPath filePath = parent.getFullPath().append(name);
		return workspaceRoot.getFile(filePath);
	}

	public void createExistentResourceFromHandle(IResource resource,
			IProgressMonitor monitor) throws CoreException {

		Assert.isLegal(resource instanceof IFile);
		if (resource.exists()) {
			return;
		}
		IFile fileHandle = (IFile) resource;
		monitor.beginTask(UndoMessages.FileDescription_NewFileProgress, 200);
		try {
			if (monitor.isCanceled()) {
				throw new OperationCanceledException();
			}
			if (location != null) {
				fileHandle.createLink(location, IResource.ALLOW_MISSING_LOCAL,
						new SubProgressMonitor(monitor, 200));
			} else {
				InputStream contents = new StringBufferInputStream(
						UndoMessages.FileDescription_ContentsCouldNotBeRestored);
				String charset = null;
				// Retrieve the contents and charset from the file state.
				// Other file state attributes, such as timestamps, have
				// already been retrieved from the original IResource object
				// and are restored in the superclass.
				if (fileState != null && fileState.exists()) {
					contents = fileState.getContents();
					charset = fileState.getCharset();
				}
				fileHandle.create(contents, false, new SubProgressMonitor(
						monitor, 100));
				fileHandle.setCharset(charset, new SubProgressMonitor(monitor,
						100));
			}
			if (monitor.isCanceled()) {
				throw new OperationCanceledException();
			}
		} finally {
			monitor.done();
		}
	}

	public boolean isValid() {
		return super.isValid() && fileState != null && fileState.exists();
	}

	public String getName() {
		return name;
	}
}




/*******************************************************************************
 * 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.ui.ide.undo;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.ui.internal.ide.undo.UndoMessages;

/**
 * A DeleteResourcesOperation represents an undoable operation for deleting one
 * or more resources in the workspace.
 * 
 * This class is intended to be instantiated and used by clients. It is not
 * intended to be subclassed by clients.
 * 
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as part
 * of a work in progress. This API may change at any given time. Please do not
 * use this API without consulting with the Platform/UI team.
 * 
 * @since 3.3
 * 
 */
public class DeleteResourcesOperation extends AbstractResourcesOperation {

	private boolean deleteContent = false;

	/**
	 * Create a DeleteResourcesOperation
	 * 
	 * @param resources
	 *            the resources to be deleted
	 * @param label
	 *            the label of the operation
	 * @param deleteContent
	 *            whether or not we are deleting content for projects
	 */
	public DeleteResourcesOperation(IResource[] resources, String label,
			boolean deleteContent) {
		super(resources, label);
		this.deleteContent = deleteContent;
	}

	protected void doExecute(IProgressMonitor monitor, IAdaptable uiInfo)
			throws CoreException {
		delete(monitor, uiInfo, deleteContent);
	}

	protected void doUndo(IProgressMonitor monitor, IAdaptable uiInfo)
			throws CoreException {
		recreate(monitor, uiInfo);
	}

	protected boolean updateResourceChangeDescriptionFactory(
			IResourceChangeDescriptionFactory factory, int operation) {
		boolean modified = false;
		if (operation == UNDO) {
			for (int i = 0; i < resourceDescriptions.length; i++) {
				IResource resource = resourceDescriptions[i].createResourceHandle();
				factory.create(resource);
				modified = true;
			}
		} else {
			for (int i = 0; i < resources.length; i++) {
				IResource resource = resources[i];
				factory.delete(resource);
				modified = true;
			}
		}
		return modified;
	}

	public IStatus computeExecutionStatus(IProgressMonitor monitor) {
		IStatus status = super.computeExecutionStatus(monitor);
		if (status.isOK()) {
			status = computeDeleteStatus();
		}
		if (status.isOK()) {
			// If the resources to be deleted include projects whose content
			// is to be deleted, warn the user that the data will be lost.
			if (deleteContent && resourcesIncludesProjects()) {
				status = getWarningStatus(
						UndoMessages.DeleteResourcesOperation_DeletingProjectContentWarning,
						0);
			}
		}
		return status;
	}

	public IStatus computeUndoableStatus(IProgressMonitor monitor) {
		IStatus status = super.computeUndoableStatus(monitor);
		if (status.isOK()) {
			status = computeCreateStatus(); 
		}
		return status;
	}

	public IStatus computeRedoableStatus(IProgressMonitor monitor) {
		IStatus status = super.computeRedoableStatus(monitor);
		if (status.isOK()) {
			status = computeDeleteStatus();
		}
		return status;
	}
}




/*******************************************************************************
 * 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.ui.internal.ide.undo;

import java.util.Map;

import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;

/**
 * MarkerDescription is a lightweight description of a marker that can be used
 * to describe a marker to be created or updated.
 * 
 * This class is not intended to be instantiated or used by clients.
 * 
 * @since 3.3
 * 
 */
public class MarkerDescription {
	String type;

	Map attributes;

	IResource resource;

	/*
	 * Create a marker description from the specified marker.
	 */
	public MarkerDescription(IMarker marker) throws CoreException {
		this.type = marker.getType();
		this.attributes = marker.getAttributes();
		this.resource = marker.getResource();

	}

	/*
	 * Create a marker description from the specified marker type, attributes,
	 * and resource.
	 */
	public MarkerDescription(String type, Map attributes, IResource resource) {
		this.type = type;
		this.attributes = attributes;
		this.resource = resource;
	}

	/*
	 * Create a marker from the marker description.
	 */
	public IMarker createMarker() throws CoreException {
		IMarker marker = resource.createMarker(type);
		marker.setAttributes(attributes);
		return marker;
	}

	/*
	 * Update an existing marker using the attributes in the marker description.
	 */
	public void updateMarker(IMarker marker) throws CoreException {
		marker.setAttributes(attributes);
	}

	/*
	 * Return the resource associated with this marker.
	 */
	public IResource getResource() {
		return resource;
	}
	
	/*
	 * Return the marker type associated with this marker.
	 */
	public String getType() {
		return type;
	}
}




/*******************************************************************************
 * 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.ui.ide.undo;

import java.io.InputStream;
import java.io.StringBufferInputStream;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFileState;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.ui.internal.ide.undo.ContainerDescription;
import org.eclipse.ui.internal.ide.undo.FileDescription;
import org.eclipse.ui.internal.ide.undo.ResourceDescription;

/**
 * A CreateFileOperation represents an undoable operation for creating a file in
 * the workspace. If a link location is specified, the folder is considered to
 * be linked to the file at the specified location. If a link location is not
 * specified, the file will be created in the location specified by the handle,
 * and the entire containment path of the file will be created if it does not
 * exist.
 * 
 * This class is intended to be instantiated and used by clients. It is not
 * intended to be subclassed by clients.
 * 
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as part
 * of a work in progress. This API may change at any given time. Please do not
 * use this API without consulting with the Platform/UI team.
 * 
 * @since 3.3
 * 
 */
public class CreateFileOperation extends AbstractCreateResourcesOperation {

	/**
	 * Create a CreateFileOperation
	 * 
	 * @param fileHandle
	 *            the file to be created
	 * @param linkLocation
	 *            the location of the file if it is to be linked
	 * @param contents
	 *            the initial contents of the file, or null if there is to be no
	 *            contents
	 * @param label
	 *            the label of the operation
	 */
	public CreateFileOperation(IFile fileHandle, IPath linkLocation, InputStream contents, String label) {
		super(null, label);
		ResourceDescription resourceDescription;
		if (linkLocation == null) {
			if (fileHandle.getParent().exists()) {
				resourceDescription = new FileDescription(fileHandle, null, createFileState(fileHandle, contents));
			} else {
				// must first ensure descriptions for the parent folders are
				// created
				ContainerDescription containerDescription = ContainerDescription.fromContainer(fileHandle.getParent());
				containerDescription.getFirstLeafFolder().addMember(new FileDescription(fileHandle, null, createFileState(fileHandle, contents)));
				resourceDescription = containerDescription;
			}
		} else {
			// create a linked file description
			resourceDescription = new FileDescription(fileHandle, linkLocation, createFileState(fileHandle, contents));
		}
		setResourceDescriptions(new ResourceDescription[ ] { resourceDescription });

	}

	/*
	 * Create a file state that represents the desired contents and attributes
	 * of the file to be created. Used to mimic file history when a resource is
	 * first created.
	 */
	private IFileState createFileState(final IFile file,
			final InputStream contents) {
		return new IFileState() {
			public InputStream getContents() {
				if (contents != null) {
					return contents;
				}
				return new StringBufferInputStream(""); //$NON-NLS-1$
			}

			public Object getAdapter(Class clazz) {
				return null;
			}

			public String getCharset() {
				try {
					return file.getCharset();
				} catch (CoreException e) {
					return null;
				}
			}

			public IPath getFullPath() {
				return file.getFullPath();
			}

			public String getName() {
				return file.getName();
			}

			public boolean exists() {
				return true;
			}

			public boolean isReadOnly() {
				return true;
			}

			public long getModificationTime() {
				return file.getLocalTimeStamp();
			}
		};
	}
}




/*******************************************************************************
 * 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.ui.internal.ide.undo;

import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.SubProgressMonitor;

/**
 * FolderDescription is a lightweight description that describes a folder to be
 * created.
 * 
 * This class is not intended to be instantiated or used by clients.
 * 
 * @since 3.3
 * 
 */
public class FolderDescription extends ContainerDescription {

	/*
	 * Create a FolderDescription from the specified folder handle. Typically
	 * used when the folder handle represents a resource that actually exists,
	 * although it will not fail if the resource is non-existent.
	 */
	public FolderDescription(IFolder folder)  {
		super(folder);
	}
	
	/*
	 * Create a FolderDescription from the specified folder handle.
	 * If the folder to be created should be linked to a different location,
	 * specify the location.
	 */
	public FolderDescription(IFolder folder, IPath linkLocation) {
		super(folder);
		this.name = folder.getName();
		this.location = linkLocation;
	}

	public IResource createResourceHandle() {
		IWorkspaceRoot workspaceRoot = getWorkspaceRoot();
		IPath folderPath = parent.getFullPath().append(name);
		return workspaceRoot.getFolder(folderPath);
	}

	public void createExistentResourceFromHandle(IResource resource,
			IProgressMonitor monitor) throws CoreException {

		Assert.isLegal(resource instanceof IFolder);
		if (resource.exists()) {
			return;
		}
		IFolder folderHandle = (IFolder) resource;
		try {
			monitor.beginTask(UndoMessages.FolderDescription_NewFolderProgress,
					200);
			if (monitor.isCanceled()) {
				throw new OperationCanceledException();
			}
			if (location != null) {
				folderHandle.createLink(location,
						IResource.ALLOW_MISSING_LOCAL, new SubProgressMonitor(
								monitor, 100));
			} else {
				folderHandle.create(false, true, new SubProgressMonitor(
						monitor, 100));
			}
			if (monitor.isCanceled()) {
				throw new OperationCanceledException();
			}
			createChildResources(folderHandle, monitor, 100);

		} finally {
			monitor.done();
		}
	}
}




/*******************************************************************************
 * 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.ui.ide.undo;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
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;

/**
 * A MoveResourcesOperation represents an undoable operation for moving one or
 * more resources in the workspace.
 * 
 * This class is intended to be instantiated and used by clients. It is not
 * intended to be subclassed by clients.
 * 
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as part
 * of a work in progress. This API may change at any given time. Please do not
 * use this API without consulting with the Platform/UI team.
 * 
 * @since 3.3
 * 
 */
public class MoveResourcesOperation extends
		AbstractCopyOrMoveResourcesOperation {

	/**
	 * Create a MoveResourcesOperation that moves all of the specified resources
	 * to the same target location, using their existing names.
	 * 
	 * @param resources
	 *            the resources to be moved
	 * @param destinationPath
	 *            the destination path for the resources, not including the name
	 *            of the new resource.
	 * @param label
	 *            the label of the operation
	 */
	public MoveResourcesOperation(IResource[] resources, IPath destinationPath,
			String label) {
		super(resources, destinationPath, label);
	}

	/**
	 * Create a MoveResourcesOperation that moves a single resource to a new
	 * location. The new location includes the name of the resource, so this may
	 * be used for a move/rename operation or a simple move.
	 * 
	 * @param resource
	 *            the resource to be moved
	 * @param newPath
	 *            the new path for the resource, including its desired name.
	 * @param label
	 *            the label of the operation
	 */
	public MoveResourcesOperation(IResource resource, IPath newPath,
			String label) {
		super(new IResource[] { resource }, new IPath[] { newPath }, label);
	}

	protected void doExecute(IProgressMonitor monitor, IAdaptable uiInfo)
			throws CoreException {
		moveOrCopy(monitor, uiInfo, true); // true = move
	}

	protected void doUndo(IProgressMonitor monitor, IAdaptable uiInfo)
			throws CoreException {
		moveOrCopy(monitor, uiInfo, true); // true = move
	}

	protected boolean updateResourceChangeDescriptionFactory(
			IResourceChangeDescriptionFactory factory, int operation) {
		for (int i = 0; i < resources.length; i++) {
			IResource resource = resources[i];
			factory.move(resource, getDestinationPath(resource, i, true));
		}
		return true;
	}

	public IStatus computeExecutionStatus(IProgressMonitor monitor) {
		IStatus status = super.computeExecutionStatus(monitor);
		if (status.isOK()) {
			status = computeMoveOrCopyStatus();
		}
		return status;
	}

	public IStatus computeUndoableStatus(IProgressMonitor monitor) {
		IStatus status = super.computeUndoableStatus(monitor);
		if (status.isOK()) {
			status = computeMoveOrCopyStatus();
		}
		return status;
	}

	public IStatus computeRedoableStatus(IProgressMonitor monitor) {
		IStatus status = super.computeRedoableStatus(monitor);
		if (status.isOK()) {
			status = computeMoveOrCopyStatus();
		}
		return status;
	}
}




/*******************************************************************************
 * 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.ui.internal.ide.undo;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourceAttributes;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;

/**
 * ResourceDescription is a lightweight description that describes the common
 * attributes of a resource to be created.
 * 
 * This class is not intended to be instantiated or used by clients.
 * 
 * @since 3.3
 * 
 */
public abstract class ResourceDescription {
	IContainer parent;

	long modificationStamp = IResource.NULL_STAMP;

	long localTimeStamp = IResource.NULL_STAMP;

	ResourceAttributes resourceAttributes;

	MarkerDescription[] markerDescriptions;

	/**
	 * @param resource
	 * @return the resource description
	 */
	public static ResourceDescription fromResource(IResource resource) {
		if (resource.getType() == IResource.PROJECT) {
			return new ProjectDescription((IProject) resource);
		} else if (resource.getType() == IResource.FOLDER) {
			return new FolderDescription((IFolder) resource);
		} else if (resource.getType() == IResource.FILE) {
			return new FileDescription((IFile) resource);
		} else {
			throw new IllegalArgumentException();
		}
	}
	
	protected static IWorkspaceRoot getWorkspaceRoot() {
		return IDEWorkbenchPlugin.getPluginWorkspace().getRoot();

	}


	/*
	 * Create a resource description with no initial attributes
	 */
	protected ResourceDescription() {
		super();
	}

	/*
	 * Create a resource description from the specified resource.
	 */
	protected ResourceDescription(IResource resource) {
		super();
		parent = resource.getParent();
		if (resource.exists()) {
			modificationStamp = resource.getModificationStamp();
			localTimeStamp = resource.getLocalTimeStamp();
			resourceAttributes = resource.getResourceAttributes();
			try {
				IMarker[] markers = resource.findMarkers(null, true,
						IResource.DEPTH_INFINITE);
				markerDescriptions = new MarkerDescription[markers.length];
				for (int i = 0; i < markers.length; i++) {
					markerDescriptions[i] = new MarkerDescription(markers[i]);
				}
			} catch (CoreException e) {
				// Eat this exception because it only occurs when the resource
				// does not exist and we have already checked this.
				// We do not want to throw exceptions on the simple constructor,
				// as
				// no one has actually tried to do anything yet.
			}
		}
	}

	/*
	 * Create a resource handle that can be used to create a resource from this
	 * resource description. This handle can be used to create the actual
	 * resource, or to describe the creation to a resource delta factory.
	 */
	public abstract IResource createResourceHandle();

	/*
	 * Get the name of this resource.
	 */
	public abstract String getName();

	/*
	 * Create an existent resource from this resource description.
	 */
	public IResource createResource(IProgressMonitor monitor)
			throws CoreException {
		IResource resource = createResourceHandle();
		createExistentResourceFromHandle(resource, monitor);
		if (modificationStamp != IResource.NULL_STAMP) {
			resource.revertModificationStamp(modificationStamp);
		}
		if (localTimeStamp != IResource.NULL_STAMP) {
			resource.setLocalTimeStamp(localTimeStamp);
		}
		if (resourceAttributes != null) {
			resource.setResourceAttributes(resourceAttributes);
		}
		if (markerDescriptions != null) {
			for (int i = 0; i < markerDescriptions.length; i++) {
				markerDescriptions[i].resource = resource;
				markerDescriptions[i].createMarker();
			}
		}
		return resource;
	}

	/*
	 * Given a resource handle, create the actual existent resource represented
	 * by that handle.
	 */
	public abstract void createExistentResourceFromHandle(
			IResource resource, IProgressMonitor monitor) throws CoreException;

	public boolean isValid() {
		return parent == null || parent.exists();
	}

	public void recordLastHistory(IResource resource, IProgressMonitor monitor)
			throws CoreException {
		// Nothing to do by default
		monitor.beginTask("", 100); //$NON-NLS-1$
		monitor.done();
	}

}




/*******************************************************************************
 * 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.ui.ide.undo;

import java.net.URI;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
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.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.ui.internal.ide.undo.ResourceDescription;
import org.eclipse.ui.internal.ide.undo.UndoMessages;

/**
 * An AbstractCopyOrMoveResourcesOperation represents an undoable operation for
 * moving or copying one or more resources in the workspace.
 * 
 * This class is not intended to be subclassed by clients.
 * 
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as part
 * of a work in progress. This API may change at any given time. Please do not
 * use this API without consulting with the Platform/UI team.
 * 
 * @since 3.3
 * 
 */
public abstract class AbstractCopyOrMoveResourcesOperation extends
		AbstractResourcesOperation {

	// Used when there are different destination names for each resource
	protected IPath[] destinationPaths = null;

	// Used when all resources are going to the same container (no name changes)
	protected IPath destination = null;

	/**
	 * Create an AbstractCopyOrMoveResourcesOperation that moves or copies all
	 * of the specified resources to the specified paths. The destination paths
	 * must include the names of the resources at their new location.
	 * 
	 * @param resources
	 *            the resources to be moved or copied
	 * @param destinationPaths
	 *            the destination paths for the resources, including the name to
	 *            be assigned to the resource at its new location.
	 * @param label
	 *            the label of the operation
	 */
	AbstractCopyOrMoveResourcesOperation(IResource[] resources,
			IPath[] destinationPaths, String label) {
		super(resources, label);
		this.destinationPaths = destinationPaths;
	}

	/**
	 * Create an AbstractCopyOrMoveResourcesOperation that moves or copies all
	 * of the specified resources to the same target location, using their
	 * existing names.
	 * 
	 * @param resources
	 *            the resources to be moved or copied
	 * @param destinationPath
	 *            the destination path for the resources, not including the name
	 *            of the new resource.
	 * @param label
	 *            the label of the operation
	 */
	AbstractCopyOrMoveResourcesOperation(IResource[] resources,
			IPath destinationPath, String label) {
		super(resources, label);
		destination = destinationPath;
	}

	protected void moveOrCopy(IProgressMonitor monitor, IAdaptable uiInfo,
			boolean move) throws CoreException {

		String progressMessage;
		if (move) {
			progressMessage = UndoMessages.AbstractResourcesOperation_MovingResources;
		} else {
			progressMessage = UndoMessages.AbstractResourcesOperation_CopyingResourcesProgress;
		}
		monitor.beginTask(progressMessage, 2000);
		IResource[] resourcesInNewLocations = new IResource[resources.length];
		List overwrittenResources = new ArrayList();
		IPath[] newDestinationPaths = new IPath[resources.length];

		for (int i = 0; i < resources.length; i++) {
			// Record the original path so this can be undone
			if (resources[i].getType() == IResource.PROJECT) {
				URI locationURI = ((IProject) resources[i]).getDescription()
						.getLocationURI();
				if (locationURI == null) {
					newDestinationPaths[i] = Platform.getLocation().append(
							resources[i].getName());
				} else {
					newDestinationPaths[i] = new Path(locationURI.getPath())
							.append(resources[i].getName());
				}
			} else {
				newDestinationPaths[i] = resources[i].getFullPath();
			}
			// Move or copy the resources and record the overwrites that would
			// be restored if this operation were reversed
			ResourceDescription[] overwrites;
			if (move) {
				overwrites = move(resources[i], getDestinationPath(
						resources[i], i, true), new SubProgressMonitor(monitor,
						1000 / resources.length), uiInfo);
			} else {
				overwrites = copy(
						new IResource[] { resources[i] },
						getDestinationPath(resources[i], i, true),
						new SubProgressMonitor(monitor, 1000 / resources.length),
						uiInfo, true);
			}
			// Accumulate the overwrites into the full list
			for (int j = 0; j < overwrites.length; j++) {
				overwrittenResources.add(overwrites[i]);
			}
			// Record the resource in its new location
			resourcesInNewLocations[i] = getWorkspace().getRoot().findMember(
					getDestinationPath(resources[i], i, false));
		}

		// Are there any previously overwritten resources to restore now?
		if (resourceDescriptions != null) {
			for (int i = 0; i < resourceDescriptions.length; i++) {
				if (resourceDescriptions[i] != null) {
					resourceDescriptions[i]
							.createResource(new SubProgressMonitor(monitor,
									1000 / resourceDescriptions.length));
				}
			}
		}

		// Reset resource descriptions to the just overwritten resources
		setResourceDescriptions((ResourceDescription[]) overwrittenResources
				.toArray(new ResourceDescription[overwrittenResources.size()]));

		// Reset the target resources to refer to the resources in their new
		// location. Note that the destination paths were reset to the original
		// location as we did the move.
		setTargetResources(resourcesInNewLocations);

		// Reset the destination path to the new paths
		destinationPaths = newDestinationPaths;
		destination = null;

		monitor.done();
	}

	/*
	 * Compute the status for moving or copying the resources.
	 * 
	 * Note this method may be called on initial moving or copying of a
	 * resource, or when a move or copy is undone or redone. Therefore, this
	 * method should check conditions that can change over the life of the
	 * operation, such as whether the file to moved or copied exists, and
	 * whether the target location is still valid. One-time static checks should
	 * typically be done by the caller so that the user is not continually
	 * prompted or warned about conditions that were acceptable at the time of
	 * original execution and do not change over time.
	 */
	protected IStatus computeMoveOrCopyStatus() {
		// Check for error conditions first so that we do not prompt the user
		// on warnings that eventually will not matter anyway.
		if (resources == null || !hasDestinationPath()) {
			markInvalid();
			return getErrorStatus(UndoMessages.AbstractResourcesOperation_NotEnoughInfo);
		}
		for (int i = 0; i < resources.length; i++) {
			IResource resource = resources[i];
			// Does the resource still exist?
			if (!resource.exists()) {
				markInvalid();
				return getErrorStatus(UndoMessages.MoveOrCopyResourceOperation_ResourceDoesNotExist);
			}
			// Are we really trying to move it to a different name?
			IPath proposedPath = getDestinationPath(resource, i, false);
			if (resource.getFullPath().equals(proposedPath)) {
				markInvalid();
				return getErrorStatus(UndoMessages.MoveOrCopyResourceOperation_SameNameOrLocation);
			}
			// Is the proposed name valid?
			IStatus status = getWorkspace().validateName(
					proposedPath.lastSegment(), resource.getType());
			if (status.getSeverity() == IStatus.ERROR) {
				markInvalid();
			}
			if (!status.isOK()) {
				return status;
			}
		}

		for (int i = 0; i < resources.length; i++) {
			// No error conditions. Check and warn for any overwrites that may
			// occur.
			IResource newResource = null;
			if (resources[i].getType() == IResource.PROJECT) {
				// Projects may be moved to a new location or copied to a new
				// name. To cover both cases, we consider matching location
				// paths, including name, to represent an overwrite.
				IPath proposedPath = getDestinationPath(resources[i], i, true);
				IPath existingPath = resources[i].getLocation().append(
						resources[i].getName());
				if (proposedPath.equals(existingPath)) {
					newResource = resources[i];
				}
			} else {
				IPath proposedPath = getDestinationPath(resources[i], i, false);
				newResource = getWorkspace().getRoot().findMember(proposedPath);
			}
			if (newResource != null) {
				int result = queryOverwrite(newResource, null);
				if (result == IDialogConstants.YES_TO_ALL_ID) {
					return Status.OK_STATUS;
				} else if (result == IDialogConstants.CANCEL_ID) {
					return Status.CANCEL_STATUS;
				} else if (result == IDialogConstants.NO_ID) {
					markInvalid();
					return getErrorStatus(UndoMessages.AbstractResourcesOperation_overwriteError);
				}
				// Otherwise (YES_ID) we continue checking each one
				// individually.
			}
		}
		return Status.OK_STATUS;
	}

	protected IPath getDestinationPath(IResource resource, int i,
			boolean includeProjectLocation) {
		if (resource.getType() == IResource.PROJECT) {
			return getProjectPath((IProject) resource, i,
					includeProjectLocation);
		}
		if (destinationPaths != null) {
			return destinationPaths[i];
		}
		return destination.append(resource.getName());

	}

	private IPath getProjectPath(IProject project, int i,
			boolean includeProjectLocation) {
		String projectName;
		IPath projectLocation = null;
		if (destinationPaths != null) {
			if (includeProjectLocation) {
				return destinationPaths[i];
			}
			// new name specified in destination path
			projectName = destinationPaths[i].lastSegment();
		} else {
			// if not use the old name and common destination path
			projectName = project.getName();
			projectLocation = destination;
		}
		if (includeProjectLocation) {
			return projectLocation.append(projectName);
		} 
		return new Path(projectName);
	}

	protected boolean hasDestinationPath() {
		return (destinationPaths != null && resources.length == destinationPaths.length)
				|| (destination != null);
	}
}




/*******************************************************************************
 * 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.ui.ide.undo;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.ui.internal.ide.undo.ResourceDescription;

/**
 * A CreateResourcesOperation represents an undoable operation for creating
 * resources in the workspace.
 * 
 * This class is not intended to be subclassed by clients.
 * 
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as part
 * of a work in progress. This API may change at any given time. Please do not
 * use this API without consulting with the Platform/UI team.
 * 
 * @since 3.3
 * 
 */
public abstract class AbstractCreateResourcesOperation extends
		AbstractResourcesOperation {

	/**
	 * Create a create resources operation
	 * 
	 * @param resourceDescriptions
	 *            the resourceDescriptions describing resources to be created
	 * @param label
	 *            the label of the operation
	 */
	AbstractCreateResourcesOperation(ResourceDescription[] resourceDescriptions,
			String label) {
		super(resourceDescriptions, label);
	}

	protected void doExecute(IProgressMonitor monitor, IAdaptable uiInfo)
			throws CoreException {
		recreate(monitor, uiInfo);
	}

	protected void doUndo(IProgressMonitor monitor, IAdaptable uiInfo)
			throws CoreException {
		delete(monitor, uiInfo, false); // never delete content on undo of
										// create project
	}

	protected boolean updateResourceChangeDescriptionFactory(
			IResourceChangeDescriptionFactory factory, int operation) {
		boolean modified = false;
		if (operation == UNDO) {
			for (int i = 0; i < resources.length; i++) {
				IResource resource = resources[i];
				factory.delete(resource);
				modified = true;
			}
		} else {
			for (int i = 0; i < resourceDescriptions.length; i++) {
				IResource resource = resourceDescriptions[i]
						.createResourceHandle();
				factory.create(resource);
				modified = true;
			}
		}
		return modified;
	}

	public IStatus computeExecutionStatus(IProgressMonitor monitor) {
		IStatus status = super.computeExecutionStatus(monitor);
		if (status.isOK()) {
			status = computeCreateStatus();
		}
		return status;
	}

	public IStatus computeUndoableStatus(IProgressMonitor monitor) {
		IStatus status = super.computeUndoableStatus(monitor);
		if (status.isOK()) {
			status = computeDeleteStatus();
		}
		return status;
	}

	public IStatus computeRedoableStatus(IProgressMonitor monitor) {
		IStatus status = super.computeRedoableStatus(monitor);
		if (status.isOK()) {
			status = computeCreateStatus();
		}
		return status;
	}
}




/*******************************************************************************
 * 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.ui.ide.undo;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
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.Platform;
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.widgets.Shell;
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.ResourceDescription;
import org.eclipse.ui.internal.ide.undo.UndoMessages;

/**
 * An AbstractResourcesOperation represents an undoable operation that
 * manipulates resources. It provides implementations for resource rename,
 * delete, creation, and modification. It also assigns the workspace undo
 * context as the undo context for operations of this type.
 * 
 * This class is not intended to be subclassed by clients.
 * 
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as part
 * of a work in progress. This API may change at any given time. Please do not
 * use this API without consulting with the Platform/UI team.
 * 
 * @since 3.3
 * 
 */
public abstract class AbstractResourcesOperation extends
		AbstractWorkspaceOperation {

	/*
	 * Delete all of the specified resources, returning resource descriptions
	 * that can be used to restore them.
	 * 
	 * This method is static to ensure "statelessness." Calling instance methods
	 * are responsible for maintaining the current state of resources and
	 * resource descriptions for the operation.
	 */
	protected 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(
						UndoMessages.AbstractResourcesOperation_DeleteResourcesProgress,
						resourcesToDelete.length);
		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;
	}

	/*
	 * Recreate the resources from the specified resource descriptions.
	 * 
	 * This method is static to ensure "statelessness." Calling instance methods
	 * are responsible for maintaining the current state of resources and
	 * resource descriptions for the operation.
	 */
	protected static IResource[] recreate(
			ResourceDescription[] resourcesToRecreate,
			IProgressMonitor monitor, IAdaptable uiInfo) throws CoreException {
		final List exceptions = new ArrayList();
		IResource[] resourcesToReturn = new IResource[resourcesToRecreate.length];
		monitor
				.beginTask(
						UndoMessages.AbstractResourcesOperation_CreateResourcesProgress,
						resourcesToRecreate.length);
		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 = createResult(exceptions);
			if (!result.isOK()) {
				throw new CoreException(result);
			}
		} finally {
			monitor.done();
		}
		return resourcesToReturn;
	}

	/*
	 * Move the specified resource to the new path provided. The new path
	 * includes any new name desired for the moved resource. Return the resource
	 * descriptions for any resources that were overwritten as part of the move.
	 * 
	 * This method is static to ensure "statelessness." Calling instance methods
	 * are responsible for maintaining the current state of resources and
	 * resource descriptions for the operation.
	 */

	protected static ResourceDescription[] move(IResource resourceToMove,
			IPath newPath, IProgressMonitor monitor, IAdaptable uiInfo)
			throws CoreException {
		monitor.beginTask(
				UndoMessages.AbstractResourcesOperation_MovingResources, 3);
		IWorkspaceRoot workspaceRoot = resourceToMove.getWorkspace().getRoot();
		List overwrittenResources = new ArrayList();

		// Some moves are optimized and recorded as complete in this flag
		boolean moved = false;
		IResource newResource = workspaceRoot.findMember(newPath);
		// If a resource already exists at the new location, we must
		// overwrite it.
		if (newResource != null) {
			// File on file overwrite is optimized as a reset of the
			// target file's contents
			if (resourceToMove.getType() == IResource.FILE
					&& newResource.getType() == IResource.FILE) {
				IFile file = (IFile) resourceToMove;
				IFile existingFile = (IFile) newResource;
				ResourceDescription resourceDescription = copyOverExistingResource(
						file, existingFile, monitor, uiInfo, true);
				if (resourceDescription != null) {
					overwrittenResources.add(resourceDescription);
					moved = true;
				}
			} else {
				// Any other overwrite is simply a delete of the resource
				// that is being overwritten, followed by the move
				ResourceDescription[] deleted = delete(
						new IResource[] { newResource },
						new SubProgressMonitor(monitor, 1), uiInfo, false);
				for (int j = 0; j < deleted.length; j++) {
					overwrittenResources.add(deleted[j]);
				}
			}
		} else {
			monitor.worked(100);
		}
		// Overwrites have been handled. If there is still a move to do, do
		// so now.
		if (!moved) {
			if (resourceToMove.getType() == IResource.PROJECT) {
				IProject project = (IProject) resourceToMove;
				IProjectDescription description = project.getDescription();
				description.setName(newPath.lastSegment());
				// If the location is the default then set the location
				// to null
				IPath projectLocation = newPath.removeLastSegments(1);
				if (projectLocation.equals(Platform.getLocation())) {
					description.setLocation(null);
				} else {
					description.setLocation(projectLocation);
				}
				project.move(description, IResource.FORCE | IResource.SHALLOW,
						new SubProgressMonitor(monitor, 2));
			} else {
				generateContainers(newPath.removeLastSegments(1));
				resourceToMove
						.move(newPath, IResource.KEEP_HISTORY
								| IResource.SHALLOW, new SubProgressMonitor(
								monitor, 2));

			}
		}
		monitor.done();
		return (ResourceDescription[]) overwrittenResources
				.toArray(new ResourceDescription[overwrittenResources.size()]);
	}

	/*
	 * Copies the resources to the given destination. This method is called
	 * recursively to merge folders during folder copy. Return an array of
	 * ResourceDescriptions for any resources that were overwritten as part of
	 * the copy.
	 */
	protected static ResourceDescription[] copy(IResource[] resources,
			IPath destination, IProgressMonitor monitor, IAdaptable uiInfo,
			boolean pathIncludesName) throws CoreException {

		monitor
				.beginTask(
						UndoMessages.AbstractResourcesOperation_CopyingResourcesProgress,
						resources.length);
		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());
			}
			IWorkspace workspace = source.getWorkspace();
			IWorkspaceRoot workspaceRoot = workspace.getRoot();
			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 (homogenousResources(source, existing)) {
					IResource[] children = ((IContainer) source).members();
					ResourceDescription[] overwritten = copy(children,
							destinationPath,
							new SubProgressMonitor(monitor, 1), uiInfo, false);
					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);
					source.copy(destinationPath, IResource.SHALLOW,
							new SubProgressMonitor(monitor, 1));
					for (int j = 0; j < deleted.length; j++) {
						overwrittenResources.add(deleted[j]);
					}
				}
			} else {
				if (existing != null) {
					if (homogenousResources(source, existing)) {
						overwrittenResources.add(copyOverExistingResource(
								source, existing, new SubProgressMonitor(
										monitor, 1), uiInfo, false));
					} 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));
						for (int j = 0; j < deleted.length; j++) {
							overwrittenResources.add(deleted[j]);
						}
					}
				} else {
					// no resources are being overwritten
					if (source.getType() == IResource.PROJECT) {
						// Get a copy of the current description and modify it
						IProjectDescription newDescription = ((IProject) source)
								.getDescription();
						newDescription.setName(destinationPath.lastSegment());
						// If the location is the default then set the location
						// to null
						IPath projectLocation = destinationPath
								.removeLastSegments(1);
						if (projectLocation.equals(Platform.getLocation())) {
							newDescription.setLocation(null);
						} else {
							newDescription.setLocation(projectLocation);
						}
						source.copy(newDescription, IResource.SHALLOW
								| IResource.FORCE, monitor);
					} else {
						// ensure the destination path exists
						IPath parentPath = destination;
						if (pathIncludesName) {
							parentPath = destination.removeLastSegments(1);
						}
						generateContainers(parentPath);
						source.copy(destinationPath, IResource.SHALLOW,
								new SubProgressMonitor(monitor, 1));
					}
				}

				if (monitor.isCanceled()) {
					throw new OperationCanceledException();
				}
			}
		}
		return (ResourceDescription[]) overwrittenResources
				.toArray(new ResourceDescription[overwrittenResources.size()]);

	}

	/*
	 * Delete the specified resource, recording enough information about it that
	 * it can be restored later. Return a ResourceDescription capable of
	 * restoring the resource.
	 * 
	 * This method is static to ensure "statelessness." Calling instance methods
	 * are responsible for maintaining the current state of resources and
	 * resource descriptions for the operation.
	 */
	protected 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) {
			IProject project = (IProject) resourceToDelete;
			project.delete(deleteContent, forceOutOfSyncDelete, monitor);
		} else {
			// if it's not a project, just delete it
			monitor
					.beginTask(
							UndoMessages.AbstractResourcesOperation_DeleteResourcesProgress,
							2);
			int updateFlags;
			if (forceOutOfSyncDelete) {
				updateFlags = IResource.KEEP_HISTORY | IResource.FORCE;
			} else {
				updateFlags = IResource.KEEP_HISTORY;
			}
			resourceToDelete.delete(updateFlags, new SubProgressMonitor(
					monitor, 1));
			resourceDescription.recordLastHistory(resourceToDelete,
					new SubProgressMonitor(monitor, 1));
			monitor.done();
		}

		return resourceDescription;
	}

	private static ResourceDescription copyOverExistingResource(
			IResource source, IResource existing, IProgressMonitor monitor,
			IAdaptable uiInfo, boolean deleteSourceFile) throws CoreException {
		IFile file = getFile(source);
		IFile existingFile = getFile(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.recordLastHistory(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;
	}

	/**
	 * Returns the resource either casted to or adapted to an IFile.
	 * 
	 * @param resource
	 *            resource to cast/adapt
	 * @return the resource either casted to or adapted to an IFile.
	 *         <code>null</code> if the resource does not adapt to IFile
	 */
	private static IFile getFile(IResource resource) {
		if (resource instanceof IFile) {
			return (IFile) resource;
		}
		return (IFile) ((IAdaptable) resource).getAdapter(IFile.class);
	}

	/**
	 * Check for existence of the specified path and generate any containers
	 * that do not yet exist.
	 * 
	 * @param path
	 *            the path describing the container hierarchy to be checked.
	 */
	private static void generateContainers(IPath path) throws CoreException {
		IContainer container;
		if (path.segmentCount() == 1) {
			container = ResourcesPlugin.getWorkspace().getRoot().getProject(
					path.segment(0));
		} else {
			container = ResourcesPlugin.getWorkspace().getRoot()
					.getFolder(path);
		}
		if (container != null) {
			ContainerDescription containerDescription = ContainerDescription
					.fromContainer(container);
			containerDescription.createExistentResourceFromHandle(container,
					new NullProgressMonitor());
		}

	}

	/**
	 * Ask the user whether the given resource should be deleted despite being
	 * out of sync with the file system.
	 * 
	 * @param resource
	 *            the out of sync resource
	 * @param uiInfo
	 *            an adaptable describing the ui info for this operation
	 * @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);
		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 returns a result status appropriate for the given list of
	 * exceptions.
	 * 
	 * @param exceptions
	 *            The list of exceptions that occurred (may be empty)
	 * @return The result status for the deletion
	 */
	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;
	}

	/**
	 * Validates 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.
	 * 
	 * @param source
	 *            source file
	 * @param destination
	 *            destination file
	 * @param shell
	 *            ui context for the validation
	 * @return boolean <code>true</code> both files could be made writeable.
	 *         <code>false</code> either one or both files were not made
	 *         writeable
	 */
	private static boolean validateEdit(IFile source, IFile destination,
			Shell shell) {
		if (destination.isReadOnly()) {
			IWorkspace workspace = source.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;
	}

	/**
	 * Returns whether the given resources are either both linked or both
	 * unlinked.
	 * 
	 * @param source
	 *            source resource
	 * @param destination
	 *            destination resource
	 * @return boolean <code>true</code> if both resources are either linked
	 *         or unlinked. <code>false</code> otherwise.
	 */
	private static boolean homogenousResources(IResource source,
			IResource destination) {
		boolean isSourceLinked = source.isLinked();
		boolean isDestinationLinked = destination.isLinked();

		return (isSourceLinked && isDestinationLinked || isSourceLinked == false
				&& isDestinationLinked == false);
	}

	protected ResourceDescription[] resourceDescriptions;

	/**
	 * Create an Abstract Resources Operation
	 * 
	 * @param resources
	 *            the resources to be modified
	 * @param label
	 *            the label of the operation
	 */
	AbstractResourcesOperation(IResource[] resources, String label) {
		super(label);
		this.addContext(WorkspaceUndoSupport.getWorkspaceUndoContext());

		setTargetResources(resources);
	}

	/**
	 * Create an Abstract Resources Operation
	 * 
	 * @param resourceDescriptions
	 *            the resourceDescriptions describing resources to be created
	 * @param label
	 *            the label of the operation
	 */
	AbstractResourcesOperation(ResourceDescription[] resourceDescriptions,
			String label) {
		super(label);
		addContext(WorkspaceUndoSupport.getWorkspaceUndoContext());
		setResourceDescriptions(resourceDescriptions);
	}

	protected void delete(IProgressMonitor monitor, IAdaptable uiInfo,
			boolean deleteContent) throws CoreException {
		setResourceDescriptions(AbstractResourcesOperation.delete(resources,
				monitor, uiInfo, deleteContent));
		setTargetResources(new IResource[0]);
	}

	protected void recreate(IProgressMonitor monitor, IAdaptable uiInfo)
			throws CoreException {
		setTargetResources(AbstractResourcesOperation.recreate(
				resourceDescriptions, monitor, uiInfo));
		setResourceDescriptions(new ResourceDescription[0]);
	}

	/*
	 * Compute the status for creating resources from the descriptions.
	 * 
	 * Note this method may be called on initial creation of a resource, or when
	 * a create or delete operation is being undone or redone. Therefore, this
	 * method should check conditions that can change over the life of the
	 * operation, such as the existence of the information needed to carry out
	 * the operation. One-time static checks should typically be done by the
	 * caller (such as the action that creates the operation) so that the user
	 * is not continually prompted or warned about conditions that were
	 * acceptable at the time of original execution.
	 */
	protected IStatus computeCreateStatus() {
		if (resourceDescriptions == null || resourceDescriptions.length == 0) {
			markInvalid();
			return getErrorStatus(UndoMessages.AbstractResourcesOperation_NotEnoughInfo);
		}
		for (int i = 0; i < resourceDescriptions.length; i++) {
			if (!resourceDescriptions[i].isValid()) {
				markInvalid();
				return getErrorStatus(UndoMessages.AbstractResourcesOperation_InvalidRestoreInfo);
			}
		}
		return Status.OK_STATUS;
	}

	/*
	 * Compute the status for deleting resources.
	 * 
	 * Note this method may be called on initial deletion of a resource, or when
	 * a create or delete operation is being undone or redone. Therefore, this
	 * method should check conditions that can change over the life of the
	 * operation, such as the existence of the resources to be deleted. One-time
	 * static checks should typically be done by the caller (such as the action
	 * that creates the operation) so that the user is not continually prompted
	 * or warned about conditions that were acceptable at the time of original
	 * execution.
	 */

	protected IStatus computeDeleteStatus() {
		if (resources == null || resources.length == 0) {
			markInvalid();
			return getErrorStatus(UndoMessages.AbstractResourcesOperation_NotEnoughInfo);
		}
		if (!resourcesExist()) {
			markInvalid();
			return getErrorStatus(UndoMessages.AbstractResourcesOperation_ResourcesDoNotExist);
		}
		return Status.OK_STATUS;
	}

	/**
	 * Ask the user whether the given resource should be overwritten.
	 * 
	 * @param resource
	 *            the resource to be overwritten
	 * @param uiInfo
	 *            an adaptable describing the ui info for this operation
	 * @return One of the IDialogConstants constants indicating which of the
	 *         Yes, Yes to All, No, Cancel options has been selected by the
	 *         user.
	 */
	protected int queryOverwrite(IResource resource, IAdaptable uiInfo) {
		Shell shell = getShell(uiInfo);
		final MessageDialog dialog = new MessageDialog(
				shell,
				UndoMessages.AbstractResourcesOperation_overwriteTitle,
				null,
				NLS
						.bind(
								UndoMessages.AbstractResourcesOperation_overwriteQuestion,
								resource.getName()), MessageDialog.QUESTION,
				new String[] { IDialogConstants.YES_LABEL,
						IDialogConstants.YES_TO_ALL_LABEL,
						IDialogConstants.NO_LABEL,
						IDialogConstants.CANCEL_LABEL }, 0);
		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;
	}

	/*
	 * Set the array of resource descriptions describing resources to be
	 * restored when undoing or redoing this operation.
	 */
	protected void setResourceDescriptions(ResourceDescription[] descriptions) {
		if (descriptions == null) {
			resourceDescriptions = new ResourceDescription[0];
		} else {
			resourceDescriptions = descriptions;
		}
	}
}




/*******************************************************************************
 * 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.ui.ide.undo;

import org.eclipse.core.resources.IFolder;
import org.eclipse.core.runtime.IPath;
import org.eclipse.ui.internal.ide.undo.ContainerDescription;
import org.eclipse.ui.internal.ide.undo.FolderDescription;
import org.eclipse.ui.internal.ide.undo.ResourceDescription;

/**
 * A CreateFolderOperation represents an undoable operation for creating a
 * folder in the workspace. If a link location is specified, the folder is
 * considered to be linked to the specified location. If a link location is not
 * specified, the folder will be created in the location specified by the
 * handle, and the entire containment path of the folder will be created if it
 * does not exist.
 * 
 * This class is intended to be instantiated and used by clients. It is not
 * intended to be subclassed by clients.
 * 
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as part
 * of a work in progress. This API may change at any given time. Please do not
 * use this API without consulting with the Platform/UI team.
 * 
 * @since 3.3
 * 
 */
public class CreateFolderOperation extends AbstractCreateResourcesOperation {

	/**
	 * Create a CreateFolderOperation
	 * 
	 * @param folderHandle
	 *            the folder to be created
	 * @param linkLocation
	 *            the location of the folder if it is to be linked
	 * @param label
	 *            the label of the operation
	 */
	public CreateFolderOperation(IFolder folderHandle, IPath linkLocation, String label) {
		super(null, label);
		ContainerDescription containerDescription;
		if (linkLocation == null) {
			containerDescription = ContainerDescription.fromContainer(folderHandle);
		} else {
			// create a linked folder description
			containerDescription = new FolderDescription(folderHandle, linkLocation);
		}
		setResourceDescriptions(new ResourceDescription[ ] {containerDescription});
	}
}




/*******************************************************************************
 * 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.ui.internal.ide.undo;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.SubProgressMonitor;

/**
 * ContainerDescription is a lightweight description that describes a container
 * to be created.
 * 
 * This class is not intended to be instantiated or used by clients.
 * 
 * @since 3.3
 * 
 */
public abstract class ContainerDescription extends ResourceDescription {

	String name;

	IPath location;

	private ResourceDescription[] members;

	/*
	 * Create a container description from the specified container handle that
	 * can be used to create the container. The returned ContainerDescription
	 * should represent any non-existing parents in addition to the specified
	 * container.
	 */

	public static ContainerDescription fromContainer(IContainer container) {
		IPath fullPath = container.getFullPath();
		ContainerDescription firstCreatedParent = null;
		ContainerDescription currentContainerDescription = null;

        // Does the container exist already? If so, then the parent exists and
		// we use the normal creation constructor.
        IWorkspaceRoot root = getWorkspaceRoot();
        IContainer currentContainer = (IContainer) root.findMember(fullPath);
        if (container != null) {
			return (ContainerDescription)ResourceDescription.fromResource(container);
		}

        // Create container descriptions for any uncreated parents in the given
        // path.
        currentContainer = root;
        for (int i = 0; i < fullPath.segmentCount(); i++) {
            String currentSegment = fullPath.segment(i);
            IResource resource = currentContainer.findMember(currentSegment);
            if (resource != null) {
            	// parent already exists, no need to create a description for it
            	currentContainer = (IContainer)resource;
            } else {
                if (i == 0) {
                	// parent does not exist and it is a project
                    firstCreatedParent = new ProjectDescription(root.getProject(currentSegment));
                    currentContainerDescription = firstCreatedParent;
                } else {
                	IFolder folderHandle = currentContainer.getFolder(new Path(currentSegment));
                    ContainerDescription currentFolder = new FolderDescription(folderHandle);
                    currentContainer = folderHandle;
                    if (currentContainerDescription != null) {
                    	currentContainerDescription.addMember(currentFolder);
                    }
                    currentContainerDescription = currentFolder;
                    if (firstCreatedParent == null) {
                    	firstCreatedParent = currentFolder;
                    }
                }
            }
        }
        return firstCreatedParent;
	}

	/*
	 * Create a ContainerDescription with no state.
	 */
	public ContainerDescription() {

	}

	/*
	 * Create a ContainerDescription from the specified container handle.
	 * Typically used when the container handle represents a resource that
	 * actually exists, although it will not fail if the resource is
	 * non-existent.
	 */
	public ContainerDescription(IContainer container) {
		super(container);
		this.name = container.getName();
		if (container.isLinked()) {
			this.location = container.getLocation();
		}
		try {
			if (container.exists()) {
				IResource[] resourceMembers = container.members();
				members = new ResourceDescription[resourceMembers.length];
				for (int i = 0; i < resourceMembers.length; i++) {
					members[i] = ResourceDescription
							.fromResource(resourceMembers[i]);
				}
			}
		} catch (CoreException e) {
			// Eat this exception because it only occurs when the resource
			// does not exist and we have already checked this.
			// We do not want to throw exceptions on the simple constructor, as
			// no one has actually tried to do anything yet.
		}
	}

	public IResource createResourceHandle() {
		IWorkspaceRoot workspaceRoot = parent.getWorkspace().getRoot();
		IPath folderPath = parent.getFullPath().append(name);
		return workspaceRoot.getFolder(folderPath);
	}

	protected void createChildResources(IContainer parentHandle,
			IProgressMonitor monitor, int ticks) throws CoreException {

		// restore any children
		if (members != null && members.length > 0) {
			for (int i = 0; i < members.length; i++) {
				members[i].parent = parentHandle;
				members[i].createResource(new SubProgressMonitor(monitor, ticks
						/ members.length));
			}
		}
	}

	public void recordLastHistory(IResource resource, IProgressMonitor monitor)
			throws CoreException {
		monitor.beginTask(
				UndoMessages.FolderDescription_SavingUndoInfoProgress, 100);
		for (int i = 0; i < members.length; i++) {
			if (members[i] instanceof FileDescription) {
				IPath path = resource.getFullPath().append(
						((FileDescription) members[i]).name);
				IFile fileHandle = resource.getWorkspace().getRoot().getFile(
						path);
				members[i].recordLastHistory(fileHandle,
						new SubProgressMonitor(monitor, 100 / members.length));
			} else if (members[i] instanceof FolderDescription) {
				IPath path = resource.getFullPath().append(
						((FolderDescription) members[i]).name);
				IFolder folderHandle = resource.getWorkspace().getRoot()
						.getFolder(path);
				members[i].recordLastHistory(folderHandle,
						new SubProgressMonitor(monitor, 100 / members.length));
			}
		}
		monitor.done();
	}

	public String getName() {
		return name;
	}

	/*
	 * Return the first folder found that has no child folders.
	 */
	public ContainerDescription getFirstLeafFolder() {
		// If there are no members, this is a leaf
		if (members == null || members.length == 0) {
			return this;
		}
		// Traverse the members and find the first potential leaf
		for (int i = 0; i < members.length; i++) {
			if (members[i] instanceof ContainerDescription) {
				return ((ContainerDescription) members[i]).getFirstLeafFolder();
			}
		}
		// No child folders were found, this is a leaf
		return this;
	}

	/*
	 * Add the specified resource description as a member of this resource
	 * description
	 */
	public void addMember(ResourceDescription member) {
		if (members == null) {
			members = new ResourceDescription[] { member };
		} else {
			ResourceDescription[] expandedMembers = new ResourceDescription[members.length + 1];
			System.arraycopy(members, 0, expandedMembers, 0, members.length);
			expandedMembers[members.length] = member;
			members = expandedMembers;
		}
	}
}




/*******************************************************************************
 * 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.ui.internal.ide.undo;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.SubProgressMonitor;

/**
 * ProjectDescription is a lightweight description that describes a project to
 * be created.
 * 
 * This class is not intended to be instantiated or used by clients.
 * 
 * @since 3.3
 * 
 */
public class ProjectDescription extends ContainerDescription {

	private IProjectDescription projectDescription;

	/*
	 * Create a project description from a specified project. Used only when the
	 * project exists and is open.
	 */
	public ProjectDescription(IProject project) {
		super(project);
		Assert.isLegal(project.exists() && project.isOpen());
		try {
			this.projectDescription = project.getDescription();
		} catch (CoreException e) {
			// Eat this exception because it only occurs when the project
			// does not exist or is not open, and we have already checked this.
			// We do not want to throw exceptions on the simple constructor, as
			// no one has actually tried to do anything yet.
		}
	}

	/*
	 * Create a project description from a specified IProjectDescription. Used
	 * when the project does not yet exist.
	 */
	public ProjectDescription(IProjectDescription projectDescription) {
		super();
		this.projectDescription = projectDescription;
	}

	public IResource createResourceHandle() {
		return ResourcesPlugin.getWorkspace().getRoot().getProject(getName());
	}

	public void createExistentResourceFromHandle(IResource resource,
			IProgressMonitor monitor) throws CoreException {
		Assert.isLegal(resource instanceof IProject);
		if (resource.exists()) {
			return;
		}
		IProject projectHandle = (IProject) resource;
		monitor.beginTask(UndoMessages.ProjectDescription_NewProjectProgress,
				200);
		if (projectDescription == null) {
			projectHandle.create(new SubProgressMonitor(monitor, 100));
		} else {
			projectHandle.create(projectDescription, new SubProgressMonitor(
					monitor, 100));
		}

		if (monitor.isCanceled()) {
			throw new OperationCanceledException();
		}
		projectHandle.open(IResource.BACKGROUND_REFRESH,
				new SubProgressMonitor(monitor, 100));
		monitor.done();
	}

	public String getName() {
		return projectDescription.getName();
	}
}




/*******************************************************************************
 * 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.ui.ide.undo;

import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.osgi.util.NLS;
import org.eclipse.ui.internal.ide.undo.ProjectDescription;
import org.eclipse.ui.internal.ide.undo.UndoMessages;

/**
 * A CreateProjectOperation represents an undoable operation for creating a
 * project in the workspace.
 * 
 * This class is intended to be instantiated and used by clients. It is not
 * intended to be subclassed by clients.
 * 
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as part
 * of a work in progress. This API may change at any given time. Please do not
 * use this API without consulting with the Platform/UI team.
 * 
 * @since 3.3
 * 
 */
public class CreateProjectOperation extends AbstractCreateResourcesOperation {

	/**
	 * Create a CreateProjectOperation
	 * 
	 * @param projectDescription
	 *            the project to be created
	 * @param label
	 *            the label of the operation
	 */
	public CreateProjectOperation(IProjectDescription projectDescription,
			String label) {
		super(new ProjectDescription[] { new ProjectDescription(
				projectDescription) }, label);
	}
	
	/**
	 * Return the specific error message to use when the specified core
	 * exception occurs, or <code>null</code> to indicate that the the
	 * exception's message should be used.
	 */
	protected String getErrorMessage(CoreException e) {
		if (e.getStatus().getCode() == IResourceStatus.CASE_VARIANT_EXISTS) {
			if (resourceDescriptions != null && resourceDescriptions.length==1) {
				ProjectDescription project = (ProjectDescription)resourceDescriptions[0];
				return NLS.bind(UndoMessages.CreateProjectOperation_caseVariantExistsError, project.getName());
			}
		}
		return super.getErrorMessage(e);
	}	
}




/*******************************************************************************
 * 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.ui.ide.undo;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
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.SubProgressMonitor;
import org.eclipse.ui.internal.ide.undo.ResourceDescription;
import org.eclipse.ui.internal.ide.undo.UndoMessages;

/**
 * A CopyResourcesOperation represents an undoable operation for copying one or
 * more resources in the workspace.
 * 
 * This class is intended to be instantiated and used by clients. It is not
 * intended to be subclassed by clients.
 * 
 * <strong>EXPERIMENTAL</strong> This class or interface has been added as part
 * of a work in progress. This API may change at any given time. Please do not
 * use this API without consulting with the Platform/UI team.
 * 
 * @since 3.3
 * 
 */
public class CopyResourcesOperation extends
		AbstractCopyOrMoveResourcesOperation {

	IResource[] originalResources;

	IPath[] originalDestinationPaths = null;

	IPath originalDestination = null;

	/**
	 * Create a CopyResourcesOperation that copies a single resource to a new
	 * location. The new location includes the name of the copy.
	 * 
	 * @param resource
	 *            the resource to be moved
	 * @param newPath
	 *            the new path for the resource, including its desired name.
	 * @param label
	 *            the label of the operation
	 */
	public CopyResourcesOperation(IResource resource, IPath newPath,
			String label) {
		super(new IResource[] { resource }, new IPath[] { newPath }, label);
		originalResources = new IResource[] { resource };
		originalDestinationPaths = new IPath[] { newPath };
	}

	/**
	 * Create a CopyResourcesOperation that copies all of the specified
	 * resources to a single target location. The original resource name will be
	 * used when copied to the new location.
	 * 
	 * @param resources
	 *            the resources to be copied
	 * @param destinationPath
	 *            the destination path for the copied resource.
	 * @param label
	 *            the label of the operation
	 */
	public CopyResourcesOperation(IResource[] resources, IPath destinationPath,
			String label) {
		super(resources, destinationPath, label);
		originalResources = resources;
		originalDestination = destinationPath;
	}

	/**
	 * Create a CopyResourcesOperation that copies each of the specified
	 * resources to its corresponding destination path in the destination path
	 * array. The resource name for the target is included in the corresponding
	 * destination path.
	 * 
	 * @param resources
	 *            the resources to be copied
	 * @param destinationPaths
	 *            a destination path for each copied resource, which includes
	 *            the name of the resource at the new destination
	 * @param label
	 *            the label of the operation
	 */
	public CopyResourcesOperation(IResource[] resources,
			IPath[] destinationPaths, String label) {
		super(resources, destinationPaths, label);
		originalResources = resources;
		// the destination array must be copied so it will be remembered.
		// move and copy operations update the original array.
		originalDestinationPaths = new IPath[destinationPaths.length];
		System.arraycopy(destinationPaths, 0, originalDestinationPaths, 0,
				destinationPaths.length);
	}

	protected void doExecute(IProgressMonitor monitor, IAdaptable uiInfo)
			throws CoreException {
		moveOrCopy(monitor, uiInfo, false); // false = copy
	}

	protected void doUndo(IProgressMonitor monitor, IAdaptable uiInfo)
			throws CoreException {
		monitor
				.beginTask(
						UndoMessages.AbstractResourcesOperation_CopyingResourcesProgress,
						2);
		// undoing a copy is first deleting the copied resources...
		AbstractResourcesOperation.delete(resources, new SubProgressMonitor(
				monitor, 1), uiInfo, true);
		// then restoring any overwritten by the previous copy...
		AbstractResourcesOperation.recreate(resourceDescriptions,
				new SubProgressMonitor(monitor, 1), uiInfo);
		setResourceDescriptions(new ResourceDescription[0]);
		// then setting the target resources and destination paths
		// back to the original ones
		setTargetResources(originalResources);
		if (originalDestination != null) {
			destination = originalDestination;
			destinationPaths = null;
		} else {
			destination = null;
			destinationPaths = originalDestinationPaths;
		}
		monitor.done();
	}

	protected boolean updateResourceChangeDescriptionFactory(
			IResourceChangeDescriptionFactory factory, int operation) {
		boolean update = false;
		if (operation == UNDO) {
			for (int i = 0; i < resources.length; i++) {
				update = true;
				IResource resource = resources[i];
				factory.delete(resource);
			}
			for (int i = 0; i < resourceDescriptions.length; i++) {
				update = true;
				IResource resource = resourceDescriptions[i].createResourceHandle();
				factory.create(resource);
			}
		} else {
			for (int i = 0; i < resources.length; i++) {
				update = true;
				IResource resource = resources[i];
				factory.copy(resource, getDestinationPath(resource, i, false));
			}
		}
		return update;
	}

	public IStatus computeExecutionStatus(IProgressMonitor monitor) {
		IStatus status = super.computeExecutionStatus(monitor);
		if (status.isOK()) {
			status = computeMoveOrCopyStatus();
		}
		return status;
	}

	public IStatus computeUndoableStatus(IProgressMonitor monitor) {
		IStatus status = super.computeUndoableStatus(monitor);
		// undoing a copy means deleting the copy that was made
		if (status.isOK()) {
			status = computeDeleteStatus();
		}
		// and if there were resources overwritten by the copy, can we still
		// recreate them?
		if (status.isOK() && resourceDescriptions != null
				&& resourceDescriptions.length > 0) {
			status = computeCreateStatus();
		}
		return status;
	}

	public IStatus computeRedoableStatus(IProgressMonitor monitor) {
		IStatus status = super.computeRedoableStatus(monitor);
		if (status.isOK()) {
			status = computeMoveOrCopyStatus();
		}
		return status;
	}
}

Return to bug 123674

Lines 15-20 Link Here

(-)extensions/org/eclipse/ui/dialogs/WizardNewFileCreationPage.java (-36 / +37 lines)
15	import java.lang.reflect.InvocationTargetException;	15	import java.lang.reflect.InvocationTargetException;
16	import java.util.Iterator;	16	import java.util.Iterator;
17		17
		18	import org.eclipse.core.commands.ExecutionException;
18	import org.eclipse.core.resources.IFile;	19	import org.eclipse.core.resources.IFile;
19	import org.eclipse.core.resources.IFolder;	20	import org.eclipse.core.resources.IFolder;
20	import org.eclipse.core.resources.IResource;	21	import org.eclipse.core.resources.IResource;
Lines 30-39 Link Here
30	import org.eclipse.core.runtime.OperationCanceledException;	31	import org.eclipse.core.runtime.OperationCanceledException;
31	import org.eclipse.core.runtime.Path;	32	import org.eclipse.core.runtime.Path;
32	import org.eclipse.core.runtime.Preferences;	33	import org.eclipse.core.runtime.Preferences;
33	import org.eclipse.core.runtime.SubProgressMonitor;
34	import org.eclipse.core.runtime.jobs.ISchedulingRule;	34	import org.eclipse.core.runtime.jobs.ISchedulingRule;
35	import org.eclipse.jface.dialogs.ErrorDialog;
36	import org.eclipse.jface.dialogs.MessageDialog;	35	import org.eclipse.jface.dialogs.MessageDialog;
		36	import org.eclipse.jface.operation.IRunnableWithProgress;
37	import org.eclipse.jface.viewers.IStructuredSelection;	37	import org.eclipse.jface.viewers.IStructuredSelection;
38	import org.eclipse.jface.wizard.WizardPage;	38	import org.eclipse.jface.wizard.WizardPage;
39	import org.eclipse.osgi.util.NLS;	39	import org.eclipse.osgi.util.NLS;
Lines 49-55 Link Here
49	import org.eclipse.swt.widgets.Listener;	49	import org.eclipse.swt.widgets.Listener;
50	import org.eclipse.swt.widgets.Shell;	50	import org.eclipse.swt.widgets.Shell;
51	import org.eclipse.ui.PlatformUI;	51	import org.eclipse.ui.PlatformUI;
52	import org.eclipse.ui.actions.WorkspaceModifyOperation;	52	import org.eclipse.ui.ide.undo.CreateFileOperation;
53	import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;	53	import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
54	import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;	54	import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
55	import org.eclipse.ui.internal.ide.IIDEHelpContextIds;	55	import org.eclipse.ui.internal.ide.IIDEHelpContextIds;
Lines 218-223 Link Here
218	* @param monitor the progress monitor to show visual progress with	218	* @param monitor the progress monitor to show visual progress with
219	* @exception CoreException if the operation fails	219	* @exception CoreException if the operation fails
220	* @exception OperationCanceledException if the operation is canceled	220	* @exception OperationCanceledException if the operation is canceled
		221	*
		222	* @deprecated As of 3.3, use or override {@link #createNewFile()} which uses the
		223	* undoable operation support. To supply customized file content for
		224	* a subclass, use {@link #getInitialContents()}.
221	*/	225	*/
222	protected void createFile(IFile fileHandle, InputStream contents,	226	protected void createFile(IFile fileHandle, InputStream contents,
223	IProgressMonitor monitor) throws CoreException {	227	IProgressMonitor monitor) throws CoreException {
Lines 321-365 Link Here
321	final InputStream initialContents = getInitialContents();	325	final InputStream initialContents = getInitialContents();
322		326
323	createLinkTarget();	327	createLinkTarget();
324	WorkspaceModifyOperation op = new WorkspaceModifyOperation(createRule(newFileHandle)) {	328	IRunnableWithProgress op = new IRunnableWithProgress() {
325	protected void execute(IProgressMonitor monitor)	329	public void run(IProgressMonitor monitor) {
326	throws CoreException {	330	CreateFileOperation op = new CreateFileOperation(
327	try {	331	newFileHandle, linkTargetPath, initialContents,
328	monitor.beginTask(IDEWorkbenchMessages.WizardNewFileCreationPage_progress, 2000);	332	IDEWorkbenchMessages.WizardNewFileCreationPage_title);
329	ContainerGenerator generator = new ContainerGenerator(	333	try {
330	containerPath);	334	PlatformUI.getWorkbench().getOperationSupport()
331	generator.generateContainer(new SubProgressMonitor(monitor,	335	.getOperationHistory().execute(op, monitor,
332	1000));	336	new IAdaptable() {
333	createFile(newFileHandle, initialContents,	337	public Object getAdapter(Class clazz) {
334	new SubProgressMonitor(monitor, 1000));	338	if (clazz == Shell.class) {
335	} finally {	339	return getContainer()
336	monitor.done();	340	.getShell();
337	}	341	}
338	}	342	return null;
339	};	343	}
		344	});
		345	} catch (ExecutionException e) {
		346	IDEWorkbenchPlugin.log(e.getMessage(), e);
		347	}
		348	}
		349	};
340		350
341	try {	351	try {
342	getContainer().run(true, true, op);	352	getContainer().run(true, true, op);
343	} catch (InterruptedException e) {	353	} catch (InterruptedException e) {
344	return null;	354	return null;
345	} catch (InvocationTargetException e) {	355	} catch (InvocationTargetException e) {
346	if (e.getTargetException() instanceof CoreException) {	356	// Execution Exceptions are handled above but we may still get unexpected runtime errors.
347	ErrorDialog	357	IDEWorkbenchPlugin.log(getClass(),
348	.openError(	358	"createNewFile()", e.getTargetException()); //$NON-NLS-1$
349	getContainer().getShell(), // Was Utilities.getFocusShell()	359	MessageDialog
350	IDEWorkbenchMessages.WizardNewFileCreationPage_errorTitle,	360	.openError(
351	null, // no special message	361	getContainer().getShell(),
352	((CoreException) e.getTargetException())	362	IDEWorkbenchMessages.WizardNewFileCreationPage_internalErrorTitle, NLS.bind(IDEWorkbenchMessages.WizardNewFileCreationPage_internalErrorMessage, e.getTargetException().getMessage()));
353	.getStatus());	363
354	} else {
355	// CoreExceptions are handled above, but unexpected runtime exceptions and errors may still occur.
356	IDEWorkbenchPlugin.log(getClass(),
357	"createNewFile()", e.getTargetException()); //$NON-NLS-1$
358	MessageDialog
359	.openError(
360	getContainer().getShell(),
361	IDEWorkbenchMessages.WizardNewFileCreationPage_internalErrorTitle, NLS.bind(IDEWorkbenchMessages.WizardNewFileCreationPage_internalErrorMessage, e.getTargetException().getMessage()));
362	}
363	return null;	364	return null;
364	}	365	}
365		366

Lines 36-49 Link Here

(-)src/org/eclipse/ui/internal/ide/undo/UndoMessages.java (-7 / +31 lines)
36	public static String AbstractWorkspaceOperation_RedoSideEffectsWarningMessage;	36	public static String AbstractWorkspaceOperation_RedoSideEffectsWarningMessage;
37	public static String AbstractWorkspaceOperation_ErrorInvalidMessage;	37	public static String AbstractWorkspaceOperation_ErrorInvalidMessage;
38	public static String AbstractWorkspaceOperation_GenericWarningMessage;	38	public static String AbstractWorkspaceOperation_GenericWarningMessage;
		39
		40	public static String AbstractResourcesOperation_ResourcesDoNotExist;
		41	public static String AbstractResourcesOperation_NotEnoughInfo;
		42	public static String AbstractResourcesOperation_InvalidRestoreInfo;
		43	public static String AbstractResourcesOperation_DeleteResourcesProgress;
		44	public static String AbstractResourcesOperation_CreateResourcesProgress;
		45	public static String AbstractResourcesOperation_CopyingResourcesProgress;
		46	public static String AbstractResourcesOperation_MovingResources;
		47	public static String AbstractResourcesOperation_outOfSyncError;
		48	public static String AbstractResourcesOperation_outOfSyncQuestion;
		49	public static String AbstractResourcesOperation_deletionMessageTitle;
		50	public static String AbstractResourcesOperation_deletionExceptionMessage;
		51	public static String AbstractResourcesOperation_overwriteTitle;
		52	public static String AbstractResourcesOperation_overwriteError;
		53	public static String AbstractResourcesOperation_overwriteQuestion;
		54
		55	public static String MoveOrCopyResourceOperation_SameNameOrLocation;
		56	public static String MoveOrCopyResourceOperation_ResourceDoesNotExist;
		57	public static String MoveOrCopyResourceOperation_ReadOnly;
		58
		59	public static String DeleteResourcesOperation_DeletingProjectContentWarning;
		60	public static String CreateProjectOperation_caseVariantExistsError;
		61
		62	public static String ProjectDescription_NewProjectProgress;
		63	public static String FileDescription_NewFileProgress;
		64	public static String FileDescription_SavingUndoInfoProgress;
		65	public static String FileDescription_ContentsCouldNotBeRestored;
		66	public static String FolderDescription_NewFolderProgress;
		67	public static String FolderDescription_SavingUndoInfoProgress;
		68
39		69
40	public static String MarkerOperation_ResourceDoesNotExist;	70	public static String MarkerOperation_ResourceDoesNotExist;
41	public static String MarkerOperation_MarkerDoesNotExist;	71	public static String MarkerOperation_MarkerDoesNotExist;
42	public static String MarkerOperation_NotEnoughInfo;	72	public static String MarkerOperation_NotEnoughInfo;
43
44	public static String RenameResourceOperation_SameName;
45	public static String RenameResourceOperation_NameAlreadyExists;
46	public static String RenameResourceOperation_ResourceDoesNotExist;
47	public static String RenameResourceOperation_ReadOnly;
48	public static String RenameResourceOperation_ResourceAlreadyExists;
49	}	73	}

Lines 20-31 Link Here

(-)src/org/eclipse/ui/internal/ide/undo/messages.properties (-5 / +31 lines)
20	AbstractWorkspaceOperation_UndoSideEffectsWarningMessage=Undoing "{0}" may have undesirable side effects.	20	AbstractWorkspaceOperation_UndoSideEffectsWarningMessage=Undoing "{0}" may have undesirable side effects.
21	AbstractWorkspaceOperation_RedoSideEffectsWarningMessage=Redoing "{0}" may have undesirable side effects.	21	AbstractWorkspaceOperation_RedoSideEffectsWarningMessage=Redoing "{0}" may have undesirable side effects.
22		22
		23	AbstractResourcesOperation_ResourcesDoNotExist=Cannot complete operation because resources no longer exist.
		24	AbstractResourcesOperation_NotEnoughInfo=There is not enough information to complete the resource operation.
		25	AbstractResourcesOperation_InvalidRestoreInfo=There is no longer enough information to restore the resource.
		26	AbstractResourcesOperation_DeleteResourcesProgress=Deleting resources...
		27	AbstractResourcesOperation_CreateResourcesProgress=Creating resources...
		28	AbstractResourcesOperation_CopyingResourcesProgress=Copying resources...
		29	AbstractResourcesOperation_MovingResources=Moving resources...
		30	AbstractResourcesOperation_outOfSyncError = Resource is out of sync with the file system. Refresh and try again.
		31	AbstractResourcesOperation_outOfSyncQuestion = Resource ''{0}'' is out of sync with the file system. Do you want to delete it anyway?
		32	AbstractResourcesOperation_deletionMessageTitle = Problems deleting
		33	AbstractResourcesOperation_deletionExceptionMessage=Multiple problems occurred while deleting resources.
		34	AbstractResourcesOperation_overwriteTitle = Resource already exists
		35	AbstractResourcesOperation_overwriteError = Could not complete operation without overwriting resources.
		36	AbstractResourcesOperation_overwriteQuestion = Resource ''{0}'' already exists. Do you want to overwrite it?
		37
		38
		39
		40	DeleteResourcesOperation_DeletingProjectContentWarning=Deleting project content will erase all of the file and folder history for the project. Undo will not restore the content.
		41
		42	CreateProjectOperation_caseVariantExistsError = The underlying file system is case insensitive. There is an existing project which conflicts with ''{0}''.
		43
		44	ProjectDescription_NewProjectProgress=Creating new project...
		45	FileDescription_NewFileProgress=Creating new file...
		46	FileDescription_ContentsCouldNotBeRestored=Unexpected error. File contents could not be restored from local history during undo/redo.
		47	FileDescription_SavingUndoInfoProgress=Saving file info...
		48	FolderDescription_NewFolderProgress=Creating new folder...
		49	FolderDescription_SavingUndoInfoProgress=Saving folder info...
		50
23	MarkerOperation_ResourceDoesNotExist=Cannot complete operation because resource no longer exists.	51	MarkerOperation_ResourceDoesNotExist=Cannot complete operation because resource no longer exists.
24	MarkerOperation_MarkerDoesNotExist=Cannot complete operation because marker no longer exists.	52	MarkerOperation_MarkerDoesNotExist=Cannot complete operation because marker no longer exists.
25	MarkerOperation_NotEnoughInfo=There is not enough information to perform the marker operation.	53	MarkerOperation_NotEnoughInfo=There is not enough information to perform the marker operation.
26		54
27	RenameResourceOperation_ReadOnly=The resource {0} is read only.	55	MoveOrCopyResourceOperation_ReadOnly=The resource {0} is read only.
28	RenameResourceOperation_SameName=Resource must be renamed to a different name.	56	MoveOrCopyResourceOperation_SameNameOrLocation=Resource cannot be moved or copied to the same location and name.
29	RenameResourceOperation_NameAlreadyExists=A resource with that name already exists.	57	MoveOrCopyResourceOperation_ResourceDoesNotExist=Resource no longer exists in the workspace.
30	RenameResourceOperation_ResourceDoesNotExist=Resource no longer exists in the workspace.
31	RenameResourceOperation_ResourceAlreadyExists=A resource named {0} already exists. It will be overwritten.

Removed Link Here

(-)src/org/eclipse/ui/ide/undo/MarkerDescription.java (-75 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.ide.undo;
13
14	import java.util.Map;
15
16	import org.eclipse.core.resources.IMarker;
17	import org.eclipse.core.resources.IResource;
18	import org.eclipse.core.runtime.CoreException;
19
20	/**
21	* MarkerDescription is a lightweight description of a marker that can be used
22	* to describe a marker to be created or updated.
23	*
24	* This class is not intended to be instantiated or used by clients.
25	*
26	* <strong>EXPERIMENTAL</strong> This class or interface has been added as part
27	* of a work in progress. This API may change at any given time. Please do not
28	* use this API without consulting with the Platform/UI team.
29	*
30	* @since 3.3
31	*
32	*/
33	class MarkerDescription {
34	String type;
35
36	Map attributes;
37
38	IResource resource;
39
40	/*
41	* Create a marker description from the specified marker.
42	*/
43	MarkerDescription(IMarker marker) throws CoreException {
44	this.type = marker.getType();
45	this.attributes = marker.getAttributes();
46	this.resource = marker.getResource();
47
48	}
49
50	/*
51	* Create a marker description from the specified marker type, attributes,
52	* and resource.
53	*/
54	MarkerDescription(String type, Map attributes, IResource resource) {
55	this.type = type;
56	this.attributes = attributes;
57	this.resource = resource;
58	}
59
60	/*
61	* Create a marker from the marker description.
62	*/
63	protected IMarker createMarker() throws CoreException {
64	IMarker marker = resource.createMarker(type);
65	marker.setAttributes(attributes);
66	return marker;
67	}
68
69	/*
70	* Update an existing marker using the attributes in the marker description.
71	*/
72	protected void updateMarker(IMarker marker) throws CoreException {
73	marker.setAttributes(attributes);
74	}
75	}

Lines 21-26 Link Here

(-)src/org/eclipse/ui/ide/undo/AbstractMarkersOperation.java (-2 / +3 lines)
21	import org.eclipse.core.runtime.IProgressMonitor;	21	import org.eclipse.core.runtime.IProgressMonitor;
22	import org.eclipse.core.runtime.IStatus;	22	import org.eclipse.core.runtime.IStatus;
23	import org.eclipse.core.runtime.Status;	23	import org.eclipse.core.runtime.Status;
		24	import org.eclipse.ui.internal.ide.undo.MarkerDescription;
24	import org.eclipse.ui.internal.ide.undo.UndoMessages;	25	import org.eclipse.ui.internal.ide.undo.UndoMessages;
25		26
26	/**	27	/**
Lines 183-189 Link Here
183	if (markerDescriptions != null) {	184	if (markerDescriptions != null) {
184	resources = new IResource[markerDescriptions.length];	185	resources = new IResource[markerDescriptions.length];
185	for (int i = 0; i < markerDescriptions.length; i++) {	186	for (int i = 0; i < markerDescriptions.length; i++) {
186	resources[i] = markerDescriptions[i].resource;	187	resources[i] = markerDescriptions[i].getResource();
187	}	188	}
188	}	189	}
189	} else {	190	} else {
Lines 212-218 Link Here
212	if (markerDescriptions != null) {	213	if (markerDescriptions != null) {
213	types = new String[markerDescriptions.length];	214	types = new String[markerDescriptions.length];
214	for (int i = 0; i < markerDescriptions.length; i++) {	215	for (int i = 0; i < markerDescriptions.length; i++) {
215	types[i] = markerDescriptions[i].type;	216	types[i] = markerDescriptions[i].getType();
216	}	217	}
217	}	218	}
218	} else {	219	} else {

Lines 59-69 Link Here

(-)src/org/eclipse/ui/ide/undo/AbstractWorkspaceOperation.java (-84 / +174 lines)
59		59
60	private static String ELLIPSIS = "..."; //$NON-NLS-1$	60	private static String ELLIPSIS = "..."; //$NON-NLS-1$
61		61
62	private static int EXECUTE = 1;	62	protected static int EXECUTE = 1;
63		63
64	private static int UNDO = 2;	64	protected static int UNDO = 2;
65		65
66	private static int REDO = 3;	66	protected static int REDO = 3;
67		67
68	protected IResource[] resources;	68	protected IResource[] resources;
69		69
Lines 71-76 Link Here
71		71
72	String[] modelProviderIds;	72	String[] modelProviderIds;
73		73
		74	/*
		75	* Return the shell described by the specified adaptable, or the active
		76	* shell if no shell has been specified in the adaptable.
		77	*/
		78	protected static Shell getShell(IAdaptable info) {
		79	if (info != null) {
		80	Shell shell = (Shell) info.getAdapter(Shell.class);
		81	if (shell != null) {
		82	return shell;
		83	}
		84	}
		85	return PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
		86	}
		87
74	/**	88	/**
75	* Create an AbstractWorkspaceOperation with the specified name.	89	* Create an AbstractWorkspaceOperation with the specified name.
76	*	90	*
Lines 137-143 Link Here
137	public boolean canExecute() {	151	public boolean canExecute() {
138	return isValid();	152	return isValid();
139	}	153	}
140		154
141	/*	155	/*
142	* (non-Javadoc)	156	* (non-Javadoc)
143	*	157	*
Lines 173-197 Link Here
173	public void run(IProgressMonitor monitor) throws CoreException {	187	public void run(IProgressMonitor monitor) throws CoreException {
174	doExecute(monitor, info);	188	doExecute(monitor, info);
175	}	189	}
176	}, null);	190	}, null, IWorkspace.AVOID_UPDATE, null);
177	} catch (final CoreException e) {	191	} catch (final CoreException e) {
		192	final boolean[] propagateException = new boolean[1];
178	getShell(info).getDisplay().syncExec(new Runnable() {	193	getShell(info).getDisplay().syncExec(new Runnable() {
179	public void run() {	194	public void run() {
180	ErrorDialog	195	propagateException[0] = handleCoreException(
181	.openError(	196	e,
182	getShell(info),	197	getShell(info),
183	NLS	198	NLS
184	.bind(	199	.bind(
185	UndoMessages.AbstractWorkspaceOperation_ExecuteErrorTitle,	200	UndoMessages.AbstractWorkspaceOperation_ExecuteErrorTitle,
186	getLabel()), null, e	201	getLabel()));
187	.getStatus());
188		202
189	}	203	}
190		204
191	});	205	});
192	throw new ExecutionException(NLS.bind(	206	if (propagateException[0]) {
193	UndoMessages.AbstractWorkspaceOperation_ExecuteErrorTitle,	207	throw new ExecutionException(
194	getLabel()), e);	208	NLS
		209	.bind(
		210	UndoMessages.AbstractWorkspaceOperation_ExecuteErrorTitle,
		211	getLabel()), e);
		212	}
195	}	213	}
196	isValid = true;	214	isValid = true;
197	return Status.OK_STATUS;	215	return Status.OK_STATUS;
Lines 215-237 Link Here
215	}	233	}
216	}, null);	234	}, null);
217	} catch (final CoreException e) {	235	} catch (final CoreException e) {
		236	final boolean[] propagateException = new boolean[1];
218	getShell(info).getDisplay().syncExec(new Runnable() {	237	getShell(info).getDisplay().syncExec(new Runnable() {
219	public void run() {	238	public void run() {
220	ErrorDialog	239	propagateException[0] = handleCoreException(
221	.openError(	240	e,
222	getShell(info),	241	getShell(info),
223	NLS	242	NLS
224	.bind(	243	.bind(
225	UndoMessages.AbstractWorkspaceOperation_RedoErrorTitle,	244	UndoMessages.AbstractWorkspaceOperation_RedoErrorTitle,
226	getLabel()), null, e	245	getLabel()));
227	.getStatus());
228
229	}	246	}
230		247
231	});	248	});
232	throw new ExecutionException(NLS.bind(	249	if (propagateException[0]) {
233	UndoMessages.AbstractWorkspaceOperation_RedoErrorTitle,	250	throw new ExecutionException(NLS.bind(
234	getLabel()), e);	251	UndoMessages.AbstractWorkspaceOperation_RedoErrorTitle,
		252	getLabel()), e);
		253	}
235	}	254	}
236	isValid = true;	255	isValid = true;
237	return Status.OK_STATUS;	256	return Status.OK_STATUS;
Lines 255-277 Link Here
255	}	274	}
256	}, null);	275	}, null);
257	} catch (final CoreException e) {	276	} catch (final CoreException e) {
		277	final boolean[] propagateException = new boolean[1];
258	getShell(info).getDisplay().syncExec(new Runnable() {	278	getShell(info).getDisplay().syncExec(new Runnable() {
259	public void run() {	279	public void run() {
260	ErrorDialog	280	propagateException[0] = handleCoreException(
261	.openError(	281	e,
262	getShell(info),	282	getShell(info),
263	NLS	283	NLS
264	.bind(	284	.bind(
265	UndoMessages.AbstractWorkspaceOperation_UndoErrorTitle,	285	UndoMessages.AbstractWorkspaceOperation_UndoErrorTitle,
266	getLabel()), null, e	286	getLabel()));
267	.getStatus());
268		287
269	}	288	}
270		289
271	});	290	});
272	throw new ExecutionException(NLS.bind(	291	if (propagateException[0]) {
273	UndoMessages.AbstractWorkspaceOperation_UndoErrorTitle,	292	throw new ExecutionException(NLS.bind(
274	getLabel()), e);	293	UndoMessages.AbstractWorkspaceOperation_UndoErrorTitle,
		294	getLabel()), e);
		295	}
275	}	296	}
276	isValid = true;	297	isValid = true;
277	return Status.OK_STATUS;	298	return Status.OK_STATUS;
Lines 289-313 Link Here
289	protected abstract void doExecute(IProgressMonitor monitor, IAdaptable info)	310	protected abstract void doExecute(IProgressMonitor monitor, IAdaptable info)
290	throws CoreException;	311	throws CoreException;
291		312
292	/*
293	* Return the shell described by the specified adaptable, or the active
294	* shell if no shell has been specified in the adaptable.
295	*/
296	protected Shell getShell(IAdaptable info) {
297	if (info != null) {
298	Shell shell = (Shell) info.getAdapter(Shell.class);
299	if (shell != null) {
300	return shell;
301	}
302	}
303	return PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
304	}
305
306	/**	313	/**
307	* Return whether the proposed operation is valid. The default	314	* Return whether the proposed operation is valid. The default
308	* implementation simply checks to see if the flag has been marked as	315	* implementation simply checks to see if the flag has been marked as
309	* invalid, relying on subclasses to mark the flag invalid when	316	* invalid, relying on subclasses to mark the flag invalid when appropriate.
310	* appropriate.
311	*	317	*
312	*/	318	*/
313	protected boolean isValid() {	319	protected boolean isValid() {
Lines 331-348 Link Here
331	public Object[] getAffectedObjects() {	337	public Object[] getAffectedObjects() {
332	return resources;	338	return resources;
333	}	339	}
334		340
335	/*	341	/*
336	* Return a status indicating the projected outcome of executing the receiver.	342	* Return a status indicating the projected outcome of executing the
337	*	343	* receiver. This method is not called by the operation history, but instead
338	* This method computes the validity of execution by computing the resource	344	* is used by clients (such as implementers of {@link IOperationApprover2})
339	* delta that would be generated on execution, and checking whether any	345	* who wish to perform advanced validation of an operation before attempting
340	* registered model providers are affected by the operation. This method is	346	* to execute it.
341	* not called by the operation history, but instead is used by clients (such	347	*
342	* as implementers of {@link IOperationApprover2}) who wish to perform	348	* If an ERROR status is returned, the operation will not proceed and the
343	* advanced validation of an operation before attempting to execute it. If the	349	* user notified if deemed necessary by the caller. The validity flag on the
344	* execute is not valid, then the validity flag on the operation should be	350	* operation should be marked as invalid. If an OK status is returned, the
345	* marked invalid.	351	* operation will proceed. The caller must interpret any other returned
		352	* status severity, and may choose to prompt the user as to how to proceed.
		353	*
		354	* If there are multiple conditions that result in an ambiguous status
		355	* severity, it is best for the implementor of this method to consult the
		356	* user as to how to proceed for each one, and return an OK or ERROR status
		357	* that accurately reflects the user's wishes, or to return a multi-status
		358	* that accurately describes all of the issues at hand, so that the caller
		359	* may potentially consult the user.
		360	*
		361	* This implementation computes the validity of execution by computing the
		362	* resource delta that would be generated on execution, and checking whether
		363	* any registered model providers are affected by the operation.
346	*	364	*
347	* @see org.eclipse.core.commands.operations.IAdvancedUndoableOperation#computeUndoableStatus(org.eclipse.core.runtime.IProgressMonitor)	365	* @see org.eclipse.core.commands.operations.IAdvancedUndoableOperation#computeUndoableStatus(org.eclipse.core.runtime.IProgressMonitor)
348	*/	366	*/
Lines 371-385 Link Here
371		389
372	/*	390	/*
373	* Return a status indicating the projected outcome of undoing the receiver.	391	* Return a status indicating the projected outcome of undoing the receiver.
374	*	392	* This method is not called by the operation history, but instead is used
375	* This method computes the validity of an undo by computing the resource	393	* by clients (such as implementers of {@link IOperationApprover2}) who
376	* delta that would be generated on undo, and checking whether any	394	* wish to perform advanced validation of an operation before attempting to
377	* registered model providers are affected by the operation. This method is	395	* undo it.
378	* not called by the operation history, but instead is used by clients (such	396	*
379	* as implementers of {@link IOperationApprover}) who wish to perform	397	* If an ERROR status is returned, the undo will not proceed and the user
380	* advanced validation of an operation before attempting to undo it. If the	398	* notified if deemed necessary by the caller. The validity flag on the
381	* undo is not valid, then the validity flag on the operation should be	399	* operation should be marked as invalid. If an OK status is returned, the
382	* marked invalid.	400	* undo will proceed. The caller must interpret any other returned status
		401	* severity, and may choose to prompt the user as to how to proceed.
		402	*
		403	* If there are multiple conditions that result in an ambiguous status
		404	* severity, it is best for the implementor of this method to consult the
		405	* user as to how to proceed for each one, and return an OK or ERROR status
		406	* that accurately reflects the user's wishes, or to return a multi-status
		407	* that accurately describes all of the issues at hand, so that the caller
		408	* may potentially consult the user.
		409	*
		410	* This implementation computes the validity of undo by computing the
		411	* resource delta that would be generated on undo, and checking whether any
		412	* registered model providers are affected by the operation. *
383	*	413	*
384	* @see org.eclipse.core.commands.operations.IAdvancedUndoableOperation#computeUndoableStatus(org.eclipse.core.runtime.IProgressMonitor)	414	* @see org.eclipse.core.commands.operations.IAdvancedUndoableOperation#computeUndoableStatus(org.eclipse.core.runtime.IProgressMonitor)
385	*/	415	*/
Lines 408-422 Link Here
408		438
409	/*	439	/*
410	* Return a status indicating the projected outcome of redoing the receiver.	440	* Return a status indicating the projected outcome of redoing the receiver.
411	*	441	* This method is not called by the operation history, but instead is used
412	* This method computes the validity of a redo by computing the resource	442	* by clients (such as implementers of {@link IOperationApprover2}) who
413	* delta that would be generated on redo, and checking whether any	443	* wish to perform advanced validation of an operation before attempting to
414	* registered model providers are affected by the operation. This method is	444	* redo it.
415	* not called by the operation history, but instead is used by clients (such	445	*
416	* as implementers of {@link IOperationApprover}) who wish to perform	446	* If an ERROR status is returned, the redo will not proceed and the user
417	* advanced validation of an operation before attempting to redo it. If the	447	* notified if deemed necessary by the caller. The validity flag on the
418	* redo is not valid, then the validity flag on the operation should be	448	* operation should be marked as invalid. If an OK status is returned, the
419	* marked invalid.	449	* redo will proceed. The caller must interpret any other returned status
		450	* severity, and may choose to prompt the user as to how to proceed.
		451	*
		452	* If there are multiple conditions that result in an ambiguous status
		453	* severity, it is best for the implementor of this method to consult the
		454	* user as to how to proceed for each one, and return an OK or ERROR status
		455	* that accurately reflects the user's wishes, or to return a multi-status
		456	* that accurately describes all of the issues at hand, so that the caller
		457	* may potentially consult the user.
		458	*
		459	* This implementation computes the validity of redo by computing the
		460	* resource delta that would be generated on redo, and checking whether any
		461	* registered model providers are affected by the operation.
420	*	462	*
421	* @see org.eclipse.core.commands.operations.IAdvancedUndoableOperation#computeUndoableStatus(org.eclipse.core.runtime.IProgressMonitor)	463	* @see org.eclipse.core.commands.operations.IAdvancedUndoableOperation#computeUndoableStatus(org.eclipse.core.runtime.IProgressMonitor)
422	*/	464	*/
Lines 512-515 Link Here
512	}	554	}
513	return true;	555	return true;
514	}	556	}
		557
		558	/**
		559	* Return whether the resources known by this operation contain any
		560	* projects.
		561	*
		562	* @return <code>true</code> if there is one or more projects known by
		563	* this operation and false if there are no projects.
		564	*/
		565	protected boolean resourcesIncludesProjects() {
		566	if (resources == null \|\| resources.length == 0) {
		567	return false;
		568	}
		569	for (int i = 0; i < resources.length; i++) {
		570	if (resources[i].getType() == IResource.PROJECT) {
		571	return true;
		572	}
		573	}
		574	return false;
		575	}
		576
		577	/**
		578	* Handle the core exception that occurred while trying to execute, undo, or
		579	* redo the operation, returning a boolean to indicate whether this
		580	* exception should cuase a {@link ExecutionException} to be thrown.
		581	*
		582	* It is safe to access UI in this method. The default implementation is to
		583	* show an error dialog, but callers may choose to swallow certain
		584	* exceptions or show them differently.
		585	*
		586	* If the only difference in handling the exception is to show a different
		587	* error message, callers should override
		588	* {@link #getErrorMessage(CoreException)} instead.
		589	*/
		590	protected boolean handleCoreException(CoreException e, Shell shell,
		591	String errorTitle) {
		592	ErrorDialog.openError(shell, errorTitle, getErrorMessage(e), e
		593	.getStatus());
		594	return true;
		595	}
		596
		597	/**
		598	* Return the specific error message to use when the specified core
		599	* exception occurs, or <code>null</code> to indicate that the the
		600	* exception's message should be used.
		601	*/
		602	protected String getErrorMessage(CoreException e) {
		603	return null;
		604	}
515	}	605	}

Lines 10-34 Link Here

(-)extensions/org/eclipse/ui/actions/DeleteResourceAction.java (-210 / +23 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.ui.actions;	11	package org.eclipse.ui.actions;
12		12
13	import java.util.ArrayList;
14	import java.util.List;	13	import java.util.List;
15		14
		15	import org.eclipse.core.commands.ExecutionException;
16	import org.eclipse.core.resources.IProject;	16	import org.eclipse.core.resources.IProject;
17	import org.eclipse.core.resources.IResource;	17	import org.eclipse.core.resources.IResource;
18	import org.eclipse.core.resources.IResourceRuleFactory;	18	import org.eclipse.core.resources.IResourceRuleFactory;
19	import org.eclipse.core.resources.IResourceStatus;
20	import org.eclipse.core.resources.IWorkspace;
21	import org.eclipse.core.resources.IWorkspaceRunnable;
22	import org.eclipse.core.resources.ResourcesPlugin;	19	import org.eclipse.core.resources.ResourcesPlugin;
23	import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;	20	import org.eclipse.core.runtime.IAdaptable;
24	import org.eclipse.core.resources.mapping.ResourceChangeValidator;
25	import org.eclipse.core.runtime.CoreException;
26	import org.eclipse.core.runtime.IProgressMonitor;	21	import org.eclipse.core.runtime.IProgressMonitor;
27	import org.eclipse.core.runtime.IStatus;	22	import org.eclipse.core.runtime.IStatus;
28	import org.eclipse.core.runtime.MultiStatus;
29	import org.eclipse.core.runtime.OperationCanceledException;
30	import org.eclipse.core.runtime.Status;	23	import org.eclipse.core.runtime.Status;
31	import org.eclipse.core.runtime.SubProgressMonitor;
32	import org.eclipse.core.runtime.jobs.ISchedulingRule;	24	import org.eclipse.core.runtime.jobs.ISchedulingRule;
33	import org.eclipse.core.runtime.jobs.Job;	25	import org.eclipse.core.runtime.jobs.Job;
34	import org.eclipse.core.runtime.jobs.MultiRule;	26	import org.eclipse.core.runtime.jobs.MultiRule;
Lines 47-53 Link Here
47	import org.eclipse.swt.widgets.Control;	39	import org.eclipse.swt.widgets.Control;
48	import org.eclipse.swt.widgets.Shell;	40	import org.eclipse.swt.widgets.Shell;
49	import org.eclipse.ui.PlatformUI;	41	import org.eclipse.ui.PlatformUI;
50	import org.eclipse.ui.ide.IDE;	42	import org.eclipse.ui.ide.undo.DeleteResourcesOperation;
51	import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;	43	import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
52	import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;	44	import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
53	import org.eclipse.ui.internal.ide.IIDEHelpContextIds;	45	import org.eclipse.ui.internal.ide.IIDEHelpContextIds;
Lines 207-217 Link Here
207	private boolean deleteContent = false;	199	private boolean deleteContent = false;
208		200
209	/**	201	/**
210	* Whether or not to automatically delete out of sync resources
211	*/
212	private boolean forceOutOfSyncDelete = false;
213
214	/**
215	* Flag that allows testing mode ... it won't pop up the project delete	202	* Flag that allows testing mode ... it won't pop up the project delete
216	* dialog, and will return "delete all content".	203	* dialog, and will return "delete all content".
217	*/	204	*/
Lines 317-360 Link Here
317	}	304	}
318		305
319	/**	306	/**
320	* Creates and returns a result status appropriate for the given list of
321	* exceptions.
322	*
323	* @param exceptions
324	* The list of exceptions that occurred (may be empty)
325	* @return The result status for the deletion
326	*/
327	private IStatus createResult(List exceptions) {
328	if (exceptions.isEmpty()) {
329	return Status.OK_STATUS;
330	}
331	final int exceptionCount = exceptions.size();
332	if (exceptionCount == 1) {
333	return ((CoreException) exceptions.get(0)).getStatus();
334	}
335	CoreException[] children = (CoreException[]) exceptions
336	.toArray(new CoreException[exceptionCount]);
337	boolean outOfSync = false;
338	for (int i = 0; i < children.length; i++) {
339	if (children[i].getStatus().getCode() == IResourceStatus.OUT_OF_SYNC_LOCAL) {
340	outOfSync = true;
341	break;
342	}
343	}
344	String title = outOfSync ? IDEWorkbenchMessages.DeleteResourceAction_outOfSyncError
345	: IDEWorkbenchMessages.DeleteResourceAction_deletionExceptionMessage;
346	final MultiStatus multi = new MultiStatus(
347	IDEWorkbenchPlugin.IDE_WORKBENCH, 0, title, null);
348	for (int i = 0; i < exceptionCount; i++) {
349	CoreException exception = children[i];
350	IStatus status = exception.getStatus();
351	multi.add(new Status(status.getSeverity(), status.getPlugin(),
352	status.getCode(), status.getMessage(), exception));
353	}
354	return multi;
355	}
356
357	/**
358	* Asks the user to confirm a delete operation.	307	* Asks the user to confirm a delete operation.
359	*	308	*
360	* @param resources	309	* @param resources
Lines 363-375 Link Here
363	* <code>false</code> if the deletion should be abandoned	312	* <code>false</code> if the deletion should be abandoned
364	*/	313	*/
365	private boolean confirmDelete(IResource[] resources) {	314	private boolean confirmDelete(IResource[] resources) {
366	if (validateDelete(resources)) {	315	if (containsOnlyProjects(resources)) {
367	if (containsOnlyProjects(resources)) {	316	return confirmDeleteProjects(resources);
368	return confirmDeleteProjects(resources);
369	}
370	return confirmDeleteNonProjects(resources);
371	}	317	}
372	return false;	318	return confirmDeleteNonProjects(resources);
		319
373	}	320	}
374		321
375	/**	322	/**
Lines 430-511 Link Here
430	return code == 0; // YES	377	return code == 0; // YES
431	}	378	}
432		379
433	/**
434	* Deletes the given resources.
435	*/
436	private void delete(IResource[] resourcesToDelete, IProgressMonitor monitor)
437	throws CoreException {
438	final List exceptions = new ArrayList();
439	forceOutOfSyncDelete = false;
440	monitor.beginTask("", resourcesToDelete.length); //$NON-NLS-1$
441	try {
442	for (int i = 0; i < resourcesToDelete.length; ++i) {
443	if (monitor.isCanceled()) {
444	throw new OperationCanceledException();
445	}
446	try {
447	delete(resourcesToDelete[i], new SubProgressMonitor(
448	monitor, 1,
449	SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK));
450	} catch (CoreException e) {
451	exceptions.add(e);
452	}
453	}
454	IStatus result = createResult(exceptions);
455	if (!result.isOK()) {
456	throw new CoreException(result);
457	}
458	} finally {
459	monitor.done();
460	}
461	}
462		380
463	/**	381
464	* Deletes the given resource.
465	*/
466	private void delete(IResource resourceToDelete, IProgressMonitor monitor)
467	throws CoreException {
468	boolean force = false; // don't force deletion of out-of-sync resources
469	try {
470	if (resourceToDelete.getType() == IResource.PROJECT) {
471	// if it's a project, ask whether content should be deleted too
472	IProject project = (IProject) resourceToDelete;
473	project.delete(deleteContent, force, monitor);
474	} else {
475	// if it's not a project, just delete it
476	resourceToDelete.delete(IResource.KEEP_HISTORY, monitor);
477	}
478	} catch (CoreException exception) {
479	if (resourceToDelete.getType() == IResource.FILE) {
480	IStatus[] children = exception.getStatus().getChildren();
481
482	if (children.length == 1
483	&& children[0].getCode() == IResourceStatus.OUT_OF_SYNC_LOCAL) {
484	if (forceOutOfSyncDelete) {
485	resourceToDelete.delete(IResource.KEEP_HISTORY
486	\| IResource.FORCE, monitor);
487	} else {
488	int result = queryDeleteOutOfSync(resourceToDelete);
489
490	if (result == IDialogConstants.YES_ID) {
491	resourceToDelete.delete(IResource.KEEP_HISTORY
492	\| IResource.FORCE, monitor);
493	} else if (result == IDialogConstants.YES_TO_ALL_ID) {
494	forceOutOfSyncDelete = true;
495	resourceToDelete.delete(IResource.KEEP_HISTORY
496	\| IResource.FORCE, monitor);
497	} else if (result == IDialogConstants.CANCEL_ID) {
498	throw new OperationCanceledException();
499	}
500	}
501	} else {
502	throw exception;
503	}
504	} else {
505	throw exception;
506	}
507	}
508	}
509		382
510	/**	383	/**
511	* Return an array of the currently selected resources.	384	* Return an array of the currently selected resources.
Lines 593-609 Link Here
593	IDEWorkbenchMessages.DeleteResourceAction_jobName) {	466	IDEWorkbenchMessages.DeleteResourceAction_jobName) {
594	public IStatus run(IProgressMonitor monitor) {	467	public IStatus run(IProgressMonitor monitor) {
595	try {	468	try {
596	ResourcesPlugin.getWorkspace().run(	469	DeleteResourcesOperation op =
597	new IWorkspaceRunnable() {	470	new DeleteResourcesOperation(resourcesToDelete, getText(), deleteContent);
598	public void run(IProgressMonitor monitor)	471	op.setModelProviderIds(getModelProviderIds());
599	throws CoreException {	472	return PlatformUI.getWorkbench().getOperationSupport()
600	delete(resourcesToDelete, monitor);	473	.getOperationHistory().execute(op, monitor, new IAdaptable() {
601	}	474	public Object getAdapter(Class clazz) {
602	}, null, IWorkspace.AVOID_UPDATE, monitor);	475	if (clazz == Shell.class) {
603	} catch (CoreException e) {	476	return shell;
604	return e.getStatus();	477	}
		478	return null;
		479	}
		480	});
		481	} catch (ExecutionException e) {
		482	IDEWorkbenchPlugin.log(e.getMessage(), e);
		483	return new Status(IStatus.ERROR, IDEWorkbenchPlugin.IDE_WORKBENCH, e.getMessage(),e);
605	}	484	}
606	return Status.OK_STATUS;
607	}	485	}
608		486
609	/*	487	/*
Lines 678-748 Link Here
678	}	556	}
679		557
680	/**	558	/**
681	* Ask the user whether the given resource should be deleted despite being
682	* out of sync with the file system.
683	*
684	* @param resource
685	* the out of sync resource
686	* @return One of the IDialogConstants constants indicating which of the
687	* Yes, Yes to All, No, Cancel options has been selected by the
688	* user.
689	*/
690	private int queryDeleteOutOfSync(IResource resource) {
691	final MessageDialog dialog = new MessageDialog(
692	shell,
693	IDEWorkbenchMessages.DeleteResourceAction_messageTitle,
694	null,
695	NLS
696	.bind(
697	IDEWorkbenchMessages.DeleteResourceAction_outOfSyncQuestion,
698	resource.getName()), MessageDialog.QUESTION,
699	new String[] { IDialogConstants.YES_LABEL,
700	IDialogConstants.YES_TO_ALL_LABEL,
701	IDialogConstants.NO_LABEL,
702	IDialogConstants.CANCEL_LABEL }, 0);
703	shell.getDisplay().syncExec(new Runnable() {
704	public void run() {
705	dialog.open();
706	}
707	});
708	int result = dialog.getReturnCode();
709	if (result == 0) {
710	return IDialogConstants.YES_ID;
711	}
712	if (result == 1) {
713	return IDialogConstants.YES_TO_ALL_ID;
714	}
715	if (result == 2) {
716	return IDialogConstants.NO_ID;
717	}
718	return IDialogConstants.CANCEL_ID;
719	}
720
721	/**
722	* Validates the operation against the model providers.
723	*
724	* @param resources
725	* the resources to be deleted
726	* @return whether the operation should proceed
727	*/
728	private boolean validateDelete(IResource[] resources) {
729	IResourceChangeDescriptionFactory factory = ResourceChangeValidator
730	.getValidator().createDeltaFactory();
731	for (int i = 0; i < resources.length; i++) {
732	IResource resource = resources[i];
733	factory.delete(resource);
734	}
735	return IDE.promptToConfirm(shell,
736	IDEWorkbenchMessages.DeleteResourceAction_confirm,
737	IDEWorkbenchMessages.DeleteResourceAction_warning, factory
738	.getDelta(), getModelProviderIds(), false /*
739	* no need
740	* to
741	* syncExec
742	*/);
743	}
744
745	/**
746	* Returns the model provider ids that are known to the client that	559	* Returns the model provider ids that are known to the client that
747	* instantiated this operation.	560	* instantiated this operation.
748	*	561	*

Lines 12-39 Link Here

(-)extensions/org/eclipse/ui/actions/CopyProjectOperation.java (-72 / +27 lines)
12		12
13	import java.lang.reflect.InvocationTargetException;	13	import java.lang.reflect.InvocationTargetException;
14		14
		15	import org.eclipse.core.commands.ExecutionException;
15	import org.eclipse.core.resources.IProject;	16	import org.eclipse.core.resources.IProject;
16	import org.eclipse.core.resources.IProjectDescription;
17	import org.eclipse.core.resources.IResource;
18	import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;	17	import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
19	import org.eclipse.core.resources.mapping.ResourceChangeValidator;	18	import org.eclipse.core.resources.mapping.ResourceChangeValidator;
20	import org.eclipse.core.runtime.CoreException;	19	import org.eclipse.core.runtime.IAdaptable;
21	import org.eclipse.core.runtime.IPath;	20	import org.eclipse.core.runtime.IPath;
22	import org.eclipse.core.runtime.IProgressMonitor;	21	import org.eclipse.core.runtime.IProgressMonitor;
23	import org.eclipse.core.runtime.IStatus;
24	import org.eclipse.core.runtime.MultiStatus;	22	import org.eclipse.core.runtime.MultiStatus;
25	import org.eclipse.core.runtime.OperationCanceledException;
26	import org.eclipse.core.runtime.Path;	23	import org.eclipse.core.runtime.Path;
27	import org.eclipse.core.runtime.Platform;
28	import org.eclipse.jface.dialogs.ErrorDialog;	24	import org.eclipse.jface.dialogs.ErrorDialog;
29	import org.eclipse.jface.dialogs.MessageDialog;	25	import org.eclipse.jface.dialogs.MessageDialog;
		26	import org.eclipse.jface.operation.IRunnableWithProgress;
30	import org.eclipse.jface.window.Window;	27	import org.eclipse.jface.window.Window;
31	import org.eclipse.osgi.util.NLS;	28	import org.eclipse.osgi.util.NLS;
32	import org.eclipse.swt.widgets.Shell;	29	import org.eclipse.swt.widgets.Shell;
33	import org.eclipse.ui.PlatformUI;	30	import org.eclipse.ui.PlatformUI;
34	import org.eclipse.ui.dialogs.ProjectLocationSelectionDialog;	31	import org.eclipse.ui.dialogs.ProjectLocationSelectionDialog;
35	import org.eclipse.ui.ide.IDE;	32	import org.eclipse.ui.ide.IDE;
		33	import org.eclipse.ui.ide.undo.CopyResourcesOperation;
36	import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;	34	import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
		35	import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
37	import org.eclipse.ui.internal.progress.ProgressMonitorJobsDialog;	36	import org.eclipse.ui.internal.progress.ProgressMonitorJobsDialog;
38		37
39	/**	38	/**
Lines 68-73 Link Here
68	* (and can hence be ignored)	67	* (and can hence be ignored)
69	* @return whether the operation should proceed	68	* @return whether the operation should proceed
70	* @since 3.2	69	* @since 3.2
		70	* @deprecated As of 3.3, validation is performed in the undoable operation
		71	* executed by this operation.
71	*/	72	*/
72	protected static boolean validateCopy(Shell shell, IProject project, String newName, String[] modelProviderIds) {	73	protected static boolean validateCopy(Shell shell, IProject project, String newName, String[] modelProviderIds) {
73	IResourceChangeDescriptionFactory factory = ResourceChangeValidator.getValidator().createDeltaFactory();	74	IResourceChangeDescriptionFactory factory = ResourceChangeValidator.getValidator().createDeltaFactory();
Lines 106-115 Link Here
106		107
107	String newName = (String) destinationPaths[0];	108	String newName = (String) destinationPaths[0];
108	IPath newLocation = new Path((String) destinationPaths[1]);	109	IPath newLocation = new Path((String) destinationPaths[1]);
109
110	if (!validateCopy(parentShell, project, newName, getModelProviderIds())) {
111	return;
112	}
113		110
114	boolean completed = performProjectCopy(project, newName, newLocation);	111	boolean completed = performProjectCopy(project, newName, newLocation);
115		112
Lines 136-158 Link Here
136	*/	133	*/
137	private boolean performProjectCopy(final IProject project,	134	private boolean performProjectCopy(final IProject project,
138	final String projectName, final IPath newLocation) {	135	final String projectName, final IPath newLocation) {
139	WorkspaceModifyOperation op = new WorkspaceModifyOperation() {	136	IRunnableWithProgress op = new IRunnableWithProgress() {
140	public void execute(IProgressMonitor monitor) {	137	public void run(IProgressMonitor monitor) {
141	try {	138	CopyResourcesOperation op = new CopyResourcesOperation(project,
142	if (monitor.isCanceled()) {	139	newLocation.append(projectName),
143	throw new OperationCanceledException();	140	IDEWorkbenchMessages.CopyProjectOperation_copyProject);
144	}	141	op.setModelProviderIds(getModelProviderIds());
145		142	try {
146	monitor.setTaskName(IDEWorkbenchMessages.CopyProjectOperation_progressTitle);	143	PlatformUI.getWorkbench().getOperationSupport()
147		144	.getOperationHistory().execute(op, monitor, new IAdaptable() {
148	//Get a copy of the current description and modify it	145	public Object getAdapter(Class clazz) {
149	IProjectDescription newDescription = createProjectDescription(	146	if (clazz == Shell.class) {
150	project, projectName, newLocation);	147	return parentShell;
151	project.copy(newDescription, IResource.SHALLOW	148	}
152	\| IResource.FORCE, monitor);	149	return null;
153	} catch (CoreException e) {	150	}
154	recordError(e); // log error	151	});
155	}	152	} catch (ExecutionException e) {
		153	// Error message already shown to user by the operation
		154	IDEWorkbenchPlugin.log(e.getMessage(), e);
		155	}
156	}	156	}
157	};	157	};
158		158
Lines 175-225 Link Here
175	}	175	}
176		176
177	/**	177	/**
178	* Create a new IProjectDescription for the copy using the auto-generated
179	* name and path.
180	*
181	* @return IProjectDescription
182	* @param project the source project
183	* @param projectName the name for the new project
184	* @param rootLocation the path the new project will be stored under.
185	* @throws CoreException
186	*/
187	private IProjectDescription createProjectDescription(IProject project,
188	String projectName, IPath rootLocation) throws CoreException {
189	//Get a copy of the current description and modify it
190	IProjectDescription newDescription = project.getDescription();
191	newDescription.setName(projectName);
192
193	//If the location is the default then set the location to null
194	if (rootLocation.equals(Platform.getLocation())) {
195	newDescription.setLocation(null);
196	} else {
197	newDescription.setLocation(rootLocation);
198	}
199
200	return newDescription;
201	}
202
203	/**
204	* Records the core exception to be displayed to the user
205	* once the action is finished.
206	*
207	* @param error a <code>CoreException</code>
208	*/
209	private void recordError(CoreException error) {
210
211	if (errorStatus == null) {
212	errorStatus = new MultiStatus(
213	PlatformUI.PLUGIN_ID,
214	IStatus.ERROR,
215	IDEWorkbenchMessages.CopyProjectOperation_copyFailedMessage,
216	error);
217	}
218
219	errorStatus.merge(error.getStatus());
220	}
221
222	/**
223	* Returns the model provider ids that are known to the client	178	* Returns the model provider ids that are known to the client
224	* that instantiated this operation.	179	* that instantiated this operation.
225	*	180	*

Lines 10-40 Link Here

(-)extensions/org/eclipse/ui/actions/RenameResourceAction.java (-138 / +47 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.ui.actions;	11	package org.eclipse.ui.actions;
12		12
13	import com.ibm.icu.text.MessageFormat;
14	import java.util.ArrayList;	13	import java.util.ArrayList;
15	import java.util.List;	14	import java.util.List;
16		15
17	import org.eclipse.core.resources.IFile;	16	import org.eclipse.core.commands.ExecutionException;
18	import org.eclipse.core.resources.IProject;
19	import org.eclipse.core.resources.IProjectDescription;
20	import org.eclipse.core.resources.IResource;	17	import org.eclipse.core.resources.IResource;
21	import org.eclipse.core.resources.IWorkspace;	18	import org.eclipse.core.resources.IWorkspace;
22	import org.eclipse.core.resources.IWorkspaceRoot;
23	import org.eclipse.core.resources.ResourceAttributes;	19	import org.eclipse.core.resources.ResourceAttributes;
24	import org.eclipse.core.resources.ResourcesPlugin;	20	import org.eclipse.core.runtime.IAdaptable;
25	import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
26	import org.eclipse.core.resources.mapping.ResourceChangeValidator;
27	import org.eclipse.core.runtime.CoreException;
28	import org.eclipse.core.runtime.IPath;	21	import org.eclipse.core.runtime.IPath;
29	import org.eclipse.core.runtime.IProgressMonitor;	22	import org.eclipse.core.runtime.IProgressMonitor;
30	import org.eclipse.core.runtime.IStatus;	23	import org.eclipse.core.runtime.IStatus;
31	import org.eclipse.core.runtime.SubProgressMonitor;
32	import org.eclipse.jface.dialogs.IInputValidator;	24	import org.eclipse.jface.dialogs.IInputValidator;
33	import org.eclipse.jface.dialogs.InputDialog;	25	import org.eclipse.jface.dialogs.InputDialog;
34	import org.eclipse.jface.dialogs.MessageDialog;	26	import org.eclipse.jface.dialogs.MessageDialog;
		27	import org.eclipse.jface.operation.IRunnableWithProgress;
35	import org.eclipse.jface.viewers.IStructuredSelection;	28	import org.eclipse.jface.viewers.IStructuredSelection;
36	import org.eclipse.jface.window.Window;	29	import org.eclipse.jface.window.Window;
37	import org.eclipse.osgi.util.NLS;
38	import org.eclipse.swt.SWT;	30	import org.eclipse.swt.SWT;
39	import org.eclipse.swt.custom.TreeEditor;	31	import org.eclipse.swt.custom.TreeEditor;
40	import org.eclipse.swt.events.FocusAdapter;	32	import org.eclipse.swt.events.FocusAdapter;
Lines 49-59 Link Here
49	import org.eclipse.swt.widgets.Tree;	41	import org.eclipse.swt.widgets.Tree;
50	import org.eclipse.swt.widgets.TreeItem;	42	import org.eclipse.swt.widgets.TreeItem;
51	import org.eclipse.ui.PlatformUI;	43	import org.eclipse.ui.PlatformUI;
52	import org.eclipse.ui.ide.IDE;	44	import org.eclipse.ui.ide.undo.MoveResourcesOperation;
53	import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;	45	import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
54	import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;	46	import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
55	import org.eclipse.ui.internal.ide.IIDEHelpContextIds;	47	import org.eclipse.ui.internal.ide.IIDEHelpContextIds;
56		48
		49	import com.ibm.icu.text.MessageFormat;
		50
57	/**	51	/**
58	* Standard action for renaming the selected resources.	52	* Standard action for renaming the selected resources.
59	* <p>	53	* <p>
Lines 97-108 Link Here
97		91
98	private static final String CHECK_RENAME_MESSAGE = IDEWorkbenchMessages.RenameResourceAction_readOnlyCheck;	92	private static final String CHECK_RENAME_MESSAGE = IDEWorkbenchMessages.RenameResourceAction_readOnlyCheck;
99		93
100	private static String RESOURCE_EXISTS_TITLE = IDEWorkbenchMessages.RenameResourceAction_resourceExists;
101
102	private static String RESOURCE_EXISTS_MESSAGE = IDEWorkbenchMessages.RenameResourceAction_overwriteQuestion;
103
104	private static String RENAMING_MESSAGE = IDEWorkbenchMessages.RenameResourceAction_progressMessage;
105
106	/**	94	/**
107	* Creates a new action. Using this constructor directly will rename using a	95	* Creates a new action. Using this constructor directly will rename using a
108	* dialog rather than the inline editor of a ResourceNavigator.	96	* dialog rather than the inline editor of a ResourceNavigator.
Lines 129-165 Link Here
129	this.treeEditor = new TreeEditor(tree);	117	this.treeEditor = new TreeEditor(tree);
130	}	118	}
131		119
132	/**	120	/**
133	* Check if the user wishes to overwrite the supplied resource
134	* @returns true if there is no collision or delete was successful
135	* @param shell the shell to create the dialog in
136	* @param destination - the resource to be overwritten
137	*/
138	private boolean checkOverwrite(final Shell shell,
139	final IResource destination) {
140
141	final boolean[] result = new boolean[1];
142
143	//Run it inside of a runnable to make sure we get to parent off of the shell as we are not
144	//in the UI thread.
145
146	Runnable query = new Runnable() {
147	public void run() {
148	String pathName = destination.getFullPath().makeRelative()
149	.toString();
150	result[0] = MessageDialog.openQuestion(shell,
151	RESOURCE_EXISTS_TITLE, MessageFormat.format(
152	RESOURCE_EXISTS_MESSAGE,
153	new Object[] { pathName }));
154	}
155
156	};
157
158	shell.getDisplay().syncExec(query);
159	return result[0];
160	}
161
162	/**
163	* Check if the supplied resource is read only or null. If it is then ask the user if they want	121	* Check if the supplied resource is read only or null. If it is then ask the user if they want
164	* to continue. Return true if the resource is not read only or if the user has given	122	* to continue. Return true if the resource is not read only or if the user has given
165	* permission.	123	* permission.
Lines 181-187 Link Here
181		139
182	return true;	140	return true;
183	}	141	}
184
185	Composite createParent() {	142	Composite createParent() {
186	Tree tree = getTree();	143	Tree tree = getTree();
187	Composite result = new Composite(tree, SWT.NONE);	144	Composite result = new Composite(tree, SWT.NONE);
Lines 341-407 Link Here
341		298
342	/* (non-Javadoc)	299	/* (non-Javadoc)
343	* Method declared on WorkspaceAction.	300	* Method declared on WorkspaceAction.
		301	* Since 3.3, this method is not used, but an implementation is still
		302	* provided for compatibility. All work is now done in the operation
		303	* created in createOperation(IStatus[]).
344	*/	304	*/
345	protected void invokeOperation(IResource resource, IProgressMonitor monitor)	305	protected void invokeOperation(IResource resource, IProgressMonitor monitor) {
346	throws CoreException {
347
348	if (!validateMove(resource, newPath)) {
349	return;
350	}
351	monitor.beginTask(RENAMING_MESSAGE, 100);
352	IWorkspaceRoot workspaceRoot = resource.getWorkspace().getRoot();
353
354	IResource newResource = workspaceRoot.findMember(newPath);
355	if (newResource != null) {
356	if (checkOverwrite(getShell(), newResource)) {
357	if (resource.getType() == IResource.FILE
358	&& newResource.getType() == IResource.FILE) {
359	IFile file = (IFile) resource;
360	IFile newFile = (IFile) newResource;
361	if (validateEdit(file, newFile, getShell())) {
362	IProgressMonitor subMonitor = new SubProgressMonitor(
363	monitor, 50);
364	newFile.setContents(file.getContents(),
365	IResource.KEEP_HISTORY, subMonitor);
366	file.delete(IResource.KEEP_HISTORY, subMonitor);
367	}
368	monitor.worked(100);
369	return;
370	}
371	newResource.delete(IResource.KEEP_HISTORY,
372	new SubProgressMonitor(monitor, 50));
373	} else {
374	monitor.worked(100);
375	return;
376	}
377	}
378	if (resource.getType() == IResource.PROJECT) {
379	IProject project = (IProject) resource;
380	IProjectDescription description = project.getDescription();
381	description.setName(newPath.segment(0));
382	project.move(description, IResource.FORCE \| IResource.SHALLOW,
383	monitor);
384	} else {
385	resource.move(newPath, IResource.KEEP_HISTORY \| IResource.SHALLOW,
386	new SubProgressMonitor(monitor, 50));
387	}
388	}	306	}
389		307
390	/**	308	/**
391	* Validates the operation against the model providers.
392	*
393	* @param resource the resource to move
394	* @param path the new path
395	* @return whether the operation should proceed
396	* @since 3.2
397	*/
398	private boolean validateMove(IResource resource, IPath path) {
399	IResourceChangeDescriptionFactory factory = ResourceChangeValidator.getValidator().createDeltaFactory();
400	factory.move(resource, path);
401	return IDE.promptToConfirm(getShell(), IDEWorkbenchMessages.RenameResourceAction_confirm, NLS.bind(IDEWorkbenchMessages.RenameResourceAction_warning, resource.getName()), factory.getDelta(), modelProviderIds, true /* syncExec */);
402	}
403
404	/**
405	* Return the new name to be given to the target resource.	309	* Return the new name to be given to the target resource.
406	*	310	*
407	* @return java.lang.String	311	* @return java.lang.String
Lines 475-481 Link Here
475	if (currentResource == null \|\| !currentResource.exists()) {	379	if (currentResource == null \|\| !currentResource.exists()) {
476	return;	380	return;
477	}	381	}
478	//Do a quick read only and null check	382	//Do a quick read only and null check
479	if (!checkReadOnlyAndNull(currentResource)) {	383	if (!checkReadOnlyAndNull(currentResource)) {
480	return;	384	return;
481	}	385	}
Lines 500-508 Link Here
500	if (!checkReadOnlyAndNull(currentResource)) {	404	if (!checkReadOnlyAndNull(currentResource)) {
501	return;	405	return;
502	}	406	}
503
504	queryNewResourceNameInline(currentResource);	407	queryNewResourceNameInline(currentResource);
505
506	}	408	}
507		409
508	/**	410	/**
Lines 612-644 Link Here
612	textActionHandler = actionHandler;	514	textActionHandler = actionHandler;
613	}	515	}
614		516
615	/**	517
616	* Validates the destination file if it is read-only and additionally
617	* the source file if both are read-only.
618	* Returns true if both files could be made writeable.
619	*
620	* @param source source file
621	* @param destination destination file
622	* @param shell ui context for the validation
623	* @return boolean <code>true</code> both files could be made writeable.
624	* <code>false</code> either one or both files were not made writeable
625	*/
626	boolean validateEdit(IFile source, IFile destination, Shell shell) {
627	if (destination.isReadOnly()) {
628	IWorkspace workspace = ResourcesPlugin.getWorkspace();
629	IStatus status;
630	if (source.isReadOnly()) {
631	status = workspace.validateEdit(new IFile[] { source,
632	destination }, shell);
633	} else {
634	status = workspace.validateEdit(new IFile[] { destination },
635	shell);
636	}
637	return status.isOK();
638	}
639	return true;
640	}
641
642	/**	518	/**
643	* Returns the model provider ids that are known to the client	519	* Returns the model provider ids that are known to the client
644	* that instantiated this operation.	520	* that instantiated this operation.
Lines 663-667 Link Here
663	public void setModelProviderIds(String[] modelProviderIds) {	539	public void setModelProviderIds(String[] modelProviderIds) {
664	this.modelProviderIds = modelProviderIds;	540	this.modelProviderIds = modelProviderIds;
665	}	541	}
666		542
		543	/*
		544	* (non-Javadoc)
		545	* @see org.eclipse.ui.actions.WorkspaceAction#createOperation(org.eclipse.core.runtime.IStatus[])
		546	*
		547	* Overridden to create and execute an undoable operation that
		548	* performs the rename.
		549	* @since 3.3
		550	*/
		551	protected IRunnableWithProgress createOperation(final IStatus [] errorStatus) {
		552	return new IRunnableWithProgress() {
		553	public void run(IProgressMonitor monitor) {
		554	IResource [] resources = (IResource [])getSelectedResources().toArray(new IResource [getSelectedResources().size()]);
		555	// Rename is only valid for a single resource. This has already been validated.
		556	if (resources.length == 1) {
		557	MoveResourcesOperation op = new MoveResourcesOperation(resources[0], newPath, getText());
		558	op.setModelProviderIds(getModelProviderIds());
		559	try {
		560	errorStatus[0] = PlatformUI.getWorkbench().getOperationSupport()
		561	.getOperationHistory().execute(op, monitor, new IAdaptable() {
		562	public Object getAdapter(Class clazz) {
		563	if (clazz == Shell.class) {
		564	return getShell();
		565	}
		566	return null;
		567	}
		568	});
		569	} catch (ExecutionException e) {
		570	IDEWorkbenchPlugin.log(e.getMessage(), e);
		571	}
		572	}
		573	}
		574	};
		575	}
667	}	576	}

Lines 18-23 Link Here

(-)extensions/org/eclipse/ui/actions/CopyFilesAndFoldersOperation.java (-99 / +71 lines)
18	import java.util.Arrays;	18	import java.util.Arrays;
19	import java.util.List;	19	import java.util.List;
20		20
		21	import org.eclipse.core.commands.ExecutionException;
21	import org.eclipse.core.filesystem.EFS;	22	import org.eclipse.core.filesystem.EFS;
22	import org.eclipse.core.filesystem.IFileInfo;	23	import org.eclipse.core.filesystem.IFileInfo;
23	import org.eclipse.core.filesystem.IFileStore;	24	import org.eclipse.core.filesystem.IFileStore;
Lines 30-37 Link Here
30	import org.eclipse.core.resources.IWorkspaceRoot;	31	import org.eclipse.core.resources.IWorkspaceRoot;
31	import org.eclipse.core.resources.ResourcesPlugin;	32	import org.eclipse.core.resources.ResourcesPlugin;
32	import org.eclipse.core.resources.WorkspaceJob;	33	import org.eclipse.core.resources.WorkspaceJob;
33	import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
34	import org.eclipse.core.resources.mapping.ResourceChangeValidator;
35	import org.eclipse.core.runtime.CoreException;	34	import org.eclipse.core.runtime.CoreException;
36	import org.eclipse.core.runtime.IAdaptable;	35	import org.eclipse.core.runtime.IAdaptable;
37	import org.eclipse.core.runtime.IPath;	36	import org.eclipse.core.runtime.IPath;
Lines 47-61 Link Here
47	import org.eclipse.jface.dialogs.IInputValidator;	46	import org.eclipse.jface.dialogs.IInputValidator;
48	import org.eclipse.jface.dialogs.InputDialog;	47	import org.eclipse.jface.dialogs.InputDialog;
49	import org.eclipse.jface.dialogs.MessageDialog;	48	import org.eclipse.jface.dialogs.MessageDialog;
		49	import org.eclipse.jface.operation.IRunnableWithProgress;
50	import org.eclipse.jface.window.Window;	50	import org.eclipse.jface.window.Window;
51	import org.eclipse.osgi.util.NLS;	51	import org.eclipse.osgi.util.NLS;
52	import org.eclipse.swt.SWT;	52	import org.eclipse.swt.SWT;
53	import org.eclipse.swt.widgets.Display;	53	import org.eclipse.swt.widgets.Display;
54	import org.eclipse.swt.widgets.Shell;	54	import org.eclipse.swt.widgets.Shell;
55	import org.eclipse.ui.PlatformUI;	55	import org.eclipse.ui.PlatformUI;
56	import org.eclipse.ui.dialogs.ContainerGenerator;
57	import org.eclipse.ui.dialogs.IOverwriteQuery;	56	import org.eclipse.ui.dialogs.IOverwriteQuery;
58	import org.eclipse.ui.ide.IDE;	57	import org.eclipse.ui.ide.undo.AbstractCopyOrMoveResourcesOperation;
		58	import org.eclipse.ui.ide.undo.CopyResourcesOperation;
59	import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;	59	import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
60	import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;	60	import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
61	import org.eclipse.ui.internal.ide.StatusUtil;	61	import org.eclipse.ui.internal.ide.StatusUtil;
Lines 388-393 Link Here
388	* destination to which resources will be copied	388	* destination to which resources will be copied
389	* @param subMonitor	389	* @param subMonitor
390	* a progress monitor for showing progress and for cancelation	390	* a progress monitor for showing progress and for cancelation
		391	*
		392	* @deprecated As of 3.3, the work is performed in the undoable operation
		393	* created in {@link #performCopy(IResource[], IPath, IProgressMonitor)}
391	*/	394	*/
392	protected void copy(IResource[] resources, IPath destination,	395	protected void copy(IResource[] resources, IPath destination,
393	IProgressMonitor subMonitor) throws CoreException {	396	IProgressMonitor subMonitor) throws CoreException {
Lines 541-568 Link Here
541	return copiedResources[0];	544	return copiedResources[0];
542	}	545	}
543		546
544	if (!validateOperation(resources, destinationPath)) {	547	IRunnableWithProgress op = new IRunnableWithProgress() {
545	return copiedResources[0];	548	public void run(IProgressMonitor monitor) {
546	}	549	copyResources(resources, destinationPath, copiedResources,
547		550	monitor);
548	if (fork) {
549	WorkspaceModifyOperation op = new WorkspaceModifyOperation() {
550	public void execute(IProgressMonitor monitor) {
551	copyResources(resources, destinationPath, copiedResources,
552	monitor);
553	}
554	};
555
556	try {
557	PlatformUI.getWorkbench().getProgressService().run(true, true,
558	op);
559	} catch (InterruptedException e) {
560	return copiedResources[0];
561	} catch (InvocationTargetException e) {
562	display(e);
563	}	551	}
564	} else {	552	};
565	copyResources(resources, destinationPath, copiedResources, monitor);	553
		554	try {
		555	PlatformUI.getWorkbench().getProgressService().run(fork, true,
		556	op);
		557	} catch (InterruptedException e) {
		558	return copiedResources[0];
		559	} catch (InvocationTargetException e) {
		560	display(e);
566	}	561	}
567		562
568	// If errors occurred, open an Error dialog	563	// If errors occurred, open an Error dialog
Lines 570-616 Link Here
570	displayError(errorStatus);	565	displayError(errorStatus);
571	errorStatus = null;	566	errorStatus = null;
572	}	567	}
		568
573	return copiedResources[0];	569	return copiedResources[0];
574	}	570	}
575		571
576	/**	572	/**
577	* Validates the copy or move operation.
578	*
579	* @param resources
580	* the resources being copied or moved
581	* @param destinationPath
582	* the destination of the copy or move
583	* @return whether the operation should proceed
584	* @since 3.2
585	*/
586	private boolean validateOperation(IResource[] resources,
587	IPath destinationPath) {
588	IResourceChangeDescriptionFactory factory = ResourceChangeValidator
589	.getValidator().createDeltaFactory();
590	for (int i = 0; i < resources.length; i++) {
591	IResource resource = resources[i];
592	if (isMove()) {
593	factory.move(resource, destinationPath.append(resource
594	.getName()));
595	} else {
596	factory.copy(resource, destinationPath.append(resource
597	.getName()));
598	}
599	}
600	String title;
601	String message;
602	if (isMove()) {
603	title = IDEWorkbenchMessages.CopyFilesAndFoldersOperation_confirmMove;
604	message = IDEWorkbenchMessages.CopyFilesAndFoldersOperation_warningMove;
605	} else {
606	title = IDEWorkbenchMessages.CopyFilesAndFoldersOperation_confirmCopy;
607	message = IDEWorkbenchMessages.CopyFilesAndFoldersOperation_warningCopy;
608	}
609	return IDE.promptToConfirm(messageShell, title, message, factory
610	.getDelta(), modelProviderIds, true /* syncExec */);
611	}
612
613	/**
614	* Return whether the operation is a move or a copy	573	* Return whether the operation is a move or a copy
615	*	574	*
616	* @return whether the operation is a move or a copy	575	* @return whether the operation is a move or a copy
Lines 1190-1205 Link Here
1190	private boolean performCopy(IResource[] resources, IPath destination,	1149	private boolean performCopy(IResource[] resources, IPath destination,
1191	IProgressMonitor monitor) {	1150	IProgressMonitor monitor) {
1192	try {	1151	try {
1193	ContainerGenerator generator = new ContainerGenerator(destination);	1152	AbstractCopyOrMoveResourcesOperation op = getUndoableCopyOrMoveOperation(
1194	generator.generateContainer(new SubProgressMonitor(monitor, 10));	1153	resources, destination);
1195	IProgressMonitor subMonitor = new SubProgressMonitor(monitor, 75);	1154	op.setModelProviderIds(getModelProviderIds());
1196	copy(resources, destination, subMonitor);	1155	PlatformUI.getWorkbench().getOperationSupport()
1197	} catch (CoreException e) {	1156	.getOperationHistory().execute(op, monitor, new IAdaptable() {
1198	recordError(e); // log error	1157	public Object getAdapter(Class clazz) {
		1158	if (clazz == Shell.class) {
		1159	return messageShell;
		1160	}
		1161	return null;
		1162	}
		1163	});
		1164	} catch (ExecutionException e) {
		1165	IDEWorkbenchPlugin.log(e.getMessage(), e);
1199	return false;	1166	return false;
1200	} finally {	1167	}
1201	monitor.done();
1202	}
1203	return true;	1168	return true;
1204	}	1169	}
1205		1170
Lines 1222-1263 Link Here
1222	private boolean performCopyWithAutoRename(IResource[] resources,	1187	private boolean performCopyWithAutoRename(IResource[] resources,
1223	IPath destination, IProgressMonitor monitor) {	1188	IPath destination, IProgressMonitor monitor) {
1224	IWorkspace workspace = resources[0].getWorkspace();	1189	IWorkspace workspace = resources[0].getWorkspace();
1225		1190	IPath [] destinationPaths = new IPath[resources.length];
1226	try {	1191	try {
1227	ContainerGenerator generator = new ContainerGenerator(destination);
1228	generator.generateContainer(new SubProgressMonitor(monitor, 10));
1229
1230	IProgressMonitor subMonitor = new SubProgressMonitor(monitor, 75);
1231	subMonitor.beginTask(getOperationTitle(), resources.length);
1232
1233	for (int i = 0; i < resources.length; i++) {	1192	for (int i = 0; i < resources.length; i++) {
1234	IResource source = resources[i];	1193	IResource source = resources[i];
1235	IPath destinationPath = destination.append(source.getName());	1194	destinationPaths[i] = destination.append(source.getName());
1236		1195
1237	if (workspace.getRoot().exists(destinationPath)) {	1196	if (workspace.getRoot().exists(destinationPaths[i])) {
1238	destinationPath = getNewNameFor(destinationPath, workspace);	1197	destinationPaths[i] = getNewNameFor(destinationPaths[i], workspace);
1239	}
1240	if (destinationPath != null) {
1241	try {
1242	source.copy(destinationPath, IResource.SHALLOW,
1243	new SubProgressMonitor(subMonitor, 0));
1244	} catch (CoreException e) {
1245	recordError(e); // log error
1246	return false;
1247	}
1248	}
1249	subMonitor.worked(1);
1250	if (subMonitor.isCanceled()) {
1251	throw new OperationCanceledException();
1252	}	1198	}
1253	}	1199	}
1254	} catch (CoreException e) {	1200	CopyResourcesOperation op = new CopyResourcesOperation(resources, destinationPaths,
1255	recordError(e); // log error	1201	IDEWorkbenchMessages.CopyFilesAndFoldersOperation_copyTitle);
		1202	op.setModelProviderIds(getModelProviderIds());
		1203	PlatformUI.getWorkbench().getOperationSupport()
		1204	.getOperationHistory().execute(op, monitor, new IAdaptable() {
		1205	public Object getAdapter(Class clazz) {
		1206	if (clazz == Shell.class) {
		1207	return messageShell;
		1208	}
		1209	return null;
		1210	}
		1211	});
		1212	} catch (ExecutionException e) {
		1213	IDEWorkbenchPlugin.log(e.getMessage(), e);
1256	return false;	1214	return false;
1257	} finally {
1258	monitor.done();
1259	}	1215	}
1260
1261	return true;	1216	return true;
1262	}	1217	}
1263		1218
Lines 1744-1747 Link Here
1744	public void setModelProviderIds(String[] modelProviderIds) {	1699	public void setModelProviderIds(String[] modelProviderIds) {
1745	this.modelProviderIds = modelProviderIds;	1700	this.modelProviderIds = modelProviderIds;
1746	}	1701	}
		1702
		1703	/**
		1704	* Returns an IUndoableOperation suitable for performing the move or copy
		1705	* operation that will move or copy the given resources to the given
		1706	* destination path.
		1707	*
		1708	* @param resources
		1709	* the resources to be moved or copied
		1710	* @param destinationPath
		1711	* the destination path to which the resources should be moved
		1712	* @return the operation that should be used to perform the move or cop
		1713	*/
		1714	protected AbstractCopyOrMoveResourcesOperation getUndoableCopyOrMoveOperation(IResource[] resources, IPath destinationPath) {
		1715	return new CopyResourcesOperation(resources, destinationPath,
		1716	IDEWorkbenchMessages.CopyFilesAndFoldersOperation_copyTitle);
		1717
		1718	}
1747	}	1719	}

Lines 160-166 Link Here

(-)src/org/eclipse/ui/internal/ide/IDEWorkbenchMessages.java (-8 / +5 lines)
160	public static String MoveProjectAction_text;	160	public static String MoveProjectAction_text;
161	public static String MoveProjectAction_toolTip;	161	public static String MoveProjectAction_toolTip;
162	public static String MoveProjectAction_moveTitle;	162	public static String MoveProjectAction_moveTitle;
163	public static String MoveProjectAction_progressMessage;
164	public static String MoveProjectAction_dialogTitle;	163	public static String MoveProjectAction_dialogTitle;
165	public static String MoveProjectAction_internalError;	164	public static String MoveProjectAction_internalError;
166		165
Lines 177-186 Link Here
177	public static String RenameResourceAction_inputDialogMessage;	176	public static String RenameResourceAction_inputDialogMessage;
178	public static String RenameResourceAction_checkTitle;	177	public static String RenameResourceAction_checkTitle;
179	public static String RenameResourceAction_readOnlyCheck;	178	public static String RenameResourceAction_readOnlyCheck;
180	public static String RenameResourceAction_resourceExists;
181	public static String RenameResourceAction_nameExists;	179	public static String RenameResourceAction_nameExists;
182	public static String RenameResourceAction_overwriteQuestion;
183	public static String RenameResourceAction_progressMessage;
184	public static String RenameResourceAction_problemTitle;	180	public static String RenameResourceAction_problemTitle;
185	public static String RenameResourceAction_progress;	181	public static String RenameResourceAction_progress;
186	public static String RenameResourceAction_nameMustBeDifferent;	182	public static String RenameResourceAction_nameMustBeDifferent;
Lines 202-211 Link Here
202	public static String DeleteResourceAction_confirmLinkedResource1;	198	public static String DeleteResourceAction_confirmLinkedResource1;
203	public static String DeleteResourceAction_confirmLinkedResourceN;	199	public static String DeleteResourceAction_confirmLinkedResourceN;
204	public static String DeleteResourceAction_readOnlyQuestion;	200	public static String DeleteResourceAction_readOnlyQuestion;
205	public static String DeleteResourceAction_messageTitle;
206	public static String DeleteResourceAction_outOfSyncError;
207	public static String DeleteResourceAction_outOfSyncQuestion;
208	public static String DeleteResourceAction_deletionExceptionMessage;
209	public static String DeleteResourceAction_jobName;	201	public static String DeleteResourceAction_jobName;
210	public static String DeleteResourceAction_checkJobName;	202	public static String DeleteResourceAction_checkJobName;
211		203
Lines 297-302 Link Here
297	public static String CopyFilesAndFoldersOperation_CopyResourcesTask;	289	public static String CopyFilesAndFoldersOperation_CopyResourcesTask;
298	public static String CopyFilesAndFoldersOperation_parentNotEqual;	290	public static String CopyFilesAndFoldersOperation_parentNotEqual;
299	public static String CopyFilesAndFoldersOperation_infoNotFound;	291	public static String CopyFilesAndFoldersOperation_infoNotFound;
		292	public static String CopyFilesAndFoldersOperation_copyTitle;
		293	public static String CopyFilesAndFoldersOperation_moveTitle;
300		294
301	public static String MoveFilesAndFoldersOperation_sameSourceAndDest;	295	public static String MoveFilesAndFoldersOperation_sameSourceAndDest;
302	public static String MoveFilesAndFoldersOperation_moveFailedTitle;	296	public static String MoveFilesAndFoldersOperation_moveFailedTitle;
Lines 366-371 Link Here
366	public static String WizardNewFolderCreationPage_progress;	360	public static String WizardNewFolderCreationPage_progress;
367	public static String WizardNewFolderCreationPage_errorTitle;	361	public static String WizardNewFolderCreationPage_errorTitle;
368	public static String WizardNewFolderCreationPage_internalErrorTitle;	362	public static String WizardNewFolderCreationPage_internalErrorTitle;
		363	public static String WizardNewFolderCreationPage_title;
369	public static String WizardNewFolder_internalError;	364	public static String WizardNewFolder_internalError;
370		365
371	// --- New File ---	366	// --- New File ---
Lines 375-380 Link Here
375	public static String WizardNewFileCreationPage_file;	370	public static String WizardNewFileCreationPage_file;
376	public static String WizardNewFileCreationPage_internalErrorTitle;	371	public static String WizardNewFileCreationPage_internalErrorTitle;
377	public static String WizardNewFileCreationPage_internalErrorMessage;	372	public static String WizardNewFileCreationPage_internalErrorMessage;
		373	public static String WizardNewFileCreationPage_title;
		374
378		375
379	// --- Linked Resource ---	376	// --- Linked Resource ---
380	public static String WizardNewLinkPage_linkFileButton;	377	public static String WizardNewLinkPage_linkFileButton;

Lines 160-166 Link Here

(-)src/org/eclipse/ui/internal/ide/messages.properties (-8 / +4 lines)
160	MoveProjectAction_text = Mo&ve...	160	MoveProjectAction_text = Mo&ve...
161	MoveProjectAction_toolTip = Move Project	161	MoveProjectAction_toolTip = Move Project
162	MoveProjectAction_moveTitle = Move Project	162	MoveProjectAction_moveTitle = Move Project
163	MoveProjectAction_progressMessage = Moving
164	MoveProjectAction_dialogTitle = Move Problems	163	MoveProjectAction_dialogTitle = Move Problems
165	MoveProjectAction_internalError = Internal error: {0}	164	MoveProjectAction_internalError = Internal error: {0}
166		165
Lines 179-188 Link Here
179	RenameResourceAction_inputDialogMessage = Enter the new resource name:	178	RenameResourceAction_inputDialogMessage = Enter the new resource name:
180	RenameResourceAction_checkTitle = Check Rename	179	RenameResourceAction_checkTitle = Check Rename
181	RenameResourceAction_readOnlyCheck = ''{0}'' is read only. Do you still wish to rename it?	180	RenameResourceAction_readOnlyCheck = ''{0}'' is read only. Do you still wish to rename it?
182	RenameResourceAction_resourceExists = Resource Exists
183	RenameResourceAction_nameExists = A resource with that name already exists	181	RenameResourceAction_nameExists = A resource with that name already exists
184	RenameResourceAction_overwriteQuestion = ''{0}'' exists. Do you wish to overwrite?
185	RenameResourceAction_progressMessage = Renaming...
186	RenameResourceAction_problemTitle = Rename Problems	182	RenameResourceAction_problemTitle = Rename Problems
187	RenameResourceAction_progress = Renaming:	183	RenameResourceAction_progress = Renaming:
188	RenameResourceAction_nameMustBeDifferent = You must use a different name	184	RenameResourceAction_nameMustBeDifferent = You must use a different name
Lines 206-215 Link Here
206	DeleteResourceAction_confirmLinkedResource1 = Are you sure you want to delete linked resource ''{0}''?\nOnly the workspace link will be deleted. Link target will remain unchanged.	202	DeleteResourceAction_confirmLinkedResource1 = Are you sure you want to delete linked resource ''{0}''?\nOnly the workspace link will be deleted. Link target will remain unchanged.
207	DeleteResourceAction_confirmLinkedResourceN = Are you sure you want to delete these {0} resources?\n\nSelection contains linked resources.\nOnly the workspace links will be deleted. Link targets will remain unchanged.	203	DeleteResourceAction_confirmLinkedResourceN = Are you sure you want to delete these {0} resources?\n\nSelection contains linked resources.\nOnly the workspace links will be deleted. Link targets will remain unchanged.
208	DeleteResourceAction_readOnlyQuestion = ''{0}'' is read only. Do you still wish to delete it?	204	DeleteResourceAction_readOnlyQuestion = ''{0}'' is read only. Do you still wish to delete it?
209	DeleteResourceAction_messageTitle = Problems deleting
210	DeleteResourceAction_outOfSyncError = Resource is out of sync with the file system. Refresh and try again.
211	DeleteResourceAction_outOfSyncQuestion = Resource ''{0}'' is out of sync with the file system. Do you want to delete it anyway?
212	DeleteResourceAction_deletionExceptionMessage=Multiple problems occurred while deleting resources.
213	DeleteResourceAction_checkJobName = Checking resources	205	DeleteResourceAction_checkJobName = Checking resources
214	DeleteResourceAction_jobName = Deleting resources	206	DeleteResourceAction_jobName = Deleting resources
215		207
Lines 305-310 Link Here
305	CopyFilesAndFoldersOperation_CopyResourcesTask=Copying Resources	297	CopyFilesAndFoldersOperation_CopyResourcesTask=Copying Resources
306	CopyFilesAndFoldersOperation_parentNotEqual = The resources must have the same parent.	298	CopyFilesAndFoldersOperation_parentNotEqual = The resources must have the same parent.
307	CopyFilesAndFoldersOperation_infoNotFound = Information for {0} could not be read. Please check the .log file for details.	299	CopyFilesAndFoldersOperation_infoNotFound = Information for {0} could not be read. Please check the .log file for details.
		300	CopyFilesAndFoldersOperation_copyTitle= Copy Resources
		301	CopyFilesAndFoldersOperation_moveTitle= Move Resources
308		302
309	MoveFilesAndFoldersOperation_sameSourceAndDest = Cannot move ''{0}''. The source and destination are the same.	303	MoveFilesAndFoldersOperation_sameSourceAndDest = Cannot move ''{0}''. The source and destination are the same.
310	MoveFilesAndFoldersOperation_moveFailedTitle = Move Problems	304	MoveFilesAndFoldersOperation_moveFailedTitle = Move Problems
Lines 386-391 Link Here
386	WizardNewFolderCreationPage_progress = Creating	380	WizardNewFolderCreationPage_progress = Creating
387	WizardNewFolderCreationPage_errorTitle = Creation Problems	381	WizardNewFolderCreationPage_errorTitle = Creation Problems
388	WizardNewFolderCreationPage_internalErrorTitle = Creation problems	382	WizardNewFolderCreationPage_internalErrorTitle = Creation problems
		383	WizardNewFolderCreationPage_title = New Folder
389	WizardNewFolder_internalError = Internal error: {0}	384	WizardNewFolder_internalError = Internal error: {0}
390		385
391	# --- New File ---	386	# --- New File ---
Lines 395-400 Link Here
395	WizardNewFileCreationPage_file = file	390	WizardNewFileCreationPage_file = file
396	WizardNewFileCreationPage_internalErrorTitle = Creation problems	391	WizardNewFileCreationPage_internalErrorTitle = Creation problems
397	WizardNewFileCreationPage_internalErrorMessage = Internal error: {0}	392	WizardNewFileCreationPage_internalErrorMessage = Internal error: {0}
		393	WizardNewFileCreationPage_title = New File
398		394
399	# --- Linked Resource ---	395	# --- Linked Resource ---
400	WizardNewLinkPage_linkFileButton = &Link to file on the file system	396	WizardNewLinkPage_linkFileButton = &Link to file on the file system

Lines 19-47 Link Here

(-)src/org/eclipse/ui/wizards/newresource/BasicNewProjectResourceWizard.java (-74 / +37 lines)
19	import java.util.Set;	19	import java.util.Set;
20	import java.util.StringTokenizer;	20	import java.util.StringTokenizer;
21		21
		22	import org.eclipse.core.commands.ExecutionException;
22	import org.eclipse.core.resources.IProject;	23	import org.eclipse.core.resources.IProject;
23	import org.eclipse.core.resources.IProjectDescription;	24	import org.eclipse.core.resources.IProjectDescription;
24	import org.eclipse.core.resources.IResource;
25	import org.eclipse.core.resources.IResourceStatus;
26	import org.eclipse.core.resources.IWorkspace;	25	import org.eclipse.core.resources.IWorkspace;
27	import org.eclipse.core.resources.ResourcesPlugin;	26	import org.eclipse.core.resources.ResourcesPlugin;
28	import org.eclipse.core.runtime.CoreException;	27	import org.eclipse.core.runtime.IAdaptable;
29	import org.eclipse.core.runtime.IConfigurationElement;	28	import org.eclipse.core.runtime.IConfigurationElement;
30	import org.eclipse.core.runtime.IExecutableExtension;	29	import org.eclipse.core.runtime.IExecutableExtension;
31	import org.eclipse.core.runtime.IProgressMonitor;	30	import org.eclipse.core.runtime.IProgressMonitor;
32	import org.eclipse.core.runtime.IStatus;	31	import org.eclipse.core.runtime.IStatus;
33	import org.eclipse.core.runtime.OperationCanceledException;
34	import org.eclipse.core.runtime.Status;	32	import org.eclipse.core.runtime.Status;
35	import org.eclipse.core.runtime.SubProgressMonitor;
36	import org.eclipse.jface.dialogs.ErrorDialog;	33	import org.eclipse.jface.dialogs.ErrorDialog;
37	import org.eclipse.jface.dialogs.IDialogConstants;	34	import org.eclipse.jface.dialogs.IDialogConstants;
38	import org.eclipse.jface.dialogs.IDialogSettings;	35	import org.eclipse.jface.dialogs.IDialogSettings;
39	import org.eclipse.jface.dialogs.MessageDialog;	36	import org.eclipse.jface.dialogs.MessageDialog;
40	import org.eclipse.jface.dialogs.MessageDialogWithToggle;	37	import org.eclipse.jface.dialogs.MessageDialogWithToggle;
		38	import org.eclipse.jface.operation.IRunnableWithProgress;
41	import org.eclipse.jface.preference.IPreferenceStore;	39	import org.eclipse.jface.preference.IPreferenceStore;
42	import org.eclipse.jface.resource.ImageDescriptor;	40	import org.eclipse.jface.resource.ImageDescriptor;
43	import org.eclipse.jface.viewers.IStructuredSelection;	41	import org.eclipse.jface.viewers.IStructuredSelection;
44	import org.eclipse.osgi.util.NLS;	42	import org.eclipse.osgi.util.NLS;
		43	import org.eclipse.swt.widgets.Shell;
45	import org.eclipse.ui.IPerspectiveDescriptor;	44	import org.eclipse.ui.IPerspectiveDescriptor;
46	import org.eclipse.ui.IPerspectiveRegistry;	45	import org.eclipse.ui.IPerspectiveRegistry;
47	import org.eclipse.ui.IPluginContribution;	46	import org.eclipse.ui.IPluginContribution;
Lines 51-57 Link Here
51	import org.eclipse.ui.IWorkbenchWindow;	50	import org.eclipse.ui.IWorkbenchWindow;
52	import org.eclipse.ui.PlatformUI;	51	import org.eclipse.ui.PlatformUI;
53	import org.eclipse.ui.WorkbenchException;	52	import org.eclipse.ui.WorkbenchException;
54	import org.eclipse.ui.actions.WorkspaceModifyOperation;
55	import org.eclipse.ui.activities.IActivityManager;	53	import org.eclipse.ui.activities.IActivityManager;
56	import org.eclipse.ui.activities.IIdentifier;	54	import org.eclipse.ui.activities.IIdentifier;
57	import org.eclipse.ui.activities.IWorkbenchActivitySupport;	55	import org.eclipse.ui.activities.IWorkbenchActivitySupport;
Lines 59-64 Link Here
59	import org.eclipse.ui.dialogs.WizardNewProjectCreationPage;	57	import org.eclipse.ui.dialogs.WizardNewProjectCreationPage;
60	import org.eclipse.ui.dialogs.WizardNewProjectReferencePage;	58	import org.eclipse.ui.dialogs.WizardNewProjectReferencePage;
61	import org.eclipse.ui.ide.IDE;	59	import org.eclipse.ui.ide.IDE;
		60	import org.eclipse.ui.ide.undo.CreateProjectOperation;
62	import org.eclipse.ui.internal.IPreferenceConstants;	61	import org.eclipse.ui.internal.IPreferenceConstants;
63	import org.eclipse.ui.internal.WorkbenchPlugin;	62	import org.eclipse.ui.internal.WorkbenchPlugin;
64	import org.eclipse.ui.internal.ide.IDEInternalPreferences;	63	import org.eclipse.ui.internal.ide.IDEInternalPreferences;
Lines 196-207 Link Here
196	}	195	}
197		196
198	// create the new project operation	197	// create the new project operation
199	WorkspaceModifyOperation op = new WorkspaceModifyOperation() {	198	IRunnableWithProgress op = new IRunnableWithProgress() {
200	protected void execute(IProgressMonitor monitor)	199	public void run(IProgressMonitor monitor) {
201	throws CoreException {	200	CreateProjectOperation op = new CreateProjectOperation(
202	createProject(description, newProjectHandle, monitor);	201	description, ResourceMessages.NewProject_windowTitle);
203	}	202	try {
		203	PlatformUI.getWorkbench().getOperationSupport()
		204	.getOperationHistory().execute(op, monitor, new IAdaptable() {
		205	public Object getAdapter(Class clazz) {
		206	if (clazz == Shell.class) {
		207	return getShell();
		208	}
		209	return null;
		210	}
		211	});
		212	} catch (ExecutionException e) {
		213	IDEWorkbenchPlugin.log(e.getMessage(), e);
		214	}
		215	}
		216
204	};	217	};
		218
205		219
206	// run the new project creation operation	220	// run the new project creation operation
207	try {	221	try {
Lines 209-242 Link Here
209	} catch (InterruptedException e) {	223	} catch (InterruptedException e) {
210	return null;	224	return null;
211	} catch (InvocationTargetException e) {	225	} catch (InvocationTargetException e) {
212	// ie.- one of the steps resulted in a core exception	226	Throwable t = e.getTargetException();
213	Throwable t = e.getTargetException();	227	// Exceptions are handled in the operation, but unexpected runtime
214	if (t instanceof CoreException) {	228	// exceptions and errors may still occur.
215	if (((CoreException) t).getStatus().getCode() == IResourceStatus.CASE_VARIANT_EXISTS) {	229	IDEWorkbenchPlugin.getDefault().getLog().log(
216	MessageDialog	230	new Status(IStatus.ERROR,
217	.openError(	231	IDEWorkbenchPlugin.IDE_WORKBENCH, 0, t
218	getShell(),	232	.toString(), t));
219	ResourceMessages.NewProject_errorMessage,	233	MessageDialog.openError(
220	NLS.bind(ResourceMessages.NewProject_caseVariantExistsError, newProjectHandle.getName())	234	getShell(),
221	);	235	ResourceMessages.NewProject_errorMessage,
222	} else {	236	NLS.bind(ResourceMessages.NewProject_internalError, t.getMessage()));
223	ErrorDialog.openError(getShell(), ResourceMessages.NewProject_errorMessage,	237
224	null, // no special message
225	((CoreException) t).getStatus());
226	}
227	} else {
228	// CoreExceptions are handled above, but unexpected runtime
229	// exceptions and errors may still occur.
230	IDEWorkbenchPlugin.getDefault().getLog().log(
231	new Status(IStatus.ERROR,
232	IDEWorkbenchPlugin.IDE_WORKBENCH, 0, t
233	.toString(), t));
234	MessageDialog
235	.openError(
236	getShell(),
237	ResourceMessages.NewProject_errorMessage,
238	NLS.bind(ResourceMessages.NewProject_internalError, t.getMessage()));
239	}
240	return null;	238	return null;
241	}	239	}
242		240
Lines 246-286 Link Here
246	}	244	}
247		245
248	/**	246	/**
249	* Creates a project resource given the project handle and description.
250	*
251	* @param description
252	* the project description to create a project resource for
253	* @param projectHandle
254	* the project handle to create a project resource for
255	* @param monitor
256	* the progress monitor to show visual progress with
257	*
258	* @exception CoreException
259	* if the operation fails
260	* @exception OperationCanceledException
261	* if the operation is canceled
262	*/
263	void createProject(IProjectDescription description, IProject projectHandle,
264	IProgressMonitor monitor) throws CoreException,
265	OperationCanceledException {
266	try {
267	monitor.beginTask("", 2000);//$NON-NLS-1$
268
269	projectHandle.create(description, new SubProgressMonitor(monitor,
270	1000));
271
272	if (monitor.isCanceled()) {
273	throw new OperationCanceledException();
274	}
275
276	projectHandle.open(IResource.BACKGROUND_REFRESH, new SubProgressMonitor(monitor, 1000));
277
278	} finally {
279	monitor.done();
280	}
281	}
282
283	/**
284	* Returns the newly created project.	247	* Returns the newly created project.
285	*	248	*
286	* @return the created project, or <code>null</code> if project not	249	* @return the created project, or <code>null</code> if project not

Added Link Here

(-)src/org/eclipse/ui/ide/undo/DeleteResourcesOperation.java (+117 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.ide.undo;
13
14	import org.eclipse.core.resources.IResource;
15	import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
16	import org.eclipse.core.runtime.CoreException;
17	import org.eclipse.core.runtime.IAdaptable;
18	import org.eclipse.core.runtime.IProgressMonitor;
19	import org.eclipse.core.runtime.IStatus;
20	import org.eclipse.ui.internal.ide.undo.UndoMessages;
21
22	/**
23	* A DeleteResourcesOperation represents an undoable operation for deleting one
24	* or more resources in the workspace.
25	*
26	* This class is intended to be instantiated and used by clients. It is not
27	* intended to be subclassed by clients.
28	*
29	* <strong>EXPERIMENTAL</strong> This class or interface has been added as part
30	* of a work in progress. This API may change at any given time. Please do not
31	* use this API without consulting with the Platform/UI team.
32	*
33	* @since 3.3
34	*
35	*/
36	public class DeleteResourcesOperation extends AbstractResourcesOperation {
37
38	private boolean deleteContent = false;
39
40	/**
41	* Create a DeleteResourcesOperation
42	*
43	* @param resources
44	* the resources to be deleted
45	* @param label
46	* the label of the operation
47	* @param deleteContent
48	* whether or not we are deleting content for projects
49	*/
50	public DeleteResourcesOperation(IResource[] resources, String label,
51	boolean deleteContent) {
52	super(resources, label);
53	this.deleteContent = deleteContent;
54	}
55
56	protected void doExecute(IProgressMonitor monitor, IAdaptable uiInfo)
57	throws CoreException {
58	delete(monitor, uiInfo, deleteContent);
59	}
60
61	protected void doUndo(IProgressMonitor monitor, IAdaptable uiInfo)
62	throws CoreException {
63	recreate(monitor, uiInfo);
64	}
65
66	protected boolean updateResourceChangeDescriptionFactory(
67	IResourceChangeDescriptionFactory factory, int operation) {
68	boolean modified = false;
69	if (operation == UNDO) {
70	for (int i = 0; i < resourceDescriptions.length; i++) {
71	IResource resource = resourceDescriptions[i].createResourceHandle();
72	factory.create(resource);
73	modified = true;
74	}
75	} else {
76	for (int i = 0; i < resources.length; i++) {
77	IResource resource = resources[i];
78	factory.delete(resource);
79	modified = true;
80	}
81	}
82	return modified;
83	}
84
85	public IStatus computeExecutionStatus(IProgressMonitor monitor) {
86	IStatus status = super.computeExecutionStatus(monitor);
87	if (status.isOK()) {
88	status = computeDeleteStatus();
89	}
90	if (status.isOK()) {
91	// If the resources to be deleted include projects whose content
92	// is to be deleted, warn the user that the data will be lost.
93	if (deleteContent && resourcesIncludesProjects()) {
94	status = getWarningStatus(
95	UndoMessages.DeleteResourcesOperation_DeletingProjectContentWarning,
96	0);
97	}
98	}
99	return status;
100	}
101
102	public IStatus computeUndoableStatus(IProgressMonitor monitor) {
103	IStatus status = super.computeUndoableStatus(monitor);
104	if (status.isOK()) {
105	status = computeCreateStatus();
106	}
107	return status;
108	}
109
110	public IStatus computeRedoableStatus(IProgressMonitor monitor) {
111	IStatus status = super.computeRedoableStatus(monitor);
112	if (status.isOK()) {
113	status = computeDeleteStatus();
114	}
115	return status;
116	}
117	}

Added Link Here

(-)src/org/eclipse/ui/ide/undo/CreateFileOperation.java (+127 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.ide.undo;
13
14	import java.io.InputStream;
15	import java.io.StringBufferInputStream;
16
17	import org.eclipse.core.resources.IFile;
18	import org.eclipse.core.resources.IFileState;
19	import org.eclipse.core.runtime.CoreException;
20	import org.eclipse.core.runtime.IPath;
21	import org.eclipse.ui.internal.ide.undo.ContainerDescription;
22	import org.eclipse.ui.internal.ide.undo.FileDescription;
23	import org.eclipse.ui.internal.ide.undo.ResourceDescription;
24
25	/**
26	* A CreateFileOperation represents an undoable operation for creating a file in
27	* the workspace. If a link location is specified, the folder is considered to
28	* be linked to the file at the specified location. If a link location is not
29	* specified, the file will be created in the location specified by the handle,
30	* and the entire containment path of the file will be created if it does not
31	* exist.
32	*
33	* This class is intended to be instantiated and used by clients. It is not
34	* intended to be subclassed by clients.
35	*
36	* <strong>EXPERIMENTAL</strong> This class or interface has been added as part
37	* of a work in progress. This API may change at any given time. Please do not
38	* use this API without consulting with the Platform/UI team.
39	*
40	* @since 3.3
41	*
42	*/
43	public class CreateFileOperation extends AbstractCreateResourcesOperation {
44
45	/**
46	* Create a CreateFileOperation
47	*
48	* @param fileHandle
49	* the file to be created
50	* @param linkLocation
51	* the location of the file if it is to be linked
52	* @param contents
53	* the initial contents of the file, or null if there is to be no
54	* contents
55	* @param label
56	* the label of the operation
57	*/
58	public CreateFileOperation(IFile fileHandle, IPath linkLocation, InputStream contents, String label) {
59	super(null, label);
60	ResourceDescription resourceDescription;
61	if (linkLocation == null) {
62	if (fileHandle.getParent().exists()) {
63	resourceDescription = new FileDescription(fileHandle, null, createFileState(fileHandle, contents));
64	} else {
65	// must first ensure descriptions for the parent folders are
66	// created
67	ContainerDescription containerDescription = ContainerDescription.fromContainer(fileHandle.getParent());
68	containerDescription.getFirstLeafFolder().addMember(new FileDescription(fileHandle, null, createFileState(fileHandle, contents)));
69	resourceDescription = containerDescription;
70	}
71	} else {
72	// create a linked file description
73	resourceDescription = new FileDescription(fileHandle, linkLocation, createFileState(fileHandle, contents));
74	}
75	setResourceDescriptions(new ResourceDescription[ ] { resourceDescription });
76
77	}
78
79	/*
80	* Create a file state that represents the desired contents and attributes
81	* of the file to be created. Used to mimic file history when a resource is
82	* first created.
83	*/
84	private IFileState createFileState(final IFile file,
85	final InputStream contents) {
86	return new IFileState() {
87	public InputStream getContents() {
88	if (contents != null) {
89	return contents;
90	}
91	return new StringBufferInputStream(""); //$NON-NLS-1$
92	}
93
94	public Object getAdapter(Class clazz) {
95	return null;
96	}
97
98	public String getCharset() {
99	try {
100	return file.getCharset();
101	} catch (CoreException e) {
102	return null;
103	}
104	}
105
106	public IPath getFullPath() {
107	return file.getFullPath();
108	}
109
110	public String getName() {
111	return file.getName();
112	}
113
114	public boolean exists() {
115	return true;
116	}
117
118	public boolean isReadOnly() {
119	return true;
120	}
121
122	public long getModificationTime() {
123	return file.getLocalTimeStamp();
124	}
125	};
126	}
127	}

Added Link Here

(-)src/org/eclipse/ui/ide/undo/MoveResourcesOperation.java (+115 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.ide.undo;
13
14	import org.eclipse.core.resources.IResource;
15	import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
16	import org.eclipse.core.runtime.CoreException;
17	import org.eclipse.core.runtime.IAdaptable;
18	import org.eclipse.core.runtime.IPath;
19	import org.eclipse.core.runtime.IProgressMonitor;
20	import org.eclipse.core.runtime.IStatus;
21
22	/**
23	* A MoveResourcesOperation represents an undoable operation for moving one or
24	* more resources in the workspace.
25	*
26	* This class is intended to be instantiated and used by clients. It is not
27	* intended to be subclassed by clients.
28	*
29	* <strong>EXPERIMENTAL</strong> This class or interface has been added as part
30	* of a work in progress. This API may change at any given time. Please do not
31	* use this API without consulting with the Platform/UI team.
32	*
33	* @since 3.3
34	*
35	*/
36	public class MoveResourcesOperation extends
37	AbstractCopyOrMoveResourcesOperation {
38
39	/**
40	* Create a MoveResourcesOperation that moves all of the specified resources
41	* to the same target location, using their existing names.
42	*
43	* @param resources
44	* the resources to be moved
45	* @param destinationPath
46	* the destination path for the resources, not including the name
47	* of the new resource.
48	* @param label
49	* the label of the operation
50	*/
51	public MoveResourcesOperation(IResource[] resources, IPath destinationPath,
52	String label) {
53	super(resources, destinationPath, label);
54	}
55
56	/**
57	* Create a MoveResourcesOperation that moves a single resource to a new
58	* location. The new location includes the name of the resource, so this may
59	* be used for a move/rename operation or a simple move.
60	*
61	* @param resource
62	* the resource to be moved
63	* @param newPath
64	* the new path for the resource, including its desired name.
65	* @param label
66	* the label of the operation
67	*/
68	public MoveResourcesOperation(IResource resource, IPath newPath,
69	String label) {
70	super(new IResource[] { resource }, new IPath[] { newPath }, label);
71	}
72
73	protected void doExecute(IProgressMonitor monitor, IAdaptable uiInfo)
74	throws CoreException {
75	moveOrCopy(monitor, uiInfo, true); // true = move
76	}
77
78	protected void doUndo(IProgressMonitor monitor, IAdaptable uiInfo)
79	throws CoreException {
80	moveOrCopy(monitor, uiInfo, true); // true = move
81	}
82
83	protected boolean updateResourceChangeDescriptionFactory(
84	IResourceChangeDescriptionFactory factory, int operation) {
85	for (int i = 0; i < resources.length; i++) {
86	IResource resource = resources[i];
87	factory.move(resource, getDestinationPath(resource, i, true));
88	}
89	return true;
90	}
91
92	public IStatus computeExecutionStatus(IProgressMonitor monitor) {
93	IStatus status = super.computeExecutionStatus(monitor);
94	if (status.isOK()) {
95	status = computeMoveOrCopyStatus();
96	}
97	return status;
98	}
99
100	public IStatus computeUndoableStatus(IProgressMonitor monitor) {
101	IStatus status = super.computeUndoableStatus(monitor);
102	if (status.isOK()) {
103	status = computeMoveOrCopyStatus();
104	}
105	return status;
106	}
107
108	public IStatus computeRedoableStatus(IProgressMonitor monitor) {
109	IStatus status = super.computeRedoableStatus(monitor);
110	if (status.isOK()) {
111	status = computeMoveOrCopyStatus();
112	}
113	return status;
114	}
115	}

Added Link Here

(-)src/org/eclipse/ui/ide/undo/AbstractCopyOrMoveResourcesOperation.java (+288 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.ide.undo;
13
14	import java.net.URI;
15	import java.util.ArrayList;
16	import java.util.List;
17
18	import org.eclipse.core.resources.IProject;
19	import org.eclipse.core.resources.IResource;
20	import org.eclipse.core.runtime.CoreException;
21	import org.eclipse.core.runtime.IAdaptable;
22	import org.eclipse.core.runtime.IPath;
23	import org.eclipse.core.runtime.IProgressMonitor;
24	import org.eclipse.core.runtime.IStatus;
25	import org.eclipse.core.runtime.Path;
26	import org.eclipse.core.runtime.Platform;
27	import org.eclipse.core.runtime.Status;
28	import org.eclipse.core.runtime.SubProgressMonitor;
29	import org.eclipse.jface.dialogs.IDialogConstants;
30	import org.eclipse.ui.internal.ide.undo.ResourceDescription;
31	import org.eclipse.ui.internal.ide.undo.UndoMessages;
32
33	/**
34	* An AbstractCopyOrMoveResourcesOperation represents an undoable operation for
35	* moving or copying one or more resources in the workspace.
36	*
37	* This class is not intended to be subclassed by clients.
38	*
39	* <strong>EXPERIMENTAL</strong> This class or interface has been added as part
40	* of a work in progress. This API may change at any given time. Please do not
41	* use this API without consulting with the Platform/UI team.
42	*
43	* @since 3.3
44	*
45	*/
46	public abstract class AbstractCopyOrMoveResourcesOperation extends
47	AbstractResourcesOperation {
48
49	// Used when there are different destination names for each resource
50	protected IPath[] destinationPaths = null;
51
52	// Used when all resources are going to the same container (no name changes)
53	protected IPath destination = null;
54
55	/**
56	* Create an AbstractCopyOrMoveResourcesOperation that moves or copies all
57	* of the specified resources to the specified paths. The destination paths
58	* must include the names of the resources at their new location.
59	*
60	* @param resources
61	* the resources to be moved or copied
62	* @param destinationPaths
63	* the destination paths for the resources, including the name to
64	* be assigned to the resource at its new location.
65	* @param label
66	* the label of the operation
67	*/
68	AbstractCopyOrMoveResourcesOperation(IResource[] resources,
69	IPath[] destinationPaths, String label) {
70	super(resources, label);
71	this.destinationPaths = destinationPaths;
72	}
73
74	/**
75	* Create an AbstractCopyOrMoveResourcesOperation that moves or copies all
76	* of the specified resources to the same target location, using their
77	* existing names.
78	*
79	* @param resources
80	* the resources to be moved or copied
81	* @param destinationPath
82	* the destination path for the resources, not including the name
83	* of the new resource.
84	* @param label
85	* the label of the operation
86	*/
87	AbstractCopyOrMoveResourcesOperation(IResource[] resources,
88	IPath destinationPath, String label) {
89	super(resources, label);
90	destination = destinationPath;
91	}
92
93	protected void moveOrCopy(IProgressMonitor monitor, IAdaptable uiInfo,
94	boolean move) throws CoreException {
95
96	String progressMessage;
97	if (move) {
98	progressMessage = UndoMessages.AbstractResourcesOperation_MovingResources;
99	} else {
100	progressMessage = UndoMessages.AbstractResourcesOperation_CopyingResourcesProgress;
101	}
102	monitor.beginTask(progressMessage, 2000);
103	IResource[] resourcesInNewLocations = new IResource[resources.length];
104	List overwrittenResources = new ArrayList();
105	IPath[] newDestinationPaths = new IPath[resources.length];
106
107	for (int i = 0; i < resources.length; i++) {
108	// Record the original path so this can be undone
109	if (resources[i].getType() == IResource.PROJECT) {
110	URI locationURI = ((IProject) resources[i]).getDescription()
111	.getLocationURI();
112	if (locationURI == null) {
113	newDestinationPaths[i] = Platform.getLocation().append(
114	resources[i].getName());
115	} else {
116	newDestinationPaths[i] = new Path(locationURI.getPath())
117	.append(resources[i].getName());
118	}
119	} else {
120	newDestinationPaths[i] = resources[i].getFullPath();
121	}
122	// Move or copy the resources and record the overwrites that would
123	// be restored if this operation were reversed
124	ResourceDescription[] overwrites;
125	if (move) {
126	overwrites = move(resources[i], getDestinationPath(
127	resources[i], i, true), new SubProgressMonitor(monitor,
128	1000 / resources.length), uiInfo);
129	} else {
130	overwrites = copy(
131	new IResource[] { resources[i] },
132	getDestinationPath(resources[i], i, true),
133	new SubProgressMonitor(monitor, 1000 / resources.length),
134	uiInfo, true);
135	}
136	// Accumulate the overwrites into the full list
137	for (int j = 0; j < overwrites.length; j++) {
138	overwrittenResources.add(overwrites[i]);
139	}
140	// Record the resource in its new location
141	resourcesInNewLocations[i] = getWorkspace().getRoot().findMember(
142	getDestinationPath(resources[i], i, false));
143	}
144
145	// Are there any previously overwritten resources to restore now?
146	if (resourceDescriptions != null) {
147	for (int i = 0; i < resourceDescriptions.length; i++) {
148	if (resourceDescriptions[i] != null) {
149	resourceDescriptions[i]
150	.createResource(new SubProgressMonitor(monitor,
151	1000 / resourceDescriptions.length));
152	}
153	}
154	}
155
156	// Reset resource descriptions to the just overwritten resources
157	setResourceDescriptions((ResourceDescription[]) overwrittenResources
158	.toArray(new ResourceDescription[overwrittenResources.size()]));
159
160	// Reset the target resources to refer to the resources in their new
161	// location. Note that the destination paths were reset to the original
162	// location as we did the move.
163	setTargetResources(resourcesInNewLocations);
164
165	// Reset the destination path to the new paths
166	destinationPaths = newDestinationPaths;
167	destination = null;
168
169	monitor.done();
170	}
171
172	/*
173	* Compute the status for moving or copying the resources.
174	*
175	* Note this method may be called on initial moving or copying of a
176	* resource, or when a move or copy is undone or redone. Therefore, this
177	* method should check conditions that can change over the life of the
178	* operation, such as whether the file to moved or copied exists, and
179	* whether the target location is still valid. One-time static checks should
180	* typically be done by the caller so that the user is not continually
181	* prompted or warned about conditions that were acceptable at the time of
182	* original execution and do not change over time.
183	*/
184	protected IStatus computeMoveOrCopyStatus() {
185	// Check for error conditions first so that we do not prompt the user
186	// on warnings that eventually will not matter anyway.
187	if (resources == null \|\| !hasDestinationPath()) {
188	markInvalid();
189	return getErrorStatus(UndoMessages.AbstractResourcesOperation_NotEnoughInfo);
190	}
191	for (int i = 0; i < resources.length; i++) {
192	IResource resource = resources[i];
193	// Does the resource still exist?
194	if (!resource.exists()) {
195	markInvalid();
196	return getErrorStatus(UndoMessages.MoveOrCopyResourceOperation_ResourceDoesNotExist);
197	}
198	// Are we really trying to move it to a different name?
199	IPath proposedPath = getDestinationPath(resource, i, false);
200	if (resource.getFullPath().equals(proposedPath)) {
201	markInvalid();
202	return getErrorStatus(UndoMessages.MoveOrCopyResourceOperation_SameNameOrLocation);
203	}
204	// Is the proposed name valid?
205	IStatus status = getWorkspace().validateName(
206	proposedPath.lastSegment(), resource.getType());
207	if (status.getSeverity() == IStatus.ERROR) {
208	markInvalid();
209	}
210	if (!status.isOK()) {
211	return status;
212	}
213	}
214
215	for (int i = 0; i < resources.length; i++) {
216	// No error conditions. Check and warn for any overwrites that may
217	// occur.
218	IResource newResource = null;
219	if (resources[i].getType() == IResource.PROJECT) {
220	// Projects may be moved to a new location or copied to a new
221	// name. To cover both cases, we consider matching location
222	// paths, including name, to represent an overwrite.
223	IPath proposedPath = getDestinationPath(resources[i], i, true);
224	IPath existingPath = resources[i].getLocation().append(
225	resources[i].getName());
226	if (proposedPath.equals(existingPath)) {
227	newResource = resources[i];
228	}
229	} else {
230	IPath proposedPath = getDestinationPath(resources[i], i, false);
231	newResource = getWorkspace().getRoot().findMember(proposedPath);
232	}
233	if (newResource != null) {
234	int result = queryOverwrite(newResource, null);
235	if (result == IDialogConstants.YES_TO_ALL_ID) {
236	return Status.OK_STATUS;
237	} else if (result == IDialogConstants.CANCEL_ID) {
238	return Status.CANCEL_STATUS;
239	} else if (result == IDialogConstants.NO_ID) {
240	markInvalid();
241	return getErrorStatus(UndoMessages.AbstractResourcesOperation_overwriteError);
242	}
243	// Otherwise (YES_ID) we continue checking each one
244	// individually.
245	}
246	}
247	return Status.OK_STATUS;
248	}
249
250	protected IPath getDestinationPath(IResource resource, int i,
251	boolean includeProjectLocation) {
252	if (resource.getType() == IResource.PROJECT) {
253	return getProjectPath((IProject) resource, i,
254	includeProjectLocation);
255	}
256	if (destinationPaths != null) {
257	return destinationPaths[i];
258	}
259	return destination.append(resource.getName());
260
261	}
262
263	private IPath getProjectPath(IProject project, int i,
264	boolean includeProjectLocation) {
265	String projectName;
266	IPath projectLocation = null;
267	if (destinationPaths != null) {
268	if (includeProjectLocation) {
269	return destinationPaths[i];
270	}
271	// new name specified in destination path
272	projectName = destinationPaths[i].lastSegment();
273	} else {
274	// if not use the old name and common destination path
275	projectName = project.getName();
276	projectLocation = destination;
277	}
278	if (includeProjectLocation) {
279	return projectLocation.append(projectName);
280	}
281	return new Path(projectName);
282	}
283
284	protected boolean hasDestinationPath() {
285	return (destinationPaths != null && resources.length == destinationPaths.length)
286	\|\| (destination != null);
287	}
288	}

Added Link Here

(-)src/org/eclipse/ui/ide/undo/CreateFolderOperation.java (+61 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.ide.undo;
13
14	import org.eclipse.core.resources.IFolder;
15	import org.eclipse.core.runtime.IPath;
16	import org.eclipse.ui.internal.ide.undo.ContainerDescription;
17	import org.eclipse.ui.internal.ide.undo.FolderDescription;
18	import org.eclipse.ui.internal.ide.undo.ResourceDescription;
19
20	/**
21	* A CreateFolderOperation represents an undoable operation for creating a
22	* folder in the workspace. If a link location is specified, the folder is
23	* considered to be linked to the specified location. If a link location is not
24	* specified, the folder will be created in the location specified by the
25	* handle, and the entire containment path of the folder will be created if it
26	* does not exist.
27	*
28	* This class is intended to be instantiated and used by clients. It is not
29	* intended to be subclassed by clients.
30	*
31	* <strong>EXPERIMENTAL</strong> This class or interface has been added as part
32	* of a work in progress. This API may change at any given time. Please do not
33	* use this API without consulting with the Platform/UI team.
34	*
35	* @since 3.3
36	*
37	*/
38	public class CreateFolderOperation extends AbstractCreateResourcesOperation {
39
40	/**
41	* Create a CreateFolderOperation
42	*
43	* @param folderHandle
44	* the folder to be created
45	* @param linkLocation
46	* the location of the folder if it is to be linked
47	* @param label
48	* the label of the operation
49	*/
50	public CreateFolderOperation(IFolder folderHandle, IPath linkLocation, String label) {
51	super(null, label);
52	ContainerDescription containerDescription;
53	if (linkLocation == null) {
54	containerDescription = ContainerDescription.fromContainer(folderHandle);
55	} else {
56	// create a linked folder description
57	containerDescription = new FolderDescription(folderHandle, linkLocation);
58	}
59	setResourceDescriptions(new ResourceDescription[ ] {containerDescription});
60	}
61	}

Added Link Here

(-)src/org/eclipse/ui/ide/undo/CreateProjectOperation.java (+65 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.ide.undo;
13
14	import org.eclipse.core.resources.IProjectDescription;
15	import org.eclipse.core.resources.IResourceStatus;
16	import org.eclipse.core.runtime.CoreException;
17	import org.eclipse.osgi.util.NLS;
18	import org.eclipse.ui.internal.ide.undo.ProjectDescription;
19	import org.eclipse.ui.internal.ide.undo.UndoMessages;
20
21	/**
22	* A CreateProjectOperation represents an undoable operation for creating a
23	* project in the workspace.
24	*
25	* This class is intended to be instantiated and used by clients. It is not
26	* intended to be subclassed by clients.
27	*
28	* <strong>EXPERIMENTAL</strong> This class or interface has been added as part
29	* of a work in progress. This API may change at any given time. Please do not
30	* use this API without consulting with the Platform/UI team.
31	*
32	* @since 3.3
33	*
34	*/
35	public class CreateProjectOperation extends AbstractCreateResourcesOperation {
36
37	/**
38	* Create a CreateProjectOperation
39	*
40	* @param projectDescription
41	* the project to be created
42	* @param label
43	* the label of the operation
44	*/
45	public CreateProjectOperation(IProjectDescription projectDescription,
46	String label) {
47	super(new ProjectDescription[] { new ProjectDescription(
48	projectDescription) }, label);
49	}
50
51	/**
52	* Return the specific error message to use when the specified core
53	* exception occurs, or <code>null</code> to indicate that the the
54	* exception's message should be used.
55	*/
56	protected String getErrorMessage(CoreException e) {
57	if (e.getStatus().getCode() == IResourceStatus.CASE_VARIANT_EXISTS) {
58	if (resourceDescriptions != null && resourceDescriptions.length==1) {
59	ProjectDescription project = (ProjectDescription)resourceDescriptions[0];
60	return NLS.bind(UndoMessages.CreateProjectOperation_caseVariantExistsError, project.getName());
61	}
62	}
63	return super.getErrorMessage(e);
64	}
65	}

Added Link Here

(-)src/org/eclipse/ui/ide/undo/CopyResourcesOperation.java (+195 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.ide.undo;
13
14	import org.eclipse.core.resources.IResource;
15	import org.eclipse.core.resources.mapping.IResourceChangeDescriptionFactory;
16	import org.eclipse.core.runtime.CoreException;
17	import org.eclipse.core.runtime.IAdaptable;
18	import org.eclipse.core.runtime.IPath;
19	import org.eclipse.core.runtime.IProgressMonitor;
20	import org.eclipse.core.runtime.IStatus;
21	import org.eclipse.core.runtime.SubProgressMonitor;
22	import org.eclipse.ui.internal.ide.undo.ResourceDescription;
23	import org.eclipse.ui.internal.ide.undo.UndoMessages;
24
25	/**
26	* A CopyResourcesOperation represents an undoable operation for copying one or
27	* more resources in the workspace.
28	*
29	* This class is intended to be instantiated and used by clients. It is not
30	* intended to be subclassed by clients.
31	*
32	* <strong>EXPERIMENTAL</strong> This class or interface has been added as part
33	* of a work in progress. This API may change at any given time. Please do not
34	* use this API without consulting with the Platform/UI team.
35	*
36	* @since 3.3
37	*
38	*/
39	public class CopyResourcesOperation extends
40	AbstractCopyOrMoveResourcesOperation {
41
42	IResource[] originalResources;
43
44	IPath[] originalDestinationPaths = null;
45
46	IPath originalDestination = null;
47
48	/**
49	* Create a CopyResourcesOperation that copies a single resource to a new
50	* location. The new location includes the name of the copy.
51	*
52	* @param resource
53	* the resource to be moved
54	* @param newPath
55	* the new path for the resource, including its desired name.
56	* @param label
57	* the label of the operation
58	*/
59	public CopyResourcesOperation(IResource resource, IPath newPath,
60	String label) {
61	super(new IResource[] { resource }, new IPath[] { newPath }, label);
62	originalResources = new IResource[] { resource };
63	originalDestinationPaths = new IPath[] { newPath };
64	}
65
66	/**
67	* Create a CopyResourcesOperation that copies all of the specified
68	* resources to a single target location. The original resource name will be
69	* used when copied to the new location.
70	*
71	* @param resources
72	* the resources to be copied
73	* @param destinationPath
74	* the destination path for the copied resource.
75	* @param label
76	* the label of the operation
77	*/
78	public CopyResourcesOperation(IResource[] resources, IPath destinationPath,
79	String label) {
80	super(resources, destinationPath, label);
81	originalResources = resources;
82	originalDestination = destinationPath;
83	}
84
85	/**
86	* Create a CopyResourcesOperation that copies each of the specified
87	* resources to its corresponding destination path in the destination path
88	* array. The resource name for the target is included in the corresponding
89	* destination path.
90	*
91	* @param resources
92	* the resources to be copied
93	* @param destinationPaths
94	* a destination path for each copied resource, which includes
95	* the name of the resource at the new destination
96	* @param label
97	* the label of the operation
98	*/
99	public CopyResourcesOperation(IResource[] resources,
100	IPath[] destinationPaths, String label) {
101	super(resources, destinationPaths, label);
102	originalResources = resources;
103	// the destination array must be copied so it will be remembered.
104	// move and copy operations update the original array.
105	originalDestinationPaths = new IPath[destinationPaths.length];
106	System.arraycopy(destinationPaths, 0, originalDestinationPaths, 0,
107	destinationPaths.length);
108	}
109
110	protected void doExecute(IProgressMonitor monitor, IAdaptable uiInfo)
111	throws CoreException {
112	moveOrCopy(monitor, uiInfo, false); // false = copy
113	}
114
115	protected void doUndo(IProgressMonitor monitor, IAdaptable uiInfo)
116	throws CoreException {
117	monitor
118	.beginTask(
119	UndoMessages.AbstractResourcesOperation_CopyingResourcesProgress,
120	2);
121	// undoing a copy is first deleting the copied resources...
122	AbstractResourcesOperation.delete(resources, new SubProgressMonitor(
123	monitor, 1), uiInfo, true);
124	// then restoring any overwritten by the previous copy...
125	AbstractResourcesOperation.recreate(resourceDescriptions,
126	new SubProgressMonitor(monitor, 1), uiInfo);
127	setResourceDescriptions(new ResourceDescription[0]);
128	// then setting the target resources and destination paths
129	// back to the original ones
130	setTargetResources(originalResources);
131	if (originalDestination != null) {
132	destination = originalDestination;
133	destinationPaths = null;
134	} else {
135	destination = null;
136	destinationPaths = originalDestinationPaths;
137	}
138	monitor.done();
139	}
140
141	protected boolean updateResourceChangeDescriptionFactory(
142	IResourceChangeDescriptionFactory factory, int operation) {
143	boolean update = false;
144	if (operation == UNDO) {
145	for (int i = 0; i < resources.length; i++) {
146	update = true;
147	IResource resource = resources[i];
148	factory.delete(resource);
149	}
150	for (int i = 0; i < resourceDescriptions.length; i++) {
151	update = true;
152	IResource resource = resourceDescriptions[i].createResourceHandle();
153	factory.create(resource);
154	}
155	} else {
156	for (int i = 0; i < resources.length; i++) {
157	update = true;
158	IResource resource = resources[i];
159	factory.copy(resource, getDestinationPath(resource, i, false));
160	}
161	}
162	return update;
163	}
164
165	public IStatus computeExecutionStatus(IProgressMonitor monitor) {
166	IStatus status = super.computeExecutionStatus(monitor);
167	if (status.isOK()) {
168	status = computeMoveOrCopyStatus();
169	}
170	return status;
171	}
172
173	public IStatus computeUndoableStatus(IProgressMonitor monitor) {
174	IStatus status = super.computeUndoableStatus(monitor);
175	// undoing a copy means deleting the copy that was made
176	if (status.isOK()) {
177	status = computeDeleteStatus();
178	}
179	// and if there were resources overwritten by the copy, can we still
180	// recreate them?
181	if (status.isOK() && resourceDescriptions != null
182	&& resourceDescriptions.length > 0) {
183	status = computeCreateStatus();
184	}
185	return status;
186	}
187
188	public IStatus computeRedoableStatus(IProgressMonitor monitor) {
189	IStatus status = super.computeRedoableStatus(monitor);
190	if (status.isOK()) {
191	status = computeMoveOrCopyStatus();
192	}
193	return status;
194	}
195	}