Attachment #117958 for bug #245565

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




package org.eclipse.pde.internal.ui.wizards.imports;

import java.util.*;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.*;
import org.eclipse.jface.dialogs.*;
import org.eclipse.jface.viewers.IStructuredSelection;

	}

	private static void doImportOperation(final Shell shell, final int importType, final IPluginModelBase[] models, final boolean forceAutobuild, final boolean launchedConfiguration) {
		PluginImportOperation job = new PluginImportOperation(models, importType, new ImportQuery(shell), new ImportQuery(shell), forceAutobuild);
		job.setPluginsInUse(launchedConfiguration);
		job.setRule(ResourcesPlugin.getWorkspace().getRoot());
		op.setLaunchedConfiguration(launchedConfiguration);
		Job job = new Job(PDEUIMessages.ImportWizard_title) {
			protected IStatus run(IProgressMonitor monitor) {
				try {
					PDEPlugin.getWorkspace().run(op, monitor);
				} catch (CoreException e) {
					PDEPlugin.logException(e);
					return Status.CANCEL_STATUS;
				}
				return Status.OK_STATUS;
			}
		};
		job.setUser(true);
		job.schedule();
	}




import java.io.IOException;
import java.util.*;
import java.util.jar.JarFile;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;

import org.eclipse.jdt.core.*;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.launching.environments.IExecutionEnvironmentsManager;
import org.eclipse.osgi.service.environment.Constants;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.osgi.service.resolver.HostSpecification;
import org.eclipse.osgi.util.ManifestElement;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.core.build.IBuild;

import org.eclipse.pde.internal.core.util.CoreUtility;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.swt.widgets.Display;
import org.eclipse.team.core.RepositoryProvider;
import org.eclipse.team.core.TeamException;
import org.eclipse.ui.wizards.datatransfer.FileSystemStructureProvider;

import org.osgi.framework.BundleException;

/**
 * Imports one or more plug-ins into the workspace.  There are three different
 * ways to import a plugin: as binary, as binary with linked source,
 * and as source. 
 */
public class PluginImportOperation extends Job {

	public static final int IMPORT_BINARY = 1;
	public static final int IMPORT_BINARY_WITH_LINKS = 2;
	public static final int IMPORT_WITH_SOURCE = 3;

	private static final String DEFAULT_SOURCE_DIR = "src"; //$NON-NLS-1$
	private static final String DEFAULT_LIBRARY_NAME = "."; //$NON-NLS-1$

	private IPluginModelBase[] fModels;
	private int fImportType;
	private IImportQuery fReplaceQuery;

	private boolean fForceAutobuild;
	private IImportQuery fExecutionQuery;

	private boolean fPluginsAreInUse = false;
	/**
	 * A list of plugins that were unable to be deleted
	 */
	private ArrayList fUnableToDeletePlugins;

	public interface IImportQuery {
		public static final int CANCEL = 0;

	 * @param importType one of three types specified by constants, binary, binary with links, source
	 * @param replaceQuery defines what to do if the project already exists in the workspace
	 * @param executionQuery defines what to do if the project requires an unsupported execution environment
	 * @param forceAutobuild whether to force a build after the import
	 */
	public PluginImportOperation(IPluginModelBase[] models, int importType, IImportQuery replaceQuery, IImportQuery executionQuery, boolean forceAutobuild) {
		super(PDEUIMessages.ImportWizard_title);
		fModels = models;
		fImportType = importType;
		fReplaceQuery = replaceQuery;
		fExecutionQuery = executionQuery;
		fForceAutobuild = forceAutobuild;
	}

	/**
	 * Sets whether some of the plug-ins being imported are currently in use by a launched
	 * Eclipse instance.  Setting this to true will force an additional check before deleting
	 * a plug-in.
	 * @param pluginsInUse
	 * @param executionQuery defines what to do if the project requires an unsupported execution environment
	 * @param forceAutobuild whether to force a build after the import
	 */
	public void setPluginsInUse(boolean pluginsInUse) {
		fPluginsAreInUse = pluginsInUse;
		fForceAutobuild = forceAutobuild;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected IStatus run(IProgressMonitor monitor) {
		if (monitor == null) {
			monitor = new NullProgressMonitor();
		}
		monitor.beginTask(PDEUIMessages.ImportWizard_operation_creating, fModels.length + 1);
		try {
			monitor.beginTask(PDEUIMessages.ImportWizard_operation_creating, fModels.length + 1);
			MultiStatus multiStatus = new MultiStatus(PDEPlugin.getPluginId(), IStatus.OK, PDEUIMessages.ImportWizard_operation_multiProblem, null);

			for (int i = 0; i < fModels.length; i++) {
				monitor.setTaskName(NLS.bind(PDEUIMessages.PluginImportOperation_Importing_plugin, fModels[i].getPluginBase().getId()));
				try {
					importPlugin(fModels[i], new SubProgressMonitor(monitor, 1));
				} catch (CoreException e) {
					multiStatus.merge(e.getStatus());
				}
				if (monitor.isCanceled()) {
					try {
						setClasspaths(new SubProgressMonitor(monitor, 1));
					} catch (JavaModelException e) {
						/* Do nothing as we are already cancelled */
					}
					return Status.CANCEL_STATUS;
				}
			}
			try {
				setClasspaths(new SubProgressMonitor(monitor, 1));
			} catch (JavaModelException e) {
				multiStatus.merge(e.getStatus());
			}
			if (!ResourcesPlugin.getWorkspace().isAutoBuilding() && fForceAutobuild)
				runBuildJob();
			return multiStatus;
				throw new CoreException(multiStatus);
		} finally {
			monitor.done();
			if (!fUnableToDeletePlugins.isEmpty()) {
				final Display display = Display.getDefault();
				display.syncExec(new Runnable() {
					public void run() {
						PluginImportFinishDialog dialog = new PluginImportFinishDialog(display.getActiveShell());
						dialog.setTitle(PDEUIMessages.PluginImportInfoDialog_title);
						dialog.setMessage(PDEUIMessages.PluginImportInfoDialog_message);
						dialog.setInput(fUnableToDeletePlugins);
						dialog.open();
					}

				});
			}
		}
	}

	/**
	 * Starts a job that will build the workspace
	 */
	private void runBuildJob() {
		Job buildJob = new Job(PDEUIMessages.CompilersConfigurationBlock_building) {
			public boolean belongsTo(Object family) {
				return ResourcesPlugin.FAMILY_AUTO_BUILD == family;
			}

			protected IStatus run(IProgressMonitor monitor) {
				try {
					PDEPlugin.getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, monitor);
				} catch (CoreException e) {
				}
				return Status.OK_STATUS;
			}
		};
		buildJob.setRule(ResourcesPlugin.getWorkspace().getRuleFactory().buildRule());
		buildJob.schedule();
	}

	/**
	 * Sets the raw classpath of projects that need to be updated
	 * @param monitor
	 * @throws JavaModelException if a classpath could not be set
	 */
	private void setClasspaths(IProgressMonitor monitor) throws JavaModelException {
		try {
			monitor.beginTask("", fProjectClasspaths.size()); //$NON-NLS-1$
			Enumeration keys = fProjectClasspaths.keys();
			while (keys.hasMoreElements()) {
				IProject project = (IProject) keys.nextElement();
				IClasspathEntry[] classpath = (IClasspathEntry[]) fProjectClasspaths.get(project);
				monitor.subTask(project.getName());
				JavaCore.create(project).setRawClasspath(classpath, new SubProgressMonitor(monitor, 1));
			}
		} finally {
			monitor.done();
		}
	}


	 * @throws CoreException if a problem occurs while importing a plugin
	 */
	private void importPlugin(IPluginModelBase model, IProgressMonitor monitor) throws CoreException {
		String id = model.getPluginBase().getId();
		monitor.beginTask(NLS.bind(PDEUIMessages.ImportWizard_operation_creating2, id), 6);
		try {
			monitor.beginTask("", 5); //$NON-NLS-1$
			if (desc != null) {
				IExecutionEnvironmentsManager manager = JavaRuntime.getExecutionEnvironmentsManager();
				String[] envs = desc.getExecutionEnvironments();
				boolean found = false;
				for (int i = 0; i < envs.length; i++) {
					if (manager.getEnvironment(envs[i]) != null) {
						found = true;
						break;
					}
				}
				if (envs.length > 0 && !found) {
					String message = NLS.bind(PDEUIMessages.PluginImportOperation_executionEnvironment, id, envs[0]);
					if (!queryExecutionEnvironment(message))
						return;
				}
			}

			// Test is the required execution environment is supported
			if (!testExecutionEnvironment(model)) {
				return;
				if (!queryReplace(project))
					return;
				if (RepositoryProvider.isShared(project))
					RepositoryProvider.unmap(project);
				if (!project.exists())
					project.create(new SubProgressMonitor(monitor, 1));
				if (!safeDeleteCheck(project, monitor)) {
					fUnableToDeletePlugins.add(model);
					return;
				}
				try {
					project.delete(true, true, monitor);
				} catch (CoreException e) {
					fUnableToDeletePlugins.add(model);
					return;
				}
			}
			// Create the project or ask to overwrite if project exists
			IProject project = createProject(model, new SubProgressMonitor(monitor, 1));

			// Target Weaving: if we are importing plug-ins in the runtime workbench from the host workbench, import everything as-is and return
			if (!project.isOpen())
				project.open(monitor);
			monitor.worked(1);

			if (Platform.inDevelopmentMode()) {
				// if we are importing plug-ins in the runtime workbench from the host workbench, import everything as-is and return
				File location = new File(model.getInstallLocation());
				if (location.isDirectory()) {
					File classpathFile = new File(location, ".classpath"); //$NON-NLS-1$
					File projectFile = new File(location, ".project"); //$NON-NLS-1$
					if (classpathFile.exists() && classpathFile.isFile() && projectFile.exists() && projectFile.isFile()) {
						PluginImportHelper.importContent(location, project.getFullPath(), FileSystemStructureProvider.INSTANCE, null, new SubProgressMonitor(monitor, 4));
						return;
					}
				}
			}

			// Perform the import
			Map sourceMap = null;
			if (fImportType == IMPORT_BINARY || isExempt(model)) {
				sourceMap = importAsBinary(project, model, new SubProgressMonitor(monitor, 4));
			} else if (fImportType == IMPORT_BINARY_WITH_LINKS) {
				sourceMap = importAsBinaryWithLinks(project, model, new SubProgressMonitor(monitor, 4));
			} else if (fImportType == IMPORT_WITH_SOURCE) {
				importAsSource(project, model, new SubProgressMonitor(monitor, 4));
						importAsBinaryWithLinks(project, model, new SubProgressMonitor(monitor, 4));
					}
					break;
				case IMPORT_WITH_SOURCE :
					if (isExempt(model)) {
						importAsBinary(project, model, true, new SubProgressMonitor(monitor, 4));
					} else {
						importAsSource(project, model, new SubProgressMonitor(monitor, 4));
					}
			}

			setProjectNatures(project, model);

			// Set the classpath
			if (project.hasNature(JavaCore.NATURE_ID) && project.findMember(".classpath") == null) //$NON-NLS-1$
				fProjectClasspaths.put(project, ClasspathComputer.getClasspath(project, model, sourceMap, true, false));
		} catch (CoreException e) {
			PDEPlugin.logException(e);
		} finally {
			monitor.done();
		}
	}

	/**
	 * Imports the contents of the plugin and imports source files as binary files that will not be compiled.
	 * @param project destination project of the import
	 * @param model model representing the plugin to import
	 * @param monitor progress monitor
	 * @return a mapping of libraries to source locations to use in the classpath
	 * @throws CoreException if there is a problem completing the import
	 */
	private Map importAsBinary(IProject project, IPluginModelBase model, IProgressMonitor monitor) throws CoreException {
		try {
			monitor.beginTask("", 3); //$NON-NLS-1$

			// Import the plug-in content
			File srcFile = new File(model.getInstallLocation());
			if (isJARd(model)) {
				PluginImportHelper.copyArchive(srcFile, project.getFile(srcFile.getName()), new SubProgressMonitor(monitor, 1));
			} else {
				PluginImportHelper.importContent(new File(model.getInstallLocation()), project.getFullPath(), FileSystemStructureProvider.INSTANCE, null, new SubProgressMonitor(monitor, 1));
			}

			// Import source from known source locations
			Map sourceMap = importSourceArchives(project, model, IMPORT_BINARY, new SubProgressMonitor(monitor, 1));

			// Extract the required bundle files and modify the imported manifest to have the correct classpath
			importRequiredPluginFiles(project, model, new SubProgressMonitor(monitor, 1));
			modifyBundleClasspathHeader(project, model);

			// Mark the project as binary
			project.setPersistentProperty(PDECore.EXTERNAL_PROJECT_PROPERTY, PDECore.BINARY_PROJECT_VALUE);
			RepositoryProvider.map(project, PDECore.BINARY_REPOSITORY_PROVIDER);

			return sourceMap;

		} finally {
			monitor.done();
		}
	}

	/**
	 * Creates links to remote plugin and source locations and sets up the project
	 * @param project destination project of the import
	 * @param model model representing the plugin to import
	 * @param monitor progress monitor
	 * @return mapping of library name to path to source library (relative to project)
	 * @throws CoreException if there is a problem completing the import
	 */
	private Map importAsBinaryWithLinks(IProject project, IPluginModelBase model, IProgressMonitor monitor) throws CoreException {
		try {
			monitor.beginTask("", 3); //$NON-NLS-1$

			// Link the plug-in content
			File srcFile = new File(model.getInstallLocation());
			IFile dstFile = project.getFile(new Path(srcFile.getName()));
			dstFile.createLink(srcFile.toURI(), IResource.NONE, new SubProgressMonitor(monitor, 1));

			// Link source from known source locations
			Map sourceMap = importSourceArchives(project, model, IMPORT_BINARY_WITH_LINKS, new SubProgressMonitor(monitor, 1));

			// Extract the required bundle files and modify the imported manifest to have the correct classpath
			importRequiredPluginFiles(project, model, new SubProgressMonitor(monitor, 1));
			modifyBundleClasspathHeader(project, model);

			// Mark the project as binary
			project.setPersistentProperty(PDECore.EXTERNAL_PROJECT_PROPERTY, PDECore.BINARY_PROJECT_VALUE);
			RepositoryProvider.map(project, PDECore.BINARY_REPOSITORY_PROVIDER);

			return sourceMap;

		} finally {
			monitor.done();
		}
	}

	/**
	 * Imports the contents of the plugin and imports source files to source folders that will be compiled.
	 * @param project destination project of the import
	 * @param model model representing the plugin to import
	 * @param monitor progress monitor
	 * @throws CoreException if there is a problem completing the import
	 */
	private void importAsSource(IProject project, IPluginModelBase model, SubProgressMonitor monitor) throws CoreException {
		try {
			monitor.beginTask("", 4); //$NON-NLS-1$

			// Extract the source
			WorkspaceBuildModel buildModel = extractSourceFolders(project, model, new SubProgressMonitor(monitor, 1));

			// Extract additional non-java files from the source bundles
			importAdditionalSourceFiles(project, model, new SubProgressMonitor(monitor, 1));

			// Extract the binary plug-in (for non-class files)
			File srcFile = new File(model.getInstallLocation());
			if (isJARd(model)) {
				PluginImportHelper.extractArchive(srcFile, project.getFullPath(), new SubProgressMonitor(monitor, 1));
			} else {
				// TODO This might put everything into a folder, which is bad
				PluginImportHelper.importContent(new File(model.getInstallLocation()), project.getFullPath(), FileSystemStructureProvider.INSTANCE, null, new SubProgressMonitor(monitor, 1));
			}

			// Create the build.properties file
			configureBinIncludes(buildModel, model, project);
			buildModel.save();
			monitor.worked(1);

		} finally {
			monitor.done();
		}

	}

	/**
	 * Creates the project to add to the workspace.  If the project already exists in 
	 * the workspace ask the user if it is ok to overwrite.  Will return <code>null</code>
	 * if no project could be created for the import (i.e. the user chooses to not overwrite).
	 * 
	 * @param model plug-in being imported
	 * @param monitor progress monitor
	 * @return the project to use or <code>null</code> if no project could be created/overwritten
	 * @throws TeamException if an existing project is shared and an error occurs disconnecting it
	 * @throws CoreException if an error occurs when working with the project
	 */
	private IProject createProject(IPluginModelBase model, IProgressMonitor monitor) throws TeamException, CoreException {
		try {
			monitor.beginTask("", 2); //$NON-NLS-1$
			IProject project = findProject(model.getPluginBase().getId());
			if (project.exists() || new File(project.getParent().getLocation().toFile(), project.getName()).exists()) {
				// Query the user to see if we should overwrite
				switch (fReplaceQuery.doQuery(NLS.bind(PDEUIMessages.ImportWizard_messages_exists, project.getName()))) {
					case IImportQuery.CANCEL :
						throw new OperationCanceledException();
					case IImportQuery.NO :
						return null;
				}
				if (RepositoryProvider.isShared(project))
					RepositoryProvider.unmap(project);
				if (!project.exists())
					project.create(new SubProgressMonitor(monitor, 1));
				if (!safeDeleteCheck(project, monitor)) {
					throw new CoreException(new Status(IStatus.ERROR, PDEPlugin.getPluginId(), NLS.bind(PDEUIMessages.PluginImportOperation_could_not_delete_project, project.getName())));
				}
				project.delete(true, true, monitor);
			}

			project.create(monitor);
			if (!project.isOpen())
				project.open(monitor);
			monitor.worked(1);

			return project;

		} finally {
			monitor.done();
		}
		return id + "_" + version; //$NON-NLS-1$
	}

	private IProject findProject(String id) {
		IPluginModelBase model = PluginRegistry.findModel(id);
		if (model != null) {
			IResource resource = model.getUnderlyingResource();
			if (resource != null)
				return resource.getProject();
		}
		return PDEPlugin.getWorkspace().getRoot().getProject(id);
	}

