Attachment #117150 for bug #245565

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

Lines 136-142 Link Here

(-)src/org/eclipse/pde/internal/ui/wizards/imports/PluginImportWizard.java (-1 / +1 lines)
136	PluginImportOperation.IImportQuery query = new ImportQuery(shell);	136	PluginImportOperation.IImportQuery query = new ImportQuery(shell);
137	PluginImportOperation.IImportQuery executionQuery = new ImportQuery(shell);	137	PluginImportOperation.IImportQuery executionQuery = new ImportQuery(shell);
138	final PluginImportOperation op = new PluginImportOperation(models, importType, query, executionQuery, forceAutobuild);	138	final PluginImportOperation op = new PluginImportOperation(models, importType, query, executionQuery, forceAutobuild);
139	op.setLaunchedConfiguration(launchedConfiguration);	139	op.setPluginsInUse(launchedConfiguration);
140	Job job = new Job(PDEUIMessages.ImportWizard_title) {	140	Job job = new Job(PDEUIMessages.ImportWizard_title) {
141	protected IStatus run(IProgressMonitor monitor) {	141	protected IStatus run(IProgressMonitor monitor) {
142	try {	142	try {




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;

	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) {
		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) {
		// TODO Determine if this is actually necessary.
		fPluginsAreInUse = pluginsInUse;
	}

	/* (non-Javadoc)

					multiStatus.merge(e.getStatus());
				}
				if (monitor.isCanceled()) {
//					TODO Set classpaths individually
					setClasspaths(new SubProgressMonitor(monitor, 1));
					throw new OperationCanceledException();
				}
			}
//			TODO Set classpaths individually?
			setClasspaths(new SubProgressMonitor(monitor, 1));
			if (!ResourcesPlugin.getWorkspace().isAutoBuilding() && fForceAutobuild)
				runBuildJob();
			// TODO Test that non-deleted plug-ins throw nice error status
			if (!multiStatus.isOK())
				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 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(NLS.bind(PDEUIMessages.ImportWizard_operation_creating2, id), 6);
			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;
				}
			}

			IProject project = findProject(id);

			// Test is the required execution environment is supported
			if (!testExecutionEnvironment(model)) {
				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$

				}
			}

			// Perform the import
			Map sourceMap = null;
			switch (fImportType) {
				case IMPORT_BINARY :
					sourceMap = importAsBinary(project, model, new SubProgressMonitor(monitor, 4));
					break;
				case IMPORT_BINARY_WITH_LINKS :
					if (id.startsWith("org.eclipse.swt") && !isJARd(model)) { //$NON-NLS-1$
						importAsBinary(project, model, monitor);
					} else {
						importAsBinaryWithLinks(project, model, new SubProgressMonitor(monitor, 4));
					}
					break;
				case IMPORT_WITH_SOURCE :
					if (isExempt(model)) {
						importAsBinary(project, model, 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));
		} 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("Creating the project", 2);
			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$
	}

	/**
	 * 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) {

	 * 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 markAsBinary whether to mark the project as a binary project
	 * @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(NLS.bind("Importing {0}", model.getPluginBase().getId()), 4);

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

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

			// Import missing libraries from fragments
			// TODO Needs testing, might be obsolete
			IFragment[] fragments = getFragmentsFor(model);
			IPluginLibrary[] libraries = model.getPluginBase().getLibraries();

			IProgressMonitor fragmentMonitor = new SubProgressMonitor(monitor, 1);
			fragmentMonitor.beginTask("", libraries.length); //$NON-NLS-1$
			for (int i = 0; i < libraries.length; i++) {
				String libraryName = ClasspathUtilCore.expandLibraryName(libraries[i].getName());
				Path libPath = new Path(libraryName);
				if (!project.exists(libPath)) {
					for (int j = 0; j < fragments.length; j++) {
						// TODO Fragments are always a specific shape?
						// Import the fragment
						File jar = new File(fragments[i].getModel().getInstallLocation(), libPath.toString());
						if (jar.exists()) {
							importArchive(project, jar, libPath);
						}
						// Import the source
						// TODO Edit copySourceArchives to handle fragments to save the code duplication, don't forget the source map			
						SourceLocationManager manager = PDECore.getDefault().getSourceLocationManager();
						String zipName = ClasspathUtilCore.getSourceZipName(libraryName);
						IPath srcPath = manager.findSourcePath(fragments[i], new Path(zipName));
						if (srcPath != null) {
							// TODO Determine the best way to make the name, can be just the source location. 
							if ("src.zip".equals(zipName) && isJARd(model)) { //$NON-NLS-1$
								// We want a more meaningful name than src.zip
								zipName = ClasspathUtilCore.getSourceZipName(new File(model.getInstallLocation()).getName());
							}
							IPath dstPath = new Path(zipName);
							sourceMap.put(libraries[i], dstPath);
							if (project.findMember(dstPath) == null) {
								importArchive(project, new File(srcPath.toOSString()), dstPath);
							}
						}
					}
				} else {
					monitor.worked(1);
				}
			}
			monitor.worked(1);

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

			// TODO Test if schema extraction is necessary
//			importAdditionalResources(project, model, new SubProgressMonitor(monitor, 1));

			return sourceMap;

		} finally {
			monitor.done();
		}
	}

	 */
	private void importAsSource(IProject project, IPluginModelBase model, SubProgressMonitor monitor) throws CoreException {
		monitor.beginTask("", 4); //$NON-NLS-1$
//		importAsBinary(project, model, false, new SubProgressMonitor(monitor, 2));
		List list = importAdditionalResources(project, model, new SubProgressMonitor(monitor, 1));
		WorkspaceBuildModel buildModel = new WorkspaceBuildModel(project.getFile("build.properties")); //$NON-NLS-1$
		if (!isJARd(model) || containsCode(new File(model.getInstallLocation()))) {

		monitor.done();
	}

	private Map copySourceArchives(IProject project, IPluginModelBase model, IProgressMonitor monitor) throws CoreException {
		String[] libraries = getLibraryNames(model, true);
		try {
			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));
								}
							}

			Map sourceMap = new HashMap(libraries.length);
			SourceLocationManager manager = PDECore.getDefault().getSourceLocationManager();
			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();
					// TODO Determine the best way to make the name, can be just the source location. 
					if ("src.zip".equals(zipName)) { //$NON-NLS-1$
						// We want a more meaningful name than src.zip
						zipName = ClasspathUtilCore.getSourceZipName(new File(model.getInstallLocation()).getName());
					}
					IPath dstPath = new Path(zipName);
					sourceMap.put(libraries[i], dstPath);
					if (project.findMember(dstPath) == null) {
						importArchive(project, new File(srcPath.toOSString()), dstPath);
					}

				}
				monitor.worked(1);
			}
			return sourceMap;
		} finally {
			monitor.done();
		}
		monitor.done();
	}

	/**
	 * Creates a path representing a zip file that is named based on the plugin install location.
	 * Used to replace src.zip with a more unique and meaningful name.
	 * @param model model that the src.zip containg source for
	 * @return a new path describing the zip file
	 */
	private IPath getDefaultSourceNameForProject(IPluginModelBase model) {
		return new Path(ClasspathUtilCore.getSourceZipName(new File(model.getInstallLocation()).getName()));
	}

	private String[] getLibraryNames(IPluginModelBase model, boolean expand) {

					if (fImportType == IMPORT_BINARY_WITH_LINKS) {
						linkSourceArchives(project, model, new SubProgressMonitor(monitor, 1));
					} else {
						copySourceArchives(project, model, new SubProgressMonitor(monitor, 1));
					}
				}
			}

		return PDEPlugin.getWorkspace().getRoot().getProject(id);
	}

	/**
	 * 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;
				}
			}
		}
		return true;
	}

	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);

		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);
//		}
//	}

//	/**
//	 * Imports the source for a library from a fragment.
//	 * @param project destination project of the import
//	 * @param fragment fragment to import the library from
//	 * @param libraryName name of the library to import, 
//	 * @param monitor progress monitor
//	 * @throws CoreException if there is a problem completing the import
//	 */
//	private void importSourceFromFragment(IProject project, IFragment fragment, String libraryName, IProgressMonitor monitor) throws CoreException {
//		try {
//			IPath jarPath = new Path(ClasspathUtilCore.expandLibraryName(libraryName));
//			String zipName = ClasspathUtilCore.getSourceZipName(jarPath.toString());
//			IPath path = new Path(zipName);
//			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);

		}
	}

	/**
	 * 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();
	}

}

Lines 1070-1077 Link Here

(-)src/org/eclipse/pde/internal/ui/pderesources.properties (-2 / +1 lines)
1070	PluginSelectionDialog_title = Plug-in Selection	1070	PluginSelectionDialog_title = Plug-in Selection
1071	PluginStructureCreator_name=Plug-in Structure Compare	1071	PluginStructureCreator_name=Plug-in Structure Compare
1072	PluginSelectionDialog_message = &Select a Plug-in:	1072	PluginSelectionDialog_message = &Select a Plug-in:
1073	PluginImportInfoDialog_message=Could not fully delete existing plug-ins with the same name.\nImporting the following plug-ins failed:	1073	PluginImportOperation_could_not_delete_project=Import operation could not delete the following project: {0}
1074	PluginImportInfoDialog_title=Deleting Plug-ins Failed
1075	PluginImportOperation_linking=Linking content...	1074	PluginImportOperation_linking=Linking content...
1076	PluginImportOperation_executionEnvironment=Plug-in ''{0}'' requires an ''{1}'' execution environment that is not supported by any of the installed JREs. Import anyway?	1075	PluginImportOperation_executionEnvironment=Plug-in ''{0}'' requires an ''{1}'' execution environment that is not supported by any of the installed JREs. Import anyway?
1077	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?	1076	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?

Lines 1594-1602 Link Here

(-)src/org/eclipse/pde/internal/ui/PDEUIMessages.java (-3 / +1 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;




	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 34-44 Link Here

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