/*******************************************************************************
* 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 com.redhat.ceylon.eclipse.code.wizard;
import static com.redhat.ceylon.eclipse.java2ceylon.Java2CeylonProxies.modelJ2C;
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.resources.IFolder;
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.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
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.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.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.NewWizardMessages;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jdt.ui.wizards.JavaCapabilityConfigurationPage;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.actions.WorkspaceModifyDelegatingOperation;
/**
* 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 NewCeylonProjectWizardPageTwo extends CapabilityConfigurationPage {
private static final String FILENAME_PROJECT = ".project"; //$NON-NLS-1$
private static final String FILENAME_CLASSPATH = ".classpath"; //$NON-NLS-1$
private final NewCeylonProjectWizardPageOne 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 NewCeylonProjectWizardPageTwo}.
*
* @param mainPage the first page of the wizard
*/
public NewCeylonProjectWizardPageTwo(NewCeylonProjectWizardPageOne 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();
}
}
@Override
public void createControl(Composite parent) {
Composite composite = new Composite(parent, SWT.NONE);
composite.setFont(parent.getFont());
composite.setLayout(new GridLayout(1, false));
Control control = getBuildPathsBlock().createControl(composite);
control.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
Dialog.applyDialogFont(composite);
/*PlatformUI.getWorkbench().getHelpSystem().setHelp(composite,
IJavaHelpContextIds.NEW_JAVAPROJECT_WIZARD_PAGE);*/
setControl(composite);
}
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 void createProject(IProject project, URI locationURI, IProgressMonitor monitor)
throws CoreException {
if (monitor == null) {
monitor= new NullProgressMonitor();
}
monitor.beginTask(NewWizardMessages.BuildPathsBlock_operationdesc_project, 10);
// create the project
try {
if (!project.exists()) {
IProjectDescription desc= project.getWorkspace()
.newProjectDescription(project.getName());
if (locationURI != null && ResourcesPlugin.getWorkspace()
.getRoot().getLocationURI().equals(locationURI)) {
locationURI= null;
}
desc.setLocationURI(locationURI);
project.create(desc, monitor);
monitor= null;
}
if (!project.isOpen()) {
project.open(monitor);
monitor= null;
}
} finally {
if (monitor != null) {
monitor.done();
}
}
}
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 (modelJ2C().ceylonModel().getProject(fCurrProject) == null) {
modelJ2C().ceylonModel().addProject(fCurrProject);
}
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 outputJavaLocation = 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();
outputJavaLocation = 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()]);
outputJavaLocation = fFirstPage.getJavaOutputLocation();
if (outputJavaLocation.segmentCount() > 1) {
CoreUtility.createDerivedFolder(root.getFolder(outputJavaLocation),
true, true, new SubProgressMonitor(monitor, 1));
}
}
if (monitor.isCanceled()) {
throw new OperationCanceledException();
}
init(javaProject, outputJavaLocation, entries, false,
fFirstPage.isCompileJava());
} 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) {
if (fOrginalFolders==null) return;
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;
modelJ2C().ceylonModel().removeProject(fCurrProject);
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
}
}
public IProject getProvisonalProject() {
return fCurrProject;
}
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();
}
}
}