	/**
	 * Returns true if it is safe to delete the project.  It is not safe to delete if
	 * one of its libraries is locked by a running launch configuration.
	 * 
	 * @param project project to test
	 * @param monitor progress monitor
	 * @return true is it is safe to delete the project, false otherwise
	 */
	private boolean safeDeleteCheck(IProject project, IProgressMonitor monitor) {
		if (!fPluginsAreInUse)
			return true;
		IPluginModelBase base = PluginRegistry.findModel(project);
		if (base != null) {

	}

	/**
	 * Tests whether the required execution environment of the given plugin is supported by
	 * the current known JREs.  If not, ask the user whether to continue.
	 * @param model the plug-in model to test
	 * @return true is the import should continue, false if the plug-in should be skipped
	 * @throws OperationCanceledException if the user chooses to cancel the operation
	 */
	private boolean testExecutionEnvironment(IPluginModelBase model) throws OperationCanceledException {
		BundleDescription desc = model.getBundleDescription();
		if (desc != null) {
			IExecutionEnvironmentsManager manager = JavaRuntime.getExecutionEnvironmentsManager();
			String[] envs = desc.getExecutionEnvironments();
			boolean found = false;
			for (int i = 0; i < envs.length; i++) {
				if (manager.getEnvironment(envs[i]) != null) {
					found = true;
					break;
				}
			}
			if (envs.length > 0 && !found) {
				switch (fExecutionQuery.doQuery(NLS.bind(PDEUIMessages.PluginImportOperation_executionEnvironment, model.getPluginBase().getId(), envs[0]))) {
					case IImportQuery.CANCEL :
						throw new OperationCanceledException();
					case IImportQuery.NO :
						return false;
							ArrayList filesToImport = new ArrayList(1);
							filesToImport.add(sourceFile);
							importContent(installLocation, project.getFullPath(), FileSystemStructureProvider.INSTANCE, filesToImport, new SubProgressMonitor(monitor, 1));
						}
					}
				}
			}
			linkSourceArchives(project, model, new SubProgressMonitor(monitor, 1));
		}
		try {
			RepositoryProvider.map(project, PDECore.BINARY_REPOSITORY_PROVIDER);
		} catch (TeamException e) {
			PDECore.logException(e);
		}
		return true;
	}

	/**
	 * Returns true if the given plugin must be imported as
	 * binary instead of the setting defined by fImportType
	 * @param model
	 * @return true is the plugin must be imported as binary, false otherwise
	 * @param monitor progress monitor
	 * @throws CoreException if there is a problem completing the import
	 */
	private boolean isExempt(IPluginModelBase model) {
		String id = model.getPluginBase().getId();
		if (fImportType == IMPORT_WITH_SOURCE) {
			if ("org.apache.ant".equals(id) //$NON-NLS-1$
					|| "org.eclipse.osgi.util".equals(id) //$NON-NLS-1$
					|| "org.eclipse.osgi.services".equals(id) //$NON-NLS-1$
					|| "org.eclipse.core.runtime.compatibility.registry".equals(id)) { //$NON-NLS-1$
				return true;
			}
		}

		if ("org.eclipse.swt".equals(id) && !isJARd(model)) //$NON-NLS-1$
			return true;
		return false;
	}

	/**
	 * Starts a job that will build the workspace
	 */
	private void runBuildJob() {
		Job buildJob = new Job(PDEUIMessages.CompilersConfigurationBlock_building) {
			public boolean belongsTo(Object family) {
				return ResourcesPlugin.FAMILY_AUTO_BUILD == family;
			}

			protected IStatus run(IProgressMonitor monitor) {
				try {
					PDEPlugin.getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, monitor);
				} catch (CoreException e) {
				if (ClasspathUtilCore.containsVariables(libraryName) && !project.exists(new Path(ClasspathUtilCore.expandLibraryName(libraryName)))) {
					for (int j = 0; j < fragments.length; j++) {
						importJarFromFragment(project, fragments[j], libraryName);
						importSourceFromFragment(project, fragments[j], libraryName, new SubProgressMonitor(monitor, 1));
					}
				} else {
					monitor.worked(1);
				}
				return Status.OK_STATUS;
			}
		};
		buildJob.setRule(ResourcesPlugin.getWorkspace().getRuleFactory().buildRule());
		buildJob.schedule();
			importAdditionalResources(project, model, new SubProgressMonitor(monitor, 1));
		} else {
			monitor.done();
		}
	}

	/**
	 * Imports the source archives required by the project either by copying or linking, based on the mode
	 * constant that is passed to the method (IMPORT_BINARY or IMPORT_BINARY_WITH_LINKS).
	 * @param project project destination
	 * @param model model we are importing
	 * @param mode either IMPORT_BINARY (copies source) or MPORT_BINARY_WITH_LINKS (links source)
	 * @param monitor progress monitor
	 * @return mapping of library name to the source location
	 * @throws CoreException if there are problems importing an archive
	 */
	private Map importSourceArchives(IProject project, IPluginModelBase model, int mode, IProgressMonitor monitor) throws CoreException {
		String[] libraries = getLibraryNames(model);
		try {
			monitor.beginTask(PDEUIMessages.ImportWizard_operation_importingSource, libraries.length);

			Map sourceMap = new HashMap(libraries.length);
			SourceLocationManager manager = PDECore.getDefault().getSourceLocationManager();
			if (libraries.length == 0)
				libraries = new String[] {"."}; //$NON-NLS-1$
			for (int i = 0; i < libraries.length; i++) {
				String zipName = ClasspathUtilCore.getSourceZipName(libraries[i]);
				IPath srcPath = manager.findSourcePath(model.getPluginBase(), new Path(zipName));
				if (srcPath != null) {
					zipName = srcPath.lastSegment();
					IPath dstPath = new Path(zipName);
					sourceMap.put(libraries[i], dstPath);
					if (project.findMember(dstPath) == null) {
						if (mode == IMPORT_BINARY) {
							PluginImportHelper.copyArchive(new File(srcPath.toOSString()), project.getFile(dstPath), new SubProgressMonitor(monitor, 1));
						} else if (mode == IMPORT_BINARY_WITH_LINKS) {
							IFile dstFile = project.getFile(dstPath);
							dstFile.createLink(srcPath, IResource.NONE, new SubProgressMonitor(monitor, 1));
						if (extIndex != -1) {
							srcZip = jarFile.getProject().findMember(srcName.substring(0, extIndex));
						}
					}
					// srcZip == null if plug-in has embedded source
					// if it jarred, all necessary files already in src folder
					if (srcZip == null && libraries[i].equals(".") && !isJARd(model)) //$NON-NLS-1$
						// if src does not exist (and returns null), then must not be plug-in with embedded source
						srcZip = jarFile.getProject().findMember("src"); //$NON-NLS-1$
					if (srcZip != null) {
						String jarName = libraries[i].equals(".") ? "" : libraryPath.removeFileExtension().lastSegment(); //$NON-NLS-1$ //$NON-NLS-2$
						String folder = addBuildEntry(buildModel, "source." + libraries[i], "src" + (jarName.length() == 0 ? "/" : "-" + jarName + "/")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
						IFolder dest = jarFile.getProject().getFolder(folder);

						if (srcZip instanceof IFolder) {
							// if the source (srcZip) equals the destination folder (dest), then we don't want to delete/copy since every
							// is already where it needs to be.  This happens when importing source bundles in folder format declaring source with ext. point. (bug 214542)
							if (!srcZip.equals(dest)) {
								if (dest.exists()) {
									dest.delete(true, null);
								}
								((IFolder) srcZip).move(dest.getFullPath(), true, new SubProgressMonitor(monitor, 1));
							}
						} else if (srcZip instanceof IFile) {
							if (!dest.exists()) {
								dest.create(true, true, null);
							}
							extractZipFile(srcZip.getLocation().toFile(), dest.getFullPath(), new SubProgressMonitor(monitor, 1));
							srcZip.delete(true, null);
						} else
							monitor.worked(1);

						if (jarFile instanceof IFile) {
							if (isJARd(model)) {
								extractJavaResources(jarFile.getLocation().toFile(), dest, new SubProgressMonitor(monitor, 1));
							} else {
								extractResources(jarFile.getLocation().toFile(), dest, new SubProgressMonitor(monitor, 1));
							}
							jarFile.delete(true, null);
						} else {
							moveBinaryContents((IContainer) jarFile, dest, new SubProgressMonitor(monitor, 1));
						}
					}
				} else if (name.equals(".") && project.getFolder("src").exists()) { //$NON-NLS-1$ //$NON-NLS-2$
					addBuildEntry(buildModel, "source..", "src/"); //$NON-NLS-1$ //$NON-NLS-2$
				}
			}
			return sourceMap;
		} finally {
			monitor.done();
		}
		configureBinIncludes(buildModel, model, project);
		if (list.size() > 0)
			configureSrcIncludes(buildModel, list);
		buildModel.save();
	}

	/**
	 * Looks up the source locations for the plug-in and imports the source for each library.  Each source root is
	 * extracted to a source folder in the project and a build model containing the source entries is returned.
	 * 
	 * @param project destination project
	 * @param model plug-in being imported
	 * @param monitor progress monitor
	 * @return a workspace build model containing entries for each created source folder
	 * @throws CoreException if there is a problem extracting the source or creating a build entry
	 */
	private WorkspaceBuildModel extractSourceFolders(IProject project, IPluginModelBase model, IProgressMonitor monitor) throws CoreException {
		try {
			String[] libraries = getLibraryNames(model);
			monitor.beginTask(PDEUIMessages.ImportWizard_operation_importingSource, libraries.length);
			ArrayList validFolders = new ArrayList();
			for (int i = 0; i < children.length; i++)
				if (children[i] instanceof IFolder) {
					String folderName = children[i].getName();
					IResource folder = srcFolder.findMember(folderName);
					if (folder != null && folder instanceof IFolder)
						validFolders.add(folder);
				}

			WorkspaceBuildModel buildModel = new WorkspaceBuildModel(project.getFile("build.properties")); //$NON-NLS-1$
			SourceLocationManager manager = PDECore.getDefault().getSourceLocationManager();

			// Need to do different things based on whether we have a individual source bundle or the old style separated zips
			if (manager.hasBundleManifestLocation(model.getPluginBase())) {
				File srcFile = manager.findSourcePlugin(model.getPluginBase());
				Set sourceRoots = manager.findSourceRoots(model.getPluginBase());
				for (int i = 0; i < libraries.length; i++) {
					if (libraries[i].equals(DEFAULT_LIBRARY_NAME)) {
						// Need to pull out any java source that is not in another source root
						IResource destination = project.getFolder(DEFAULT_SOURCE_DIR);
						if (!destination.exists()) {
							List excludeFolders = new ArrayList(sourceRoots.size());
							for (Iterator iterator = sourceRoots.iterator(); iterator.hasNext();) {
								String root = (String) iterator.next();
								if (!root.equals(DEFAULT_LIBRARY_NAME)) {
									excludeFolders.add(new Path(root));
								}
							if (!destFile.getParent().exists()) {
								CoreUtility.createFolder((IFolder) destFile.getParent());
							}
							PluginImportHelper.extractJavaSourceFromArchive(srcFile, excludeFolders, destination.getFullPath(), new SubProgressMonitor(monitor, 1));
							addBuildEntry(buildModel, "source." + DEFAULT_LIBRARY_NAME, DEFAULT_SOURCE_DIR + "/"); //$NON-NLS-1$ //$NON-NLS-2$
						}
					} else if (sourceRoots.contains(getSourceDirName(libraries[i]))) {
						IPath sourceDir = new Path(getSourceDirName(libraries[i]));
						IResource destination = project.getFolder(sourceDir);
						if (!destination.exists()) {
							PluginImportHelper.extractFolderFromArchive(srcFile, sourceDir, destination.getFullPath(), new SubProgressMonitor(monitor, 1));
							addBuildEntry(buildModel, "source." + libraries[i], sourceDir.toString()); //$NON-NLS-1$
						}
					}
				}
			} else {
				// Old style, zips in folders, determine the source zip name/location and extract it to the project
				for (int i = 0; i < libraries.length; i++) {
					String zipName = ClasspathUtilCore.getSourceZipName(libraries[i]);
					IPath srcPath = manager.findSourcePath(model.getPluginBase(), new Path(zipName));
					if (srcPath != null) {
						IPath dstPath = new Path(getSourceDirName(libraries[i]));
						IResource destination = project.getFolder(dstPath);
						if (!destination.exists()) {
							PluginImportHelper.extractArchive(new File(srcPath.toOSString()), destination.getFullPath(), new SubProgressMonitor(monitor, 1));
							addBuildEntry(buildModel, "source." + libraries[i], dstPath.toString()); //$NON-NLS-1$
						}
					} else {
						resources = ((IFolder) res).members();
						for (int i = 0; i < resources.length; i++)
							stack.push(resources[i]);
					}
				}
				folder.delete(true, null);
				monitor.worked(1);
			}
			return buildModel;
		} finally {
			monitor.done();
		}
	}

	/**
	 * Extracts any additional files and folders that exist in the source location
	 * @param project the destination project
	 * @param model the plugin being imported
	 * @param model model representing the plugin to import
	 * @param monitor progress monitor
	 * @throws CoreException is there is a problem importing the files
	 * @throws CoreException if there is a problem completing the import
	 */
	private void importAdditionalSourceFiles(IProject project, IPluginModelBase model, SubProgressMonitor monitor) throws CoreException {
		File sourceLocation = PDECore.getDefault().getSourceLocationManager().findSourcePlugin(model.getPluginBase());
		if (sourceLocation != null) {
			if (sourceLocation.isFile()) {
				ArrayList collected = new ArrayList();
				ZipFileStructureProvider provider = null;
				Object root = location;
				File[] children = location.listFiles();
				if (children != null) {
					for (int i = 0; i < children.length; i++) {
						String name = children[i].getName();
						if (!project.exists(new Path(name)) && !"src.zip".equals(name)) { //$NON-NLS-1$
							list.add(children[i]);
						}
					}
					importContent(root, project.getFullPath(), FileSystemStructureProvider.INSTANCE, list, monitor);
					ArrayList srcEntryList = new ArrayList(list.size());
					for (ListIterator iterator = list.listIterator(); iterator.hasNext();) {
						File current = (File) iterator.next();
						String entry = current.getName();
						if (current.isDirectory()) {
							entry += "/"; //$NON-NLS-1$
						}
						srcEntryList.add(entry);
					}
					return srcEntryList;
				}
			} else if (location.isFile()) {
				ZipFile zipFile = null;
				try {
					provider = new ZipFileStructureProvider(new ZipFile(sourceLocation));
					ZipFileStructureProvider zipProvider = new ZipFileStructureProvider(zipFile);
					Object root = zipProvider.getRoot();
					collectAdditionalResources(zipProvider, root, list, project);
					importContent(root, project.getFullPath(), zipProvider, list, monitor);
					ArrayList srcEntryList = new ArrayList(list.size());
					for (Iterator iterator = list.iterator(); iterator.hasNext();) {
						ZipEntry current = (ZipEntry) iterator.next();
						String entry = current.getName();
						srcEntryList.add(entry);
					}
					return srcEntryList;
				} catch (IOException e) {
					IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
					throw new CoreException(status);
				} finally {
					if (zipFile != null) {
						try {
							zipFile.close();
						} catch (IOException e) {
						}
					}
				}
				PluginImportHelper.collectNonJavaFiles(provider, provider.getRoot(), collected);
				PluginImportHelper.importContent(provider.getRoot(), project.getFullPath(), provider, collected, monitor);
			} else {
				// TODO Test how to do directories
				ArrayList collected = new ArrayList();
				PluginImportHelper.collectNonJavaFiles(FileSystemStructureProvider.INSTANCE, sourceLocation, collected);
				PluginImportHelper.importContent(sourceLocation, project.getFullPath(), FileSystemStructureProvider.INSTANCE, collected, monitor);
			}
		}
	}

	/**
	 * Imports files from the plug-in that are necessary to make the created project a plug-in project.
	 * Specifically the manifest and related file are extracted.  
	 * @param project
	 * @param model
	 * @param monitor
	 * @throws CoreException if there is a problem importing the content
	 */
	private void importRequiredPluginFiles(IProject project, IPluginModelBase model, IProgressMonitor monitor) throws CoreException {
		if (isJARd(model)) {
			ArrayList collected = new ArrayList();
			ZipFileStructureProvider provider = null;
			try {
				provider = new ZipFileStructureProvider(new ZipFile(new File(model.getInstallLocation())));
			} catch (IOException e) {
				IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
				throw new CoreException(status);
			}
			PluginImportHelper.collectRequiredBundleFiles(provider, provider.getRoot(), collected);
			PluginImportHelper.importContent(provider.getRoot(), project.getFullPath(), provider, collected, monitor);
		} else {
			ArrayList collected = new ArrayList();
			File file = new File(model.getInstallLocation());
			PluginImportHelper.collectRequiredBundleFiles(FileSystemStructureProvider.INSTANCE, file, collected);
			PluginImportHelper.importContent(file, project.getFullPath(), FileSystemStructureProvider.INSTANCE, collected, monitor);
		}
	}

	private String addBuildEntry(WorkspaceBuildModel model, String key, String value) throws CoreException {
		IBuild build = model.getBuild(true);
		IBuildEntry entry = build.getEntry(key);
		if (entry == null) {
			entry = model.getFactory().createEntry(key);
			entry.addToken(value);
			build.add(entry);
		}
		String[] tokens = entry.getTokens();
		return (tokens.length > 0) ? tokens[0] : "src/"; //$NON-NLS-1$
	}

	private void configureBinIncludes(WorkspaceBuildModel buildModel, IPluginModelBase model, IProject project) throws CoreException {

					entry.addToken(token);
				}
			} else {
				String[] tokens = PluginImportHelper.getTopLevelResources(location);
				for (int i = 0; i < tokens.length; i++) {
					IResource res = project.findMember(tokens[i]);
					if ((res == null) && (build.getEntry(IBuildEntry.JAR_PREFIX + tokens[i]) == null))

		return set;
	}

	private void configureSrcIncludes(WorkspaceBuildModel buildModel, List list) throws CoreException {
		IBuildEntry entry = buildModel.getBuild(true).getEntry("src.includes"); //$NON-NLS-1$
		if (entry == null) {
			entry = buildModel.getFactory().createEntry("src.includes"); //$NON-NLS-1$
			for (int i = 0; i < list.size(); i++) {
				entry.addToken(list.get(i).toString());
			}
			buildModel.getBuild().add(entry);
		}
	}

	private String addBuildEntry(WorkspaceBuildModel model, String key, String value) throws CoreException {
		IBuild build = model.getBuild(true);
		IBuildEntry entry = build.getEntry(key);
		if (entry == null) {
			entry = model.getFactory().createEntry(key);
			entry.addToken(value);
			build.add(entry);
		}
		String[] tokens = entry.getTokens();
		return (tokens.length > 0) ? tokens[0] : "src/"; //$NON-NLS-1$
	}

	/**
	 * Creates links in the project to the source locations for the various libraries.
	 * If the source for all libraries is in a single bundle, one link is created
	 * @param project destination project of the import
	 * @param model model representing the plugin to import
	 * @param monitor progress monitor
	 * @throws CoreException if there is a problem completing the import
	 */
	private void linkSourceArchives(IProject project, IPluginModelBase model, IProgressMonitor monitor) throws CoreException {
		String[] libraries = getLibraryNames(model, true);
		monitor.beginTask(PDEUIMessages.ImportWizard_operation_copyingSource, libraries.length);

		SourceLocationManager manager = PDECore.getDefault().getSourceLocationManager();
		if (manager.hasBundleManifestLocation(model.getPluginBase())) {
			IPath srcPath = manager.findSourcePath(model.getPluginBase(), null);
			if (srcPath != null) {
				// Source for all libraries is in the same bundle, just create one link to the source bundle
				IPath path = new Path(project.getName() + "src.zip"); //$NON-NLS-1$
				IFile srcFile = project.getFile(path.lastSegment());
				if (!srcFile.exists()) {
					srcFile.createLink(srcPath, IResource.NONE, new SubProgressMonitor(monitor, 1));
				}
			}
			monitor.worked(libraries.length);
		} else {
			for (int i = 0; i < libraries.length; i++) {
				String zipName = ClasspathUtilCore.getSourceZipName(libraries[i]);
				IPath path = new Path(zipName);
				if (project.findMember(path) == null) {
					IPath srcPath = manager.findSourcePath(model.getPluginBase(), path);
					if (srcPath != null) {
						if ("src.zip".equals(zipName) && isJARd(model)) { //$NON-NLS-1$
							path = new Path(ClasspathUtilCore.getSourceZipName(new File(model.getInstallLocation()).getName()));
						}
						IFile zipFile = project.getFile(path.lastSegment());
						if (!zipFile.exists()) {
							zipFile.createLink(srcPath, IResource.NONE, new SubProgressMonitor(monitor, 1));
						}
					}
				}
				monitor.worked(1);
			}
		}
		monitor.done();
	}

	private void importSourceArchives(IProject project, IPluginModelBase model, IProgressMonitor monitor) throws CoreException {
		String[] libraries = getLibraryNames(model, true);
		monitor.beginTask(PDEUIMessages.ImportWizard_operation_copyingSource, libraries.length);

		SourceLocationManager manager = PDECore.getDefault().getSourceLocationManager();

		Set roots = null;
		if (manager.hasBundleManifestLocation(model.getPluginBase()))
			roots = manager.findSourceRoots(model.getPluginBase());

		for (int i = 0; i < libraries.length; i++) {
			String zipName = ClasspathUtilCore.getSourceZipName(libraries[i]);
			IPath path = new Path(zipName);
			if (project.findMember(path) == null) {
				// if we are importing the source through a sourceBundle header...
				if (roots != null) {
					IPath sourceLocation = manager.findSourcePath(model.getPluginBase(), null);
					String currentRoot = ".".equals(libraries[i]) ? "." : path.removeFileExtension().toString(); //$NON-NLS-1$ //$NON-NLS-2$
					if (roots.contains(currentRoot)) {
						if (".".equals(currentRoot)) { //$NON-NLS-1$
							// Save to a special folder name based on the install location
							IPath sourceName = getDefaultSourceNameForProject(model);
							sourceName = sourceName.removeFileExtension();
							IFolder dest = project.getFolder(sourceName);
							if (!dest.exists()) {
								dest.create(true, true, null);
							}

							// List all of the other source roots so they are not included when importing source from the root, ".", of the jar
							Set allBundleRoots = manager.findAllSourceRootsInSourceLocation(model.getPluginBase());
							List rootsToExclude = new ArrayList(allBundleRoots.size() - 1);
							for (Iterator iterator2 = allBundleRoots.iterator(); iterator2.hasNext();) {
								String rootString = (String) iterator2.next();
								if (!".".equals(rootString)) { //$NON-NLS-1$
									rootsToExclude.add(new Path(rootString));
								}
							}

							// Extract folders containing java source
							extractJavaSource(new File(sourceLocation.toOSString()), rootsToExclude, dest, monitor);
						} else {
							// Extract the specific library from it's folder
							extractResourcesFromFolder(new File(sourceLocation.toOSString()), new Path(currentRoot), project, monitor);
						}
					}
				} else {
					IPath srcPath = manager.findSourcePath(model.getPluginBase(), path);
					if (srcPath != null) {
						if ("src.zip".equals(zipName) && isJARd(model)) { //$NON-NLS-1$
							path = getDefaultSourceNameForProject(model);
						}
						importArchive(project, new File(srcPath.toOSString()), path);
					}
				}
			}
			monitor.worked(1);
		}
		monitor.done();
	}

	/**
	 * Creates a model for an existing manifest file, replacing the classpath entry with the
	 * new location of the referenced library.  Also removes any extra entries such as signing
	 * headers. 
	 * @param project
	 * @param base
	 */
	private IPath getDefaultSourceNameForProject(IPluginModelBase model) {
		return new Path(ClasspathUtilCore.getSourceZipName(new File(model.getInstallLocation()).getName()));
	}

	private String[] getLibraryNames(IPluginModelBase model, boolean expand) {
		IPluginLibrary[] libraries = model.getPluginBase().getLibraries();
		ArrayList list = new ArrayList();
		for (int i = 0; i < libraries.length; i++) {
			if (expand)
				list.add(ClasspathUtilCore.expandLibraryName(libraries[i].getName()));
			else
				list.add(libraries[i].getName());
		}
		if (libraries.length == 0 && isJARd(model))
			list.add("."); //$NON-NLS-1$
		return (String[]) list.toArray(new String[list.size()]);
	}

	private void extractJARdPlugin(IProject project, IPluginModelBase model, IProgressMonitor monitor) throws CoreException {
		ZipFile zipFile = null;
		try {
			zipFile = new ZipFile(model.getInstallLocation());
			ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
			if (!containsCode(provider)) {
				extractZipFile(new File(model.getInstallLocation()), project.getFullPath(), monitor);
				return;
			}
			ArrayList collected = new ArrayList();
			collectNonJavaResources(provider, provider.getRoot(), collected);
			importContent(provider.getRoot(), project.getFullPath(), provider, collected, monitor);

			File file = new File(model.getInstallLocation());
			if (hasEmbeddedSource(provider) && fImportType == IMPORT_WITH_SOURCE) {
				collected = new ArrayList();
				collectJavaFiles(provider, provider.getRoot(), collected);
				importContent(provider.getRoot(), project.getFullPath(), provider, collected, monitor);
				collected = new ArrayList();
				collectJavaResources(provider, provider.getRoot(), collected);
				importContent(provider.getRoot(), project.getFullPath().append("src"), provider, collected, monitor); //$NON-NLS-1$
			} else {
				if (fImportType == IMPORT_BINARY_WITH_LINKS) {
					project.getFile(file.getName()).createLink(new Path(file.getAbsolutePath()), IResource.NONE, null);
				} else {
					importArchive(project, file, new Path(file.getName()));
				}
				if (!hasEmbeddedSource(provider)) {
					if (fImportType == IMPORT_BINARY_WITH_LINKS) {
						linkSourceArchives(project, model, new SubProgressMonitor(monitor, 1));
					} else {
						importSourceArchives(project, model, new SubProgressMonitor(monitor, 1));
					}
				}
			}
			if (fImportType != IMPORT_WITH_SOURCE) {
				modifyBundleClasspathHeader(project, model);
			} else {
				removeSignedHeaders(project);
			}
			setPermissions(model, project);
		} catch (IOException e) {
			IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
			throw new CoreException(status);
		} finally {
			if (zipFile != null) {
				try {
					zipFile.close();
				} catch (IOException e) {
				}
			}
		}
	}

	private void modifyBundleClasspathHeader(IProject project, IPluginModelBase base) {
		IFile file = project.getFile(JarFile.MANIFEST_NAME);
		if (file.exists()) {

		}
	}

	private void removeSignedHeaders(IProject project) {
		IFile file = project.getFile(JarFile.MANIFEST_NAME);
		if (!file.exists())
			return;
		WorkspaceBundleModel model = new WorkspaceBundleModel(file);
		model.save();
	}

	private IProject findProject(String id) {
		IPluginModelBase model = PluginRegistry.findModel(id);
		if (model != null) {
			IResource resource = model.getUnderlyingResource();
			if (resource != null)
				return resource.getProject();
		}
		return PDEPlugin.getWorkspace().getRoot().getProject(id);
	}

	private boolean queryReplace(IProject project) throws OperationCanceledException {
		switch (fReplaceQuery.doQuery(NLS.bind(PDEUIMessages.ImportWizard_messages_exists, project.getName()))) {
			case IImportQuery.CANCEL :
				throw new OperationCanceledException();
			case IImportQuery.NO :
				return false;
		}
		return true;
	}

	private boolean queryExecutionEnvironment(String message) throws OperationCanceledException {
		switch (fExecutionQuery.doQuery(message)) {
			case IImportQuery.CANCEL :
				throw new OperationCanceledException();
			case IImportQuery.NO :
				return false;
		}
		return true;
	}

	private void setProjectDescription(IProject project, IPluginModelBase model) throws CoreException {
		IProjectDescription desc = project.getDescription();
		if (!desc.hasNature(PDE.PLUGIN_NATURE))
			CoreUtility.addNatureToProject(project, PDE.PLUGIN_NATURE, null);
		if (needsJavaNature(project, model) && !desc.hasNature(JavaCore.NATURE_ID))
			CoreUtility.addNatureToProject(project, JavaCore.NATURE_ID, null);
	}

	private boolean needsJavaNature(IProject project, IPluginModelBase model) {
		if (model.getPluginBase().getLibraries().length > 0)
			return true;

		return false;
	}

	private void setProjectNatures(IProject project, IPluginModelBase model) throws CoreException {
		IProjectDescription desc = project.getDescription();
		if (!desc.hasNature(PDE.PLUGIN_NATURE))
			CoreUtility.addNatureToProject(project, PDE.PLUGIN_NATURE, null);
		if (needsJavaNature(project, model) && !desc.hasNature(JavaCore.NATURE_ID))
			CoreUtility.addNatureToProject(project, JavaCore.NATURE_ID, null);
			return true;

		if ("org.eclipse.swt".equals(id) && !isJARd(model)) //$NON-NLS-1$
			return true;
		return false;
	}

	private boolean isJARd(IPluginModelBase model) {
		return new File(model.getInstallLocation()).isFile();
	}

	private void setPermissions(IPluginModelBase model, IProject project) {
		try {
			if (!Platform.getOS().equals(Constants.OS_WIN32) && model instanceof IFragmentModel) {
				IFragment fragment = ((IFragmentModel) model).getFragment();
				if ("org.eclipse.swt".equals(fragment.getPluginId())) { //$NON-NLS-1$
					IResource[] children = project.members();
					for (int i = 0; i < children.length; i++) {
						if (children[i] instanceof IFile && isInterestingResource(children[i].getName())) {
							Runtime.getRuntime().exec(new String[] {"chmod", "755", children[i].getLocation().toOSString()}).waitFor(); //$NON-NLS-1$ //$NON-NLS-2$
						}
					}
				}
			}
		} catch (CoreException e) {
		} catch (InterruptedException e) {
		} catch (IOException e) {
		}
	}

	private boolean isInterestingResource(String name) {
		return name.endsWith(".jnilib") //$NON-NLS-1$
				|| name.endsWith(".sl") //$NON-NLS-1$
				|| name.endsWith(".a") //$NON-NLS-1$
				|| name.indexOf(".so") != -1; //$NON-NLS-1$
	}

	private IFragment[] getFragmentsFor(IPluginModelBase model) {
		ArrayList result = new ArrayList();
		for (int i = 0; i < fModels.length; i++) {
			if (fModels[i] instanceof IFragmentModel) {
				HostSpecification spec = fModels[i].getBundleDescription().getHost();
				BundleDescription host = spec == null ? null : (BundleDescription) spec.getSupplier();
				if (model.getBundleDescription().equals(host)) {
					result.add(((IFragmentModel) fModels[i]).getFragment());
				}
			}
		}
		return (IFragment[]) result.toArray(new IFragment[result.size()]);
	}

	private void importJarFromFragment(IProject project, IFragment fragment, String name) throws CoreException {
		IPath jarPath = new Path(ClasspathUtilCore.expandLibraryName(name));
		File jar = new File(fragment.getModel().getInstallLocation(), jarPath.toString());
		if (jar.exists()) {
			importArchive(project, jar, jarPath);
		}
	}

	/**
	 * Gets the list of libraries from the model and returns an array of their expanded
	 * names.  Will add the default library name if no libraries are specified.
	 * @param model
	 * @return list of library names
	 * @param monitor progress monitor
	 * @throws CoreException if there is a problem completing the import
	 */
	private String[] getLibraryNames(IPluginModelBase model) {
		IPluginLibrary[] libraries = model.getPluginBase().getLibraries();
		ArrayList list = new ArrayList();
		for (int i = 0; i < libraries.length; i++) {
			list.add(ClasspathUtilCore.expandLibraryName(libraries[i].getName()));
			if (project.findMember(path) == null) {
				SourceLocationManager manager = PDECore.getDefault().getSourceLocationManager();
				IPath srcPath = manager.findSourcePath(fragment, path);
				if (srcPath != null) {
					if (manager.hasBundleManifestLocation(fragment)) {
						// Extract the specific library from it's folder
						extractResourcesFromFolder(new File(srcPath.toOSString()), path.removeFileExtension(), project, monitor);
					} else {
						importArchive(project, new File(srcPath.toOSString()), path);
					}
				}
			}
		} finally {
			monitor.done();
		}
	}

	protected void collectAdditionalResources(ZipFileStructureProvider provider, Object element, ArrayList collected, IProject project) {
		collectAdditionalResources(provider, element, collected);
		ListIterator li = collected.listIterator();
		while (li.hasNext()) {
			ZipEntry ze = (ZipEntry) li.next();
			String name = ze.getName();
			// only import the entries that don't already exist
			if (project.findMember(name) != null) {
				li.remove();
			}
		}
		if (libraries.length == 0 && isJARd(model))
			list.add(DEFAULT_LIBRARY_NAME);
		return (String[]) list.toArray(new String[list.size()]);
	}

	/**
	 * Returns the standard source directory name for a library name.  
	 * Used to get the source root name for a library as well as the
	 * standard destination name.
	 * @param libraryName
	 * @return source dir name
	 */
	private String getSourceDirName(String libraryName) {
		int dot = libraryName.lastIndexOf('.');
		return (dot != -1) ? libraryName.substring(0, dot) + DEFAULT_SOURCE_DIR : libraryName;
			if (name.startsWith("META-INF/") && (name.endsWith(".RSA") || name.endsWith(".DSA") || name.endsWith(".SF"))) //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
				li.remove();
		}
	}

	/**
	 * Returns whether the install location of the plug-in is a jar file or a folder
	 * @param model
	 * @return true if the install location is a jar, false if it is a folder
	 */
	private boolean isJARd(IPluginModelBase model) {
		return new File(model.getInstallLocation()).isFile();
	}

}




import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.viewers.*;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.internal.core.*;
import org.eclipse.pde.internal.core.WorkspaceModelManager;
import org.eclipse.pde.internal.core.plugin.AbstractPluginModelBase;
import org.eclipse.pde.internal.core.util.PatternConstructor;
import org.eclipse.pde.internal.ui.*;

	private TableViewer fAvailableListViewer;
	private Text fFilterText;
	private VersionFilter fVersionFilter;
	private AvailableFilter fAvailableFilter;
	private SourcePluginFilter fSourceFilter;
	// fSelected is used to track the selection in a hash set so we can efficiently
	// filter selected items out of the available item list
	private Set fSelected;

	private Button fRemoveAllButton;
	private Button fAddRequiredButton;
	private Button fFilterOldVersionButton;
	private Button fFilterSourcePluginsButton;

	private static final String SETTINGS_SHOW_LATEST = "showLatestPluginsOnly"; //$NON-NLS-1$
	private static final String SETTINGS_SHOW_SOURCE = "showSourcePlugins"; //$NON-NLS-1$

	private class AvailableFilter extends ViewerFilter {
		private Pattern fPattern;

				return true;
			return hVersion.equals(plugin.getBundleDescription().getVersion());
		}
	}

	/**
	 * This filter is used to remove source plug-ins from view
	 * 
	 */
	private class SourcePluginFilter extends ViewerFilter {
		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
		 */
		public boolean select(Viewer viewer, Object parentElement, Object element) {
			if (element instanceof IPluginModelBase) {
				PDEState state = fPage1.getState();
				if (state != null) {
					BundleDescription description = ((IPluginModelBase) element).getBundleDescription();
					if (description != null) {
						return state.getBundleSourceEntry(description.getBundleId()) == null;
					}
				}
			}
			return true;
		}
	}

	public PluginImportWizardDetailedPage(String pageName, PluginImportWizardFirstPage firstPage) {

		Composite buttonContainer = new Composite(container, SWT.NONE);
		buttonContainer.setLayout(GridLayoutFactory.fillDefaults().create());
		createComputationsOption(buttonContainer, 3);
		createFilterOptions(buttonContainer, 3);

		addViewerListeners();
		addFilters();

		initialize();
		setControl(container);

		PlatformUI.getWorkbench().getHelpSystem().setHelp(container, IHelpContextIds.PLUGIN_IMPORT_SECOND_PAGE);
	}

	private void createFilterOptions(Composite container, int span) {
		Composite parent = new Composite(container, SWT.NONE);
		parent.setLayout(GridLayoutFactory.swtDefaults().margins(5, 0).create());
		fFilterOldVersionButton = new Button(parent, SWT.CHECK);


		fFilterOldVersionButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				fAvailableListViewer.removeFilter(fVersionFilter);
				if (fFilterOldVersionButton.getSelection()) {
					fAvailableListViewer.addFilter(fVersionFilter);
				} else {
					fAvailableListViewer.removeFilter(fVersionFilter);
				}
				fAvailableListViewer.getTable().setRedraw(false);
				fAvailableListViewer.refresh();
				fAvailableListViewer.getTable().setRedraw(true);
			}
		});

		fFilterSourcePluginsButton = new Button(parent, SWT.CHECK);
		// TODO NLS this string, not done so related patches won't conflict
		fFilterSourcePluginsButton.setText("Show source plug-ins");
		gData = new GridData(GridData.FILL_HORIZONTAL);
		gData.horizontalSpan = span;
		fFilterSourcePluginsButton.setLayoutData(gData);

		if (getDialogSettings().get(SETTINGS_SHOW_SOURCE) != null) {
			fFilterSourcePluginsButton.setSelection(getDialogSettings().getBoolean(SETTINGS_SHOW_SOURCE));
		} else {
			fFilterSourcePluginsButton.setSelection(false);
		}

		fFilterSourcePluginsButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				if (fFilterSourcePluginsButton.getSelection()) {
					fAvailableListViewer.removeFilter(fSourceFilter);
				} else {
					fAvailableListViewer.addFilter(fSourceFilter);
				}
			}
		});
	}

	private void addFilters() {
		fVersionFilter = new VersionFilter();
		fVersionFilter.setModel(fModels);
		fAvailableFilter = new AvailableFilter();
		fSourceFilter = new SourcePluginFilter();
		fAvailableListViewer.addFilter(fAvailableFilter);
		fAvailableListViewer.addFilter(fVersionFilter);
		if (!fFilterSourcePluginsButton.getSelection()) {
			fAvailableListViewer.addFilter(fSourceFilter);
		}

		fFilterJob = new WorkbenchJob("FilterJob") { //$NON-NLS-1$
			public IStatus runInUIThread(IProgressMonitor monitor) {
				handleFilter();

	protected void refreshPage() {
		fImportListViewer.getTable().removeAll();
		fSelected.clear();
		fAvailableFilter.setPattern("*"); //$NON-NLS-1$
		fVersionFilter.setModel(fModels);
		fAvailableListViewer.refresh();
		pageChanged();

		String newFilter;
		if (fFilterText == null || (newFilter = fFilterText.getText().trim()).length() == 0)
			newFilter = "*"; //$NON-NLS-1$
		changed = fAvailableFilter.setPattern(newFilter);
		if (changed) {
			// TODO Test whether we need to redraw/refresh
			fAvailableListViewer.getTable().setRedraw(false);
			fAvailableListViewer.refresh();
			fAvailableListViewer.getTable().setRedraw(true);

	public void storeSettings() {
		IDialogSettings settings = getDialogSettings();
		settings.put(SETTINGS_SHOW_LATEST, fFilterOldVersionButton.getSelection());
		settings.put(SETTINGS_SHOW_SOURCE, fFilterSourcePluginsButton.getSelection());
		super.storeSettings();
	}





/*******************************************************************************
 * Copyright (c) 2005, 2007 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.pde.internal.ui.wizards.imports;

import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
import java.util.zip.ZipFile;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.pde.internal.core.util.CoreUtility;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.ui.dialogs.IOverwriteQuery;
import org.eclipse.ui.wizards.datatransfer.*;

public abstract class JarImportOperation implements IWorkspaceRunnable {

	protected void extractZipFile(File file, IPath destPath, IProgressMonitor monitor) throws CoreException {
		ZipFile zipFile = null;
		try {
			zipFile = new ZipFile(file);
			ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
			importContent(provider.getRoot(), destPath, provider, null, monitor);
		} catch (IOException e) {
			IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
			throw new CoreException(status);
		} finally {
			if (zipFile != null) {
				try {
					zipFile.close();
				} catch (IOException e) {
				}
			}
		}
	}

	protected void importContent(Object source, IPath destPath, IImportStructureProvider provider, List filesToImport, IProgressMonitor monitor) throws CoreException {
		IOverwriteQuery query = new IOverwriteQuery() {
			public String queryOverwrite(String file) {
				return ALL;
			}
		};
		try {
			ImportOperation op = new ImportOperation(destPath, source, provider, query);
			op.setCreateContainerStructure(false);
			if (filesToImport != null) {
				op.setFilesToImport(filesToImport);
			}
			op.run(monitor);
		} catch (InvocationTargetException e) {
			IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
			throw new CoreException(status);
		} catch (InterruptedException e) {
			throw new OperationCanceledException(e.getMessage());
		}
	}

	protected void extractResources(File file, IResource dest, IProgressMonitor monitor) throws CoreException {
		ZipFile zipFile = null;
		try {
			zipFile = new ZipFile(file);
			ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
			ArrayList collected = new ArrayList();
			collectResources(provider, provider.getRoot(), true, collected);
			importContent(provider.getRoot(), dest.getFullPath(), provider, collected, monitor);
		} catch (IOException e) {
			IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
			throw new CoreException(status);
		} finally {
			if (zipFile != null) {
				try {
					zipFile.close();
				} catch (IOException e) {
				}
			}
		}
	}

	/**
	 * Extracts all of the files and subfolders from a single folder within an archive file.
	 * @param file archive file to search for files
	 * @param folderPath path to the folder to extract from
	 * @param dest destination to import content to
	 * @param monitor progress monitor
	 * @throws CoreException if a problem occurs while extracting
	 * @since 3.4
	 */
	protected void extractResourcesFromFolder(File file, IPath folderPath, IResource dest, IProgressMonitor monitor) throws CoreException {
		ZipFile zipFile = null;
		try {
			zipFile = new ZipFile(file);
			ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
			ArrayList collected = new ArrayList();
			collectResourcesFromFolder(provider, provider.getRoot(), folderPath, collected);
			importContent(provider.getRoot(), dest.getFullPath(), provider, collected, monitor);
		} catch (IOException e) {
			IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
			throw new CoreException(status);
		} finally {
			if (zipFile != null) {
				try {
					zipFile.close();
				} catch (IOException e) {
				}
			}
		}
	}

	/**
	 * Searches the given archive file for java source folders.  Imports the files in the
	 * source folders to the specified destination unless the folder is in the list of 
	 * folders to exclude. 
	 * @param file archive file to search for source in
	 * @param excludeFolders list of IPaths describing folders to ignore while searching
	 * @param dest destination to put the extracted source
	 * @param monitor progress monitor
	 * @throws CoreException if there is a problem extracting source from the zip
	 * @since 3.4
	 */
	protected void extractJavaSource(File file, List excludeFolders, IResource dest, IProgressMonitor monitor) throws CoreException {
		ZipFile zipFile = null;
		try {
			zipFile = new ZipFile(file);
			ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
			ArrayList collected = new ArrayList();
			collectJavaSourceFromRoot(provider, excludeFolders, collected);
			importContent(provider.getRoot(), dest.getFullPath(), provider, collected, monitor);
		} catch (IOException e) {
			IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
			throw new CoreException(status);
		} finally {
			if (zipFile != null) {
				try {
					zipFile.close();
				} catch (IOException e) {
				}
			}
		}
	}

	protected void extractJavaResources(File file, IResource dest, IProgressMonitor monitor) throws CoreException {
		ZipFile zipFile = null;
		try {
			zipFile = new ZipFile(file);
			ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
			ArrayList collected = new ArrayList();
			collectJavaResources(provider, provider.getRoot(), collected);
			importContent(provider.getRoot(), dest.getFullPath(), provider, collected, monitor);
		} catch (IOException e) {
			IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
			throw new CoreException(status);
		} finally {
			if (zipFile != null) {
				try {
					zipFile.close();
				} catch (IOException e) {
				}
			}
		}
	}

	protected void importArchive(IProject project, File archive, IPath destPath) throws CoreException {
		try {
			if (destPath.segmentCount() > 2)
				CoreUtility.createFolder(project.getFolder(destPath.removeLastSegments(1)));
			IFile file = project.getFile(destPath);
			FileInputStream fstream = new FileInputStream(archive);
			if (file.exists())
				file.setContents(fstream, true, false, null);
			else
				file.create(fstream, true, null);
			fstream.close();
		} catch (IOException e) {
			IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.OK, e.getMessage(), e);
			throw new CoreException(status);
		}
	}

	private void collectResources(ZipFileStructureProvider provider, Object element, boolean excludeMeta, ArrayList collected) {
		List children = provider.getChildren(element);
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr)) {
					if (!excludeMeta || !provider.getLabel(curr).equals("META-INF")) { //$NON-NLS-1$
						collectResources(provider, curr, excludeMeta, collected);
					}
				} else if (!provider.getLabel(curr).endsWith(".class")) { //$NON-NLS-1$
					collected.add(curr);
				}
			}
		}
	}

	/**
	 * Recursively searches through the zip files searching for files inside of
	 * the specified folder.  The files found will be added to the given list.
	 * @param provider zip provider
	 * @param element element of the zip currently being looked at
	 * @param folderPath location of the folder to get resources from
	 * @param collected list of files found
	 * @since 3.4
	 */
	protected void collectResourcesFromFolder(ZipFileStructureProvider provider, Object element, IPath folderPath, ArrayList collected) {
		List children = provider.getChildren(element);
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr)) {
					if (provider.getLabel(curr).equals(folderPath.segment(0))) {
						if (folderPath.segmentCount() > 1) {
							collectResourcesFromFolder(provider, curr, folderPath.removeFirstSegments(1), collected);
						} else {
							collectResources(provider, curr, false, collected);
						}
					}
				}
			}
		}
	}

	/**
	 * Searches through the zip file for java source folders.  Collects the files
	 * within the source folders.  If a folder is in the list of folder paths to
	 * ignore, the folder will be skipped.
	 * @param provider zip provider
	 * @param ignoreFolders list of IPaths describing folders to ignore
	 * @param collected list that source files will be added to
	 * @since 3.4
	 */
	protected void collectJavaSourceFromRoot(ZipFileStructureProvider provider, List ignoreFolders, ArrayList collected) {
		List children = provider.getChildren(provider.getRoot());
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr) && folderContainsFileExtension(provider, curr, ".java")) { //$NON-NLS-1$
					// Check if we are in an ignored folder
					List ignoreSubFolders = new ArrayList();
					boolean ignoreThisChild = false;
					for (Iterator iterator = ignoreFolders.iterator(); iterator.hasNext();) {
						IPath currentPath = (IPath) iterator.next();
						if (provider.getLabel(curr).equals(currentPath.segment(0))) {
							if (currentPath.segmentCount() > 1) {
								// There is a subfolder that should be ignored
								ignoreSubFolders.add(currentPath.removeFirstSegments(1));
							} else {
								// This folder should be ignored
								ignoreThisChild = true;
								break;
							}
						}
					}
					if (!ignoreThisChild) {
						collectJavaSource(provider, curr, ignoreSubFolders, collected);
					}
				}
			}
		}
	}

	/**
	 * Recursively searches the children of the given element inside of a zip file. 
	 * If the folder path is in the set of folders to ignore, the folder will be skipped.
	 * All files found, except for .class files, will be added. The given list will be
	 * updated with the source files.
	 * 
	 * @param provider zip provider
	 * @param element current element inside the zip
	 * @param ignoreFolders list of IPath folder paths to skip while searching
	 * @param collected list to update with new files found to import
	 * @since 3.4
	 */
	protected void collectJavaSource(ZipFileStructureProvider provider, Object element, List ignoreFolders, ArrayList collected) {
		List children = provider.getChildren(element);
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr)) {
					// Check if we are in an ignored folder
					List ignoreSubFolders = new ArrayList();
					boolean ignoreThisChild = false;
					for (Iterator iterator = ignoreFolders.iterator(); iterator.hasNext();) {
						IPath currentPath = (IPath) iterator.next();
						if (provider.getLabel(curr).equals(currentPath.segment(0))) {
							if (currentPath.segmentCount() > 1) {
								// There is a subfolder that should be ignored.  Remove segment referencing current folder.
								ignoreSubFolders.add(currentPath.removeFirstSegments(1));
							} else {
								// This folder should be ignored
								ignoreThisChild = true;
								break;
							}
						}
					}
					if (!ignoreThisChild) {
						collectJavaSource(provider, curr, ignoreSubFolders, collected);
					}
					// Add the file to the list
				} else if (!provider.getLabel(curr).endsWith(".class")) { //$NON-NLS-1$
					collected.add(curr);
				}
			}
		}
	}

	protected void collectNonJavaResources(ZipFileStructureProvider provider, Object element, ArrayList collected) {
		List children = provider.getChildren(element);
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr)) {
					if (!provider.getLabel(curr).equals("src") && !isClassFolder(provider, curr)) { //$NON-NLS-1$
						ArrayList list = new ArrayList();
						collectResources(provider, curr, false, list);
						collected.addAll(list);
					}
				} else if (!provider.getLabel(curr).endsWith(".class")) { //$NON-NLS-1$
					collected.add(curr);
				}
			}
		}
	}

	protected void collectAdditionalResources(ZipFileStructureProvider provider, Object element, ArrayList collected) {
		List children = provider.getChildren(element);
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr)) {
					// ignore source folders
					if (folderContainsFileExtension(provider, curr, ".java")) //$NON-NLS-1$
						continue;
					collected.add(curr);
				} else if (!provider.getLabel(curr).endsWith(".java")) { //$NON-NLS-1$
					collected.add(curr);
				}
			}
		}
	}

	protected void collectJavaFiles(ZipFileStructureProvider provider, Object element, ArrayList collected) {
		List children = provider.getChildren(element);
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr)) {
					if (provider.getLabel(curr).equals("src")) { //$NON-NLS-1$
						ArrayList list = new ArrayList();
						collectResources(provider, curr, false, list);
						collected.addAll(list);
					}
				}
			}
		}
	}

	protected void collectJavaResources(ZipFileStructureProvider provider, Object element, ArrayList collected) {
		List children = provider.getChildren(element);
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr)) {
					if (isClassFolder(provider, curr)) {
						ArrayList list = new ArrayList();
						collectResources(provider, curr, false, list);
						collected.addAll(list);
					}
				}
			}
		}
	}

	private boolean folderContainsFileExtension(ZipFileStructureProvider provider, Object element, String fileExtension) {
		List children = provider.getChildren(element);
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr)) {
					if (folderContainsFileExtension(provider, curr, fileExtension)) {
						return true;
					}
				} else if (provider.getLabel(curr).endsWith(fileExtension)) { //$NON-NLS-1$
					return true;
				}
			}
		}
		return false;
	}

	private boolean isClassFolder(ZipFileStructureProvider provider, Object element) {
		return folderContainsFileExtension(provider, element, ".class"); //$NON-NLS-1$
	}

	protected boolean hasEmbeddedSource(ZipFileStructureProvider provider) {
		List children = provider.getChildren(provider.getRoot());
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr) && provider.getLabel(curr).equals("src")) { //$NON-NLS-1$
					return true;
				}
			}
		}
		return false;
	}

	protected boolean containsCode(ZipFileStructureProvider provider) {
		List children = provider.getChildren(provider.getRoot());
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr) && isClassFolder(provider, curr)) {
					return true;
				}
			}
		}
		return false;
	}

	protected boolean containsCode(File file) {
		ZipFile zipFile = null;
		try {
			zipFile = new ZipFile(file);
			return containsCode(new ZipFileStructureProvider(zipFile));
		} catch (IOException e) {
		} finally {
			if (zipFile != null) {
				try {
					zipFile.close();
				} catch (IOException e) {
				}
			}
		}
		return true;
	}

	protected String[] getTopLevelResources(File file) {
		ArrayList result = new ArrayList();
		ZipFile zipFile = null;
		try {
			zipFile = new ZipFile(file);
			ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
			List children = provider.getChildren(provider.getRoot());
			if (children != null && !children.isEmpty()) {
				for (int i = 0; i < children.size(); i++) {
					Object curr = children.get(i);
					if (provider.isFolder(curr)) {
						if (!isClassFolder(provider, curr))
							result.add(provider.getLabel(curr) + "/"); //$NON-NLS-1$
						else {
							if (!result.contains(".")) //$NON-NLS-1$
								result.add("."); //$NON-NLS-1$
						}
					} else {
						result.add(provider.getLabel(curr));
					}
				}
			}
		} catch (IOException e) {
		} finally {
			if (zipFile != null) {
				try {
					zipFile.close();
				} catch (IOException e) {
				}
			}
		}
		return (String[]) result.toArray(new String[result.size()]);
	}

}




