| /******************************************************************************* |
| * Copyright (c) 2000, 2011 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jdt.ui.wizards; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.lang.reflect.InvocationTargetException; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.core.filesystem.EFS; |
| import org.eclipse.core.filesystem.IFileInfo; |
| import org.eclipse.core.filesystem.IFileStore; |
| |
| 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.IStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.SubProgressMonitor; |
| |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IResourceStatus; |
| import org.eclipse.core.resources.IWorkspaceRoot; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| |
| import org.eclipse.jface.dialogs.ErrorDialog; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| |
| import org.eclipse.ui.actions.WorkspaceModifyDelegatingOperation; |
| |
| import org.eclipse.jdt.core.IClasspathEntry; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.JavaCore; |
| |
| import org.eclipse.jdt.internal.corext.util.Messages; |
| |
| import org.eclipse.jdt.ui.JavaUI; |
| |
| import org.eclipse.jdt.internal.ui.JavaPlugin; |
| import org.eclipse.jdt.internal.ui.dialogs.StatusInfo; |
| import org.eclipse.jdt.internal.ui.util.CoreUtility; |
| import org.eclipse.jdt.internal.ui.util.ExceptionHandler; |
| import org.eclipse.jdt.internal.ui.wizards.ClassPathDetector; |
| import org.eclipse.jdt.internal.ui.wizards.NewWizardMessages; |
| |
| /** |
| * The second page of the New Java project wizard. It allows to configure the build path and output location. |
| * As addition to the {@link JavaCapabilityConfigurationPage}, the wizard page does an |
| * early project creation (so that linked folders can be defined) and, if an |
| * existing external location was specified, detects the class path. |
| * |
| * <p> |
| * Clients may instantiate or subclass. |
| * </p> |
| * |
| * @since 3.4 |
| */ |
| public class NewJavaProjectWizardPageTwo extends JavaCapabilityConfigurationPage { |
| |
| private static final String FILENAME_PROJECT= ".project"; //$NON-NLS-1$ |
| private static final String FILENAME_CLASSPATH= ".classpath"; //$NON-NLS-1$ |
| |
| private final NewJavaProjectWizardPageOne fFirstPage; |
| |
| private URI fCurrProjectLocation; // null if location is platform location |
| private IProject fCurrProject; |
| |
| private boolean fKeepContent; |
| |
| private File fDotProjectBackup; |
| private File fDotClasspathBackup; |
| private Boolean fIsAutobuild; |
| private HashSet<IFileStore> fOrginalFolders; |
| |
| /** |
| * Constructor for the {@link NewJavaProjectWizardPageTwo}. |
| * |
| * @param mainPage the first page of the wizard |
| */ |
| public NewJavaProjectWizardPageTwo(NewJavaProjectWizardPageOne mainPage) { |
| fFirstPage= mainPage; |
| fCurrProjectLocation= null; |
| fCurrProject= null; |
| fKeepContent= false; |
| |
| fDotProjectBackup= null; |
| fDotClasspathBackup= null; |
| fIsAutobuild= null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jdt.ui.wizards.JavaCapabilityConfigurationPage#useNewSourcePage() |
| */ |
| @Override |
| protected final boolean useNewSourcePage() { |
| return true; |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.dialogs.IDialogPage#setVisible(boolean) |
| */ |
| @Override |
| public void setVisible(boolean visible) { |
| boolean isShownFirstTime= visible && fCurrProject == null; |
| if (visible) { |
| if (isShownFirstTime) { // entering from the first page |
| createProvisonalProject(); |
| } |
| } else { |
| if (getContainer().getCurrentPage() == fFirstPage) { // leaving back to the first page |
| removeProvisonalProject(); |
| } |
| } |
| super.setVisible(visible); |
| if (isShownFirstTime) { |
| setFocus(); |
| } |
| } |
| |
| |
| |
| private boolean hasExistingContent(URI realLocation) throws CoreException { |
| IFileStore file= EFS.getStore(realLocation); |
| return file.fetchInfo().exists(); |
| } |
| |
| private IStatus changeToNewProject() { |
| class UpdateRunnable implements IRunnableWithProgress { |
| public IStatus infoStatus= Status.OK_STATUS; |
| |
| public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException { |
| try { |
| if (fIsAutobuild == null) { |
| fIsAutobuild= Boolean.valueOf(CoreUtility.setAutoBuilding(false)); |
| } |
| infoStatus= updateProject(monitor); |
| } catch (CoreException e) { |
| throw new InvocationTargetException(e); |
| } catch (OperationCanceledException e) { |
| throw new InterruptedException(); |
| } finally { |
| monitor.done(); |
| } |
| } |
| } |
| UpdateRunnable op= new UpdateRunnable(); |
| try { |
| getContainer().run(true, false, new WorkspaceModifyDelegatingOperation(op)); |
| return op.infoStatus; |
| } catch (InvocationTargetException e) { |
| final String title= NewWizardMessages.NewJavaProjectWizardPageTwo_error_title; |
| final String message= NewWizardMessages.NewJavaProjectWizardPageTwo_error_message; |
| ExceptionHandler.handle(e, getShell(), title, message); |
| } catch (InterruptedException e) { |
| // cancel pressed |
| } |
| return null; |
| } |
| |
| private static URI getRealLocation(String projectName, URI location) { |
| if (location == null) { // inside workspace |
| try { |
| URI rootLocation= ResourcesPlugin.getWorkspace().getRoot().getLocationURI(); |
| |
| location= new URI(rootLocation.getScheme(), null, |
| Path.fromPortableString(rootLocation.getPath()).append(projectName).toString(), |
| null); |
| } catch (URISyntaxException e) { |
| Assert.isTrue(false, "Can't happen"); //$NON-NLS-1$ |
| } |
| } |
| return location; |
| } |
| |
| private final IStatus updateProject(IProgressMonitor monitor) throws CoreException, InterruptedException { |
| IStatus result= StatusInfo.OK_STATUS; |
| if (monitor == null) { |
| monitor= new NullProgressMonitor(); |
| } |
| try { |
| monitor.beginTask(NewWizardMessages.NewJavaProjectWizardPageTwo_operation_initialize, 7); |
| if (monitor.isCanceled()) { |
| throw new OperationCanceledException(); |
| } |
| |
| String projectName= fFirstPage.getProjectName(); |
| |
| fCurrProject= ResourcesPlugin.getWorkspace().getRoot().getProject(projectName); |
| fCurrProjectLocation= fFirstPage.getProjectLocationURI(); |
| |
| URI realLocation= getRealLocation(projectName, fCurrProjectLocation); |
| fKeepContent= hasExistingContent(realLocation); |
| |
| if (monitor.isCanceled()) { |
| throw new OperationCanceledException(); |
| } |
| |
| if (fKeepContent) { |
| rememberExistingFiles(realLocation); |
| rememberExisitingFolders(realLocation); |
| } |
| |
| if (monitor.isCanceled()) { |
| throw new OperationCanceledException(); |
| } |
| |
| try { |
| createProject(fCurrProject, fCurrProjectLocation, new SubProgressMonitor(monitor, 2)); |
| } catch (CoreException e) { |
| if (e.getStatus().getCode() == IResourceStatus.FAILED_READ_METADATA) { |
| result= new StatusInfo(IStatus.INFO, Messages.format(NewWizardMessages.NewJavaProjectWizardPageTwo_DeleteCorruptProjectFile_message, e.getLocalizedMessage())); |
| |
| deleteProjectFile(realLocation); |
| if (fCurrProject.exists()) |
| fCurrProject.delete(true, null); |
| |
| createProject(fCurrProject, fCurrProjectLocation, null); |
| } else { |
| throw e; |
| } |
| } |
| |
| if (monitor.isCanceled()) { |
| throw new OperationCanceledException(); |
| } |
| |
| initializeBuildPath(JavaCore.create(fCurrProject), new SubProgressMonitor(monitor, 2)); |
| configureJavaProject(new SubProgressMonitor(monitor, 3)); // create the Java project to allow the use of the new source folder page |
| } finally { |
| monitor.done(); |
| } |
| return result; |
| } |
| |
| /** |
| * Evaluates the new build path and output folder according to the settings on the first page. |
| * The resulting build path is set by calling {@link #init(IJavaProject, IPath, IClasspathEntry[], boolean)}. |
| * Clients can override this method. |
| * |
| * @param javaProject the new project which is already created when this method is called. |
| * @param monitor the progress monitor |
| * @throws CoreException thrown when initializing the build path failed |
| */ |
| protected void initializeBuildPath(IJavaProject javaProject, IProgressMonitor monitor) throws CoreException { |
| if (monitor == null) { |
| monitor= new NullProgressMonitor(); |
| } |
| monitor.beginTask(NewWizardMessages.NewJavaProjectWizardPageTwo_monitor_init_build_path, 2); |
| |
| try { |
| IClasspathEntry[] entries= null; |
| IPath outputLocation= null; |
| IProject project= javaProject.getProject(); |
| |
| if (fKeepContent) { |
| if (!project.getFile(FILENAME_CLASSPATH).exists()) { |
| final ClassPathDetector detector= new ClassPathDetector(fCurrProject, new SubProgressMonitor(monitor, 2)); |
| entries= detector.getClasspath(); |
| outputLocation= detector.getOutputLocation(); |
| if (entries.length == 0) |
| entries= null; |
| } else { |
| monitor.worked(2); |
| } |
| } else { |
| List<IClasspathEntry> cpEntries= new ArrayList<IClasspathEntry>(); |
| IWorkspaceRoot root= project.getWorkspace().getRoot(); |
| |
| IClasspathEntry[] sourceClasspathEntries= fFirstPage.getSourceClasspathEntries(); |
| for (int i= 0; i < sourceClasspathEntries.length; i++) { |
| IPath path= sourceClasspathEntries[i].getPath(); |
| if (path.segmentCount() > 1) { |
| IFolder folder= root.getFolder(path); |
| CoreUtility.createFolder(folder, true, true, new SubProgressMonitor(monitor, 1)); |
| } |
| cpEntries.add(sourceClasspathEntries[i]); |
| } |
| |
| cpEntries.addAll(Arrays.asList(fFirstPage.getDefaultClasspathEntries())); |
| |
| entries= cpEntries.toArray(new IClasspathEntry[cpEntries.size()]); |
| |
| outputLocation= fFirstPage.getOutputLocation(); |
| if (outputLocation.segmentCount() > 1) { |
| IFolder folder= root.getFolder(outputLocation); |
| CoreUtility.createDerivedFolder(folder, true, true, new SubProgressMonitor(monitor, 1)); |
| } |
| } |
| if (monitor.isCanceled()) { |
| throw new OperationCanceledException(); |
| } |
| |
| init(javaProject, outputLocation, entries, false); |
| } finally { |
| monitor.done(); |
| } |
| } |
| |
| private void deleteProjectFile(URI projectLocation) throws CoreException { |
| IFileStore file= EFS.getStore(projectLocation); |
| if (file.fetchInfo().exists()) { |
| IFileStore projectFile= file.getChild(FILENAME_PROJECT); |
| if (projectFile.fetchInfo().exists()) { |
| projectFile.delete(EFS.NONE, null); |
| } |
| } |
| } |
| |
| private void rememberExisitingFolders(URI projectLocation) { |
| fOrginalFolders= new HashSet<IFileStore>(); |
| |
| try { |
| IFileStore[] children= EFS.getStore(projectLocation).childStores(EFS.NONE, null); |
| for (int i= 0; i < children.length; i++) { |
| IFileStore child= children[i]; |
| IFileInfo info= child.fetchInfo(); |
| if (info.isDirectory() && info.exists() && !fOrginalFolders.contains(child.getName())) { |
| fOrginalFolders.add(child); |
| } |
| } |
| } catch (CoreException e) { |
| JavaPlugin.log(e); |
| } |
| } |
| |
| private void restoreExistingFolders(URI projectLocation) { |
| try { |
| IFileStore[] children= EFS.getStore(projectLocation).childStores(EFS.NONE, null); |
| for (int i= 0; i < children.length; i++) { |
| IFileStore child= children[i]; |
| IFileInfo info= child.fetchInfo(); |
| if (info.isDirectory() && info.exists() && !fOrginalFolders.contains(child)) { |
| child.delete(EFS.NONE, null); |
| fOrginalFolders.remove(child); |
| } |
| } |
| |
| for (Iterator<IFileStore> iterator= fOrginalFolders.iterator(); iterator.hasNext();) { |
| IFileStore deleted= iterator.next(); |
| deleted.mkdir(EFS.NONE, null); |
| } |
| } catch (CoreException e) { |
| JavaPlugin.log(e); |
| } |
| } |
| |
| private void rememberExistingFiles(URI projectLocation) throws CoreException { |
| fDotProjectBackup= null; |
| fDotClasspathBackup= null; |
| |
| IFileStore file= EFS.getStore(projectLocation); |
| if (file.fetchInfo().exists()) { |
| IFileStore projectFile= file.getChild(FILENAME_PROJECT); |
| if (projectFile.fetchInfo().exists()) { |
| fDotProjectBackup= createBackup(projectFile, "project-desc"); //$NON-NLS-1$ |
| } |
| IFileStore classpathFile= file.getChild(FILENAME_CLASSPATH); |
| if (classpathFile.fetchInfo().exists()) { |
| fDotClasspathBackup= createBackup(classpathFile, "classpath-desc"); //$NON-NLS-1$ |
| } |
| } |
| } |
| |
| private void restoreExistingFiles(URI projectLocation, IProgressMonitor monitor) throws CoreException { |
| int ticks= ((fDotProjectBackup != null ? 1 : 0) + (fDotClasspathBackup != null ? 1 : 0)) * 2; |
| monitor.beginTask("", ticks); //$NON-NLS-1$ |
| try { |
| IFileStore projectFile= EFS.getStore(projectLocation).getChild(FILENAME_PROJECT); |
| projectFile.delete(EFS.NONE, new SubProgressMonitor(monitor, 1)); |
| if (fDotProjectBackup != null) { |
| copyFile(fDotProjectBackup, projectFile, new SubProgressMonitor(monitor, 1)); |
| } |
| } catch (IOException e) { |
| IStatus status= new Status(IStatus.ERROR, JavaUI.ID_PLUGIN, IStatus.ERROR, NewWizardMessages.NewJavaProjectWizardPageTwo_problem_restore_project, e); |
| throw new CoreException(status); |
| } |
| try { |
| IFileStore classpathFile= EFS.getStore(projectLocation).getChild(FILENAME_CLASSPATH); |
| classpathFile.delete(EFS.NONE, new SubProgressMonitor(monitor, 1)); |
| if (fDotClasspathBackup != null) { |
| copyFile(fDotClasspathBackup, classpathFile, new SubProgressMonitor(monitor, 1)); |
| } |
| } catch (IOException e) { |
| IStatus status= new Status(IStatus.ERROR, JavaUI.ID_PLUGIN, IStatus.ERROR, NewWizardMessages.NewJavaProjectWizardPageTwo_problem_restore_classpath, e); |
| throw new CoreException(status); |
| } |
| } |
| |
| private File createBackup(IFileStore source, String name) throws CoreException { |
| try { |
| File bak= File.createTempFile("eclipse-" + name, ".bak"); //$NON-NLS-1$//$NON-NLS-2$ |
| copyFile(source, bak); |
| return bak; |
| } catch (IOException e) { |
| IStatus status= new Status(IStatus.ERROR, JavaUI.ID_PLUGIN, IStatus.ERROR, Messages.format(NewWizardMessages.NewJavaProjectWizardPageTwo_problem_backup, name), e); |
| throw new CoreException(status); |
| } |
| } |
| |
| private void copyFile(IFileStore source, File target) throws IOException, CoreException { |
| InputStream is= source.openInputStream(EFS.NONE, null); |
| FileOutputStream os= new FileOutputStream(target); |
| copyFile(is, os); |
| } |
| |
| private void copyFile(File source, IFileStore target, IProgressMonitor monitor) throws IOException, CoreException { |
| FileInputStream is= new FileInputStream(source); |
| OutputStream os= target.openOutputStream(EFS.NONE, monitor); |
| copyFile(is, os); |
| } |
| |
| private void copyFile(InputStream is, OutputStream os) throws IOException { |
| try { |
| byte[] buffer = new byte[8192]; |
| while (true) { |
| int bytesRead= is.read(buffer); |
| if (bytesRead == -1) |
| break; |
| |
| os.write(buffer, 0, bytesRead); |
| } |
| } finally { |
| try { |
| is.close(); |
| } finally { |
| os.close(); |
| } |
| } |
| } |
| |
| /** |
| * Called from the wizard on finish. |
| * |
| * @param monitor the progress monitor |
| * @throws CoreException thrown when the project creation or configuration failed |
| * @throws InterruptedException thrown when the user cancelled the project creation |
| */ |
| public void performFinish(IProgressMonitor monitor) throws CoreException, InterruptedException { |
| try { |
| monitor.beginTask(NewWizardMessages.NewJavaProjectWizardPageTwo_operation_create, 3); |
| if (fCurrProject == null) { |
| updateProject(new SubProgressMonitor(monitor, 1)); |
| } |
| String newProjectCompliance= fKeepContent ? null : fFirstPage.getCompilerCompliance(); |
| configureJavaProject(newProjectCompliance, new SubProgressMonitor(monitor, 2)); |
| |
| } finally { |
| monitor.done(); |
| fCurrProject= null; |
| if (fIsAutobuild != null) { |
| CoreUtility.setAutoBuilding(fIsAutobuild.booleanValue()); |
| fIsAutobuild= null; |
| } |
| } |
| } |
| |
| /** |
| * Creates the provisional project on which the wizard is working on. The provisional project is typically |
| * created when the page is entered the first time. The early project creation is required to configure linked folders. |
| * |
| * @return the provisional project |
| */ |
| protected IProject createProvisonalProject() { |
| IStatus status= changeToNewProject(); |
| if (status != null && !status.isOK()) { |
| ErrorDialog.openError(getShell(), NewWizardMessages.NewJavaProjectWizardPageTwo_error_title, null, status); |
| } |
| return fCurrProject; |
| } |
| |
| /** |
| * Removes the provisional project. The provisional project is typically removed when the user cancels the wizard or goes |
| * back to the first page. |
| */ |
| protected void removeProvisonalProject() { |
| if (!fCurrProject.exists()) { |
| fCurrProject= null; |
| return; |
| } |
| |
| IRunnableWithProgress op= new IRunnableWithProgress() { |
| public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException { |
| doRemoveProject(monitor); |
| } |
| }; |
| |
| try { |
| getContainer().run(true, true, new WorkspaceModifyDelegatingOperation(op)); |
| } catch (InvocationTargetException e) { |
| final String title= NewWizardMessages.NewJavaProjectWizardPageTwo_error_remove_title; |
| final String message= NewWizardMessages.NewJavaProjectWizardPageTwo_error_remove_message; |
| ExceptionHandler.handle(e, getShell(), title, message); |
| } catch (InterruptedException e) { |
| // cancel pressed |
| } |
| } |
| |
| private final void doRemoveProject(IProgressMonitor monitor) throws InvocationTargetException { |
| final boolean noProgressMonitor= (fCurrProjectLocation == null); // inside workspace |
| if (monitor == null || noProgressMonitor) { |
| monitor= new NullProgressMonitor(); |
| } |
| monitor.beginTask(NewWizardMessages.NewJavaProjectWizardPageTwo_operation_remove, 3); |
| try { |
| try { |
| URI projLoc= fCurrProject.getLocationURI(); |
| |
| boolean removeContent= !fKeepContent && fCurrProject.isSynchronized(IResource.DEPTH_INFINITE); |
| if (!removeContent) { |
| restoreExistingFolders(projLoc); |
| } |
| fCurrProject.delete(removeContent, false, new SubProgressMonitor(monitor, 2)); |
| |
| restoreExistingFiles(projLoc, new SubProgressMonitor(monitor, 1)); |
| } finally { |
| CoreUtility.setAutoBuilding(fIsAutobuild.booleanValue()); // fIsAutobuild must be set |
| fIsAutobuild= null; |
| } |
| } catch (CoreException e) { |
| throw new InvocationTargetException(e); |
| } finally { |
| monitor.done(); |
| fCurrProject= null; |
| fKeepContent= false; |
| } |
| } |
| |
| /** |
| * Called from the wizard on cancel. |
| */ |
| public void performCancel() { |
| if (fCurrProject != null) { |
| removeProvisonalProject(); |
| } |
| } |
| } |