tests/org.eclipse.wst.xml.core.tests/src/org/eclipse/wst/xml/core/tests/util/ProjectUnzipUtility.java - sourceediting/webtools.sourceediting.tests - Git at Google

 /*******************************************************************************
  * Copyright (c) 2004 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.wst.xml.core.tests.util;

 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Enumeration;
 import java.util.List;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;

 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IProjectDescription;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.ui.actions.WorkspaceModifyOperation;
 import org.eclipse.ui.dialogs.IOverwriteQuery;
 import org.eclipse.ui.wizards.datatransfer.FileSystemStructureProvider;
 import org.eclipse.ui.wizards.datatransfer.IImportStructureProvider;
 import org.eclipse.ui.wizards.datatransfer.ImportOperation;

 /**
  * Imports zipped files into the test workspace. Deletes all projects in
  * workspace.
  *
  * @author pavery
  */
 public class ProjectUnzipUtility {
 	class WorkspaceProgressMonitor implements IProgressMonitor {
 		private boolean finished = false;

 		public void beginTask(String name, int totalWork) {
 			// noop
 		}

 		public void done() {
 			finished = true;
 		}

 		public boolean isFinished() {
 			return finished;
 		}

 		public void internalWorked(double work) {
 			// noop
 		}

 		public boolean isCanceled() {
 			return finished;
 		}

 		public void setCanceled(boolean value) {
 			if (value == true)
 				finished = true;
 		}

 		public void setTaskName(String name) {
 			// noop
 		}

 		public void subTask(String name) {
 			// noop
 		}

 		public void worked(int work) {
 			// noop
 		}
 	}

 	class MyOverwriteQuery implements IOverwriteQuery {
 		public String queryOverwrite(String pathString) {
 			return ALL;
 		}
 	}

 	public final static String PROJECT_ZIPS_FOLDER = "projecttestfiles";
 	private List fCreatedProjects = null;

 	public ProjectUnzipUtility() {
 		// for deletion later
 		fCreatedProjects = new ArrayList();
 	}

 	/**
 	 * @param fileToImport
 	 *            the file you wish to import
 	 * @param folderPath
 	 *            the container path within the workspace
 	 */
 	public void importFile(File fileToImport, String folderPath) {
 		WorkspaceProgressMonitor importProgress = new WorkspaceProgressMonitor();
 		try {
 			if (fileToImport.exists()) {
 				IPath containerPath = new Path(folderPath);
 				//fCreatedProjects.add(folderPath);
 				IImportStructureProvider provider = FileSystemStructureProvider.INSTANCE;
 				IOverwriteQuery overwriteImplementor = new MyOverwriteQuery();
 				File[] filesToImport = {fileToImport};
 				ImportOperation importOp = new ImportOperation(containerPath, null, provider, overwriteImplementor, Arrays.asList(filesToImport));
 				importOp.setCreateContainerStructure(false);
 				importOp.setOverwriteResources(true);
 				importOp.run(importProgress);
 			}
 			else {
 				System.out.println("handle source doesn't exist");
 			}
 		}
 		catch (Exception ex) {
 			ex.printStackTrace();
 		}
 		finally {
 			importProgress.done();
 		}
 	}

 	/**
 	 * the following is logic from
 	 * http://www.devshed.com/c/a/Java/Zip-Meets-Java/2/
 	 */
 	// specify buffer size for extraction
 	static final int BUFFER = 2048;

 	public void unzipAndImport(File inFile, String destinationDirectory) {
 		try {
 			// Specify file to decompress
 			String inFileName = inFile.getAbsolutePath(); //"c:/example.zip";
 			// Specify destination where file will be unzipped
 			//String destinationDirectory =
 			// "d:/eclipsedev/M5_SSE_TESTS_WORKSPACE/"; //"c:/temp/";
 			File sourceZipFile = new File(inFileName);
 			File unzipDestinationDirectory = new File(destinationDirectory);
 			// Open Zip file for reading
 			ZipFile zipFile = new ZipFile(sourceZipFile, ZipFile.OPEN_READ);
 			// Create an enumeration of the entries in the zip file
 			Enumeration zipFileEntries = zipFile.entries();
 			String projectFolderName = null;
 			IProject currentProject = null;
 			// Process each entry
 			while (zipFileEntries.hasMoreElements()) {
 				// grab a zip file entry
 				ZipEntry entry = (ZipEntry) zipFileEntries.nextElement();
 				String currentEntry = entry.getName();
 				//System.out.println("Extracting: " + entry);
 				File destFile = new File(unzipDestinationDirectory, currentEntry);
 				// grab file's parent directory structure
 				File destinationParent = destFile.getParentFile();
 				// create the parent directory structure if needed
 				destinationParent.mkdirs();
 				// extract file if not a directory
 				if (!entry.isDirectory()) {
 					BufferedInputStream is = new BufferedInputStream(zipFile.getInputStream(entry));
 					int currentByte;
 					// establish buffer for writing file
 					byte data[] = new byte[BUFFER];
 					// write the current file to disk
 					FileOutputStream fos = new FileOutputStream(destFile);
 					BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
 					// read and write until last byte is encountered
 					while ((currentByte = is.read(data, 0, BUFFER)) != -1) {
 						dest.write(data, 0, currentByte);
 					}
 					dest.flush();
 					dest.close();
 					is.close();
 					if (projectFolderName != null)
 						importFile(destFile, projectFolderName);
 				}
 				else {
 					// need handle to the main project folder to create
 					// containerPath
 					// unlike version in sse.tests, we don't create project
 					// for
 					// every directory
 					//					if(projectFolderName == null) {
 					//						projectFolderName = destFile.getName();
 					//						fCreatedProjects.add(projectFolderName);
 					//
 					//						currentProject =
 					// ResourcesPlugin.getWorkspace().getRoot().getProject(projectFolderName);
 					//					}
 				}
 			}
 			zipFile.close();
 			// fixes workspace metadata for the project
 			// for clean startup next run
 			if (currentProject != null) {
 				try {
 					Path projectLocation = new Path(Platform.getLocation().toOSString());
 					createProject(currentProject, projectLocation, new WorkspaceProgressMonitor());
 				}
 				catch (CoreException cex) {
 					cex.printStackTrace();
 				}
 			}
 		}
 		catch (IOException ioe) {
 			ioe.printStackTrace();
 		}
 	}

 	/**
 	 *
 	 */
 	public void refreshWorkspace() throws CoreException {
 		IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
 		IProject[] projects = wsRoot.getProjects();
 		for (int i = 0; i < projects.length; i++) {
 			projects[i].refreshLocal(IResource.DEPTH_INFINITE, null);
 		}
 		wsRoot.refreshLocal(IResource.DEPTH_INFINITE, null);
 	}

 	/**
 	 * Delete projects created (unzipped and imported) by this utility
 	 *
 	 * @throws Exception
 	 */
 	public void deleteProjects() throws Exception {
 		final IProject[] projects = getCreatedProjects();
 		WorkspaceModifyOperation deleteOp = new WorkspaceModifyOperation() {
 			protected void execute(IProgressMonitor monitor) throws CoreException {
 				for (int i = 0; i < projects.length; i++) {
 					projects[i].clearHistory(null);
 					projects[i].close(null);
 					projects[i].delete(true, true, null);
 				}
 				refreshWorkspace();
 			}
 		};
 		WorkspaceProgressMonitor progress = new WorkspaceProgressMonitor();
 		deleteOp.run(progress);
 		// saves the new workspace metadata
 		ResourcesPlugin.getWorkspace().save(true, null);
 	}

 	public void deleteProject(String projectName) throws Exception {
 		final String name = projectName;
 		IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
 		final IProject proj = wsRoot.getProject(name);
 		WorkspaceModifyOperation deleteOp = new WorkspaceModifyOperation(proj) {
 			protected void execute(IProgressMonitor monitor) throws CoreException {
 				//				IWorkspaceRoot wsRoot =
 				// ResourcesPlugin.getWorkspace().getRoot();
 				//				IProject proj = wsRoot.getProject(name);
 				if (proj != null && proj.exists()) {
 					proj.clearHistory(null);
 					//proj.close(null);
 					proj.refreshLocal(IResource.DEPTH_INFINITE, null);
 					try {
 						proj.delete(true, true, null);
 					}
 					catch (Exception e) {
 						// just try again (not sure why they are not being
 						// deleted)
 						proj.refreshLocal(IResource.DEPTH_INFINITE, null);
 						proj.delete(true, true, null);
 					}
 					//proj = null;
 				}
 				refreshWorkspace();
 			}
 		};
 		WorkspaceProgressMonitor progress = new WorkspaceProgressMonitor();
 		deleteOp.run(progress);
 		// saves the new workspace metadata
 		ResourcesPlugin.getWorkspace().save(true, null);
 	}

 	/**
 	 * @return IProjects that were unzipped and imported into the workspace by
 	 *         this utility
 	 */
 	public IProject[] getCreatedProjects() {
 		IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
 		String[] projectNames = (String[]) fCreatedProjects.toArray(new String[fCreatedProjects.size()]);
 		IProject[] projects = new IProject[projectNames.length];
 		for (int i = 0; i < projectNames.length; i++) {
 			projects[i] = wsRoot.getProject(projectNames[i]);
 		}
 		return projects;
 	}

 	public void initJavaProject(String projName) throws CoreException {
 		// resynch
 		refreshWorkspace();
 		//change prereqs to get this functionality back in
 		IProject proj = ResourcesPlugin.getWorkspace().getRoot().getProject(projName);
 		if (!proj.exists()) {
 			proj.create(new NullProgressMonitor());
 		}
 		// need to add java nature, or else project won't "exist()" in the
 		// java
 		// element sense
 		String[] natureIds = {"org.eclipse.jdt.core.javanature"};
 		if (!proj.isOpen()) {
 			proj.open(null);
 		}
 		IProjectDescription desc = proj.getDescription();
 		desc.setNatureIds(natureIds);
 		proj.setDescription(desc, new NullProgressMonitor());
 	}

 	private void createProject(IProject project, IPath locationPath, IProgressMonitor monitor) throws CoreException {
 		if (monitor == null) {
 			monitor = new WorkspaceProgressMonitor();
 		}
 		monitor.beginTask("creating test project", 10);
 		// create the project
 		try {
 			if (!project.exists()) {
 				IProjectDescription desc = project.getWorkspace().newProjectDescription(project.getName());
 				if (Platform.getLocation().equals(locationPath)) {
 					locationPath = null;
 				}
 				desc.setLocation(locationPath);
 				project.create(desc, monitor);
 				monitor = null;
 			}
 			if (!project.isOpen()) {
 				project.open(monitor);
 				monitor = null;
 			}
 		}
 		finally {
 			if (monitor != null) {
 				monitor.done();
 			}
 		}
 	}

 	public void deleteProject(IProject fProject) throws InvocationTargetException, InterruptedException {
 		final IProject proj = fProject;
 		WorkspaceModifyOperation deleteOp = new WorkspaceModifyOperation(proj) {
 			protected void execute(IProgressMonitor monitor) throws CoreException {
 				//				IWorkspaceRoot wsRoot =
 				// ResourcesPlugin.getWorkspace().getRoot();
 				//				IProject proj = wsRoot.getProject(name);
 				if (proj != null && proj.exists()) {
 					proj.clearHistory(null);
 					//proj.close(null);
 					proj.refreshLocal(IResource.DEPTH_INFINITE, null);
 					proj.delete(true, true, null);
 					//proj = null;
 				}
 				refreshWorkspace();
 			}
 		};
 		//WorkspaceProgressMonitor progress = new WorkspaceProgressMonitor();
 		deleteOp.run(null);
 		// saves the new workspace metadata
 		//ResourcesPlugin.getWorkspace().save(true, null);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2004 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.wst.xml.core.tests.util;

	import java.io.BufferedInputStream;
	import java.io.BufferedOutputStream;
	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.lang.reflect.InvocationTargetException;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Enumeration;
	import java.util.List;
	import java.util.zip.ZipEntry;
	import java.util.zip.ZipFile;

	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IProjectDescription;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.resources.IWorkspaceRoot;
	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.core.runtime.Platform;
	import org.eclipse.ui.actions.WorkspaceModifyOperation;
	import org.eclipse.ui.dialogs.IOverwriteQuery;
	import org.eclipse.ui.wizards.datatransfer.FileSystemStructureProvider;
	import org.eclipse.ui.wizards.datatransfer.IImportStructureProvider;
	import org.eclipse.ui.wizards.datatransfer.ImportOperation;

	/**
	* Imports zipped files into the test workspace. Deletes all projects in
	* workspace.
	*
	* @author pavery
	*/
	public class ProjectUnzipUtility {
	class WorkspaceProgressMonitor implements IProgressMonitor {
	private boolean finished = false;

	public void beginTask(String name, int totalWork) {
	// noop
	}

	public void done() {
	finished = true;
	}

	public boolean isFinished() {
	return finished;
	}

	public void internalWorked(double work) {
	// noop
	}

	public boolean isCanceled() {
	return finished;
	}

	public void setCanceled(boolean value) {
	if (value == true)
	finished = true;
	}

	public void setTaskName(String name) {
	// noop
	}

	public void subTask(String name) {
	// noop
	}

	public void worked(int work) {
	// noop
	}
	}

	class MyOverwriteQuery implements IOverwriteQuery {
	public String queryOverwrite(String pathString) {
	return ALL;
	}
	}

	public final static String PROJECT_ZIPS_FOLDER = "projecttestfiles";
	private List fCreatedProjects = null;

	public ProjectUnzipUtility() {
	// for deletion later
	fCreatedProjects = new ArrayList();
	}

	/**
	* @param fileToImport
	* the file you wish to import
	* @param folderPath
	* the container path within the workspace
	*/
	public void importFile(File fileToImport, String folderPath) {
	WorkspaceProgressMonitor importProgress = new WorkspaceProgressMonitor();
	try {
	if (fileToImport.exists()) {
	IPath containerPath = new Path(folderPath);
	//fCreatedProjects.add(folderPath);
	IImportStructureProvider provider = FileSystemStructureProvider.INSTANCE;
	IOverwriteQuery overwriteImplementor = new MyOverwriteQuery();
	File[] filesToImport = {fileToImport};
	ImportOperation importOp = new ImportOperation(containerPath, null, provider, overwriteImplementor, Arrays.asList(filesToImport));
	importOp.setCreateContainerStructure(false);
	importOp.setOverwriteResources(true);
	importOp.run(importProgress);
	}
	else {
	System.out.println("handle source doesn't exist");
	}
	}
	catch (Exception ex) {
	ex.printStackTrace();
	}
	finally {
	importProgress.done();
	}
	}

	/**
	* the following is logic from
	* http://www.devshed.com/c/a/Java/Zip-Meets-Java/2/
	*/
	// specify buffer size for extraction
	static final int BUFFER = 2048;

	public void unzipAndImport(File inFile, String destinationDirectory) {
	try {
	// Specify file to decompress
	String inFileName = inFile.getAbsolutePath(); //"c:/example.zip";
	// Specify destination where file will be unzipped
	//String destinationDirectory =
	// "d:/eclipsedev/M5_SSE_TESTS_WORKSPACE/"; //"c:/temp/";
	File sourceZipFile = new File(inFileName);
	File unzipDestinationDirectory = new File(destinationDirectory);
	// Open Zip file for reading
	ZipFile zipFile = new ZipFile(sourceZipFile, ZipFile.OPEN_READ);
	// Create an enumeration of the entries in the zip file
	Enumeration zipFileEntries = zipFile.entries();
	String projectFolderName = null;
	IProject currentProject = null;
	// Process each entry
	while (zipFileEntries.hasMoreElements()) {
	// grab a zip file entry
	ZipEntry entry = (ZipEntry) zipFileEntries.nextElement();
	String currentEntry = entry.getName();
	//System.out.println("Extracting: " + entry);
	File destFile = new File(unzipDestinationDirectory, currentEntry);
	// grab file's parent directory structure
	File destinationParent = destFile.getParentFile();
	// create the parent directory structure if needed
	destinationParent.mkdirs();
	// extract file if not a directory
	if (!entry.isDirectory()) {
	BufferedInputStream is = new BufferedInputStream(zipFile.getInputStream(entry));
	int currentByte;
	// establish buffer for writing file
	byte data[] = new byte[BUFFER];
	// write the current file to disk
	FileOutputStream fos = new FileOutputStream(destFile);
	BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
	// read and write until last byte is encountered
	while ((currentByte = is.read(data, 0, BUFFER)) != -1) {
	dest.write(data, 0, currentByte);
	}
	dest.flush();
	dest.close();
	is.close();
	if (projectFolderName != null)
	importFile(destFile, projectFolderName);
	}
	else {
	// need handle to the main project folder to create
	// containerPath
	// unlike version in sse.tests, we don't create project
	// for
	// every directory
	// if(projectFolderName == null) {
	// projectFolderName = destFile.getName();
	// fCreatedProjects.add(projectFolderName);
	//
	// currentProject =
	// ResourcesPlugin.getWorkspace().getRoot().getProject(projectFolderName);
	// }
	}
	}
	zipFile.close();
	// fixes workspace metadata for the project
	// for clean startup next run
	if (currentProject != null) {
	try {
	Path projectLocation = new Path(Platform.getLocation().toOSString());
	createProject(currentProject, projectLocation, new WorkspaceProgressMonitor());
	}
	catch (CoreException cex) {
	cex.printStackTrace();
	}
	}
	}
	catch (IOException ioe) {
	ioe.printStackTrace();
	}
	}

	/**
	*
	*/
	public void refreshWorkspace() throws CoreException {
	IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
	IProject[] projects = wsRoot.getProjects();
	for (int i = 0; i < projects.length; i++) {
	projects[i].refreshLocal(IResource.DEPTH_INFINITE, null);
	}
	wsRoot.refreshLocal(IResource.DEPTH_INFINITE, null);
	}

	/**
	* Delete projects created (unzipped and imported) by this utility
	*
	* @throws Exception
	*/
	public void deleteProjects() throws Exception {
	final IProject[] projects = getCreatedProjects();
	WorkspaceModifyOperation deleteOp = new WorkspaceModifyOperation() {
	protected void execute(IProgressMonitor monitor) throws CoreException {
	for (int i = 0; i < projects.length; i++) {
	projects[i].clearHistory(null);
	projects[i].close(null);
	projects[i].delete(true, true, null);
	}
	refreshWorkspace();
	}
	};
	WorkspaceProgressMonitor progress = new WorkspaceProgressMonitor();
	deleteOp.run(progress);
	// saves the new workspace metadata
	ResourcesPlugin.getWorkspace().save(true, null);
	}

	public void deleteProject(String projectName) throws Exception {
	final String name = projectName;
	IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
	final IProject proj = wsRoot.getProject(name);
	WorkspaceModifyOperation deleteOp = new WorkspaceModifyOperation(proj) {
	protected void execute(IProgressMonitor monitor) throws CoreException {
	// IWorkspaceRoot wsRoot =
	// ResourcesPlugin.getWorkspace().getRoot();
	// IProject proj = wsRoot.getProject(name);
	if (proj != null && proj.exists()) {
	proj.clearHistory(null);
	//proj.close(null);
	proj.refreshLocal(IResource.DEPTH_INFINITE, null);
	try {
	proj.delete(true, true, null);
	}
	catch (Exception e) {
	// just try again (not sure why they are not being
	// deleted)
	proj.refreshLocal(IResource.DEPTH_INFINITE, null);
	proj.delete(true, true, null);
	}
	//proj = null;
	}
	refreshWorkspace();
	}
	};
	WorkspaceProgressMonitor progress = new WorkspaceProgressMonitor();
	deleteOp.run(progress);
	// saves the new workspace metadata
	ResourcesPlugin.getWorkspace().save(true, null);
	}

	/**
	* @return IProjects that were unzipped and imported into the workspace by
	* this utility
	*/
	public IProject[] getCreatedProjects() {
	IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
	String[] projectNames = (String[]) fCreatedProjects.toArray(new String[fCreatedProjects.size()]);
	IProject[] projects = new IProject[projectNames.length];
	for (int i = 0; i < projectNames.length; i++) {
	projects[i] = wsRoot.getProject(projectNames[i]);
	}
	return projects;
	}

	public void initJavaProject(String projName) throws CoreException {
	// resynch
	refreshWorkspace();
	//change prereqs to get this functionality back in
	IProject proj = ResourcesPlugin.getWorkspace().getRoot().getProject(projName);
	if (!proj.exists()) {
	proj.create(new NullProgressMonitor());
	}
	// need to add java nature, or else project won't "exist()" in the
	// java
	// element sense
	String[] natureIds = {"org.eclipse.jdt.core.javanature"};
	if (!proj.isOpen()) {
	proj.open(null);
	}
	IProjectDescription desc = proj.getDescription();
	desc.setNatureIds(natureIds);
	proj.setDescription(desc, new NullProgressMonitor());
	}

	private void createProject(IProject project, IPath locationPath, IProgressMonitor monitor) throws CoreException {
	if (monitor == null) {
	monitor = new WorkspaceProgressMonitor();
	}
	monitor.beginTask("creating test project", 10);
	// create the project
	try {
	if (!project.exists()) {
	IProjectDescription desc = project.getWorkspace().newProjectDescription(project.getName());
	if (Platform.getLocation().equals(locationPath)) {
	locationPath = null;
	}
	desc.setLocation(locationPath);
	project.create(desc, monitor);
	monitor = null;
	}
	if (!project.isOpen()) {
	project.open(monitor);
	monitor = null;
	}
	}
	finally {
	if (monitor != null) {
	monitor.done();
	}
	}
	}

	public void deleteProject(IProject fProject) throws InvocationTargetException, InterruptedException {
	final IProject proj = fProject;
	WorkspaceModifyOperation deleteOp = new WorkspaceModifyOperation(proj) {
	protected void execute(IProgressMonitor monitor) throws CoreException {
	// IWorkspaceRoot wsRoot =
	// ResourcesPlugin.getWorkspace().getRoot();
	// IProject proj = wsRoot.getProject(name);
	if (proj != null && proj.exists()) {
	proj.clearHistory(null);
	//proj.close(null);
	proj.refreshLocal(IResource.DEPTH_INFINITE, null);
	proj.delete(true, true, null);
	//proj = null;
	}
	refreshWorkspace();
	}
	};
	//WorkspaceProgressMonitor progress = new WorkspaceProgressMonitor();
	deleteOp.run(null);
	// saves the new workspace metadata
	//ResourcesPlugin.getWorkspace().save(true, null);
	}
	}