PluginSelectionDialog_title = Plug-in Selection
PluginStructureCreator_name=Plug-in Structure Compare
PluginSelectionDialog_message = &Select a Plug-in:
PluginImportOperation_could_not_delete_project=Import operation could not delete the following project: {0}
PluginImportInfoDialog_title=Deleting Plug-ins Failed
PluginImportOperation_linking=Linking content...
PluginImportOperation_executionEnvironment=Plug-in ''{0}'' requires an ''{1}'' execution environment that is not supported by any of the installed JREs. Import anyway?
PluginImportOperation_Importing_plugin=Importing {0}
PluginImportWizard_runningConfigDesc=An application is currently running. Some of the selected plug-ins may not be imported if they are locked by it. Do you want to continue?
PluginImportWizard_runningConfigsDesc=Multiple applications are currently running. Some of the selected plug-ins may not be imported if they are locked by them. Do you want to continue?
PluginImportWizard_runningConfigsTitle=Running Applications

ImportWizard_DetailedPage_filterDesc=Show latest version of plug-ins only
ImportWizard_DetailedPage_search = &ID (* = any string, ? = any character):

ImportWizard_operation_creating = Creating projects from plug-ins
ImportWizard_operation_multiProblem = Problems detected while importing plug-ins
ImportWizard_operation_importingSource== Importing source...
ImportWizard_operation_copyingSource = Copying source...

FeatureImportWizard_FirstPage_title = Import Features
FeatureImportWizard_FirstPage_desc = Create projects from features in the file system.
FeatureImportWizard_FirstPage_runtimeLocation = &Choose from features in the target platform

Lines 114-120 Link Here

(-)META-INF/MANIFEST.MF (-1 / +4 lines)
114	org.eclipse.equinox.p2.core;bundle-version="[1.0.0,2.0.0)",	114	org.eclipse.equinox.p2.core;bundle-version="[1.0.0,2.0.0)",
115	org.eclipse.equinox.p2.director;bundle-version="[1.0.100,2.0.0)",	115	org.eclipse.equinox.p2.director;bundle-version="[1.0.100,2.0.0)",
116	org.eclipse.equinox.p2.artifact.repository;bundle-version="[1.0.100,2.0.0)",	116	org.eclipse.equinox.p2.artifact.repository;bundle-version="[1.0.100,2.0.0)",
117	org.eclipse.equinox.p2.metadata.repository;bundle-version="[1.0.100,2.0.0)"	117	org.eclipse.equinox.p2.metadata.repository;bundle-version="[1.0.100,2.0.0)",
		118	org.eclipse.equinox.p2.publisher;bundle-version="[1.0.0,2.0.0)",
		119	org.eclipse.equinox.frameworkadmin;bundle-version="1.0.100",
		120	org.eclipse.equinox.frameworkadmin.equinox;bundle-version="1.0.100"
118	Eclipse-LazyStart: true	121	Eclipse-LazyStart: true
119	Import-Package: com.ibm.icu.text,	122	Import-Package: com.ibm.icu.text,
120	org.eclipse.jdt.debug.core	123	org.eclipse.jdt.debug.core

Lines 11-31 Link Here

(-)src/org/eclipse/pde/ui/launcher/AbstractPDELaunchConfiguration.java (-19 / +175 lines)
11	package org.eclipse.pde.ui.launcher;	11	package org.eclipse.pde.ui.launcher;
12		12
13	import java.io.File;	13	import java.io.File;
14	import java.util.ArrayList;	14	import java.io.IOException;
15	import java.util.Map;	15	import java.util.*;
16	import org.eclipse.core.resources.IMarker;	16	import org.eclipse.core.resources.IMarker;
17	import org.eclipse.core.resources.IProject;	17	import org.eclipse.core.resources.IProject;
		18	import org.eclipse.core.resources.IResource;
18	import org.eclipse.core.runtime.*;	19	import org.eclipse.core.runtime.*;
19	import org.eclipse.debug.core.*;	20	import org.eclipse.debug.core.*;
20	import org.eclipse.debug.core.model.LaunchConfigurationDelegate;	21	import org.eclipse.debug.core.model.LaunchConfigurationDelegate;
21	import org.eclipse.jdt.core.IJavaModelMarker;	22	import org.eclipse.jdt.core.IJavaModelMarker;
		23	import org.eclipse.equinox.internal.frameworkadmin.equinox.EquinoxConstants;
		24	import org.eclipse.equinox.internal.p2.core.helpers.ServiceHelper;
		25	import org.eclipse.equinox.internal.p2.director.DirectorActivator;
		26	import org.eclipse.equinox.internal.provisional.frameworkadmin.*;
		27	import org.eclipse.equinox.internal.provisional.p2.engine.IProfile;
		28	import org.eclipse.equinox.internal.provisional.p2.engine.IProfileRegistry;
		29	import org.eclipse.equinox.p2.publisher.PublisherInfo;
		30	import org.eclipse.equinox.p2.publisher.PublisherResult;
		31	import org.eclipse.equinox.p2.publisher.eclipse.BundlesAction;
22	import org.eclipse.jdt.launching.*;	32	import org.eclipse.jdt.launching.*;
23	import org.eclipse.jface.dialogs.MessageDialog;	33	import org.eclipse.jface.dialogs.MessageDialog;
		34	import org.eclipse.osgi.service.resolver.BundleDescription;
		35	import org.eclipse.pde.core.plugin.IPluginModelBase;
24	import org.eclipse.pde.core.plugin.TargetPlatform;	36	import org.eclipse.pde.core.plugin.TargetPlatform;
25	import org.eclipse.pde.internal.core.TargetPlatformHelper;	37	import org.eclipse.pde.internal.core.TargetPlatformHelper;
26	import org.eclipse.pde.internal.core.builders.PDEMarkerFactory;	38	import org.eclipse.pde.internal.core.builders.PDEMarkerFactory;
27	import org.eclipse.pde.internal.ui.*;	39	import org.eclipse.pde.internal.ui.*;
28	import org.eclipse.pde.internal.ui.launcher.*;	40	import org.eclipse.pde.internal.ui.launcher.*;
		41	import org.osgi.framework.*;
		42	import org.osgi.util.tracker.ServiceTracker;
29		43
30	/**	44	/**
31	* An abstract launch delegate for PDE-based launch configurations	45	* An abstract launch delegate for PDE-based launch configurations
Lines 62-89 Link Here
62	}	76	}
63	throw e;	77	throw e;
64	}	78	}
		79
65	// if restarting, remove the restart flag from the launch config	80	// if restarting, remove the restart flag from the launch config
66	if (configuration.getAttribute(IPDEUIConstants.RESTART, false) && configuration instanceof ILaunchConfigurationWorkingCopy) {	81	if (configuration.getAttribute(IPDEUIConstants.RESTART, false) && configuration instanceof ILaunchConfigurationWorkingCopy) {
67	((ILaunchConfigurationWorkingCopy) configuration).setAttribute(IPDEUIConstants.RESTART, false);	82	((ILaunchConfigurationWorkingCopy) configuration).setAttribute(IPDEUIConstants.RESTART, false);
68	((ILaunchConfigurationWorkingCopy) configuration).doSave();	83	((ILaunchConfigurationWorkingCopy) configuration).doSave();
69	}	84	}
70	VMRunnerConfiguration runnerConfig = new VMRunnerConfiguration(getMainClass(), getClasspath(configuration));	85
71	runnerConfig.setVMArguments(getVMArguments(configuration));	86	// createP2Profile(configuration, monitor);
72	runnerConfig.setProgramArguments(getProgramArguments(configuration));	87
73	runnerConfig.setWorkingDirectory(getWorkingDirectory(configuration).getAbsolutePath());	88	// VMRunnerConfiguration runnerConfig = new VMRunnerConfiguration(getMainClass(), getClasspath(configuration));
74	runnerConfig.setEnvironment(getEnvironment(configuration));	89	// runnerConfig.setVMArguments(getVMArguments(configuration));
75	runnerConfig.setVMSpecificAttributesMap(getVMSpecificAttributesMap(configuration));	90	// runnerConfig.setProgramArguments(getProgramArguments(configuration));
76		91	// runnerConfig.setWorkingDirectory(getWorkingDirectory(configuration).getAbsolutePath());
77	monitor.worked(1);	92	// runnerConfig.setEnvironment(getEnvironment(configuration));
78		93	// runnerConfig.setVMSpecificAttributesMap(getVMSpecificAttributesMap(configuration));
79	setDefaultSourceLocator(configuration);	94	//
80	manageLaunch(launch);	95	// monitor.worked(1);
81	IVMRunner runner = getVMRunner(configuration, mode);	96	//
82	if (runner != null)	97	// setDefaultSourceLocator(configuration);
83	runner.run(runnerConfig, launch, monitor);	98	// manageLaunch(launch);
84	else	99	// IVMRunner runner = getVMRunner(configuration, mode);
85	monitor.setCanceled(true);	100	// if (runner != null)
86	monitor.done();	101	// runner.run(runnerConfig, launch, monitor);
		102	// else
		103	// monitor.setCanceled(true);
		104	// monitor.done();
		105
		106	setupFrameworkAdmin(configuration);
		107
87	} catch (final CoreException e) {	108	} catch (final CoreException e) {
88	monitor.setCanceled(true);	109	monitor.setCanceled(true);
89	LauncherUtils.getDisplay().syncExec(new Runnable() {	110	LauncherUtils.getDisplay().syncExec(new Runnable() {
Lines 95-100 Link Here
95	}	116	}
96		117
97	/**	118	/**
		119	* @since 3.5
		120	*/
		121	protected void createP2Profile(ILaunchConfiguration configuration, IProgressMonitor monitor) throws CoreException {
		122	IProfileRegistry profileRegistry = (IProfileRegistry) ServiceHelper.getService(DirectorActivator.context, IProfileRegistry.class.getName());
		123	if (profileRegistry == null)
		124	throw new CoreException(new Status(IStatus.ERROR, PDEPlugin.getPluginId(), "ProfileRegistry unavailable"));
		125	IProfile profile = profileRegistry.addProfile("Tempy");
		126
		127	Set models = LaunchPluginValidator.parsePlugins(configuration, IPDELauncherConstants.SELECTED_WORKSPACE_PLUGINS);
		128	List bundleDescriptions = new ArrayList(models.size());
		129	for (Iterator iterator = models.iterator(); iterator.hasNext();) {
		130	IPluginModelBase currentModel = (IPluginModelBase) iterator.next();
		131	BundleDescription bd = currentModel.getBundleDescription();
		132
		133	// TODO Unclear if we can use the existing bundle description, or we need to recreate
		134	IResource res = currentModel.getUnderlyingResource();
		135	bd = BundlesAction.createBundleDescription(new File(res.getLocationURI()));
		136
		137	if (bd != null) {
		138	bundleDescriptions.add(bd);
		139	}
		140	}
		141
		142	BundlesAction bundlesAction = new BundlesAction((BundleDescription[]) bundleDescriptions.toArray(new BundleDescription[bundleDescriptions.size()]));
		143	PublisherResult results = new PublisherResult();
		144	IStatus status = bundlesAction.perform(new PublisherInfo(), results, monitor);
		145
		146	System.out.println(results.getIUs(null, null));
		147
		148	models = LaunchPluginValidator.parsePlugins(configuration, IPDELauncherConstants.SELECTED_TARGET_PLUGINS);
		149	bundleDescriptions = new ArrayList(models.size());
		150	for (Iterator iterator = models.iterator(); iterator.hasNext();) {
		151	IPluginModelBase currentModel = (IPluginModelBase) iterator.next();
		152	BundleDescription bd = currentModel.getBundleDescription();
		153
		154	// TODO Unclear if we can use the existing bundle description, or we need to recreate
		155	IResource res = currentModel.getUnderlyingResource();
		156	bd = BundlesAction.createBundleDescription(new File(res.getLocationURI()));
		157
		158	if (bd != null) {
		159	bundleDescriptions.add(bd);
		160	}
		161	}
		162
		163	bundlesAction = new BundlesAction((BundleDescription[]) bundleDescriptions.toArray(new BundleDescription[bundleDescriptions.size()]));
		164	results = new PublisherResult();
		165	status = bundlesAction.perform(new PublisherInfo(), results, monitor);
		166
		167	System.out.println(results.getIUs(null, null));
		168
		169	}
		170
		171	/**
		172	* @since 3.5
		173	*/
		174	protected void setupFrameworkAdmin(ILaunchConfiguration configuration) throws CoreException {
		175	ServiceReference serviceRef = PDEPlugin.getDefault().getBundleContext().getServiceReference(FrameworkAdmin.class.getName());
		176	PDEPlugin.getDefault().getBundleContext().getService(serviceRef);
		177
		178	final String FILTER_OBJECTCLASS = "(" + Constants.OBJECTCLASS + "=" + FrameworkAdmin.class.getName() + ")";
		179	final String filterFwName = "(" + FrameworkAdmin.SERVICE_PROP_KEY_FW_NAME + "=Equinox)";
		180	final String filterLauncherName = "(" + FrameworkAdmin.SERVICE_PROP_KEY_LAUNCHER_NAME + "=Eclipse.exe)";
		181	final String filterFwAdmin = "(&" + FILTER_OBJECTCLASS + filterFwName + filterLauncherName + ")";
		182
183	Filter filter;
184	ServiceTracker fwAdminTracker = null;
185	try {
186	filter = PDEPlugin.getDefault().getBundleContext().createFilter(filterFwAdmin);
187	fwAdminTracker = new ServiceTracker(PDEPlugin.getDefault().getBundleContext(), filter, null);
188	fwAdminTracker.open();
189	} catch (InvalidSyntaxException e) {
190	// never happens
191	e.printStackTrace();
192	}
193
194	if (fwAdminTracker != null) {
195	FrameworkAdmin fwAdmin = (FrameworkAdmin) fwAdminTracker.getService();
196
197	Manipulator tempManipulator = fwAdmin.getRunningManipulator();
198
199	Manipulator manipulator = fwAdmin.getManipulator();
200
201	LauncherData launcherData = new LauncherData(EquinoxConstants.FW_NAME, EquinoxConstants.FW_VERSION, EquinoxConstants.LAUNCHER_NAME, EquinoxConstants.LAUNCHER_VERSION);
202	launcherData.setLauncher(new File(Platform.getInstallLocation().getURL().getFile(), "eclipse.exe"));
203	launcherData.setLauncherConfigLocation(new File(getConfigDir(configuration), "eclipse.ini"));
204
205	launcherData.setJvmArgs(getVMArguments(configuration));
206	// TODO Simplify how we get the VM without breaking API, #getVMRunner() will no longer be used
207	launcherData.setJvm(VMHelper.createLauncher(configuration).getInstallLocation());
208	launcherData.setProgramArgs(getProgramArguments(configuration));
209
210	launcherData.setFwConfigLocation(getConfigDir(configuration));
211
212	// TODO What else needs to be set
213	// data.setFwJar(fwJar);
214	// data.setFwPersistentDataLocation(fwPersistentDataLocation, clean);
215	// data.setHome(home);
216
217	// TODO Need to account for the following methods
218	// VMRunnerConfiguration runnerConfig = new VMRunnerConfiguration(getMainClass(), getClasspath(configuration));
219	// runnerConfig.setEnvironment(getEnvironment(configuration));
220	// runnerConfig.setVMSpecificAttributesMap(getVMSpecificAttributesMap(configuration));
221
222	ConfigData configData = new ConfigData(EquinoxConstants.FW_NAME, EquinoxConstants.FW_VERSION, EquinoxConstants.LAUNCHER_NAME, EquinoxConstants.LAUNCHER_VERSION);
223
224	IPluginModelBase[] plugins = LaunchPluginValidator.getPluginList(configuration);
225	List launchingBundles = new ArrayList(plugins.length);
226	for (int i = 0; i < plugins.length; i++) {
227	launchingBundles.add(new BundleInfo(plugins[i].getInstallLocation()));
228	}
229	configData.setBundles((BundleInfo[]) launchingBundles.toArray(new BundleInfo[launchingBundles.size()]));
230
231	// TODO What else needs to be set
232	// configData.setBeginningFwStartLevel(startLevel);
233	// configData.setFwDependentProps(props);
234	// configData.setFwIndependentProps(props);
235	// configData.setInitialBundleStartLevel(startLevel);
236
237	manipulator.setLauncherData(launcherData);
238	manipulator.setConfigData(configData);
239
240	try {
241
242	manipulator.save(false);
243
244	fwAdmin.launch(manipulator, getWorkingDirectory(configuration));
245
246	} catch (IOException e) {
247	// TODO Translate?
248	throw new CoreException(new Status(IStatus.ERROR, PDEPlugin.getPluginId(), "Error trying to launch framework", e));
249	}
250	}
251	}
252
253	/**
98	* Returns the VM runner for the given launch mode to use when launching the	254	* Returns the VM runner for the given launch mode to use when launching the
99	* given configuration.	255	* given configuration.
100	*	256	*




/*******************************************************************************
 * Copyright (c) 2005, 2008 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.pde.internal.ui.wizards.imports;

import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
import java.util.zip.ZipFile;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.*;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.ui.dialogs.IOverwriteQuery;
import org.eclipse.ui.wizards.datatransfer.*;

/**
 * Helper class for the plugin import operation.  Contains methods to assist in the copying and extracting
 * of jar a folder files.
 */
public class PluginImportHelper {

	/**
	 * Imports the contents of a zip file or folder, extracting the necessary files and
	 * putting them in the specified destination.  
	 * @param source the file or folder to import from, should either be the root of the zip file or the File representing the folder
	 * @param dstPath
	 * @param provider
	 * @param filesToImport
	 * @param monitor
	 * @throws CoreException
	 */
	public static void importContent(Object source, IPath dstPath, IImportStructureProvider provider, List filesToImport, IProgressMonitor monitor) throws CoreException {
		IOverwriteQuery query = new IOverwriteQuery() {
			public String queryOverwrite(String file) {
				return ALL;
			}
		};
		try {
			ImportOperation op = new ImportOperation(dstPath, source, provider, query);
			op.setCreateContainerStructure(false);
			if (filesToImport != null) {
				op.setFilesToImport(filesToImport);
			}
			op.run(monitor);
		} catch (InvocationTargetException e) {
			IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
			throw new CoreException(status);
		} catch (InterruptedException e) {
			throw new OperationCanceledException(e.getMessage());
		}
	}

	/**
	 * Extracts the contents of the specified zip file to the specified destination
	 * @param file
	 * @param dstPath
	 * @param monitor
	 * @throws CoreException
	 */
	public static void extractArchive(File file, IPath dstPath, IProgressMonitor monitor) throws CoreException {
		ZipFile zipFile = null;
		try {
			zipFile = new ZipFile(file);
			ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
			importContent(provider.getRoot(), dstPath, provider, null, monitor);
		} catch (IOException e) {
			IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
			throw new CoreException(status);
		} finally {
			if (zipFile != null) {
				try {
					zipFile.close();
				} catch (IOException e) {
				}
			}
		}
	}

	/**
	 * Extracts all of the files and subfolders from a single folder within an archive file.
	 * @param file archive file to search for files
	 * @param folderPath path to the folder to extract from
	 * @param dstPath destination to import content to
	 * @param monitor progress monitor
	 * @throws CoreException if a problem occurs while extracting
	 * @since 3.4
	 */
	public static void extractFolderFromArchive(File file, IPath folderPath, IPath dstPath, IProgressMonitor monitor) throws CoreException {
		ZipFile zipFile = null;
		try {
			zipFile = new ZipFile(file);
			ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
			ArrayList collected = new ArrayList();
			collectResourcesFromFolder(provider, provider.getRoot(), folderPath, collected);
			importContent(provider.getRoot(), dstPath, provider, collected, monitor);
		} catch (IOException e) {
			IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
			throw new CoreException(status);
		} finally {
			if (zipFile != null) {
				try {
					zipFile.close();
				} catch (IOException e) {
				}
			}
		}
	}

	/**
	 * Searches the given archive file for java source folders.  Imports the files in the
	 * source folders to the specified destination unless the folder is in the list of 
	 * folders to exclude. 
	 * @param file archive file to search for source in
	 * @param excludeFolders list of IPaths describing folders to ignore while searching
	 * @param dstPath full path to destination to put the extracted source
	 * @param monitor progress monitor
	 * @throws CoreException if there is a problem extracting source from the zip
	 */
	public static void extractJavaSourceFromArchive(File file, List excludeFolders, IPath dstPath, IProgressMonitor monitor) throws CoreException {
		ZipFile zipFile = null;
		try {
			zipFile = new ZipFile(file);
			ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
			ArrayList collected = new ArrayList();
			collectJavaSourceFromRoot(provider, excludeFolders, collected);
			importContent(provider.getRoot(), dstPath, provider, collected, monitor);
		} catch (IOException e) {
			IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
			throw new CoreException(status);
		} finally {
			if (zipFile != null) {
				try {
					zipFile.close();
				} catch (IOException e) {
				}
			}
		}
	}

	/**
	 * Copies an archive file to an IFile
	 * @param file
	 * @param dstFile
	 * @throws CoreException
	 */
	public static void copyArchive(File file, IFile dstFile, IProgressMonitor monitor) throws CoreException {
		try {
			FileInputStream fstream = new FileInputStream(file);
			if (dstFile.exists())
				dstFile.setContents(fstream, true, false, monitor);
			else
				dstFile.create(fstream, true, monitor);
			fstream.close();
		} catch (IOException e) {
			IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.OK, e.getMessage(), e);
			throw new CoreException(status);
		}
	}

	public static String[] getTopLevelResources(File file) {
		ArrayList result = new ArrayList();
		ZipFile zipFile = null;
		try {
			zipFile = new ZipFile(file);
			ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
			List children = provider.getChildren(provider.getRoot());
			if (children != null && !children.isEmpty()) {
				for (int i = 0; i < children.size(); i++) {
					Object curr = children.get(i);
					if (provider.isFolder(curr)) {
						if (!isClassFolder(provider, curr))
							result.add(provider.getLabel(curr) + "/"); //$NON-NLS-1$
						else {
							if (!result.contains(".")) //$NON-NLS-1$
								result.add("."); //$NON-NLS-1$
						}
					} else {
						result.add(provider.getLabel(curr));
					}
				}
			}
		} catch (IOException e) {
		} finally {
			if (zipFile != null) {
				try {
					zipFile.close();
				} catch (IOException e) {
				}
			}
		}
		return (String[]) result.toArray(new String[result.size()]);
	}

	public static void collectRequiredBundleFiles(IImportStructureProvider provider, Object element, ArrayList collected) {
		List children = provider.getChildren(element);
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				String name = provider.getLabel(curr);
				if (provider.isFolder(curr)) {
					if (!name.equals("src") && !isClassFolder(provider, curr)) { //$NON-NLS-1$
						ArrayList list = new ArrayList();
						collectResources(provider, curr, false, list);
						collected.addAll(list);
					}
				} else if (!name.endsWith(".class")) { //$NON-NLS-1$
					// Ignore the bundle signing files
					if (!(provider.getFullPath(curr).indexOf("META-INF/") != -1 && (name.endsWith(".RSA") || name.endsWith(".DSA") || name.endsWith(".SF")))) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
						collected.add(curr);
					}
				}

			}
		}
	}

	public static void collectNonJavaFiles(IImportStructureProvider provider, Object element, ArrayList collected) {
		List children = provider.getChildren(element);
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr)) {
					// ignore source folders
					if (folderContainsFileExtension(provider, curr, ".java")) //$NON-NLS-1$
						continue;
					collected.add(curr);
				} else if (!provider.getLabel(curr).endsWith(".java")) { //$NON-NLS-1$
					collected.add(curr);
				}
			}
		}
	}

	private static void collectResources(IImportStructureProvider provider, Object element, boolean excludeMeta, ArrayList collected) {
		List children = provider.getChildren(element);
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr)) {
					if (!excludeMeta || !provider.getLabel(curr).equals("META-INF")) { //$NON-NLS-1$
						collectResources(provider, curr, excludeMeta, collected);
					}
				} else if (!provider.getLabel(curr).endsWith(".class")) { //$NON-NLS-1$
					collected.add(curr);
				}
			}
		}
	}

	/**
	 * Recursively searches through the zip files searching for files inside of
	 * the specified folder.  The files found will be added to the given list.
	 * @param provider zip provider
	 * @param element element of the zip currently being looked at
	 * @param folderPath location of the folder to get resources from
	 * @param collected list of files found
	 * @since 3.4
	 */
	private static void collectResourcesFromFolder(ZipFileStructureProvider provider, Object element, IPath folderPath, ArrayList collected) {
		List children = provider.getChildren(element);
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr)) {
					if (provider.getLabel(curr).equals(folderPath.segment(0))) {
						if (folderPath.segmentCount() > 1) {
							collectResourcesFromFolder(provider, curr, folderPath.removeFirstSegments(1), collected);
						} else {
							collectResources(provider, curr, false, collected);
						}
					}
				}
			}
		}
	}

	/**
	 * Searches through the zip file for java source folders.  Collects the files
	 * within the source folders.  If a folder is in the list of folder paths to
	 * ignore, the folder will be skipped.
	 * @param provider zip provider
	 * @param ignoreFolders list of IPaths describing folders to ignore
	 * @param collected list that source files will be added to
	 * @since 3.4
	 */
	private static void collectJavaSourceFromRoot(ZipFileStructureProvider provider, List ignoreFolders, ArrayList collected) {
		List children = provider.getChildren(provider.getRoot());
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr) && folderContainsFileExtension(provider, curr, ".java")) { //$NON-NLS-1$
					// Check if we are in an ignored folder
					List ignoreSubFolders = new ArrayList();
					boolean ignoreThisChild = false;
					for (Iterator iterator = ignoreFolders.iterator(); iterator.hasNext();) {
						IPath currentPath = (IPath) iterator.next();
						if (provider.getLabel(curr).equals(currentPath.segment(0))) {
							if (currentPath.segmentCount() > 1) {
								// There is a subfolder that should be ignored
								ignoreSubFolders.add(currentPath.removeFirstSegments(1));
							} else {
								// This folder should be ignored
								ignoreThisChild = true;
								break;
							}
						}
					}
					if (!ignoreThisChild) {
						collectJavaSource(provider, curr, ignoreSubFolders, collected);
					}
				}
			}
		}
	}

	/**
	 * Recursively searches the children of the given element inside of a zip file. 
	 * If the folder path is in the set of folders to ignore, the folder will be skipped.
	 * All files found, except for .class files, will be added. The given list will be
	 * updated with the source files.
	 * 
	 * @param provider zip provider
	 * @param element current element inside the zip
	 * @param ignoreFolders list of IPath folder paths to skip while searching
	 * @param collected list to update with new files found to import
	 * @since 3.4
	 */
	private static void collectJavaSource(ZipFileStructureProvider provider, Object element, List ignoreFolders, ArrayList collected) {
		List children = provider.getChildren(element);
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr)) {
					// Check if we are in an ignored folder
					List ignoreSubFolders = new ArrayList();
					boolean ignoreThisChild = false;
					for (Iterator iterator = ignoreFolders.iterator(); iterator.hasNext();) {
						IPath currentPath = (IPath) iterator.next();
						if (provider.getLabel(curr).equals(currentPath.segment(0))) {
							if (currentPath.segmentCount() > 1) {
								// There is a subfolder that should be ignored.  Remove segment referencing current folder.
								ignoreSubFolders.add(currentPath.removeFirstSegments(1));
							} else {
								// This folder should be ignored
								ignoreThisChild = true;
								break;
							}
						}
					}
					if (!ignoreThisChild) {
						collectJavaSource(provider, curr, ignoreSubFolders, collected);
					}
					// Add the file to the list
				} else if (!provider.getLabel(curr).endsWith(".class")) { //$NON-NLS-1$
					collected.add(curr);
				}
			}
		}
	}

	private static boolean folderContainsFileExtension(IImportStructureProvider provider, Object element, String fileExtension) {
		List children = provider.getChildren(element);
		if (children != null && !children.isEmpty()) {
			for (int i = 0; i < children.size(); i++) {
				Object curr = children.get(i);
				if (provider.isFolder(curr)) {
					if (folderContainsFileExtension(provider, curr, fileExtension)) {
						return true;
					}
				} else if (provider.getLabel(curr).endsWith(fileExtension)) {
					return true;
				}
			}
		}
		return false;
	}

	private static boolean isClassFolder(IImportStructureProvider provider, Object element) {
		return folderContainsFileExtension(provider, element, ".class"); //$NON-NLS-1$
	}

}




package org.eclipse.pde.ui.tests.imports;

import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jdt.core.*;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.PluginRegistry;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.wizards.imports.PluginImportOperation;
import org.eclipse.pde.internal.ui.wizards.imports.PluginImportWizard.ImportQuery;
import org.eclipse.pde.ui.tests.PDETestCase;

	
	protected void runOperation(IPluginModelBase[] models, int type) {
		PluginImportOperation.IImportQuery query = new ImportQuery(getShell());
		PluginImportOperation.IImportQuery executionQuery = new ImportQuery(getShell());		
		PluginImportOperation job = new PluginImportOperation(models, type, query, executionQuery, false);
		job.setRule(ResourcesPlugin.getWorkspace().getRoot());
		job.setSystem(true);
		job.schedule();
		try{
			job.join();
		} catch (InterruptedException e){
			fail("Job interupted: " + e.getMessage());
		}
		IStatus status = job.getResult();
		if (!status.isOK()){
			fail("Import Operation failed: " + status.toString());
		}
	}





	private static final int SEVERITY_IGNORE = 1;

	public static void setClasspath(IProject project, IPluginModelBase model) throws CoreException {
		IClasspathEntry[] entries = getClasspath(project, model, null, false, true);
		JavaCore.create(project).setRawClasspath(entries, null);
	}

	// TODO Javadoc
	public static IClasspathEntry[] getClasspath(IProject project, IPluginModelBase model, Map sourceLibraryMap, boolean clear, boolean overrideCompliance) throws CoreException {
		IJavaProject javaProject = JavaCore.create(project);
		ArrayList result = new ArrayList();
		IBuild build = getBuild(project);

		result.add(createEntryUsingPreviousEntry(javaProject, ee, PDECore.REQUIRED_PLUGINS_CONTAINER_PATH));

		// add own libraries/source
		addSourceAndLibraries(project, model, build, clear, sourceLibraryMap, result);

		IClasspathEntry[] entries = (IClasspathEntry[]) result.toArray(new IClasspathEntry[result.size()]);
		IJavaModelStatus validation = JavaConventions.validateClasspath(javaProject, entries, javaProject.getOutputLocation());

		return (IClasspathEntry[]) result.toArray(new IClasspathEntry[result.size()]);
	}

	private static void addSourceAndLibraries(IProject project, IPluginModelBase model, IBuild build, boolean clear, Map sourceLibraryMap, ArrayList result) throws CoreException {

		HashSet paths = new HashSet();


			if (buildEntry != null) {
				addSourceFolder(buildEntry, project, paths, result);
			} else {
				IPath sourceAttachment = sourceLibraryMap != null ? (IPath) sourceLibraryMap.get(libraries[i].getName()) : null;
				if (libraries[i].getName().equals(".")) //$NON-NLS-1$
					addJARdPlugin(project, ClasspathUtilCore.getFilename(model), sourceAttachment, attrs, result);
				else
					addLibraryEntry(project, libraries[i], sourceAttachment, attrs, result);
			}
		}
		if (libraries.length == 0) {

					addSourceFolder(buildEntry, project, paths, result);
				}
			} else if (ClasspathUtilCore.hasBundleStructure(model)) {
				IPath sourceAttachment = sourceLibraryMap != null ? (IPath) sourceLibraryMap.get(".") : null; //$NON-NLS-1$
				addJARdPlugin(project, ClasspathUtilCore.getFilename(model), sourceAttachment, attrs, result);
			}
		}
	}

		return (buildModel != null) ? buildModel.getBuild() : null;
	}

	private static void addLibraryEntry(IProject project, IPluginLibrary library, IPath sourceAttachment, IClasspathAttribute[] attrs, ArrayList result) throws JavaModelException {
		String name = ClasspathUtilCore.expandLibraryName(library.getName());
		IResource jarFile = project.findMember(name);
		if (jarFile == null)

			}
		}

		IClasspathEntry entry = createClasspathEntry(project, jarFile, name, sourceAttachment, attrs, library.isExported());
		if (!result.contains(entry))
			result.add(entry);
	}

	private static void addJARdPlugin(IProject project, String filename, IPath sourceAttachment, IClasspathAttribute[] attrs, ArrayList result) {
		String name = ClasspathUtilCore.expandLibraryName(filename);
		IResource jarFile = project.findMember(name);
		if (jarFile != null) {
			IClasspathEntry entry = createClasspathEntry(project, jarFile, filename, sourceAttachment, attrs, true);
			if (!result.contains(entry))
				result.add(entry);
		}
	}

	private static IClasspathEntry createClasspathEntry(IProject project, IResource library, String fileName, IPath sourceAttachment, IClasspathAttribute[] attrs, boolean isExported) {
		IResource resource = sourceAttachment != null ? project.findMember(sourceAttachment) : project.findMember(ClasspathUtilCore.getSourceZipName(fileName));
		// TODO This case may no longer be needed as the source can be any name, the source attachment should be specified in this case
//		if (resource == null) {
//			// If a specific library zip can't be found, look for the common source jar as is may have multiple source roots
//			resource = project.getFile(project.getName() + "src.zip"); //$NON-NLS-1$
//		}		
		return JavaCore.newLibraryEntry(library.getFullPath(), resource == null ? null : resource.getFullPath(), null, new IAccessRule[0], attrs, isExported);
				// see PluginImportOperation.linkSourceArchives
				resource = project.getFile(project.getName() + "src.zip"); //$NON-NLS-1$
		}
		IPath srcAttachment = resource != null ? resource.getFullPath() : library.getFullPath();
		return JavaCore.newLibraryEntry(library.getFullPath(), srcAttachment, null, new IAccessRule[0], attrs, isExported);
	}

	private static String getExecutionEnvironment(BundleDescription bundleDescription) {

Return to bug 245565

Lines 11-18 Link Here

(-)src/org/eclipse/pde/internal/ui/wizards/imports/PluginImportWizard.java (-17 / +5 lines)
11	package org.eclipse.pde.internal.ui.wizards.imports;	11	package org.eclipse.pde.internal.ui.wizards.imports;
12		12
13	import java.util.*;	13	import java.util.*;
14	import org.eclipse.core.runtime.*;	14	import org.eclipse.core.resources.ResourcesPlugin;
15	import org.eclipse.core.runtime.jobs.Job;	15	import org.eclipse.core.runtime.CoreException;
16	import org.eclipse.debug.core.*;	16	import org.eclipse.debug.core.*;
17	import org.eclipse.jface.dialogs.*;	17	import org.eclipse.jface.dialogs.*;
18	import org.eclipse.jface.viewers.IStructuredSelection;	18	import org.eclipse.jface.viewers.IStructuredSelection;
Lines 133-153 Link Here
133	}	133	}
134		134
135	private static void doImportOperation(final Shell shell, final int importType, final IPluginModelBase[] models, final boolean forceAutobuild, final boolean launchedConfiguration) {	135	private static void doImportOperation(final Shell shell, final int importType, final IPluginModelBase[] models, final boolean forceAutobuild, final boolean launchedConfiguration) {
136	PluginImportOperation.IImportQuery query = new ImportQuery(shell);	136	PluginImportOperation job = new PluginImportOperation(models, importType, new ImportQuery(shell), new ImportQuery(shell), forceAutobuild);
137	PluginImportOperation.IImportQuery executionQuery = new ImportQuery(shell);	137	job.setPluginsInUse(launchedConfiguration);
138	final PluginImportOperation op = new PluginImportOperation(models, importType, query, executionQuery, forceAutobuild);	138	job.setRule(ResourcesPlugin.getWorkspace().getRoot());
139	op.setLaunchedConfiguration(launchedConfiguration);
140	Job job = new Job(PDEUIMessages.ImportWizard_title) {
141	protected IStatus run(IProgressMonitor monitor) {
142	try {
143	PDEPlugin.getWorkspace().run(op, monitor);
144	} catch (CoreException e) {
145	PDEPlugin.logException(e);
146	return Status.CANCEL_STATUS;
147	}
148	return Status.OK_STATUS;
149	}
150	};
151	job.setUser(true);	139	job.setUser(true);
152	job.schedule();	140	job.schedule();
153	}	141	}

Lines 21-30 Link Here

(-)src/org/eclipse/pde/internal/ui/wizards/imports/PluginImportWizardDetailedPage.java (-15 / +66 lines)
21	import org.eclipse.jface.dialogs.IDialogSettings;	21	import org.eclipse.jface.dialogs.IDialogSettings;
22	import org.eclipse.jface.layout.GridLayoutFactory;	22	import org.eclipse.jface.layout.GridLayoutFactory;
23	import org.eclipse.jface.viewers.*;	23	import org.eclipse.jface.viewers.*;
		24	import org.eclipse.osgi.service.resolver.BundleDescription;
24	import org.eclipse.osgi.util.NLS;	25	import org.eclipse.osgi.util.NLS;
25	import org.eclipse.pde.core.plugin.IPluginModelBase;	26	import org.eclipse.pde.core.plugin.IPluginModelBase;
26	import org.eclipse.pde.internal.core.PDECore;	27	import org.eclipse.pde.internal.core.*;
27	import org.eclipse.pde.internal.core.WorkspaceModelManager;
28	import org.eclipse.pde.internal.core.plugin.AbstractPluginModelBase;	28	import org.eclipse.pde.internal.core.plugin.AbstractPluginModelBase;
29	import org.eclipse.pde.internal.core.util.PatternConstructor;	29	import org.eclipse.pde.internal.core.util.PatternConstructor;
30	import org.eclipse.pde.internal.ui.*;	30	import org.eclipse.pde.internal.ui.*;
Lines 53-59 Link Here
53	private TableViewer fAvailableListViewer;	53	private TableViewer fAvailableListViewer;
54	private Text fFilterText;	54	private Text fFilterText;
55	private VersionFilter fVersionFilter;	55	private VersionFilter fVersionFilter;
56	private AvailableFilter fFilter;	56	private AvailableFilter fAvailableFilter;
		57	private SourcePluginFilter fSourceFilter;
57	// fSelected is used to track the selection in a hash set so we can efficiently	58	// fSelected is used to track the selection in a hash set so we can efficiently
58	// filter selected items out of the available item list	59	// filter selected items out of the available item list
59	private Set fSelected;	60	private Set fSelected;
Lines 65-72 Link Here
65	private Button fRemoveAllButton;	66	private Button fRemoveAllButton;
66	private Button fAddRequiredButton;	67	private Button fAddRequiredButton;
67	private Button fFilterOldVersionButton;	68	private Button fFilterOldVersionButton;
		69	private Button fFilterSourcePluginsButton;
68		70
69	private static final String SETTINGS_SHOW_LATEST = "showLatestPluginsOnly"; //$NON-NLS-1$	71	private static final String SETTINGS_SHOW_LATEST = "showLatestPluginsOnly"; //$NON-NLS-1$
		72	private static final String SETTINGS_SHOW_SOURCE = "showSourcePlugins"; //$NON-NLS-1$
70		73
71	private class AvailableFilter extends ViewerFilter {	74	private class AvailableFilter extends ViewerFilter {
72	private Pattern fPattern;	75	private Pattern fPattern;
Lines 131-137 Link Here
131	return true;	134	return true;
132	return hVersion.equals(plugin.getBundleDescription().getVersion());	135	return hVersion.equals(plugin.getBundleDescription().getVersion());
133	}	136	}
		137	}
134		138
		139	/**
		140	* This filter is used to remove source plug-ins from view
		141	*
		142	*/
		143	private class SourcePluginFilter extends ViewerFilter {
		144	/* (non-Javadoc)
		145	* @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
		146	*/
		147	public boolean select(Viewer viewer, Object parentElement, Object element) {
		148	if (element instanceof IPluginModelBase) {
		149	PDEState state = fPage1.getState();
		150	if (state != null) {
		151	BundleDescription description = ((IPluginModelBase) element).getBundleDescription();
		152	if (description != null) {
		153	return state.getBundleSourceEntry(description.getBundleId()) == null;
		154	}
		155	}
		156	}
		157	return true;
		158	}
135	}	159	}
136		160
137	public PluginImportWizardDetailedPage(String pageName, PluginImportWizardFirstPage firstPage) {	161	public PluginImportWizardDetailedPage(String pageName, PluginImportWizardFirstPage firstPage) {
Lines 160-169 Link Here
160	Composite buttonContainer = new Composite(container, SWT.NONE);	184	Composite buttonContainer = new Composite(container, SWT.NONE);
161	buttonContainer.setLayout(GridLayoutFactory.fillDefaults().create());	185	buttonContainer.setLayout(GridLayoutFactory.fillDefaults().create());
162	createComputationsOption(buttonContainer, 3);	186	createComputationsOption(buttonContainer, 3);
163	createFilterOption(buttonContainer, 3);	187	createFilterOptions(buttonContainer, 3);
164		188
165	addViewerListeners();	189	addViewerListeners();
166	addFilter();	190	addFilters();
167		191
168	initialize();	192	initialize();
169	setControl(container);	193	setControl(container);
Lines 171-177 Link Here
171	PlatformUI.getWorkbench().getHelpSystem().setHelp(container, IHelpContextIds.PLUGIN_IMPORT_SECOND_PAGE);	195	PlatformUI.getWorkbench().getHelpSystem().setHelp(container, IHelpContextIds.PLUGIN_IMPORT_SECOND_PAGE);
172	}	196	}
173		197
174	private void createFilterOption(Composite container, int span) {	198	private void createFilterOptions(Composite container, int span) {
175	Composite parent = new Composite(container, SWT.NONE);	199	Composite parent = new Composite(container, SWT.NONE);
176	parent.setLayout(GridLayoutFactory.swtDefaults().margins(5, 0).create());	200	parent.setLayout(GridLayoutFactory.swtDefaults().margins(5, 0).create());
177	fFilterOldVersionButton = new Button(parent, SWT.CHECK);	201	fFilterOldVersionButton = new Button(parent, SWT.CHECK);
Lines 188-211 Link Here
188		212
189	fFilterOldVersionButton.addSelectionListener(new SelectionAdapter() {	213	fFilterOldVersionButton.addSelectionListener(new SelectionAdapter() {
190	public void widgetSelected(SelectionEvent e) {	214	public void widgetSelected(SelectionEvent e) {
191	fAvailableListViewer.removeFilter(fVersionFilter);
192	if (fFilterOldVersionButton.getSelection()) {	215	if (fFilterOldVersionButton.getSelection()) {
193	fAvailableListViewer.addFilter(fVersionFilter);	216	fAvailableListViewer.addFilter(fVersionFilter);
		217	} else {
		218	fAvailableListViewer.removeFilter(fVersionFilter);
194	}	219	}
195	fAvailableListViewer.getTable().setRedraw(false);
196	fAvailableListViewer.refresh();
197	fAvailableListViewer.getTable().setRedraw(true);
198	}	220	}
		221	});
199		222
		223	fFilterSourcePluginsButton = new Button(parent, SWT.CHECK);
		224	// TODO NLS this string, not done so related patches won't conflict
		225	fFilterSourcePluginsButton.setText("Show source plug-ins");
		226	gData = new GridData(GridData.FILL_HORIZONTAL);
		227	gData.horizontalSpan = span;
		228	fFilterSourcePluginsButton.setLayoutData(gData);
		229
		230	if (getDialogSettings().get(SETTINGS_SHOW_SOURCE) != null) {
		231	fFilterSourcePluginsButton.setSelection(getDialogSettings().getBoolean(SETTINGS_SHOW_SOURCE));
		232	} else {
		233	fFilterSourcePluginsButton.setSelection(false);
		234	}
		235
		236	fFilterSourcePluginsButton.addSelectionListener(new SelectionAdapter() {
		237	public void widgetSelected(SelectionEvent e) {
		238	if (fFilterSourcePluginsButton.getSelection()) {
		239	fAvailableListViewer.removeFilter(fSourceFilter);
		240	} else {
		241	fAvailableListViewer.addFilter(fSourceFilter);
		242	}
		243	}
200	});	244	});
201	}	245	}
202		246
203	private void addFilter() {	247	private void addFilters() {
204	fVersionFilter = new VersionFilter();	248	fVersionFilter = new VersionFilter();
205	fVersionFilter.setModel(fModels);	249	fVersionFilter.setModel(fModels);
206	fFilter = new AvailableFilter();	250	fAvailableFilter = new AvailableFilter();
207	fAvailableListViewer.addFilter(fFilter);	251	fSourceFilter = new SourcePluginFilter();
		252	fAvailableListViewer.addFilter(fAvailableFilter);
208	fAvailableListViewer.addFilter(fVersionFilter);	253	fAvailableListViewer.addFilter(fVersionFilter);
		254	if (!fFilterSourcePluginsButton.getSelection()) {
		255	fAvailableListViewer.addFilter(fSourceFilter);
		256	}
		257
209	fFilterJob = new WorkbenchJob("FilterJob") { //$NON-NLS-1$	258	fFilterJob = new WorkbenchJob("FilterJob") { //$NON-NLS-1$
210	public IStatus runInUIThread(IProgressMonitor monitor) {	259	public IStatus runInUIThread(IProgressMonitor monitor) {
211	handleFilter();	260	handleFilter();
Lines 416-422 Link Here
416	protected void refreshPage() {	465	protected void refreshPage() {
417	fImportListViewer.getTable().removeAll();	466	fImportListViewer.getTable().removeAll();
418	fSelected.clear();	467	fSelected.clear();
419	fFilter.setPattern("*"); //$NON-NLS-1$	468	fAvailableFilter.setPattern("*"); //$NON-NLS-1$
420	fVersionFilter.setModel(fModels);	469	fVersionFilter.setModel(fModels);
421	fAvailableListViewer.refresh();	470	fAvailableListViewer.refresh();
422	pageChanged();	471	pageChanged();
Lines 487-494 Link Here
487	String newFilter;	536	String newFilter;
488	if (fFilterText == null \|\| (newFilter = fFilterText.getText().trim()).length() == 0)	537	if (fFilterText == null \|\| (newFilter = fFilterText.getText().trim()).length() == 0)
489	newFilter = "*"; //$NON-NLS-1$	538	newFilter = "*"; //$NON-NLS-1$
490	changed = fFilter.setPattern(newFilter);	539	changed = fAvailableFilter.setPattern(newFilter);
491	if (changed) {	540	if (changed) {
		541	// TODO Test whether we need to redraw/refresh
492	fAvailableListViewer.getTable().setRedraw(false);	542	fAvailableListViewer.getTable().setRedraw(false);
493	fAvailableListViewer.refresh();	543	fAvailableListViewer.refresh();
494	fAvailableListViewer.getTable().setRedraw(true);	544	fAvailableListViewer.getTable().setRedraw(true);
Lines 632-637 Link Here
632	public void storeSettings() {	682	public void storeSettings() {
633	IDialogSettings settings = getDialogSettings();	683	IDialogSettings settings = getDialogSettings();
634	settings.put(SETTINGS_SHOW_LATEST, fFilterOldVersionButton.getSelection());	684	settings.put(SETTINGS_SHOW_LATEST, fFilterOldVersionButton.getSelection());
		685	settings.put(SETTINGS_SHOW_SOURCE, fFilterSourcePluginsButton.getSelection());
635	super.storeSettings();	686	super.storeSettings();
636	}	687	}
637		688

Removed Link Here

(-)src/org/eclipse/pde/internal/ui/wizards/imports/JarImportOperation.java (-479 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005, 2007 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	package org.eclipse.pde.internal.ui.wizards.imports;
12
13	import java.io.*;
14	import java.lang.reflect.InvocationTargetException;
15	import java.util.*;
16	import java.util.zip.ZipFile;
17	import org.eclipse.core.resources.*;
18	import org.eclipse.core.runtime.*;
19	import org.eclipse.pde.internal.core.util.CoreUtility;
20	import org.eclipse.pde.internal.ui.PDEPlugin;
21	import org.eclipse.ui.dialogs.IOverwriteQuery;
22	import org.eclipse.ui.wizards.datatransfer.*;
23
24	public abstract class JarImportOperation implements IWorkspaceRunnable {
25
26	protected void extractZipFile(File file, IPath destPath, IProgressMonitor monitor) throws CoreException {
27	ZipFile zipFile = null;
28	try {
29	zipFile = new ZipFile(file);
30	ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
31	importContent(provider.getRoot(), destPath, provider, null, monitor);
32	} catch (IOException e) {
33	IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
34	throw new CoreException(status);
35	} finally {
36	if (zipFile != null) {
37	try {
38	zipFile.close();
39	} catch (IOException e) {
40	}
41	}
42	}
43	}
44
45	protected void importContent(Object source, IPath destPath, IImportStructureProvider provider, List filesToImport, IProgressMonitor monitor) throws CoreException {
46	IOverwriteQuery query = new IOverwriteQuery() {
47	public String queryOverwrite(String file) {
48	return ALL;
49	}
50	};
51	try {
52	ImportOperation op = new ImportOperation(destPath, source, provider, query);
53	op.setCreateContainerStructure(false);
54	if (filesToImport != null) {
55	op.setFilesToImport(filesToImport);
56	}
57	op.run(monitor);
58	} catch (InvocationTargetException e) {
59	IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
60	throw new CoreException(status);
61	} catch (InterruptedException e) {
62	throw new OperationCanceledException(e.getMessage());
63	}
64	}
65
66	protected void extractResources(File file, IResource dest, IProgressMonitor monitor) throws CoreException {
67	ZipFile zipFile = null;
68	try {
69	zipFile = new ZipFile(file);
70	ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
71	ArrayList collected = new ArrayList();
72	collectResources(provider, provider.getRoot(), true, collected);
73	importContent(provider.getRoot(), dest.getFullPath(), provider, collected, monitor);
74	} catch (IOException e) {
75	IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
76	throw new CoreException(status);
77	} finally {
78	if (zipFile != null) {
79	try {
80	zipFile.close();
81	} catch (IOException e) {
82	}
83	}
84	}
85	}
86
87	/**
88	* Extracts all of the files and subfolders from a single folder within an archive file.
89	* @param file archive file to search for files
90	* @param folderPath path to the folder to extract from
91	* @param dest destination to import content to
92	* @param monitor progress monitor
93	* @throws CoreException if a problem occurs while extracting
94	* @since 3.4
95	*/
96	protected void extractResourcesFromFolder(File file, IPath folderPath, IResource dest, IProgressMonitor monitor) throws CoreException {
97	ZipFile zipFile = null;
98	try {
99	zipFile = new ZipFile(file);
100	ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
101	ArrayList collected = new ArrayList();
102	collectResourcesFromFolder(provider, provider.getRoot(), folderPath, collected);
103	importContent(provider.getRoot(), dest.getFullPath(), provider, collected, monitor);
104	} catch (IOException e) {
105	IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
106	throw new CoreException(status);
107	} finally {
108	if (zipFile != null) {
109	try {
110	zipFile.close();
111	} catch (IOException e) {
112	}
113	}
114	}
115	}
116
117	/**
118	* Searches the given archive file for java source folders. Imports the files in the
119	* source folders to the specified destination unless the folder is in the list of
120	* folders to exclude.
121	* @param file archive file to search for source in
122	* @param excludeFolders list of IPaths describing folders to ignore while searching
123	* @param dest destination to put the extracted source
124	* @param monitor progress monitor
125	* @throws CoreException if there is a problem extracting source from the zip
126	* @since 3.4
127	*/
128	protected void extractJavaSource(File file, List excludeFolders, IResource dest, IProgressMonitor monitor) throws CoreException {
129	ZipFile zipFile = null;
130	try {
131	zipFile = new ZipFile(file);
132	ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
133	ArrayList collected = new ArrayList();
134	collectJavaSourceFromRoot(provider, excludeFolders, collected);
135	importContent(provider.getRoot(), dest.getFullPath(), provider, collected, monitor);
136	} catch (IOException e) {
137	IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
138	throw new CoreException(status);
139	} finally {
140	if (zipFile != null) {
141	try {
142	zipFile.close();
143	} catch (IOException e) {
144	}
145	}
146	}
147	}
148
149	protected void extractJavaResources(File file, IResource dest, IProgressMonitor monitor) throws CoreException {
150	ZipFile zipFile = null;
151	try {
152	zipFile = new ZipFile(file);
153	ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
154	ArrayList collected = new ArrayList();
155	collectJavaResources(provider, provider.getRoot(), collected);
156	importContent(provider.getRoot(), dest.getFullPath(), provider, collected, monitor);
157	} catch (IOException e) {
158	IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
159	throw new CoreException(status);
160	} finally {
161	if (zipFile != null) {
162	try {
163	zipFile.close();
164	} catch (IOException e) {
165	}
166	}
167	}
168	}
169
170	protected void importArchive(IProject project, File archive, IPath destPath) throws CoreException {
171	try {
172	if (destPath.segmentCount() > 2)
173	CoreUtility.createFolder(project.getFolder(destPath.removeLastSegments(1)));
174	IFile file = project.getFile(destPath);
175	FileInputStream fstream = new FileInputStream(archive);
176	if (file.exists())
177	file.setContents(fstream, true, false, null);
178	else
179	file.create(fstream, true, null);
180	fstream.close();
181	} catch (IOException e) {
182	IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.OK, e.getMessage(), e);
183	throw new CoreException(status);
184	}
185	}
186
187	private void collectResources(ZipFileStructureProvider provider, Object element, boolean excludeMeta, ArrayList collected) {
188	List children = provider.getChildren(element);
189	if (children != null && !children.isEmpty()) {
190	for (int i = 0; i < children.size(); i++) {
191	Object curr = children.get(i);
192	if (provider.isFolder(curr)) {
193	if (!excludeMeta \|\| !provider.getLabel(curr).equals("META-INF")) { //$NON-NLS-1$
194	collectResources(provider, curr, excludeMeta, collected);
195	}
196	} else if (!provider.getLabel(curr).endsWith(".class")) { //$NON-NLS-1$
197	collected.add(curr);
198	}
199	}
200	}
201	}
202
203	/**
204	* Recursively searches through the zip files searching for files inside of
205	* the specified folder. The files found will be added to the given list.
206	* @param provider zip provider
207	* @param element element of the zip currently being looked at
208	* @param folderPath location of the folder to get resources from
209	* @param collected list of files found
210	* @since 3.4
211	*/
212	protected void collectResourcesFromFolder(ZipFileStructureProvider provider, Object element, IPath folderPath, ArrayList collected) {
213	List children = provider.getChildren(element);
214	if (children != null && !children.isEmpty()) {
215	for (int i = 0; i < children.size(); i++) {
216	Object curr = children.get(i);
217	if (provider.isFolder(curr)) {
218	if (provider.getLabel(curr).equals(folderPath.segment(0))) {
219	if (folderPath.segmentCount() > 1) {
220	collectResourcesFromFolder(provider, curr, folderPath.removeFirstSegments(1), collected);
221	} else {
222	collectResources(provider, curr, false, collected);
223	}
224	}
225	}
226	}
227	}
228	}
229
230	/**
231	* Searches through the zip file for java source folders. Collects the files
232	* within the source folders. If a folder is in the list of folder paths to
233	* ignore, the folder will be skipped.
234	* @param provider zip provider
235	* @param ignoreFolders list of IPaths describing folders to ignore
236	* @param collected list that source files will be added to
237	* @since 3.4
238	*/
239	protected void collectJavaSourceFromRoot(ZipFileStructureProvider provider, List ignoreFolders, ArrayList collected) {
240	List children = provider.getChildren(provider.getRoot());
241	if (children != null && !children.isEmpty()) {
242	for (int i = 0; i < children.size(); i++) {
243	Object curr = children.get(i);
244	if (provider.isFolder(curr) && folderContainsFileExtension(provider, curr, ".java")) { //$NON-NLS-1$
245	// Check if we are in an ignored folder
246	List ignoreSubFolders = new ArrayList();
247	boolean ignoreThisChild = false;
248	for (Iterator iterator = ignoreFolders.iterator(); iterator.hasNext();) {
249	IPath currentPath = (IPath) iterator.next();
250	if (provider.getLabel(curr).equals(currentPath.segment(0))) {
251	if (currentPath.segmentCount() > 1) {
252	// There is a subfolder that should be ignored
253	ignoreSubFolders.add(currentPath.removeFirstSegments(1));
254	} else {
255	// This folder should be ignored
256	ignoreThisChild = true;
257	break;
258	}
259	}
260	}
261	if (!ignoreThisChild) {
262	collectJavaSource(provider, curr, ignoreSubFolders, collected);
263	}
264	}
265	}
266	}
267	}
268
269	/**
270	* Recursively searches the children of the given element inside of a zip file.
271	* If the folder path is in the set of folders to ignore, the folder will be skipped.
272	* All files found, except for .class files, will be added. The given list will be
273	* updated with the source files.
274	*
275	* @param provider zip provider
276	* @param element current element inside the zip
277	* @param ignoreFolders list of IPath folder paths to skip while searching
278	* @param collected list to update with new files found to import
279	* @since 3.4
280	*/
281	protected void collectJavaSource(ZipFileStructureProvider provider, Object element, List ignoreFolders, ArrayList collected) {
282	List children = provider.getChildren(element);
283	if (children != null && !children.isEmpty()) {
284	for (int i = 0; i < children.size(); i++) {
285	Object curr = children.get(i);
286	if (provider.isFolder(curr)) {
287	// Check if we are in an ignored folder
288	List ignoreSubFolders = new ArrayList();
289	boolean ignoreThisChild = false;
290	for (Iterator iterator = ignoreFolders.iterator(); iterator.hasNext();) {
291	IPath currentPath = (IPath) iterator.next();
292	if (provider.getLabel(curr).equals(currentPath.segment(0))) {
293	if (currentPath.segmentCount() > 1) {
294	// There is a subfolder that should be ignored. Remove segment referencing current folder.
295	ignoreSubFolders.add(currentPath.removeFirstSegments(1));
296	} else {
297	// This folder should be ignored
298	ignoreThisChild = true;
299	break;
300	}
301	}
302	}
303	if (!ignoreThisChild) {
304	collectJavaSource(provider, curr, ignoreSubFolders, collected);
305	}
306	// Add the file to the list
307	} else if (!provider.getLabel(curr).endsWith(".class")) { //$NON-NLS-1$
308	collected.add(curr);
309	}
310	}
311	}
312	}
313
314	protected void collectNonJavaResources(ZipFileStructureProvider provider, Object element, ArrayList collected) {
315	List children = provider.getChildren(element);
316	if (children != null && !children.isEmpty()) {
317	for (int i = 0; i < children.size(); i++) {
318	Object curr = children.get(i);
319	if (provider.isFolder(curr)) {
320	if (!provider.getLabel(curr).equals("src") && !isClassFolder(provider, curr)) { //$NON-NLS-1$
321	ArrayList list = new ArrayList();
322	collectResources(provider, curr, false, list);
323	collected.addAll(list);
324	}
325	} else if (!provider.getLabel(curr).endsWith(".class")) { //$NON-NLS-1$
326	collected.add(curr);
327	}
328	}
329	}
330	}
331
332	protected void collectAdditionalResources(ZipFileStructureProvider provider, Object element, ArrayList collected) {
333	List children = provider.getChildren(element);
334	if (children != null && !children.isEmpty()) {
335	for (int i = 0; i < children.size(); i++) {
336	Object curr = children.get(i);
337	if (provider.isFolder(curr)) {
338	// ignore source folders
339	if (folderContainsFileExtension(provider, curr, ".java")) //$NON-NLS-1$
340	continue;
341	collected.add(curr);
342	} else if (!provider.getLabel(curr).endsWith(".java")) { //$NON-NLS-1$
343	collected.add(curr);
344	}
345	}
346	}
347	}
348
349	protected void collectJavaFiles(ZipFileStructureProvider provider, Object element, ArrayList collected) {
350	List children = provider.getChildren(element);
351	if (children != null && !children.isEmpty()) {
352	for (int i = 0; i < children.size(); i++) {
353	Object curr = children.get(i);
354	if (provider.isFolder(curr)) {
355	if (provider.getLabel(curr).equals("src")) { //$NON-NLS-1$
356	ArrayList list = new ArrayList();
357	collectResources(provider, curr, false, list);
358	collected.addAll(list);
359	}
360	}
361	}
362	}
363	}
364
365	protected void collectJavaResources(ZipFileStructureProvider provider, Object element, ArrayList collected) {
366	List children = provider.getChildren(element);
367	if (children != null && !children.isEmpty()) {
368	for (int i = 0; i < children.size(); i++) {
369	Object curr = children.get(i);
370	if (provider.isFolder(curr)) {
371	if (isClassFolder(provider, curr)) {
372	ArrayList list = new ArrayList();
373	collectResources(provider, curr, false, list);
374	collected.addAll(list);
375	}
376	}
377	}
378	}
379	}
380
381	private boolean folderContainsFileExtension(ZipFileStructureProvider provider, Object element, String fileExtension) {
382	List children = provider.getChildren(element);
383	if (children != null && !children.isEmpty()) {
384	for (int i = 0; i < children.size(); i++) {
385	Object curr = children.get(i);
386	if (provider.isFolder(curr)) {
387	if (folderContainsFileExtension(provider, curr, fileExtension)) {
388	return true;
389	}
390	} else if (provider.getLabel(curr).endsWith(fileExtension)) { //$NON-NLS-1$
391	return true;
392	}
393	}
394	}
395	return false;
396	}
397
398	private boolean isClassFolder(ZipFileStructureProvider provider, Object element) {
399	return folderContainsFileExtension(provider, element, ".class"); //$NON-NLS-1$
400	}
401
402	protected boolean hasEmbeddedSource(ZipFileStructureProvider provider) {
403	List children = provider.getChildren(provider.getRoot());
404	if (children != null && !children.isEmpty()) {
405	for (int i = 0; i < children.size(); i++) {
406	Object curr = children.get(i);
407	if (provider.isFolder(curr) && provider.getLabel(curr).equals("src")) { //$NON-NLS-1$
408	return true;
409	}
410	}
411	}
412	return false;
413	}
414
415	protected boolean containsCode(ZipFileStructureProvider provider) {
416	List children = provider.getChildren(provider.getRoot());
417	if (children != null && !children.isEmpty()) {
418	for (int i = 0; i < children.size(); i++) {
419	Object curr = children.get(i);
420	if (provider.isFolder(curr) && isClassFolder(provider, curr)) {
421	return true;
422	}
423	}
424	}
425	return false;
426	}
427
428	protected boolean containsCode(File file) {
429	ZipFile zipFile = null;
430	try {
431	zipFile = new ZipFile(file);
432	return containsCode(new ZipFileStructureProvider(zipFile));
433	} catch (IOException e) {
434	} finally {
435	if (zipFile != null) {
436	try {
437	zipFile.close();
438	} catch (IOException e) {
439	}
440	}
441	}
442	return true;
443	}
444
445	protected String[] getTopLevelResources(File file) {
446	ArrayList result = new ArrayList();
447	ZipFile zipFile = null;
448	try {
449	zipFile = new ZipFile(file);
450	ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
451	List children = provider.getChildren(provider.getRoot());
452	if (children != null && !children.isEmpty()) {
453	for (int i = 0; i < children.size(); i++) {
454	Object curr = children.get(i);
455	if (provider.isFolder(curr)) {
456	if (!isClassFolder(provider, curr))
457	result.add(provider.getLabel(curr) + "/"); //$NON-NLS-1$
458	else {
459	if (!result.contains(".")) //$NON-NLS-1$
460	result.add("."); //$NON-NLS-1$
461	}
462	} else {
463	result.add(provider.getLabel(curr));
464	}
465	}
466	}
467	} catch (IOException e) {
468	} finally {
469	if (zipFile != null) {
470	try {
471	zipFile.close();
472	} catch (IOException e) {
473	}
474	}
475	}
476	return (String[]) result.toArray(new String[result.size()]);
477	}
478
479	}

Lines 1073-1082 Link Here

(-)src/org/eclipse/pde/internal/ui/pderesources.properties (-6 / +4 lines)
1073	PluginSelectionDialog_title = Plug-in Selection	1073	PluginSelectionDialog_title = Plug-in Selection
1074	PluginStructureCreator_name=Plug-in Structure Compare	1074	PluginStructureCreator_name=Plug-in Structure Compare
1075	PluginSelectionDialog_message = &Select a Plug-in:	1075	PluginSelectionDialog_message = &Select a Plug-in:
1076	PluginImportInfoDialog_message=Could not fully delete existing plug-ins with the same name.\nImporting the following plug-ins failed:	1076	PluginImportOperation_could_not_delete_project=Import operation could not delete the following project: {0}
1077	PluginImportInfoDialog_title=Deleting Plug-ins Failed
1078	PluginImportOperation_linking=Linking content...	1077	PluginImportOperation_linking=Linking content...
1079	PluginImportOperation_executionEnvironment=Plug-in ''{0}'' requires an ''{1}'' execution environment that is not supported by any of the installed JREs. Import anyway?	1078	PluginImportOperation_executionEnvironment=Plug-in ''{0}'' requires an ''{1}'' execution environment that is not supported by any of the installed JREs. Import anyway?
		1079	PluginImportOperation_Importing_plugin=Importing {0}
1080	PluginImportWizard_runningConfigDesc=An application is currently running. Some of the selected plug-ins may not be imported if they are locked by it. Do you want to continue?	1080	PluginImportWizard_runningConfigDesc=An application is currently running. Some of the selected plug-ins may not be imported if they are locked by it. Do you want to continue?
1081	PluginImportWizard_runningConfigsDesc=Multiple applications are currently running. Some of the selected plug-ins may not be imported if they are locked by them. Do you want to continue?	1081	PluginImportWizard_runningConfigsDesc=Multiple applications are currently running. Some of the selected plug-ins may not be imported if they are locked by them. Do you want to continue?
1082	PluginImportWizard_runningConfigsTitle=Running Applications	1082	PluginImportWizard_runningConfigsTitle=Running Applications
Lines 1141-1151 Link Here
1141	ImportWizard_DetailedPage_filterDesc=Show latest version of plug-ins only	1141	ImportWizard_DetailedPage_filterDesc=Show latest version of plug-ins only
1142	ImportWizard_DetailedPage_search = &ID (* = any string, ? = any character):	1142	ImportWizard_DetailedPage_search = &ID (* = any string, ? = any character):
1143		1143
1144	ImportWizard_operation_creating = Creating projects from plug-ins...	1144	ImportWizard_operation_creating = Creating projects from plug-ins
1145	ImportWizard_operation_multiProblem = Problems detected while importing plug-ins	1145	ImportWizard_operation_multiProblem = Problems detected while importing plug-ins
1146	ImportWizard_operation_creating2 = Creating ''{0}''...	1146	ImportWizard_operation_importingSource== Importing source...
1147	ImportWizard_operation_copyingSource = Copying source...
1148
1149	FeatureImportWizard_FirstPage_title = Import Features	1147	FeatureImportWizard_FirstPage_title = Import Features
1150	FeatureImportWizard_FirstPage_desc = Create projects from features in the file system.	1148	FeatureImportWizard_FirstPage_desc = Create projects from features in the file system.
1151	FeatureImportWizard_FirstPage_runtimeLocation = &Choose from features in the target platform	1149	FeatureImportWizard_FirstPage_runtimeLocation = &Choose from features in the target platform

Lines 1594-1602 Link Here

(-)src/org/eclipse/pde/internal/ui/PDEUIMessages.java (-5 / +4 lines)
1594		1594
1595	public static String PluginSelectionDialog_title;	1595	public static String PluginSelectionDialog_title;
1596	public static String PluginSelectionDialog_message;	1596	public static String PluginSelectionDialog_message;
1597	public static String PluginImportInfoDialog_message;	1597	public static String PluginImportOperation_could_not_delete_project;
1598
1599	public static String PluginImportInfoDialog_title;
1600		1598
1601	public static String PluginImportOperation_linking;	1599	public static String PluginImportOperation_linking;
1602	public static String PluginContentPage_appQuestion;	1600	public static String PluginContentPage_appQuestion;
Lines 1660-1667 Link Here
1660		1658
1661	public static String ImportWizard_operation_creating;	1659	public static String ImportWizard_operation_creating;
1662	public static String ImportWizard_operation_multiProblem;	1660	public static String ImportWizard_operation_multiProblem;
1663	public static String ImportWizard_operation_creating2;	1661	public static String ImportWizard_operation_importingSource;
1664	public static String ImportWizard_operation_copyingSource;
1665		1662
1666	public static String FeatureImportWizard_FirstPage_title;	1663	public static String FeatureImportWizard_FirstPage_title;
1667	public static String FeatureImportWizard_FirstPage_desc;	1664	public static String FeatureImportWizard_FirstPage_desc;
Lines 2556-2561 Link Here
2556		2553
2557	public static String PluginImportOperation_executionEnvironment;	2554	public static String PluginImportOperation_executionEnvironment;
2558		2555
		2556	public static String PluginImportOperation_Importing_plugin;
		2557
2559	public static String PluginImportWizard_runningConfigDesc;	2558	public static String PluginImportWizard_runningConfigDesc;
2560		2559
2561	public static String PluginImportWizard_runningConfigsDesc;	2560	public static String PluginImportWizard_runningConfigsDesc;

Added Link Here

(-)src/org/eclipse/pde/internal/ui/wizards/imports/PluginImportHelper.java (+389 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005, 2008 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	package org.eclipse.pde.internal.ui.wizards.imports;
12
13	import java.io.*;
14	import java.lang.reflect.InvocationTargetException;
15	import java.util.*;
16	import java.util.zip.ZipFile;
17	import org.eclipse.core.resources.IFile;
18	import org.eclipse.core.runtime.*;
19	import org.eclipse.pde.internal.ui.PDEPlugin;
20	import org.eclipse.ui.dialogs.IOverwriteQuery;
21	import org.eclipse.ui.wizards.datatransfer.*;
22
23	/**
24	* Helper class for the plugin import operation. Contains methods to assist in the copying and extracting
25	* of jar a folder files.
26	*/
27	public class PluginImportHelper {
28
29	/**
30	* Imports the contents of a zip file or folder, extracting the necessary files and
31	* putting them in the specified destination.
32	* @param source the file or folder to import from, should either be the root of the zip file or the File representing the folder
33	* @param dstPath
34	* @param provider
35	* @param filesToImport
36	* @param monitor
37	* @throws CoreException
38	*/
39	public static void importContent(Object source, IPath dstPath, IImportStructureProvider provider, List filesToImport, IProgressMonitor monitor) throws CoreException {
40	IOverwriteQuery query = new IOverwriteQuery() {
41	public String queryOverwrite(String file) {
42	return ALL;
43	}
44	};
45	try {
46	ImportOperation op = new ImportOperation(dstPath, source, provider, query);
47	op.setCreateContainerStructure(false);
48	if (filesToImport != null) {
49	op.setFilesToImport(filesToImport);
50	}
51	op.run(monitor);
52	} catch (InvocationTargetException e) {
53	IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
54	throw new CoreException(status);
55	} catch (InterruptedException e) {
56	throw new OperationCanceledException(e.getMessage());
57	}
58	}
59
60	/**
61	* Extracts the contents of the specified zip file to the specified destination
62	* @param file
63	* @param dstPath
64	* @param monitor
65	* @throws CoreException
66	*/
67	public static void extractArchive(File file, IPath dstPath, IProgressMonitor monitor) throws CoreException {
68	ZipFile zipFile = null;
69	try {
70	zipFile = new ZipFile(file);
71	ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
72	importContent(provider.getRoot(), dstPath, provider, null, monitor);
73	} catch (IOException e) {
74	IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
75	throw new CoreException(status);
76	} finally {
77	if (zipFile != null) {
78	try {
79	zipFile.close();
80	} catch (IOException e) {
81	}
82	}
83	}
84	}
85
86	/**
87	* Extracts all of the files and subfolders from a single folder within an archive file.
88	* @param file archive file to search for files
89	* @param folderPath path to the folder to extract from
90	* @param dstPath destination to import content to
91	* @param monitor progress monitor
92	* @throws CoreException if a problem occurs while extracting
93	* @since 3.4
94	*/
95	public static void extractFolderFromArchive(File file, IPath folderPath, IPath dstPath, IProgressMonitor monitor) throws CoreException {
96	ZipFile zipFile = null;
97	try {
98	zipFile = new ZipFile(file);
99	ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
100	ArrayList collected = new ArrayList();
101	collectResourcesFromFolder(provider, provider.getRoot(), folderPath, collected);
102	importContent(provider.getRoot(), dstPath, provider, collected, monitor);
103	} catch (IOException e) {
104	IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
105	throw new CoreException(status);
106	} finally {
107	if (zipFile != null) {
108	try {
109	zipFile.close();
110	} catch (IOException e) {
111	}
112	}
113	}
114	}
115
116	/**
117	* Searches the given archive file for java source folders. Imports the files in the
118	* source folders to the specified destination unless the folder is in the list of
119	* folders to exclude.
120	* @param file archive file to search for source in
121	* @param excludeFolders list of IPaths describing folders to ignore while searching
122	* @param dstPath full path to destination to put the extracted source
123	* @param monitor progress monitor
124	* @throws CoreException if there is a problem extracting source from the zip
125	*/
126	public static void extractJavaSourceFromArchive(File file, List excludeFolders, IPath dstPath, IProgressMonitor monitor) throws CoreException {
127	ZipFile zipFile = null;
128	try {
129	zipFile = new ZipFile(file);
130	ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
131	ArrayList collected = new ArrayList();
132	collectJavaSourceFromRoot(provider, excludeFolders, collected);
133	importContent(provider.getRoot(), dstPath, provider, collected, monitor);
134	} catch (IOException e) {
135	IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, e.getMessage(), e);
136	throw new CoreException(status);
137	} finally {
138	if (zipFile != null) {
139	try {
140	zipFile.close();
141	} catch (IOException e) {
142	}
143	}
144	}
145	}
146
147	/**
148	* Copies an archive file to an IFile
149	* @param file
150	* @param dstFile
151	* @throws CoreException
152	*/
153	public static void copyArchive(File file, IFile dstFile, IProgressMonitor monitor) throws CoreException {
154	try {
155	FileInputStream fstream = new FileInputStream(file);
156	if (dstFile.exists())
157	dstFile.setContents(fstream, true, false, monitor);
158	else
159	dstFile.create(fstream, true, monitor);
160	fstream.close();
161	} catch (IOException e) {
162	IStatus status = new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.OK, e.getMessage(), e);
163	throw new CoreException(status);
164	}
165	}
166
167	public static String[] getTopLevelResources(File file) {
168	ArrayList result = new ArrayList();
169	ZipFile zipFile = null;
170	try {
171	zipFile = new ZipFile(file);
172	ZipFileStructureProvider provider = new ZipFileStructureProvider(zipFile);
173	List children = provider.getChildren(provider.getRoot());
174	if (children != null && !children.isEmpty()) {
175	for (int i = 0; i < children.size(); i++) {
176	Object curr = children.get(i);
177	if (provider.isFolder(curr)) {
178	if (!isClassFolder(provider, curr))
179	result.add(provider.getLabel(curr) + "/"); //$NON-NLS-1$
180	else {
181	if (!result.contains(".")) //$NON-NLS-1$
182	result.add("."); //$NON-NLS-1$
183	}
184	} else {
185	result.add(provider.getLabel(curr));
186	}
187	}
188	}
189	} catch (IOException e) {
190	} finally {
191	if (zipFile != null) {
192	try {
193	zipFile.close();
194	} catch (IOException e) {
195	}
196	}
197	}
198	return (String[]) result.toArray(new String[result.size()]);
199	}
200
201	public static void collectRequiredBundleFiles(IImportStructureProvider provider, Object element, ArrayList collected) {
202	List children = provider.getChildren(element);
203	if (children != null && !children.isEmpty()) {
204	for (int i = 0; i < children.size(); i++) {
205	Object curr = children.get(i);
206	String name = provider.getLabel(curr);
207	if (provider.isFolder(curr)) {
208	if (!name.equals("src") && !isClassFolder(provider, curr)) { //$NON-NLS-1$
209	ArrayList list = new ArrayList();
210	collectResources(provider, curr, false, list);
211	collected.addAll(list);
212	}
213	} else if (!name.endsWith(".class")) { //$NON-NLS-1$
214	// Ignore the bundle signing files
215	if (!(provider.getFullPath(curr).indexOf("META-INF/") != -1 && (name.endsWith(".RSA") \|\| name.endsWith(".DSA") \|\| name.endsWith(".SF")))) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
216	collected.add(curr);
217	}
218	}
219
220	}
221	}
222	}
223
224	public static void collectNonJavaFiles(IImportStructureProvider provider, Object element, ArrayList collected) {
225	List children = provider.getChildren(element);
226	if (children != null && !children.isEmpty()) {
227	for (int i = 0; i < children.size(); i++) {
228	Object curr = children.get(i);
229	if (provider.isFolder(curr)) {
230	// ignore source folders
231	if (folderContainsFileExtension(provider, curr, ".java")) //$NON-NLS-1$
232	continue;
233	collected.add(curr);
234	} else if (!provider.getLabel(curr).endsWith(".java")) { //$NON-NLS-1$
235	collected.add(curr);
236	}
237	}
238	}
239	}
240
241	private static void collectResources(IImportStructureProvider provider, Object element, boolean excludeMeta, ArrayList collected) {
242	List children = provider.getChildren(element);
243	if (children != null && !children.isEmpty()) {
244	for (int i = 0; i < children.size(); i++) {
245	Object curr = children.get(i);
246	if (provider.isFolder(curr)) {
247	if (!excludeMeta \|\| !provider.getLabel(curr).equals("META-INF")) { //$NON-NLS-1$
248	collectResources(provider, curr, excludeMeta, collected);
249	}
250	} else if (!provider.getLabel(curr).endsWith(".class")) { //$NON-NLS-1$
251	collected.add(curr);
252	}
253	}
254	}
255	}
256
257	/**
258	* Recursively searches through the zip files searching for files inside of
259	* the specified folder. The files found will be added to the given list.
260	* @param provider zip provider
261	* @param element element of the zip currently being looked at
262	* @param folderPath location of the folder to get resources from
263	* @param collected list of files found
264	* @since 3.4
265	*/
266	private static void collectResourcesFromFolder(ZipFileStructureProvider provider, Object element, IPath folderPath, ArrayList collected) {
267	List children = provider.getChildren(element);
268	if (children != null && !children.isEmpty()) {
269	for (int i = 0; i < children.size(); i++) {
270	Object curr = children.get(i);
271	if (provider.isFolder(curr)) {
272	if (provider.getLabel(curr).equals(folderPath.segment(0))) {
273	if (folderPath.segmentCount() > 1) {
274	collectResourcesFromFolder(provider, curr, folderPath.removeFirstSegments(1), collected);
275	} else {
276	collectResources(provider, curr, false, collected);
277	}
278	}
279	}
280	}
281	}
282	}
283
284	/**
285	* Searches through the zip file for java source folders. Collects the files
286	* within the source folders. If a folder is in the list of folder paths to
287	* ignore, the folder will be skipped.
288	* @param provider zip provider
289	* @param ignoreFolders list of IPaths describing folders to ignore
290	* @param collected list that source files will be added to
291	* @since 3.4
292	*/
293	private static void collectJavaSourceFromRoot(ZipFileStructureProvider provider, List ignoreFolders, ArrayList collected) {
294	List children = provider.getChildren(provider.getRoot());
295	if (children != null && !children.isEmpty()) {
296	for (int i = 0; i < children.size(); i++) {
297	Object curr = children.get(i);
298	if (provider.isFolder(curr) && folderContainsFileExtension(provider, curr, ".java")) { //$NON-NLS-1$
299	// Check if we are in an ignored folder
300	List ignoreSubFolders = new ArrayList();
301	boolean ignoreThisChild = false;
302	for (Iterator iterator = ignoreFolders.iterator(); iterator.hasNext();) {
303	IPath currentPath = (IPath) iterator.next();
304	if (provider.getLabel(curr).equals(currentPath.segment(0))) {
305	if (currentPath.segmentCount() > 1) {
306	// There is a subfolder that should be ignored
307	ignoreSubFolders.add(currentPath.removeFirstSegments(1));
308	} else {
309	// This folder should be ignored
310	ignoreThisChild = true;
311	break;
312	}
313	}
314	}
315	if (!ignoreThisChild) {
316	collectJavaSource(provider, curr, ignoreSubFolders, collected);
317	}
318	}
319	}
320	}
321	}
322
323	/**
324	* Recursively searches the children of the given element inside of a zip file.
325	* If the folder path is in the set of folders to ignore, the folder will be skipped.
326	* All files found, except for .class files, will be added. The given list will be
327	* updated with the source files.
328	*
329	* @param provider zip provider
330	* @param element current element inside the zip
331	* @param ignoreFolders list of IPath folder paths to skip while searching
332	* @param collected list to update with new files found to import
333	* @since 3.4
334	*/
335	private static void collectJavaSource(ZipFileStructureProvider provider, Object element, List ignoreFolders, ArrayList collected) {
336	List children = provider.getChildren(element);
337	if (children != null && !children.isEmpty()) {
338	for (int i = 0; i < children.size(); i++) {
339	Object curr = children.get(i);
340	if (provider.isFolder(curr)) {
341	// Check if we are in an ignored folder
342	List ignoreSubFolders = new ArrayList();
343	boolean ignoreThisChild = false;
344	for (Iterator iterator = ignoreFolders.iterator(); iterator.hasNext();) {
345	IPath currentPath = (IPath) iterator.next();
346	if (provider.getLabel(curr).equals(currentPath.segment(0))) {
347	if (currentPath.segmentCount() > 1) {
348	// There is a subfolder that should be ignored. Remove segment referencing current folder.
349	ignoreSubFolders.add(currentPath.removeFirstSegments(1));
350	} else {
351	// This folder should be ignored
352	ignoreThisChild = true;
353	break;
354	}
355	}
356	}
357	if (!ignoreThisChild) {
358	collectJavaSource(provider, curr, ignoreSubFolders, collected);
359	}
360	// Add the file to the list
361	} else if (!provider.getLabel(curr).endsWith(".class")) { //$NON-NLS-1$
362	collected.add(curr);
363	}
364	}
365	}
366	}
367
368	private static boolean folderContainsFileExtension(IImportStructureProvider provider, Object element, String fileExtension) {
369	List children = provider.getChildren(element);
370	if (children != null && !children.isEmpty()) {
371	for (int i = 0; i < children.size(); i++) {
372	Object curr = children.get(i);
373	if (provider.isFolder(curr)) {
374	if (folderContainsFileExtension(provider, curr, fileExtension)) {
375	return true;
376	}
377	} else if (provider.getLabel(curr).endsWith(fileExtension)) {
378	return true;
379	}
380	}
381	}
382	return false;
383	}
384
385	private static boolean isClassFolder(IImportStructureProvider provider, Object element) {
386	return folderContainsFileExtension(provider, element, ".class"); //$NON-NLS-1$
387	}
388
389	}

Lines 11-22 Link Here

(-)src/org/eclipse/pde/ui/tests/imports/BaseImportTestCase.java (-11 / +15 lines)
11	package org.eclipse.pde.ui.tests.imports;	11	package org.eclipse.pde.ui.tests.imports;
12		12
13	import org.eclipse.core.resources.*;	13	import org.eclipse.core.resources.*;
14	import org.eclipse.core.runtime.*;	14	import org.eclipse.core.runtime.CoreException;
		15	import org.eclipse.core.runtime.IStatus;
15	import org.eclipse.jdt.core.*;	16	import org.eclipse.jdt.core.*;
16	import org.eclipse.pde.core.plugin.IPluginModelBase;	17	import org.eclipse.pde.core.plugin.IPluginModelBase;
17	import org.eclipse.pde.core.plugin.PluginRegistry;	18	import org.eclipse.pde.core.plugin.PluginRegistry;
18	import org.eclipse.pde.internal.core.PDECore;	19	import org.eclipse.pde.internal.core.PDECore;
19	import org.eclipse.pde.internal.ui.PDEPlugin;
20	import org.eclipse.pde.internal.ui.wizards.imports.PluginImportOperation;	20	import org.eclipse.pde.internal.ui.wizards.imports.PluginImportOperation;
21	import org.eclipse.pde.internal.ui.wizards.imports.PluginImportWizard.ImportQuery;	21	import org.eclipse.pde.internal.ui.wizards.imports.PluginImportWizard.ImportQuery;
22	import org.eclipse.pde.ui.tests.PDETestCase;	22	import org.eclipse.pde.ui.tests.PDETestCase;
Lines 69-83 Link Here
69		69
70	protected void runOperation(IPluginModelBase[] models, int type) {	70	protected void runOperation(IPluginModelBase[] models, int type) {
71	PluginImportOperation.IImportQuery query = new ImportQuery(getShell());	71	PluginImportOperation.IImportQuery query = new ImportQuery(getShell());
72	PluginImportOperation.IImportQuery executionQuery = new ImportQuery(getShell());	72	PluginImportOperation.IImportQuery executionQuery = new ImportQuery(getShell());
73	final PluginImportOperation op = new PluginImportOperation(models, type, query, executionQuery, false);	73	PluginImportOperation job = new PluginImportOperation(models, type, query, executionQuery, false);
74		74	job.setRule(ResourcesPlugin.getWorkspace().getRoot());
75	try {	75	job.setSystem(true);
76	PDEPlugin.getWorkspace().run(op, new NullProgressMonitor());	76	job.schedule();
77	} catch (OperationCanceledException e) {	77	try{
78	fail("Import Operation failed: " + e);	78	job.join();
79	} catch (CoreException e) {	79	} catch (InterruptedException e){
80	fail("Import Operation failed: " + e);	80	fail("Job interupted: " + e.getMessage());
		81	}
		82	IStatus status = job.getResult();
		83	if (!status.isOK()){
		84	fail("Import Operation failed: " + status.toString());
81	}	85	}
82	}	86	}
83		87

Lines 35-45 Link Here

(-)src/org/eclipse/pde/internal/core/ClasspathComputer.java (-24 / +22 lines)
35	private static final int SEVERITY_IGNORE = 1;	35	private static final int SEVERITY_IGNORE = 1;
36		36
37	public static void setClasspath(IProject project, IPluginModelBase model) throws CoreException {	37	public static void setClasspath(IProject project, IPluginModelBase model) throws CoreException {
38	IClasspathEntry[] entries = getClasspath(project, model, false, true);	38	IClasspathEntry[] entries = getClasspath(project, model, null, false, true);
39	JavaCore.create(project).setRawClasspath(entries, null);	39	JavaCore.create(project).setRawClasspath(entries, null);
40	}	40	}
41		41
42	public static IClasspathEntry[] getClasspath(IProject project, IPluginModelBase model, boolean clear, boolean overrideCompliance) throws CoreException {	42	// TODO Javadoc
		43	public static IClasspathEntry[] getClasspath(IProject project, IPluginModelBase model, Map sourceLibraryMap, boolean clear, boolean overrideCompliance) throws CoreException {
43	IJavaProject javaProject = JavaCore.create(project);	44	IJavaProject javaProject = JavaCore.create(project);
44	ArrayList result = new ArrayList();	45	ArrayList result = new ArrayList();
45	IBuild build = getBuild(project);	46	IBuild build = getBuild(project);
Lines 53-59 Link Here
53	result.add(createEntryUsingPreviousEntry(javaProject, ee, PDECore.REQUIRED_PLUGINS_CONTAINER_PATH));	54	result.add(createEntryUsingPreviousEntry(javaProject, ee, PDECore.REQUIRED_PLUGINS_CONTAINER_PATH));
54		55
55	// add own libraries/source	56	// add own libraries/source
56	addSourceAndLibraries(project, model, build, clear, result);	57	addSourceAndLibraries(project, model, build, clear, sourceLibraryMap, result);
57		58
58	IClasspathEntry[] entries = (IClasspathEntry[]) result.toArray(new IClasspathEntry[result.size()]);	59	IClasspathEntry[] entries = (IClasspathEntry[]) result.toArray(new IClasspathEntry[result.size()]);
59	IJavaModelStatus validation = JavaConventions.validateClasspath(javaProject, entries, javaProject.getOutputLocation());	60	IJavaModelStatus validation = JavaConventions.validateClasspath(javaProject, entries, javaProject.getOutputLocation());
Lines 64-70 Link Here
64	return (IClasspathEntry[]) result.toArray(new IClasspathEntry[result.size()]);	65	return (IClasspathEntry[]) result.toArray(new IClasspathEntry[result.size()]);
65	}	66	}
66		67
67	public static void addSourceAndLibraries(IProject project, IPluginModelBase model, IBuild build, boolean clear, ArrayList result) throws CoreException {	68	private static void addSourceAndLibraries(IProject project, IPluginModelBase model, IBuild build, boolean clear, Map sourceLibraryMap, ArrayList result) throws CoreException {
68		69
69	HashSet paths = new HashSet();	70	HashSet paths = new HashSet();
70		71
Lines 87-96 Link Here
87	if (buildEntry != null) {	88	if (buildEntry != null) {
88	addSourceFolder(buildEntry, project, paths, result);	89	addSourceFolder(buildEntry, project, paths, result);
89	} else {	90	} else {
		91	IPath sourceAttachment = sourceLibraryMap != null ? (IPath) sourceLibraryMap.get(libraries[i].getName()) : null;
90	if (libraries[i].getName().equals(".")) //$NON-NLS-1$	92	if (libraries[i].getName().equals(".")) //$NON-NLS-1$
91	addJARdPlugin(project, ClasspathUtilCore.getFilename(model), attrs, result);	93	addJARdPlugin(project, ClasspathUtilCore.getFilename(model), sourceAttachment, attrs, result);
92	else	94	else
93	addLibraryEntry(project, libraries[i], attrs, result);	95	addLibraryEntry(project, libraries[i], sourceAttachment, attrs, result);
94	}	96	}
95	}	97	}
96	if (libraries.length == 0) {	98	if (libraries.length == 0) {
Lines 100-106 Link Here
100	addSourceFolder(buildEntry, project, paths, result);	102	addSourceFolder(buildEntry, project, paths, result);
101	}	103	}
102	} else if (ClasspathUtilCore.hasBundleStructure(model)) {	104	} else if (ClasspathUtilCore.hasBundleStructure(model)) {
103	addJARdPlugin(project, ClasspathUtilCore.getFilename(model), attrs, result);	105	IPath sourceAttachment = sourceLibraryMap != null ? (IPath) sourceLibraryMap.get(".") : null; //$NON-NLS-1$
		106	addJARdPlugin(project, ClasspathUtilCore.getFilename(model), sourceAttachment, attrs, result);
104	}	107	}
105	}	108	}
106	}	109	}
Lines 147-153 Link Here
147	return (buildModel != null) ? buildModel.getBuild() : null;	150	return (buildModel != null) ? buildModel.getBuild() : null;
148	}	151	}
149		152
150	private static void addLibraryEntry(IProject project, IPluginLibrary library, IClasspathAttribute[] attrs, ArrayList result) throws JavaModelException {	153	private static void addLibraryEntry(IProject project, IPluginLibrary library, IPath sourceAttachment, IClasspathAttribute[] attrs, ArrayList result) throws JavaModelException {
151	String name = ClasspathUtilCore.expandLibraryName(library.getName());	154	String name = ClasspathUtilCore.expandLibraryName(library.getName());
152	IResource jarFile = project.findMember(name);	155	IResource jarFile = project.findMember(name);
153	if (jarFile == null)	156	if (jarFile == null)
Lines 162-195 Link Here
162	}	165	}
163	}	166	}
164		167
165	IClasspathEntry entry = createClasspathEntry(project, jarFile, name, attrs, library.isExported());	168	IClasspathEntry entry = createClasspathEntry(project, jarFile, name, sourceAttachment, attrs, library.isExported());
166	if (!result.contains(entry))	169	if (!result.contains(entry))
167	result.add(entry);	170	result.add(entry);
168	}	171	}
169		172
170	private static void addJARdPlugin(IProject project, String filename, IClasspathAttribute[] attrs, ArrayList result) {	173	private static void addJARdPlugin(IProject project, String filename, IPath sourceAttachment, IClasspathAttribute[] attrs, ArrayList result) {
171	String name = ClasspathUtilCore.expandLibraryName(filename);	174	String name = ClasspathUtilCore.expandLibraryName(filename);
172	IResource jarFile = project.findMember(name);	175	IResource jarFile = project.findMember(name);
173	if (jarFile != null) {	176	if (jarFile != null) {
174	IClasspathEntry entry = createClasspathEntry(project, jarFile, filename, attrs, true);	177	IClasspathEntry entry = createClasspathEntry(project, jarFile, filename, sourceAttachment, attrs, true);
175	if (!result.contains(entry))	178	if (!result.contains(entry))
176	result.add(entry);	179	result.add(entry);
177	}	180	}
178	}	181	}
179		182
180	private static IClasspathEntry createClasspathEntry(IProject project, IResource library, String fileName, IClasspathAttribute[] attrs, boolean isExported) {	183	private static IClasspathEntry createClasspathEntry(IProject project, IResource library, String fileName, IPath sourceAttachment, IClasspathAttribute[] attrs, boolean isExported) {
181	String sourceZipName = ClasspathUtilCore.getSourceZipName(fileName);	184	IResource resource = sourceAttachment != null ? project.findMember(sourceAttachment) : project.findMember(ClasspathUtilCore.getSourceZipName(fileName));
182	IResource resource = project.findMember(sourceZipName);	185	// TODO This case may no longer be needed as the source can be any name, the source attachment should be specified in this case
183	// if zip file does not exist, see if a directory with the source does. This in necessary how we import source for individual source bundles.	186	// if (resource == null) {
184	if (resource == null && sourceZipName.endsWith(".zip")) { //$NON-NLS-1$	187	// // If a specific library zip can't be found, look for the common source jar as is may have multiple source roots
185	resource = project.findMember(sourceZipName.substring(0, sourceZipName.length() - 4));	188	// resource = project.getFile(project.getName() + "src.zip"); //$NON-NLS-1$
186	if (resource == null)	189	// }
187	// if we can't find the the source for a library, then try to find the common source location set up to share source from one jar to all libraries.	190	return JavaCore.newLibraryEntry(library.getFullPath(), resource == null ? null : resource.getFullPath(), null, new IAccessRule[0], attrs, isExported);
188	// see PluginImportOperation.linkSourceArchives
189	resource = project.getFile(project.getName() + "src.zip"); //$NON-NLS-1$
190	}
191	IPath srcAttachment = resource != null ? resource.getFullPath() : library.getFullPath();
192	return JavaCore.newLibraryEntry(library.getFullPath(), srcAttachment, null, new IAccessRule[0], attrs, isExported);
193	}	191	}
194		192
195	private static String getExecutionEnvironment(BundleDescription bundleDescription) {	193	private static String getExecutionEnvironment(BundleDescription bundleDescription) {