Attachment #147804 for bug #278845

Lines 10-18 Link Here

(-)src/org/eclipse/pde/ui/tests/launcher/LaunchConfigurationHelperTestCase.java (-2 / +1 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.pde.ui.tests.launcher;	11	package org.eclipse.pde.ui.tests.launcher;
12		12
13	import org.eclipse.pde.internal.ui.launcher.LaunchConfigurationHelper;
14
15	import junit.framework.*;	13	import junit.framework.*;
		14	import org.eclipse.pde.internal.launching.launcher.LaunchConfigurationHelper;
16		15
17	/**	16	/**
18	* Tests LaunchConfigurationHelper convenience methods	17	* Tests LaunchConfigurationHelper convenience methods




 *******************************************************************************/
package org.eclipse.pde.ui.tests.target;

import org.eclipse.pde.internal.core.target.provisional.IResolvedBundle;

import org.eclipse.pde.internal.core.target.*;

import java.io.*;
import java.net.URL;
import java.util.*;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.core.runtime.*;
import org.eclipse.equinox.internal.provisional.frameworkadmin.BundleInfo;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.TargetPlatform;
import org.eclipse.pde.internal.core.*;
import org.eclipse.pde.internal.core.target.TargetDefinition;
import org.eclipse.pde.internal.core.target.TargetDefinitionPersistenceHelper;
import org.eclipse.pde.internal.core.target.provisional.*;
import org.eclipse.pde.internal.launching.launcher.LaunchArgumentsHelper;
import org.eclipse.pde.internal.ui.tests.macro.MacroPlugin;
import org.osgi.framework.ServiceReference;





/*******************************************************************************
 *  Copyright (c) 2006, 2009 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

 *******************************************************************************/
package org.eclipse.pde.ui.launcher;

import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.*;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.launching.*;
import org.eclipse.pde.internal.core.util.PDEJavaHelper;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.launcher.LaunchPluginValidator;
import org.eclipse.pde.internal.ui.launcher.VMHelper;

/**
 * Generates a source lookup path for all PDE-based launch configurations
 * <p>
 * Clients may subclass this class.
 * </p>
 * @since 3.3
 * @deprecated use {@link org.eclipse.pde.launching.PDESourcePathProvider} instead.
 * @see org.eclipse.pde.launching.PDESourcePathProvider
 */
public class PDESourcePathProvider extends org.eclipse.pde.launching.PDESourcePathProvider {

	public static final String ID = "org.eclipse.pde.ui.workbenchClasspathProvider"; //$NON-NLS-1$

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jdt.launching.StandardSourcePathProvider#computeUnresolvedClasspath(org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public IRuntimeClasspathEntry[] computeUnresolvedClasspath(ILaunchConfiguration configuration) throws CoreException {
		List sourcePath = new ArrayList();
		sourcePath.add(getJREEntry(configuration));
		IProject[] projects = getJavaProjects(configuration);
		for (int i = 0; i < projects.length; i++) {
			sourcePath.add(JavaRuntime.newProjectRuntimeClasspathEntry(JavaCore.create(projects[i])));
		}
		return (IRuntimeClasspathEntry[]) sourcePath.toArray(new IRuntimeClasspathEntry[sourcePath.size()]);
	}

	/**
	 * Returns a JRE runtime classpath entry
	 * 
	 * @param configuration
	 * 			the launch configuration
	 * @return a JRE runtime classpath entry
	 * @throws CoreException
	 * 			if the JRE associated with the launch configuration cannot be found
	 * 			or if unable to retrieve the launch configuration attributes
	 */
	private IRuntimeClasspathEntry getJREEntry(ILaunchConfiguration configuration) throws CoreException {
		IVMInstall jre = VMHelper.createLauncher(configuration);
		IPath containerPath = new Path(JavaRuntime.JRE_CONTAINER);
		containerPath = containerPath.append(jre.getVMInstallType().getId());
		containerPath = containerPath.append(jre.getName());
		return JavaRuntime.newRuntimeContainerClasspathEntry(containerPath, IRuntimeClasspathEntry.BOOTSTRAP_CLASSES);
	}

	/**
	 * Returns an array of sorted plug-in projects that represent plug-ins participating
	 * in the launch
	 * 
	 * @param configuration
	 * 			the launch configuration
	 * @return an array of ordered projects
	 * @throws CoreException
	 * 			if unable to retrieve attributes from the launch configuration or if 
	 * 			an error occurs when checking the nature of the project
	 * 			
	 */
	private IProject[] getJavaProjects(ILaunchConfiguration configuration) throws CoreException {
		IProject[] projects = LaunchPluginValidator.getAffectedProjects(configuration);
		return PDEPlugin.getWorkspace().computeProjectOrder(projects).projects;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jdt.launching.StandardSourcePathProvider#resolveClasspath(org.eclipse.jdt.launching.IRuntimeClasspathEntry[], org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public IRuntimeClasspathEntry[] resolveClasspath(IRuntimeClasspathEntry[] entries, ILaunchConfiguration configuration) throws CoreException {
		List all = new ArrayList(entries.length);
		for (int i = 0; i < entries.length; i++) {
			if (entries[i].getType() == IRuntimeClasspathEntry.PROJECT) {
				// a project resolves to itself for source lookup (rather than
				// the class file output locations)
				all.add(entries[i]);
				// also add non-JRE libraries
				IResource resource = entries[i].getResource();
				if (resource instanceof IProject) {
					addBinaryPackageFragmentRoots(JavaCore.create((IProject) resource), all);
				}
			} else {
				IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(entries[i], configuration);
				for (int j = 0; j < resolved.length; j++) {
					all.add(resolved[j]);
				}
			}
		}
		return (IRuntimeClasspathEntry[]) all.toArray(new IRuntimeClasspathEntry[all.size()]);
	}

	/**
	 * Adds runtime classpath entries for binary package fragment roots contained within
	 * the project
	 * 
	 * @param jProject
	 * 			the Java project whose roots are to be enumerated
	 * @param all
	 * 			a list of accumulated runtime classpath entries
	 * @throws CoreException
	 * 			if unable to evaluate the package fragment roots
	 */
	private void addBinaryPackageFragmentRoots(IJavaProject jProject, List all) throws CoreException {
		IPackageFragmentRoot[] roots = jProject.getPackageFragmentRoots();
		for (int j = 0; j < roots.length; j++) {
			if (roots[j].getKind() == IPackageFragmentRoot.K_BINARY && !PDEJavaHelper.isJRELibrary(roots[j])) {
				IRuntimeClasspathEntry rte = JavaRuntime.newArchiveRuntimeClasspathEntry(roots[j].getPath());
				IPath path = roots[j].getSourceAttachmentPath();
				if (path != null) {
					rte.setSourceAttachmentPath(path);
					rte.setSourceAttachmentRootPath(roots[j].getSourceAttachmentRootPath());
				}
				if (!all.contains(rte))
					all.add(rte);
			}
		}

	}
}

Lines 10-15 Link Here

(-)src/org/eclipse/pde/ui/launcher/OSGiSettingsTab.java (+2 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.pde.ui.launcher;	11	package org.eclipse.pde.ui.launcher;
12		12
		13	import org.eclipse.pde.launching.IPDELauncherConstants;
		14
13	import org.eclipse.core.runtime.CoreException;	15	import org.eclipse.core.runtime.CoreException;
14	import org.eclipse.debug.core.ILaunchConfiguration;	16	import org.eclipse.debug.core.ILaunchConfiguration;
15	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;	17	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;

Lines 13-20 Link Here

(-)src/org/eclipse/pde/ui/launcher/OSGiLauncherTabGroup.java (-3 / +3 lines)
13	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;	13	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
14	import org.eclipse.debug.ui.*;	14	import org.eclipse.debug.ui.*;
15	import org.eclipse.jdt.debug.ui.launchConfigurations.JavaArgumentsTab;	15	import org.eclipse.jdt.debug.ui.launchConfigurations.JavaArgumentsTab;
16	import org.eclipse.pde.internal.ui.PDEPlugin;	16	import org.eclipse.pde.internal.launching.PDELaunchingPlugin;
17	import org.eclipse.pde.internal.ui.launcher.OSGiFrameworkManager;	17	import org.eclipse.pde.internal.launching.launcher.OSGiFrameworkManager;
18		18
19	/**	19	/**
20	* Creates and initializes the tabs on the OSGi Framework launch configuration.	20	* Creates and initializes the tabs on the OSGi Framework launch configuration.
Lines 49-55 Link Here
49	*/	49	*/
50	public void setDefaults(ILaunchConfigurationWorkingCopy configuration) {	50	public void setDefaults(ILaunchConfigurationWorkingCopy configuration) {
51	super.setDefaults(configuration);	51	super.setDefaults(configuration);
52	OSGiFrameworkManager manager = PDEPlugin.getDefault().getOSGiFrameworkManager();	52	OSGiFrameworkManager manager = PDELaunchingPlugin.getDefault().getOSGiFrameworkManager();
53	manager.getDefaultInitializer().initialize(configuration);	53	manager.getDefaultInitializer().initialize(configuration);
54	}	54	}
55		55




 *******************************************************************************/
package org.eclipse.pde.ui.launcher;

import java.io.File;
import java.util.*;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.*;
import org.eclipse.debug.core.*;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.internal.junit.launcher.*;
import org.eclipse.jdt.launching.*;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.core.plugin.*;
import org.eclipse.pde.internal.core.*;
import org.eclipse.pde.internal.core.util.CoreUtility;
import org.eclipse.pde.internal.core.util.VersionUtil;
import org.eclipse.pde.internal.ui.*;
import org.eclipse.pde.internal.ui.launcher.*;
import org.osgi.framework.Version;

/**
 * A launch delegate for launching JUnit Plug-in tests.
 *
 * @since 3.3
 * @deprecated use {@link org.eclipse.pde.launching.JUnitLaunchConfigurationDelegate} instead.
 * @see org.eclipse.pde.launching.JUnitLaunchConfigurationDelegate
 */
public class JUnitLaunchConfigurationDelegate extends org.eclipse.pde.launching.JUnitLaunchConfigurationDelegate {

	/**
	 * To avoid duplicating variable substitution (and duplicate prompts)
	 * this variable will store the substituted workspace location.
	 */
	private String fWorkspaceLocation;

	protected File fConfigDir = null;

	// used to generate the dev classpath entries
	// key is bundle ID, value is a model
	private Map fAllBundles;

	// key is a model, value is startLevel:autoStart
	private Map fModels;

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jdt.launching.AbstractJavaLaunchConfigurationDelegate#getVMRunner(org.eclipse.debug.core.ILaunchConfiguration, java.lang.String)
	 */
	public IVMRunner getVMRunner(ILaunchConfiguration configuration, String mode) throws CoreException {
		IVMInstall launcher = VMHelper.createLauncher(configuration);
		return launcher.getVMRunner(mode);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.junit.launcher.JUnitLaunchConfigurationDelegate#verifyMainTypeName(org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public String verifyMainTypeName(ILaunchConfiguration configuration) throws CoreException {
		if (TargetPlatformHelper.getTargetVersion() >= 3.3)
			return "org.eclipse.equinox.launcher.Main"; //$NON-NLS-1$
		return "org.eclipse.core.launcher.Main"; //$NON-NLS-1$
	}

	private String getTestPluginId(ILaunchConfiguration configuration) throws CoreException {
		IJavaProject javaProject = getJavaProject(configuration);
		IPluginModelBase model = PluginRegistry.findModel(javaProject.getProject());
		if (model == null)
			abort(NLS.bind(PDEUIMessages.JUnitLaunchConfiguration_error_notaplugin, javaProject.getProject().getName()), null, IStatus.OK);
		if (model instanceof IFragmentModel)
			return ((IFragmentModel) model).getFragment().getPluginId();

		return model.getPluginBase().getId();
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jdt.internal.junit.launcher.JUnitBaseLaunchConfiguration#abort(java.lang.String, java.lang.Throwable, int)
	 */
	protected void abort(String message, Throwable exception, int code) throws CoreException {
		throw new CoreException(new Status(IStatus.ERROR, IPDEUIConstants.PLUGIN_ID, code, message, exception));
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.junit.launcher.JUnitLaunchConfigurationDelegate#collectExecutionArguments(org.eclipse.debug.core.ILaunchConfiguration, java.util.List, java.util.List)
	 */
	protected void collectExecutionArguments(ILaunchConfiguration configuration, List/*String*/vmArguments, List/*String*/programArgs) throws CoreException {
		super.collectExecutionArguments(configuration, vmArguments, programArgs);

		// Specify the JUnit Plug-in test application to launch
		programArgs.add("-application"); //$NON-NLS-1$
		String application = getApplication(configuration);

		programArgs.add(application);

		// If a product is specified, then add it to the program args
		if (configuration.getAttribute(IPDELauncherConstants.USE_PRODUCT, false)) {
			programArgs.add("-product"); //$NON-NLS-1$
			programArgs.add(configuration.getAttribute(IPDELauncherConstants.PRODUCT, "")); //$NON-NLS-1$
		} else {
			// Specify the application to test
			String defaultApplication = IPDEUIConstants.CORE_TEST_APPLICATION.equals(application) ? null : TargetPlatform.getDefaultApplication();
			String testApplication = configuration.getAttribute(IPDELauncherConstants.APP_TO_TEST, defaultApplication);
			if (testApplication != null) {
				programArgs.add("-testApplication"); //$NON-NLS-1$
				programArgs.add(testApplication);
			}
		}

		// Specify the location of the runtime workbench
		if (fWorkspaceLocation == null) {
			fWorkspaceLocation = LaunchArgumentsHelper.getWorkspaceLocation(configuration);
		}
		if (fWorkspaceLocation.length() > 0) {
			programArgs.add("-data"); //$NON-NLS-1$
			programArgs.add(fWorkspaceLocation);
		}

		// Create the platform configuration for the runtime workbench
		String productID = LaunchConfigurationHelper.getProductID(configuration);
		LaunchConfigurationHelper.createConfigIniFile(configuration, productID, fAllBundles, fModels, getConfigurationDirectory(configuration));
		String brandingId = LaunchConfigurationHelper.getContributingPlugin(productID);
		TargetPlatform.createPlatformConfiguration(getConfigurationDirectory(configuration), (IPluginModelBase[]) fAllBundles.values().toArray(new IPluginModelBase[fAllBundles.size()]), brandingId != null ? (IPluginModelBase) fAllBundles.get(brandingId) : null);
		TargetPlatformHelper.checkPluginPropertiesConsistency(fAllBundles, getConfigurationDirectory(configuration));

		programArgs.add("-configuration"); //$NON-NLS-1$
		programArgs.add("file:" + new Path(getConfigurationDirectory(configuration).getPath()).addTrailingSeparator().toString()); //$NON-NLS-1$

		// Specify the output folder names
		programArgs.add("-dev"); //$NON-NLS-1$
		programArgs.add(ClasspathHelper.getDevEntriesProperties(getConfigurationDirectory(configuration).toString() + "/dev.properties", fAllBundles)); //$NON-NLS-1$

		// necessary for PDE to know how to load plugins when target platform = host platform
		// see PluginPathFinder.getPluginPaths()
		IPluginModelBase base = findPlugin(PDECore.PLUGIN_ID);
		if (base != null && VersionUtil.compareMacroMinorMicro(base.getBundleDescription().getVersion(), new Version("3.3.1")) < 0) //$NON-NLS-1$
			programArgs.add("-pdelaunch"); //$NON-NLS-1$				

		// Create the .options file if tracing is turned on
		if (configuration.getAttribute(IPDELauncherConstants.TRACING, false) && !IPDELauncherConstants.TRACING_NONE.equals(configuration.getAttribute(IPDELauncherConstants.TRACING_CHECKED, (String) null))) {
			programArgs.add("-debug"); //$NON-NLS-1$
			String path = getConfigurationDirectory(configuration).getPath() + IPath.SEPARATOR + ".options"; //$NON-NLS-1$
			programArgs.add(LaunchArgumentsHelper.getTracingFileArgument(configuration, path));
		}

		// add the program args specified by the user
		String[] userArgs = LaunchArgumentsHelper.getUserProgramArgumentArray(configuration);
		for (int i = 0; i < userArgs.length; i++) {
			// be forgiving if people have tracing turned on and forgot
			// to remove the -debug from the program args field.
			if (userArgs[i].equals("-debug") && programArgs.contains("-debug")) //$NON-NLS-1$ //$NON-NLS-2$
				continue;
			programArgs.add(userArgs[i]);
		}

		if (!configuration.getAttribute(IPDEUIConstants.APPEND_ARGS_EXPLICITLY, false)) {
			if (!programArgs.contains("-os")) { //$NON-NLS-1$
				programArgs.add("-os"); //$NON-NLS-1$
				programArgs.add(TargetPlatform.getOS());
			}
			if (!programArgs.contains("-ws")) { //$NON-NLS-1$
				programArgs.add("-ws"); //$NON-NLS-1$
				programArgs.add(TargetPlatform.getWS());
			}
			if (!programArgs.contains("-arch")) { //$NON-NLS-1$
				programArgs.add("-arch"); //$NON-NLS-1$
				programArgs.add(TargetPlatform.getOSArch());
			}
		}

		programArgs.add("-testpluginname"); //$NON-NLS-1$
		programArgs.add(getTestPluginId(configuration));
	}

	/**
	 * Returns the application to launch plug-in tests with
	 * 
	 * @since 3.5
	 * 
	 * @param configuration
	 * @return the application
	 */
	protected String getApplication(ILaunchConfiguration configuration) {
		String application = null;

		boolean shouldRunInUIThread = true;
		try {
			shouldRunInUIThread = configuration.getAttribute(IPDELauncherConstants.RUN_IN_UI_THREAD, true);
		} catch (CoreException e) {
		}

		if (!shouldRunInUIThread) {
			return IPDEUIConstants.NON_UI_THREAD_APPLICATION;
		}

		try {
			// if application is set, it must be a headless app.
			application = configuration.getAttribute(IPDELauncherConstants.APPLICATION, (String) null);
		} catch (CoreException e) {
		}

		// if application is not set, we should launch the default UI test app
		// Check to see if we should launch the legacy UI app
		if (application == null) {
			IPluginModelBase model = (IPluginModelBase) fAllBundles.get("org.eclipse.pde.junit.runtime"); //$NON-NLS-1$
			BundleDescription desc = model != null ? model.getBundleDescription() : null;
			if (desc != null) {
				Version version = desc.getVersion();
				int major = version.getMajor();
				// launch legacy UI app only if we are launching a target that does 
				// not use the new application model and we are launching with a 
				// org.eclipse.pde.junit.runtime whose version is >= 3.3
				if (major >= 3 && version.getMinor() >= 3 && !TargetPlatformHelper.usesNewApplicationModel()) {
					application = IPDEUIConstants.LEGACY_UI_TEST_APPLICATION;
				}
			}
		}

		// launch the UI test application
		if (application == null)
			application = IPDEUIConstants.UI_TEST_APPLICATION;
		return application;
	}

	private IPluginModelBase findPlugin(String id) throws CoreException {
		IPluginModelBase model = PluginRegistry.findModel(id);
		if (model == null)
			model = PDECore.getDefault().findPluginInHost(id);
		if (model == null)
			abort(NLS.bind(PDEUIMessages.JUnitLaunchConfiguration_error_missingPlugin, id), null, IStatus.OK);
		return model;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jdt.launching.AbstractJavaLaunchConfigurationDelegate#getProgramArguments(org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public String getProgramArguments(ILaunchConfiguration configuration) throws CoreException {
		return LaunchArgumentsHelper.getUserProgramArguments(configuration);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jdt.launching.AbstractJavaLaunchConfigurationDelegate#getVMArguments(org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public String getVMArguments(ILaunchConfiguration configuration) throws CoreException {
		String vmArgs = LaunchArgumentsHelper.getUserVMArguments(configuration);

		// necessary for PDE to know how to load plugins when target platform = host platform
		IPluginModelBase base = (IPluginModelBase) fAllBundles.get(PDECore.PLUGIN_ID);
		if (base != null && VersionUtil.compareMacroMinorMicro(base.getBundleDescription().getVersion(), new Version("3.3.1")) >= 0) { //$NON-NLS-1$
			vmArgs = concatArg(vmArgs, "-Declipse.pde.launch=true"); //$NON-NLS-1$
		}
		// For p2 target, add "-Declipse.p2.data.area=@config.dir/p2" unless already specified by user
		if (fAllBundles.containsKey("org.eclipse.equinox.p2.core")) { //$NON-NLS-1$
			if (vmArgs.indexOf("-Declipse.p2.data.area=") < 0) { //$NON-NLS-1$
				vmArgs = concatArg(vmArgs, "-Declipse.p2.data.area=@config.dir" + File.separator + "p2"); //$NON-NLS-1$ //$NON-NLS-2$
			}
		}
		return vmArgs;
	}

	/**
	 * Returns the result of concatenating the given argument to the
	 * specified vmArgs.
	 * 
	 * @param vmArgs existing VM arguments
	 * @param arg argument to concatenate
	 * @return result of concatenation
	 */
	private String concatArg(String vmArgs, String arg) {
		if (vmArgs.length() > 0 && !vmArgs.endsWith(" ")) //$NON-NLS-1$
			vmArgs = vmArgs.concat(" "); //$NON-NLS-1$
		return vmArgs.concat(arg);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jdt.launching.AbstractJavaLaunchConfigurationDelegate#getEnvironment(org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public String[] getEnvironment(ILaunchConfiguration configuration) throws CoreException {
		return DebugPlugin.getDefault().getLaunchManager().getEnvironment(configuration);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jdt.launching.AbstractJavaLaunchConfigurationDelegate#getClasspath(org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public String[] getClasspath(ILaunchConfiguration configuration) throws CoreException {
		String[] classpath = LaunchArgumentsHelper.constructClasspath(configuration);
		if (classpath == null) {
			abort(PDEUIMessages.WorkbenchLauncherConfigurationDelegate_noStartup, null, IStatus.OK);
		}
		return classpath;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jdt.launching.AbstractJavaLaunchConfigurationDelegate#getWorkingDirectory(org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public File getWorkingDirectory(ILaunchConfiguration configuration) throws CoreException {
		return LaunchArgumentsHelper.getWorkingDirectory(configuration);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jdt.launching.AbstractJavaLaunchConfigurationDelegate#getVMSpecificAttributesMap(org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public Map getVMSpecificAttributesMap(ILaunchConfiguration configuration) throws CoreException {
		return LaunchArgumentsHelper.getVMSpecificAttributesMap(configuration);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jdt.launching.AbstractJavaLaunchConfigurationDelegate#setDefaultSourceLocator(org.eclipse.debug.core.ILaunch, org.eclipse.debug.core.ILaunchConfiguration)
	 */
	protected void setDefaultSourceLocator(ILaunch launch, ILaunchConfiguration configuration) throws CoreException {
		ILaunchConfigurationWorkingCopy wc = null;
		if (configuration.isWorkingCopy()) {
			wc = (ILaunchConfigurationWorkingCopy) configuration;
		} else {
			wc = configuration.getWorkingCopy();
		}
		String id = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_SOURCE_PATH_PROVIDER, (String) null);
		if (!PDESourcePathProvider.ID.equals(id)) {
			wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_SOURCE_PATH_PROVIDER, PDESourcePathProvider.ID);
			wc.doSave();
		}

		manageLaunch(launch);
	}

	/**
	 * Returns the location of the configuration area
	 * 
	 * @param configuration
	 * 				the launch configuration
	 * @return a directory where the configuration area is located
	 */
	protected File getConfigurationDirectory(ILaunchConfiguration configuration) {
		if (fConfigDir == null)
			fConfigDir = LaunchConfigurationHelper.getConfigurationArea(configuration);
		return fConfigDir;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jdt.launching.AbstractJavaLaunchConfigurationDelegate#getBuildOrder(org.eclipse.debug.core.ILaunchConfiguration, java.lang.String)
	 */
	protected IProject[] getBuildOrder(ILaunchConfiguration configuration, String mode) throws CoreException {
		return computeBuildOrder(LaunchPluginValidator.getAffectedProjects(configuration));
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jdt.launching.AbstractJavaLaunchConfigurationDelegate#getProjectsForProblemSearch(org.eclipse.debug.core.ILaunchConfiguration, java.lang.String)
	 */
	protected IProject[] getProjectsForProblemSearch(ILaunchConfiguration configuration, String mode) throws CoreException {
		return LaunchPluginValidator.getAffectedProjects(configuration);
	}

	/**
	 * Adds a listener to the launch to be notified at interesting launch lifecycle
	 * events such as when the launch terminates.
	 * 
	 * @param launch
	 * 			the launch 			
	 */
	protected void manageLaunch(ILaunch launch) {
		PDEPlugin.getDefault().getLaunchListener().manage(launch);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.junit.launcher.JUnitLaunchConfigurationDelegate#preLaunchCheck(org.eclipse.debug.core.ILaunchConfiguration, org.eclipse.debug.core.ILaunch, org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected void preLaunchCheck(ILaunchConfiguration configuration, ILaunch launch, IProgressMonitor monitor) throws CoreException {
		fWorkspaceLocation = null;
		fModels = BundleLauncherHelper.getMergedBundleMap(configuration, false);
		fAllBundles = new HashMap(fModels.size());
		Iterator iter = fModels.keySet().iterator();
		while (iter.hasNext()) {
			IPluginModelBase model = (IPluginModelBase) iter.next();
			fAllBundles.put(model.getPluginBase().getId(), model);
		}

		// implicitly add the plug-ins required for JUnit testing if necessary
		String[] requiredPlugins = getRequiredPlugins(configuration);
		for (int i = 0; i < requiredPlugins.length; i++) {
			String id = requiredPlugins[i];
			if (!fAllBundles.containsKey(id)) {
				IPluginModelBase model = findPlugin(id);
				fAllBundles.put(id, model);
				fModels.put(model, "default:default"); //$NON-NLS-1$
			}
		}

		boolean autoValidate = configuration.getAttribute(IPDELauncherConstants.AUTOMATIC_VALIDATE, false);
		monitor.beginTask("", autoValidate ? 3 : 4); //$NON-NLS-1$
		if (autoValidate)
			validatePluginDependencies(configuration, new SubProgressMonitor(monitor, 1));
		validateProjectDependencies(configuration, new SubProgressMonitor(monitor, 1));
		clear(configuration, new SubProgressMonitor(monitor, 1));
		launch.setAttribute(IPDELauncherConstants.CONFIG_LOCATION, getConfigurationDirectory(configuration).toString());
		synchronizeManifests(configuration, new SubProgressMonitor(monitor, 1));
	}

	private String[] getRequiredPlugins(ILaunchConfiguration configuration) {
		// if we are using JUnit4, we need to include the junit4 specific bundles
		ITestKind testKind = JUnitLaunchConfigurationConstants.getTestRunnerKind(configuration);
		if (TestKindRegistry.JUNIT4_TEST_KIND_ID.equals(testKind.getId()))
			return new String[] {"org.junit", "org.eclipse.jdt.junit.runtime", "org.eclipse.pde.junit.runtime", "org.junit4", "org.eclipse.jdt.junit4.runtime"}; //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
		return new String[] {"org.junit", "org.eclipse.jdt.junit.runtime", "org.eclipse.pde.junit.runtime"}; //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
	}

	/**
	 * Checks for old-style plugin.xml files that have become stale since the last launch.
	 * For any stale plugin.xml files found, the corresponding MANIFEST.MF is deleted 
	 * from the runtime configuration area so that it gets regenerated upon startup.
	 * 
	 * @param configuration
	 * 			the launch configuration
	 * @param monitor
	 * 			the progress monitor
	 */
	protected void synchronizeManifests(ILaunchConfiguration configuration, IProgressMonitor monitor) {
		LaunchConfigurationHelper.synchronizeManifests(configuration, getConfigurationDirectory(configuration));
		monitor.done();
	}

	/**
	 * Clears the workspace prior to launching if the workspace exists and the option to 
	 * clear it is turned on.  Also clears the configuration area if that option is chosen.
	 * 
	 * @param configuration
	 * 			the launch configuration
	 * @param monitor
	 * 			the progress monitor
	 * @throws CoreException
	 * 			if unable to retrieve launch attribute values
	 * @since 3.3
	 */
	protected void clear(ILaunchConfiguration configuration, IProgressMonitor monitor) throws CoreException {
		if (fWorkspaceLocation == null) {
			fWorkspaceLocation = LaunchArgumentsHelper.getWorkspaceLocation(configuration);
		}
		// Clear workspace and prompt, if necessary
		if (!LauncherUtils.clearWorkspace(configuration, fWorkspaceLocation, new SubProgressMonitor(monitor, 1))) {
			monitor.setCanceled(true);
			return;
		}

		// clear config area, if necessary
		if (configuration.getAttribute(IPDELauncherConstants.CONFIG_CLEAR_AREA, false))
			CoreUtility.deleteContent(getConfigurationDirectory(configuration));
	}

	/**
	 * Checks if the Automated Management of Dependencies option is turned on.
	 * If so, it makes aure all manifests are updated with the correct dependencies.
	 * 
	 * @param configuration
	 * 			the launch configuration
	 * @param monitor
	 * 			a progress monitor
	 */
	protected void validateProjectDependencies(ILaunchConfiguration configuration, IProgressMonitor monitor) {
		LauncherUtils.validateProjectDependencies(configuration, monitor);
	}

	/**
	 * Validates inter-bundle dependencies automatically prior to launching
	 * if that option is turned on.
	 * 
	 * @param configuration
	 * 			the launch configuration
	 * @param monitor
	 * 			a progress monitor
	 */
	protected void validatePluginDependencies(ILaunchConfiguration configuration, IProgressMonitor monitor) throws CoreException {
		EclipsePluginValidationOperation op = new EclipsePluginValidationOperation(configuration);
		LaunchPluginValidator.runValidationOperation(op, monitor);
	}
}




 *******************************************************************************/
package org.eclipse.pde.ui.launcher;

import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.PluginRegistry;
import org.eclipse.pde.internal.ui.launcher.BundleLauncherHelper;

/**
 * Initializes launch configuration attributes for newly-created OSGi Framework 
 * launch configurations

 * </p>
 * 
 * @since 3.3
 * @deprecated use {@link org.eclipse.pde.launching.OSGiLaunchConfigurationInitializer} instead.
 * @see org.eclipse.pde.launching.OSGiLaunchConfigurationInitializer
 */
public class OSGiLaunchConfigurationInitializer extends org.eclipse.pde.launching.OSGiLaunchConfigurationInitializer {

	protected static final String DEFAULT = "default"; //$NON-NLS-1$

	/**
	 * Initializes some attributes on a newly-created launch configuration
	 * 
	 * @param configuration
	 * 			the launch configuration
	 */
	public void initialize(ILaunchConfigurationWorkingCopy configuration) {
		initializeFrameworkDefaults(configuration);
		initializeBundleState(configuration);
		initializeSourcePathProvider(configuration);
	}

	/**
	 * Sets the source provider ID
	 * 
	 * @param configuration
	 * 			the launch configuration
	 */
	protected void initializeSourcePathProvider(ILaunchConfigurationWorkingCopy configuration) {
		configuration.setAttribute(IJavaLaunchConfigurationConstants.ATTR_SOURCE_PATH_PROVIDER, PDESourcePathProvider.ID);
	}

	/**
	 * Initializes the start level and auto-start attributes
	 * 
	 * @param configuration
	 * 			the launch configuration
	 */
	protected void initializeFrameworkDefaults(ILaunchConfigurationWorkingCopy configuration) {
		configuration.setAttribute(IPDELauncherConstants.DEFAULT_AUTO_START, true);
		configuration.setAttribute(IPDELauncherConstants.DEFAULT_START_LEVEL, 4);
	}

	/**
	 * Initializes the checked/unchecked state of bundles
	 * 
	 * @param configuration
	 * 			the launch configuration
	 */
	protected void initializeBundleState(ILaunchConfigurationWorkingCopy configuration) {
		StringBuffer explugins = new StringBuffer();
		StringBuffer wsplugins = new StringBuffer();
		IPluginModelBase[] models = PluginRegistry.getActiveModels();
		for (int i = 0; i < models.length; i++) {
			boolean inWorkspace = models[i].getUnderlyingResource() != null;
			appendBundle(inWorkspace ? wsplugins : explugins, models[i]);
		}
		configuration.setAttribute(IPDELauncherConstants.WORKSPACE_BUNDLES, wsplugins.toString());
		configuration.setAttribute(IPDELauncherConstants.TARGET_BUNDLES, explugins.toString());
		configuration.setAttribute(IPDELauncherConstants.AUTOMATIC_ADD, true);
	}

	private void appendBundle(StringBuffer buffer, IPluginModelBase model) {
		if (buffer.length() > 0)
			buffer.append(","); //$NON-NLS-1$
		String id = model.getPluginBase().getId();
		String value = BundleLauncherHelper.writeBundleEntry(model, getStartLevel(id), getAutoStart(id));
		buffer.append(value);
	}

	/**
	 * Returns the bundle's start level
	 * 
	 * @param bundleID
	 * 			the bundle ID
	 * @return the start level for the given bundle or the string <code>default</code>
	 */
	protected String getStartLevel(String bundleID) {
		return DEFAULT;
	}

	/**
	 * Returns whether the bundle should be started automatically
	 * @param bundleID
	 * 			the bundle ID
	 * @return <code>true</code>, <code>false</code>, or <code>default</code>
	 */
	protected String getAutoStart(String bundleID) {
		return DEFAULT;
	}

}

Lines 10-15 Link Here

(-)src/org/eclipse/pde/ui/launcher/TestTab.java (+2 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.pde.ui.launcher;	11	package org.eclipse.pde.ui.launcher;
12		12
		13	import org.eclipse.pde.launching.IPDELauncherConstants;
		14
13	import org.eclipse.core.runtime.CoreException;	15	import org.eclipse.core.runtime.CoreException;
14	import org.eclipse.debug.core.ILaunchConfiguration;	16	import org.eclipse.debug.core.ILaunchConfiguration;
15	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;	17	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;




/*******************************************************************************
 * Copyright (c) 2000, 2009 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

import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.ui.*;
import org.eclipse.jdt.debug.ui.launchConfigurations.JavaArgumentsTab;
import org.eclipse.pde.internal.launching.IPDEConstants;
import org.eclipse.pde.internal.ui.IPDEUIConstants;

/**

			// is present in the original copy.  We do this by querying the config twice, with different default values.  If the values == eachother, we 
			// we know the value is present.  Since generated configs don't contain DOCLEARLOG, we know if DOCLEARLOG is present in the original copy the 
			// perform apply so save the initialization values has already been run and this is a user modification.
			boolean firstQuery = original.getAttribute(IPDEConstants.DOCLEARLOG, false);
			boolean secondQuery = original.getAttribute(IPDEConstants.DOCLEARLOG, true);
			if (original != null && firstQuery == secondQuery)
				configuration.setAttribute(IPDEUIConstants.GENERATED_CONFIG, false);
		} catch (CoreException e) {




 *******************************************************************************/
package org.eclipse.pde.ui.launcher;

import java.io.File;
import java.util.ArrayList;
import java.util.Map;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.*;
import org.eclipse.debug.core.*;
import org.eclipse.debug.core.model.LaunchConfigurationDelegate;
import org.eclipse.jdt.core.IJavaModelMarker;
import org.eclipse.jdt.launching.*;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.pde.core.plugin.TargetPlatform;
import org.eclipse.pde.internal.core.TargetPlatformHelper;
import org.eclipse.pde.internal.core.builders.PDEMarkerFactory;
import org.eclipse.pde.internal.ui.*;
import org.eclipse.pde.internal.ui.launcher.*;

/**
 * An abstract launch delegate for PDE-based launch configurations
 * <p>
 * Clients may subclass this class.
 * </p>
 * @since 3.2
 * @deprecated use {@link org.eclipse.pde.launching.AbstractPDELaunchConfiguration}
 * @see org.eclipse.pde.launching.AbstractPDELaunchConfiguration
 */
public abstract class AbstractPDELaunchConfiguration extends org.eclipse.pde.launching.AbstractPDELaunchConfiguration {

	protected File fConfigDir = null;

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.LaunchConfigurationDelegate#isLaunchProblem(org.eclipse.core.resources.IMarker)
	 */
	protected boolean isLaunchProblem(IMarker problemMarker) throws CoreException {
		return super.isLaunchProblem(problemMarker) && (problemMarker.getType().equals(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER) || problemMarker.getType().equals(PDEMarkerFactory.MARKER_ID));
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.debug.core.model.ILaunchConfigurationDelegate#launch(org.eclipse.debug.core.ILaunchConfiguration, java.lang.String, org.eclipse.debug.core.ILaunch, org.eclipse.core.runtime.IProgressMonitor)
	 */
	public void launch(ILaunchConfiguration configuration, String mode, ILaunch launch, IProgressMonitor monitor) throws CoreException {
		try {
			fConfigDir = null;
			monitor.beginTask("", 4); //$NON-NLS-1$
			try {
				preLaunchCheck(configuration, launch, new SubProgressMonitor(monitor, 2));
			} catch (CoreException e) {
				if (e.getStatus().getSeverity() == IStatus.CANCEL) {
					monitor.setCanceled(true);
					return;
				}
				throw e;
			}
			// if restarting, remove the restart flag from the launch config
			if (configuration.getAttribute(IPDEUIConstants.RESTART, false) && configuration instanceof ILaunchConfigurationWorkingCopy) {
				((ILaunchConfigurationWorkingCopy) configuration).setAttribute(IPDEUIConstants.RESTART, false);
				((ILaunchConfigurationWorkingCopy) configuration).doSave();
			}
			VMRunnerConfiguration runnerConfig = new VMRunnerConfiguration(getMainClass(), getClasspath(configuration));
			runnerConfig.setVMArguments(getVMArguments(configuration));
			runnerConfig.setProgramArguments(getProgramArguments(configuration));
			runnerConfig.setWorkingDirectory(getWorkingDirectory(configuration).getAbsolutePath());
			runnerConfig.setEnvironment(getEnvironment(configuration));
			runnerConfig.setVMSpecificAttributesMap(getVMSpecificAttributesMap(configuration));

			monitor.worked(1);

			setDefaultSourceLocator(configuration);
			manageLaunch(launch);
			IVMRunner runner = getVMRunner(configuration, mode);
			if (runner != null)
				runner.run(runnerConfig, launch, monitor);
			else
				monitor.setCanceled(true);
			monitor.done();
		} catch (final CoreException e) {
			monitor.setCanceled(true);
			LauncherUtils.getDisplay().syncExec(new Runnable() {
				public void run() {
					MessageDialog.openError(LauncherUtils.getActiveShell(), PDEUIMessages.Launcher_error_title, e.getMessage());
				}
			});
		}
	}

	/**
	 * Returns the VM runner for the given launch mode to use when launching the
	 * given configuration.
	 *  
	 * @param configuration launch configuration
	 * @param mode launch node
	 * @return VM runner to use when launching the given configuration in the given mode
	 * @throws CoreException if a VM runner cannot be determined
	 */
	public IVMRunner getVMRunner(ILaunchConfiguration configuration, String mode) throws CoreException {
		IVMInstall launcher = VMHelper.createLauncher(configuration);
		return launcher.getVMRunner(mode);
	}

	/**
	 * Assigns a default source locator to the given launch if a source locator
	 * has not yet been assigned to it, and the associated launch configuration
	 * does not specify a source locator.
	 * 
	 * @param configuration
	 *            configuration being launched
	 * @exception CoreException
	 *                if unable to set the source locator
	 */
	protected void setDefaultSourceLocator(ILaunchConfiguration configuration) throws CoreException {
		ILaunchConfigurationWorkingCopy wc = null;
		if (configuration.isWorkingCopy()) {
			wc = (ILaunchConfigurationWorkingCopy) configuration;
		} else {
			wc = configuration.getWorkingCopy();
		}
		String id = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_SOURCE_PATH_PROVIDER, (String) null);
		if (!PDESourcePathProvider.ID.equals(id)) {
			wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_SOURCE_PATH_PROVIDER, PDESourcePathProvider.ID);
			wc.doSave();
		}
	}

	/**
	 * Returns the entries that should appear on boot classpath.
	 * 
	 * @param configuration
	 *            launch configuration
	 * @return the location of startup.jar and 
	 * 		the bootstrap classpath specified by the given launch configuration
	 *        
	 * @exception CoreException
	 *                if unable to find startup.jar
	 */
	public String[] getClasspath(ILaunchConfiguration configuration) throws CoreException {
		String[] classpath = LaunchArgumentsHelper.constructClasspath(configuration);
		if (classpath == null) {
			String message = PDEUIMessages.WorkbenchLauncherConfigurationDelegate_noStartup;
			throw new CoreException(LauncherUtils.createErrorStatus(message));
		}
		return classpath;
	}

	/** 
	 * Returns an array of environment variables to be used when
	 * launching the given configuration or <code>null</code> if unspecified.
	 * 
	 * @param configuration launch configuration
	 * @throws CoreException if unable to access associated attribute or if
	 * unable to resolve a variable in an environment variable's value
	 */
	public String[] getEnvironment(ILaunchConfiguration configuration) throws CoreException {
		return DebugPlugin.getDefault().getLaunchManager().getEnvironment(configuration);
	}

	/**
	 * Returns the working directory path specified by the given launch
	 * configuration, or <code>null</code> if none.
	 * 
	 * @param configuration
	 *            launch configuration
	 * @return the working directory path specified by the given launch
	 *         configuration, or <code>null</code> if none
	 * @exception CoreException
	 *                if unable to retrieve the attribute
	 */
	public File getWorkingDirectory(ILaunchConfiguration configuration) throws CoreException {
		return LaunchArgumentsHelper.getWorkingDirectory(configuration);
	}

	/**
	 * Returns the Map of VM-specific attributes specified by the given launch
	 * configuration, or <code>null</code> if none.
	 * 
	 * @param configuration
	 *            launch configuration
	 * @return the <code>Map</code> of VM-specific attributes
	 * @exception CoreException
	 *                if unable to retrieve the attribute
	 */
	public Map getVMSpecificAttributesMap(ILaunchConfiguration configuration) throws CoreException {
		return LaunchArgumentsHelper.getVMSpecificAttributesMap(configuration);
	}

	/**
	 * Returns the VM arguments specified by the given launch configuration, as
	 * an array of strings. 
	 * 
	 * @param configuration
	 *            launch configuration
	 * @return the VM arguments specified by the given launch configuration,
	 *         possibly an empty array
	 * @exception CoreException
	 *                if unable to retrieve the attribute
	 */
	public String[] getVMArguments(ILaunchConfiguration configuration) throws CoreException {
		String[] vmArgs = new ExecutionArguments(LaunchArgumentsHelper.getUserVMArguments(configuration), "").getVMArgumentsArray(); //$NON-NLS-1$
		// For p2 target, add "-Declipse.p2.data.area=@config.dir/p2" unless already specified by user
		Map bundleMap = BundleLauncherHelper.getMergedBundleMap(configuration, false);
		if (bundleMap.containsKey("org.eclipse.equinox.p2.core")) { //$NON-NLS-1$
			for (int i = 0; i < vmArgs.length; i++) {
				String arg = vmArgs[i];
				if (arg.startsWith("-Declipse.p2.data.area=")) { //$NON-NLS-1$
					return vmArgs;
				}
			}
			String[] temp = new String[vmArgs.length + 1];
			System.arraycopy(vmArgs, 0, temp, 0, vmArgs.length);
			temp[vmArgs.length] = "-Declipse.p2.data.area=@config.dir" + File.separator + "p2"; //$NON-NLS-1$ //$NON-NLS-2$
			return temp;
		}
		return vmArgs;
	}

	/**
	 * Returns the program arguments to launch with.
	 * This list is a combination of arguments computed by PDE based on attributes
	 * specified in the given launch configuration, followed by the program arguments
	 * that the entered directly into the launch configuration.
	 * 
	 * @param configuration
	 *            launch configuration
	 * @return the program arguments necessary for launching
	 * 
	 * @exception CoreException
	 *                if unable to retrieve the attribute or create the
	 *                necessary configuration files      
	 */
	public String[] getProgramArguments(ILaunchConfiguration configuration) throws CoreException {
		ArrayList programArgs = new ArrayList();

		// add tracing, if turned on	
		if (configuration.getAttribute(IPDELauncherConstants.TRACING, false) && !IPDELauncherConstants.TRACING_NONE.equals(configuration.getAttribute(IPDELauncherConstants.TRACING_CHECKED, (String) null))) {
			programArgs.add("-debug"); //$NON-NLS-1$
			programArgs.add(LaunchArgumentsHelper.getTracingFileArgument(configuration, getConfigDir(configuration).toString() + IPath.SEPARATOR + ".options")); //$NON-NLS-1$
		}

		// add the program args specified by the user
		String[] userArgs = LaunchArgumentsHelper.getUserProgramArgumentArray(configuration);
		ArrayList userDefined = new ArrayList();
		for (int i = 0; i < userArgs.length; i++) {
			// be forgiving if people have tracing turned on and forgot
			// to remove the -debug from the program args field.
			if (userArgs[i].equals("-debug") && programArgs.contains("-debug")) //$NON-NLS-1$ //$NON-NLS-2$
				continue;
			userDefined.add(userArgs[i]);
		}

		if (!configuration.getAttribute(IPDEUIConstants.APPEND_ARGS_EXPLICITLY, false)) {

			if (!userDefined.contains("-os")) { //$NON-NLS-1$
				programArgs.add("-os"); //$NON-NLS-1$
				programArgs.add(TargetPlatform.getOS());
			}
			if (!userDefined.contains("-ws")) { //$NON-NLS-1$
				programArgs.add("-ws"); //$NON-NLS-1$
				programArgs.add(TargetPlatform.getWS());
			}
			if (!userDefined.contains("-arch")) { //$NON-NLS-1$
				programArgs.add("-arch"); //$NON-NLS-1$
				programArgs.add(TargetPlatform.getOSArch());
			}
		}

		if (userDefined.size() > 0) {
			programArgs.addAll(userDefined);
		}

		return (String[]) programArgs.toArray(new String[programArgs.size()]);
	}

	/**
	 * Does sanity checking before launching.  The criteria whether the launch should 
	 * proceed or not is specific to the launch configuration type.
	 * 
	 * @param configuration launch configuration
	 * @param launch the launch object to contribute processes and debug targets to
	 * @param monitor a progress monitor
	 * 
	 * @throws CoreException exception thrown if launch fails or canceled or if unable to retrieve attributes
	 * from the launch configuration
	 * 				
	 */
	protected void preLaunchCheck(ILaunchConfiguration configuration, ILaunch launch, IProgressMonitor monitor) throws CoreException {
		boolean autoValidate = configuration.getAttribute(IPDELauncherConstants.AUTOMATIC_VALIDATE, false);
		monitor.beginTask("", autoValidate ? 3 : 4); //$NON-NLS-1$
		if (autoValidate)
			validatePluginDependencies(configuration, new SubProgressMonitor(monitor, 1));
		validateProjectDependencies(configuration, new SubProgressMonitor(monitor, 1));
		clear(configuration, new SubProgressMonitor(monitor, 1));
		launch.setAttribute(IPDELauncherConstants.CONFIG_LOCATION, getConfigDir(configuration).toString());
		synchronizeManifests(configuration, new SubProgressMonitor(monitor, 1));
	}

	/**
	 * Returns the configuration area specified by the given launch
	 * configuration.
	 * 
	 * @param configuration
	 *            launch configuration
	 * @return the directory path specified by the given launch
	 *         configuration
	 */
	protected File getConfigDir(ILaunchConfiguration configuration) {
		if (fConfigDir == null)
			fConfigDir = LaunchConfigurationHelper.getConfigurationArea(configuration);
		return fConfigDir;
	}

	/*
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.LaunchConfigurationDelegate#getBuildOrder(org.eclipse.debug.core.ILaunchConfiguration, java.lang.String)
	 */
	protected IProject[] getBuildOrder(ILaunchConfiguration configuration, String mode) throws CoreException {
		return computeBuildOrder(LaunchPluginValidator.getAffectedProjects(configuration));
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.debug.core.model.LaunchConfigurationDelegate#getProjectsForProblemSearch(org.eclipse.debug.core.ILaunchConfiguration, java.lang.String)
	 */
	protected IProject[] getProjectsForProblemSearch(ILaunchConfiguration configuration, String mode) throws CoreException {
		return LaunchPluginValidator.getAffectedProjects(configuration);
	}

	/**
	 * Returns the fully-qualified name of the class to launch. 
	 * 
	 * @return the fully-qualified name of the class to launch.  Must not return <code>null</code>. 
	 * @since 3.3
	 */
	public String getMainClass() {
		if (TargetPlatformHelper.getTargetVersion() >= 3.3)
			return "org.eclipse.equinox.launcher.Main"; //$NON-NLS-1$
		return "org.eclipse.core.launcher.Main"; //$NON-NLS-1$
	}

	/**
	 * Adds a listener to the launch to be notified at interesting launch lifecycle
	 * events such as when the launch terminates.
	 * 
	 * @param launch
	 * 			the launch 		
	 * 
	 * @since 3.3	
	 */
	protected void manageLaunch(ILaunch launch) {
		PDEPlugin.getDefault().getLaunchListener().manage(launch);
	}

	/**
	 * Checks for old-style plugin.xml files that have become stale since the last launch.
	 * For any stale plugin.xml files found, the corresponding MANIFEST.MF is deleted 
	 * from the runtime configuration area so that it gets regenerated upon startup.
	 * 
	 * @param configuration
	 * 			the launch configuration
	 * @param monitor
	 * 			a progress monitor
	 * 
	 * @since 3.3
	 */
	protected void synchronizeManifests(ILaunchConfiguration configuration, IProgressMonitor monitor) {
		LaunchConfigurationHelper.synchronizeManifests(configuration, getConfigDir(configuration));
		monitor.done();
	}

	/**
	 * Checks if the Automated Management of Dependencies option is turned on.
	 * If so, it makes aure all manifests are updated with the correct dependencies.
	 * 
	 * @param configuration
	 * 			the launch configuration
	 * @param monitor
	 * 			a progress monitor
	 * 
	 * @since 3.3
	 */
	protected void validateProjectDependencies(ILaunchConfiguration configuration, IProgressMonitor monitor) {
		LauncherUtils.validateProjectDependencies(configuration, monitor);
	}

	/**
	 * By default, this method does nothing.  Clients should override, if appropriate.
	 * 
	 * @param configuration
	 * 			the launch configuration
	 * @param monitor
	 * 			the progress monitor
	 * @throws CoreException
	 * 			if unable to retrieve launch attribute values
	 * @since 3.3
	 */
	protected void clear(ILaunchConfiguration configuration, IProgressMonitor monitor) throws CoreException {
	}

	/**
	 * Validates inter-bundle dependencies automatically prior to launching
	 * if that option is turned on.
	 * 
	 * @param configuration
	 * 			the launch configuration
	 * @param monitor
	 * 			a progress monitor
	 * @since 3.3
	 */
	protected void validatePluginDependencies(ILaunchConfiguration configuration, IProgressMonitor monitor) throws CoreException {
		EclipsePluginValidationOperation op = new EclipsePluginValidationOperation(configuration);
		LaunchPluginValidator.runValidationOperation(op, monitor);
	}

}




 * 
 * @noimplement This interface is not intended to be implemented by clients.
 * @noextend This interface is not intended to be extended by clients.
 * @deprecated use {@link org.eclipse.pde.launching.IPDELauncherConstants} instead.
 * @see org.eclipse.pde.launching.IPDELauncherConstants
 */
public interface IPDELauncherConstants extends org.eclipse.pde.launching.IPDELauncherConstants {

	/**
	 * Launch configuration attribute key. The value is a string specifying
	 * workspace data location for an Eclipse application.
	 */
	String LOCATION = "location"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a boolean specifying
	 * workspace data location for an Eclipse application should be cleared
	 * prior to launching.
	 */
	String DOCLEAR = "clearws"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a boolean specifying
	 * whether the user should be prompted prior to clearing the workspace.
	 * 
	 * @see IPDELauncherConstants#DOCLEAR
	 */
	String ASKCLEAR = "askclear"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a string specifying
	 * the application to run.  If the value is <code>null</code>, the default 
	 * application as specified in the target platform will be used.
	 */
	String APPLICATION = "application"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a string specifying
	 * the product to run.
	 * 
	 * @see IPDELauncherConstants#APPLICATION
	 */
	String PRODUCT = "product"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a boolean specifying
	 * if the launch should appear in product-mode.  If the value is <code>false</code>,
	 * the launch takes place in application-mode.
	 * 
	 * @see IPDELauncherConstants#PRODUCT
	 * @see IPDELauncherConstants#APPLICATION
	 */
	String USE_PRODUCT = "useProduct"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key used in Plug-in JUnit launch configurations only. 
	 * The value is a string specifying the application to be tested.  
	 * If the value is <code>null</code>, the default UI workbench application is tested.
	 */
	String APP_TO_TEST = "testApplication"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a string specifying
	 * the name of the VM to launch with.  If the value is <code>null</code>,
	 * the default workspace VM is used.
	 * 
	 * @deprecated use IJavaLaunchConfigurationConstants.ATTR_JRE_CONTAINER_PATH
	 */
	String VMINSTALL = "vminstall"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a string specifying
	 * the user-entered bootstrap classpath entries. 
	 */
	String BOOTSTRAP_ENTRIES = "bootstrap"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a boolean specifying
	 * if the default self-hosting mode should be used when launching.
	 * The default being to launch with all workspace plug-ins and all the 
	 * plug-ins that are explicitly checked on the Target Platform preference page.
	 */
	String USE_DEFAULT = "default"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a boolean specifying
	 * if the feature-based self-hosting mode should be used.
	 * The workspace must be set up properly for the feature-based self-hosting
	 * to succeed.
	 * Check the PDE Tips and Tricks section for how to set up feature-based self-hosting.
	 */
	String USEFEATURES = "usefeatures"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a string specifying
	 * a comma-separated list of IDs of workspace plug-ins to launch with.
	 * This value is only used when the Automatic Add option is off.
	 * 
	 * @see IPDELauncherConstants#AUTOMATIC_ADD
	 */
	String SELECTED_WORKSPACE_PLUGINS = "selected_workspace_plugins"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a string specifying
	 * a comma-separated list of IDs of workspace plug-ins that are to be excluded from
	 * the launch.
	 * This value is only used when the Automatic Add option is on.
	 * 
	 * @see IPDELauncherConstants#AUTOMATIC_ADD
	 */
	String DESELECTED_WORKSPACE_PLUGINS = "deselected_workspace_plugins"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a boolean specifying
	 * whether workspace plug-in created after the creation of a launch configuration
	 * should be added to the list of plug-ins to launch with.
	 * 
	 * If the value is <code>true</code>, then DESELECTED_WORKSPACE_PLUGINS should be used.
	 * Otherwise, SELECTED_WORKSPACE_PLUGINS should be used.
	 * 
	 * @see IPDELauncherConstants#DESELECTED_WORKSPACE_PLUGINS
	 * @see IPDELauncherConstants#SELECTED_WORKSPACE_PLUGINS
	 */
	String AUTOMATIC_ADD = "automaticAdd"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a boolean specifying
	 * whether the list of plug-ins to run should be validate prior to launching.
	 * If problems are found, they will be reported and the user will be able to cancel or
	 * continue.
	 * If no problems are found, the launch continues as normal.
	 */
	String AUTOMATIC_VALIDATE = "automaticValidate"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a string specifying
	 * a comma-separated list of IDs of target platform plug-ins to launch with.
	 * This value is only used when the Automatic Add option is off.
	 */
	String SELECTED_TARGET_PLUGINS = "selected_target_plugins"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a boolean indicating
	 * whether the computation of required plug-ins on the Plug-ins tab should include
	 * the traversal of optional dependencies.
	 */
	String INCLUDE_OPTIONAL = "includeOptional"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a boolean indicating
	 * whether tracing is enabled or disabled.
	 */
	String TRACING = "tracing"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a map containing the list
	 * of options to debug with.
	 */
	String TRACING_OPTIONS = "tracingOptions"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is the id of the last plug-in 
	 * that was selected on the Tracing tab.
	 */
	String TRACING_SELECTED_PLUGIN = "selectedPlugin"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is the IDs of all plug-ins
	 * checked on the Tracing tab.  The value may also be "[NONE]"
	 * 
	 * @see IPDELauncherConstants#TRACING_NONE
	 */
	String TRACING_CHECKED = "checked"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute value indicating that, although tracing is enabled,
	 * no plug-ins have been selected to be traced.
	 */
	String TRACING_NONE = "[NONE]"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a boolean specifying 
	 * if PDE should generate a default configuration area for the launch.
	 * 
	 * If <code>true</code>, a configuration location in the PDE metadata area 
	 * is created.  Otherwise, the user is expected to specify a location.
	 * 
	 * @see IPDELauncherConstants#CONFIG_LOCATION
	 */
	String CONFIG_USE_DEFAULT_AREA = "useDefaultConfigArea"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a string specifying 
	 * the configuration area location for an Eclipse application launch.
	 * 
	 * This key is only used when CONFIG_USE_DEFAULT_AREA is <code>false</code>.
	 * 
	 * @see IPDELauncherConstants#CONFIG_USE_DEFAULT_AREA
	 */
	String CONFIG_LOCATION = "configLocation"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a boolean specifying 
	 * if the configuration area location should be cleared prior to launching
	*/
	String CONFIG_CLEAR_AREA = "clearConfig"; //$NON-NLS-1$

	/**
	 * Launch configuration atribute key.  The value is a boolean specifying
	 * if PDE should generate a default config.ini file for the launch.
	 * 
	 * If <code>true</code>, a configuration file is created.  
	 * Otherwise, the user is expected to specify a config.ini to be used as a template.
	 * 
	 * @see IPDELauncherConstants#CONFIG_TEMPLATE_LOCATION
	 */
	String CONFIG_GENERATE_DEFAULT = "useDefaultConfig"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a string specifying 
	 * the location of the config.ini file to be used as a template for an 
	 * Eclipse application launch.
	 * 
	 * This key is only used when CONFIG_GENERATE_DEFAULT is <code>false</code>.
	 * 
	 * @see IPDELauncherConstants#CONFIG_GENERATE_DEFAULT
	 */
	String CONFIG_TEMPLATE_LOCATION = "templateConfig"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a string specifying 
	 * the location of the .product file with which this launch configuration 
	 * is associated.
	 */
	String PRODUCT_FILE = "productFile"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key.  The value is the ID of an OSGi framework
	 * declared in an <code>org.eclipse.pde.ui.osgiLaunchers</code> extension point.
	 * 
	 * @since 3.3
	 */
	String OSGI_FRAMEWORK_ID = "osgi_framework_id"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key.  The value is a boolean specifying
	 * if the default Auto-Start for an OSGi Framework launch configuration 
	 * is <code>true</code> or <code>false</code>
	 * 
	 * @see IPDELauncherConstants#DEFAULT_START_LEVEL
	 */
	String DEFAULT_AUTO_START = "default_auto_start"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key.  The value is an integer specifying
	 * the default start level for bundles in an OSGi Framework launch configuration.
	 * 
	 * @see IPDELauncherConstants#DEFAULT_AUTO_START
	 */
	String DEFAULT_START_LEVEL = "default_start_level"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key.  The value is a comma-separated list
	 * of workspace bundles to launch with the OSGi framework.
	 * 
	 * Each token in the list is of the format:
	 * <plugin-id>@<start-level>:<auto-start>
	 * 
	 * @see IPDELauncherConstants#DEFAULT_AUTO_START
	 * @see IPDELauncherConstants#DEFAULT_START_LEVEL
	 */
	String WORKSPACE_BUNDLES = "workspace_bundles"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key.  The value is a comma-separated list
	 * of non-workspace bundles to launch with the OSGi framework.
	 * 
	 * Each token in the list is of the format:
	 * <plugin-id>@<start-level>:<auto-start>
	 * 
	 * @see IPDELauncherConstants#DEFAULT_AUTO_START
	 * @see IPDELauncherConstants#DEFAULT_START_LEVEL
	 */
	String TARGET_BUNDLES = "target_bundles"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key.  The value can be either the full path
	 * to the workspace location of a Target Definition (ie. .target file), or
	 * the ID of a target defined in an org.eclipse.pde.core.targets extension.
	 */
	String DEFINED_TARGET = "defined_target"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a boolean indicating
	 * whether or not to display only selected plug-ins. 
	 * 
	 * @since 3.4
	 */
	String SHOW_SELECTED_ONLY = "show_selected_only"; //$NON-NLS-1$

	/**
	 * The unique tab identifier for the bundles tab
	 * 
	 * @since 3.5
	 * @see BundlesTab
	 */
	String TAB_BUNDLES_ID = "org.eclipse.pde.ui.launch.tab.osgi.bundles"; //$NON-NLS-1$

	/**
	 * The unique tab identifier for the configuration tab
	 * 
	 * @since 3.5
	 * @see ConfigurationTab
	 */
	String TAB_CONFIGURATION_ID = "org.eclipse.pde.ui.launch.tab.configuration"; //$NON-NLS-1$

	/**
	 * The unique tab identifier for the main tab
	 * 
	 * @since 3.5
	 * @see MainTab
	 */
	String TAB_MAIN_ID = "org.eclipse.pde.ui.launch.tab.main"; //$NON-NLS-1$

	/**
	 * The unique tab identifier for the osgi settings tab
	 * 
	 * @since 3.5
	 * @see OSGiSettingsTab
	 */
	String TAB_OSGI_SETTINGS_ID = "org.eclipse.pde.ui.launch.tab.osgi.settings"; //$NON-NLS-1$

	/**
	 * The unique tab identifier for the plug-in junit tab
	 * 
	 * @since 3.5
	 * @see PluginJUnitMainTab
	 */
	String TAB_PLUGIN_JUNIT_MAIN_ID = "org.eclipse.pde.ui.launch.tab.junit.main"; //$NON-NLS-1$

	/**
	 * The unique tab identifier for the plug-ins tab
	 * 
	 * @since 3.5
	 * @see PluginsTab
	 */
	String TAB_PLUGINS_ID = "org.eclipse.pde.ui.launch.tab.plugins"; //$NON-NLS-1$

	/**
	 * The unique tab identifier for the tracing tab
	 * 
	 * @since 3.5
	 * @see TracingTab
	 */
	String TAB_TRACING_ID = "org.eclipse.pde.ui.launch.tab.tracing"; //$NON-NLS-1$

	/**
	 * The unique tab identifier for the tracing tab
	 * 
	 * @since 3.5
	 * @see TestTab
	 */
	String TAB_TEST_ID = "org.eclipse.pde.ui.launch.tab.test"; //$NON-NLS-1$

	/**
	 * The launch configuration type id for OSGi launches.
	 * 
	 * @since 3.5
	 * @see OSGiLaunchShortcut
	 */
	String OSGI_CONFIGURATION_TYPE = "org.eclipse.pde.ui.EquinoxLauncher"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key. The value is a boolean specifying 
	 * whether the tests should run on the UI thread.
	 * 
	 * The default value is <code>true</code>
	 * 
	 * @since 3.5
	 */
	String RUN_IN_UI_THREAD = "run_in_ui_thread"; //$NON-NLS-1$
}




 *******************************************************************************/
package org.eclipse.pde.ui.launcher;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.*;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.model.LaunchConfigurationDelegate;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.internal.ui.*;
import org.eclipse.pde.internal.ui.launcher.LaunchPluginValidator;
import org.eclipse.pde.internal.ui.launcher.OSGiFrameworkManager;

/**
 * A launch delegate for launching OSGi frameworks
 * <p>
 * Clients may subclass and instantiate this class.
 * </p>
 * @since 3.3
 * @deprecated use {@link org.eclipse.pde.launching.OSGiLaunchConfigurationDelegate} instead.
 * @see org.eclipse.pde.launching.OSGiLaunchConfigurationDelegat
 */
public class OSGiLaunchConfigurationDelegate extends org.eclipse.pde.launching.OSGiLaunchConfigurationDelegate {

	/**
	 * Delegates to the launcher delegate associated with the OSGi framework
	 * selected in the launch configuration.
	 * 
	 * @see org.eclipse.debug.core.model.ILaunchConfigurationDelegate#launch(org.eclipse.debug.core.ILaunchConfiguration, java.lang.String, org.eclipse.debug.core.ILaunch, org.eclipse.core.runtime.IProgressMonitor)
	 */
	public void launch(ILaunchConfiguration configuration, String mode, ILaunch launch, IProgressMonitor monitor) throws CoreException {
		OSGiFrameworkManager manager = PDEPlugin.getDefault().getOSGiFrameworkManager();
		String id = configuration.getAttribute(IPDELauncherConstants.OSGI_FRAMEWORK_ID, manager.getDefaultFramework());
		LaunchConfigurationDelegate launcher = manager.getFrameworkLauncher(id);
		if (launcher != null) {
			launcher.launch(configuration, mode, launch, monitor);
		} else {
			String name = manager.getFrameworkName(id);
			if (name == null)
				name = PDEUIMessages.OSGiLaunchConfiguration_selected;
			String message = NLS.bind(PDEUIMessages.OSGiLaunchConfiguration_cannotFindLaunchConfiguration, name);
			IStatus status = new Status(IStatus.ERROR, IPDEUIConstants.PLUGIN_ID, IStatus.OK, message, null);
			throw new CoreException(status);
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.LaunchConfigurationDelegate#getBuildOrder(org.eclipse.debug.core.ILaunchConfiguration, java.lang.String)
	 */
	protected IProject[] getBuildOrder(ILaunchConfiguration configuration, String mode) throws CoreException {
		return computeBuildOrder(LaunchPluginValidator.getAffectedProjects(configuration));
	}

}

Lines 10-15 Link Here

(-)src/org/eclipse/pde/ui/launcher/BundlesTab.java (+2 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.pde.ui.launcher;	11	package org.eclipse.pde.ui.launcher;
12		12
		13	import org.eclipse.pde.launching.IPDELauncherConstants;
		14
13	import org.eclipse.core.runtime.CoreException;	15	import org.eclipse.core.runtime.CoreException;
14	import org.eclipse.debug.core.ILaunchConfiguration;	16	import org.eclipse.debug.core.ILaunchConfiguration;
15	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;	17	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;

Lines 10-15 Link Here

(-)src/org/eclipse/pde/ui/launcher/PluginsTab.java (+2 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.pde.ui.launcher;	11	package org.eclipse.pde.ui.launcher;
12		12
		13	import org.eclipse.pde.launching.IPDELauncherConstants;
		14
13	import org.eclipse.core.runtime.CoreException;	15	import org.eclipse.core.runtime.CoreException;
14	import org.eclipse.core.runtime.IPath;	16	import org.eclipse.core.runtime.IPath;
15	import org.eclipse.debug.core.ILaunchConfiguration;	17	import org.eclipse.debug.core.ILaunchConfiguration;

Lines 10-15 Link Here

(-)src/org/eclipse/pde/ui/launcher/TracingTab.java (+2 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.pde.ui.launcher;	11	package org.eclipse.pde.ui.launcher;
12		12
		13	import org.eclipse.pde.launching.IPDELauncherConstants;
		14
13	import org.eclipse.debug.core.ILaunchConfiguration;	15	import org.eclipse.debug.core.ILaunchConfiguration;
14	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;	16	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
15	import org.eclipse.jface.dialogs.Dialog;	17	import org.eclipse.jface.dialogs.Dialog;

Lines 10-15 Link Here

(-)src/org/eclipse/pde/ui/launcher/AbstractLaunchShortcut.java (+2 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.pde.ui.launcher;	11	package org.eclipse.pde.ui.launcher;
12		12
		13	import org.eclipse.pde.launching.IPDELauncherConstants;
		14
13	import java.util.ArrayList;	15	import java.util.ArrayList;
14	import org.eclipse.core.runtime.CoreException;	16	import org.eclipse.core.runtime.CoreException;
15	import org.eclipse.debug.core.*;	17	import org.eclipse.debug.core.*;




package org.eclipse.pde.internal.ui.preferences;

import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.preferences.*;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.viewers.*;
import org.eclipse.pde.core.plugin.IPluginExtensionPoint;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.core.PDEPreferencesManager;
import org.eclipse.pde.internal.core.schema.SchemaRegistry;
import org.eclipse.pde.internal.launching.*;
import org.eclipse.pde.internal.launching.launcher.OSGiFrameworkManager;
import org.eclipse.pde.internal.ui.*;
import org.eclipse.pde.internal.ui.launcher.OSGiFrameworkManager;
import org.eclipse.pde.internal.ui.search.ShowDescriptionAction;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.*;
import org.eclipse.ui.*;
import org.osgi.service.prefs.BackingStoreException;

/**
 * Provides the preference page for managing the default OSGi framework to use.

	 * Restores the default framework setting from the PDE preferences
	 */
	private void setDefaultFramework() {
		PDEPreferencesManager preferenceManager = PDELaunchingPlugin.getDefault().getPreferenceManager();
		fDefaultFramework = preferenceManager.getString(ILaunchingPreferenceConstants.DEFAULT_OSGI_FRAMEOWRK);
	}

	/* (non-Javadoc)

		fTableViewer.getTable().setLayoutData(new GridData(GridData.FILL_BOTH));
		fTableViewer.setContentProvider(ArrayContentProvider.getInstance());
		fTableViewer.setLabelProvider(new FrameworkLabelProvider());
		fTableViewer.setInput(PDELaunchingPlugin.getDefault().getOSGiFrameworkManager().getSortedFrameworks());
		fTableViewer.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				IConfigurationElement element = (IConfigurationElement) event.getElement();

			}
		});
		if (fDefaultFramework != null) {
			IConfigurationElement element = PDELaunchingPlugin.getDefault().getOSGiFrameworkManager().getFramework(fDefaultFramework);
			if (element != null) {
				fTableViewer.setCheckedElements(new Object[] {element});
			}

	 * @see org.eclipse.jface.preference.PreferencePage#performOk()
	 */
	public boolean performOk() {
		IEclipsePreferences instancePrefs = new InstanceScope().getNode(IPDEConstants.PLUGIN_ID);
		IEclipsePreferences defaultPrefs = new DefaultScope().getNode(IPDEConstants.PLUGIN_ID);
		if (defaultPrefs.get(ILaunchingPreferenceConstants.DEFAULT_OSGI_FRAMEOWRK, "").equals(fDefaultFramework)) { //$NON-NLS-1$
			instancePrefs.remove(ILaunchingPreferenceConstants.DEFAULT_OSGI_FRAMEOWRK);
		} else {
			instancePrefs.put(ILaunchingPreferenceConstants.DEFAULT_OSGI_FRAMEOWRK, fDefaultFramework);
		}
		try {
			instancePrefs.flush();
		} catch (BackingStoreException e) {
			PDEPlugin.log(e);
		}

		return super.performOk();
	}


Lines 11-20 Link Here

(-)src/org/eclipse/pde/internal/ui/preferences/MainPreferencePage.java (-2 / +21 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.pde.internal.ui.preferences;	12	package org.eclipse.pde.internal.ui.preferences;
13		13
		14	import org.eclipse.core.runtime.preferences.*;
14	import org.eclipse.jface.dialogs.Dialog;	15	import org.eclipse.jface.dialogs.Dialog;
15	import org.eclipse.jface.dialogs.MessageDialogWithToggle;	16	import org.eclipse.jface.dialogs.MessageDialogWithToggle;
16	import org.eclipse.jface.preference.IPreferenceStore;	17	import org.eclipse.jface.preference.IPreferenceStore;
17	import org.eclipse.jface.preference.PreferencePage;	18	import org.eclipse.jface.preference.PreferencePage;
		19	import org.eclipse.pde.internal.core.PDEPreferencesManager;
		20	import org.eclipse.pde.internal.launching.*;
18	import org.eclipse.pde.internal.ui.*;	21	import org.eclipse.pde.internal.ui.*;
19	import org.eclipse.swt.SWT;	22	import org.eclipse.swt.SWT;
20	import org.eclipse.swt.events.SelectionAdapter;	23	import org.eclipse.swt.events.SelectionAdapter;
Lines 23-28 Link Here
23	import org.eclipse.swt.layout.GridLayout;	26	import org.eclipse.swt.layout.GridLayout;
24	import org.eclipse.swt.widgets.*;	27	import org.eclipse.swt.widgets.*;
25	import org.eclipse.ui.*;	28	import org.eclipse.ui.*;
		29	import org.osgi.service.prefs.BackingStoreException;
26		30
27	public class MainPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {	31	public class MainPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {
28	private Button fUseID;	32	private Button fUseID;
Lines 39-44 Link Here
39		43
40	protected Control createContents(Composite parent) {	44	protected Control createContents(Composite parent) {
41	IPreferenceStore store = PDEPlugin.getDefault().getPreferenceStore();	45	IPreferenceStore store = PDEPlugin.getDefault().getPreferenceStore();
		46	PDEPreferencesManager launchingStore = PDELaunchingPlugin.getDefault().getPreferenceManager();
42		47
43	Composite composite = new Composite(parent, SWT.NONE);	48	Composite composite = new Composite(parent, SWT.NONE);
44	GridLayout layout = new GridLayout();	49	GridLayout layout = new GridLayout();
Lines 63-69 Link Here
63		68
64	fAutoManage = new Button(group, SWT.CHECK);	69	fAutoManage = new Button(group, SWT.CHECK);
65	fAutoManage.setText(PDEUIMessages.MainPreferencePage_updateStale);	70	fAutoManage.setText(PDEUIMessages.MainPreferencePage_updateStale);
66	fAutoManage.setSelection(store.getBoolean(IPreferenceConstants.PROP_AUTO_MANAGE));	71	fAutoManage.setSelection(launchingStore.getBoolean(ILaunchingPreferenceConstants.PROP_AUTO_MANAGE));
67		72
68	group = SWTFactory.createGroup(composite, PDEUIMessages.MainPreferencePage_exportingGroup, 1, 1, GridData.FILL_HORIZONTAL);	73	group = SWTFactory.createGroup(composite, PDEUIMessages.MainPreferencePage_exportingGroup, 1, 1, GridData.FILL_HORIZONTAL);
69		74
Lines 107-116 Link Here
107	} else {	112	} else {
108	store.setValue(IPreferenceConstants.PROP_SHOW_OBJECTS, IPreferenceConstants.VALUE_USE_NAMES);	113	store.setValue(IPreferenceConstants.PROP_SHOW_OBJECTS, IPreferenceConstants.VALUE_USE_NAMES);
109	}	114	}
110	store.setValue(IPreferenceConstants.PROP_AUTO_MANAGE, fAutoManage.getSelection());
111	store.setValue(IPreferenceConstants.OVERWRITE_BUILD_FILES_ON_EXPORT, fOverwriteBuildFiles.getSelection() ? MessageDialogWithToggle.PROMPT : MessageDialogWithToggle.ALWAYS);	115	store.setValue(IPreferenceConstants.OVERWRITE_BUILD_FILES_ON_EXPORT, fOverwriteBuildFiles.getSelection() ? MessageDialogWithToggle.PROMPT : MessageDialogWithToggle.ALWAYS);
112	store.setValue(IPreferenceConstants.PROP_SHOW_SOURCE_BUNDLES, fShowSourceBundles.getSelection());	116	store.setValue(IPreferenceConstants.PROP_SHOW_SOURCE_BUNDLES, fShowSourceBundles.getSelection());
113	PDEPlugin.getDefault().getPreferenceManager().savePluginPreferences();	117	PDEPlugin.getDefault().getPreferenceManager().savePluginPreferences();
		118
		119	// write AUTO_MANAGE setting to pde.launching instance scope
		120	IEclipsePreferences instancePrefs = new InstanceScope().getNode(IPDEConstants.PLUGIN_ID);
		121	IEclipsePreferences defaultPrefs = new DefaultScope().getNode(IPDEConstants.PLUGIN_ID);
		122	if (defaultPrefs.getBoolean(ILaunchingPreferenceConstants.PROP_AUTO_MANAGE, false) == fAutoManage.getSelection()) {
		123	instancePrefs.remove(ILaunchingPreferenceConstants.PROP_AUTO_MANAGE);
		124	} else {
		125	instancePrefs.putBoolean(ILaunchingPreferenceConstants.PROP_AUTO_MANAGE, fAutoManage.getSelection());
		126	}
		127	try {
		128	instancePrefs.flush();
		129	} catch (BackingStoreException e) {
		130	PDEPlugin.log(e);
		131	}
		132
114	return super.performOk();	133	return super.performOk();
115	}	134	}
116		135




/*******************************************************************************
 *  Copyright (c) 2007, 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.launcher;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.debug.core.*;
import org.eclipse.jdt.launching.*;
import org.eclipse.pde.internal.ui.IPDEUIConstants;
import org.eclipse.pde.ui.launcher.IPDELauncherConstants;

public class PDEMigrationDelegate implements ILaunchConfigurationMigrationDelegate {

	public boolean isCandidate(ILaunchConfiguration candidate) throws CoreException {
		return !candidate.getAttribute(IPDEUIConstants.APPEND_ARGS_EXPLICITLY, false) || candidate.hasAttribute(IPDELauncherConstants.VMINSTALL);
	}

	public void migrate(ILaunchConfiguration candidate) throws CoreException {
		ILaunchConfigurationWorkingCopy wc = candidate.getWorkingCopy();
		migrate(wc);
		wc.doSave();
	}

	public void migrate(ILaunchConfigurationWorkingCopy candidate) throws CoreException {
		if (!candidate.getAttribute(IPDEUIConstants.APPEND_ARGS_EXPLICITLY, false)) {
			candidate.setAttribute(IPDEUIConstants.APPEND_ARGS_EXPLICITLY, true);
			String args = candidate.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, ""); //$NON-NLS-1$
			StringBuffer buffer = new StringBuffer(LaunchArgumentsHelper.getInitialProgramArguments());
			if (args.length() > 0) {
				buffer.append(" "); //$NON-NLS-1$
				buffer.append(args);
			}
			candidate.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, buffer.toString());
		}
		if (candidate.hasAttribute(IPDELauncherConstants.VMINSTALL)) {
			String name = candidate.getAttribute(IPDELauncherConstants.VMINSTALL, (String) null);
			if (name != null) {
				IVMInstall vm = VMHelper.getVMInstall(name);
				if (vm != null) {
					IPath path = JavaRuntime.newJREContainerPath(vm);
					candidate.setAttribute(IJavaLaunchConfigurationConstants.ATTR_JRE_CONTAINER_PATH, path.toPortableString());
				}
			}
			candidate.removeAttribute(IPDELauncherConstants.VMINSTALL);
		}
	}

}

Lines 27-32 Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/OpenLogDialog.java (-2 / +4 lines)
27	* Displays the error log in non-Win32 platforms - see bug 55314.	27	* Displays the error log in non-Win32 platforms - see bug 55314.
28	*/	28	*/
29	public final class OpenLogDialog extends TrayDialog {	29	public final class OpenLogDialog extends TrayDialog {
		30	// maximum log file size
		31	public static final long MAX_FILE_LENGTH = 1024 * 1024;
30	// input log file	32	// input log file
31	private File logFile;	33	private File logFile;
32	// location/size configuration	34	// location/size configuration
Lines 90-96 Link Here
90	private String getLogSummary() {	92	private String getLogSummary() {
91	StringWriter out = new StringWriter();	93	StringWriter out = new StringWriter();
92	PrintWriter writer = new PrintWriter(out);	94	PrintWriter writer = new PrintWriter(out);
93	if (logFile.length() > LaunchListener.MAX_FILE_LENGTH) {	95	if (logFile.length() > MAX_FILE_LENGTH) {
94	readLargeFileWithMonitor(writer);	96	readLargeFileWithMonitor(writer);
95	} else {	97	} else {
96	readFileWithMonitor(writer);	98	readFileWithMonitor(writer);
Lines 112-118 Link Here
112	boolean hasStarted = false;	114	boolean hasStarted = false;
113	try {	115	try {
114	random = new RandomAccessFile(logFile, "r"); //$NON-NLS-1$	116	random = new RandomAccessFile(logFile, "r"); //$NON-NLS-1$
115	random.seek(logFile.length() - LaunchListener.MAX_FILE_LENGTH);	117	random.seek(logFile.length() - MAX_FILE_LENGTH);
116	for (;;) {	118	for (;;) {
117	String line = random.readLine();	119	String line = random.readLine();
118	if (line == null)	120	if (line == null)




/*******************************************************************************
 * Copyright (c) 2005, 2009 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.launcher;

import java.io.*;
import java.net.URL;
import java.util.*;
import org.eclipse.core.runtime.*;
import org.eclipse.core.variables.IStringVariableManager;
import org.eclipse.core.variables.VariablesPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.TargetPlatform;
import org.eclipse.pde.internal.build.IPDEBuildConstants;
import org.eclipse.pde.internal.core.*;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.ui.launcher.IPDELauncherConstants;

/**
 * Contains helper methods for launching an Eclipse Runtime Workbench
 */
public class LaunchConfigurationHelper {

	private static final String PROP_OSGI_FRAMEWORK = "osgi.framework"; //$NON-NLS-1$
	private static final String PROP_OSGI_BUNDLES = "osgi.bundles"; //$NON-NLS-1$
	private static final String PROP_P2_DATA_AREA = "eclipse.p2.data.area"; //$NON-NLS-1$

	public static void synchronizeManifests(ILaunchConfiguration config, File configDir) {
		try {
			String programArgs = config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, ""); //$NON-NLS-1$
			if (programArgs.indexOf("-clean") != -1) //$NON-NLS-1$
				return;
		} catch (CoreException e) {
		}
		File dir = new File(configDir, "org.eclipse.osgi/manifests"); //$NON-NLS-1$
		if (dir.exists() && dir.isDirectory()) {
			PDECore.getDefault().getJavaElementChangeListener().synchronizeManifests(dir);
		}
	}

	public static File getConfigurationArea(ILaunchConfiguration config) {
		File dir = getConfigurationLocation(config);
		if (!dir.exists())
			dir.mkdirs();
		return dir;
	}

	public static File getConfigurationLocation(ILaunchConfiguration config) {
		//bug 170213 change config location if config name contains #
		String configName = config.getName();
		configName = configName.replace('#', 'h');
		File dir = new File(PDECore.getDefault().getStateLocation().toOSString(), configName);
		try {
			if (!config.getAttribute(IPDELauncherConstants.CONFIG_USE_DEFAULT_AREA, true)) {
				String userPath = config.getAttribute(IPDELauncherConstants.CONFIG_LOCATION, (String) null);
				if (userPath != null) {
					userPath = getSubstitutedString(userPath);
					dir = new File(userPath).getAbsoluteFile();
				}
			}
		} catch (CoreException e) {
		}
		return dir;
	}

	private static String getSubstitutedString(String text) throws CoreException {
		if (text == null)
			return ""; //$NON-NLS-1$
		IStringVariableManager mgr = VariablesPlugin.getDefault().getStringVariableManager();
		return mgr.performStringSubstitution(text);
	}

	public static Properties createConfigIniFile(ILaunchConfiguration configuration, String productID, Map bundles, Map bundlesWithStartLevels, File directory) throws CoreException {
		Properties properties = null;
		// if we are to generate a config.ini, start with the values in the target platform's config.ini - bug 141918
		if (configuration.getAttribute(IPDELauncherConstants.CONFIG_GENERATE_DEFAULT, true)) {
			properties = TargetPlatformHelper.getConfigIniProperties();
			// if target's config.ini does not exist, lets try to fill in default values
			if (properties == null)
				properties = new Properties();
			// keep properties only if we are launching the default product (bug 175437)
			else if (productID == null || !productID.equals(properties.get("eclipse.product"))) //$NON-NLS-1$
				properties.clear();
			// if target's config.ini has the osgi.bundles header, then parse and compute the proper osgi.bundles value
			String bundleList = properties.getProperty(PROP_OSGI_BUNDLES);
			if (bundleList != null)
				properties.setProperty(PROP_OSGI_BUNDLES, computeOSGiBundles(TargetPlatformHelper.stripPathInformation(bundleList), bundles, bundlesWithStartLevels));
			String dataArea = properties.getProperty(PROP_P2_DATA_AREA);
			if (dataArea != null) {
				// Make the p2 data area in the configuration area itself, rather than a sibling of the configuration
				// area (which is a the root pde.core shared metadata area) @see bug 272810
				properties.setProperty(PROP_P2_DATA_AREA, "@config.dir/.p2"); //$NON-NLS-1$
			}
		} else {
			String templateLoc = configuration.getAttribute(IPDELauncherConstants.CONFIG_TEMPLATE_LOCATION, (String) null);
			if (templateLoc != null) {
				properties = loadFromTemplate(getSubstitutedString(templateLoc));
				// if template contains osgi.bundles, then only strip the path, do not compute the value
				String osgiBundles = properties.getProperty(PROP_OSGI_BUNDLES);
				if (osgiBundles != null)
					properties.setProperty(PROP_OSGI_BUNDLES, TargetPlatformHelper.stripPathInformation(osgiBundles));
			}
		}
		// whether we create a new config.ini or read from one as a template, we should add the required properties - bug 161265
		if (properties != null) {
			addRequiredProperties(properties, productID, bundles, bundlesWithStartLevels);
		} else {
			properties = new Properties();
		}
		if (!directory.exists()) {
			directory.mkdirs();
		}
		String osgiBundles = properties.getProperty(PROP_OSGI_BUNDLES);
		int start = configuration.getAttribute(IPDELauncherConstants.DEFAULT_START_LEVEL, 4);
		properties.put("osgi.bundles.defaultStartLevel", Integer.toString(start)); //$NON-NLS-1$
		boolean autostart = configuration.getAttribute(IPDELauncherConstants.DEFAULT_AUTO_START, false);

		// if we are launching using P2, write out P2 files (bundles.txt) and add P2 property to config.ini
		if (osgiBundles != null && osgiBundles.indexOf(IPDEBuildConstants.BUNDLE_SIMPLE_CONFIGURATOR) != -1 && bundles.containsKey(IPDEBuildConstants.BUNDLE_SIMPLE_CONFIGURATOR)) {
			URL bundlesTxt = null;
			boolean usedefault = configuration.getAttribute(IPDELauncherConstants.USE_DEFAULT, true);
			boolean useFeatures = configuration.getAttribute(IPDELauncherConstants.USEFEATURES, false);
			if (usedefault || useFeatures) {
				bundlesTxt = P2Utils.writeBundlesTxt(bundlesWithStartLevels, 4, false, directory, osgiBundles);
			} else {
				bundlesTxt = P2Utils.writeBundlesTxt(bundlesWithStartLevels, start, autostart, directory, null);
			}

			if (bundlesTxt != null) {
				properties.setProperty("org.eclipse.equinox.simpleconfigurator.configUrl", bundlesTxt.toString()); //$NON-NLS-1$
				// if we have simple configurator and update configurator together, ensure update doesn't reconcile
				if (bundles.get(IPDEBuildConstants.BUNDLE_UPDATE_CONFIGURATOR) != null) {
					properties.setProperty("org.eclipse.update.reconcile", "false"); //$NON-NLS-1$ //$NON-NLS-2$
				}
			}
		}

		setBundleLocations(bundles, properties, autostart);

		save(new File(directory, "config.ini"), properties); //$NON-NLS-1$
		return properties;
	}

	private static void addRequiredProperties(Properties properties, String productID, Map bundles, Map bundlesWithStartLevels) {
		if (!properties.containsKey("osgi.install.area")) //$NON-NLS-1$
			properties.setProperty("osgi.install.area", "file:" + TargetPlatform.getLocation()); //$NON-NLS-1$ //$NON-NLS-2$
		if (!properties.containsKey("osgi.configuration.cascaded")) //$NON-NLS-1$
			properties.setProperty("osgi.configuration.cascaded", "false"); //$NON-NLS-1$ //$NON-NLS-2$
		if (!properties.containsKey(PROP_OSGI_FRAMEWORK))
			properties.setProperty(PROP_OSGI_FRAMEWORK, IPDEBuildConstants.BUNDLE_OSGI);
		if (!properties.containsKey("osgi.splashPath") && productID != null) //$NON-NLS-1$
			addSplashLocation(properties, productID, bundles);
		// if osgi.splashPath is set, try to resolve relative paths to absolute paths
		if (properties.containsKey("osgi.splashPath")) //$NON-NLS-1$
			resolveLocationPath(properties.getProperty("osgi.splashPath"), properties, bundles); //$NON-NLS-1$
		if (!properties.containsKey(PROP_OSGI_BUNDLES))
			properties.setProperty(PROP_OSGI_BUNDLES, computeOSGiBundles(TargetPlatform.getBundleList(), bundles, bundlesWithStartLevels));
		if (!properties.containsKey("osgi.bundles.defaultStartLevel")) //$NON-NLS-1$
			properties.setProperty("osgi.bundles.defaultStartLevel", "4"); //$NON-NLS-1$ //$NON-NLS-2$
	}

	/**
	 * Computes a list of osgi bundles to be put into the osgi.bundles property based
	 * on the bundles from the target platform config.ini and a map of bundles we are
	 * launching with.  The list of bundles must have already had it's path information
	 * removed.
	 * @param bundleList list of bundles without path information
	 * @param bundles map of bundle id to bundle model, contains all bundles being launched with
	 * @param bundlesWithStartLevels map of bundles of start level
	 * @return string list of osgi bundles
	 */
	private static String computeOSGiBundles(String bundleList, Map bundles, Map bundlesWithStartLevels) {

		// if p2 and only simple configurator and 
		// if simple configurator isn't selected & isn't in bundle list... hack it

		// if using p2's simple configurator, a bundles.txt will be written, so we only need simple configurator in the config.ini
		if (bundles.get(IPDEBuildConstants.BUNDLE_SIMPLE_CONFIGURATOR) != null)
			return "org.eclipse.equinox.simpleconfigurator@1:start"; //$NON-NLS-1$

		StringBuffer buffer = new StringBuffer();
		Set initialBundleSet = new HashSet();
		StringTokenizer tokenizer = new StringTokenizer(bundleList, ","); //$NON-NLS-1$
		while (tokenizer.hasMoreTokens()) {
			String token = tokenizer.nextToken();
			int index = token.indexOf('@');
			String id = index != -1 ? token.substring(0, index) : token;
			if (bundles.containsKey(id)) {
				if (buffer.length() > 0)
					buffer.append(',');
				buffer.append(id);
				if (index != -1 && index < token.length() - 1)
					buffer.append(token.substring(index));
				initialBundleSet.add(id);
			}
		}

		// if org.eclipse.update.configurator is not included (LIKE IN BASIC RCP APPLICATION), then write out all bundles in osgi.bundles - bug 170772
		if (!initialBundleSet.contains(IPDEBuildConstants.BUNDLE_UPDATE_CONFIGURATOR)) {
			initialBundleSet.add(IPDEBuildConstants.BUNDLE_OSGI);
			Iterator iter = bundlesWithStartLevels.keySet().iterator();
			while (iter.hasNext()) {
				IPluginModelBase model = (IPluginModelBase) iter.next();
				String id = model.getPluginBase().getId();
				if (!initialBundleSet.contains(id)) {
					if (buffer.length() > 0)
						buffer.append(',');

					String slinfo = (String) bundlesWithStartLevels.get(model);
					buffer.append(id);
					buffer.append('@');
					buffer.append(slinfo);
				}
			}
		}
		return buffer.toString();
	}

	private static Properties loadFromTemplate(String templateLoc) throws CoreException {
		Properties properties = new Properties();
		File templateFile = new File(templateLoc);
		if (templateFile.exists() && templateFile.isFile()) {
			FileInputStream stream = null;
			try {
				stream = new FileInputStream(templateFile);
				properties.load(stream);
			} catch (Exception e) {
				String message = e.getMessage();
				if (message != null)
					throw new CoreException(new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, message, e));
			} finally {
				if (stream != null) {
					try {
						stream.close();
					} catch (IOException e) {
					}
				}
			}
		}
		return properties;
	}

	private static void addSplashLocation(Properties properties, String productID, Map map) {
		Properties targetConfig = TargetPlatformHelper.getConfigIniProperties();
		String targetProduct = targetConfig == null ? null : targetConfig.getProperty("eclipse.product"); //$NON-NLS-1$
		String targetSplash = targetConfig == null ? null : targetConfig.getProperty("osgi.splashPath"); //$NON-NLS-1$
		if (!productID.equals(targetProduct) || targetSplash == null) {
			ArrayList locations = new ArrayList();
			String plugin = getContributingPlugin(productID);
			locations.add(plugin);
			IPluginModelBase model = (IPluginModelBase) map.get(plugin);
			if (model != null) {
				BundleDescription desc = model.getBundleDescription();
				if (desc != null) {
					BundleDescription[] fragments = desc.getFragments();
					for (int i = 0; i < fragments.length; i++)
						locations.add(fragments[i].getSymbolicName());
				}
			}
			resolveLocationPath(locations, properties, map);
		} else
			resolveLocationPath(targetSplash, properties, map);
	}

	private static void resolveLocationPath(String splashPath, Properties properties, Map map) {
		ArrayList locations = new ArrayList();
		StringTokenizer tok = new StringTokenizer(splashPath, ","); //$NON-NLS-1$
		while (tok.hasMoreTokens())
			locations.add(tok.nextToken());
		resolveLocationPath(locations, properties, map);
	}

	private static void resolveLocationPath(ArrayList locations, Properties properties, Map map) {
		StringBuffer buffer = new StringBuffer();
		for (int i = 0; i < locations.size(); i++) {
			String location = (String) locations.get(i);
			if (location.startsWith("platform:/base/plugins/")) { //$NON-NLS-1$
				location = location.replaceFirst("platform:/base/plugins/", ""); //$NON-NLS-1$ //$NON-NLS-2$
			}
			String url = getBundleURL(location, map, false);
			if (url == null)
				continue;
			if (buffer.length() > 0)
				buffer.append(","); //$NON-NLS-1$
			buffer.append(url);
		}
		if (buffer.length() > 0)
			properties.setProperty("osgi.splashPath", buffer.toString()); //$NON-NLS-1$
	}

	/**
	 * Returns a string url representing the install location of the bundle model with the
	 * specified id.  The model is obtained using the provided map.
	 * @param id the id of the bundle
	 * @param pluginMap mapping of bundle ids to bundle models
	 * @param includeReference whether to prefix the url with 'reference:'
	 * @return string url for the bundle location
	 */
	public static String getBundleURL(String id, Map pluginMap, boolean includeReference) {
		IPluginModelBase model = (IPluginModelBase) pluginMap.get(id.trim());
		return getBundleURL(model, includeReference);
	}

	/**
	 * Returns a string url representing the install location of the given bundle model
	 * @param model the model to create the url for
	 * @param includeReference whether to prefix the url with 'reference:'
	 * @return string url for bundle location
	 */
	public static String getBundleURL(IPluginModelBase model, boolean includeReference) {
		if (model == null || model.getInstallLocation() == null)
			return null;
		StringBuffer buf = new StringBuffer();
		if (includeReference) {
			buf.append(TargetPlatformHelper.REFERENCE_PREFIX);
		}
		buf.append(TargetPlatformHelper.FILE_URL_PREFIX);
		buf.append(new Path(model.getInstallLocation()).removeTrailingSeparator().toString());
		return buf.toString();
	}

	/**
	 * Use the map of bundles we are launching with to update the osgi.framework
	 * and osgi.bundles properties with the correct info.
	 * @param map map of bundles being launched (id mapped to model)
	 * @param properties properties for config.ini
	 */
	private static void setBundleLocations(Map map, Properties properties, boolean defaultAuto) {
		String framework = properties.getProperty(PROP_OSGI_FRAMEWORK);
		if (framework != null) {
			framework = TargetPlatformHelper.stripPathInformation(framework);
			String url = getBundleURL(framework, map, false);
			if (url != null)
				properties.setProperty(PROP_OSGI_FRAMEWORK, url);
		}

		String bundles = properties.getProperty(PROP_OSGI_BUNDLES);
		if (bundles != null) {
			StringBuffer buffer = new StringBuffer();
			StringTokenizer tokenizer = new StringTokenizer(bundles, ","); //$NON-NLS-1$
			while (tokenizer.hasMoreTokens()) {
				String token = tokenizer.nextToken().trim();
				String url = getBundleURL(token, map, false);
				int i = -1;
				if (url == null) {
					i = token.indexOf('@');
					if (i != -1) {
						url = getBundleURL(token.substring(0, i), map, false);
					}
					if (url == null) {
						i = token.indexOf(':');
						if (i != -1)
							url = getBundleURL(token.substring(0, i), map, false);
					}
				}
				if (url != null) {
					if (buffer.length() > 0) {
						buffer.append(","); //$NON-NLS-1$
					}
					buffer.append("reference:" + url); //$NON-NLS-1$
					if (i != -1) {
						String slinfo = token.substring(i + 1);
						buffer.append(getStartData(slinfo, defaultAuto));
					}
				}
			}
			properties.setProperty(PROP_OSGI_BUNDLES, buffer.toString());
		}
	}

	/**
	 * Convenience method to parses the startData ("startLevel:autoStart"), convert it to the
	 * format expected by the OSGi bundles property, and append to a StringBuffer.
	 * @param startData data to parse ("startLevel:autoStart")
	 * @param defaultAuto default auto start setting
	 */
	public static String getStartData(String startData, boolean defaultAuto) {
		StringBuffer buffer = new StringBuffer();
		int index = startData.indexOf(':');
		String level = index > 0 ? startData.substring(0, index) : "default"; //$NON-NLS-1$
		String auto = startData;
		if (!startData.equals("start")) //$NON-NLS-1$
			auto = index >= 0 && index < startData.length() - 1 ? startData.substring(index + 1) : "default"; //$NON-NLS-1$
		if ("default".equals(auto)) //$NON-NLS-1$
			auto = Boolean.toString(defaultAuto);
		if (!level.equals("default") || "true".equals(auto) || "start".equals(auto)) //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			buffer.append("@"); //$NON-NLS-1$

		if (!level.equals("default")) { //$NON-NLS-1$
			buffer.append(level);
			if ("start".equals(auto) || "true".equals(auto)) //$NON-NLS-1$ //$NON-NLS-2$
				buffer.append(":"); //$NON-NLS-1$
		}
		if ("start".equals(auto) || "true".equals(auto)) { //$NON-NLS-1$ //$NON-NLS-2$
			buffer.append("start"); //$NON-NLS-1$
		}
		return buffer.toString();
	}

	public static void save(File file, Properties properties) {
		try {
			FileOutputStream stream = new FileOutputStream(file);
			properties.store(stream, "Configuration File"); //$NON-NLS-1$
			stream.flush();
			stream.close();
		} catch (IOException e) {
			PDECore.logException(e);
		}
	}

	public static String getContributingPlugin(String productID) {
		if (productID == null)
			return null;
		int index = productID.lastIndexOf('.');
		return index == -1 ? productID : productID.substring(0, index);
	}

	public static String getProductID(ILaunchConfiguration configuration) throws CoreException {
		if (configuration.getAttribute(IPDELauncherConstants.USE_PRODUCT, false)) {
			return configuration.getAttribute(IPDELauncherConstants.PRODUCT, (String) null);
		}

		// find the product associated with the application, and return its
		// contributing plug-in
		String appID = configuration.getAttribute(IPDELauncherConstants.APPLICATION, TargetPlatform.getDefaultApplication());
		IExtension[] extensions = PDECore.getDefault().getExtensionsRegistry().findExtensions("org.eclipse.core.runtime.products", true); //$NON-NLS-1$
		for (int i = 0; i < extensions.length; i++) {
			String id = extensions[i].getUniqueIdentifier();
			if (id == null)
				continue;
			IConfigurationElement[] children = extensions[i].getConfigurationElements();
			if (children.length != 1)
				continue;
			if (!"product".equals(children[0].getName())) //$NON-NLS-1$
				continue;
			if (appID.equals(children[0].getAttribute("application"))) //$NON-NLS-1$
				return id;
		}
		return null;

	}

}




/*******************************************************************************
 * Copyright (c) 2006, 2009 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.launcher;

import java.util.*;
import org.eclipse.core.runtime.*;
import org.eclipse.debug.core.model.LaunchConfigurationDelegate;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.pde.internal.ui.IPreferenceConstants;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.ui.launcher.OSGiLaunchConfigurationInitializer;

public class OSGiFrameworkManager implements IRegistryChangeListener {

	public static final String POINT_ID = "org.eclipse.pde.ui.osgiFrameworks"; //$NON-NLS-1$
	public static final String DEFAULT_FRAMEWORK = "org.eclipse.pde.ui.EquinoxFramework"; //$NON-NLS-1$

	public static final String ATT_ID = "id"; //$NON-NLS-1$
	public static final String ATT_NAME = "name"; //$NON-NLS-1$
	public static final String ATT_DELEGATE = "launcherDelegate"; //$NON-NLS-1$
	public static final String ATT_INITIALIZER = "initializer"; //$NON-NLS-1$

	public static final String ELEMENT_FRAMEWORK = "framework"; //$NON-NLS-1$

	private Map fFrameworks;

	public IConfigurationElement[] getFrameworks() {
		if (fFrameworks == null)
			loadElements();
		return (IConfigurationElement[]) fFrameworks.values().toArray(new IConfigurationElement[fFrameworks.size()]);
	}

	public IConfigurationElement[] getSortedFrameworks() {
		IConfigurationElement[] elements = getFrameworks();
		return orderElements(elements);
	}

	private void loadElements() {
		fFrameworks = new HashMap();
		IExtensionRegistry registry = Platform.getExtensionRegistry();
		IConfigurationElement[] elements = registry.getConfigurationElementsFor(POINT_ID);
		for (int i = 0; i < elements.length; i++) {
			String id = elements[i].getAttribute(ATT_ID);
			if (id == null || elements[i].getAttribute(ATT_NAME) == null || elements[i].getAttribute(ATT_DELEGATE) == null)
				continue;
			fFrameworks.put(id, elements[i]);
		}
	}

	private IConfigurationElement[] orderElements(IConfigurationElement[] elems) {
		Arrays.sort(elems, new Comparator() {
			public int compare(Object o1, Object o2) {
				String name1 = ((IConfigurationElement) o1).getAttribute(ATT_NAME);
				String name2 = ((IConfigurationElement) o2).getAttribute(ATT_NAME);
				if (name1 != null)
					return name1.compareToIgnoreCase(name2);
				return 1;
			}
		});
		return elems;
	}

	public void registryChanged(IRegistryChangeEvent event) {
		//TODO implement 
	}

	public String getDefaultFramework() {
		IPreferenceStore store = PDEPlugin.getDefault().getPreferenceStore();
		return store.getString(IPreferenceConstants.DEFAULT_OSGI_FRAMEOWRK);
	}

	public OSGiLaunchConfigurationInitializer getDefaultInitializer() {
		return getInitializer(getDefaultFramework());
	}

	public OSGiLaunchConfigurationInitializer getInitializer(String frameworkID) {
		if (fFrameworks == null)
			loadElements();
		if (fFrameworks.containsKey(frameworkID)) {
			try {
				IConfigurationElement element = (IConfigurationElement) fFrameworks.get(frameworkID);
				if (element.getAttribute(ATT_INITIALIZER) != null) {
					Object result = element.createExecutableExtension(ATT_INITIALIZER);
					if (result instanceof OSGiLaunchConfigurationInitializer)
						return (OSGiLaunchConfigurationInitializer) result;
				}
			} catch (CoreException e) {
			}
		}
		return new OSGiLaunchConfigurationInitializer();
	}

	public LaunchConfigurationDelegate getFrameworkLauncher(String frameworkID) {
		if (fFrameworks == null)
			loadElements();
		if (fFrameworks.containsKey(frameworkID)) {
			try {
				IConfigurationElement element = (IConfigurationElement) fFrameworks.get(frameworkID);
				Object result = element.createExecutableExtension(ATT_DELEGATE);
				if (result instanceof LaunchConfigurationDelegate)
					return (LaunchConfigurationDelegate) result;
			} catch (CoreException e) {
			}
		}
		return null;
	}

	public String getFrameworkName(String frameworkID) {
		if (fFrameworks == null)
			loadElements();
		if (fFrameworks.containsKey(frameworkID)) {
			IConfigurationElement element = (IConfigurationElement) fFrameworks.get(frameworkID);
			return element.getAttribute(ATT_NAME);
		}
		return null;
	}

	/**
	 * Returns the {@link IConfigurationElement} for the framework with the given ID
	 * or <code>null</code> if no element exists with that ID.
	 * @param frameworkId
	 * @return the {@link IConfigurationElement} for the framework with the given ID or <code>null</code>
	 * 
	 * @since 3.5
	 */
	public IConfigurationElement getFramework(String frameworkId) {
		if (fFrameworks == null) {
			loadElements();
		}
		return (IConfigurationElement) fFrameworks.get(frameworkId);
	}

}




/*******************************************************************************
 * Copyright (c) 2000, 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.launcher;

import java.io.File;
import java.util.ArrayList;
import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.runtime.*;
import org.eclipse.debug.core.*;
import org.eclipse.debug.core.model.IProcess;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.pde.internal.ui.*;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.*;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.internal.views.log.LogView;

public class LaunchListener implements ILaunchListener, IDebugEventSetListener {
	private ArrayList managedLaunches;
	// maximum log file size
	public static final long MAX_FILE_LENGTH = 1024 * 1024;
	// different ways to open the error log
	public static final int OPEN_IN_ERROR_LOG_VIEW = 0;
	public static final int OPEN_IN_SYSTEM_EDITOR = 1;

	public LaunchListener() {
		managedLaunches = new ArrayList();
	}

	public void manage(ILaunch launch) {
		if (managedLaunches.size() == 0)
			hookListener(true);
		if (!managedLaunches.contains(launch))
			managedLaunches.add(launch);
	}

	/**
	 * @see org.eclipse.debug.core.ILaunchesListener#launchesRemoved(org.eclipse.debug.core.ILaunch)
	 */
	public void launchRemoved(ILaunch launch) {
		update(launch, true);
	}

	/**
	 * @see org.eclipse.debug.core.ILaunchesListener#launchesAdded(org.eclipse.debug.core.ILaunch)
	 */
	public void launchAdded(ILaunch launch) {
	}

	/**
	 * @see org.eclipse.debug.core.ILaunchesListener#launchesChanged(org.eclipse.debug.core.ILaunch)
	 */
	public void launchChanged(ILaunch launch) {
	}

	private void update(ILaunch launch, boolean remove) {
		if (managedLaunches.contains(launch)) {
			if (remove || launch.isTerminated()) {
				managedLaunches.remove(launch);
				if (managedLaunches.size() == 0) {
					hookListener(false);
				}
			}
		}
	}

	private void hookListener(boolean add) {
		DebugPlugin debugPlugin = DebugPlugin.getDefault();
		ILaunchManager launchManager = debugPlugin.getLaunchManager();
		if (add) {
			launchManager.addLaunchListener(this);
			debugPlugin.addDebugEventListener(this);
		} else {
			launchManager.removeLaunchListener(this);
			debugPlugin.removeDebugEventListener(this);
		}
	}

	private void doRestart(ILaunch launch) {
		ILaunchConfiguration config = launch.getLaunchConfiguration();
		try {
			ILaunchConfigurationWorkingCopy copy = config.getWorkingCopy();
			copy.setAttribute(IPDEUIConstants.RESTART, true);
			copy.launch(launch.getLaunchMode(), new NullProgressMonitor());
		} catch (CoreException e) {
			PDEPlugin.logException(e);
		}
	}

	public void shutdown() {
		hookListener(false);
	}

	/**
	 * @see org.eclipse.debug.core.IDebugEventSetListener#handleDebugEvents(org.eclipse.debug.core.DebugEvent)
	 */
	public void handleDebugEvents(DebugEvent[] events) {
		for (int i = 0; i < events.length; i++) {
			DebugEvent event = events[i];
			Object source = event.getSource();
			if (source instanceof IProcess && event.getKind() == DebugEvent.TERMINATE) {
				IProcess process = (IProcess) source;
				ILaunch launch = process.getLaunch();
				if (launch != null) {
					try {
						launchTerminated(launch, process.getExitValue());
					} catch (DebugException e) {
					}
				}
			}
		}
	}

	private void launchTerminated(final ILaunch launch, int returnValue) {
		if (managedLaunches.contains(launch)) {
			update(launch, true);
			if (returnValue == 23) {
				doRestart(launch);
				return;
			}
			// launch failed because the associated workspace is in use
			if (returnValue == 15) {
				Display.getDefault().asyncExec(new Runnable() {
					public void run() {
						MessageDialog.openError(PDEPlugin.getActiveWorkbenchShell(), PDEUIMessages.Launcher_error_title, PDEUIMessages.Launcher_error_code15);
					}
				});
				return;
			}
			// launch failed for reasons printed to the log.
			if (returnValue == 13) {
				Display.getDefault().asyncExec(new Runnable() {
					public void run() {
						try {
							File log = getMostRecentLogFile(launch.getLaunchConfiguration());
							if (log != null && log.exists()) {
								MessageDialog dialog = new MessageDialog(PDEPlugin.getActiveWorkbenchShell(), PDEUIMessages.Launcher_error_title, null, // accept the default window icon
										PDEUIMessages.Launcher_error_code13, MessageDialog.ERROR, new String[] {PDEUIMessages.Launcher_error_displayInLogView, PDEUIMessages.Launcher_error_displayInSystemEditor, IDialogConstants.NO_LABEL}, OPEN_IN_ERROR_LOG_VIEW);
								int dialog_value = dialog.open();
								if (dialog_value == OPEN_IN_ERROR_LOG_VIEW) {
									LogView errlog = (LogView) PDEPlugin.getActivePage().showView("org.eclipse.pde.runtime.LogView"); //$NON-NLS-1$
									errlog.handleImportPath(log.getAbsolutePath());
									errlog.sortByDateDescending();
								} else if (dialog_value == OPEN_IN_SYSTEM_EDITOR) {
									openInEditor(log);
								}
							}
						} catch (CoreException e) {
						}
					}
				});
			}
		}
	}

	private void openInEditor(File log) {
		IFileStore fileStore = EFS.getLocalFileSystem().getStore(new Path(log.getAbsolutePath()));
		if (!fileStore.fetchInfo().isDirectory() && fileStore.fetchInfo().exists()) {
			IWorkbenchWindow ww = PDEPlugin.getActiveWorkbenchWindow();
			IWorkbenchPage page = ww.getActivePage();
			try {
				IDE.openEditorOnFileStore(page, fileStore);
			} catch (PartInitException e) {
			}
		}
	}

	/**
	 * Returns latest log file for Launch Configuration.
	 * It's ".metadala/.log", file with most recent timestamp ending with ".log"
	 * in configuration location or null if none found.
	 *
	 * @returns log file or null
	 * @throws CoreException
	 * @since 3.4
	 */
	static File getMostRecentLogFile(ILaunchConfiguration configuration) throws CoreException {
		File latest = null;
		String workspace = LaunchArgumentsHelper.getWorkspaceLocation(configuration);
		if (workspace.length() > 0) {
			latest = new File(workspace, ".metadata/.log"); //$NON-NLS-1$
			if (!latest.exists())
				latest = null;
		}
		File configDir = LaunchConfigurationHelper.getConfigurationLocation(configuration);
		File[] children = configDir.listFiles();
		if (children != null) {
			for (int i = 0; i < children.length; i++) {
				if (!children[i].isDirectory() && children[i].getName().endsWith(".log")) { //$NON-NLS-1$
					if (latest == null || latest.lastModified() < children[i].lastModified())
						latest = children[i];
				}
			}
		}
		return latest;
	}

}




 *  Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import org.eclipse.pde.launching.IPDELauncherConstants;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.pde.internal.launching.PDELaunchingPlugin;
import org.eclipse.pde.internal.launching.launcher.OSGiFrameworkManager;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.pde.ui.launcher.AbstractLauncherTab;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.*;

public class OSGiFrameworkBlock {

	private Combo fDefaultAutoStart;
	private Spinner fDefaultStartLevel;
	private IConfigurationElement[] fConfigElements;
	private Combo fLauncherCombo;
	private Listener fListener;
	private AbstractLauncherTab fTab;

	class Listener extends SelectionAdapter implements ModifyListener {

		public void widgetSelected(SelectionEvent e) {
			fTab.updateLaunchConfigurationDialog();
		}

		public void modifyText(ModifyEvent e) {
			fTab.updateLaunchConfigurationDialog();
		}
	}

	public OSGiFrameworkBlock(AbstractLauncherTab tab) {
		fTab = tab;
		fConfigElements = PDELaunchingPlugin.getDefault().getOSGiFrameworkManager().getSortedFrameworks();
		fListener = new Listener();
	}

	public void createControl(Composite parent) {
		Composite composite = new Composite(parent, SWT.NONE);
		GridLayout layout = new GridLayout(6, false);
		layout.marginHeight = layout.marginWidth = 0;
		composite.setLayout(layout);
		GridData gd = new GridData(GridData.FILL_HORIZONTAL);
		gd.horizontalSpan = 2;
		composite.setLayoutData(gd);

		Label label = new Label(composite, SWT.NONE);
		label.setText(PDEUIMessages.OSGiBundlesTab_frameworkLabel);
		gd = new GridData();
		gd.horizontalIndent = 5;
		label.setLayoutData(gd);

		fLauncherCombo = new Combo(composite, SWT.READ_ONLY);
		for (int i = 0; i < fConfigElements.length; i++)
			fLauncherCombo.add(fConfigElements[i].getAttribute("name")); //$NON-NLS-1$
		fLauncherCombo.addSelectionListener(fListener);

		label = new Label(composite, SWT.NONE);
		gd = new GridData();
		gd.horizontalIndent = 20;
		label.setLayoutData(gd);
		label.setText(PDEUIMessages.EquinoxPluginsTab_defaultStart);

		fDefaultStartLevel = new Spinner(composite, SWT.BORDER);
		fDefaultStartLevel.setMinimum(1);
		fDefaultStartLevel.addModifyListener(fListener);

		label = new Label(composite, SWT.NONE);
		gd = new GridData();
		gd.horizontalIndent = 20;
		label.setLayoutData(gd);
		label.setText(PDEUIMessages.EquinoxPluginsTab_defaultAuto);

		fDefaultAutoStart = new Combo(composite, SWT.BORDER | SWT.READ_ONLY);
		fDefaultAutoStart.setItems(new String[] {Boolean.toString(true), Boolean.toString(false)});
		fDefaultAutoStart.select(0);
		fDefaultAutoStart.addSelectionListener(fListener);

		label = new Label(composite, SWT.SEPARATOR | SWT.HORIZONTAL);
		gd = new GridData(GridData.FILL_HORIZONTAL);
		gd.horizontalSpan = 6;
		label.setLayoutData(gd);
	}

	public void initializeFrom(ILaunchConfiguration config) throws CoreException {
		initializeFramework(config);
		boolean auto = config.getAttribute(IPDELauncherConstants.DEFAULT_AUTO_START, true);
		fDefaultAutoStart.setText(Boolean.toString(auto));
		int level = config.getAttribute(IPDELauncherConstants.DEFAULT_START_LEVEL, 4);
		fDefaultStartLevel.setSelection(level);
	}

	private void initializeFramework(ILaunchConfiguration config) throws CoreException {
		OSGiFrameworkManager manager = PDELaunchingPlugin.getDefault().getOSGiFrameworkManager();
		String id = config.getAttribute(IPDELauncherConstants.OSGI_FRAMEWORK_ID, manager.getDefaultFramework());

		for (int i = 0; i < fConfigElements.length; i++) {
			if (id.equals(fConfigElements[i].getAttribute(OSGiFrameworkManager.ATT_ID))) {
				fLauncherCombo.select(i);
				return;
			}
		}
		if (fLauncherCombo.getItemCount() > 0)
			fLauncherCombo.select(0);
	}

	public void performApply(ILaunchConfigurationWorkingCopy config) {
		config.setAttribute(IPDELauncherConstants.DEFAULT_AUTO_START, Boolean.toString(true).equals(fDefaultAutoStart.getText()));
		config.setAttribute(IPDELauncherConstants.DEFAULT_START_LEVEL, fDefaultStartLevel.getSelection());

		int index = fLauncherCombo.getSelectionIndex();
		String id = index > -1 ? fConfigElements[index].getAttribute(OSGiFrameworkManager.ATT_ID) : null;
		OSGiFrameworkManager manager = PDELaunchingPlugin.getDefault().getOSGiFrameworkManager();

		// no need to persist the default OSGi framework
		if (manager.getDefaultFramework().equals(id))
			id = null;
		config.setAttribute(IPDELauncherConstants.OSGI_FRAMEWORK_ID, id);
	}

	public int getDefaultStartLevel() {
		return fDefaultStartLevel.getSelection();
	}
}




 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import org.eclipse.pde.launching.IPDELauncherConstants;

import org.eclipse.pde.internal.launching.launcher.*;

import java.util.*;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.ui.launcher.BundlesTab;
import org.eclipse.pde.ui.launcher.IPDELauncherConstants;

public class OSGiBundleBlock extends AbstractPluginBlock {


Lines 12-17 Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/AbstractPluginBlock.java (-1 / +5 lines)
12	*******************************************************************************/	12	*******************************************************************************/
13	package org.eclipse.pde.internal.ui.launcher;	13	package org.eclipse.pde.internal.ui.launcher;
14		14
		15	import org.eclipse.pde.launching.IPDELauncherConstants;
		16
		17	import org.eclipse.pde.internal.launching.launcher.BundleLauncherHelper;
		18	import org.eclipse.pde.internal.launching.launcher.LaunchValidationOperation;
		19
15	import java.util.*;	20	import java.util.*;
16	import org.eclipse.core.resources.IProject;	21	import org.eclipse.core.resources.IProject;
17	import org.eclipse.core.resources.IResource;	22	import org.eclipse.core.resources.IResource;
Lines 35-41 Link Here
35	import org.eclipse.pde.internal.ui.util.*;	40	import org.eclipse.pde.internal.ui.util.*;
36	import org.eclipse.pde.internal.ui.wizards.ListUtil;	41	import org.eclipse.pde.internal.ui.wizards.ListUtil;
37	import org.eclipse.pde.ui.launcher.AbstractLauncherTab;	42	import org.eclipse.pde.ui.launcher.AbstractLauncherTab;
38	import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
39	import org.eclipse.swt.SWT;	43	import org.eclipse.swt.SWT;
40	import org.eclipse.swt.SWTException;	44	import org.eclipse.swt.SWTException;
41	import org.eclipse.swt.custom.CCombo;	45	import org.eclipse.swt.custom.CCombo;




/*******************************************************************************
 * Copyright (c) 2005, 2009 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
 *     Code 9 Corporation - ongoing enhancements
 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import java.io.File;
import java.util.*;
import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.debug.core.sourcelookup.*;
import org.eclipse.debug.core.sourcelookup.containers.*;
import org.eclipse.debug.ui.sourcelookup.WorkingSetSourceContainer;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.debug.core.*;
import org.eclipse.jdt.launching.IRuntimeClasspathEntry;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.launching.sourcelookup.containers.JavaSourceLookupParticipant;
import org.eclipse.pde.core.plugin.*;
import org.eclipse.pde.internal.core.PDEClasspathContainer;
import org.eclipse.pde.internal.core.TargetPlatformHelper;
import org.eclipse.pde.internal.ui.PDEPlugin;

public class PDESourceLookupDirector extends AbstractSourceLookupDirector {

	/**
	 * Cache of source containers by location and id (String & String)
	 */
	private Map fSourceContainerMap = new HashMap();

	private static Set fFilteredTypes;

	static {
		fFilteredTypes = new HashSet(3);
		fFilteredTypes.add(ProjectSourceContainer.TYPE_ID);
		fFilteredTypes.add(WorkspaceSourceContainer.TYPE_ID);
		fFilteredTypes.add(WorkingSetSourceContainer.TYPE_ID);
	}

	/**
	 * Lazily initialized.
	 */
	private double fOSGiRuntimeVersion = Double.MIN_VALUE;

	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.core.sourcelookup.ISourceLookupDirector#initializeParticipants()
	 */
	public void initializeParticipants() {
		addParticipants(new ISourceLookupParticipant[] {new JavaSourceLookupParticipant()});
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.core.sourcelookup.ISourceLookupDirector#supportsSourceContainerType(org.eclipse.debug.internal.core.sourcelookup.ISourceContainerType)
	 */
	public boolean supportsSourceContainerType(ISourceContainerType type) {
		return !fFilteredTypes.contains(type.getId());
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.sourcelookup.AbstractSourceLookupDirector#getSourceElement(java.lang.Object)
	 */
	public Object getSourceElement(Object element) {
		PDESourceLookupQuery query = new PDESourceLookupQuery(this, element);
		SafeRunner.run(query);
		Object result = query.getResult();
		return result != null ? result : super.getSourceElement(element);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.sourcelookup.AbstractSourceLookupDirector#findSourceElements(java.lang.Object)
	 */
	public Object[] findSourceElements(Object object) throws CoreException {
		Object[] sourceElements = null;
		if (object instanceof IJavaStackFrame || object instanceof IJavaObject || object instanceof IJavaReferenceType) {
			sourceElements = new Object[] {getSourceElement(object)};
		}
		if (sourceElements == null) {
			sourceElements = super.findSourceElements(object);
		}
		return sourceElements;
	}

	ISourceContainer[] getSourceContainers(String location, String id) throws CoreException {

		ISourceContainer[] containers = (ISourceContainer[]) fSourceContainerMap.get(location);
		if (containers != null) {
			return containers;
		}

		ArrayList result = new ArrayList();
		ModelEntry entry = PluginRegistry.findEntry(id);

		boolean match = false;

		IPluginModelBase[] models = entry.getWorkspaceModels();
		for (int i = 0; i < models.length; i++) {
			if (isPerfectMatch(models[i], new Path(location))) {
				IResource resource = models[i].getUnderlyingResource();
				// if the plug-in matches a workspace model,
				// add the project and any libraries not coming via a container
				// to the list of source containers, in that order
				if (resource != null) {
					addProjectSourceContainers(resource.getProject(), result);
				}
				match = true;
				break;
			}
		}

		if (!match) {
			File file = new File(location);
			if (file.isFile()) {
				// in case of linked plug-in projects that map to an external JARd plug-in,
				// use source container that maps to the library in the linked project.
				ISourceContainer container = getArchiveSourceContainer(location);
				if (container != null) {
					containers = new ISourceContainer[] {container};
					fSourceContainerMap.put(location, containers);
					return containers;
				}
			}

			models = entry.getExternalModels();
			for (int i = 0; i < models.length; i++) {
				if (isPerfectMatch(models[i], new Path(location))) {
					// try all source zips found in the source code locations
					IClasspathEntry[] entries = PDEClasspathContainer.getExternalEntries(models[i]);
					for (int j = 0; j < entries.length; j++) {
						IRuntimeClasspathEntry rte = convertClasspathEntry(entries[j]);
						if (rte != null)
							result.add(rte);
					}
					break;
				}
			}
		}

		IRuntimeClasspathEntry[] entries = (IRuntimeClasspathEntry[]) result.toArray(new IRuntimeClasspathEntry[result.size()]);
		containers = JavaRuntime.getSourceContainers(entries);
		fSourceContainerMap.put(location, containers);
		return containers;
	}

	private boolean isPerfectMatch(IPluginModelBase model, IPath path) {
		return model == null ? false : path.equals(new Path(model.getInstallLocation()));
	}

	private IRuntimeClasspathEntry convertClasspathEntry(IClasspathEntry entry) {
		if (entry == null)
			return null;

		IPath srcPath = entry.getSourceAttachmentPath();
		if (srcPath != null && srcPath.segmentCount() > 0) {
			IRuntimeClasspathEntry rte = JavaRuntime.newArchiveRuntimeClasspathEntry(entry.getPath());
			rte.setSourceAttachmentPath(srcPath);
			rte.setSourceAttachmentRootPath(entry.getSourceAttachmentRootPath());
			return rte;
		}
		return null;
	}

	private ISourceContainer getArchiveSourceContainer(String location) throws JavaModelException {
		IWorkspaceRoot root = PDEPlugin.getWorkspace().getRoot();
		IFile[] containers = root.findFilesForLocationURI(URIUtil.toURI(location));
		for (int i = 0; i < containers.length; i++) {
			IJavaElement element = JavaCore.create(containers[i]);
			if (element instanceof IPackageFragmentRoot) {
				IPackageFragmentRoot archive = (IPackageFragmentRoot) element;
				IPath path = archive.getSourceAttachmentPath();
				if (path == null || path.segmentCount() == 0)
					continue;

				IPath rootPath = archive.getSourceAttachmentRootPath();
				boolean detectRootPath = rootPath != null && rootPath.segmentCount() > 0;

				IFile archiveFile = root.getFile(path);
				if (archiveFile.exists())
					return new ArchiveSourceContainer(archiveFile, detectRootPath);

				File file = path.toFile();
				if (file.exists())
					return new ExternalArchiveSourceContainer(file.getAbsolutePath(), detectRootPath);
			}
		}
		return null;
	}

	private void addProjectSourceContainers(IProject project, ArrayList result) throws CoreException {
		if (project == null || !project.hasNature(JavaCore.NATURE_ID))
			return;

		IJavaProject jProject = JavaCore.create(project);
		result.add(JavaRuntime.newProjectRuntimeClasspathEntry(jProject));

		IClasspathEntry[] entries = jProject.getRawClasspath();
		for (int i = 0; i < entries.length; i++) {
			IClasspathEntry entry = entries[i];
			if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
				IRuntimeClasspathEntry rte = convertClasspathEntry(entry);
				if (rte != null)
					result.add(rte);
			}
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.sourcelookup.AbstractSourceLookupDirector#dispose()
	 */
	public synchronized void dispose() {
		Iterator iterator = fSourceContainerMap.values().iterator();
		while (iterator.hasNext()) {
			ISourceContainer[] containers = (ISourceContainer[]) iterator.next();
			for (int i = 0; i < containers.length; i++) {
				containers[i].dispose();
			}
		}
		fSourceContainerMap.clear();
		super.dispose();
	}

	/**
	 * Returns the version of the OSGi runtime being debugged, based on the target platform.
	 * Cached per source lookup director.
	 * 
	 * @return OSGi runtime version
	 */
	double getOSGiRuntimeVersion() {
		if (fOSGiRuntimeVersion == Double.MIN_VALUE) {
			fOSGiRuntimeVersion = TargetPlatformHelper.getTargetVersion();
		}
		return fOSGiRuntimeVersion;
	}

}




/*******************************************************************************
 * Copyright (c) 2009 EclipseSource 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:
 *     EclipseSource Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.launching.IVMInstall;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.launching.environments.IExecutionEnvironment;
import org.eclipse.jdt.launching.environments.IExecutionEnvironmentsManager;
import org.eclipse.pde.core.plugin.IPluginModelBase;

public class ProductValidationOperation extends LaunchValidationOperation {

	private IPluginModelBase[] fModels;

	public ProductValidationOperation(IPluginModelBase[] models) {
		super(null);
		fModels = models;
	}

	protected IPluginModelBase[] getModels() throws CoreException {
		return fModels;
	}

	protected IExecutionEnvironment[] getMatchingEnvironments() throws CoreException {
		IVMInstall install = JavaRuntime.getDefaultVMInstall();

		IExecutionEnvironmentsManager manager = JavaRuntime.getExecutionEnvironmentsManager();
		IExecutionEnvironment[] envs = manager.getExecutionEnvironments();
		List result = new ArrayList(envs.length);
		for (int i = 0; i < envs.length; i++) {
			IExecutionEnvironment env = envs[i];
			IVMInstall[] compatible = env.getCompatibleVMs();
			for (int j = 0; j < compatible.length; j++) {
				if (compatible[j].equals(install)) {
					result.add(env);
					break;
				}
			}
		}
		return (IExecutionEnvironment[]) result.toArray(new IExecutionEnvironment[result.size()]);
	}

}

Lines 15-20 Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/PDELogFileProvider.java (+1 lines)
15	import java.util.*;	15	import java.util.*;
16	import org.eclipse.core.runtime.CoreException;	16	import org.eclipse.core.runtime.CoreException;
17	import org.eclipse.debug.core.*;	17	import org.eclipse.debug.core.*;
		18	import org.eclipse.pde.internal.launching.launcher.LaunchListener;
18	import org.eclipse.pde.ui.launcher.EclipseLaunchShortcut;	19	import org.eclipse.pde.ui.launcher.EclipseLaunchShortcut;
19	import org.eclipse.ui.internal.views.log.ILogFileProvider;	20	import org.eclipse.ui.internal.views.log.ILogFileProvider;
20	import org.eclipse.ui.statushandlers.StatusManager;	21	import org.eclipse.ui.statushandlers.StatusManager;




/*******************************************************************************
 * Copyright (c) 2005, 2009 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.launcher;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.*;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.*;
import org.eclipse.core.variables.IStringVariableManager;
import org.eclipse.core.variables.VariablesPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.launching.ExecutionArguments;
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.eclipse.pde.core.plugin.*;
import org.eclipse.pde.internal.build.IPDEBuildConstants;
import org.eclipse.pde.internal.core.*;
import org.eclipse.pde.internal.core.target.provisional.ITargetHandle;
import org.eclipse.pde.internal.core.target.provisional.ITargetPlatformService;
import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
import org.osgi.framework.Bundle;

public class LaunchArgumentsHelper {

	/**
	 * Returns the location that will be used as the workspace when launching.  Will
	 * replace variables, so this method should only be called
	 * when variable substitution (may prompt the user) is appropriate.
	 * @param configuration the launch configuration to get the workspace value for
	 * @return workspace location path as a string
	 * @throws CoreException if there is a problem with the configuration
	 */
	public static String getWorkspaceLocation(ILaunchConfiguration configuration) throws CoreException {
		String location = configuration.getAttribute(IPDELauncherConstants.LOCATION, (String) null);
		if (location == null) {
			// backward compatibility
			location = configuration.getAttribute(IPDELauncherConstants.LOCATION + "0", (String) null); //$NON-NLS-1$
			if (location != null) {
				ILaunchConfigurationWorkingCopy wc = null;
				if (configuration.isWorkingCopy()) {
					wc = (ILaunchConfigurationWorkingCopy) configuration;
				} else {
					wc = configuration.getWorkingCopy();
				}
				wc.setAttribute(IPDELauncherConstants.LOCATION + "0", (String) null); //$NON-NLS-1$
				wc.setAttribute(IPDELauncherConstants.LOCATION, location);
				wc.doSave();
			}
		}
		return getSubstitutedString(location);
	}

	public static String[] getUserProgramArgumentArray(ILaunchConfiguration configuration) throws CoreException {
		String args = getUserProgramArguments(configuration);
		return new ExecutionArguments("", args).getProgramArgumentsArray(); //$NON-NLS-1$
	}

	public static String getUserProgramArguments(ILaunchConfiguration configuration) throws CoreException {
		String args = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, (String) null);
		if (args == null) {
			// backward compatibility
			args = configuration.getAttribute("progargs", (String) null); //$NON-NLS-1$
			if (args != null) {
				ILaunchConfigurationWorkingCopy wc = null;
				if (configuration.isWorkingCopy()) {
					wc = (ILaunchConfigurationWorkingCopy) configuration;
				} else {
					wc = configuration.getWorkingCopy();
				}
				wc.setAttribute("progargs", (String) null); //$NON-NLS-1$
				wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, args);
				wc.doSave();
			}
		}
		return args == null ? "" : getSubstitutedString(args); //$NON-NLS-1$
	}

	public static String getUserVMArguments(ILaunchConfiguration configuration) throws CoreException {
		String args = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, (String) null);
		if (args == null) {
			// backward compatibility
			args = configuration.getAttribute("vmargs", (String) null); //$NON-NLS-1$
			if (args != null) {
				ILaunchConfigurationWorkingCopy wc = null;
				if (configuration.isWorkingCopy()) {
					wc = (ILaunchConfigurationWorkingCopy) configuration;
				} else {
					wc = configuration.getWorkingCopy();
				}
				wc.setAttribute("vmargs", (String) null); //$NON-NLS-1$
				wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, args);
				wc.doSave();
			}
		}
		return args == null ? "" : getSubstitutedString(args); //$NON-NLS-1$
	}

	/**
	 * Fetches the VM Arguments from the current Target Platform
	 *  
	 * @return	VM Arguments from the current Target Platform or empty string if none found
	 */
	public static String getInitialVMArguments() {

		try {
			ITargetPlatformService service = (ITargetPlatformService) PDECore.getDefault().acquireService(ITargetPlatformService.class.getName());
			if (service != null) {
				ITargetHandle target = service.getWorkspaceTargetHandle();
				if (target != null) {
					String result = target.getTargetDefinition().getVMArguments();
					result = result != null ? result : ""; //$NON-NLS-1$
					return result;
				}
			}
		} catch (CoreException e) {
		}

		// TODO: Generally, once the new preference target platform preference page is in use,
		// this code path will not be used. Once we decide to remove support for old targets/preferences
		// this code can be removed.
		PDEPreferencesManager preferences = PDECore.getDefault().getPreferencesManager();
		StringBuffer result = new StringBuffer(preferences.getString(ICoreConstants.VM_ARGS));

		if (preferences.getBoolean(ICoreConstants.VM_LAUNCHER_INI)) {
			// hack on the arguments from eclipse.ini
			result.append(TargetPlatformHelper.getIniVMArgs());
		}
		return result.toString();
	}

	public static String getInitialProgramArguments() {
		StringBuffer buffer = new StringBuffer("-os ${target.os} -ws ${target.ws} -arch ${target.arch} -nl ${target.nl}"); //$NON-NLS-1$

		PDEPreferencesManager preferences = PDECore.getDefault().getPreferencesManager();
		String programArgs = preferences.getString(ICoreConstants.PROGRAM_ARGS);
		if (programArgs.length() > 0) {
			buffer.append(" "); //$NON-NLS-1$
			buffer.append(programArgs);
		}
		return buffer.toString();
	}

	public static File getWorkingDirectory(ILaunchConfiguration configuration) throws CoreException {
		String working;
		try {
			working = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, new File(".").getCanonicalPath()); //$NON-NLS-1$
		} catch (IOException e) {
			working = "${workspace_loc}/../"; //$NON-NLS-1$
		}
		File dir = new File(getSubstitutedString(working));
		if (!dir.exists())
			dir.mkdirs();
		return dir;
	}

	public static Map getVMSpecificAttributesMap(ILaunchConfiguration config) throws CoreException {
		Map map = new HashMap(2);
		String javaCommand = config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_JAVA_COMMAND, (String) null);
		map.put(IJavaLaunchConfigurationConstants.ATTR_JAVA_COMMAND, javaCommand);
		if (TargetPlatform.getOS().equals("macosx")) { //$NON-NLS-1$
			ModelEntry entry = PluginRegistry.findEntry("org.eclipse.jdt.debug"); //$NON-NLS-1$
			if (entry != null) {
				IPluginModelBase[] models = entry.getExternalModels();
				for (int i = 0; i < models.length; i++) {
					File file = new File(models[i].getInstallLocation());
					if (!file.isFile())
						file = new File(file, "jdi.jar"); //$NON-NLS-1$
					if (file.exists()) {
						map.put(IJavaLaunchConfigurationConstants.ATTR_BOOTPATH_PREPEND, new String[] {file.getAbsolutePath()});
						break;
					}
				}
			}
		}
		return map;
	}

	public static String getTracingFileArgument(ILaunchConfiguration config, String optionsFileName) throws CoreException {
		try {
			TracingOptionsManager mng = PDECore.getDefault().getTracingOptionsManager();
			Map options = config.getAttribute(IPDELauncherConstants.TRACING_OPTIONS, (Map) null);
			String selected = config.getAttribute(IPDELauncherConstants.TRACING_CHECKED, (String) null);
			if (selected == null) {
				mng.save(optionsFileName, options);
			} else if (!selected.equals(IPDELauncherConstants.TRACING_NONE)) {
				HashSet result = new HashSet();
				StringTokenizer tokenizer = new StringTokenizer(selected, ","); //$NON-NLS-1$
				while (tokenizer.hasMoreTokens()) {
					result.add(tokenizer.nextToken());
				}
				mng.save(optionsFileName, options, result);
			}
		} catch (CoreException e) {
			return ""; //$NON-NLS-1$
		}
		return optionsFileName;
	}

	public static String[] constructClasspath(ILaunchConfiguration configuration) throws CoreException {
		double targetVersion = TargetPlatformHelper.getTargetVersion();
		String jarPath = targetVersion >= 3.3 ? getEquinoxStartupPath(IPDEBuildConstants.BUNDLE_EQUINOX_LAUNCHER) : getStartupJarPath();
		if (jarPath == null && targetVersion < 3.3)
			jarPath = getEquinoxStartupPath("org.eclipse.core.launcher"); //$NON-NLS-1$

		if (jarPath == null)
			return null;

		ArrayList entries = new ArrayList();
		entries.add(jarPath);

		String bootstrap = configuration.getAttribute(IPDELauncherConstants.BOOTSTRAP_ENTRIES, ""); //$NON-NLS-1$
		StringTokenizer tok = new StringTokenizer(getSubstitutedString(bootstrap), ","); //$NON-NLS-1$
		while (tok.hasMoreTokens())
			entries.add(tok.nextToken().trim());
		return (String[]) entries.toArray(new String[entries.size()]);
	}

	private static String getEquinoxStartupPath(String packageName) throws CoreException {
		IPluginModelBase model = PluginRegistry.findModel(IPDEBuildConstants.BUNDLE_EQUINOX_LAUNCHER);
		if (model != null) {
			IResource resource = model.getUnderlyingResource();
			// found in the target
			if (resource == null)
				return model.getInstallLocation();

			// find it in the workspace
			IProject project = resource.getProject();
			if (project.hasNature(JavaCore.NATURE_ID)) {
				IJavaProject jProject = JavaCore.create(project);
				IClasspathEntry[] entries = jProject.getRawClasspath();
				for (int i = 0; i < entries.length; i++) {
					int kind = entries[i].getEntryKind();
					if (kind == IClasspathEntry.CPE_SOURCE || kind == IClasspathEntry.CPE_LIBRARY) {
						IPackageFragmentRoot[] roots = jProject.findPackageFragmentRoots(entries[i]);
						for (int j = 0; j < roots.length; j++) {
							if (roots[j].getPackageFragment(packageName).exists()) {
								// if source folder, find the output folder
								if (kind == IClasspathEntry.CPE_SOURCE) {
									IPath path = entries[i].getOutputLocation();
									if (path == null)
										path = jProject.getOutputLocation();
									path = path.removeFirstSegments(1);
									return project.getLocation().append(path).toOSString();
								}
								// else if is a library jar, then get the location of the jar itself
								IResource jar = roots[j].getResource();
								if (jar != null) {
									return jar.getLocation().toOSString();
								}
							}
						}
					}
				}
			}
		}
		Bundle bundle = Platform.getBundle(IPDEBuildConstants.BUNDLE_EQUINOX_LAUNCHER);
		if (bundle != null) {
			try {
				URL url = FileLocator.resolve(bundle.getEntry("/")); //$NON-NLS-1$
				url = FileLocator.toFileURL(url);
				String path = url.getFile();
				if (path.startsWith("file:")) //$NON-NLS-1$
					path = path.substring(5);
				path = new File(path).getAbsolutePath();
				if (path.endsWith("!")) //$NON-NLS-1$
					path = path.substring(0, path.length() - 1);
				return path;
			} catch (IOException e) {
			}
		}
		return null;
	}

	private static String getStartupJarPath() throws CoreException {
		IPluginModelBase model = PluginRegistry.findModel("org.eclipse.platform"); //$NON-NLS-1$
		if (model != null && model.getUnderlyingResource() != null) {
			IProject project = model.getUnderlyingResource().getProject();
			if (project.hasNature(JavaCore.NATURE_ID)) {
				IJavaProject jProject = JavaCore.create(project);
				IPackageFragmentRoot[] roots = jProject.getPackageFragmentRoots();
				for (int i = 0; i < roots.length; i++) {
					if (roots[i].getKind() == IPackageFragmentRoot.K_SOURCE && roots[i].getPackageFragment("org.eclipse.core.launcher").exists()) { //$NON-NLS-1$
						IPath path = jProject.getOutputLocation().removeFirstSegments(1);
						return project.getLocation().append(path).toOSString();
					}
				}
			}
			if (project.getFile("startup.jar").exists()) //$NON-NLS-1$
				return project.getFile("startup.jar").getLocation().toOSString(); //$NON-NLS-1$
		}
		File startupJar = new Path(TargetPlatform.getLocation()).append("startup.jar").toFile(); //$NON-NLS-1$

		// if something goes wrong with the preferences, fall back on the startup.jar 
		// in the running eclipse.  
		if (!startupJar.exists())
			startupJar = new Path(TargetPlatform.getDefaultLocation()).append("startup.jar").toFile(); //$NON-NLS-1$

		return startupJar.exists() ? startupJar.getAbsolutePath() : null;
	}

	private static String getSubstitutedString(String text) throws CoreException {
		if (text == null)
			return ""; //$NON-NLS-1$
		IStringVariableManager mgr = VariablesPlugin.getDefault().getStringVariableManager();
		return mgr.performStringSubstitution(text);
	}

	public static String getDefaultWorkspaceLocation(String uniqueName) {
		return "${workspace_loc}/../runtime-" + uniqueName.replaceAll("\\s", ""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}

	public static String getDefaultJUnitWorkspaceLocation() {
		return "${workspace_loc}/../junit-workspace"; //$NON-NLS-1$
	}

	public static String getDefaultJUnitConfigurationLocation() {
		return "${workspace_loc}/.metadata/.plugins/org.eclipse.pde.core/pde-junit"; //$NON-NLS-1$
	}

}

Lines 12-17 Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/TracingBlock.java (-1 / +4 lines)
12	*******************************************************************************/	12	*******************************************************************************/
13	package org.eclipse.pde.internal.ui.launcher;	13	package org.eclipse.pde.internal.ui.launcher;
14		14
		15	import org.eclipse.pde.launching.IPDELauncherConstants;
		16
15	import java.util.*;	17	import java.util.*;
16	import org.eclipse.core.runtime.CoreException;	18	import org.eclipse.core.runtime.CoreException;
17	import org.eclipse.debug.core.ILaunchConfiguration;	19	import org.eclipse.debug.core.ILaunchConfiguration;
Lines 25-31 Link Here
25	import org.eclipse.pde.internal.ui.PDEUIMessages;	27	import org.eclipse.pde.internal.ui.PDEUIMessages;
26	import org.eclipse.pde.internal.ui.util.SWTUtil;	28	import org.eclipse.pde.internal.ui.util.SWTUtil;
27	import org.eclipse.pde.internal.ui.wizards.ListUtil;	29	import org.eclipse.pde.internal.ui.wizards.ListUtil;
28	import org.eclipse.pde.ui.launcher.*;	30	import org.eclipse.pde.ui.launcher.AbstractLauncherTab;
		31	import org.eclipse.pde.ui.launcher.TracingTab;
29	import org.eclipse.swt.SWT;	32	import org.eclipse.swt.SWT;
30	import org.eclipse.swt.custom.SashForm;	33	import org.eclipse.swt.custom.SashForm;
31	import org.eclipse.swt.events.SelectionAdapter;	34	import org.eclipse.swt.events.SelectionAdapter;




/*******************************************************************************
 * Copyright (c) 2006, 2009 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
 *     Stephan Herrmann - Bug 242461 - JSR045 support
 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import java.io.File;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.model.IValue;
import org.eclipse.debug.core.sourcelookup.ISourceContainer;
import org.eclipse.jdt.debug.core.*;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.osgi.service.resolver.State;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.core.TargetPlatformHelper;

public class PDESourceLookupQuery implements ISafeRunnable {

	protected static String OSGI_CLASSLOADER = "org.eclipse.osgi.internal.baseadaptor.DefaultClassLoader"; //$NON-NLS-1$
	private static String LEGACY_ECLIPSE_CLASSLOADER = "org.eclipse.core.runtime.adaptor.EclipseClassLoader"; //$NON-NLS-1$
	private static String MAIN_CLASS = "org.eclipse.core.launcher.Main"; //$NON-NLS-1$
	private static String MAIN_PLUGIN = "org.eclipse.platform"; //$NON-NLS-1$

	private Object fElement;
	private Object fResult;
	private PDESourceLookupDirector fDirector;

	public PDESourceLookupQuery(PDESourceLookupDirector director, Object object) {
		fElement = object;
		fDirector = director;
	}

	public void handleException(Throwable exception) {
	}

	public void run() throws Exception {
		IJavaReferenceType declaringType = null;
		String sourcePath = null;
		if (fElement instanceof IJavaStackFrame) {
			IJavaStackFrame stackFrame = (IJavaStackFrame) fElement;
			declaringType = stackFrame.getReferenceType();
			// under JSR 45 source path from the stack frame is more precise than anything derived from the type: 
			sourcePath = stackFrame.getSourcePath();
		} else if (fElement instanceof IJavaObject) {
			IJavaType javaType = ((IJavaObject) fElement).getJavaType();
			if (javaType instanceof IJavaReferenceType) {
				declaringType = (IJavaReferenceType) javaType;
			}
		} else if (fElement instanceof IJavaReferenceType) {
			declaringType = (IJavaReferenceType) fElement;
		}
		if (declaringType != null) {
			IJavaObject classLoaderObject = declaringType.getClassLoaderObject();
			String declaringTypeName = declaringType.getName();
			if (sourcePath == null) {
				String[] sourcePaths = declaringType.getSourcePaths(null);
				if (sourcePaths != null) {
					sourcePath = sourcePaths[0];
				}
				if (sourcePath == null) {
					sourcePath = generateSourceName(declaringTypeName);
				}
			}

			if (classLoaderObject != null) {
				IJavaClassType type = (IJavaClassType) classLoaderObject.getJavaType();
				if (OSGI_CLASSLOADER.equals(type.getName())) {
					if (fDirector.getOSGiRuntimeVersion() < 3.5) {
						fResult = findSourceElement34(classLoaderObject, sourcePath);
					} else {
						fResult = findSourceElement(classLoaderObject, sourcePath);
					}
				} else if (LEGACY_ECLIPSE_CLASSLOADER.equals(type.getName())) {
					fResult = findSourceElement_legacy(classLoaderObject, sourcePath);
				} else if (MAIN_CLASS.equals(declaringTypeName)) {
					IPluginModelBase model = PDECore.getDefault().getModelManager().findModel(MAIN_PLUGIN);
					if (model != null)
						fResult = getSourceElement(model.getInstallLocation(), MAIN_PLUGIN, sourcePath);
				}
			}
		}
	}

	protected Object getResult() {
		return fResult;
	}

	private String getValue(IJavaObject object, String variable) throws DebugException {
		IJavaFieldVariable var = object.getField(variable, false);
		return var == null ? null : var.getValue().getValueString();
	}

	/**
	 * Finds a source element in a 3.4 OSGi runtime.
	 * 
	 * @param object Bundle class loader object
	 * @param typeName fully qualified name of the source type being searched for
	 * @return source element
	 * @throws CoreException
	 */
	protected Object findSourceElement34(IJavaObject object, String typeName) throws CoreException {
		IJavaObject manager = getObject(object, "manager", false); //$NON-NLS-1$
		if (manager != null) {
			IJavaObject data = getObject(manager, "data", false); //$NON-NLS-1$
			if (data != null) {
				String location = getValue(data, "fileName"); //$NON-NLS-1$
				String id = getValue(data, "symbolicName"); //$NON-NLS-1$
				return getSourceElement(location, id, typeName);
			}
		}
		return null;
	}

	/**
	 * Finds source in a 3.5 runtime. In 3.5, the OSGi runtime provides hooks to properly
	 * lookup source in fragments that replace/prepend jars in their host.
	 * 
	 * @param object Bundle class loader object
	 * @param typeName fully qualified name of the source type being searched for 
	 * @return source element
	 * @throws CoreException
	 */
	protected Object findSourceElement(IJavaObject object, String typeName) throws CoreException {
		IJavaObject manager = getObject(object, "manager", false); //$NON-NLS-1$
		if (manager != null) {
			IJavaObject data = getObject(manager, "data", false); //$NON-NLS-1$
			if (data != null) {
				String id = getValue(data, "symbolicName"); //$NON-NLS-1$
				// search manager's class path for location
				Object result = searchClasspathEntries(manager, id, typeName);
				if (result != null) {
					return result;
				}
				// then check its fragments
				IJavaObject frgArray = getObject(manager, "fragments", false); //$NON-NLS-1$
				if (frgArray instanceof IJavaArray) {
					IJavaArray fragments = (IJavaArray) frgArray;
					for (int i = 0; i < fragments.getLength(); i++) {
						IJavaObject fragment = (IJavaObject) fragments.getValue(i);
						if (!fragment.isNull()) {
							// search fragment class path
							result = searchClasspathEntries(fragment, id, typeName);
							if (result != null) {
								return result;
							}
						}

					}
				}
			}
		}
		return null;
	}

	private Object searchClasspathEntries(IJavaObject entriesOwner, String id, String typeName) throws CoreException {
		IJavaObject cpeArray = getObject(entriesOwner, "entries", false); //$NON-NLS-1$
		if (cpeArray instanceof IJavaArray) {
			IJavaArray entries = (IJavaArray) cpeArray;
			for (int i = 0; i < entries.getLength(); i++) {
				IJavaObject entry = (IJavaObject) entries.getValue(i);
				if (!entry.isNull()) {
					IJavaObject baseData = getObject(entry, "data", false); //$NON-NLS-1$
					if (baseData != null && !baseData.isNull()) {
						IJavaObject fileName = getObject(baseData, "fileName", false); //$NON-NLS-1$
						if (fileName != null && !fileName.isNull()) {
							String location = fileName.getValueString();
							Object el = getSourceElement(location, id, typeName);
							if (el != null) {
								return el;
							}
						}
					}
				}
			}
		}
		return null;
	}

	private IJavaObject getObject(IJavaObject object, String field, boolean superfield) throws DebugException {
		IJavaFieldVariable variable = object.getField(field, superfield);
		if (variable != null) {
			IValue value = variable.getValue();
			if (value instanceof IJavaObject)
				return (IJavaObject) value;
		}
		return null;
	}

	private Object findSourceElement_legacy(IJavaObject object, String typeName) throws CoreException {
		IJavaObject hostdata = getObject(object, "hostdata", true); //$NON-NLS-1$
		if (hostdata != null) {
			String location = getValue(hostdata, "fileName"); //$NON-NLS-1$
			String id = getValue(hostdata, "symbolicName"); //$NON-NLS-1$
			return getSourceElement(location, id, typeName);
		}
		return null;
	}

	private Object getSourceElement(String location, String id, String typeName) throws CoreException {
		if (location != null && id != null) {
			Object result = findSourceElement(getSourceContainers(location, id), typeName);
			if (result != null)
				return result;

			// don't give up yet, search fragments attached to this host
			State state = TargetPlatformHelper.getState();
			BundleDescription desc = state.getBundle(id, null);
			if (desc != null) {
				BundleDescription[] fragments = desc.getFragments();
				for (int i = 0; i < fragments.length; i++) {
					location = fragments[i].getLocation();
					id = fragments[i].getSymbolicName();
					result = findSourceElement(getSourceContainers(location, id), typeName);
					if (result != null)
						return result;
				}
			}
		}
		return null;
	}

	private Object findSourceElement(ISourceContainer[] containers, String typeName) throws CoreException {
		for (int i = 0; i < containers.length; i++) {
			Object[] result = containers[i].findSourceElements(typeName);
			if (result.length > 0)
				return result[0];
		}
		return null;
	}

	protected ISourceContainer[] getSourceContainers(String location, String id) throws CoreException {
		return fDirector.getSourceContainers(location, id);
	}

	/**
	 * Generates and returns a source file path based on a qualified type name.
	 * For example, when <code>java.lang.String</code> is provided,
	 * the returned source name is <code>java/lang/String.java</code>.
	 * 
	 * @param qualifiedTypeName fully qualified type name that may contain inner types
	 *  denoted with <code>$</code> character
	 * @return a source file path corresponding to the type name
	 */
	private static String generateSourceName(String qualifiedTypeName) {
		int index = qualifiedTypeName.indexOf('$');
		if (index >= 0)
			qualifiedTypeName = qualifiedTypeName.substring(0, index);
		return qualifiedTypeName.replace('.', File.separatorChar) + ".java"; //$NON-NLS-1$
	}

}




/*******************************************************************************
 * Copyright (c) 2007, 2009 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
 *     EclipseSource Corporation - ongoing enhancements
 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.pde.core.plugin.IPluginModelBase;

public class OSGiValidationOperation extends LaunchValidationOperation {

	public OSGiValidationOperation(ILaunchConfiguration configuration) {
		super(configuration);
	}

	protected IPluginModelBase[] getModels() throws CoreException {
		return BundleLauncherHelper.getMergedBundles(fLaunchConfiguration, true);
	}

}

Lines 11-16 Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/LaunchAction.java (-4 / +10 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.pde.internal.ui.launcher;	12	package org.eclipse.pde.internal.ui.launcher;
13		13
		14	import org.eclipse.pde.launching.*;
		15	import org.eclipse.pde.ui.launcher.EclipseLaunchShortcut;
		16
14	import java.io.File;	17	import java.io.File;
15	import java.util.*;	18	import java.util.*;
16	import org.eclipse.core.resources.IResource;	19	import org.eclipse.core.resources.IResource;
Lines 28-35 Link Here
28	import org.eclipse.pde.internal.core.iproduct.*;	31	import org.eclipse.pde.internal.core.iproduct.*;
29	import org.eclipse.pde.internal.core.iproduct.IProduct;	32	import org.eclipse.pde.internal.core.iproduct.IProduct;
30	import org.eclipse.pde.internal.core.util.CoreUtility;	33	import org.eclipse.pde.internal.core.util.CoreUtility;
31	import org.eclipse.pde.internal.ui.*;	34	import org.eclipse.pde.internal.launching.IPDEConstants;
32	import org.eclipse.pde.ui.launcher.*;	35	import org.eclipse.pde.internal.launching.launcher.BundleLauncherHelper;
		36	import org.eclipse.pde.internal.launching.launcher.LaunchArgumentsHelper;
		37	import org.eclipse.pde.internal.ui.PDEPlugin;
		38	import org.eclipse.pde.internal.ui.PDEUIMessages;
33	import org.eclipse.ui.dialogs.ElementListSelectionDialog;	39	import org.eclipse.ui.dialogs.ElementListSelectionDialog;
34		40
35	public class LaunchAction extends Action {	41	public class LaunchAction extends Action {
Lines 263-270 Link Here
263	wc.setAttribute(IPDELauncherConstants.USEFEATURES, false);	269	wc.setAttribute(IPDELauncherConstants.USEFEATURES, false);
264	wc.setAttribute(IPDELauncherConstants.USE_DEFAULT, false);	270	wc.setAttribute(IPDELauncherConstants.USE_DEFAULT, false);
265	wc.setAttribute(IPDELauncherConstants.DOCLEAR, false);	271	wc.setAttribute(IPDELauncherConstants.DOCLEAR, false);
266	wc.setAttribute(IPDEUIConstants.DOCLEARLOG, false);	272	wc.setAttribute(IPDEConstants.DOCLEARLOG, false);
267	wc.setAttribute(IPDEUIConstants.APPEND_ARGS_EXPLICITLY, true);	273	wc.setAttribute(IPDEConstants.APPEND_ARGS_EXPLICITLY, true);
268	wc.setAttribute(IPDELauncherConstants.ASKCLEAR, true);	274	wc.setAttribute(IPDELauncherConstants.ASKCLEAR, true);
269	wc.setAttribute(IPDELauncherConstants.USE_PRODUCT, true);	275	wc.setAttribute(IPDELauncherConstants.USE_PRODUCT, true);
270	wc.setAttribute(IPDELauncherConstants.AUTOMATIC_ADD, false);	276	wc.setAttribute(IPDELauncherConstants.AUTOMATIC_ADD, false);




/*******************************************************************************
 * Copyright (c) 2006, 2009 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.launcher;

import java.util.*;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.eclipse.pde.internal.core.*;
import org.eclipse.pde.internal.ui.IPDEUIConstants;
import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
import org.eclipse.pde.ui.launcher.OSGiLaunchConfigurationInitializer;

public class EquinoxInitializer extends OSGiLaunchConfigurationInitializer {

	private Map fStartLevels;

	public void initialize(ILaunchConfigurationWorkingCopy configuration) {
		super.initialize(configuration);
		initializeProgramArguments(configuration);
		initializeVMArguments(configuration);
		initializeTracing(configuration);
	}

	private void initializeProgramArguments(ILaunchConfigurationWorkingCopy configuration) {
		StringBuffer buffer = new StringBuffer(LaunchArgumentsHelper.getInitialProgramArguments());
		if (buffer.length() > 0) {
			if (buffer.indexOf("-console") == -1) { //$NON-NLS-1$
				buffer.append(" -console"); //$NON-NLS-1$
			}
		} else {
			buffer.append("-console"); //$NON-NLS-1$
		}
		configuration.setAttribute(IPDEUIConstants.APPEND_ARGS_EXPLICITLY, true);
		configuration.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, buffer.toString());
	}

	private void initializeVMArguments(ILaunchConfigurationWorkingCopy configuration) {
		configuration.setAttribute(IPDEUIConstants.LAUNCHER_PDE_VERSION, "3.3"); //$NON-NLS-1$
		PDEPreferencesManager preferences = PDECore.getDefault().getPreferencesManager();
		StringBuffer vmArgs = new StringBuffer(preferences.getString(ICoreConstants.VM_ARGS));
		if (vmArgs.indexOf("-Declipse.ignoreApp") == -1) { //$NON-NLS-1$
			if (vmArgs.length() > 0)
				vmArgs.append(" "); //$NON-NLS-1$
			vmArgs.append("-Declipse.ignoreApp=true"); //$NON-NLS-1$
		}
		if (vmArgs.indexOf("-Dosgi.noShutdown") == -1) { //$NON-NLS-1$
			vmArgs.append(" -Dosgi.noShutdown=true"); //$NON-NLS-1$
		}
		configuration.setAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, vmArgs.toString());
	}

	private void initializeTracing(ILaunchConfigurationWorkingCopy configuration) {
		configuration.setAttribute(IPDELauncherConstants.TRACING_CHECKED, IPDELauncherConstants.TRACING_NONE);
	}

	protected void initializeBundleState(ILaunchConfigurationWorkingCopy configuration) {
		initializeBundleState();
		super.initializeBundleState(configuration);
	}

	protected String getAutoStart(String bundleID) {
		if (fStartLevels.containsKey(bundleID)) {
			String value = fStartLevels.get(bundleID).toString();
			return value.substring(value.indexOf(":") + 1); //$NON-NLS-1$
		}
		return super.getAutoStart(bundleID);
	}

	protected String getStartLevel(String bundleID) {
		if (fStartLevels.containsKey(bundleID)) {
			String value = fStartLevels.get(bundleID).toString();
			return value.substring(0, value.indexOf(":")); //$NON-NLS-1$
		}
		return super.getStartLevel(bundleID);
	}

	private void initializeBundleState() {
		if (fStartLevels == null)
			fStartLevels = new HashMap();
		Properties props = TargetPlatformHelper.getConfigIniProperties();
		if (props != null) {
			String value = (String) props.get("osgi.bundles"); //$NON-NLS-1$
			if (value != null) {
				StringTokenizer tokenizer = new StringTokenizer(value, ","); //$NON-NLS-1$
				while (tokenizer.hasMoreTokens()) {
					String tokenValue = tokenizer.nextToken();
					int index = tokenValue.indexOf("@"); //$NON-NLS-1$
					if (index > 0) {
						String bundle = tokenValue.substring(0, index).trim();
						fStartLevels.put(bundle, getStartValue(tokenValue.substring(index)));
					}
				}
			}
		}
	}

	private String getStartValue(String value) {
		StringBuffer buffer = new StringBuffer(value);
		StringBuffer result = new StringBuffer(":"); //$NON-NLS-1$

		int index = value.indexOf("start"); //$NON-NLS-1$
		result.append(Boolean.toString(index != -1));

		if (index != -1)
			buffer.delete(index, index + 5);

		int colon = value.indexOf(':');
		if (colon != -1)
			buffer.deleteCharAt(colon);

		// delete the first char '@'
		buffer.deleteCharAt(0);

		try {
			result.insert(0, Integer.parseInt(buffer.toString().trim()));
		} catch (NumberFormatException e) {
			result.insert(0, DEFAULT);
		}
		return result.toString();
	}

}




/*******************************************************************************
 * Copyright (c) 2007, 2009 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
 *     EclipseSource Corporation - ongoing enhancements
 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import java.util.*;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.pde.core.plugin.*;
import org.eclipse.pde.internal.build.IPDEBuildConstants;
import org.eclipse.pde.internal.core.TargetPlatformHelper;
import org.eclipse.pde.internal.ui.IPDEUIConstants;
import org.eclipse.pde.ui.launcher.IPDELauncherConstants;

public class BundleLauncherHelper {

	public static final char VERSION_SEPARATOR = '*';

	public static Map getWorkspaceBundleMap(ILaunchConfiguration configuration) throws CoreException {
		return getWorkspaceBundleMap(configuration, null, IPDELauncherConstants.WORKSPACE_BUNDLES);
	}

	public static Map getTargetBundleMap(ILaunchConfiguration configuration) throws CoreException {
		return getTargetBundleMap(configuration, null, IPDELauncherConstants.TARGET_BUNDLES);
	}

	public static Map getMergedBundleMap(ILaunchConfiguration configuration, boolean osgi) throws CoreException {
		Set set = new HashSet();
		Map map = new HashMap();

		// if we are using the eclipse-based launcher, we need special checks
		if (!osgi) {

			checkBackwardCompatibility(configuration, true);

			if (configuration.getAttribute(IPDELauncherConstants.USE_DEFAULT, true)) {
				IPluginModelBase[] models = PluginRegistry.getActiveModels();
				for (int i = 0; i < models.length; i++) {
					addBundleToMap(map, models[i], "default:default"); //$NON-NLS-1$
				}
				return map;
			}

			if (configuration.getAttribute(IPDELauncherConstants.USEFEATURES, false)) {
				IPluginModelBase[] models = PluginRegistry.getWorkspaceModels();
				for (int i = 0; i < models.length; i++) {
					addBundleToMap(map, models[i], "default:default"); //$NON-NLS-1$
				}
				return map;
			}
		}

		String workspace = osgi == false ? IPDELauncherConstants.SELECTED_WORKSPACE_PLUGINS : IPDELauncherConstants.WORKSPACE_BUNDLES;
		String target = osgi == false ? IPDELauncherConstants.SELECTED_TARGET_PLUGINS : IPDELauncherConstants.TARGET_BUNDLES;
		map = getWorkspaceBundleMap(configuration, set, workspace);
		map.putAll(getTargetBundleMap(configuration, set, target));
		return map;
	}

	public static IPluginModelBase[] getMergedBundles(ILaunchConfiguration configuration, boolean osgi) throws CoreException {
		Map map = getMergedBundleMap(configuration, osgi);
		return (IPluginModelBase[]) map.keySet().toArray(new IPluginModelBase[map.size()]);
	}

	public static Map getWorkspaceBundleMap(ILaunchConfiguration configuration, Set set, String attribute) throws CoreException {
		String selected = configuration.getAttribute(attribute, ""); //$NON-NLS-1$
		Map map = new HashMap();
		StringTokenizer tok = new StringTokenizer(selected, ","); //$NON-NLS-1$
		while (tok.hasMoreTokens()) {
			String token = tok.nextToken();
			int index = token.indexOf('@');
			if (index < 0) { // if no start levels, assume default
				token = token.concat("@default:default"); //$NON-NLS-1$
				index = token.indexOf('@');
			}
			String idVersion = token.substring(0, index);
			int versionIndex = idVersion.indexOf(VERSION_SEPARATOR);
			String id = (versionIndex > 0) ? idVersion.substring(0, versionIndex) : idVersion;
			String version = (versionIndex > 0) ? idVersion.substring(versionIndex + 1) : null;
			if (set != null)
				set.add(id);
			ModelEntry entry = PluginRegistry.findEntry(id);
			if (entry != null) {
				IPluginModelBase[] models = entry.getWorkspaceModels();
				for (int i = 0; i < models.length; i++) {
					IPluginBase base = models[i].getPluginBase();

					// match only if...
					// a) if we have the same version
					// b) no version
					// c) all else fails, if there's just one bundle available, use it
					if (base.getVersion().equals(version) || version == null || models.length == 1)
						addBundleToMap(map, models[i], token.substring(index + 1));
				}
			}
		}

		if (configuration.getAttribute(IPDELauncherConstants.AUTOMATIC_ADD, true)) {
			Set deselectedPlugins = LaunchPluginValidator.parsePlugins(configuration, IPDELauncherConstants.DESELECTED_WORKSPACE_PLUGINS);
			IPluginModelBase[] models = PluginRegistry.getWorkspaceModels();
			for (int i = 0; i < models.length; i++) {
				String id = models[i].getPluginBase().getId();
				if (id == null)
					continue;
				if (!deselectedPlugins.contains(models[i])) {
					if (set != null)
						set.add(id);
					if (!map.containsKey(models[i]))
						addBundleToMap(map, models[i], "default:default"); //$NON-NLS-1$
				}
			}
		}
		return map;
	}

	/**
	 * Adds the given bundle and start information to the map.  This will override anything set
	 * for system bundles, and set their start level to the appropriate level
	 * @param map The map to add the bundles too
	 * @param bundle The bundle to add
	 * @param substring the start information in the form level:autostart
	 */
	private static void addBundleToMap(Map map, IPluginModelBase bundle, String sl) {
		BundleDescription desc = bundle.getBundleDescription();
		boolean defaultsl = (sl == null || sl.equals("default:default")); //$NON-NLS-1$
		if (desc != null && defaultsl) {
			String modelName = desc.getSymbolicName();
			if (IPDEBuildConstants.BUNDLE_DS.equals(modelName)) {
				map.put(bundle, "1:true"); //$NON-NLS-1$ 
			} else if (IPDEBuildConstants.BUNDLE_SIMPLE_CONFIGURATOR.equals(modelName)) {
				map.put(bundle, "1:true"); //$NON-NLS-1$
			} else if (IPDEBuildConstants.BUNDLE_EQUINOX_COMMON.equals(modelName)) {
				map.put(bundle, "2:true"); //$NON-NLS-1$
			} else if (IPDEBuildConstants.BUNDLE_OSGI.equals(modelName)) {
				map.put(bundle, "-1:true"); //$NON-NLS-1$
			} else if (IPDEBuildConstants.BUNDLE_UPDATE_CONFIGURATOR.equals(modelName)) {
				map.put(bundle, "3:true"); //$NON-NLS-1$
			} else if (IPDEBuildConstants.BUNDLE_CORE_RUNTIME.equals(modelName)) {
				if (TargetPlatformHelper.getTargetVersion() > 3.1) {
					map.put(bundle, "default:true"); //$NON-NLS-1$
				} else {
					map.put(bundle, "2:true"); //$NON-NLS-1$
				}
			} else {
				map.put(bundle, sl);
			}
		} else {
			map.put(bundle, sl);
		}

	}

	public static Map getTargetBundleMap(ILaunchConfiguration configuration, Set set, String attribute) throws CoreException {
		String selected = configuration.getAttribute(attribute, ""); //$NON-NLS-1$
		Map map = new HashMap();
		StringTokenizer tok = new StringTokenizer(selected, ","); //$NON-NLS-1$
		while (tok.hasMoreTokens()) {
			String token = tok.nextToken();
			int index = token.indexOf('@');
			if (index < 0) { // if no start levels, assume default
				token = token.concat("@default:default"); //$NON-NLS-1$
				index = token.indexOf('@');
			}
			String idVersion = token.substring(0, index);
			int versionIndex = idVersion.indexOf(VERSION_SEPARATOR);
			String id = (versionIndex > 0) ? idVersion.substring(0, versionIndex) : idVersion;
			String version = (versionIndex > 0) ? idVersion.substring(versionIndex + 1) : null;
			if (set != null && set.contains(id))
				continue;
			ModelEntry entry = PluginRegistry.findEntry(id);
			if (entry != null) {
				IPluginModelBase[] models = entry.getExternalModels();
				for (int i = 0; i < models.length; i++) {
					if (models[i].isEnabled()) {
						IPluginBase base = models[i].getPluginBase();
						// match only if...
						// a) if we have the same version
						// b) no version
						// c) all else fails, if there's just one bundle available, use it
						if (base.getVersion().equals(version) || version == null || models.length == 1)
							addBundleToMap(map, models[i], token.substring(index + 1));
					}
				}
			}
		}
		return map;
	}

	public static String writeBundleEntry(IPluginModelBase model, String startLevel, String autoStart) {
		IPluginBase base = model.getPluginBase();
		String id = base.getId();
		StringBuffer buffer = new StringBuffer(id);

		ModelEntry entry = PluginRegistry.findEntry(id);
		if (entry.getActiveModels().length > 1) {
			buffer.append(VERSION_SEPARATOR);
			buffer.append(model.getPluginBase().getVersion());
		}

		boolean hasStartLevel = (startLevel != null && startLevel.length() > 0);
		boolean hasAutoStart = (autoStart != null && autoStart.length() > 0);

		if (hasStartLevel || hasAutoStart)
			buffer.append('@');
		if (hasStartLevel)
			buffer.append(startLevel);
		if (hasStartLevel || hasAutoStart)
			buffer.append(':');
		if (hasAutoStart)
			buffer.append(autoStart);
		return buffer.toString();
	}

	public static void checkBackwardCompatibility(ILaunchConfiguration configuration, boolean save) throws CoreException {
		ILaunchConfigurationWorkingCopy wc = null;
		if (configuration.isWorkingCopy()) {
			wc = (ILaunchConfigurationWorkingCopy) configuration;
		} else {
			wc = configuration.getWorkingCopy();
		}

		String value = configuration.getAttribute("wsproject", (String) null); //$NON-NLS-1$
		if (value != null) {
			wc.setAttribute("wsproject", (String) null); //$NON-NLS-1$
			if (value.indexOf(';') != -1) {
				value = value.replace(';', ',');
			} else if (value.indexOf(':') != -1) {
				value = value.replace(':', ',');
			}
			value = (value.length() == 0 || value.equals(",")) //$NON-NLS-1$
			? null
					: value.substring(0, value.length() - 1);

			boolean automatic = configuration.getAttribute(IPDELauncherConstants.AUTOMATIC_ADD, true);
			String attr = automatic ? IPDELauncherConstants.DESELECTED_WORKSPACE_PLUGINS : IPDELauncherConstants.SELECTED_WORKSPACE_PLUGINS;
			wc.setAttribute(attr, value);
		}

		String value2 = configuration.getAttribute("extplugins", (String) null); //$NON-NLS-1$
		if (value2 != null) {
			wc.setAttribute("extplugins", (String) null); //$NON-NLS-1$
			if (value2.indexOf(';') != -1) {
				value2 = value2.replace(';', ',');
			} else if (value2.indexOf(':') != -1) {
				value2 = value2.replace(':', ',');
			}
			value2 = (value2.length() == 0 || value2.equals(",")) ? null : value2.substring(0, value2.length() - 1); //$NON-NLS-1$
			wc.setAttribute(IPDELauncherConstants.SELECTED_TARGET_PLUGINS, value2);
		}

		String version = configuration.getAttribute(IPDEUIConstants.LAUNCHER_PDE_VERSION, (String) null);
		boolean newApp = TargetPlatformHelper.usesNewApplicationModel();
		boolean upgrade = !"3.3".equals(version) && newApp; //$NON-NLS-1$
		if (!upgrade)
			upgrade = TargetPlatformHelper.getTargetVersion() >= 3.2 && version == null;
		if (upgrade) {
			wc.setAttribute(IPDEUIConstants.LAUNCHER_PDE_VERSION, newApp ? "3.3" : "3.2a"); //$NON-NLS-1$ //$NON-NLS-2$
			boolean usedefault = configuration.getAttribute(IPDELauncherConstants.USE_DEFAULT, true);
			boolean useFeatures = configuration.getAttribute(IPDELauncherConstants.USEFEATURES, false);
			boolean automaticAdd = configuration.getAttribute(IPDELauncherConstants.AUTOMATIC_ADD, true);
			if (!usedefault && !useFeatures) {
				ArrayList list = new ArrayList();
				if (version == null) {
					list.add("org.eclipse.core.contenttype"); //$NON-NLS-1$
					list.add("org.eclipse.core.jobs"); //$NON-NLS-1$
					list.add(IPDEBuildConstants.BUNDLE_EQUINOX_COMMON);
					list.add("org.eclipse.equinox.preferences"); //$NON-NLS-1$
					list.add("org.eclipse.equinox.registry"); //$NON-NLS-1$
					list.add("org.eclipse.core.runtime.compatibility.registry"); //$NON-NLS-1$
				}
				if (!"3.3".equals(version) && newApp) //$NON-NLS-1$
					list.add("org.eclipse.equinox.app"); //$NON-NLS-1$
				StringBuffer extensions = new StringBuffer(configuration.getAttribute(IPDELauncherConstants.SELECTED_WORKSPACE_PLUGINS, "")); //$NON-NLS-1$
				StringBuffer target = new StringBuffer(configuration.getAttribute(IPDELauncherConstants.SELECTED_TARGET_PLUGINS, "")); //$NON-NLS-1$
				for (int i = 0; i < list.size(); i++) {
					String plugin = list.get(i).toString();
					IPluginModelBase model = PluginRegistry.findModel(plugin);
					if (model == null)
						continue;
					if (model.getUnderlyingResource() != null) {
						if (automaticAdd)
							continue;
						if (extensions.length() > 0)
							extensions.append(","); //$NON-NLS-1$
						extensions.append(plugin);
					} else {
						if (target.length() > 0)
							target.append(","); //$NON-NLS-1$
						target.append(plugin);
					}
				}
				if (extensions.length() > 0)
					wc.setAttribute(IPDELauncherConstants.SELECTED_WORKSPACE_PLUGINS, extensions.toString());
				if (target.length() > 0)
					wc.setAttribute(IPDELauncherConstants.SELECTED_TARGET_PLUGINS, target.toString());
			}
		}

		if (save && (value != null || value2 != null || upgrade))
			wc.doSave();
	}

}




/*******************************************************************************
 *  Copyright (c) 2007, 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.launcher;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.eclipse.pde.internal.ui.IPDEUIConstants;

public class OSGiMigrationDelegate extends PDEMigrationDelegate {

	public boolean isCandidate(ILaunchConfiguration candidate) throws CoreException {
		return super.isCandidate(candidate) || !candidate.getAttribute(IPDEUIConstants.LAUNCHER_PDE_VERSION, "").equals("3.3"); //$NON-NLS-1$ //$NON-NLS-2$
	}

	public void migrate(ILaunchConfigurationWorkingCopy wc) throws CoreException {
		if (!wc.getAttribute(IPDEUIConstants.LAUNCHER_PDE_VERSION, "").equals("3.3")) { //$NON-NLS-1$ //$NON-NLS-2$
			wc.setAttribute(IPDEUIConstants.LAUNCHER_PDE_VERSION, "3.3"); //$NON-NLS-1$
			StringBuffer vmArgs = new StringBuffer(wc.getAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, "")); //$NON-NLS-1$
			if (vmArgs.indexOf("-Declipse.ignoreApp") == -1) { //$NON-NLS-1$
				if (vmArgs.length() > 0)
					vmArgs.append(" "); //$NON-NLS-1$
				vmArgs.append("-Declipse.ignoreApp=true"); //$NON-NLS-1$
			}
			if (vmArgs.indexOf("-Dosgi.noShutdown") == -1) { //$NON-NLS-1$
				vmArgs.append(" -Dosgi.noShutdown=true"); //$NON-NLS-1$
			}
			wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, vmArgs.toString());
		}
		super.migrate(wc);
	}

}




/*******************************************************************************
 * 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
 *     Les Jones <lesojones@gmail.com> - Bug 195433
 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import org.eclipse.core.runtime.*;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.launching.*;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.internal.core.util.VMUtil;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.pde.ui.launcher.IPDELauncherConstants;

public class VMHelper {

	/**
	 * Get the default VMInstall name using the available info in the config,
	 * using the JavaProject if available.
	 * 
	 * @param configuration
	 *            Launch configuration to check
	 * @return name of the VMInstall
	 * @throws CoreException
	 *             thrown if there's a problem getting the VM name
	 */
	public static String getDefaultVMInstallName(ILaunchConfiguration configuration) throws CoreException {
		IJavaProject javaProject = JavaRuntime.getJavaProject(configuration);
		IVMInstall vmInstall = null;
		if (javaProject != null) {
			vmInstall = JavaRuntime.getVMInstall(javaProject);
		}

		if (vmInstall != null) {
			return vmInstall.getName();
		}

		return VMUtil.getDefaultVMInstallName();
	}

	public static IVMInstall getVMInstall(ILaunchConfiguration configuration) throws CoreException {
		String jre = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_JRE_CONTAINER_PATH, (String) null);
		IVMInstall vm = null;
		if (jre == null) {
			String name = configuration.getAttribute(IPDELauncherConstants.VMINSTALL, (String) null);
			if (name == null) {
				name = getDefaultVMInstallName(configuration);
			}
			vm = getVMInstall(name);
			if (vm == null) {
				throw new CoreException(LauncherUtils.createErrorStatus(NLS.bind(PDEUIMessages.WorkbenchLauncherConfigurationDelegate_noJRE, name)));
			}
		} else {
			IPath jrePath = Path.fromPortableString(jre);
			vm = JavaRuntime.getVMInstall(jrePath);
			if (vm == null) {
				String id = JavaRuntime.getExecutionEnvironmentId(jrePath);
				if (id == null) {
					String name = JavaRuntime.getVMInstallName(jrePath);
					throw new CoreException(LauncherUtils.createErrorStatus(NLS.bind(PDEUIMessages.WorkbenchLauncherConfigurationDelegate_noJRE, name)));
				}
				throw new CoreException(LauncherUtils.createErrorStatus(NLS.bind(PDEUIMessages.VMHelper_cannotFindExecEnv, id)));
			}
		}
		return vm;
	}

	public static IVMInstall getVMInstall(String name) {
		if (name != null) {
			IVMInstall[] installs = VMUtil.getAllVMInstances();
			for (int i = 0; i < installs.length; i++) {
				if (installs[i].getName().equals(name))
					return installs[i];
			}
		}
		return JavaRuntime.getDefaultVMInstall();
	}

	public static IVMInstall createLauncher(ILaunchConfiguration configuration) throws CoreException {
		IVMInstall launcher = getVMInstall(configuration);
		if (!launcher.getInstallLocation().exists())
			throw new CoreException(LauncherUtils.createErrorStatus(PDEUIMessages.WorkbenchLauncherConfigurationDelegate_jrePathNotFound));
		return launcher;
	}

}




/*******************************************************************************
 *  Copyright (c) 2007, 2009 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.launcher;

import java.io.*;
import java.util.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.jdt.launching.IVMInstall;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.launching.environments.IExecutionEnvironment;
import org.eclipse.jdt.launching.environments.IExecutionEnvironmentsManager;
import org.eclipse.osgi.service.resolver.State;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.PluginRegistry;
import org.eclipse.pde.internal.core.BundleValidationOperation;
import org.eclipse.pde.internal.core.TargetPlatformHelper;
import org.osgi.framework.Constants;

public abstract class LaunchValidationOperation implements IWorkspaceRunnable {

	private BundleValidationOperation fOperation;
	protected ILaunchConfiguration fLaunchConfiguration;

	public LaunchValidationOperation(ILaunchConfiguration configuration) {
		fLaunchConfiguration = configuration;
	}

	public void run(IProgressMonitor monitor) throws CoreException {
		fOperation = new BundleValidationOperation(getModels(), getPlatformProperties());
		fOperation.run(monitor);
	}

	protected abstract IPluginModelBase[] getModels() throws CoreException;

	protected Dictionary[] getPlatformProperties() throws CoreException {
		IExecutionEnvironment[] envs = getMatchingEnvironments();
		if (envs.length == 0)
			return new Dictionary[] {TargetPlatformHelper.getTargetEnvironment()};

		// add java profiles for those EE's that have a .profile file in the current system bundle
		ArrayList result = new ArrayList(envs.length);
		for (int i = 0; i < envs.length; i++) {
			Properties profileProps = getJavaProfileProperties(envs[i].getId());
			if (profileProps != null) {
				Dictionary props = TargetPlatformHelper.getTargetEnvironment();
				String systemPackages = profileProps.getProperty(Constants.FRAMEWORK_SYSTEMPACKAGES);
				if (systemPackages != null)
					props.put(Constants.FRAMEWORK_SYSTEMPACKAGES, systemPackages);
				String ee = profileProps.getProperty(Constants.FRAMEWORK_EXECUTIONENVIRONMENT);
				if (ee != null)
					props.put(Constants.FRAMEWORK_EXECUTIONENVIRONMENT, ee);
				result.add(props);
			}
		}
		if (result.size() > 0)
			return (Dictionary[]) result.toArray(new Dictionary[result.size()]);
		return new Dictionary[] {TargetPlatformHelper.getTargetEnvironment()};

	}

	protected IExecutionEnvironment[] getMatchingEnvironments() throws CoreException {
		IVMInstall install = VMHelper.getVMInstall(fLaunchConfiguration);
		if (install == null)
			return new IExecutionEnvironment[0];

		IExecutionEnvironmentsManager manager = JavaRuntime.getExecutionEnvironmentsManager();
		IExecutionEnvironment[] envs = manager.getExecutionEnvironments();
		List result = new ArrayList(envs.length);
		for (int i = 0; i < envs.length; i++) {
			IExecutionEnvironment env = envs[i];
			IVMInstall[] compatible = env.getCompatibleVMs();
			for (int j = 0; j < compatible.length; j++) {
				if (compatible[j].equals(install)) {
					result.add(env);
					break;
				}
			}
		}
		return (IExecutionEnvironment[]) result.toArray(new IExecutionEnvironment[result.size()]);
	}

	private Properties getJavaProfileProperties(String ee) {
		IPluginModelBase model = PluginRegistry.findModel("system.bundle"); //$NON-NLS-1$
		if (model == null)
			return null;

		File location = new File(model.getInstallLocation());
		String filename = ee.replace('/', '_') + ".profile"; //$NON-NLS-1$
		InputStream is = null;
		ZipFile zipFile = null;
		try {
			// find the input stream to the profile properties file
			if (location.isDirectory()) {
				File file = new File(location, filename);
				if (file.exists())
					is = new FileInputStream(file);
			} else {
				zipFile = null;
				try {
					zipFile = new ZipFile(location, ZipFile.OPEN_READ);
					ZipEntry entry = zipFile.getEntry(filename);
					if (entry != null)
						is = zipFile.getInputStream(entry);
				} catch (IOException e) {
					// nothing to do
				}
			}
			if (is != null) {
				Properties profile = new Properties();
				profile.load(is);
				return profile;
			}
		} catch (IOException e) {
			// nothing to do
		} finally {
			if (is != null)
				try {
					is.close();
				} catch (IOException e) {
					// nothing to do
				}
			if (zipFile != null)
				try {
					zipFile.close();
				} catch (IOException e) {
					// nothing to do
				}
		}
		return null;
	}

	public boolean hasErrors() {
		return fOperation.hasErrors();
	}

	public Map getInput() {
		return fOperation.getResolverErrors();
	}

	public boolean isEmpty() {
		return fOperation.getState().getHighestBundleId() == -1;
	}

	protected State getState() {
		return fOperation.getState();
	}

}




/*******************************************************************************
 *  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.launcher;

import java.io.File;
import org.eclipse.debug.core.*;
import org.eclipse.pde.internal.core.util.CoreUtility;

public class LaunchConfigurationListener implements ILaunchConfigurationListener {

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchConfigurationListener#launchConfigurationAdded(org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public void launchConfigurationAdded(ILaunchConfiguration configuration) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchConfigurationListener#launchConfigurationChanged(org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public void launchConfigurationChanged(ILaunchConfiguration configuration) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchConfigurationListener#launchConfigurationRemoved(org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public void launchConfigurationRemoved(ILaunchConfiguration configuration) {
		File configDir = LaunchConfigurationHelper.getConfigurationLocation(configuration);
		if (configDir.exists()) {
			// rename the config area if it was auto-set by PDE when the launch configuration is renamed
			ILaunchConfiguration destination = DebugPlugin.getDefault().getLaunchManager().getMovedTo(configuration);
			boolean delete = true;
			if (destination != null) {
				delete = !configDir.renameTo(LaunchConfigurationHelper.getConfigurationLocation(destination));
			}
			if (delete)
				CoreUtility.deleteContent(configDir);
		}
	}

}




 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import org.eclipse.pde.launching.*;
import org.eclipse.pde.ui.launcher.AbstractLauncherTab;
import org.eclipse.pde.ui.launcher.EclipseLaunchShortcut;

import java.util.*;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.pde.core.plugin.*;
import org.eclipse.pde.internal.core.util.IdUtil;
import org.eclipse.pde.internal.launching.IPDEConstants;
import org.eclipse.pde.internal.launching.launcher.*;

public class PluginBlock extends AbstractPluginBlock {


				String configType = fLaunchConfig.getType().getIdentifier();
				String attribute = configType.equals(EclipseLaunchShortcut.CONFIGURATION_TYPE) ? IPDELauncherConstants.APPLICATION : IPDELauncherConstants.APP_TO_TEST;
				String application = fLaunchConfig.getAttribute(attribute, TargetPlatform.getDefaultApplication());
				if (!IPDEConstants.CORE_TEST_APPLICATION.equals(application))
					validateLaunchId(application);
			}
		} catch (CoreException e) {




/*******************************************************************************
 * Copyright (c) 2007, 2009 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
 *     EclipseSource Corporation - ongoing enhancements
 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import java.util.HashMap;
import java.util.Map;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.core.plugin.*;
import org.eclipse.pde.internal.core.util.IdUtil;
import org.eclipse.pde.internal.ui.*;
import org.eclipse.pde.internal.ui.elements.NamedElement;
import org.eclipse.pde.ui.launcher.EclipseLaunchShortcut;
import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
import org.eclipse.swt.graphics.Image;

public class EclipsePluginValidationOperation extends LaunchValidationOperation {

	private Map fExtensionErrors = new HashMap(2);
	private static Object[] EMPTY = new Object[0];

	public EclipsePluginValidationOperation(ILaunchConfiguration configuration) {
		super(configuration);
	}

	protected IPluginModelBase[] getModels() throws CoreException {
		return BundleLauncherHelper.getMergedBundles(fLaunchConfiguration, false);
	}

	public void run(IProgressMonitor monitor) throws CoreException {
		super.run(monitor);
		if (fExtensionErrors.size() > 0)
			fExtensionErrors.clear();
		validateExtensions();
	}

	private void validateExtensions() {
		try {
			if (fLaunchConfiguration.getAttribute(IPDELauncherConstants.USE_PRODUCT, false)) {
				String product = fLaunchConfiguration.getAttribute(IPDELauncherConstants.PRODUCT, (String) null);
				if (product != null) {
					validateExtension(product);
					String application = getApplication(product);
					if (application != null)
						validateExtension(application);
				}
			} else {
				String configType = fLaunchConfiguration.getType().getIdentifier();
				String attribute = configType.equals(EclipseLaunchShortcut.CONFIGURATION_TYPE) ? IPDELauncherConstants.APPLICATION : IPDELauncherConstants.APP_TO_TEST;
				String application = fLaunchConfiguration.getAttribute(attribute, TargetPlatform.getDefaultApplication());
				if (!IPDEUIConstants.CORE_TEST_APPLICATION.equals(application)) {
					validateExtension(application);
				}
			}
		} catch (CoreException e) {
			PDEPlugin.log(e);
		}
	}

	private String getApplication(String product) {
		String bundleID = product.substring(0, product.lastIndexOf('.'));
		BundleDescription bundle = getState().getBundle(bundleID, null);
		if (bundle != null) {
			IPluginModelBase model = PluginRegistry.findModel(bundle);
			if (model != null) {
				IPluginExtension[] extensions = model.getPluginBase().getExtensions();
				for (int i = 0; i < extensions.length; i++) {
					IPluginExtension ext = extensions[i];
					String point = ext.getPoint();
					if ("org.eclipse.core.runtime.products".equals(point) //$NON-NLS-1$
							&& product.equals(IdUtil.getFullId(ext))) {
						if (ext.getChildCount() == 1) {
							IPluginElement prod = (IPluginElement) ext.getChildren()[0];
							if (prod.getName().equals("product")) { //$NON-NLS-1$
								IPluginAttribute attr = prod.getAttribute("application"); //$NON-NLS-1$
								return attr != null ? attr.getValue() : null;
							}
						}
					}
				}
			}
		}
		return null;
	}

	private void validateExtension(String id) {
		int index = id.lastIndexOf('.');
		if (index == -1)
			return;
		String bundleID = id.substring(0, index);
		BundleDescription bundle = getState().getBundle(bundleID, null);
		if (bundle == null) {
			String name = NLS.bind(PDEUIMessages.EclipsePluginValidationOperation_pluginMissing, bundleID);
			PDELabelProvider provider = PDEPlugin.getDefault().getLabelProvider();
			Image image = provider.get(PDEPluginImages.DESC_PLUGIN_OBJ);
			fExtensionErrors.put(new NamedElement(name, image), EMPTY);
		}
	}

	public boolean hasErrors() {
		return super.hasErrors() || fExtensionErrors.size() >= 1;
	}

	public Map getInput() {
		Map map = super.getInput();
		map.putAll(fExtensionErrors);
		return map;
	}

}




/*******************************************************************************
 * Copyright (c) 2005, 2009 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.launcher;

import java.util.*;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.*;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.pde.core.plugin.*;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.core.SearchablePluginsManager;
import org.eclipse.pde.internal.ui.IPDEUIConstants;
import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
import org.eclipse.swt.widgets.Display;

public class LaunchPluginValidator {

	private static IPluginModelBase[] getSelectedWorkspacePlugins(ILaunchConfiguration configuration) throws CoreException {

		boolean usedefault = configuration.getAttribute(IPDELauncherConstants.USE_DEFAULT, true);
		boolean useFeatures = configuration.getAttribute(IPDELauncherConstants.USEFEATURES, false);

		IPluginModelBase[] models = PluginRegistry.getWorkspaceModels();

		if (usedefault || useFeatures || models.length == 0)
			return models;

		Collection result = null;
		Map bundles = BundleLauncherHelper.getWorkspaceBundleMap(configuration, null, IPDELauncherConstants.SELECTED_WORKSPACE_PLUGINS);
		result = bundles.keySet();
		return (IPluginModelBase[]) result.toArray(new IPluginModelBase[result.size()]);
	}

	/**
	 * 
	 * @param configuration launchConfiguration to get the attribute value
	 * @param attribute launch configuration attribute to containing plug-in information
	 * @return a TreeSet containing IPluginModelBase objects which are represented by the value of the attribute
	 * @throws CoreException
	 */
	public static Set parsePlugins(ILaunchConfiguration configuration, String attribute) throws CoreException {
		HashSet set = new HashSet();
		String ids = configuration.getAttribute(attribute, (String) null);
		if (ids != null) {
			String[] entries = ids.split(","); //$NON-NLS-1$
			Map unmatchedEntries = new HashMap();
			for (int i = 0; i < entries.length; i++) {
				int index = entries[i].indexOf('@');
				if (index < 0) { // if no start levels, assume default
					entries[i] = entries[i].concat("@default:default"); //$NON-NLS-1$
					index = entries[i].indexOf('@');
				}
				String idVersion = entries[i].substring(0, index);
				int versionIndex = entries[i].indexOf(BundleLauncherHelper.VERSION_SEPARATOR);
				String id = (versionIndex > 0) ? idVersion.substring(0, versionIndex) : idVersion;
				String version = (versionIndex > 0) ? idVersion.substring(versionIndex + 1) : null;
				ModelEntry entry = PluginRegistry.findEntry(id);
				if (entry != null) {
					IPluginModelBase matchingModels[] = attribute.equals(IPDELauncherConstants.SELECTED_TARGET_PLUGINS) ? entry.getExternalModels() : entry.getWorkspaceModels();
					for (int j = 0; j < matchingModels.length; j++) {
						if (matchingModels[j].isEnabled()) {
							// TODO Very similar logic to BundleLauncherHelper
							// the logic here is this (see bug 225644)
							// a) if we come across a bundle that has the right version, immediately add it
							// b) if there's no version, add it
							// c) if there's only one instance of that bundle in the list of ids... add it
							if (version == null || matchingModels[j].getPluginBase().getVersion().equals(version)) {
								set.add(matchingModels[j]);
							} else if (matchingModels.length == 1) {
								if (unmatchedEntries.remove(id) == null) {
									unmatchedEntries.put(id, matchingModels[j]);
								}
							}
						}
					}
				}
			}
			set.addAll(unmatchedEntries.values());
		}
		return set;
	}

	public static IProject[] getAffectedProjects(ILaunchConfiguration config) throws CoreException {
		// if restarting, no need to check projects for errors
		if (config.getAttribute(IPDEUIConstants.RESTART, false))
			return new IProject[0];
		ArrayList projects = new ArrayList();
		IPluginModelBase[] models = getSelectedWorkspacePlugins(config);
		for (int i = 0; i < models.length; i++) {
			IProject project = models[i].getUnderlyingResource().getProject();
			if (project.hasNature(JavaCore.NATURE_ID))
				projects.add(project);
		}

		// add fake "Java Search" project
		SearchablePluginsManager manager = PDECore.getDefault().getSearchablePluginsManager();
		IJavaProject proxy = manager.getProxyProject();
		if (proxy != null) {
			projects.add(proxy.getProject());
		}
		return (IProject[]) projects.toArray(new IProject[projects.size()]);
	}

	public static void runValidationOperation(final LaunchValidationOperation op, IProgressMonitor monitor) throws CoreException {
		op.run(monitor);
		if (op.hasErrors()) {
			final int[] result = new int[1];
			final Display display = LauncherUtils.getDisplay();
			display.syncExec(new Runnable() {
				public void run() {
					PluginStatusDialog dialog = new PluginStatusDialog(display.getActiveShell());
					dialog.showCancelButton(true);
					dialog.setInput(op.getInput());
					result[0] = dialog.open();
				}
			});
			if (result[0] == IDialogConstants.CANCEL_ID)
				throw new CoreException(Status.CANCEL_STATUS);
		}
	}

}

Lines 11-16 Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/JREBlock.java (-1 / +4 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.pde.internal.ui.launcher;	12	package org.eclipse.pde.internal.ui.launcher;
13		13
		14	import org.eclipse.pde.launching.IPDELauncherConstants;
		15
		16	import org.eclipse.pde.internal.launching.launcher.VMHelper;
		17
14	import java.util.Arrays;	18	import java.util.Arrays;
15	import java.util.Comparator;	19	import java.util.Comparator;
16	import org.eclipse.core.runtime.*;	20	import org.eclipse.core.runtime.*;
Lines 25-31 Link Here
25	import org.eclipse.pde.internal.ui.SWTFactory;	29	import org.eclipse.pde.internal.ui.SWTFactory;
26	import org.eclipse.pde.internal.ui.util.SWTUtil;	30	import org.eclipse.pde.internal.ui.util.SWTUtil;
27	import org.eclipse.pde.ui.launcher.AbstractLauncherTab;	31	import org.eclipse.pde.ui.launcher.AbstractLauncherTab;
28	import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
29	import org.eclipse.swt.SWT;	32	import org.eclipse.swt.SWT;
30	import org.eclipse.swt.events.*;	33	import org.eclipse.swt.events.*;
31	import org.eclipse.swt.layout.GridData;	34	import org.eclipse.swt.layout.GridData;




/*******************************************************************************
 * Copyright (c) 2003, 2009 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
 *     EclipseSource Corporation - ongoing enhancements
 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import java.io.*;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.*;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.osgi.service.datalocation.Location;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.PluginRegistry;
import org.eclipse.pde.internal.core.*;
import org.eclipse.pde.internal.core.util.CoreUtility;
import org.eclipse.pde.internal.ui.*;
import org.eclipse.pde.internal.ui.wizards.tools.OrganizeManifestsProcessor;
import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IWorkbenchWindow;
import org.osgi.framework.*;

public class LauncherUtils {

	private static final String TIMESTAMP = "timestamp"; //$NON-NLS-1$
	private static final String FILE_NAME = "dep-timestamp.properties"; //$NON-NLS-1$
	private static Properties fLastRun;

	public static Display getDisplay() {
		Display display = Display.getCurrent();
		if (display == null) {
			display = Display.getDefault();
		}
		return display;
	}

	public final static Shell getActiveShell() {
		IWorkbenchWindow window = PDEPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow();
		if (window == null) {
			IWorkbenchWindow[] windows = PDEPlugin.getDefault().getWorkbench().getWorkbenchWindows();
			if (windows.length > 0)
				return windows[0].getShell();
		} else
			return window.getShell();
		return getDisplay().getActiveShell();
	}

	public static boolean clearWorkspace(ILaunchConfiguration configuration, String workspace, IProgressMonitor monitor) throws CoreException {

		// If the workspace is not defined, there is no workspace to clear
		// What will happen is that the workspace chooser dialog will be 
		// brought up because no -data parameter will be specified on the 
		// launch
		if (workspace.length() == 0) {
			monitor.done();
			return true;
		}

		// Check if the workspace is already in use, if so, open a message and stop the launch before clearing
		boolean isLocked = false;
		try {
			BundleContext context = PDECore.getDefault().getBundleContext();
			ServiceReference[] references = context.getServiceReferences(Location.class.getName(), "(type=osgi.configuration.area)"); //$NON-NLS-1$
			if (references.length > 0) {
				Object service = context.getService(references[0]);
				if (service instanceof Location) {
					URL workspaceURL = new Path(workspace).toFile().toURI().toURL();
					Location targetLocation = ((Location) service).createLocation(null, workspaceURL, false);
					targetLocation.set(targetLocation.getDefault(), false);
					isLocked = targetLocation.isLocked();
				}
			}
		} catch (InvalidSyntaxException e) {
			PDECore.log(e);
			isLocked = false;
		} catch (MalformedURLException e) {
			PDECore.log(e);
			isLocked = false;
		} catch (IOException e) {
			PDECore.log(e);
			isLocked = false;
		}

		if (isLocked) {
			generateErrorDialog(PDEUIMessages.LauncherUtils_workspaceLocked, NLS.bind(PDEUIMessages.LauncherUtils_cannotLaunchApplication, workspace));
			monitor.done();
			return false;
		}

		File workspaceFile = new Path(workspace).toFile().getAbsoluteFile();
		if (configuration.getAttribute(IPDELauncherConstants.DOCLEAR, false) && workspaceFile.exists()) {
			if (configuration.getAttribute(IPDELauncherConstants.ASKCLEAR, true)) {
				int result;
				if (configuration.getAttribute(IPDEUIConstants.DOCLEARLOG, false)) {
					result = generateDialog(PDEUIMessages.LauncherUtils_clearLogFile);
				} else {
					result = generateDialog(NLS.bind(PDEUIMessages.WorkbenchLauncherConfigurationDelegate_confirmDeleteWorkspace, workspaceFile.getPath()));
				}

				if (result == 2 /*Cancel Button*/|| result == -1 /*Dialog close button*/) {
					monitor.done();
					return false;
				} else if (result == 0) {
					if (configuration.getAttribute(IPDEUIConstants.DOCLEARLOG, false)) {
						LauncherUtils.clearWorkspaceLog(workspace);
					} else {
						CoreUtility.deleteContent(workspaceFile);
					}
				}
			} else if (configuration.getAttribute(IPDEUIConstants.DOCLEARLOG, false)) {
				LauncherUtils.clearWorkspaceLog(workspace);
			} else {
				CoreUtility.deleteContent(workspaceFile);
			}
		}

		monitor.done();
		return true;
	}

	public static boolean generateConfigIni() {
		String message = PDEUIMessages.LauncherUtils_generateConfigIni;
		return generateDialog(message) == 0;
	}

	/**
	 * Creates a message dialog using a syncExec in case we are launching in the background.
	 * Dialog will be a question dialog with Yes, No and Cancel buttons.
	 * @param message Message to use in the dialog
	 * @return int representing the button clicked (-1 or 2 for cancel, 0 for yes, 1 for no).
	 */
	private static int generateDialog(final String message) {
		final int[] result = new int[1];
		getDisplay().syncExec(new Runnable() {
			public void run() {
				String title = PDEUIMessages.LauncherUtils_title;
				MessageDialog dialog = new MessageDialog(getActiveShell(), title, null, message, MessageDialog.QUESTION, new String[] {IDialogConstants.YES_LABEL, IDialogConstants.NO_LABEL, IDialogConstants.CANCEL_LABEL}, 0);
				result[0] = dialog.open();
			}
		});
		return result[0];
	}

	private static void generateErrorDialog(final String title, final String message) {
		getDisplay().syncExec(new Runnable() {
			public void run() {
				MessageDialog dialog = new MessageDialog(getActiveShell(), title, null, message, MessageDialog.ERROR, new String[] {IDialogConstants.OK_LABEL}, 0);
				dialog.open();
			}
		});
	}

	public static void validateProjectDependencies(ILaunchConfiguration launch, final IProgressMonitor monitor) {
		IPreferenceStore store = PDEPlugin.getDefault().getPreferenceStore();
		if (!store.getBoolean(IPreferenceConstants.PROP_AUTO_MANAGE))
			return;

		String timeStamp;
		boolean useDefault, autoAdd;
		try {
			timeStamp = launch.getAttribute(TIMESTAMP, "0"); //$NON-NLS-1$
			autoAdd = launch.getAttribute(IPDELauncherConstants.AUTOMATIC_ADD, true);
			useDefault = launch.getAttribute(IPDELauncherConstants.USE_DEFAULT, true);
			useDefault |= launch.getAttribute(IPDELauncherConstants.USEFEATURES, false);
			final ArrayList projects = new ArrayList();
			if (useDefault)
				handleUseDefault(timeStamp, projects);
			else if (autoAdd)
				handleDeselectedPlugins(launch, timeStamp, projects);
			else
				handleSelectedPlugins(launch, timeStamp, projects);

			if (!projects.isEmpty())
				Display.getDefault().syncExec(new Runnable() {
					public void run() {
						OrganizeManifestsProcessor processor = new OrganizeManifestsProcessor(projects);
						initializeProcessor(processor);
						try {
							Change change = processor.createChange(monitor);
							change.perform(monitor);
							// update table for each project with current time stamp
							Properties table = getLastRun();
							String ts = Long.toString(System.currentTimeMillis());
							Iterator it = projects.iterator();
							while (it.hasNext())
								table.put(((IProject) it.next()).getName(), ts);
						} catch (OperationCanceledException e) {
						} catch (CoreException e) {
						}
					}
				});

			ILaunchConfigurationWorkingCopy wc = null;
			if (launch.isWorkingCopy())
				wc = (ILaunchConfigurationWorkingCopy) launch;
			else
				wc = launch.getWorkingCopy();
			wc.setAttribute(TIMESTAMP, Long.toString(System.currentTimeMillis()));
			wc.doSave();
		} catch (CoreException e) {
		}
	}

	private static void initializeProcessor(OrganizeManifestsProcessor processor) {
		processor.setAddMissing(false);
		processor.setRemoveUnresolved(false);
		processor.setModifyDep(false);
		processor.setRemoveLazy(false);
		processor.setRemoveUselessFiles(false);
		processor.setAddDependencies(true);
		processor.setCalculateUses(false);
		processor.setMarkInternal(false);
		processor.setPrefixIconNL(false);
		processor.setUnusedDependencies(false);
		processor.setUnusedKeys(false);
	}

	private static String getTimeStamp(IProject project) {
		IJavaProject jp = JavaCore.create(project);
		try {
			long timeStamp = 0;
			IClasspathEntry[] entries = jp.getResolvedClasspath(true);
			for (int i = 0; i < entries.length; i++) {
				if (entries[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {
					File file;
					IPath location = entries[i].getOutputLocation();
					if (location == null)
						location = jp.getOutputLocation();
					IResource res = project.getWorkspace().getRoot().findMember(location);
					IPath path = res == null ? null : res.getLocation();
					if (path == null)
						continue;
					file = path.toFile();
					Stack files = new Stack();
					files.push(file);
					while (!files.isEmpty()) {
						file = (File) files.pop();
						if (file.isDirectory()) {
							File[] children = file.listFiles();
							if (children != null) {
								for (int j = 0; j < children.length; j++)
									files.push(children[j]);
							}
						} else if (file.getName().endsWith(".class") && timeStamp < file.lastModified()) //$NON-NLS-1$
							timeStamp = file.lastModified();
					}
				}
			}
			String[] otherFiles = {ICoreConstants.BUNDLE_FILENAME_DESCRIPTOR, ICoreConstants.BUILD_FILENAME_DESCRIPTOR};
			for (int i = 0; i < otherFiles.length; i++) {
				IResource file = project.getFile(otherFiles[i]);
				if (file != null) {
					long fileTimeStamp = file.getRawLocation().toFile().lastModified();
					if (timeStamp < fileTimeStamp)
						timeStamp = fileTimeStamp;
				}
			}
			return Long.toString(timeStamp);
		} catch (JavaModelException e) {
		}
		return "0"; //$NON-NLS-1$
	}

	private static void handleUseDefault(String launcherTimeStamp, ArrayList projects) {
		IProject[] projs = ResourcesPlugin.getWorkspace().getRoot().getProjects();
		for (int i = 0; i < projs.length; i++) {
			if (!WorkspaceModelManager.isPluginProject(projs[i]))
				continue;
			String timestamp = getTimeStamp(projs[i]);
			if (timestamp.compareTo(launcherTimeStamp) > 0 && shouldAdd(projs[i], launcherTimeStamp, timestamp))
				projects.add(projs[i]);
		}
	}

	private static void handleSelectedPlugins(ILaunchConfiguration config, String timeStamp, ArrayList projects) throws CoreException {
		Map selectedPlugins = BundleLauncherHelper.getWorkspaceBundleMap(config, null, IPDELauncherConstants.SELECTED_WORKSPACE_PLUGINS);
		Iterator it = selectedPlugins.keySet().iterator();
		while (it.hasNext()) {
			IPluginModelBase model = (IPluginModelBase) it.next();
			IResource res = model.getUnderlyingResource();
			if (res != null) {
				IProject project = res.getProject();
				String projTimeStamp = getTimeStamp(project);
				if (projTimeStamp.compareTo(timeStamp) > 0 && shouldAdd(project, timeStamp, projTimeStamp))
					projects.add(project);
			}
		}
	}

	private static void handleDeselectedPlugins(ILaunchConfiguration config, String launcherTimeStamp, ArrayList projects) throws CoreException {
		Map deSelectedPlugins = BundleLauncherHelper.getWorkspaceBundleMap(config, null, IPDELauncherConstants.DESELECTED_WORKSPACE_PLUGINS);
		IProject[] projs = ResourcesPlugin.getWorkspace().getRoot().getProjects();
		for (int i = 0; i < projs.length; i++) {
			if (!WorkspaceModelManager.isPluginProject(projs[i]))
				continue;
			IPluginModelBase base = PluginRegistry.findModel(projs[i]);
			if (base == null || base != null && deSelectedPlugins.containsKey(base))
				continue;
			String timestamp = getTimeStamp(projs[i]);
			if (timestamp.compareTo(launcherTimeStamp) > 0 && shouldAdd(projs[i], launcherTimeStamp, timestamp))
				projects.add(projs[i]);
		}
	}

	public static final void shutdown() {
		if (fLastRun == null)
			return;
		FileOutputStream stream = null;
		try {
			stream = new FileOutputStream(new File(getDirectory(), FILE_NAME));
			fLastRun.store(stream, "Cached timestamps"); //$NON-NLS-1$
			stream.flush();
			stream.close();
		} catch (IOException e) {
			PDECore.logException(e);
		} finally {
			try {
				if (stream != null)
					stream.close();
			} catch (IOException e1) {
			}
		}
	}

	private static File getDirectory() {
		IPath path = PDECore.getDefault().getStateLocation().append(".cache"); //$NON-NLS-1$
		File directory = new File(path.toOSString());
		if (!directory.exists() || !directory.isDirectory())
			directory.mkdirs();
		return directory;
	}

	private static Properties getLastRun() {
		if (fLastRun == null) {
			fLastRun = new Properties();
			FileInputStream fis = null;
			try {
				File file = new File(getDirectory(), FILE_NAME);
				if (file.exists()) {
					fis = new FileInputStream(file);
					fLastRun.load(fis);
					fis.close();
				}
			} catch (IOException e) {
				PDECore.logException(e);
			} finally {
				try {
					if (fis != null)
						fis.close();
				} catch (IOException e1) {
				}
			}
		}
		return fLastRun;
	}

	private static boolean shouldAdd(IProject proj, String launcherTS, String fileSystemTS) {
		String projTS = (String) getLastRun().get(proj.getName());
		if (projTS == null)
			return true;
		return ((projTS.compareTo(launcherTS) < 0) || (projTS.compareTo(fileSystemTS) < 0));
	}

	public static boolean requiresUI(ILaunchConfiguration configuration) {
		try {
			String projectID = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, ""); //$NON-NLS-1$
			if (projectID.length() > 0) {
				IResource project = PDEPlugin.getWorkspace().getRoot().findMember(projectID);
				if (project instanceof IProject) {
					IPluginModelBase model = PluginRegistry.findModel((IProject) project);
					if (model != null) {
						Set plugins = DependencyManager.getSelfAndDependencies(model);
						return plugins.contains("org.eclipse.swt"); //$NON-NLS-1$
					}
				}
			}
		} catch (CoreException e) {
		}
		return true;
	}

	public static boolean clearWorkspaceLog(String workspace) {
		File logFile = new File(workspace, ".metadata" + File.separator + ".log"); //$NON-NLS-1$ //$NON-NLS-2$
		if (logFile != null && logFile.exists()) {
			return logFile.delete();
		}
		return true;
	}

	public static IStatus createErrorStatus(String message) {
		return new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.OK, message, null);
	}

}

Lines 1-5 Link Here

(-)src/org/eclipse/pde/internal/ui/wizards/exports/BaseExportWizard.java (-3 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 14-23 Link Here
14	import org.eclipse.jface.viewers.IStructuredSelection;	14	import org.eclipse.jface.viewers.IStructuredSelection;
15	import org.eclipse.jface.wizard.IWizardPage;	15	import org.eclipse.jface.wizard.IWizardPage;
16	import org.eclipse.jface.wizard.Wizard;	16	import org.eclipse.jface.wizard.Wizard;
17	import org.eclipse.pde.internal.ui.*;	17	import org.eclipse.pde.internal.launching.ILaunchingPreferenceConstants;
		18	import org.eclipse.pde.internal.ui.PDEPlugin;
		19	import org.eclipse.pde.internal.ui.PDEUIMessages;
18	import org.eclipse.ui.*;	20	import org.eclipse.ui.*;
19		21
20	public abstract class BaseExportWizard extends Wizard implements IExportWizard, IPreferenceConstants {	22	public abstract class BaseExportWizard extends Wizard implements IExportWizard, ILaunchingPreferenceConstants {
21		23
22	protected IStructuredSelection fSelection;	24	protected IStructuredSelection fSelection;
23		25




   <extension-point id="newExtension" name="%expoint.newExtension.name" schema="schema/newExtension.exsd"/>
   <extension-point id="templates" name="%expoint.templates.name" schema="schema/templates.exsd"/>
   <extension-point id="samples" name="%expoint.samples.name" schema="schema/samples.exsd"/>
   <extension-point id="osgiFrameworks" name="%expoint.osgiLauncher.name" schema="schema/osgiFrameworks.exsd"/>
   <extension-point id="targetProvisioners" name="%extension-point.name.0" schema="schema/targetProvisioners.exsd"/>
   <extension-point id="launchShortcuts" name="%extension-point.name.1" schema="schema/launchShortcuts.exsd"/>


      </objectContribution>
   </extension>
   <extension
         point="org.eclipse.debug.core.launchConfigurationTypes">
      <launchConfigurationType
            delegate="org.eclipse.pde.ui.launcher.EclipseApplicationLaunchConfiguration"
            delegateDescription="%PDELaunchDelegate.description"
            delegateName="%PDELaunchDelegate.name"
            id="org.eclipse.pde.ui.RuntimeWorkbench"
            migrationDelegate="org.eclipse.pde.internal.ui.launcher.PDEMigrationDelegate"
            modes="run, debug"
            name="%launchConfigurationType.name"
            sourceLocatorId="org.eclipse.pde.ui.launcher.PDESourceLookupDirector"
            sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer">
      </launchConfigurationType>
      <launchConfigurationType
            delegate="org.eclipse.pde.ui.launcher.JUnitLaunchConfigurationDelegate"
            delegateDescription="%JUnitPluginLaunchDelegate.description"
            delegateName="%JUnitPluginLaunchDelegate.name"
            id="org.eclipse.pde.ui.JunitLaunchConfig"
            migrationDelegate="org.eclipse.pde.internal.ui.launcher.PDEMigrationDelegate"
            modes="run, debug"
            name="%launcher.junit.name"
            sourceLocatorId="org.eclipse.pde.ui.launcher.PDESourceLookupDirector"
            sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer">
      </launchConfigurationType>
      <launchConfigurationType
            delegate="org.eclipse.pde.ui.launcher.OSGiLaunchConfigurationDelegate"
            delegateDescription="%OSGiLaunchDelegate.description"
            delegateName="%OSGiLaunchDelegate.name"
            id="org.eclipse.pde.ui.EquinoxLauncher"
            migrationDelegate="org.eclipse.pde.internal.ui.launcher.OSGiMigrationDelegate"
            modes="run, debug"
            name="%launcher.framework.name"
            public="true"
            sourceLocatorId="org.eclipse.pde.ui.launcher.PDESourceLookupDirector"
            sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer"/>
   </extension>
   <extension
         point="org.eclipse.debug.ui.launchConfigurationTypeImages">
      <launchConfigurationTypeImage
            icon="$nl$/icons/etool16/eclipse_launcher.gif"

      </launchConfigurationTabGroup>
   </extension>
   <extension
         point="org.eclipse.jdt.junit.junitLaunchConfigs">
      <launchConfigType
            configTypeID="org.eclipse.pde.ui.JunitLaunchConfig">
      </launchConfigType>
   </extension>
   <extension
         point="org.eclipse.debug.ui.launchShortcuts">
      <shortcut
            class="org.eclipse.pde.ui.launcher.JUnitWorkbenchLaunchShortcut"

            id="org.eclipse.pde.ui.dependencyExtentResultPage"/>
   </extension>
   <extension
         point="org.eclipse.jdt.launching.classpathProviders">
      <classpathProvider
            class="org.eclipse.pde.ui.launcher.PDESourcePathProvider"
            id="org.eclipse.pde.ui.workbenchClasspathProvider">
      </classpathProvider>
   </extension>
   <extension
         point="org.eclipse.ui.intro.configExtension">
      <standbyContentPart
            pluginId="org.eclipse.pde.ui"

         </description>
       </fontDefinition>
    </extension>
    <extension point="org.eclipse.debug.core.sourceLocators">
   		<sourceLocator
   			id="org.eclipse.pde.ui.launcher.PDESourceLookupDirector"
   			class="org.eclipse.pde.internal.ui.launcher.PDESourceLookupDirector"
   			name="%pde.sourcelocator">
   		</sourceLocator>
   </extension>
   <extension
          point="org.eclipse.ui.perspectiveExtensions">
       <perspectiveExtension

      </perspectiveExtension>
    </extension>
    <extension
         point="org.eclipse.pde.ui.osgiFrameworks">
      <framework
            launcherDelegate="org.eclipse.pde.ui.launcher.EquinoxLaunchConfiguration"
            id="org.eclipse.pde.ui.EquinoxFramework"
            name="%Equinox.shortcut.label" 
            initializer="org.eclipse.pde.internal.ui.launcher.EquinoxInitializer"/>
    </extension>
    <extension
          point="org.eclipse.ui.ide.markerSupport">
       <markerTypeCategory
             name="%marker.category">

                   tooltip="%showErrorInStackTraceConsoleAction.label">
             </action>
          </viewContribution>
	</extension>
	<extension
         point="org.eclipse.debug.core.statusHandlers">
      <statusHandler
            class="org.eclipse.pde.internal.ui.launcher.LaunchTerminationStatusHandler"
            code="13"
            id="org.eclipse.pde.launching.ERR13"
            plugin="org.eclipse.pde.launching">
      </statusHandler>
      <statusHandler
            class="org.eclipse.pde.internal.ui.launcher.LaunchTerminationStatusHandler"
            code="15"
            id="org.eclipse.pde.launching.ERR15"
            plugin="org.eclipse.pde.launching">
      </statusHandler>
      <statusHandler
            class="org.eclipse.pde.internal.ui.launcher.GenericExceptionStatusHandler"
            code="42"
            id="org.eclipse.pde.launching.GENERIC_EXCEPTION"
            plugin="org.eclipse.pde.launching">
      </statusHandler>
      <statusHandler
            class="org.eclipse.pde.internal.ui.launcher.PluginValidationStatusHandler"
            code="1000"
            id="org.eclipse.pde.launching.CREATE_EXTENSION_ERROR"
            plugin="org.eclipse.pde.launching">
      </statusHandler>
      <statusHandler
            class="org.eclipse.pde.internal.ui.launcher.PluginValidationStatusHandler"
            code="1001"
            id="org.eclipse.pde.launching.DISPLAY_VALIDATION_ERROR"
            plugin="org.eclipse.pde.launching">
      </statusHandler>
      <statusHandler
            class="org.eclipse.pde.internal.ui.launcher.LauncherUtilsStatusHandler"
            code="2000"
            id="org.eclipse.pde.launching.WORKSPACE_LOCKED"
            plugin="org.eclipse.pde.launching">
      </statusHandler>
      <statusHandler
            class="org.eclipse.pde.internal.ui.launcher.LauncherUtilsStatusHandler"
            code="2001"
            id="org.eclipse.pde.launching.CLEAR_LOG"
            plugin="org.eclipse.pde.launching">
      </statusHandler>
      <statusHandler
            class="org.eclipse.pde.internal.ui.launcher.LauncherUtilsStatusHandler"
            code="2002"
            id="org.eclipse.pde.launching.DELETE_WORKSPACE"
            plugin="org.eclipse.pde.launching">
      </statusHandler>
      <statusHandler
            class="org.eclipse.pde.internal.ui.launcher.LauncherUtilsStatusHandler"
            code="2003"
            id="org.eclipse.pde.launching.CREATE_CONFIG_INI"
            plugin="org.eclipse.pde.launching">
      </statusHandler>
      <statusHandler
            class="org.eclipse.pde.internal.ui.launcher.LauncherUtilsStatusHandler"
            code="2004"
            id="org.eclipse.pde.launching.ORGANIZE_MANIFESTS"
            plugin="org.eclipse.pde.launching">
      </statusHandler>
   </extension>	
</plugin>




expoint.samples.name = Code Samples
expoint.osgiLauncher.name = OSGi Launcher

PDELaunchDelegate.name=Eclipse Application Launcher
PDELaunchDelegate.description=The Eclipse Application launcher is used to run or debug a separate instance of an Eclipse application
OSGiLaunchDelegate.name=OSGi Framework Launcher
OSGiLaunchDelegate.description=The OSGi Framework launcher is used to launch an OSGi framework and run or debug OSGi bundles
JUnitPluginLaunchDelegate.name= JUnit Plugin Test Launcher
JUnitPluginLaunchDelegate.description=The JUnit Plugin Test launcher is used to run and debug test suites for plug-in projects

RunPDELaunchShortcut.description=Runs a separate Eclipse application
DebugPDELaunchShortcut.description=Debugs a separate Eclipse application
RunOSGiLaunchShortcut.description=Runs an OSGi framework

launcher.shortcut.label= Eclipse Application
EclipseApplicationShortcut.description.debug = Debug Eclipse Application
EclipseApplicationShortcut.description.run = Run Eclipse Application
Equinox.shortcut.label = Equinox
OSGiShortcut.description.debug = Debug OSGi Framework
OSGiShortcut.description.run = Run OSGi Framework
launcher.junit.name = JUnit Plug-in Test
JUnitApplicationShortcut.description.debug = Debug JUnit Plug-in Test
JUnitApplicationShortcut.description.run = Run JUnit Plug-in Test

launchConfigurationType.name = Eclipse Application
launcher.framework.name = OSGi Framework

osgiLauncherTabGroup.description.debug=Create a configuration to launch the OSGi framework in debug mode.
osgiLauncherTabGroup.description.run=Create a configuration to launch the OSGi framework.
workbenchLauncherTabGroup.description.debug=Create a configuration to launch an Eclipse application in debug mode.

editor.target.name = Target Editor
fontDefinition.label.0 = Manifest compare text font
fontDefinition.description.0 = The MANIFEST.MF compare text font is used by Bundle manifest compare/merge tools.
pde.sourcelocator = PDE Source Lookup Director

category.source.name = Manifest Editor Source
category.source.description = PDE Source Page actions




package org.eclipse.pde.internal.ui;

import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.pde.internal.launching.IPDEConstants;

public interface IPDEUIConstants extends IPDEConstants {
	String PLUGIN_ID = "org.eclipse.pde.ui"; //$NON-NLS-1$

	String MANIFEST_EDITOR_ID = PLUGIN_ID + ".manifestEditor"; //$NON-NLS-1$


	String PLUGIN_DOC_ROOT = "/org.eclipse.pde.doc.user/"; //$NON-NLS-1$

	// JUnit application identifiers
	String LEGACY_UI_TEST_APPLICATION = "org.eclipse.pde.junit.runtime.legacytestapplication"; //$NON-NLS-1$
	String NON_UI_THREAD_APPLICATION = "org.eclipse.pde.junit.runtime.nonuithreadtestapplication"; //$NON-NLS-1$
	String UI_TEST_APPLICATION = "org.eclipse.pde.junit.runtime.uitestapplication"; //$NON-NLS-1$
	String CORE_TEST_APPLICATION = "org.eclipse.pde.junit.runtime.coretestapplication"; //$NON-NLS-1$

	/**
	 * Launch configuration attribute key.  The value is a boolean specifies
	 * whether the launch configuration is being restarted.  This does not need to 
	 * be promoted to IPDELauncherConstants since clients should not need to know 
	 * about restarts.  
	 */
	String RESTART = "restart"; //$NON-NLS-1$
	/**
	 * Launch configuration attribute key. The value is a boolean specifying
	 * whether the workspace log for an Eclipse application should be cleared

	 * 
	 * TODO, move to IPDELauncherConstants in 3.4
	 */
	String DOCLEARLOG = "clearwslog"; //$NON-NLS-1$
	String LAUNCHER_PDE_VERSION = "pde.version"; //$NON-NLS-1$
	String APPEND_ARGS_EXPLICITLY = "append.args"; //$NON-NLS-1$
	String GENERATED_CONFIG = "pde.generated.config"; //$NON-NLS-1$

}




ConfigurationTab_fileDialogMessage=Select a config.ini file:


WorkbenchLauncherConfigurationDelegate_noJRE = Cannot locate JRE definition: "{0}". Launch aborted.
WorkbenchLauncherConfigurationDelegate_jrePathNotFound = The installation path to the specified JRE could not be found.  Launch aborted.
WorkbenchLauncherConfigurationDelegate_badFeatureSetup = When in feature mode, plug-ins must be in the 'plugins' directory and features in 'features' directory in the workspace.
WorkbenchLauncherConfigurationDelegate_noStartup = Launching failed. Bootstrap code cannot be found.
WorkbenchLauncherConfigurationDelegate_confirmDeleteWorkspace = Do you really want to clear the run-time workspace data in {0}?
JUnitLaunchConfiguration_error_notaplugin = Could not launch the JUnit plug-in tests because project ''{0}'' is not a plug-in project.
JUnitLaunchConfiguration_error_missingPlugin = Required plug-in ''{0}'' could not be found.

Launcher_error_title=Launch Error
LauncherSection_desc=Customize the executable that is used to launch the product.
LauncherSection_ico=Use a single ICO file containing the 6 images:
LauncherUtils_workspaceLocked=Workspace Cannot Be Locked
LauncherUtils_cannotLaunchApplication=Could not launch the application because the associated workspace is currently in use by another Eclipse application.\n\n{0}
LauncherUtils_clearLogFile=Do you really want to clear the log file?
LauncherUtils_title=Launcher
LauncherPage_title=Launching

LauncherSection_icon=Icon:
LauncherSection_tiny=Tiny:
Launcher_error_code13=The application could not start.  Would you like to view the log?
Launcher_error_code15=Could not launch the configuration because the associated workspace is currently in use.
Launcher_error_displayInLogView=Yes, in the Error Log view
LauncherUtils_generateConfigIni=The config.ini template file you specified does not exist.  Continue launching with a generated config.ini file?
Launcher_error_displayInSystemEditor=Yes, in an editor

InternationalizeWizard_NLSFragmentGenerator_errorMessage = An error occured while generating an NL Fragment.

MainTab_jreSection = Java Runtime Environment
EquinoxLaunchConfiguration_oldTarget=The org.eclipse.osgi plug-in is missing from this configuration.
EquinoxPluginBlock_levelColumn=Start Level
EquinoxPluginsTab_defaultStart=Default S&tart level:
EquinoxPluginBlock_autoColumn=Auto-Start

EditorSourcePage_name=Source
EditTargetNode_0=New Target Definition
OSGiBundlesTab_frameworkLabel=&Framework:
OSGiLaunchConfiguration_cannotFindLaunchConfiguration=Cannot find the {0} OSGi framework.
OSGiLaunchConfiguration_selected=selected
OSGiFrameworkPreferencePage_default=(default)
OSGiFrameworkPreferencePage_installed=Installed <a>OSGi frameworks</a>:
OSGiFrameworkPreferencePage_installed_nolink=Installed OSGi frameworks:

UpdateSplashHandlerInModelAction_nameEnterprise=Enterprise
UpdateSplashProgressAction_msgErrorTextFileBuffer=Text file buffer is NULL
UpdateSplashHandlerInModelAction_nameLanguages=Languages
EclipsePluginValidationOperation_pluginMissing={0} is missing
SplashProgressSection_progressName=Customization
SplashProgressSection_progressSectionDesc=Create a custom splash screen using one of the provided templates or by adding a progress bar and message.
UpdateSplashHandlerInModelAction_templateTypeInteractive=Interactive - A simulated log-in session

PDECompilersConfigurationBlock_warning = Warning
PDECompilersConfigurationBlock_ignore = Ignore

VMHelper_cannotFindExecEnv=Cannot locate Execution Environment definition: "{0}". Launch aborted.

LicensingPage_title=Licensing
LicenseSection_title=License
LicenseSection_description=Specify the license text and URL for the product.




import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.*;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfigurationListener;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.pde.internal.core.PDEPreferencesManager;
import org.eclipse.pde.internal.ui.launcher.PDELogFileProvider;
import org.eclipse.pde.internal.ui.util.SWTUtil;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.internal.views.log.LogFilesManager;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.eclipse.ui.texteditor.IDocumentProvider;
import org.osgi.framework.BundleContext;

public class PDEPlugin extends AbstractUIPlugin implements IPDEUIConstants {

	// Shared instance
	private static PDEPlugin fInstance;

	// Launches listener
	private LaunchListener fLaunchListener;

	private BundleContext fBundleContext;

	private Hashtable fCounters;

	// Provides Launch Configurations log files to Log View

	private PDELabelProvider fLabelProvider;

	/**
	 * Utility class to help setup the launch configuration listener
	 * without loading the debug plugin
	 */
	private DebugPluginUtil fDebugPluginUtil;

	/**
	 * The shared text file document provider.
	 * @since 3.2
	 */
	private IDocumentProvider fTextFileDocumentProvider;

	private OSGiFrameworkManager fOSGiFrameworkManager;

	private PDEPreferencesManager fPreferenceManager;

	public PDEPlugin() {

	 */
	public void start(BundleContext context) throws Exception {
		super.start(context);
		fBundleContext = context;
		setupLaunchConfigurationListener();
		fLogFileProvider = new PDELogFileProvider();
		LogFilesManager.addLogFileProvider(fLogFileProvider);
	}

	/**
	 * Add the launch configuration listener if the debug plugin
	 * is started.  Otherwise, setup a bundle listener to install
	 * the listener when the debug plugin loads.
	 * @param context bundle context needed to get current bundles
	 */
	private void setupLaunchConfigurationListener() {
		boolean listenerStarted = false;
		Bundle bundle = Platform.getBundle("org.eclipse.debug.core"); //$NON-NLS-1$
		if (bundle != null && bundle.getState() == Bundle.ACTIVE) {
			fDebugPluginUtil = new DebugPluginUtil();
			fDebugPluginUtil.addListener();
			listenerStarted = true;
		}
		if (!listenerStarted) {
			fBundleContext.addBundleListener(new BundleListener() {
				public void bundleChanged(BundleEvent event) {
					if (event.getType() == BundleEvent.STARTED && "org.eclipse.debug.core".equals(event.getBundle().getSymbolicName())) { //$NON-NLS-1$
						fDebugPluginUtil = new DebugPluginUtil();
						fDebugPluginUtil.addListener();
						fBundleContext.removeBundleListener(this);
					}
				}
			});
		}
	}

	public BundleContext getBundleContext() {
		return fBundleContext;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
	 */
	public void stop(BundleContext context) throws Exception {
		if (fLaunchListener != null)
			fLaunchListener.shutdown();
		if (fFormColors != null) {
			fFormColors.dispose();
			fFormColors = null;

			fLabelProvider.dispose();
			fLabelProvider = null;
		}
		if (fDebugPluginUtil != null) {
			fDebugPluginUtil.removeListener();
		}
		if (fLogFileProvider != null) {
			LogFilesManager.removeLogFileProvider(fLogFileProvider);
			fLogFileProvider = null;
		}
		LauncherUtils.shutdown();
		super.stop(context);
	}


		return fLabelProvider;
	}

	public LaunchListener getLaunchListener() {
		if (fLaunchListener == null)
			fLaunchListener = new LaunchListener();
		return fLaunchListener;
	}

	public OSGiFrameworkManager getOSGiFrameworkManager() {
		if (fOSGiFrameworkManager == null)
			fOSGiFrameworkManager = new OSGiFrameworkManager();
		return fOSGiFrameworkManager;
	}

	public static boolean isFullNameModeEnabled() {
		IPreferenceStore store = getDefault().getPreferenceStore();
		return store.getString(IPreferenceConstants.PROP_SHOW_OBJECTS).equals(IPreferenceConstants.VALUE_USE_NAMES);

		return fTextFileDocumentProvider;
	}

	/**
	 * Utility class that creates and controls a the PDE launch configuration listener.
	 * This is done in a separate class to avoid loading the debug plugin.
	 * @since 3.4
	 */
	private class DebugPluginUtil {
		private ILaunchConfigurationListener fLaunchConfigurationListener;

		public void addListener() {
			if (fLaunchConfigurationListener == null) {
				fLaunchConfigurationListener = new LaunchConfigurationListener();
			}
			DebugPlugin.getDefault().getLaunchManager().addLaunchConfigurationListener(fLaunchConfigurationListener);
		}

		public void removeListener() {
			if (fLaunchConfigurationListener != null) {
				DebugPlugin.getDefault().getLaunchManager().removeLaunchConfigurationListener(fLaunchConfigurationListener);
				fLaunchConfigurationListener = null;
			}
		}
	}
}




 *******************************************************************************/
package org.eclipse.pde.internal.ui;

import org.eclipse.pde.internal.launching.ILaunchingPreferenceConstants;

/**
 * Listing of constants used in PDE preferences
 * 
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IPreferenceConstants extends ILaunchingPreferenceConstants {

	// Main preference page	
	public static final String PROP_SHOW_OBJECTS = "Preferences.MainPage.showObjects"; //$NON-NLS-1$
	public static final String VALUE_USE_IDS = "useIds"; //$NON-NLS-1$
	public static final String VALUE_USE_NAMES = "useNames"; //$NON-NLS-1$
	public static final String PROP_AUTO_MANAGE = "Preferences.MainPage.automanageDependencies"; //$NON-NLS-1$
	public static final String PROP_SHOW_SOURCE_BUNDLES = "Preferences.MainPage.showSourceBundles"; //$NON-NLS-1$
	public static final String OVERWRITE_BUILD_FILES_ON_EXPORT = "Preferences.MainPage.overwriteBuildFilesOnExport"; //$NON-NLS-1$
	public static final String PROP_PROMPT_REMOVE_TARGET = "Preferences.MainPage.promptRemoveTarget"; //$NON-NLS-1$

	public static final String DEPS_VIEW_SHOW_CALLERS = "DependenciesView.show.callers"; //$NON-NLS-1$
	public static final String DEPS_VIEW_SHOW_LIST = "DependenciesView.show.list"; //$NON-NLS-1$
	public static final String DEPS_VIEW_SHOW_STATE = "DependenciesView.show.state"; //$NON-NLS-1$

	// OSGi Frameworks
	public static final String DEFAULT_OSGI_FRAMEOWRK = "Preference.default.osgi.framework"; //$NON-NLS-1$
}





	public static String DependencyPropertiesDialog_exportGroupText;

	public static String EclipsePluginValidationOperation_pluginMissing;

	public static String ExternalizeStringsOperation_editNames_addComment;

	public static String ExternalizeStringsOperation_editNames_insertProperty;


	public static String LauncherUtils_workspaceLocked;

	public static String LauncherUtils_cannotLaunchApplication;

	public static String LauncherUtils_clearLogFile;

	public static String LauncherUtils_generateConfigIni;

	public static String ConfigurationSection_selection;
	public static String ConfigurationTab_fileDialogMessage;

	public static String WorkbenchLauncherConfigurationDelegate_noJRE;
	public static String WorkbenchLauncherConfigurationDelegate_jrePathNotFound;
	public static String WorkbenchLauncherConfigurationDelegate_badFeatureSetup;
	public static String WorkbenchLauncherConfigurationDelegate_noStartup;
	public static String WorkbenchLauncherConfigurationDelegate_confirmDeleteWorkspace;
	public static String JUnitLaunchConfiguration_error_notaplugin;
	public static String JUnitLaunchConfiguration_error_missingPlugin;

	public static String Launcher_error_title;
	public static String LauncherSection_desc;

	public static String LauncherSection_icon;
	public static String LauncherSection_tiny;
	public static String Launcher_error_code13;
	public static String Launcher_error_code15;
	public static String Launcher_error_displayInLogView;
	public static String Launcher_error_displayInSystemEditor;
	public static String LauncherSection_browse;

	public static String OpenLogDialog_cannotDisplay;

	public static String OSGiBundlesTab_frameworkLabel;
	public static String OSGiLaunchConfiguration_cannotFindLaunchConfiguration;
	public static String OSGiLaunchConfiguration_selected;

	// Preferences ####################################
	public static String Preferences_MainPage_Description;


	public static String EquinoxSettingsTab_name;

	public static String EquinoxLaunchConfiguration_oldTarget;

	public static String ModelChangeLabelProvider_instance;

	public static String ModelChangeLabelProvider_instances;

	public static String HyperlinkActionOpenBundle;
	public static String HyperlinkActionOpenPackage;

	public static String VMHelper_cannotFindExecEnv;

	public static String HyperlinkActionOpenResource;
	public static String HyperlinkActionOpenSchema;
	public static String HyperlinkActionOpenTranslation;




import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.jface.action.*;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.*;

import org.eclipse.pde.internal.core.plugin.ExternalPluginModel;
import org.eclipse.pde.internal.core.plugin.WorkspacePluginModel;
import org.eclipse.pde.internal.core.text.build.BuildEntry;
import org.eclipse.pde.internal.launching.ILaunchingPreferenceConstants;
import org.eclipse.pde.internal.launching.PDELaunchingPlugin;
import org.eclipse.pde.internal.ui.*;
import org.eclipse.pde.internal.ui.dialogs.PluginSelectionDialog;
import org.eclipse.pde.internal.ui.editor.*;

					entry.addToken(pmodel.getPlugin().getId());
				}
				markDirty();
				PDEPreferencesManager store = PDELaunchingPlugin.getDefault().getPreferenceManager();
				store.setDefault(ILaunchingPreferenceConstants.PROP_AUTO_MANAGE, true);
			} catch (CoreException e) {
				PDEPlugin.logException(e);
			}




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.pde.ui">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.pde.ui" id="osgiFrameworks" name="OSGi Frameworks"/>
      </appInfo>
      <documentation>
         &lt;p&gt;
This extension point is used to register new OSGi frameworks. Each framework is associated with a launcher delegate that is called when the OSGi framework is selected in the &lt;b&gt;OSGi Framework&lt;/b&gt; launch configuration.
&lt;/p&gt;
&lt;p&gt;Registered OSGi frameworks appear on the &lt;b&gt;Plug-in Development &gt; OSGi frameworks&lt;/b&gt; preference page, where a default framework can be set.
&lt;/p&gt;
      </documentation>
   </annotation>

   <element name="extension">
      <complexType>
         <sequence>
            <element ref="framework" minOccurs="1" maxOccurs="unbounded"/>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="framework">
      <complexType>
         <attribute name="id" type="string" use="required">
            <annotation>
               <documentation>
                  a unique identifier of the framework
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string" use="required">
            <annotation>
               <documentation>
                  human-readable name of the OSGi framework
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="launcherDelegate" type="string" use="required">
            <annotation>
               <documentation>
                  a launch configuration delegate to launch the OSGi framework. The value of this attribute is the fully qualified name of the Java class that extends &lt;code&gt;org.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration&lt;/code&gt;.
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn="org.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="initializer" type="string">
            <annotation>
               <documentation>
                  initializes new OSGi Framework launch configurations with suitable defaults.  The value of this attribute must be a fully-qualified name of a Java class that extends the default implementation &lt;code&gt;org.eclipse.pde.ui.launcher.OSGiLaunchConfigurationInitializer&lt;/code&gt;.  If not specified, the default initializer &lt;code&gt;org.eclipse.pde.ui.launcher.OSGiLaunchConfigurationInitializer&lt;/code&gt; is instantiated.
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn="org.eclipse.pde.ui.launcher.OSGiLaunchConfigurationInitializer"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <annotation>
      <appInfo>
         <meta.section type="since"/>
      </appInfo>
      <documentation>
         3.3
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="examples"/>
      </appInfo>
      <documentation>
         &lt;p&gt;
The following is an example of the extension point:
&lt;pre&gt;
   &lt;extension
         point=&quot;org.eclipse.pde.ui.osgiFrameworks&quot;&gt;
      &lt;framework
            launcherDelegate=&quot;org.eclipse.pde.ui.launcher.EquinoxLaunchConfiguration&quot;
            id=&quot;org.eclipse.pde.ui.EquinoxFramework&quot;
            name=&quot;%Equinox.shortcut.label&quot; 
            initializer=&quot;org.eclipse.pde.internal.ui.launcher.EquinoxInitializer&quot;/&gt;
   &lt;/extension&gt;
&lt;/pre&gt;
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="apiInfo"/>
      </appInfo>
      <documentation>
         &lt;p&gt;
The value of the attribute &lt;code&gt;launcherDelegate&lt;/code&gt; must be a fully qualified name of a Java class that extends &lt;code&gt;org.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration&lt;/code&gt;.  If the launcher is to provide its own source lookup order, then the method &lt;code&gt;setDefaultSourceLocator&lt;/code&gt; should be overridden.
&lt;/p&gt;
&lt;p&gt;
The value of the attribute &lt;code&gt;initializer&lt;/code&gt; must be a fully qualified name of a Java class that extends &lt;code&gt;org.eclipse.ui.launcher.OSGiLaunchConfigurationInitializer&lt;/code&gt;.
&lt;/p&gt;
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="implementation"/>
      </appInfo>
      <documentation>
         &lt;p&gt;
PDE supplies the Equinox OSGi Framework extension to launch Equinox frameworks.
&lt;/p&gt;
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="copyright"/>
      </appInfo>
      <documentation>
         Copyright (c) 2006 IBM Corporation and others.
&lt;br&gt;
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 
&lt;a href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;.
      </documentation>
   </annotation>

</schema>

Lines 11-16 Link Here

(-)src/org/eclipse/pde/internal/ui/wizards/product/ProductFromConfigOperation.java (-2 / +4 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.pde.internal.ui.wizards.product;	12	package org.eclipse.pde.internal.ui.wizards.product;
13		13
		14	import org.eclipse.pde.launching.IPDELauncherConstants;
		15
		16	import org.eclipse.pde.internal.launching.launcher.BundleLauncherHelper;
		17
14	import java.util.*;	18	import java.util.*;
15	import org.eclipse.core.resources.IContainer;	19	import org.eclipse.core.resources.IContainer;
16	import org.eclipse.core.resources.IFile;	20	import org.eclipse.core.resources.IFile;
Lines 21-28 Link Here
21	import org.eclipse.pde.internal.core.iproduct.*;	25	import org.eclipse.pde.internal.core.iproduct.*;
22	import org.eclipse.pde.internal.core.iproduct.IProduct;	26	import org.eclipse.pde.internal.core.iproduct.IProduct;
23	import org.eclipse.pde.internal.ui.PDEPlugin;	27	import org.eclipse.pde.internal.ui.PDEPlugin;
24	import org.eclipse.pde.internal.ui.launcher.BundleLauncherHelper;
25	import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
26		28
27	/**	29	/**
28	* This operation generates a product configuration filling in fields based on information	30	* This operation generates a product configuration filling in fields based on information

Lines 2-8 Link Here

(-)META-INF/MANIFEST.MF (-2 / +3 lines)
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-Name: %name	3	Bundle-Name: %name
4	Bundle-SymbolicName: org.eclipse.pde.ui; singleton:=true	4	Bundle-SymbolicName: org.eclipse.pde.ui; singleton:=true
5	Bundle-Version: 3.5.100.qualifier	5	Bundle-Version: 3.6.0.qualifier
6	Bundle-Activator: org.eclipse.pde.internal.ui.PDEPlugin	6	Bundle-Activator: org.eclipse.pde.internal.ui.PDEPlugin
7	Bundle-Vendor: %provider-name	7	Bundle-Vendor: %provider-name
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
Lines 103-109 Link Here
103	org.eclipse.equinox.p2.metadata.repository;bundle-version="[1.0.100,2.0.0)",	103	org.eclipse.equinox.p2.metadata.repository;bundle-version="[1.0.100,2.0.0)",
104	org.eclipse.equinox.frameworkadmin;bundle-version="[1.0.100,2.0.0)",	104	org.eclipse.equinox.frameworkadmin;bundle-version="[1.0.100,2.0.0)",
105	org.eclipse.equinox.frameworkadmin.equinox;bundle-version="[1.0.100,2.0.0)",	105	org.eclipse.equinox.frameworkadmin.equinox;bundle-version="[1.0.100,2.0.0)",
106	org.eclipse.equinox.p2.repository;bundle-version="[1.0.0,2.0.0)"	106	org.eclipse.equinox.p2.repository;bundle-version="[1.0.0,2.0.0)",
		107	org.eclipse.pde.launching;bundle-version="[3.6.0,4.0.0)";visibility:=reexport
107	Eclipse-LazyStart: true	108	Eclipse-LazyStart: true
108	Import-Package: com.ibm.icu.text,	109	Import-Package: com.ibm.icu.text,
109	org.eclipse.jdt.debug.core	110	org.eclipse.jdt.debug.core

Lines 21-28 Link Here

(-)src/org/eclipse/pde/internal/ui/editor/product/ProductValidateAction.java (-1 / +1 lines)
21	import org.eclipse.pde.internal.core.*;	21	import org.eclipse.pde.internal.core.*;
22	import org.eclipse.pde.internal.core.ifeature.*;	22	import org.eclipse.pde.internal.core.ifeature.*;
23	import org.eclipse.pde.internal.core.iproduct.*;	23	import org.eclipse.pde.internal.core.iproduct.*;
		24	import org.eclipse.pde.internal.launching.launcher.*;
24	import org.eclipse.pde.internal.ui.*;	25	import org.eclipse.pde.internal.ui.*;
25	import org.eclipse.pde.internal.ui.launcher.*;
26		26
27	public class ProductValidateAction extends Action {	27	public class ProductValidateAction extends Action {
28		28

Lines 1-5 Link Here

(-)src/org/eclipse/pde/internal/ui/editor/PDEMultiPageContentOutline.java (-2 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 13-18 Link Here
13	import java.util.ArrayList;	13	import java.util.ArrayList;
14	import org.eclipse.jface.action.*;	14	import org.eclipse.jface.action.*;
15	import org.eclipse.jface.viewers.*;	15	import org.eclipse.jface.viewers.*;
		16	import org.eclipse.pde.internal.launching.ILaunchingPreferenceConstants;
16	import org.eclipse.pde.internal.ui.*;	17	import org.eclipse.pde.internal.ui.*;
17	import org.eclipse.swt.SWT;	18	import org.eclipse.swt.SWT;
18	import org.eclipse.swt.events.FocusListener;	19	import org.eclipse.swt.events.FocusListener;
Lines 24-30 Link Here
24	import org.eclipse.ui.part.PageBook;	25	import org.eclipse.ui.part.PageBook;
25	import org.eclipse.ui.views.contentoutline.IContentOutlinePage;	26	import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
26		27
27	public class PDEMultiPageContentOutline extends Page implements IContentOutlinePage, ISelectionProvider, ISelectionChangedListener, IPreferenceConstants {	28	public class PDEMultiPageContentOutline extends Page implements IContentOutlinePage, ISelectionProvider, ISelectionChangedListener, ILaunchingPreferenceConstants {
28	private PageBook pagebook;	29	private PageBook pagebook;
29	private ISelection selection;	30	private ISelection selection;
30	private ArrayList listeners;	31	private ArrayList listeners;




/*******************************************************************************
 * Copyright (c) 2009 eXXcellent solutions gmbh, EclipseSource 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:
 *     Achim Demelt, eXXcellent solutions gmbh - initial API and implementation
 *     EclipseSource - initial API and implementation, ongoing enhancements
 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import org.eclipse.core.runtime.*;
import org.eclipse.debug.core.IStatusHandler;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.internal.launching.PDEMessages;
import org.eclipse.pde.internal.launching.launcher.*;
import org.eclipse.pde.internal.ui.*;
import org.eclipse.pde.internal.ui.elements.NamedElement;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;

public class PluginValidationStatusHandler implements IStatusHandler {
	public Object handleStatus(IStatus status, Object source) throws CoreException {
		if (status.getCode() == EclipsePluginValidationOperation.CREATE_EXTENSION_ERROR_CODE)
			return createExtensionError((String) source);
		else if (status.getCode() == LaunchPluginValidator.DISPLAY_VALIDATION_ERROR_CODE)
			displayValidationError((LaunchValidationOperation) source);
		return null;
	}

	private Object createExtensionError(String bundleID) {
		String name = NLS.bind(PDEMessages.EclipsePluginValidationOperation_pluginMissing, bundleID);
		PDELabelProvider provider = PDEPlugin.getDefault().getLabelProvider();
		Image image = provider.get(PDEPluginImages.DESC_PLUGIN_OBJ);
		return new NamedElement(name, image);
	}

	private void displayValidationError(final LaunchValidationOperation op) throws CoreException {
		final int[] result = new int[1];
		final Display display = LauncherUtilsStatusHandler.getDisplay();
		display.syncExec(new Runnable() {
			public void run() {
				PluginStatusDialog dialog = new PluginStatusDialog(display.getActiveShell());
				dialog.showCancelButton(true);
				dialog.setInput(op.getInput());
				result[0] = dialog.open();
			}
		});
		if (result[0] == IDialogConstants.CANCEL_ID)
			throw new CoreException(Status.CANCEL_STATUS);
	}

}




/*******************************************************************************
 * Copyright (c) 2009 eXXcellent solutions gmbh, EclipseSource 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:
 *     Achim Demelt, eXXcellent solutions gmbh - initial API and implementation
 *     EclipseSource - initial API and implementation, ongoing enhancements
 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import java.util.*;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.*;
import org.eclipse.debug.core.IStatusHandler;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.internal.launching.PDEMessages;
import org.eclipse.pde.internal.launching.launcher.LauncherUtils;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.pde.internal.ui.wizards.tools.OrganizeManifestsProcessor;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IWorkbenchWindow;

public class LauncherUtilsStatusHandler implements IStatusHandler {

	public Object handleStatus(IStatus status, Object source) throws CoreException {
		if (status.getCode() == LauncherUtils.WORKSPACE_LOCKED)
			handleWorkspaceLocked((String) source);
		else if (status.getCode() == LauncherUtils.CLEAR_LOG)
			return clearLog();
		else if (status.getCode() == LauncherUtils.DELETE_WORKSPACE)
			return deleteWorkspace((String) source);
		else if (status.getCode() == LauncherUtils.GENERATE_CONFIG_INI)
			return generateConfigIni();
		else if (status.getCode() == LauncherUtils.ORGANIZE_MANIFESTS) {
			Object[] args = (Object[]) source;
			organizeManifests((ArrayList) args[0], (IProgressMonitor) args[1], (Properties) args[2]);
		}
		return null;
	}

	private Boolean generateConfigIni() {
		String message = PDEUIMessages.LauncherUtils_generateConfigIni;
		return Boolean.valueOf(generateDialog(message).intValue() == 0);
	}

	private Integer deleteWorkspace(String path) {
		return generateDialog(NLS.bind(PDEUIMessages.WorkbenchLauncherConfigurationDelegate_confirmDeleteWorkspace, path));
	}

	private Integer clearLog() {
		return generateDialog(PDEUIMessages.LauncherUtils_clearLogFile);
	}

	private void handleWorkspaceLocked(String workspace) {
		generateErrorDialog(PDEUIMessages.LauncherUtils_workspaceLocked, NLS.bind(PDEMessages.LauncherUtils_cannotLaunchApplication, workspace));
	}

	private void organizeManifests(final ArrayList projects, final IProgressMonitor monitor, final Properties lastRun) {
		Display.getDefault().syncExec(new Runnable() {
			public void run() {
				OrganizeManifestsProcessor processor = new OrganizeManifestsProcessor(projects);
				initializeProcessor(processor);
				try {
					Change change = processor.createChange(monitor);
					change.perform(monitor);
					// update table for each project with current time stamp
					Properties table = lastRun;
					String ts = Long.toString(System.currentTimeMillis());
					Iterator it = projects.iterator();
					while (it.hasNext())
						table.put(((IProject) it.next()).getName(), ts);
				} catch (OperationCanceledException e) {
				} catch (CoreException e) {
				}
			}
		});
	}

	public static Display getDisplay() {
		Display display = Display.getCurrent();
		if (display == null) {
			display = Display.getDefault();
		}
		return display;
	}

	public final static Shell getActiveShell() {
		IWorkbenchWindow window = PDEPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow();
		if (window == null) {
			IWorkbenchWindow[] windows = PDEPlugin.getDefault().getWorkbench().getWorkbenchWindows();
			if (windows.length > 0)
				return windows[0].getShell();
		} else
			return window.getShell();
		return getDisplay().getActiveShell();
	}

	private static void initializeProcessor(OrganizeManifestsProcessor processor) {
		processor.setAddMissing(false);
		processor.setRemoveUnresolved(false);
		processor.setModifyDep(false);
		processor.setRemoveLazy(false);
		processor.setRemoveUselessFiles(false);
		processor.setAddDependencies(true);
		processor.setCalculateUses(false);
		processor.setMarkInternal(false);
		processor.setPrefixIconNL(false);
		processor.setUnusedDependencies(false);
		processor.setUnusedKeys(false);
	}

	/**
	 * Creates a message dialog using a syncExec in case we are launching in the background.
	 * Dialog will be a question dialog with Yes, No and Cancel buttons.
	 * @param message Message to use in the dialog
	 * @return int representing the button clicked (-1 or 2 for cancel, 0 for yes, 1 for no).
	 */
	private static Integer generateDialog(final String message) {
		final int[] result = new int[1];
		getDisplay().syncExec(new Runnable() {
			public void run() {
				String title = PDEUIMessages.LauncherUtils_title;
				MessageDialog dialog = new MessageDialog(getActiveShell(), title, null, message, MessageDialog.QUESTION, new String[] {IDialogConstants.YES_LABEL, IDialogConstants.NO_LABEL, IDialogConstants.CANCEL_LABEL}, 0);
				result[0] = dialog.open();
			}
		});
		return new Integer(result[0]);
	}

	private static void generateErrorDialog(final String title, final String message) {
		getDisplay().syncExec(new Runnable() {
			public void run() {
				MessageDialog dialog = new MessageDialog(getActiveShell(), title, null, message, MessageDialog.ERROR, new String[] {IDialogConstants.OK_LABEL}, 0);
				dialog.open();
			}
		});
	}

}




/*******************************************************************************
 * Copyright (c) 2009 eXXcellent solutions gmbh, EclipseSource 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:
 *     Achim Demelt, eXXcellent solutions gmbh - initial API and implementation
 *     EclipseSource - initial API and implementation, ongoing enhancements
 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import java.io.File;
import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.runtime.*;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.IStatusHandler;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.pde.internal.launching.PDEMessages;
import org.eclipse.pde.internal.launching.launcher.LaunchListener;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.*;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.internal.views.log.LogView;

public class LaunchTerminationStatusHandler implements IStatusHandler {
	// different ways to open the error log
	public static final int OPEN_IN_ERROR_LOG_VIEW = 0;
	public static final int OPEN_IN_SYSTEM_EDITOR = 1;

	public Object handleStatus(IStatus status, Object source) throws CoreException {
		if (status.getCode() == 13)
			handleOtherReasonsFoundInLog((ILaunch) source);
		else if (status.getCode() == 15)
			handleWorkspaceInUse();
		return null;
	}

	private void handleWorkspaceInUse() {
		Display.getDefault().asyncExec(new Runnable() {
			public void run() {
				MessageDialog.openError(PDEPlugin.getActiveWorkbenchShell(), PDEUIMessages.Launcher_error_title, PDEMessages.Launcher_error_code15);
			}
		});
	}

	private void handleOtherReasonsFoundInLog(final ILaunch launch) {
		Display.getDefault().asyncExec(new Runnable() {
			public void run() {
				try {
					File log = LaunchListener.getMostRecentLogFile(launch.getLaunchConfiguration());
					if (log != null && log.exists()) {
						MessageDialog dialog = new MessageDialog(PDEPlugin.getActiveWorkbenchShell(), PDEUIMessages.Launcher_error_title, null, // accept the default window icon
								PDEUIMessages.Launcher_error_code13, MessageDialog.ERROR, new String[] {PDEUIMessages.Launcher_error_displayInLogView, PDEUIMessages.Launcher_error_displayInSystemEditor, IDialogConstants.NO_LABEL}, OPEN_IN_ERROR_LOG_VIEW);
						int dialog_value = dialog.open();
						if (dialog_value == OPEN_IN_ERROR_LOG_VIEW) {
							LogView errlog = (LogView) PDEPlugin.getActivePage().showView("org.eclipse.pde.runtime.LogView"); //$NON-NLS-1$
							errlog.handleImportPath(log.getAbsolutePath());
							errlog.sortByDateDescending();
						} else if (dialog_value == OPEN_IN_SYSTEM_EDITOR) {
							openInEditor(log);
						}
					}
				} catch (CoreException e) {
				}
			}
		});
	}

	private void openInEditor(File log) {
		IFileStore fileStore = EFS.getLocalFileSystem().getStore(new Path(log.getAbsolutePath()));
		if (!fileStore.fetchInfo().isDirectory() && fileStore.fetchInfo().exists()) {
			IWorkbenchWindow ww = PDEPlugin.getActiveWorkbenchWindow();
			IWorkbenchPage page = ww.getActivePage();
			try {
				IDE.openEditorOnFileStore(page, fileStore);
			} catch (PartInitException e) {
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 eXXcellent solutions gmbh 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:
 *     Achim Demelt, eXXcellent solutions gmbh - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.debug.core.IStatusHandler;
import org.eclipse.pde.internal.ui.PDEPlugin;

public class GenericExceptionStatusHandler implements IStatusHandler {

	public Object handleStatus(IStatus status, Object source) throws CoreException {
		PDEPlugin.logException(status.getException());
		return null;
	}

}

Return to bug 278845

Lines 10-30 Link Here

(-)src/org/eclipse/pde/ui/tests/target/LocalTargetDefinitionTests.java (-6 / +5 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.pde.ui.tests.target;	11	package org.eclipse.pde.ui.tests.target;
12		12
13	import org.eclipse.pde.internal.core.target.provisional.IResolvedBundle;
14
15	import org.eclipse.pde.internal.core.target.*;
16
17	import java.io.*;	13	import java.io.*;
18	import java.net.URL;	14	import java.net.URL;
19	import java.util.*;	15	import java.util.*;
20	import junit.framework.*;	16	import junit.framework.Test;
		17	import junit.framework.TestSuite;
21	import org.eclipse.core.runtime.*;	18	import org.eclipse.core.runtime.*;
22	import org.eclipse.equinox.internal.provisional.frameworkadmin.BundleInfo;	19	import org.eclipse.equinox.internal.provisional.frameworkadmin.BundleInfo;
23	import org.eclipse.pde.core.plugin.IPluginModelBase;	20	import org.eclipse.pde.core.plugin.IPluginModelBase;
24	import org.eclipse.pde.core.plugin.TargetPlatform;	21	import org.eclipse.pde.core.plugin.TargetPlatform;
25	import org.eclipse.pde.internal.core.*;	22	import org.eclipse.pde.internal.core.*;
		23	import org.eclipse.pde.internal.core.target.TargetDefinition;
		24	import org.eclipse.pde.internal.core.target.TargetDefinitionPersistenceHelper;
26	import org.eclipse.pde.internal.core.target.provisional.*;	25	import org.eclipse.pde.internal.core.target.provisional.*;
27	import org.eclipse.pde.internal.ui.launcher.LaunchArgumentsHelper;	26	import org.eclipse.pde.internal.launching.launcher.LaunchArgumentsHelper;
28	import org.eclipse.pde.internal.ui.tests.macro.MacroPlugin;	27	import org.eclipse.pde.internal.ui.tests.macro.MacroPlugin;
29	import org.osgi.framework.ServiceReference;	28	import org.osgi.framework.ServiceReference;
30		29

Lines 1-5 Link Here

(-)src/org/eclipse/pde/ui/launcher/PDESourcePathProvider.java (-119 / +4 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2006, 2008 IBM Corporation and others.	2	* Copyright (c) 2006, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 10-139 Link Here
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.pde.ui.launcher;	11	package org.eclipse.pde.ui.launcher;
12		12
13	import java.util.ArrayList;
14	import java.util.List;
15	import org.eclipse.core.resources.IProject;
16	import org.eclipse.core.resources.IResource;
17	import org.eclipse.core.runtime.*;
18	import org.eclipse.debug.core.ILaunchConfiguration;
19	import org.eclipse.jdt.core.*;
20	import org.eclipse.jdt.launching.*;
21	import org.eclipse.pde.internal.core.util.PDEJavaHelper;
22	import org.eclipse.pde.internal.ui.PDEPlugin;
23	import org.eclipse.pde.internal.ui.launcher.LaunchPluginValidator;
24	import org.eclipse.pde.internal.ui.launcher.VMHelper;
25
26	/**	13	/**
27	* Generates a source lookup path for all PDE-based launch configurations	14	* Generates a source lookup path for all PDE-based launch configurations
28	* <p>	15	* <p>
29	* Clients may subclass this class.	16	* Clients may subclass this class.
30	* </p>	17	* </p>
31	* @since 3.3	18	* @since 3.3
		19	* @deprecated use {@link org.eclipse.pde.launching.PDESourcePathProvider} instead.
		20	* @see org.eclipse.pde.launching.PDESourcePathProvider
32	*/	21	*/
33	public class PDESourcePathProvider extends StandardSourcePathProvider {	22	public class PDESourcePathProvider extends org.eclipse.pde.launching.PDESourcePathProvider {
34
35	public static final String ID = "org.eclipse.pde.ui.workbenchClasspathProvider"; //$NON-NLS-1$
36
37	/*
38	* (non-Javadoc)
39	* @see org.eclipse.jdt.launching.StandardSourcePathProvider#computeUnresolvedClasspath(org.eclipse.debug.core.ILaunchConfiguration)
40	*/
41	public IRuntimeClasspathEntry[] computeUnresolvedClasspath(ILaunchConfiguration configuration) throws CoreException {
42	List sourcePath = new ArrayList();
43	sourcePath.add(getJREEntry(configuration));
44	IProject[] projects = getJavaProjects(configuration);
45	for (int i = 0; i < projects.length; i++) {
46	sourcePath.add(JavaRuntime.newProjectRuntimeClasspathEntry(JavaCore.create(projects[i])));
47	}
48	return (IRuntimeClasspathEntry[]) sourcePath.toArray(new IRuntimeClasspathEntry[sourcePath.size()]);
49	}
50
51	/**
52	* Returns a JRE runtime classpath entry
53	*
54	* @param configuration
55	* the launch configuration
56	* @return a JRE runtime classpath entry
57	* @throws CoreException
58	* if the JRE associated with the launch configuration cannot be found
59	* or if unable to retrieve the launch configuration attributes
60	*/
61	private IRuntimeClasspathEntry getJREEntry(ILaunchConfiguration configuration) throws CoreException {
62	IVMInstall jre = VMHelper.createLauncher(configuration);
63	IPath containerPath = new Path(JavaRuntime.JRE_CONTAINER);
64	containerPath = containerPath.append(jre.getVMInstallType().getId());
65	containerPath = containerPath.append(jre.getName());
66	return JavaRuntime.newRuntimeContainerClasspathEntry(containerPath, IRuntimeClasspathEntry.BOOTSTRAP_CLASSES);
67	}
68
69	/**
70	* Returns an array of sorted plug-in projects that represent plug-ins participating
71	* in the launch
72	*
73	* @param configuration
74	* the launch configuration
75	* @return an array of ordered projects
76	* @throws CoreException
77	* if unable to retrieve attributes from the launch configuration or if
78	* an error occurs when checking the nature of the project
79	*
80	*/
81	private IProject[] getJavaProjects(ILaunchConfiguration configuration) throws CoreException {
82	IProject[] projects = LaunchPluginValidator.getAffectedProjects(configuration);
83	return PDEPlugin.getWorkspace().computeProjectOrder(projects).projects;
84	}
85
86	/*
87	* (non-Javadoc)
88	* @see org.eclipse.jdt.launching.StandardSourcePathProvider#resolveClasspath(org.eclipse.jdt.launching.IRuntimeClasspathEntry[], org.eclipse.debug.core.ILaunchConfiguration)
89	*/
90	public IRuntimeClasspathEntry[] resolveClasspath(IRuntimeClasspathEntry[] entries, ILaunchConfiguration configuration) throws CoreException {
91	List all = new ArrayList(entries.length);
92	for (int i = 0; i < entries.length; i++) {
93	if (entries[i].getType() == IRuntimeClasspathEntry.PROJECT) {
94	// a project resolves to itself for source lookup (rather than
95	// the class file output locations)
96	all.add(entries[i]);
97	// also add non-JRE libraries
98	IResource resource = entries[i].getResource();
99	if (resource instanceof IProject) {
100	addBinaryPackageFragmentRoots(JavaCore.create((IProject) resource), all);
101	}
102	} else {
103	IRuntimeClasspathEntry[] resolved = JavaRuntime.resolveRuntimeClasspathEntry(entries[i], configuration);
104	for (int j = 0; j < resolved.length; j++) {
105	all.add(resolved[j]);
106	}
107	}
108	}
109	return (IRuntimeClasspathEntry[]) all.toArray(new IRuntimeClasspathEntry[all.size()]);
110	}
111
112	/**
113	* Adds runtime classpath entries for binary package fragment roots contained within
114	* the project
115	*
116	* @param jProject
117	* the Java project whose roots are to be enumerated
118	* @param all
119	* a list of accumulated runtime classpath entries
120	* @throws CoreException
121	* if unable to evaluate the package fragment roots
122	*/
123	private void addBinaryPackageFragmentRoots(IJavaProject jProject, List all) throws CoreException {
124	IPackageFragmentRoot[] roots = jProject.getPackageFragmentRoots();
125	for (int j = 0; j < roots.length; j++) {
126	if (roots[j].getKind() == IPackageFragmentRoot.K_BINARY && !PDEJavaHelper.isJRELibrary(roots[j])) {
127	IRuntimeClasspathEntry rte = JavaRuntime.newArchiveRuntimeClasspathEntry(roots[j].getPath());
128	IPath path = roots[j].getSourceAttachmentPath();
129	if (path != null) {
130	rte.setSourceAttachmentPath(path);
131	rte.setSourceAttachmentRootPath(roots[j].getSourceAttachmentRootPath());
132	}
133	if (!all.contains(rte))
134	all.add(rte);
135	}
136	}
137		23
138	}
139	}	24	}

Lines 22-30 Link Here

(-)src/org/eclipse/pde/ui/launcher/EquinoxLaunchConfiguration.java (-8 / +10 lines)
22	import org.eclipse.pde.internal.core.ClasspathHelper;	22	import org.eclipse.pde.internal.core.ClasspathHelper;
23	import org.eclipse.pde.internal.core.P2Utils;	23	import org.eclipse.pde.internal.core.P2Utils;
24	import org.eclipse.pde.internal.core.util.CoreUtility;	24	import org.eclipse.pde.internal.core.util.CoreUtility;
25	import org.eclipse.pde.internal.ui.IPDEUIConstants;	25	import org.eclipse.pde.internal.launching.IPDEConstants;
26	import org.eclipse.pde.internal.ui.PDEUIMessages;	26	import org.eclipse.pde.internal.launching.PDEMessages;
27	import org.eclipse.pde.internal.ui.launcher.*;	27	import org.eclipse.pde.internal.launching.launcher.*;
28		28
29	/**	29	/**
30	* A launch delegate for launching the Equinox framework	30	* A launch delegate for launching the Equinox framework
Lines 32-37 Link Here
32	* Clients may subclass and instantiate this class.	32	* Clients may subclass and instantiate this class.
33	* </p>	33	* </p>
34	* @since 3.2	34	* @since 3.2
		35	* @deprecated use {@link org.eclipse.pde.launching.EquinoxLaunchConfiguration} instead.
		36	* @see org.eclipse.pde.launching.EquinoxLaunchConfiguration
35	*/	37	*/
36	public class EquinoxLaunchConfiguration extends AbstractPDELaunchConfiguration {	38	public class EquinoxLaunchConfiguration extends AbstractPDELaunchConfiguration {
37		39
Lines 68-76 Link Here
68	properties.setProperty("osgi.install.area", "file:" + TargetPlatform.getLocation()); //$NON-NLS-1$ //$NON-NLS-2$	70	properties.setProperty("osgi.install.area", "file:" + TargetPlatform.getLocation()); //$NON-NLS-1$ //$NON-NLS-2$
69	properties.setProperty("osgi.configuration.cascaded", "false"); //$NON-NLS-1$ //$NON-NLS-2$	71	properties.setProperty("osgi.configuration.cascaded", "false"); //$NON-NLS-1$ //$NON-NLS-2$
70	properties.put("osgi.framework", LaunchConfigurationHelper.getBundleURL(IPDEBuildConstants.BUNDLE_OSGI, fAllBundles, false)); //$NON-NLS-1$	72	properties.put("osgi.framework", LaunchConfigurationHelper.getBundleURL(IPDEBuildConstants.BUNDLE_OSGI, fAllBundles, false)); //$NON-NLS-1$
71	int start = configuration.getAttribute(IPDELauncherConstants.DEFAULT_START_LEVEL, 4);	73	int start = configuration.getAttribute(org.eclipse.pde.launching.IPDELauncherConstants.DEFAULT_START_LEVEL, 4);
72	properties.put("osgi.bundles.defaultStartLevel", Integer.toString(start)); //$NON-NLS-1$	74	properties.put("osgi.bundles.defaultStartLevel", Integer.toString(start)); //$NON-NLS-1$
73	boolean autostart = configuration.getAttribute(IPDELauncherConstants.DEFAULT_AUTO_START, true);	75	boolean autostart = configuration.getAttribute(org.eclipse.pde.launching.IPDELauncherConstants.DEFAULT_AUTO_START, true);
74		76
75	String bundles = null;	77	String bundles = null;
76	if (fAllBundles.containsKey(IPDEBuildConstants.BUNDLE_SIMPLE_CONFIGURATOR)) {	78	if (fAllBundles.containsKey(IPDEBuildConstants.BUNDLE_SIMPLE_CONFIGURATOR)) {
Lines 93-99 Link Here
93	if (bundles.length() > 0)	95	if (bundles.length() > 0)
94	properties.put("osgi.bundles", bundles); //$NON-NLS-1$	96	properties.put("osgi.bundles", bundles); //$NON-NLS-1$
95		97
96	if (!"3.3".equals(configuration.getAttribute(IPDEUIConstants.LAUNCHER_PDE_VERSION, ""))) { //$NON-NLS-1$ //$NON-NLS-2$	98	if (!"3.3".equals(configuration.getAttribute(IPDEConstants.LAUNCHER_PDE_VERSION, ""))) { //$NON-NLS-1$ //$NON-NLS-2$
97	properties.put("eclipse.ignoreApp", "true"); //$NON-NLS-1$ //$NON-NLS-2$	99	properties.put("eclipse.ignoreApp", "true"); //$NON-NLS-1$ //$NON-NLS-2$
98	properties.put("osgi.noShutdown", "true"); //$NON-NLS-1$ //$NON-NLS-2$	100	properties.put("osgi.noShutdown", "true"); //$NON-NLS-1$ //$NON-NLS-2$
99	}	101	}
Lines 169-175 Link Here
169	fModels.put(model, "default:default"); //$NON-NLS-1$	171	fModels.put(model, "default:default"); //$NON-NLS-1$
170	fAllBundles.put(IPDEBuildConstants.BUNDLE_OSGI, model);	172	fAllBundles.put(IPDEBuildConstants.BUNDLE_OSGI, model);
171	} else {	173	} else {
172	String message = PDEUIMessages.EquinoxLaunchConfiguration_oldTarget;	174	String message = PDEMessages.EquinoxLaunchConfiguration_oldTarget;
173	throw new CoreException(LauncherUtils.createErrorStatus(message));	175	throw new CoreException(LauncherUtils.createErrorStatus(message));
174	}	176	}
175	}	177	}
Lines 198-204 Link Here
198	*/	200	*/
199	protected void clear(ILaunchConfiguration configuration, IProgressMonitor monitor) throws CoreException {	201	protected void clear(ILaunchConfiguration configuration, IProgressMonitor monitor) throws CoreException {
200	// clear config area, if necessary	202	// clear config area, if necessary
201	if (configuration.getAttribute(IPDELauncherConstants.CONFIG_CLEAR_AREA, false))	203	if (configuration.getAttribute(org.eclipse.pde.launching.IPDELauncherConstants.CONFIG_CLEAR_AREA, false))
202	CoreUtility.deleteContent(getConfigDir(configuration));	204	CoreUtility.deleteContent(getConfigDir(configuration));
203	}	205	}
204		206

Lines 23-31 Link Here

(-)src/org/eclipse/pde/ui/launcher/EclipseApplicationLaunchConfiguration.java (-13 / +15 lines)
23	import org.eclipse.pde.internal.core.*;	23	import org.eclipse.pde.internal.core.*;
24	import org.eclipse.pde.internal.core.util.CoreUtility;	24	import org.eclipse.pde.internal.core.util.CoreUtility;
25	import org.eclipse.pde.internal.core.util.VersionUtil;	25	import org.eclipse.pde.internal.core.util.VersionUtil;
		26	import org.eclipse.pde.internal.launching.PDEMessages;
		27	import org.eclipse.pde.internal.launching.launcher.*;
26	import org.eclipse.pde.internal.ui.PDEPlugin;	28	import org.eclipse.pde.internal.ui.PDEPlugin;
27	import org.eclipse.pde.internal.ui.PDEUIMessages;
28	import org.eclipse.pde.internal.ui.launcher.*;
29	import org.osgi.framework.Version;	29	import org.osgi.framework.Version;
30		30
31	/**	31	/**
Lines 34-39 Link Here
34	* Clients may subclass and instantiate this class.	34	* Clients may subclass and instantiate this class.
35	* </p>	35	* </p>
36	* @since 3.2	36	* @since 3.2
		37	* @deprecated use {@link org.eclipse.pde.launching.EclipseApplicationLaunchConfiguration}
		38	* @see org.eclipse.pde.launching.AbstractPDELaunchConfiguration
37	*/	39	*/
38	public class EclipseApplicationLaunchConfiguration extends AbstractPDELaunchConfiguration {	40	public class EclipseApplicationLaunchConfiguration extends AbstractPDELaunchConfiguration {
39		41
Lines 58-76 Link Here
58	ArrayList programArgs = new ArrayList();	60	ArrayList programArgs = new ArrayList();
59		61
60	// If a product is specified, then add it to the program args	62	// If a product is specified, then add it to the program args
61	if (configuration.getAttribute(IPDELauncherConstants.USE_PRODUCT, false)) {	63	if (configuration.getAttribute(org.eclipse.pde.launching.IPDELauncherConstants.USE_PRODUCT, false)) {
62	String product = configuration.getAttribute(IPDELauncherConstants.PRODUCT, ""); //$NON-NLS-1$	64	String product = configuration.getAttribute(org.eclipse.pde.launching.IPDELauncherConstants.PRODUCT, ""); //$NON-NLS-1$
63	if (product.length() > 0) {	65	if (product.length() > 0) {
64	programArgs.add("-product"); //$NON-NLS-1$	66	programArgs.add("-product"); //$NON-NLS-1$
65	programArgs.add(product);	67	programArgs.add(product);
66	} else { // TODO product w/o an application and product... how to handle gracefully?	68	} else { // TODO product w/o an application and product... how to handle gracefully?
67	programArgs.add("-application"); //$NON-NLS-1$	69	programArgs.add("-application"); //$NON-NLS-1$
68	programArgs.add(configuration.getAttribute(IPDELauncherConstants.APPLICATION, "")); //$NON-NLS-1$	70	programArgs.add(configuration.getAttribute(org.eclipse.pde.launching.IPDELauncherConstants.APPLICATION, "")); //$NON-NLS-1$
69	}	71	}
70	} else {	72	} else {
71	// specify the application to launch	73	// specify the application to launch
72	programArgs.add("-application"); //$NON-NLS-1$	74	programArgs.add("-application"); //$NON-NLS-1$
73	programArgs.add(configuration.getAttribute(IPDELauncherConstants.APPLICATION, TargetPlatform.getDefaultApplication()));	75	programArgs.add(configuration.getAttribute(org.eclipse.pde.launching.IPDELauncherConstants.APPLICATION, TargetPlatform.getDefaultApplication()));
74	}	76	}
75		77
76	// specify the workspace location for the runtime workbench	78	// specify the workspace location for the runtime workbench
Lines 83-94 Link Here
83	}	85	}
84		86
85	boolean showSplash = true;	87	boolean showSplash = true;
86	if (configuration.getAttribute(IPDELauncherConstants.USEFEATURES, false)) {	88	if (configuration.getAttribute(org.eclipse.pde.launching.IPDELauncherConstants.USEFEATURES, false)) {
87	validateFeatures();	89	validateFeatures();
88	IPath installPath = PDEPlugin.getWorkspace().getRoot().getLocation();	90	IPath installPath = PDEPlugin.getWorkspace().getRoot().getLocation();
89	programArgs.add("-install"); //$NON-NLS-1$	91	programArgs.add("-install"); //$NON-NLS-1$
90	programArgs.add("file:" + installPath.removeLastSegments(1).addTrailingSeparator().toString()); //$NON-NLS-1$	92	programArgs.add("file:" + installPath.removeLastSegments(1).addTrailingSeparator().toString()); //$NON-NLS-1$
91	if (!configuration.getAttribute(IPDELauncherConstants.CONFIG_USE_DEFAULT_AREA, true)) {	93	if (!configuration.getAttribute(org.eclipse.pde.launching.IPDELauncherConstants.CONFIG_USE_DEFAULT_AREA, true)) {
92	programArgs.add("-configuration"); //$NON-NLS-1$	94	programArgs.add("-configuration"); //$NON-NLS-1$
93	programArgs.add("file:" + new Path(getConfigDir(configuration).getPath()).addTrailingSeparator().toString()); //$NON-NLS-1$	95	programArgs.add("file:" + new Path(getConfigDir(configuration).getPath()).addTrailingSeparator().toString()); //$NON-NLS-1$
94	}	96	}
Lines 158-164 Link Here
158	\|\| !featuresPath.toFile().exists();	160	\|\| !featuresPath.toFile().exists();
159	}	161	}
160	if (badStructure) {	162	if (badStructure) {
161	throw new CoreException(LauncherUtils.createErrorStatus(PDEUIMessages.WorkbenchLauncherConfigurationDelegate_badFeatureSetup));	163	throw new CoreException(LauncherUtils.createErrorStatus(PDEMessages.WorkbenchLauncherConfigurationDelegate_badFeatureSetup));
162	}	164	}
163	// Ensure important files are present	165	// Ensure important files are present
164	ensureProductFilesExist(getProductPath());	166	ensureProductFilesExist(getProductPath());
Lines 196-202 Link Here
196	protected File getConfigDir(ILaunchConfiguration config) {	198	protected File getConfigDir(ILaunchConfiguration config) {
197	if (fConfigDir == null) {	199	if (fConfigDir == null) {
198	try {	200	try {
199	if (config.getAttribute(IPDELauncherConstants.USEFEATURES, false) && config.getAttribute(IPDELauncherConstants.CONFIG_USE_DEFAULT_AREA, true)) {	201	if (config.getAttribute(org.eclipse.pde.launching.IPDELauncherConstants.USEFEATURES, false) && config.getAttribute(org.eclipse.pde.launching.IPDELauncherConstants.CONFIG_USE_DEFAULT_AREA, true)) {
200	String root = getProductPath().toString();	202	String root = getProductPath().toString();
201	root += "/configuration"; //$NON-NLS-1$	203	root += "/configuration"; //$NON-NLS-1$
202	fConfigDir = new File(root);	204	fConfigDir = new File(root);
Lines 233-239 Link Here
233	throw new CoreException(Status.CANCEL_STATUS);	235	throw new CoreException(Status.CANCEL_STATUS);
234		236
235	// clear config area, if necessary	237	// clear config area, if necessary
236	if (configuration.getAttribute(IPDELauncherConstants.CONFIG_CLEAR_AREA, false))	238	if (configuration.getAttribute(org.eclipse.pde.launching.IPDELauncherConstants.CONFIG_CLEAR_AREA, false))
237	CoreUtility.deleteContent(getConfigDir(configuration));	239	CoreUtility.deleteContent(getConfigDir(configuration));
238	}	240	}
239		241
Lines 255-262 Link Here
255	}	257	}
256		258
257	private void validateConfigIni(ILaunchConfiguration configuration) throws CoreException {	259	private void validateConfigIni(ILaunchConfiguration configuration) throws CoreException {
258	if (!configuration.getAttribute(IPDELauncherConstants.CONFIG_GENERATE_DEFAULT, true)) {	260	if (!configuration.getAttribute(org.eclipse.pde.launching.IPDELauncherConstants.CONFIG_GENERATE_DEFAULT, true)) {
259	String templateLoc = configuration.getAttribute(IPDELauncherConstants.CONFIG_TEMPLATE_LOCATION, ""); //$NON-NLS-1$	261	String templateLoc = configuration.getAttribute(org.eclipse.pde.launching.IPDELauncherConstants.CONFIG_TEMPLATE_LOCATION, ""); //$NON-NLS-1$
260	IStringVariableManager mgr = VariablesPlugin.getDefault().getStringVariableManager();	262	IStringVariableManager mgr = VariablesPlugin.getDefault().getStringVariableManager();
261	templateLoc = mgr.performStringSubstitution(templateLoc);	263	templateLoc = mgr.performStringSubstitution(templateLoc);
262		264

Lines 10-15 Link Here

(-)src/org/eclipse/pde/ui/launcher/JUnitWorkbenchLaunchShortcut.java (-7 / +10 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.pde.ui.launcher;	11	package org.eclipse.pde.ui.launcher;
12		12
		13	import org.eclipse.pde.launching.IPDELauncherConstants;
		14	import org.eclipse.pde.launching.PDESourcePathProvider;
		15
13	import org.eclipse.core.runtime.CoreException;	16	import org.eclipse.core.runtime.CoreException;
14	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;	17	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
15	import org.eclipse.jdt.core.IJavaElement;	18	import org.eclipse.jdt.core.IJavaElement;
Lines 17-25 Link Here
17	import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;	20	import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
18	import org.eclipse.pde.core.plugin.TargetPlatform;	21	import org.eclipse.pde.core.plugin.TargetPlatform;
19	import org.eclipse.pde.internal.core.TargetPlatformHelper;	22	import org.eclipse.pde.internal.core.TargetPlatformHelper;
20	import org.eclipse.pde.internal.ui.IPDEUIConstants;	23	import org.eclipse.pde.internal.launching.IPDEConstants;
21	import org.eclipse.pde.internal.ui.launcher.LaunchArgumentsHelper;	24	import org.eclipse.pde.internal.launching.launcher.LaunchArgumentsHelper;
22	import org.eclipse.pde.internal.ui.launcher.LauncherUtils;	25	import org.eclipse.pde.internal.launching.launcher.LauncherUtils;
23		26
24	/**	27	/**
25	* A launch shortcut capable of launching a Plug-in JUnit test.	28	* A launch shortcut capable of launching a Plug-in JUnit test.
Lines 43-55 Link Here
43	protected ILaunchConfigurationWorkingCopy createLaunchConfiguration(IJavaElement element) throws CoreException {	46	protected ILaunchConfigurationWorkingCopy createLaunchConfiguration(IJavaElement element) throws CoreException {
44	ILaunchConfigurationWorkingCopy configuration = super.createLaunchConfiguration(element);	47	ILaunchConfigurationWorkingCopy configuration = super.createLaunchConfiguration(element);
45	if (TargetPlatformHelper.usesNewApplicationModel())	48	if (TargetPlatformHelper.usesNewApplicationModel())
46	configuration.setAttribute(IPDEUIConstants.LAUNCHER_PDE_VERSION, "3.3"); //$NON-NLS-1$	49	configuration.setAttribute(IPDEConstants.LAUNCHER_PDE_VERSION, "3.3"); //$NON-NLS-1$
47	else if (TargetPlatformHelper.getTargetVersion() >= 3.2)	50	else if (TargetPlatformHelper.getTargetVersion() >= 3.2)
48	configuration.setAttribute(IPDEUIConstants.LAUNCHER_PDE_VERSION, "3.2a"); //$NON-NLS-1$	51	configuration.setAttribute(IPDEConstants.LAUNCHER_PDE_VERSION, "3.2a"); //$NON-NLS-1$
49	configuration.setAttribute(IPDELauncherConstants.LOCATION, LaunchArgumentsHelper.getDefaultJUnitWorkspaceLocation());	52	configuration.setAttribute(IPDELauncherConstants.LOCATION, LaunchArgumentsHelper.getDefaultJUnitWorkspaceLocation());
50	configuration.setAttribute(IPDELauncherConstants.DOCLEAR, true);	53	configuration.setAttribute(IPDELauncherConstants.DOCLEAR, true);
51	configuration.setAttribute(IPDELauncherConstants.ASKCLEAR, false);	54	configuration.setAttribute(IPDELauncherConstants.ASKCLEAR, false);
52	configuration.setAttribute(IPDEUIConstants.APPEND_ARGS_EXPLICITLY, true);	55	configuration.setAttribute(IPDEConstants.APPEND_ARGS_EXPLICITLY, true);
53		56
54	// Program to launch	57	// Program to launch
55	if (LauncherUtils.requiresUI(configuration)) {	58	if (LauncherUtils.requiresUI(configuration)) {
Lines 59-65 Link Here
59	configuration.setAttribute(IPDELauncherConstants.PRODUCT, product);	62	configuration.setAttribute(IPDELauncherConstants.PRODUCT, product);
60	}	63	}
61	} else {	64	} else {
62	configuration.setAttribute(IPDELauncherConstants.APPLICATION, IPDEUIConstants.CORE_TEST_APPLICATION);	65	configuration.setAttribute(IPDELauncherConstants.APPLICATION, IPDEConstants.CORE_TEST_APPLICATION);
63	}	66	}
64		67
65	// Plug-ins to launch	68	// Plug-ins to launch

Lines 19-398 Link Here

(-)src/org/eclipse/pde/ui/launcher/IPDELauncherConstants.java (-374 / +3 lines)
19	*	19	*
20	* @noimplement This interface is not intended to be implemented by clients.	20	* @noimplement This interface is not intended to be implemented by clients.
21	* @noextend This interface is not intended to be extended by clients.	21	* @noextend This interface is not intended to be extended by clients.
		22	* @deprecated use {@link org.eclipse.pde.launching.IPDELauncherConstants} instead.
		23	* @see org.eclipse.pde.launching.IPDELauncherConstants
22	*/	24	*/
23	public interface IPDELauncherConstants {	25	public interface IPDELauncherConstants extends org.eclipse.pde.launching.IPDELauncherConstants {
24		26
25	/**
26	* Launch configuration attribute key. The value is a string specifying
27	* workspace data location for an Eclipse application.
28	*/
29	String LOCATION = "location"; //$NON-NLS-1$
30
31	/**
32	* Launch configuration attribute key. The value is a boolean specifying
33	* workspace data location for an Eclipse application should be cleared
34	* prior to launching.
35	*/
36	String DOCLEAR = "clearws"; //$NON-NLS-1$
37
38	/**
39	* Launch configuration attribute key. The value is a boolean specifying
40	* whether the user should be prompted prior to clearing the workspace.
41	*
42	* @see IPDELauncherConstants#DOCLEAR
43	*/
44	String ASKCLEAR = "askclear"; //$NON-NLS-1$
45
46	/**
47	* Launch configuration attribute key. The value is a string specifying
48	* the application to run. If the value is <code>null</code>, the default
49	* application as specified in the target platform will be used.
50	*/
51	String APPLICATION = "application"; //$NON-NLS-1$
52
53	/**
54	* Launch configuration attribute key. The value is a string specifying
55	* the product to run.
56	*
57	* @see IPDELauncherConstants#APPLICATION
58	*/
59	String PRODUCT = "product"; //$NON-NLS-1$
60
61	/**
62	* Launch configuration attribute key. The value is a boolean specifying
63	* if the launch should appear in product-mode. If the value is <code>false</code>,
64	* the launch takes place in application-mode.
65	*
66	* @see IPDELauncherConstants#PRODUCT
67	* @see IPDELauncherConstants#APPLICATION
68	*/
69	String USE_PRODUCT = "useProduct"; //$NON-NLS-1$
70
71	/**
72	* Launch configuration attribute key used in Plug-in JUnit launch configurations only.
73	* The value is a string specifying the application to be tested.
74	* If the value is <code>null</code>, the default UI workbench application is tested.
75	*/
76	String APP_TO_TEST = "testApplication"; //$NON-NLS-1$
77
78	/**
79	* Launch configuration attribute key. The value is a string specifying
80	* the name of the VM to launch with. If the value is <code>null</code>,
81	* the default workspace VM is used.
82	*
83	* @deprecated use IJavaLaunchConfigurationConstants.ATTR_JRE_CONTAINER_PATH
84	*/
85	String VMINSTALL = "vminstall"; //$NON-NLS-1$
86
87	/**
88	* Launch configuration attribute key. The value is a string specifying
89	* the user-entered bootstrap classpath entries.
90	*/
91	String BOOTSTRAP_ENTRIES = "bootstrap"; //$NON-NLS-1$
92
93	/**
94	* Launch configuration attribute key. The value is a boolean specifying
95	* if the default self-hosting mode should be used when launching.
96	* The default being to launch with all workspace plug-ins and all the
97	* plug-ins that are explicitly checked on the Target Platform preference page.
98	*/
99	String USE_DEFAULT = "default"; //$NON-NLS-1$
100
101	/**
102	* Launch configuration attribute key. The value is a boolean specifying
103	* if the feature-based self-hosting mode should be used.
104	* The workspace must be set up properly for the feature-based self-hosting
105	* to succeed.
106	* Check the PDE Tips and Tricks section for how to set up feature-based self-hosting.
107	*/
108	String USEFEATURES = "usefeatures"; //$NON-NLS-1$
109
110	/**
111	* Launch configuration attribute key. The value is a string specifying
112	* a comma-separated list of IDs of workspace plug-ins to launch with.
113	* This value is only used when the Automatic Add option is off.
114	*
115	* @see IPDELauncherConstants#AUTOMATIC_ADD
116	*/
117	String SELECTED_WORKSPACE_PLUGINS = "selected_workspace_plugins"; //$NON-NLS-1$
118
119	/**
120	* Launch configuration attribute key. The value is a string specifying
121	* a comma-separated list of IDs of workspace plug-ins that are to be excluded from
122	* the launch.
123	* This value is only used when the Automatic Add option is on.
124	*
125	* @see IPDELauncherConstants#AUTOMATIC_ADD
126	*/
127	String DESELECTED_WORKSPACE_PLUGINS = "deselected_workspace_plugins"; //$NON-NLS-1$
128
129	/**
130	* Launch configuration attribute key. The value is a boolean specifying
131	* whether workspace plug-in created after the creation of a launch configuration
132	* should be added to the list of plug-ins to launch with.
133	*
134	* If the value is <code>true</code>, then DESELECTED_WORKSPACE_PLUGINS should be used.
135	* Otherwise, SELECTED_WORKSPACE_PLUGINS should be used.
136	*
137	* @see IPDELauncherConstants#DESELECTED_WORKSPACE_PLUGINS
138	* @see IPDELauncherConstants#SELECTED_WORKSPACE_PLUGINS
139	*/
140	String AUTOMATIC_ADD = "automaticAdd"; //$NON-NLS-1$
141
142	/**
143	* Launch configuration attribute key. The value is a boolean specifying
144	* whether the list of plug-ins to run should be validate prior to launching.
145	* If problems are found, they will be reported and the user will be able to cancel or
146	* continue.
147	* If no problems are found, the launch continues as normal.
148	*/
149	String AUTOMATIC_VALIDATE = "automaticValidate"; //$NON-NLS-1$
150
151	/**
152	* Launch configuration attribute key. The value is a string specifying
153	* a comma-separated list of IDs of target platform plug-ins to launch with.
154	* This value is only used when the Automatic Add option is off.
155	*/
156	String SELECTED_TARGET_PLUGINS = "selected_target_plugins"; //$NON-NLS-1$
157
158	/**
159	* Launch configuration attribute key. The value is a boolean indicating
160	* whether the computation of required plug-ins on the Plug-ins tab should include
161	* the traversal of optional dependencies.
162	*/
163	String INCLUDE_OPTIONAL = "includeOptional"; //$NON-NLS-1$
164
165	/**
166	* Launch configuration attribute key. The value is a boolean indicating
167	* whether tracing is enabled or disabled.
168	*/
169	String TRACING = "tracing"; //$NON-NLS-1$
170
171	/**
172	* Launch configuration attribute key. The value is a map containing the list
173	* of options to debug with.
174	*/
175	String TRACING_OPTIONS = "tracingOptions"; //$NON-NLS-1$
176
177	/**
178	* Launch configuration attribute key. The value is the id of the last plug-in
179	* that was selected on the Tracing tab.
180	*/
181	String TRACING_SELECTED_PLUGIN = "selectedPlugin"; //$NON-NLS-1$
182
183	/**
184	* Launch configuration attribute key. The value is the IDs of all plug-ins
185	* checked on the Tracing tab. The value may also be "[NONE]"
186	*
187	* @see IPDELauncherConstants#TRACING_NONE
188	*/
189	String TRACING_CHECKED = "checked"; //$NON-NLS-1$
190
191	/**
192	* Launch configuration attribute value indicating that, although tracing is enabled,
193	* no plug-ins have been selected to be traced.
194	*/
195	String TRACING_NONE = "[NONE]"; //$NON-NLS-1$
196
197	/**
198	* Launch configuration attribute key. The value is a boolean specifying
199	* if PDE should generate a default configuration area for the launch.
200	*
201	* If <code>true</code>, a configuration location in the PDE metadata area
202	* is created. Otherwise, the user is expected to specify a location.
203	*
204	* @see IPDELauncherConstants#CONFIG_LOCATION
205	*/
206	String CONFIG_USE_DEFAULT_AREA = "useDefaultConfigArea"; //$NON-NLS-1$
207
208	/**
209	* Launch configuration attribute key. The value is a string specifying
210	* the configuration area location for an Eclipse application launch.
211	*
212	* This key is only used when CONFIG_USE_DEFAULT_AREA is <code>false</code>.
213	*
214	* @see IPDELauncherConstants#CONFIG_USE_DEFAULT_AREA
215	*/
216	String CONFIG_LOCATION = "configLocation"; //$NON-NLS-1$
217
218	/**
219	* Launch configuration attribute key. The value is a boolean specifying
220	* if the configuration area location should be cleared prior to launching
221	*/
222	String CONFIG_CLEAR_AREA = "clearConfig"; //$NON-NLS-1$
223
224	/**
225	* Launch configuration atribute key. The value is a boolean specifying
226	* if PDE should generate a default config.ini file for the launch.
227	*
228	* If <code>true</code>, a configuration file is created.
229	* Otherwise, the user is expected to specify a config.ini to be used as a template.
230	*
231	* @see IPDELauncherConstants#CONFIG_TEMPLATE_LOCATION
232	*/
233	String CONFIG_GENERATE_DEFAULT = "useDefaultConfig"; //$NON-NLS-1$
234
235	/**
236	* Launch configuration attribute key. The value is a string specifying
237	* the location of the config.ini file to be used as a template for an
238	* Eclipse application launch.
239	*
240	* This key is only used when CONFIG_GENERATE_DEFAULT is <code>false</code>.
241	*
242	* @see IPDELauncherConstants#CONFIG_GENERATE_DEFAULT
243	*/
244	String CONFIG_TEMPLATE_LOCATION = "templateConfig"; //$NON-NLS-1$
245
246	/**
247	* Launch configuration attribute key. The value is a string specifying
248	* the location of the .product file with which this launch configuration
249	* is associated.
250	*/
251	String PRODUCT_FILE = "productFile"; //$NON-NLS-1$
252
253	/**
254	* Launch configuration attribute key. The value is the ID of an OSGi framework
255	* declared in an <code>org.eclipse.pde.ui.osgiLaunchers</code> extension point.
256	*
257	* @since 3.3
258	*/
259	String OSGI_FRAMEWORK_ID = "osgi_framework_id"; //$NON-NLS-1$
260
261	/**
262	* Launch configuration attribute key. The value is a boolean specifying
263	* if the default Auto-Start for an OSGi Framework launch configuration
264	* is <code>true</code> or <code>false</code>
265	*
266	* @see IPDELauncherConstants#DEFAULT_START_LEVEL
267	*/
268	String DEFAULT_AUTO_START = "default_auto_start"; //$NON-NLS-1$
269
270	/**
271	* Launch configuration attribute key. The value is an integer specifying
272	* the default start level for bundles in an OSGi Framework launch configuration.
273	*
274	* @see IPDELauncherConstants#DEFAULT_AUTO_START
275	*/
276	String DEFAULT_START_LEVEL = "default_start_level"; //$NON-NLS-1$
277
278	/**
279	* Launch configuration attribute key. The value is a comma-separated list
280	* of workspace bundles to launch with the OSGi framework.
281	*
282	* Each token in the list is of the format:
283	* <plugin-id>@<start-level>:<auto-start>
284	*
285	* @see IPDELauncherConstants#DEFAULT_AUTO_START
286	* @see IPDELauncherConstants#DEFAULT_START_LEVEL
287	*/
288	String WORKSPACE_BUNDLES = "workspace_bundles"; //$NON-NLS-1$
289
290	/**
291	* Launch configuration attribute key. The value is a comma-separated list
292	* of non-workspace bundles to launch with the OSGi framework.
293	*
294	* Each token in the list is of the format:
295	* <plugin-id>@<start-level>:<auto-start>
296	*
297	* @see IPDELauncherConstants#DEFAULT_AUTO_START
298	* @see IPDELauncherConstants#DEFAULT_START_LEVEL
299	*/
300	String TARGET_BUNDLES = "target_bundles"; //$NON-NLS-1$
301
302	/**
303	* Launch configuration attribute key. The value can be either the full path
304	* to the workspace location of a Target Definition (ie. .target file), or
305	* the ID of a target defined in an org.eclipse.pde.core.targets extension.
306	*/
307	String DEFINED_TARGET = "defined_target"; //$NON-NLS-1$
308
309	/**
310	* Launch configuration attribute key. The value is a boolean indicating
311	* whether or not to display only selected plug-ins.
312	*
313	* @since 3.4
314	*/
315	String SHOW_SELECTED_ONLY = "show_selected_only"; //$NON-NLS-1$
316
317	/**
318	* The unique tab identifier for the bundles tab
319	*
320	* @since 3.5
321	* @see BundlesTab
322	*/
323	String TAB_BUNDLES_ID = "org.eclipse.pde.ui.launch.tab.osgi.bundles"; //$NON-NLS-1$
324
325	/**
326	* The unique tab identifier for the configuration tab
327	*
328	* @since 3.5
329	* @see ConfigurationTab
330	*/
331	String TAB_CONFIGURATION_ID = "org.eclipse.pde.ui.launch.tab.configuration"; //$NON-NLS-1$
332
333	/**
334	* The unique tab identifier for the main tab
335	*
336	* @since 3.5
337	* @see MainTab
338	*/
339	String TAB_MAIN_ID = "org.eclipse.pde.ui.launch.tab.main"; //$NON-NLS-1$
340
341	/**
342	* The unique tab identifier for the osgi settings tab
343	*
344	* @since 3.5
345	* @see OSGiSettingsTab
346	*/
347	String TAB_OSGI_SETTINGS_ID = "org.eclipse.pde.ui.launch.tab.osgi.settings"; //$NON-NLS-1$
348
349	/**
350	* The unique tab identifier for the plug-in junit tab
351	*
352	* @since 3.5
353	* @see PluginJUnitMainTab
354	*/
355	String TAB_PLUGIN_JUNIT_MAIN_ID = "org.eclipse.pde.ui.launch.tab.junit.main"; //$NON-NLS-1$
356
357	/**
358	* The unique tab identifier for the plug-ins tab
359	*
360	* @since 3.5
361	* @see PluginsTab
362	*/
363	String TAB_PLUGINS_ID = "org.eclipse.pde.ui.launch.tab.plugins"; //$NON-NLS-1$
364
365	/**
366	* The unique tab identifier for the tracing tab
367	*
368	* @since 3.5
369	* @see TracingTab
370	*/
371	String TAB_TRACING_ID = "org.eclipse.pde.ui.launch.tab.tracing"; //$NON-NLS-1$
372
373	/**
374	* The unique tab identifier for the tracing tab
375	*
376	* @since 3.5
377	* @see TestTab
378	*/
379	String TAB_TEST_ID = "org.eclipse.pde.ui.launch.tab.test"; //$NON-NLS-1$
380
381	/**
382	* The launch configuration type id for OSGi launches.
383	*
384	* @since 3.5
385	* @see OSGiLaunchShortcut
386	*/
387	String OSGI_CONFIGURATION_TYPE = "org.eclipse.pde.ui.EquinoxLauncher"; //$NON-NLS-1$
388
389	/**
390	* Launch configuration attribute key. The value is a boolean specifying
391	* whether the tests should run on the UI thread.
392	*
393	* The default value is <code>true</code>
394	*
395	* @since 3.5
396	*/
397	String RUN_IN_UI_THREAD = "run_in_ui_thread"; //$NON-NLS-1$
398	}	27	}

Removed Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/PDEMigrationDelegate.java (-56 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007, 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.launcher;
12
13	import org.eclipse.core.runtime.CoreException;
14	import org.eclipse.core.runtime.IPath;
15	import org.eclipse.debug.core.*;
16	import org.eclipse.jdt.launching.*;
17	import org.eclipse.pde.internal.ui.IPDEUIConstants;
18	import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
19
20	public class PDEMigrationDelegate implements ILaunchConfigurationMigrationDelegate {
21
22	public boolean isCandidate(ILaunchConfiguration candidate) throws CoreException {
23	return !candidate.getAttribute(IPDEUIConstants.APPEND_ARGS_EXPLICITLY, false) \|\| candidate.hasAttribute(IPDELauncherConstants.VMINSTALL);
24	}
25
26	public void migrate(ILaunchConfiguration candidate) throws CoreException {
27	ILaunchConfigurationWorkingCopy wc = candidate.getWorkingCopy();
28	migrate(wc);
29	wc.doSave();
30	}
31
32	public void migrate(ILaunchConfigurationWorkingCopy candidate) throws CoreException {
33	if (!candidate.getAttribute(IPDEUIConstants.APPEND_ARGS_EXPLICITLY, false)) {
34	candidate.setAttribute(IPDEUIConstants.APPEND_ARGS_EXPLICITLY, true);
35	String args = candidate.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, ""); //$NON-NLS-1$
36	StringBuffer buffer = new StringBuffer(LaunchArgumentsHelper.getInitialProgramArguments());
37	if (args.length() > 0) {
38	buffer.append(" "); //$NON-NLS-1$
39	buffer.append(args);
40	}
41	candidate.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, buffer.toString());
42	}
43	if (candidate.hasAttribute(IPDELauncherConstants.VMINSTALL)) {
44	String name = candidate.getAttribute(IPDELauncherConstants.VMINSTALL, (String) null);
45	if (name != null) {
46	IVMInstall vm = VMHelper.getVMInstall(name);
47	if (vm != null) {
48	IPath path = JavaRuntime.newJREContainerPath(vm);
49	candidate.setAttribute(IJavaLaunchConfigurationConstants.ATTR_JRE_CONTAINER_PATH, path.toPortableString());
50	}
51	}
52	candidate.removeAttribute(IPDELauncherConstants.VMINSTALL);
53	}
54	}
55
56	}

Removed Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/LaunchConfigurationHelper.java (-453 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005, 2009 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.launcher;
12
13	import java.io.*;
14	import java.net.URL;
15	import java.util.*;
16	import org.eclipse.core.runtime.*;
17	import org.eclipse.core.variables.IStringVariableManager;
18	import org.eclipse.core.variables.VariablesPlugin;
19	import org.eclipse.debug.core.ILaunchConfiguration;
20	import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
21	import org.eclipse.osgi.service.resolver.BundleDescription;
22	import org.eclipse.pde.core.plugin.IPluginModelBase;
23	import org.eclipse.pde.core.plugin.TargetPlatform;
24	import org.eclipse.pde.internal.build.IPDEBuildConstants;
25	import org.eclipse.pde.internal.core.*;
26	import org.eclipse.pde.internal.ui.PDEPlugin;
27	import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
28
29	/**
30	* Contains helper methods for launching an Eclipse Runtime Workbench
31	*/
32	public class LaunchConfigurationHelper {
33
34	private static final String PROP_OSGI_FRAMEWORK = "osgi.framework"; //$NON-NLS-1$
35	private static final String PROP_OSGI_BUNDLES = "osgi.bundles"; //$NON-NLS-1$
36	private static final String PROP_P2_DATA_AREA = "eclipse.p2.data.area"; //$NON-NLS-1$
37
38	public static void synchronizeManifests(ILaunchConfiguration config, File configDir) {
39	try {
40	String programArgs = config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, ""); //$NON-NLS-1$
41	if (programArgs.indexOf("-clean") != -1) //$NON-NLS-1$
42	return;
43	} catch (CoreException e) {
44	}
45	File dir = new File(configDir, "org.eclipse.osgi/manifests"); //$NON-NLS-1$
46	if (dir.exists() && dir.isDirectory()) {
47	PDECore.getDefault().getJavaElementChangeListener().synchronizeManifests(dir);
48	}
49	}
50
51	public static File getConfigurationArea(ILaunchConfiguration config) {
52	File dir = getConfigurationLocation(config);
53	if (!dir.exists())
54	dir.mkdirs();
55	return dir;
56	}
57
58	public static File getConfigurationLocation(ILaunchConfiguration config) {
59	//bug 170213 change config location if config name contains #
60	String configName = config.getName();
61	configName = configName.replace('#', 'h');
62	File dir = new File(PDECore.getDefault().getStateLocation().toOSString(), configName);
63	try {
64	if (!config.getAttribute(IPDELauncherConstants.CONFIG_USE_DEFAULT_AREA, true)) {
65	String userPath = config.getAttribute(IPDELauncherConstants.CONFIG_LOCATION, (String) null);
66	if (userPath != null) {
67	userPath = getSubstitutedString(userPath);
68	dir = new File(userPath).getAbsoluteFile();
69	}
70	}
71	} catch (CoreException e) {
72	}
73	return dir;
74	}
75
76	private static String getSubstitutedString(String text) throws CoreException {
77	if (text == null)
78	return ""; //$NON-NLS-1$
79	IStringVariableManager mgr = VariablesPlugin.getDefault().getStringVariableManager();
80	return mgr.performStringSubstitution(text);
81	}
82
83	public static Properties createConfigIniFile(ILaunchConfiguration configuration, String productID, Map bundles, Map bundlesWithStartLevels, File directory) throws CoreException {
84	Properties properties = null;
85	// if we are to generate a config.ini, start with the values in the target platform's config.ini - bug 141918
86	if (configuration.getAttribute(IPDELauncherConstants.CONFIG_GENERATE_DEFAULT, true)) {
87	properties = TargetPlatformHelper.getConfigIniProperties();
88	// if target's config.ini does not exist, lets try to fill in default values
89	if (properties == null)
90	properties = new Properties();
91	// keep properties only if we are launching the default product (bug 175437)
92	else if (productID == null \|\| !productID.equals(properties.get("eclipse.product"))) //$NON-NLS-1$
93	properties.clear();
94	// if target's config.ini has the osgi.bundles header, then parse and compute the proper osgi.bundles value
95	String bundleList = properties.getProperty(PROP_OSGI_BUNDLES);
96	if (bundleList != null)
97	properties.setProperty(PROP_OSGI_BUNDLES, computeOSGiBundles(TargetPlatformHelper.stripPathInformation(bundleList), bundles, bundlesWithStartLevels));
98	String dataArea = properties.getProperty(PROP_P2_DATA_AREA);
99	if (dataArea != null) {
100	// Make the p2 data area in the configuration area itself, rather than a sibling of the configuration
101	// area (which is a the root pde.core shared metadata area) @see bug 272810
102	properties.setProperty(PROP_P2_DATA_AREA, "@config.dir/.p2"); //$NON-NLS-1$
103	}
104	} else {
105	String templateLoc = configuration.getAttribute(IPDELauncherConstants.CONFIG_TEMPLATE_LOCATION, (String) null);
106	if (templateLoc != null) {
107	properties = loadFromTemplate(getSubstitutedString(templateLoc));
108	// if template contains osgi.bundles, then only strip the path, do not compute the value
109	String osgiBundles = properties.getProperty(PROP_OSGI_BUNDLES);
110	if (osgiBundles != null)
111	properties.setProperty(PROP_OSGI_BUNDLES, TargetPlatformHelper.stripPathInformation(osgiBundles));
112	}
113	}
114	// whether we create a new config.ini or read from one as a template, we should add the required properties - bug 161265
115	if (properties != null) {
116	addRequiredProperties(properties, productID, bundles, bundlesWithStartLevels);
117	} else {
118	properties = new Properties();
119	}
120	if (!directory.exists()) {
121	directory.mkdirs();
122	}
123	String osgiBundles = properties.getProperty(PROP_OSGI_BUNDLES);
124	int start = configuration.getAttribute(IPDELauncherConstants.DEFAULT_START_LEVEL, 4);
125	properties.put("osgi.bundles.defaultStartLevel", Integer.toString(start)); //$NON-NLS-1$
126	boolean autostart = configuration.getAttribute(IPDELauncherConstants.DEFAULT_AUTO_START, false);
127
128	// if we are launching using P2, write out P2 files (bundles.txt) and add P2 property to config.ini
129	if (osgiBundles != null && osgiBundles.indexOf(IPDEBuildConstants.BUNDLE_SIMPLE_CONFIGURATOR) != -1 && bundles.containsKey(IPDEBuildConstants.BUNDLE_SIMPLE_CONFIGURATOR)) {
130	URL bundlesTxt = null;
131	boolean usedefault = configuration.getAttribute(IPDELauncherConstants.USE_DEFAULT, true);
132	boolean useFeatures = configuration.getAttribute(IPDELauncherConstants.USEFEATURES, false);
133	if (usedefault \|\| useFeatures) {
134	bundlesTxt = P2Utils.writeBundlesTxt(bundlesWithStartLevels, 4, false, directory, osgiBundles);
135	} else {
136	bundlesTxt = P2Utils.writeBundlesTxt(bundlesWithStartLevels, start, autostart, directory, null);
137	}
138
139	if (bundlesTxt != null) {
140	properties.setProperty("org.eclipse.equinox.simpleconfigurator.configUrl", bundlesTxt.toString()); //$NON-NLS-1$
141	// if we have simple configurator and update configurator together, ensure update doesn't reconcile
142	if (bundles.get(IPDEBuildConstants.BUNDLE_UPDATE_CONFIGURATOR) != null) {
143	properties.setProperty("org.eclipse.update.reconcile", "false"); //$NON-NLS-1$ //$NON-NLS-2$
144	}
145	}
146	}
147
148	setBundleLocations(bundles, properties, autostart);
149
150	save(new File(directory, "config.ini"), properties); //$NON-NLS-1$
151	return properties;
152	}
153
154	private static void addRequiredProperties(Properties properties, String productID, Map bundles, Map bundlesWithStartLevels) {
155	if (!properties.containsKey("osgi.install.area")) //$NON-NLS-1$
156	properties.setProperty("osgi.install.area", "file:" + TargetPlatform.getLocation()); //$NON-NLS-1$ //$NON-NLS-2$
157	if (!properties.containsKey("osgi.configuration.cascaded")) //$NON-NLS-1$
158	properties.setProperty("osgi.configuration.cascaded", "false"); //$NON-NLS-1$ //$NON-NLS-2$
159	if (!properties.containsKey(PROP_OSGI_FRAMEWORK))
160	properties.setProperty(PROP_OSGI_FRAMEWORK, IPDEBuildConstants.BUNDLE_OSGI);
161	if (!properties.containsKey("osgi.splashPath") && productID != null) //$NON-NLS-1$
162	addSplashLocation(properties, productID, bundles);
163	// if osgi.splashPath is set, try to resolve relative paths to absolute paths
164	if (properties.containsKey("osgi.splashPath")) //$NON-NLS-1$
165	resolveLocationPath(properties.getProperty("osgi.splashPath"), properties, bundles); //$NON-NLS-1$
166	if (!properties.containsKey(PROP_OSGI_BUNDLES))
167	properties.setProperty(PROP_OSGI_BUNDLES, computeOSGiBundles(TargetPlatform.getBundleList(), bundles, bundlesWithStartLevels));
168	if (!properties.containsKey("osgi.bundles.defaultStartLevel")) //$NON-NLS-1$
169	properties.setProperty("osgi.bundles.defaultStartLevel", "4"); //$NON-NLS-1$ //$NON-NLS-2$
170	}
171
172	/**
173	* Computes a list of osgi bundles to be put into the osgi.bundles property based
174	* on the bundles from the target platform config.ini and a map of bundles we are
175	* launching with. The list of bundles must have already had it's path information
176	* removed.
177	* @param bundleList list of bundles without path information
178	* @param bundles map of bundle id to bundle model, contains all bundles being launched with
179	* @param bundlesWithStartLevels map of bundles of start level
180	* @return string list of osgi bundles
181	*/
182	private static String computeOSGiBundles(String bundleList, Map bundles, Map bundlesWithStartLevels) {
183
184	// if p2 and only simple configurator and
185	// if simple configurator isn't selected & isn't in bundle list... hack it
186
187	// if using p2's simple configurator, a bundles.txt will be written, so we only need simple configurator in the config.ini
188	if (bundles.get(IPDEBuildConstants.BUNDLE_SIMPLE_CONFIGURATOR) != null)
189	return "org.eclipse.equinox.simpleconfigurator@1:start"; //$NON-NLS-1$
190
191	StringBuffer buffer = new StringBuffer();
192	Set initialBundleSet = new HashSet();
193	StringTokenizer tokenizer = new StringTokenizer(bundleList, ","); //$NON-NLS-1$
194	while (tokenizer.hasMoreTokens()) {
195	String token = tokenizer.nextToken();
196	int index = token.indexOf('@');
197	String id = index != -1 ? token.substring(0, index) : token;
198	if (bundles.containsKey(id)) {
199	if (buffer.length() > 0)
200	buffer.append(',');
201	buffer.append(id);
202	if (index != -1 && index < token.length() - 1)
203	buffer.append(token.substring(index));
204	initialBundleSet.add(id);
205	}
206	}
207
208	// if org.eclipse.update.configurator is not included (LIKE IN BASIC RCP APPLICATION), then write out all bundles in osgi.bundles - bug 170772
209	if (!initialBundleSet.contains(IPDEBuildConstants.BUNDLE_UPDATE_CONFIGURATOR)) {
210	initialBundleSet.add(IPDEBuildConstants.BUNDLE_OSGI);
211	Iterator iter = bundlesWithStartLevels.keySet().iterator();
212	while (iter.hasNext()) {
213	IPluginModelBase model = (IPluginModelBase) iter.next();
214	String id = model.getPluginBase().getId();
215	if (!initialBundleSet.contains(id)) {
216	if (buffer.length() > 0)
217	buffer.append(',');
218
219	String slinfo = (String) bundlesWithStartLevels.get(model);
220	buffer.append(id);
221	buffer.append('@');
222	buffer.append(slinfo);
223	}
224	}
225	}
226	return buffer.toString();
227	}
228
229	private static Properties loadFromTemplate(String templateLoc) throws CoreException {
230	Properties properties = new Properties();
231	File templateFile = new File(templateLoc);
232	if (templateFile.exists() && templateFile.isFile()) {
233	FileInputStream stream = null;
234	try {
235	stream = new FileInputStream(templateFile);
236	properties.load(stream);
237	} catch (Exception e) {
238	String message = e.getMessage();
239	if (message != null)
240	throw new CoreException(new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.ERROR, message, e));
241	} finally {
242	if (stream != null) {
243	try {
244	stream.close();
245	} catch (IOException e) {
246	}
247	}
248	}
249	}
250	return properties;
251	}
252
253	private static void addSplashLocation(Properties properties, String productID, Map map) {
254	Properties targetConfig = TargetPlatformHelper.getConfigIniProperties();
255	String targetProduct = targetConfig == null ? null : targetConfig.getProperty("eclipse.product"); //$NON-NLS-1$
256	String targetSplash = targetConfig == null ? null : targetConfig.getProperty("osgi.splashPath"); //$NON-NLS-1$
257	if (!productID.equals(targetProduct) \|\| targetSplash == null) {
258	ArrayList locations = new ArrayList();
259	String plugin = getContributingPlugin(productID);
260	locations.add(plugin);
261	IPluginModelBase model = (IPluginModelBase) map.get(plugin);
262	if (model != null) {
263	BundleDescription desc = model.getBundleDescription();
264	if (desc != null) {
265	BundleDescription[] fragments = desc.getFragments();
266	for (int i = 0; i < fragments.length; i++)
267	locations.add(fragments[i].getSymbolicName());
268	}
269	}
270	resolveLocationPath(locations, properties, map);
271	} else
272	resolveLocationPath(targetSplash, properties, map);
273	}
274
275	private static void resolveLocationPath(String splashPath, Properties properties, Map map) {
276	ArrayList locations = new ArrayList();
277	StringTokenizer tok = new StringTokenizer(splashPath, ","); //$NON-NLS-1$
278	while (tok.hasMoreTokens())
279	locations.add(tok.nextToken());
280	resolveLocationPath(locations, properties, map);
281	}
282
283	private static void resolveLocationPath(ArrayList locations, Properties properties, Map map) {
284	StringBuffer buffer = new StringBuffer();
285	for (int i = 0; i < locations.size(); i++) {
286	String location = (String) locations.get(i);
287	if (location.startsWith("platform:/base/plugins/")) { //$NON-NLS-1$
288	location = location.replaceFirst("platform:/base/plugins/", ""); //$NON-NLS-1$ //$NON-NLS-2$
289	}
290	String url = getBundleURL(location, map, false);
291	if (url == null)
292	continue;
293	if (buffer.length() > 0)
294	buffer.append(","); //$NON-NLS-1$
295	buffer.append(url);
296	}
297	if (buffer.length() > 0)
298	properties.setProperty("osgi.splashPath", buffer.toString()); //$NON-NLS-1$
299	}
300
301	/**
302	* Returns a string url representing the install location of the bundle model with the
303	* specified id. The model is obtained using the provided map.
304	* @param id the id of the bundle
305	* @param pluginMap mapping of bundle ids to bundle models
306	* @param includeReference whether to prefix the url with 'reference:'
307	* @return string url for the bundle location
308	*/
309	public static String getBundleURL(String id, Map pluginMap, boolean includeReference) {
310	IPluginModelBase model = (IPluginModelBase) pluginMap.get(id.trim());
311	return getBundleURL(model, includeReference);
312	}
313
314	/**
315	* Returns a string url representing the install location of the given bundle model
316	* @param model the model to create the url for
317	* @param includeReference whether to prefix the url with 'reference:'
318	* @return string url for bundle location
319	*/
320	public static String getBundleURL(IPluginModelBase model, boolean includeReference) {
321	if (model == null \|\| model.getInstallLocation() == null)
322	return null;
323	StringBuffer buf = new StringBuffer();
324	if (includeReference) {
325	buf.append(TargetPlatformHelper.REFERENCE_PREFIX);
326	}
327	buf.append(TargetPlatformHelper.FILE_URL_PREFIX);
328	buf.append(new Path(model.getInstallLocation()).removeTrailingSeparator().toString());
329	return buf.toString();
330	}
331
332	/**
333	* Use the map of bundles we are launching with to update the osgi.framework
334	* and osgi.bundles properties with the correct info.
335	* @param map map of bundles being launched (id mapped to model)
336	* @param properties properties for config.ini
337	*/
338	private static void setBundleLocations(Map map, Properties properties, boolean defaultAuto) {
339	String framework = properties.getProperty(PROP_OSGI_FRAMEWORK);
340	if (framework != null) {
341	framework = TargetPlatformHelper.stripPathInformation(framework);
342	String url = getBundleURL(framework, map, false);
343	if (url != null)
344	properties.setProperty(PROP_OSGI_FRAMEWORK, url);
345	}
346
347	String bundles = properties.getProperty(PROP_OSGI_BUNDLES);
348	if (bundles != null) {
349	StringBuffer buffer = new StringBuffer();
350	StringTokenizer tokenizer = new StringTokenizer(bundles, ","); //$NON-NLS-1$
351	while (tokenizer.hasMoreTokens()) {
352	String token = tokenizer.nextToken().trim();
353	String url = getBundleURL(token, map, false);
354	int i = -1;
355	if (url == null) {
356	i = token.indexOf('@');
357	if (i != -1) {
358	url = getBundleURL(token.substring(0, i), map, false);
359	}
360	if (url == null) {
361	i = token.indexOf(':');
362	if (i != -1)
363	url = getBundleURL(token.substring(0, i), map, false);
364	}
365	}
366	if (url != null) {
367	if (buffer.length() > 0) {
368	buffer.append(","); //$NON-NLS-1$
369	}
370	buffer.append("reference:" + url); //$NON-NLS-1$
371	if (i != -1) {
372	String slinfo = token.substring(i + 1);
373	buffer.append(getStartData(slinfo, defaultAuto));
374	}
375	}
376	}
377	properties.setProperty(PROP_OSGI_BUNDLES, buffer.toString());
378	}
379	}
380
381	/**
382	* Convenience method to parses the startData ("startLevel:autoStart"), convert it to the
383	* format expected by the OSGi bundles property, and append to a StringBuffer.
384	* @param startData data to parse ("startLevel:autoStart")
385	* @param defaultAuto default auto start setting
386	*/
387	public static String getStartData(String startData, boolean defaultAuto) {
388	StringBuffer buffer = new StringBuffer();
389	int index = startData.indexOf(':');
390	String level = index > 0 ? startData.substring(0, index) : "default"; //$NON-NLS-1$
391	String auto = startData;
392	if (!startData.equals("start")) //$NON-NLS-1$
393	auto = index >= 0 && index < startData.length() - 1 ? startData.substring(index + 1) : "default"; //$NON-NLS-1$
394	if ("default".equals(auto)) //$NON-NLS-1$
395	auto = Boolean.toString(defaultAuto);
396	if (!level.equals("default") \|\| "true".equals(auto) \|\| "start".equals(auto)) //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
397	buffer.append("@"); //$NON-NLS-1$
398
399	if (!level.equals("default")) { //$NON-NLS-1$
400	buffer.append(level);
401	if ("start".equals(auto) \|\| "true".equals(auto)) //$NON-NLS-1$ //$NON-NLS-2$
402	buffer.append(":"); //$NON-NLS-1$
403	}
404	if ("start".equals(auto) \|\| "true".equals(auto)) { //$NON-NLS-1$ //$NON-NLS-2$
405	buffer.append("start"); //$NON-NLS-1$
406	}
407	return buffer.toString();
408	}
409
410	public static void save(File file, Properties properties) {
411	try {
412	FileOutputStream stream = new FileOutputStream(file);
413	properties.store(stream, "Configuration File"); //$NON-NLS-1$
414	stream.flush();
415	stream.close();
416	} catch (IOException e) {
417	PDECore.logException(e);
418	}
419	}
420
421	public static String getContributingPlugin(String productID) {
422	if (productID == null)
423	return null;
424	int index = productID.lastIndexOf('.');
425	return index == -1 ? productID : productID.substring(0, index);
426	}
427
428	public static String getProductID(ILaunchConfiguration configuration) throws CoreException {
429	if (configuration.getAttribute(IPDELauncherConstants.USE_PRODUCT, false)) {
430	return configuration.getAttribute(IPDELauncherConstants.PRODUCT, (String) null);
431	}
432
433	// find the product associated with the application, and return its
434	// contributing plug-in
435	String appID = configuration.getAttribute(IPDELauncherConstants.APPLICATION, TargetPlatform.getDefaultApplication());
436	IExtension[] extensions = PDECore.getDefault().getExtensionsRegistry().findExtensions("org.eclipse.core.runtime.products", true); //$NON-NLS-1$
437	for (int i = 0; i < extensions.length; i++) {
438	String id = extensions[i].getUniqueIdentifier();
439	if (id == null)
440	continue;
441	IConfigurationElement[] children = extensions[i].getConfigurationElements();
442	if (children.length != 1)
443	continue;
444	if (!"product".equals(children[0].getName())) //$NON-NLS-1$
445	continue;
446	if (appID.equals(children[0].getAttribute("application"))) //$NON-NLS-1$
447	return id;
448	}
449	return null;
450
451	}
452
453	}

Removed Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/ProductValidationOperation.java (-54 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 EclipseSource 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	* EclipseSource Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.pde.internal.ui.launcher;
12
13	import java.util.ArrayList;
14	import java.util.List;
15	import org.eclipse.core.runtime.CoreException;
16	import org.eclipse.jdt.launching.IVMInstall;
17	import org.eclipse.jdt.launching.JavaRuntime;
18	import org.eclipse.jdt.launching.environments.IExecutionEnvironment;
19	import org.eclipse.jdt.launching.environments.IExecutionEnvironmentsManager;
20	import org.eclipse.pde.core.plugin.IPluginModelBase;
21
22	public class ProductValidationOperation extends LaunchValidationOperation {
23
24	private IPluginModelBase[] fModels;
25
26	public ProductValidationOperation(IPluginModelBase[] models) {
27	super(null);
28	fModels = models;
29	}
30
31	protected IPluginModelBase[] getModels() throws CoreException {
32	return fModels;
33	}
34
35	protected IExecutionEnvironment[] getMatchingEnvironments() throws CoreException {
36	IVMInstall install = JavaRuntime.getDefaultVMInstall();
37
38	IExecutionEnvironmentsManager manager = JavaRuntime.getExecutionEnvironmentsManager();
39	IExecutionEnvironment[] envs = manager.getExecutionEnvironments();
40	List result = new ArrayList(envs.length);
41	for (int i = 0; i < envs.length; i++) {
42	IExecutionEnvironment env = envs[i];
43	IVMInstall[] compatible = env.getCompatibleVMs();
44	for (int j = 0; j < compatible.length; j++) {
45	if (compatible[j].equals(install)) {
46	result.add(env);
47	break;
48	}
49	}
50	}
51	return (IExecutionEnvironment[]) result.toArray(new IExecutionEnvironment[result.size()]);
52	}
53
54	}

Removed Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/OSGiValidationOperation.java (-28 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007, 2009 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	* EclipseSource Corporation - ongoing enhancements
11	*******************************************************************************/
12	package org.eclipse.pde.internal.ui.launcher;
13
14	import org.eclipse.core.runtime.CoreException;
15	import org.eclipse.debug.core.ILaunchConfiguration;
16	import org.eclipse.pde.core.plugin.IPluginModelBase;
17
18	public class OSGiValidationOperation extends LaunchValidationOperation {
19
20	public OSGiValidationOperation(ILaunchConfiguration configuration) {
21	super(configuration);
22	}
23
24	protected IPluginModelBase[] getModels() throws CoreException {
25	return BundleLauncherHelper.getMergedBundles(fLaunchConfiguration, true);
26	}
27
28	}

Removed Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/VMHelper.java (-94 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	* Les Jones <lesojones@gmail.com> - Bug 195433
11	*******************************************************************************/
12	package org.eclipse.pde.internal.ui.launcher;
13
14	import org.eclipse.core.runtime.*;
15	import org.eclipse.debug.core.ILaunchConfiguration;
16	import org.eclipse.jdt.core.IJavaProject;
17	import org.eclipse.jdt.launching.*;
18	import org.eclipse.osgi.util.NLS;
19	import org.eclipse.pde.internal.core.util.VMUtil;
20	import org.eclipse.pde.internal.ui.PDEUIMessages;
21	import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
22
23	public class VMHelper {
24
25	/**
26	* Get the default VMInstall name using the available info in the config,
27	* using the JavaProject if available.
28	*
29	* @param configuration
30	* Launch configuration to check
31	* @return name of the VMInstall
32	* @throws CoreException
33	* thrown if there's a problem getting the VM name
34	*/
35	public static String getDefaultVMInstallName(ILaunchConfiguration configuration) throws CoreException {
36	IJavaProject javaProject = JavaRuntime.getJavaProject(configuration);
37	IVMInstall vmInstall = null;
38	if (javaProject != null) {
39	vmInstall = JavaRuntime.getVMInstall(javaProject);
40	}
41
42	if (vmInstall != null) {
43	return vmInstall.getName();
44	}
45
46	return VMUtil.getDefaultVMInstallName();
47	}
48
49	public static IVMInstall getVMInstall(ILaunchConfiguration configuration) throws CoreException {
50	String jre = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_JRE_CONTAINER_PATH, (String) null);
51	IVMInstall vm = null;
52	if (jre == null) {
53	String name = configuration.getAttribute(IPDELauncherConstants.VMINSTALL, (String) null);
54	if (name == null) {
55	name = getDefaultVMInstallName(configuration);
56	}
57	vm = getVMInstall(name);
58	if (vm == null) {
59	throw new CoreException(LauncherUtils.createErrorStatus(NLS.bind(PDEUIMessages.WorkbenchLauncherConfigurationDelegate_noJRE, name)));
60	}
61	} else {
62	IPath jrePath = Path.fromPortableString(jre);
63	vm = JavaRuntime.getVMInstall(jrePath);
64	if (vm == null) {
65	String id = JavaRuntime.getExecutionEnvironmentId(jrePath);
66	if (id == null) {
67	String name = JavaRuntime.getVMInstallName(jrePath);
68	throw new CoreException(LauncherUtils.createErrorStatus(NLS.bind(PDEUIMessages.WorkbenchLauncherConfigurationDelegate_noJRE, name)));
69	}
70	throw new CoreException(LauncherUtils.createErrorStatus(NLS.bind(PDEUIMessages.VMHelper_cannotFindExecEnv, id)));
71	}
72	}
73	return vm;
74	}
75
76	public static IVMInstall getVMInstall(String name) {
77	if (name != null) {
78	IVMInstall[] installs = VMUtil.getAllVMInstances();
79	for (int i = 0; i < installs.length; i++) {
80	if (installs[i].getName().equals(name))
81	return installs[i];
82	}
83	}
84	return JavaRuntime.getDefaultVMInstall();
85	}
86
87	public static IVMInstall createLauncher(ILaunchConfiguration configuration) throws CoreException {
88	IVMInstall launcher = getVMInstall(configuration);
89	if (!launcher.getInstallLocation().exists())
90	throw new CoreException(LauncherUtils.createErrorStatus(PDEUIMessages.WorkbenchLauncherConfigurationDelegate_jrePathNotFound));
91	return launcher;
92	}
93
94	}

Removed Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/LauncherUtils.java (-413 lines)
1	/*******************************************************************************
2	* Copyright (c) 2003, 2009 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	* EclipseSource Corporation - ongoing enhancements
11	*******************************************************************************/
12	package org.eclipse.pde.internal.ui.launcher;
13
14	import java.io.*;
15	import java.net.MalformedURLException;
16	import java.net.URL;
17	import java.util.*;
18	import org.eclipse.core.resources.*;
19	import org.eclipse.core.runtime.*;
20	import org.eclipse.debug.core.ILaunchConfiguration;
21	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
22	import org.eclipse.jdt.core.*;
23	import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
24	import org.eclipse.jface.dialogs.IDialogConstants;
25	import org.eclipse.jface.dialogs.MessageDialog;
26	import org.eclipse.jface.preference.IPreferenceStore;
27	import org.eclipse.ltk.core.refactoring.Change;
28	import org.eclipse.osgi.service.datalocation.Location;
29	import org.eclipse.osgi.util.NLS;
30	import org.eclipse.pde.core.plugin.IPluginModelBase;
31	import org.eclipse.pde.core.plugin.PluginRegistry;
32	import org.eclipse.pde.internal.core.*;
33	import org.eclipse.pde.internal.core.util.CoreUtility;
34	import org.eclipse.pde.internal.ui.*;
35	import org.eclipse.pde.internal.ui.wizards.tools.OrganizeManifestsProcessor;
36	import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
37	import org.eclipse.swt.widgets.Display;
38	import org.eclipse.swt.widgets.Shell;
39	import org.eclipse.ui.IWorkbenchWindow;
40	import org.osgi.framework.*;
41
42	public class LauncherUtils {
43
44	private static final String TIMESTAMP = "timestamp"; //$NON-NLS-1$
45	private static final String FILE_NAME = "dep-timestamp.properties"; //$NON-NLS-1$
46	private static Properties fLastRun;
47
48	public static Display getDisplay() {
49	Display display = Display.getCurrent();
50	if (display == null) {
51	display = Display.getDefault();
52	}
53	return display;
54	}
55
56	public final static Shell getActiveShell() {
57	IWorkbenchWindow window = PDEPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow();
58	if (window == null) {
59	IWorkbenchWindow[] windows = PDEPlugin.getDefault().getWorkbench().getWorkbenchWindows();
60	if (windows.length > 0)
61	return windows[0].getShell();
62	} else
63	return window.getShell();
64	return getDisplay().getActiveShell();
65	}
66
67	public static boolean clearWorkspace(ILaunchConfiguration configuration, String workspace, IProgressMonitor monitor) throws CoreException {
68
69	// If the workspace is not defined, there is no workspace to clear
70	// What will happen is that the workspace chooser dialog will be
71	// brought up because no -data parameter will be specified on the
72	// launch
73	if (workspace.length() == 0) {
74	monitor.done();
75	return true;
76	}
77
78	// Check if the workspace is already in use, if so, open a message and stop the launch before clearing
79	boolean isLocked = false;
80	try {
81	BundleContext context = PDECore.getDefault().getBundleContext();
82	ServiceReference[] references = context.getServiceReferences(Location.class.getName(), "(type=osgi.configuration.area)"); //$NON-NLS-1$
83	if (references.length > 0) {
84	Object service = context.getService(references[0]);
85	if (service instanceof Location) {
86	URL workspaceURL = new Path(workspace).toFile().toURI().toURL();
87	Location targetLocation = ((Location) service).createLocation(null, workspaceURL, false);
88	targetLocation.set(targetLocation.getDefault(), false);
89	isLocked = targetLocation.isLocked();
90	}
91	}
92	} catch (InvalidSyntaxException e) {
93	PDECore.log(e);
94	isLocked = false;
95	} catch (MalformedURLException e) {
96	PDECore.log(e);
97	isLocked = false;
98	} catch (IOException e) {
99	PDECore.log(e);
100	isLocked = false;
101	}
102
103	if (isLocked) {
104	generateErrorDialog(PDEUIMessages.LauncherUtils_workspaceLocked, NLS.bind(PDEUIMessages.LauncherUtils_cannotLaunchApplication, workspace));
105	monitor.done();
106	return false;
107	}
108
109	File workspaceFile = new Path(workspace).toFile().getAbsoluteFile();
110	if (configuration.getAttribute(IPDELauncherConstants.DOCLEAR, false) && workspaceFile.exists()) {
111	if (configuration.getAttribute(IPDELauncherConstants.ASKCLEAR, true)) {
112	int result;
113	if (configuration.getAttribute(IPDEUIConstants.DOCLEARLOG, false)) {
114	result = generateDialog(PDEUIMessages.LauncherUtils_clearLogFile);
115	} else {
116	result = generateDialog(NLS.bind(PDEUIMessages.WorkbenchLauncherConfigurationDelegate_confirmDeleteWorkspace, workspaceFile.getPath()));
117	}
118
119	if (result == 2 /Cancel Button/\|\| result == -1 /Dialog close button/) {
120	monitor.done();
121	return false;
122	} else if (result == 0) {
123	if (configuration.getAttribute(IPDEUIConstants.DOCLEARLOG, false)) {
124	LauncherUtils.clearWorkspaceLog(workspace);
125	} else {
126	CoreUtility.deleteContent(workspaceFile);
127	}
128	}
129	} else if (configuration.getAttribute(IPDEUIConstants.DOCLEARLOG, false)) {
130	LauncherUtils.clearWorkspaceLog(workspace);
131	} else {
132	CoreUtility.deleteContent(workspaceFile);
133	}
134	}
135
136	monitor.done();
137	return true;
138	}
139
140	public static boolean generateConfigIni() {
141	String message = PDEUIMessages.LauncherUtils_generateConfigIni;
142	return generateDialog(message) == 0;
143	}
144
145	/**
146	* Creates a message dialog using a syncExec in case we are launching in the background.
147	* Dialog will be a question dialog with Yes, No and Cancel buttons.
148	* @param message Message to use in the dialog
149	* @return int representing the button clicked (-1 or 2 for cancel, 0 for yes, 1 for no).
150	*/
151	private static int generateDialog(final String message) {
152	final int[] result = new int[1];
153	getDisplay().syncExec(new Runnable() {
154	public void run() {
155	String title = PDEUIMessages.LauncherUtils_title;
156	MessageDialog dialog = new MessageDialog(getActiveShell(), title, null, message, MessageDialog.QUESTION, new String[] {IDialogConstants.YES_LABEL, IDialogConstants.NO_LABEL, IDialogConstants.CANCEL_LABEL}, 0);
157	result[0] = dialog.open();
158	}
159	});
160	return result[0];
161	}
162
163	private static void generateErrorDialog(final String title, final String message) {
164	getDisplay().syncExec(new Runnable() {
165	public void run() {
166	MessageDialog dialog = new MessageDialog(getActiveShell(), title, null, message, MessageDialog.ERROR, new String[] {IDialogConstants.OK_LABEL}, 0);
167	dialog.open();
168	}
169	});
170	}
171
172	public static void validateProjectDependencies(ILaunchConfiguration launch, final IProgressMonitor monitor) {
173	IPreferenceStore store = PDEPlugin.getDefault().getPreferenceStore();
174	if (!store.getBoolean(IPreferenceConstants.PROP_AUTO_MANAGE))
175	return;
176
177	String timeStamp;
178	boolean useDefault, autoAdd;
179	try {
180	timeStamp = launch.getAttribute(TIMESTAMP, "0"); //$NON-NLS-1$
181	autoAdd = launch.getAttribute(IPDELauncherConstants.AUTOMATIC_ADD, true);
182	useDefault = launch.getAttribute(IPDELauncherConstants.USE_DEFAULT, true);
183	useDefault \|= launch.getAttribute(IPDELauncherConstants.USEFEATURES, false);
184	final ArrayList projects = new ArrayList();
185	if (useDefault)
186	handleUseDefault(timeStamp, projects);
187	else if (autoAdd)
188	handleDeselectedPlugins(launch, timeStamp, projects);
189	else
190	handleSelectedPlugins(launch, timeStamp, projects);
191
192	if (!projects.isEmpty())
193	Display.getDefault().syncExec(new Runnable() {
194	public void run() {
195	OrganizeManifestsProcessor processor = new OrganizeManifestsProcessor(projects);
196	initializeProcessor(processor);
197	try {
198	Change change = processor.createChange(monitor);
199	change.perform(monitor);
200	// update table for each project with current time stamp
201	Properties table = getLastRun();
202	String ts = Long.toString(System.currentTimeMillis());
203	Iterator it = projects.iterator();
204	while (it.hasNext())
205	table.put(((IProject) it.next()).getName(), ts);
206	} catch (OperationCanceledException e) {
207	} catch (CoreException e) {
208	}
209	}
210	});
211
212	ILaunchConfigurationWorkingCopy wc = null;
213	if (launch.isWorkingCopy())
214	wc = (ILaunchConfigurationWorkingCopy) launch;
215	else
216	wc = launch.getWorkingCopy();
217	wc.setAttribute(TIMESTAMP, Long.toString(System.currentTimeMillis()));
218	wc.doSave();
219	} catch (CoreException e) {
220	}
221	}
222
223	private static void initializeProcessor(OrganizeManifestsProcessor processor) {
224	processor.setAddMissing(false);
225	processor.setRemoveUnresolved(false);
226	processor.setModifyDep(false);
227	processor.setRemoveLazy(false);
228	processor.setRemoveUselessFiles(false);
229	processor.setAddDependencies(true);
230	processor.setCalculateUses(false);
231	processor.setMarkInternal(false);
232	processor.setPrefixIconNL(false);
233	processor.setUnusedDependencies(false);
234	processor.setUnusedKeys(false);
235	}
236
237	private static String getTimeStamp(IProject project) {
238	IJavaProject jp = JavaCore.create(project);
239	try {
240	long timeStamp = 0;
241	IClasspathEntry[] entries = jp.getResolvedClasspath(true);
242	for (int i = 0; i < entries.length; i++) {
243	if (entries[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {
244	File file;
245	IPath location = entries[i].getOutputLocation();
246	if (location == null)
247	location = jp.getOutputLocation();
248	IResource res = project.getWorkspace().getRoot().findMember(location);
249	IPath path = res == null ? null : res.getLocation();
250	if (path == null)
251	continue;
252	file = path.toFile();
253	Stack files = new Stack();
254	files.push(file);
255	while (!files.isEmpty()) {
256	file = (File) files.pop();
257	if (file.isDirectory()) {
258	File[] children = file.listFiles();
259	if (children != null) {
260	for (int j = 0; j < children.length; j++)
261	files.push(children[j]);
262	}
263	} else if (file.getName().endsWith(".class") && timeStamp < file.lastModified()) //$NON-NLS-1$
264	timeStamp = file.lastModified();
265	}
266	}
267	}
268	String[] otherFiles = {ICoreConstants.BUNDLE_FILENAME_DESCRIPTOR, ICoreConstants.BUILD_FILENAME_DESCRIPTOR};
269	for (int i = 0; i < otherFiles.length; i++) {
270	IResource file = project.getFile(otherFiles[i]);
271	if (file != null) {
272	long fileTimeStamp = file.getRawLocation().toFile().lastModified();
273	if (timeStamp < fileTimeStamp)
274	timeStamp = fileTimeStamp;
275	}
276	}
277	return Long.toString(timeStamp);
278	} catch (JavaModelException e) {
279	}
280	return "0"; //$NON-NLS-1$
281	}
282
283	private static void handleUseDefault(String launcherTimeStamp, ArrayList projects) {
284	IProject[] projs = ResourcesPlugin.getWorkspace().getRoot().getProjects();
285	for (int i = 0; i < projs.length; i++) {
286	if (!WorkspaceModelManager.isPluginProject(projs[i]))
287	continue;
288	String timestamp = getTimeStamp(projs[i]);
289	if (timestamp.compareTo(launcherTimeStamp) > 0 && shouldAdd(projs[i], launcherTimeStamp, timestamp))
290	projects.add(projs[i]);
291	}
292	}
293
294	private static void handleSelectedPlugins(ILaunchConfiguration config, String timeStamp, ArrayList projects) throws CoreException {
295	Map selectedPlugins = BundleLauncherHelper.getWorkspaceBundleMap(config, null, IPDELauncherConstants.SELECTED_WORKSPACE_PLUGINS);
296	Iterator it = selectedPlugins.keySet().iterator();
297	while (it.hasNext()) {
298	IPluginModelBase model = (IPluginModelBase) it.next();
299	IResource res = model.getUnderlyingResource();
300	if (res != null) {
301	IProject project = res.getProject();
302	String projTimeStamp = getTimeStamp(project);
303	if (projTimeStamp.compareTo(timeStamp) > 0 && shouldAdd(project, timeStamp, projTimeStamp))
304	projects.add(project);
305	}
306	}
307	}
308
309	private static void handleDeselectedPlugins(ILaunchConfiguration config, String launcherTimeStamp, ArrayList projects) throws CoreException {
310	Map deSelectedPlugins = BundleLauncherHelper.getWorkspaceBundleMap(config, null, IPDELauncherConstants.DESELECTED_WORKSPACE_PLUGINS);
311	IProject[] projs = ResourcesPlugin.getWorkspace().getRoot().getProjects();
312	for (int i = 0; i < projs.length; i++) {
313	if (!WorkspaceModelManager.isPluginProject(projs[i]))
314	continue;
315	IPluginModelBase base = PluginRegistry.findModel(projs[i]);
316	if (base == null \|\| base != null && deSelectedPlugins.containsKey(base))
317	continue;
318	String timestamp = getTimeStamp(projs[i]);
319	if (timestamp.compareTo(launcherTimeStamp) > 0 && shouldAdd(projs[i], launcherTimeStamp, timestamp))
320	projects.add(projs[i]);
321	}
322	}
323
324	public static final void shutdown() {
325	if (fLastRun == null)
326	return;
327	FileOutputStream stream = null;
328	try {
329	stream = new FileOutputStream(new File(getDirectory(), FILE_NAME));
330	fLastRun.store(stream, "Cached timestamps"); //$NON-NLS-1$
331	stream.flush();
332	stream.close();
333	} catch (IOException e) {
334	PDECore.logException(e);
335	} finally {
336	try {
337	if (stream != null)
338	stream.close();
339	} catch (IOException e1) {
340	}
341	}
342	}
343
344	private static File getDirectory() {
345	IPath path = PDECore.getDefault().getStateLocation().append(".cache"); //$NON-NLS-1$
346	File directory = new File(path.toOSString());
347	if (!directory.exists() \|\| !directory.isDirectory())
348	directory.mkdirs();
349	return directory;
350	}
351
352	private static Properties getLastRun() {
353	if (fLastRun == null) {
354	fLastRun = new Properties();
355	FileInputStream fis = null;
356	try {
357	File file = new File(getDirectory(), FILE_NAME);
358	if (file.exists()) {
359	fis = new FileInputStream(file);
360	fLastRun.load(fis);
361	fis.close();
362	}
363	} catch (IOException e) {
364	PDECore.logException(e);
365	} finally {
366	try {
367	if (fis != null)
368	fis.close();
369	} catch (IOException e1) {
370	}
371	}
372	}
373	return fLastRun;
374	}
375
376	private static boolean shouldAdd(IProject proj, String launcherTS, String fileSystemTS) {
377	String projTS = (String) getLastRun().get(proj.getName());
378	if (projTS == null)
379	return true;
380	return ((projTS.compareTo(launcherTS) < 0) \|\| (projTS.compareTo(fileSystemTS) < 0));
381	}
382
383	public static boolean requiresUI(ILaunchConfiguration configuration) {
384	try {
385	String projectID = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, ""); //$NON-NLS-1$
386	if (projectID.length() > 0) {
387	IResource project = PDEPlugin.getWorkspace().getRoot().findMember(projectID);
388	if (project instanceof IProject) {
389	IPluginModelBase model = PluginRegistry.findModel((IProject) project);
390	if (model != null) {
391	Set plugins = DependencyManager.getSelfAndDependencies(model);
392	return plugins.contains("org.eclipse.swt"); //$NON-NLS-1$
393	}
394	}
395	}
396	} catch (CoreException e) {
397	}
398	return true;
399	}
400
401	public static boolean clearWorkspaceLog(String workspace) {
402	File logFile = new File(workspace, ".metadata" + File.separator + ".log"); //$NON-NLS-1$ //$NON-NLS-2$
403	if (logFile != null && logFile.exists()) {
404	return logFile.delete();
405	}
406	return true;
407	}
408
409	public static IStatus createErrorStatus(String message) {
410	return new Status(IStatus.ERROR, PDEPlugin.getPluginId(), IStatus.OK, message, null);
411	}
412
413	}

Lines 18-24 Link Here

(-)plugin.xml (-66 / +64 lines)
18	<extension-point id="newExtension" name="%expoint.newExtension.name" schema="schema/newExtension.exsd"/>	18	<extension-point id="newExtension" name="%expoint.newExtension.name" schema="schema/newExtension.exsd"/>
19	<extension-point id="templates" name="%expoint.templates.name" schema="schema/templates.exsd"/>	19	<extension-point id="templates" name="%expoint.templates.name" schema="schema/templates.exsd"/>
20	<extension-point id="samples" name="%expoint.samples.name" schema="schema/samples.exsd"/>	20	<extension-point id="samples" name="%expoint.samples.name" schema="schema/samples.exsd"/>
21	<extension-point id="osgiFrameworks" name="%expoint.osgiLauncher.name" schema="schema/osgiFrameworks.exsd"/>
22	<extension-point id="targetProvisioners" name="%extension-point.name.0" schema="schema/targetProvisioners.exsd"/>	21	<extension-point id="targetProvisioners" name="%extension-point.name.0" schema="schema/targetProvisioners.exsd"/>
23	<extension-point id="launchShortcuts" name="%extension-point.name.1" schema="schema/launchShortcuts.exsd"/>	22	<extension-point id="launchShortcuts" name="%extension-point.name.1" schema="schema/launchShortcuts.exsd"/>
24		23
Lines 895-936 Link Here
895	</objectContribution>	894	</objectContribution>
896	</extension>	895	</extension>
897	<extension	896	<extension
898	point="org.eclipse.debug.core.launchConfigurationTypes">
899	<launchConfigurationType
900	delegate="org.eclipse.pde.ui.launcher.EclipseApplicationLaunchConfiguration"
901	delegateDescription="%PDELaunchDelegate.description"
902	delegateName="%PDELaunchDelegate.name"
903	id="org.eclipse.pde.ui.RuntimeWorkbench"
904	migrationDelegate="org.eclipse.pde.internal.ui.launcher.PDEMigrationDelegate"
905	modes="run, debug"
906	name="%launchConfigurationType.name"
907	sourceLocatorId="org.eclipse.pde.ui.launcher.PDESourceLookupDirector"
908	sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer">
909	</launchConfigurationType>
910	<launchConfigurationType
911	delegate="org.eclipse.pde.ui.launcher.JUnitLaunchConfigurationDelegate"
912	delegateDescription="%JUnitPluginLaunchDelegate.description"
913	delegateName="%JUnitPluginLaunchDelegate.name"
914	id="org.eclipse.pde.ui.JunitLaunchConfig"
915	migrationDelegate="org.eclipse.pde.internal.ui.launcher.PDEMigrationDelegate"
916	modes="run, debug"
917	name="%launcher.junit.name"
918	sourceLocatorId="org.eclipse.pde.ui.launcher.PDESourceLookupDirector"
919	sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer">
920	</launchConfigurationType>
921	<launchConfigurationType
922	delegate="org.eclipse.pde.ui.launcher.OSGiLaunchConfigurationDelegate"
923	delegateDescription="%OSGiLaunchDelegate.description"
924	delegateName="%OSGiLaunchDelegate.name"
925	id="org.eclipse.pde.ui.EquinoxLauncher"
926	migrationDelegate="org.eclipse.pde.internal.ui.launcher.OSGiMigrationDelegate"
927	modes="run, debug"
928	name="%launcher.framework.name"
929	public="true"
930	sourceLocatorId="org.eclipse.pde.ui.launcher.PDESourceLookupDirector"
931	sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer"/>
932	</extension>
933	<extension
934	point="org.eclipse.debug.ui.launchConfigurationTypeImages">	897	point="org.eclipse.debug.ui.launchConfigurationTypeImages">
935	<launchConfigurationTypeImage	898	<launchConfigurationTypeImage
936	icon="$nl$/icons/etool16/eclipse_launcher.gif"	899	icon="$nl$/icons/etool16/eclipse_launcher.gif"
Lines 994-1005 Link Here
994	</launchConfigurationTabGroup>	957	</launchConfigurationTabGroup>
995	</extension>	958	</extension>
996	<extension	959	<extension
997	point="org.eclipse.jdt.junit.junitLaunchConfigs">
998	<launchConfigType
999	configTypeID="org.eclipse.pde.ui.JunitLaunchConfig">
1000	</launchConfigType>
1001	</extension>
1002	<extension
1003	point="org.eclipse.debug.ui.launchShortcuts">	960	point="org.eclipse.debug.ui.launchShortcuts">
1004	<shortcut	961	<shortcut
1005	class="org.eclipse.pde.ui.launcher.JUnitWorkbenchLaunchShortcut"	962	class="org.eclipse.pde.ui.launcher.JUnitWorkbenchLaunchShortcut"
Lines 1221-1233 Link Here
1221	id="org.eclipse.pde.ui.dependencyExtentResultPage"/>	1178	id="org.eclipse.pde.ui.dependencyExtentResultPage"/>
1222	</extension>	1179	</extension>
1223	<extension	1180	<extension
1224	point="org.eclipse.jdt.launching.classpathProviders">
1225	<classpathProvider
1226	class="org.eclipse.pde.ui.launcher.PDESourcePathProvider"
1227	id="org.eclipse.pde.ui.workbenchClasspathProvider">
1228	</classpathProvider>
1229	</extension>
1230	<extension
1231	point="org.eclipse.ui.intro.configExtension">	1181	point="org.eclipse.ui.intro.configExtension">
1232	<standbyContentPart	1182	<standbyContentPart
1233	pluginId="org.eclipse.pde.ui"	1183	pluginId="org.eclipse.pde.ui"
Lines 1637-1649 Link Here
1637	</description>	1587	</description>
1638	</fontDefinition>	1588	</fontDefinition>
1639	</extension>	1589	</extension>
1640	<extension point="org.eclipse.debug.core.sourceLocators">
1641	<sourceLocator
1642	id="org.eclipse.pde.ui.launcher.PDESourceLookupDirector"
1643	class="org.eclipse.pde.internal.ui.launcher.PDESourceLookupDirector"
1644	name="%pde.sourcelocator">
1645	</sourceLocator>
1646	</extension>
1647	<extension	1590	<extension
1648	point="org.eclipse.ui.perspectiveExtensions">	1591	point="org.eclipse.ui.perspectiveExtensions">
1649	<perspectiveExtension	1592	<perspectiveExtension
Lines 1720-1733 Link Here
1720	</perspectiveExtension>	1663	</perspectiveExtension>
1721	</extension>	1664	</extension>
1722	<extension	1665	<extension
1723	point="org.eclipse.pde.ui.osgiFrameworks">
1724	<framework
1725	launcherDelegate="org.eclipse.pde.ui.launcher.EquinoxLaunchConfiguration"
1726	id="org.eclipse.pde.ui.EquinoxFramework"
1727	name="%Equinox.shortcut.label"
1728	initializer="org.eclipse.pde.internal.ui.launcher.EquinoxInitializer"/>
1729	</extension>
1730	<extension
1731	point="org.eclipse.ui.ide.markerSupport">	1666	point="org.eclipse.ui.ide.markerSupport">
1732	<markerTypeCategory	1667	<markerTypeCategory
1733	name="%marker.category">	1668	name="%marker.category">
Lines 2026-2030 Link Here
2026	tooltip="%showErrorInStackTraceConsoleAction.label">	1961	tooltip="%showErrorInStackTraceConsoleAction.label">
2027	</action>	1962	</action>
2028	</viewContribution>	1963	</viewContribution>
2029	</extension>>	1964	</extension>
		1965	<extension
		1966	point="org.eclipse.debug.core.statusHandlers">
		1967	<statusHandler
		1968	class="org.eclipse.pde.internal.ui.launcher.LaunchTerminationStatusHandler"
		1969	code="13"
		1970	id="org.eclipse.pde.launching.ERR13"
		1971	plugin="org.eclipse.pde.launching">
		1972	</statusHandler>
		1973	<statusHandler
		1974	class="org.eclipse.pde.internal.ui.launcher.LaunchTerminationStatusHandler"
		1975	code="15"
		1976	id="org.eclipse.pde.launching.ERR15"
		1977	plugin="org.eclipse.pde.launching">
		1978	</statusHandler>
		1979	<statusHandler
		1980	class="org.eclipse.pde.internal.ui.launcher.GenericExceptionStatusHandler"
		1981	code="42"
		1982	id="org.eclipse.pde.launching.GENERIC_EXCEPTION"
		1983	plugin="org.eclipse.pde.launching">
		1984	</statusHandler>
		1985	<statusHandler
		1986	class="org.eclipse.pde.internal.ui.launcher.PluginValidationStatusHandler"
		1987	code="1000"
		1988	id="org.eclipse.pde.launching.CREATE_EXTENSION_ERROR"
		1989	plugin="org.eclipse.pde.launching">
		1990	</statusHandler>
		1991	<statusHandler
		1992	class="org.eclipse.pde.internal.ui.launcher.PluginValidationStatusHandler"
		1993	code="1001"
		1994	id="org.eclipse.pde.launching.DISPLAY_VALIDATION_ERROR"
		1995	plugin="org.eclipse.pde.launching">
		1996	</statusHandler>
		1997	<statusHandler
		1998	class="org.eclipse.pde.internal.ui.launcher.LauncherUtilsStatusHandler"
		1999	code="2000"
		2000	id="org.eclipse.pde.launching.WORKSPACE_LOCKED"
		2001	plugin="org.eclipse.pde.launching">
		2002	</statusHandler>
		2003	<statusHandler
		2004	class="org.eclipse.pde.internal.ui.launcher.LauncherUtilsStatusHandler"
		2005	code="2001"
		2006	id="org.eclipse.pde.launching.CLEAR_LOG"
		2007	plugin="org.eclipse.pde.launching">
		2008	</statusHandler>
		2009	<statusHandler
		2010	class="org.eclipse.pde.internal.ui.launcher.LauncherUtilsStatusHandler"
		2011	code="2002"
		2012	id="org.eclipse.pde.launching.DELETE_WORKSPACE"
		2013	plugin="org.eclipse.pde.launching">
		2014	</statusHandler>
		2015	<statusHandler
		2016	class="org.eclipse.pde.internal.ui.launcher.LauncherUtilsStatusHandler"
		2017	code="2003"
		2018	id="org.eclipse.pde.launching.CREATE_CONFIG_INI"
		2019	plugin="org.eclipse.pde.launching">
		2020	</statusHandler>
		2021	<statusHandler
		2022	class="org.eclipse.pde.internal.ui.launcher.LauncherUtilsStatusHandler"
		2023	code="2004"
		2024	id="org.eclipse.pde.launching.ORGANIZE_MANIFESTS"
		2025	plugin="org.eclipse.pde.launching">
		2026	</statusHandler>
		2027	</extension>
2030	</plugin>	2028	</plugin>

Lines 20-32 Link Here

(-)plugin.properties (-12 lines)
20	expoint.samples.name = Code Samples	20	expoint.samples.name = Code Samples
21	expoint.osgiLauncher.name = OSGi Launcher	21	expoint.osgiLauncher.name = OSGi Launcher
22		22
23	PDELaunchDelegate.name=Eclipse Application Launcher
24	PDELaunchDelegate.description=The Eclipse Application launcher is used to run or debug a separate instance of an Eclipse application
25	OSGiLaunchDelegate.name=OSGi Framework Launcher
26	OSGiLaunchDelegate.description=The OSGi Framework launcher is used to launch an OSGi framework and run or debug OSGi bundles
27	JUnitPluginLaunchDelegate.name= JUnit Plugin Test Launcher
28	JUnitPluginLaunchDelegate.description=The JUnit Plugin Test launcher is used to run and debug test suites for plug-in projects
29
30	RunPDELaunchShortcut.description=Runs a separate Eclipse application	23	RunPDELaunchShortcut.description=Runs a separate Eclipse application
31	DebugPDELaunchShortcut.description=Debugs a separate Eclipse application	24	DebugPDELaunchShortcut.description=Debugs a separate Eclipse application
32	RunOSGiLaunchShortcut.description=Runs an OSGi framework	25	RunOSGiLaunchShortcut.description=Runs an OSGi framework
Lines 132-147 Link Here
132	launcher.shortcut.label= Eclipse Application	125	launcher.shortcut.label= Eclipse Application
133	EclipseApplicationShortcut.description.debug = Debug Eclipse Application	126	EclipseApplicationShortcut.description.debug = Debug Eclipse Application
134	EclipseApplicationShortcut.description.run = Run Eclipse Application	127	EclipseApplicationShortcut.description.run = Run Eclipse Application
135	Equinox.shortcut.label = Equinox
136	OSGiShortcut.description.debug = Debug OSGi Framework	128	OSGiShortcut.description.debug = Debug OSGi Framework
137	OSGiShortcut.description.run = Run OSGi Framework	129	OSGiShortcut.description.run = Run OSGi Framework
138	launcher.junit.name = JUnit Plug-in Test	130	launcher.junit.name = JUnit Plug-in Test
139	JUnitApplicationShortcut.description.debug = Debug JUnit Plug-in Test	131	JUnitApplicationShortcut.description.debug = Debug JUnit Plug-in Test
140	JUnitApplicationShortcut.description.run = Run JUnit Plug-in Test	132	JUnitApplicationShortcut.description.run = Run JUnit Plug-in Test
141		133
142	launchConfigurationType.name = Eclipse Application
143	launcher.framework.name = OSGi Framework
144
145	osgiLauncherTabGroup.description.debug=Create a configuration to launch the OSGi framework in debug mode.	134	osgiLauncherTabGroup.description.debug=Create a configuration to launch the OSGi framework in debug mode.
146	osgiLauncherTabGroup.description.run=Create a configuration to launch the OSGi framework.	135	osgiLauncherTabGroup.description.run=Create a configuration to launch the OSGi framework.
147	workbenchLauncherTabGroup.description.debug=Create a configuration to launch an Eclipse application in debug mode.	136	workbenchLauncherTabGroup.description.debug=Create a configuration to launch an Eclipse application in debug mode.
Lines 182-188 Link Here
182	editor.target.name = Target Editor	171	editor.target.name = Target Editor
183	fontDefinition.label.0 = Manifest compare text font	172	fontDefinition.label.0 = Manifest compare text font
184	fontDefinition.description.0 = The MANIFEST.MF compare text font is used by Bundle manifest compare/merge tools.	173	fontDefinition.description.0 = The MANIFEST.MF compare text font is used by Bundle manifest compare/merge tools.
185	pde.sourcelocator = PDE Source Lookup Director
186		174
187	category.source.name = Manifest Editor Source	175	category.source.name = Manifest Editor Source
188	category.source.description = PDE Source Page actions	176	category.source.description = PDE Source Page actions

Lines 12-19 Link Here

(-)src/org/eclipse/pde/internal/ui/IPDEUIConstants.java (-17 / +2 lines)
12	package org.eclipse.pde.internal.ui;	12	package org.eclipse.pde.internal.ui;
13		13
14	import org.eclipse.core.runtime.QualifiedName;	14	import org.eclipse.core.runtime.QualifiedName;
		15	import org.eclipse.pde.internal.launching.IPDEConstants;
15		16
16	public interface IPDEUIConstants {	17	public interface IPDEUIConstants extends IPDEConstants {
17	String PLUGIN_ID = "org.eclipse.pde.ui"; //$NON-NLS-1$	18	String PLUGIN_ID = "org.eclipse.pde.ui"; //$NON-NLS-1$
18		19
19	String MANIFEST_EDITOR_ID = PLUGIN_ID + ".manifestEditor"; //$NON-NLS-1$	20	String MANIFEST_EDITOR_ID = PLUGIN_ID + ".manifestEditor"; //$NON-NLS-1$
Lines 40-58 Link Here
40		41
41	String PLUGIN_DOC_ROOT = "/org.eclipse.pde.doc.user/"; //$NON-NLS-1$	42	String PLUGIN_DOC_ROOT = "/org.eclipse.pde.doc.user/"; //$NON-NLS-1$
42		43
43	// JUnit application identifiers
44	String LEGACY_UI_TEST_APPLICATION = "org.eclipse.pde.junit.runtime.legacytestapplication"; //$NON-NLS-1$
45	String NON_UI_THREAD_APPLICATION = "org.eclipse.pde.junit.runtime.nonuithreadtestapplication"; //$NON-NLS-1$
46	String UI_TEST_APPLICATION = "org.eclipse.pde.junit.runtime.uitestapplication"; //$NON-NLS-1$
47	String CORE_TEST_APPLICATION = "org.eclipse.pde.junit.runtime.coretestapplication"; //$NON-NLS-1$
48
49	/**
50	* Launch configuration attribute key. The value is a boolean specifies
51	* whether the launch configuration is being restarted. This does not need to
52	* be promoted to IPDELauncherConstants since clients should not need to know
53	* about restarts.
54	*/
55	String RESTART = "restart"; //$NON-NLS-1$
56	/**	44	/**
57	* Launch configuration attribute key. The value is a boolean specifying	45	* Launch configuration attribute key. The value is a boolean specifying
58	* whether the workspace log for an Eclipse application should be cleared	46	* whether the workspace log for an Eclipse application should be cleared
Lines 60-68 Link Here
60	*	48	*
61	* TODO, move to IPDELauncherConstants in 3.4	49	* TODO, move to IPDELauncherConstants in 3.4
62	*/	50	*/
63	String DOCLEARLOG = "clearwslog"; //$NON-NLS-1$
64	String LAUNCHER_PDE_VERSION = "pde.version"; //$NON-NLS-1$
65	String APPEND_ARGS_EXPLICITLY = "append.args"; //$NON-NLS-1$
66	String GENERATED_CONFIG = "pde.generated.config"; //$NON-NLS-1$	51	String GENERATED_CONFIG = "pde.generated.config"; //$NON-NLS-1$
67		52
68	}	53	}

Lines 548-566 Link Here

(-)src/org/eclipse/pde/internal/ui/pderesources.properties (-14 lines)
548	ConfigurationTab_fileDialogMessage=Select a config.ini file:	548	ConfigurationTab_fileDialogMessage=Select a config.ini file:
549		549
550		550
551	WorkbenchLauncherConfigurationDelegate_noJRE = Cannot locate JRE definition: "{0}". Launch aborted.
552	WorkbenchLauncherConfigurationDelegate_jrePathNotFound = The installation path to the specified JRE could not be found. Launch aborted.
553	WorkbenchLauncherConfigurationDelegate_badFeatureSetup = When in feature mode, plug-ins must be in the 'plugins' directory and features in 'features' directory in the workspace.
554	WorkbenchLauncherConfigurationDelegate_noStartup = Launching failed. Bootstrap code cannot be found.
555	WorkbenchLauncherConfigurationDelegate_confirmDeleteWorkspace = Do you really want to clear the run-time workspace data in {0}?	551	WorkbenchLauncherConfigurationDelegate_confirmDeleteWorkspace = Do you really want to clear the run-time workspace data in {0}?
556	JUnitLaunchConfiguration_error_notaplugin = Could not launch the JUnit plug-in tests because project ''{0}'' is not a plug-in project.
557	JUnitLaunchConfiguration_error_missingPlugin = Required plug-in ''{0}'' could not be found.
558		552
559	Launcher_error_title=Launch Error	553	Launcher_error_title=Launch Error
560	LauncherSection_desc=Customize the executable that is used to launch the product.	554	LauncherSection_desc=Customize the executable that is used to launch the product.
561	LauncherSection_ico=Use a single ICO file containing the 6 images:	555	LauncherSection_ico=Use a single ICO file containing the 6 images:
562	LauncherUtils_workspaceLocked=Workspace Cannot Be Locked	556	LauncherUtils_workspaceLocked=Workspace Cannot Be Locked
563	LauncherUtils_cannotLaunchApplication=Could not launch the application because the associated workspace is currently in use by another Eclipse application.\n\n{0}
564	LauncherUtils_clearLogFile=Do you really want to clear the log file?	557	LauncherUtils_clearLogFile=Do you really want to clear the log file?
565	LauncherUtils_title=Launcher	558	LauncherUtils_title=Launcher
566	LauncherPage_title=Launching	559	LauncherPage_title=Launching
Lines 568-574 Link Here
568	LauncherSection_icon=Icon:	561	LauncherSection_icon=Icon:
569	LauncherSection_tiny=Tiny:	562	LauncherSection_tiny=Tiny:
570	Launcher_error_code13=The application could not start. Would you like to view the log?	563	Launcher_error_code13=The application could not start. Would you like to view the log?
571	Launcher_error_code15=Could not launch the configuration because the associated workspace is currently in use.
572	Launcher_error_displayInLogView=Yes, in the Error Log view	564	Launcher_error_displayInLogView=Yes, in the Error Log view
573	LauncherUtils_generateConfigIni=The config.ini template file you specified does not exist. Continue launching with a generated config.ini file?	565	LauncherUtils_generateConfigIni=The config.ini template file you specified does not exist. Continue launching with a generated config.ini file?
574	Launcher_error_displayInSystemEditor=Yes, in an editor	566	Launcher_error_displayInSystemEditor=Yes, in an editor
Lines 2008-2014 Link Here
2008	InternationalizeWizard_NLSFragmentGenerator_errorMessage = An error occured while generating an NL Fragment.	2000	InternationalizeWizard_NLSFragmentGenerator_errorMessage = An error occured while generating an NL Fragment.
2009		2001
2010	MainTab_jreSection = Java Runtime Environment	2002	MainTab_jreSection = Java Runtime Environment
2011	EquinoxLaunchConfiguration_oldTarget=The org.eclipse.osgi plug-in is missing from this configuration.
2012	EquinoxPluginBlock_levelColumn=Start Level	2003	EquinoxPluginBlock_levelColumn=Start Level
2013	EquinoxPluginsTab_defaultStart=Default S&tart level:	2004	EquinoxPluginsTab_defaultStart=Default S&tart level:
2014	EquinoxPluginBlock_autoColumn=Auto-Start	2005	EquinoxPluginBlock_autoColumn=Auto-Start
Lines 2185-2192 Link Here
2185	EditorSourcePage_name=Source	2176	EditorSourcePage_name=Source
2186	EditTargetNode_0=New Target Definition	2177	EditTargetNode_0=New Target Definition
2187	OSGiBundlesTab_frameworkLabel=&Framework:	2178	OSGiBundlesTab_frameworkLabel=&Framework:
2188	OSGiLaunchConfiguration_cannotFindLaunchConfiguration=Cannot find the {0} OSGi framework.
2189	OSGiLaunchConfiguration_selected=selected
2190	OSGiFrameworkPreferencePage_default=(default)	2179	OSGiFrameworkPreferencePage_default=(default)
2191	OSGiFrameworkPreferencePage_installed=Installed <a>OSGi frameworks</a>:	2180	OSGiFrameworkPreferencePage_installed=Installed <a>OSGi frameworks</a>:
2192	OSGiFrameworkPreferencePage_installed_nolink=Installed OSGi frameworks:	2181	OSGiFrameworkPreferencePage_installed_nolink=Installed OSGi frameworks:
Lines 2218-2224 Link Here
2218	UpdateSplashHandlerInModelAction_nameEnterprise=Enterprise	2207	UpdateSplashHandlerInModelAction_nameEnterprise=Enterprise
2219	UpdateSplashProgressAction_msgErrorTextFileBuffer=Text file buffer is NULL	2208	UpdateSplashProgressAction_msgErrorTextFileBuffer=Text file buffer is NULL
2220	UpdateSplashHandlerInModelAction_nameLanguages=Languages	2209	UpdateSplashHandlerInModelAction_nameLanguages=Languages
2221	EclipsePluginValidationOperation_pluginMissing={0} is missing
2222	SplashProgressSection_progressName=Customization	2210	SplashProgressSection_progressName=Customization
2223	SplashProgressSection_progressSectionDesc=Create a custom splash screen using one of the provided templates or by adding a progress bar and message.	2211	SplashProgressSection_progressSectionDesc=Create a custom splash screen using one of the provided templates or by adding a progress bar and message.
2224	UpdateSplashHandlerInModelAction_templateTypeInteractive=Interactive - A simulated log-in session	2212	UpdateSplashHandlerInModelAction_templateTypeInteractive=Interactive - A simulated log-in session
Lines 2274-2281 Link Here
2274	PDECompilersConfigurationBlock_warning = Warning	2262	PDECompilersConfigurationBlock_warning = Warning
2275	PDECompilersConfigurationBlock_ignore = Ignore	2263	PDECompilersConfigurationBlock_ignore = Ignore
2276		2264
2277	VMHelper_cannotFindExecEnv=Cannot locate Execution Environment definition: "{0}". Launch aborted.
2278
2279	LicensingPage_title=Licensing	2265	LicensingPage_title=Licensing
2280	LicenseSection_title=License	2266	LicenseSection_title=License
2281	LicenseSection_description=Specify the license text and URL for the product.	2267	LicenseSection_description=Specify the license text and URL for the product.

Lines 16-27 Link Here

(-)src/org/eclipse/pde/internal/ui/PDEPlugin.java (-90 / +2 lines)
16	import org.eclipse.core.resources.IWorkspace;	16	import org.eclipse.core.resources.IWorkspace;
17	import org.eclipse.core.resources.ResourcesPlugin;	17	import org.eclipse.core.resources.ResourcesPlugin;
18	import org.eclipse.core.runtime.*;	18	import org.eclipse.core.runtime.*;
19	import org.eclipse.debug.core.DebugPlugin;
20	import org.eclipse.debug.core.ILaunchConfigurationListener;
21	import org.eclipse.jface.dialogs.ErrorDialog;	19	import org.eclipse.jface.dialogs.ErrorDialog;
22	import org.eclipse.jface.preference.IPreferenceStore;	20	import org.eclipse.jface.preference.IPreferenceStore;
23	import org.eclipse.pde.internal.core.PDEPreferencesManager;	21	import org.eclipse.pde.internal.core.PDEPreferencesManager;
24	import org.eclipse.pde.internal.ui.launcher.*;	22	import org.eclipse.pde.internal.ui.launcher.PDELogFileProvider;
25	import org.eclipse.pde.internal.ui.util.SWTUtil;	23	import org.eclipse.pde.internal.ui.util.SWTUtil;
26	import org.eclipse.swt.widgets.Display;	24	import org.eclipse.swt.widgets.Display;
27	import org.eclipse.swt.widgets.Shell;	25	import org.eclipse.swt.widgets.Shell;
Lines 33-50 Link Here
33	import org.eclipse.ui.internal.views.log.LogFilesManager;	31	import org.eclipse.ui.internal.views.log.LogFilesManager;
34	import org.eclipse.ui.plugin.AbstractUIPlugin;	32	import org.eclipse.ui.plugin.AbstractUIPlugin;
35	import org.eclipse.ui.texteditor.IDocumentProvider;	33	import org.eclipse.ui.texteditor.IDocumentProvider;
36	import org.osgi.framework.*;	34	import org.osgi.framework.BundleContext;
37		35
38	public class PDEPlugin extends AbstractUIPlugin implements IPDEUIConstants {	36	public class PDEPlugin extends AbstractUIPlugin implements IPDEUIConstants {
39		37
40	// Shared instance	38	// Shared instance
41	private static PDEPlugin fInstance;	39	private static PDEPlugin fInstance;
42		40
43	// Launches listener
44	private LaunchListener fLaunchListener;
45
46	private BundleContext fBundleContext;
47
48	private Hashtable fCounters;	41	private Hashtable fCounters;
49		42
50	// Provides Launch Configurations log files to Log View	43	// Provides Launch Configurations log files to Log View
Lines 55-73 Link Here
55	private PDELabelProvider fLabelProvider;	48	private PDELabelProvider fLabelProvider;
56		49
57	/**	50	/**
58	* Utility class to help setup the launch configuration listener
59	* without loading the debug plugin
60	*/
61	private DebugPluginUtil fDebugPluginUtil;
62
63	/**
64	* The shared text file document provider.	51	* The shared text file document provider.
65	* @since 3.2	52	* @since 3.2
66	*/	53	*/
67	private IDocumentProvider fTextFileDocumentProvider;	54	private IDocumentProvider fTextFileDocumentProvider;
68		55
69	private OSGiFrameworkManager fOSGiFrameworkManager;
70
71	private PDEPreferencesManager fPreferenceManager;	56	private PDEPreferencesManager fPreferenceManager;
72		57
73	public PDEPlugin() {	58	public PDEPlugin() {
Lines 183-231 Link Here
183	*/	168	*/
184	public void start(BundleContext context) throws Exception {	169	public void start(BundleContext context) throws Exception {
185	super.start(context);	170	super.start(context);
186	fBundleContext = context;
187	setupLaunchConfigurationListener();
188	fLogFileProvider = new PDELogFileProvider();	171	fLogFileProvider = new PDELogFileProvider();
189	LogFilesManager.addLogFileProvider(fLogFileProvider);	172	LogFilesManager.addLogFileProvider(fLogFileProvider);
190	}	173	}
191		174
192	/**
193	* Add the launch configuration listener if the debug plugin
194	* is started. Otherwise, setup a bundle listener to install
195	* the listener when the debug plugin loads.
196	* @param context bundle context needed to get current bundles
197	*/
198	private void setupLaunchConfigurationListener() {
199	boolean listenerStarted = false;
200	Bundle bundle = Platform.getBundle("org.eclipse.debug.core"); //$NON-NLS-1$
201	if (bundle != null && bundle.getState() == Bundle.ACTIVE) {
202	fDebugPluginUtil = new DebugPluginUtil();
203	fDebugPluginUtil.addListener();
204	listenerStarted = true;
205	}
206	if (!listenerStarted) {
207	fBundleContext.addBundleListener(new BundleListener() {
208	public void bundleChanged(BundleEvent event) {
209	if (event.getType() == BundleEvent.STARTED && "org.eclipse.debug.core".equals(event.getBundle().getSymbolicName())) { //$NON-NLS-1$
210	fDebugPluginUtil = new DebugPluginUtil();
211	fDebugPluginUtil.addListener();
212	fBundleContext.removeBundleListener(this);
213	}
214	}
215	});
216	}
217	}
218
219	public BundleContext getBundleContext() {
220	return fBundleContext;
221	}
222
223	/* (non-Javadoc)	175	/* (non-Javadoc)
224	* @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)	176	* @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
225	*/	177	*/
226	public void stop(BundleContext context) throws Exception {	178	public void stop(BundleContext context) throws Exception {
227	if (fLaunchListener != null)
228	fLaunchListener.shutdown();
229	if (fFormColors != null) {	179	if (fFormColors != null) {
230	fFormColors.dispose();	180	fFormColors.dispose();
231	fFormColors = null;	181	fFormColors = null;
Lines 234-247 Link Here
234	fLabelProvider.dispose();	184	fLabelProvider.dispose();
235	fLabelProvider = null;	185	fLabelProvider = null;
236	}	186	}
237	if (fDebugPluginUtil != null) {
238	fDebugPluginUtil.removeListener();
239	}
240	if (fLogFileProvider != null) {	187	if (fLogFileProvider != null) {
241	LogFilesManager.removeLogFileProvider(fLogFileProvider);	188	LogFilesManager.removeLogFileProvider(fLogFileProvider);
242	fLogFileProvider = null;	189	fLogFileProvider = null;
243	}	190	}
244	LauncherUtils.shutdown();
245	super.stop(context);	191	super.stop(context);
246	}	192	}
247		193
Lines 251-268 Link Here
251	return fLabelProvider;	197	return fLabelProvider;
252	}	198	}
253		199
254	public LaunchListener getLaunchListener() {
255	if (fLaunchListener == null)
256	fLaunchListener = new LaunchListener();
257	return fLaunchListener;
258	}
259
260	public OSGiFrameworkManager getOSGiFrameworkManager() {
261	if (fOSGiFrameworkManager == null)
262	fOSGiFrameworkManager = new OSGiFrameworkManager();
263	return fOSGiFrameworkManager;
264	}
265
266	public static boolean isFullNameModeEnabled() {	200	public static boolean isFullNameModeEnabled() {
267	IPreferenceStore store = getDefault().getPreferenceStore();	201	IPreferenceStore store = getDefault().getPreferenceStore();
268	return store.getString(IPreferenceConstants.PROP_SHOW_OBJECTS).equals(IPreferenceConstants.VALUE_USE_NAMES);	202	return store.getString(IPreferenceConstants.PROP_SHOW_OBJECTS).equals(IPreferenceConstants.VALUE_USE_NAMES);
Lines 280-305 Link Here
280	return fTextFileDocumentProvider;	214	return fTextFileDocumentProvider;
281	}	215	}
282		216
283	/**
284	* Utility class that creates and controls a the PDE launch configuration listener.
285	* This is done in a separate class to avoid loading the debug plugin.
286	* @since 3.4
287	*/
288	private class DebugPluginUtil {
289	private ILaunchConfigurationListener fLaunchConfigurationListener;
290
291	public void addListener() {
292	if (fLaunchConfigurationListener == null) {
293	fLaunchConfigurationListener = new LaunchConfigurationListener();
294	}
295	DebugPlugin.getDefault().getLaunchManager().addLaunchConfigurationListener(fLaunchConfigurationListener);
296	}
297
298	public void removeListener() {
299	if (fLaunchConfigurationListener != null) {
300	DebugPlugin.getDefault().getLaunchManager().removeLaunchConfigurationListener(fLaunchConfigurationListener);
301	fLaunchConfigurationListener = null;
302	}
303	}
304	}
305	}	217	}

Lines 11-28 Link Here

(-)src/org/eclipse/pde/internal/ui/IPreferenceConstants.java (-5 / +3 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.pde.internal.ui;	12	package org.eclipse.pde.internal.ui;
13		13
		14	import org.eclipse.pde.internal.launching.ILaunchingPreferenceConstants;
		15
14	/**	16	/**
15	* Listing of constants used in PDE preferences	17	* Listing of constants used in PDE preferences
16	*	18	*
17	* @noimplement This interface is not intended to be implemented by clients.	19	* @noimplement This interface is not intended to be implemented by clients.
18	*/	20	*/
19	public interface IPreferenceConstants {	21	public interface IPreferenceConstants extends ILaunchingPreferenceConstants {
20		22
21	// Main preference page	23	// Main preference page
22	public static final String PROP_SHOW_OBJECTS = "Preferences.MainPage.showObjects"; //$NON-NLS-1$	24	public static final String PROP_SHOW_OBJECTS = "Preferences.MainPage.showObjects"; //$NON-NLS-1$
23	public static final String VALUE_USE_IDS = "useIds"; //$NON-NLS-1$	25	public static final String VALUE_USE_IDS = "useIds"; //$NON-NLS-1$
24	public static final String VALUE_USE_NAMES = "useNames"; //$NON-NLS-1$	26	public static final String VALUE_USE_NAMES = "useNames"; //$NON-NLS-1$
25	public static final String PROP_AUTO_MANAGE = "Preferences.MainPage.automanageDependencies"; //$NON-NLS-1$
26	public static final String PROP_SHOW_SOURCE_BUNDLES = "Preferences.MainPage.showSourceBundles"; //$NON-NLS-1$	27	public static final String PROP_SHOW_SOURCE_BUNDLES = "Preferences.MainPage.showSourceBundles"; //$NON-NLS-1$
27	public static final String OVERWRITE_BUILD_FILES_ON_EXPORT = "Preferences.MainPage.overwriteBuildFilesOnExport"; //$NON-NLS-1$	28	public static final String OVERWRITE_BUILD_FILES_ON_EXPORT = "Preferences.MainPage.overwriteBuildFilesOnExport"; //$NON-NLS-1$
28	public static final String PROP_PROMPT_REMOVE_TARGET = "Preferences.MainPage.promptRemoveTarget"; //$NON-NLS-1$	29	public static final String PROP_PROMPT_REMOVE_TARGET = "Preferences.MainPage.promptRemoveTarget"; //$NON-NLS-1$
Lines 37-43 Link Here
37	public static final String DEPS_VIEW_SHOW_CALLERS = "DependenciesView.show.callers"; //$NON-NLS-1$	38	public static final String DEPS_VIEW_SHOW_CALLERS = "DependenciesView.show.callers"; //$NON-NLS-1$
38	public static final String DEPS_VIEW_SHOW_LIST = "DependenciesView.show.list"; //$NON-NLS-1$	39	public static final String DEPS_VIEW_SHOW_LIST = "DependenciesView.show.list"; //$NON-NLS-1$
39	public static final String DEPS_VIEW_SHOW_STATE = "DependenciesView.show.state"; //$NON-NLS-1$	40	public static final String DEPS_VIEW_SHOW_STATE = "DependenciesView.show.state"; //$NON-NLS-1$
40
41	// OSGi Frameworks
42	public static final String DEFAULT_OSGI_FRAMEOWRK = "Preference.default.osgi.framework"; //$NON-NLS-1$
43	}	41	}

Lines 52-59 Link Here

(-)src/org/eclipse/pde/internal/ui/PDEUIMessages.java (-17 lines)
52		52
53	public static String DependencyPropertiesDialog_exportGroupText;	53	public static String DependencyPropertiesDialog_exportGroupText;
54		54
55	public static String EclipsePluginValidationOperation_pluginMissing;
56
57	public static String ExternalizeStringsOperation_editNames_addComment;	55	public static String ExternalizeStringsOperation_editNames_addComment;
58		56
59	public static String ExternalizeStringsOperation_editNames_insertProperty;	57	public static String ExternalizeStringsOperation_editNames_insertProperty;
Lines 179-186 Link Here
179		177
180	public static String LauncherUtils_workspaceLocked;	178	public static String LauncherUtils_workspaceLocked;
181		179
182	public static String LauncherUtils_cannotLaunchApplication;
183
184	public static String LauncherUtils_clearLogFile;	180	public static String LauncherUtils_clearLogFile;
185		181
186	public static String LauncherUtils_generateConfigIni;	182	public static String LauncherUtils_generateConfigIni;
Lines 895-907 Link Here
895	public static String ConfigurationSection_selection;	891	public static String ConfigurationSection_selection;
896	public static String ConfigurationTab_fileDialogMessage;	892	public static String ConfigurationTab_fileDialogMessage;
897		893
898	public static String WorkbenchLauncherConfigurationDelegate_noJRE;
899	public static String WorkbenchLauncherConfigurationDelegate_jrePathNotFound;
900	public static String WorkbenchLauncherConfigurationDelegate_badFeatureSetup;
901	public static String WorkbenchLauncherConfigurationDelegate_noStartup;
902	public static String WorkbenchLauncherConfigurationDelegate_confirmDeleteWorkspace;	894	public static String WorkbenchLauncherConfigurationDelegate_confirmDeleteWorkspace;
903	public static String JUnitLaunchConfiguration_error_notaplugin;
904	public static String JUnitLaunchConfiguration_error_missingPlugin;
905		895
906	public static String Launcher_error_title;	896	public static String Launcher_error_title;
907	public static String LauncherSection_desc;	897	public static String LauncherSection_desc;
Lines 910-916 Link Here
910	public static String LauncherSection_icon;	900	public static String LauncherSection_icon;
911	public static String LauncherSection_tiny;	901	public static String LauncherSection_tiny;
912	public static String Launcher_error_code13;	902	public static String Launcher_error_code13;
913	public static String Launcher_error_code15;
914	public static String Launcher_error_displayInLogView;	903	public static String Launcher_error_displayInLogView;
915	public static String Launcher_error_displayInSystemEditor;	904	public static String Launcher_error_displayInSystemEditor;
916	public static String LauncherSection_browse;	905	public static String LauncherSection_browse;
Lines 933-940 Link Here
933	public static String OpenLogDialog_cannotDisplay;	922	public static String OpenLogDialog_cannotDisplay;
934		923
935	public static String OSGiBundlesTab_frameworkLabel;	924	public static String OSGiBundlesTab_frameworkLabel;
936	public static String OSGiLaunchConfiguration_cannotFindLaunchConfiguration;
937	public static String OSGiLaunchConfiguration_selected;
938		925
939	// Preferences ####################################	926	// Preferences ####################################
940	public static String Preferences_MainPage_Description;	927	public static String Preferences_MainPage_Description;
Lines 2103-2110 Link Here
2103		2090
2104	public static String EquinoxSettingsTab_name;	2091	public static String EquinoxSettingsTab_name;
2105		2092
2106	public static String EquinoxLaunchConfiguration_oldTarget;
2107
2108	public static String ModelChangeLabelProvider_instance;	2093	public static String ModelChangeLabelProvider_instance;
2109		2094
2110	public static String ModelChangeLabelProvider_instances;	2095	public static String ModelChangeLabelProvider_instances;
Lines 2758-2765 Link Here
2758	public static String HyperlinkActionOpenBundle;	2743	public static String HyperlinkActionOpenBundle;
2759	public static String HyperlinkActionOpenPackage;	2744	public static String HyperlinkActionOpenPackage;
2760		2745
2761	public static String VMHelper_cannotFindExecEnv;
2762
2763	public static String HyperlinkActionOpenResource;	2746	public static String HyperlinkActionOpenResource;
2764	public static String HyperlinkActionOpenSchema;	2747	public static String HyperlinkActionOpenSchema;
2765	public static String HyperlinkActionOpenTranslation;	2748	public static String HyperlinkActionOpenTranslation;

Lines 19-25 Link Here

(-)src/org/eclipse/pde/internal/ui/editor/plugin/DependencyManagementSection.java (-3 / +4 lines)
19	import org.eclipse.core.runtime.NullProgressMonitor;	19	import org.eclipse.core.runtime.NullProgressMonitor;
20	import org.eclipse.core.runtime.preferences.IEclipsePreferences;	20	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
21	import org.eclipse.jface.action.*;	21	import org.eclipse.jface.action.*;
22	import org.eclipse.jface.preference.IPreferenceStore;
23	import org.eclipse.jface.util.IPropertyChangeListener;	22	import org.eclipse.jface.util.IPropertyChangeListener;
24	import org.eclipse.jface.util.PropertyChangeEvent;	23	import org.eclipse.jface.util.PropertyChangeEvent;
25	import org.eclipse.jface.viewers.*;	24	import org.eclipse.jface.viewers.*;
Lines 33-38 Link Here
33	import org.eclipse.pde.internal.core.plugin.ExternalPluginModel;	32	import org.eclipse.pde.internal.core.plugin.ExternalPluginModel;
34	import org.eclipse.pde.internal.core.plugin.WorkspacePluginModel;	33	import org.eclipse.pde.internal.core.plugin.WorkspacePluginModel;
35	import org.eclipse.pde.internal.core.text.build.BuildEntry;	34	import org.eclipse.pde.internal.core.text.build.BuildEntry;
		35	import org.eclipse.pde.internal.launching.ILaunchingPreferenceConstants;
		36	import org.eclipse.pde.internal.launching.PDELaunchingPlugin;
36	import org.eclipse.pde.internal.ui.*;	37	import org.eclipse.pde.internal.ui.*;
37	import org.eclipse.pde.internal.ui.dialogs.PluginSelectionDialog;	38	import org.eclipse.pde.internal.ui.dialogs.PluginSelectionDialog;
38	import org.eclipse.pde.internal.ui.editor.*;	39	import org.eclipse.pde.internal.ui.editor.*;
Lines 393-400 Link Here
393	entry.addToken(pmodel.getPlugin().getId());	394	entry.addToken(pmodel.getPlugin().getId());
394	}	395	}
395	markDirty();	396	markDirty();
396	IPreferenceStore store = PDEPlugin.getDefault().getPreferenceStore();	397	PDEPreferencesManager store = PDELaunchingPlugin.getDefault().getPreferenceManager();
397	store.setDefault(IPreferenceConstants.PROP_AUTO_MANAGE, true);	398	store.setDefault(ILaunchingPreferenceConstants.PROP_AUTO_MANAGE, true);
398	} catch (CoreException e) {	399	} catch (CoreException e) {
399	PDEPlugin.logException(e);	400	PDEPlugin.logException(e);
400	}	401	}

Removed Link Here

(-)schema/osgiFrameworks.exsd (-159 lines)
1	<?xml version='1.0' encoding='UTF-8'?>
2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.pde.ui">
4	<annotation>
5	<appInfo>
6	<meta.schema plugin="org.eclipse.pde.ui" id="osgiFrameworks" name="OSGi Frameworks"/>
7	</appInfo>
8	<documentation>
9	<p>
10	This extension point is used to register new OSGi frameworks. Each framework is associated with a launcher delegate that is called when the OSGi framework is selected in the <b>OSGi Framework</b> launch configuration.
11	</p>
12	<p>Registered OSGi frameworks appear on the <b>Plug-in Development > OSGi frameworks</b> preference page, where a default framework can be set.
13	</p>
14	</documentation>
15	</annotation>
16
17	<element name="extension">
18	<complexType>
19	<sequence>
20	<element ref="framework" minOccurs="1" maxOccurs="unbounded"/>
21	</sequence>
22	<attribute name="point" type="string" use="required">
23	<annotation>
24	<documentation>
25
26	</documentation>
27	</annotation>
28	</attribute>
29	<attribute name="id" type="string">
30	<annotation>
31	<documentation>
32
33	</documentation>
34	</annotation>
35	</attribute>
36	<attribute name="name" type="string">
37	<annotation>
38	<documentation>
39
40	</documentation>
41	<appInfo>
42	<meta.attribute translatable="true"/>
43	</appInfo>
44	</annotation>
45	</attribute>
46	</complexType>
47	</element>
48
49	<element name="framework">
50	<complexType>
51	<attribute name="id" type="string" use="required">
52	<annotation>
53	<documentation>
54	a unique identifier of the framework
55	</documentation>
56	</annotation>
57	</attribute>
58	<attribute name="name" type="string" use="required">
59	<annotation>
60	<documentation>
61	human-readable name of the OSGi framework
62	</documentation>
63	<appInfo>
64	<meta.attribute translatable="true"/>
65	</appInfo>
66	</annotation>
67	</attribute>
68	<attribute name="launcherDelegate" type="string" use="required">
69	<annotation>
70	<documentation>
71	a launch configuration delegate to launch the OSGi framework. The value of this attribute is the fully qualified name of the Java class that extends <code>org.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration</code>.
72	</documentation>
73	<appInfo>
74	<meta.attribute kind="java" basedOn="org.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration"/>
75	</appInfo>
76	</annotation>
77	</attribute>
78	<attribute name="initializer" type="string">
79	<annotation>
80	<documentation>
81	initializes new OSGi Framework launch configurations with suitable defaults. The value of this attribute must be a fully-qualified name of a Java class that extends the default implementation <code>org.eclipse.pde.ui.launcher.OSGiLaunchConfigurationInitializer</code>. If not specified, the default initializer <code>org.eclipse.pde.ui.launcher.OSGiLaunchConfigurationInitializer</code> is instantiated.
82	</documentation>
83	<appInfo>
84	<meta.attribute kind="java" basedOn="org.eclipse.pde.ui.launcher.OSGiLaunchConfigurationInitializer"/>
85	</appInfo>
86	</annotation>
87	</attribute>
88	</complexType>
89	</element>
90
91	<annotation>
92	<appInfo>
93	<meta.section type="since"/>
94	</appInfo>
95	<documentation>
96	3.3
97	</documentation>
98	</annotation>
99
100	<annotation>
101	<appInfo>
102	<meta.section type="examples"/>
103	</appInfo>
104	<documentation>
105	<p>
106	The following is an example of the extension point:
107	<pre>
108	<extension
109	point="org.eclipse.pde.ui.osgiFrameworks">
110	<framework
111	launcherDelegate="org.eclipse.pde.ui.launcher.EquinoxLaunchConfiguration"
112	id="org.eclipse.pde.ui.EquinoxFramework"
113	name="%Equinox.shortcut.label"
114	initializer="org.eclipse.pde.internal.ui.launcher.EquinoxInitializer"/>
115	</extension>
116	</pre>
117	</documentation>
118	</annotation>
119
120	<annotation>
121	<appInfo>
122	<meta.section type="apiInfo"/>
123	</appInfo>
124	<documentation>
125	<p>
126	The value of the attribute <code>launcherDelegate</code> must be a fully qualified name of a Java class that extends <code>org.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration</code>. If the launcher is to provide its own source lookup order, then the method <code>setDefaultSourceLocator</code> should be overridden.
127	</p>
128	<p>
129	The value of the attribute <code>initializer</code> must be a fully qualified name of a Java class that extends <code>org.eclipse.ui.launcher.OSGiLaunchConfigurationInitializer</code>.
130	</p>
131	</documentation>
132	</annotation>
133
134	<annotation>
135	<appInfo>
136	<meta.section type="implementation"/>
137	</appInfo>
138	<documentation>
139	<p>
140	PDE supplies the Equinox OSGi Framework extension to launch Equinox frameworks.
141	</p>
142	</documentation>
143	</annotation>
144
145	<annotation>
146	<appInfo>
147	<meta.section type="copyright"/>
148	</appInfo>
149	<documentation>
150	Copyright (c) 2006 IBM Corporation and others.
151	<br>
152	All rights reserved. This program and the accompanying materials are made
153	available under the terms of the Eclipse Public License v1.0 which
154	accompanies this distribution, and is available at
155	<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
156	</documentation>
157	</annotation>
158
159	</schema>

Added Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/PluginValidationStatusHandler.java (+57 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 eXXcellent solutions gmbh, EclipseSource Corporation
3	* and others.
4	* All rights reserved. This program and the accompanying materials
5	* are made available under the terms of the Eclipse Public License v1.0
6	* which accompanies this distribution, and is available at
7	* http://www.eclipse.org/legal/epl-v10.html
8	*
9	* Contributors:
10	* Achim Demelt, eXXcellent solutions gmbh - initial API and implementation
11	* EclipseSource - initial API and implementation, ongoing enhancements
12	*******************************************************************************/
13	package org.eclipse.pde.internal.ui.launcher;
14
15	import org.eclipse.core.runtime.*;
16	import org.eclipse.debug.core.IStatusHandler;
17	import org.eclipse.jface.dialogs.IDialogConstants;
18	import org.eclipse.osgi.util.NLS;
19	import org.eclipse.pde.internal.launching.PDEMessages;
20	import org.eclipse.pde.internal.launching.launcher.*;
21	import org.eclipse.pde.internal.ui.*;
22	import org.eclipse.pde.internal.ui.elements.NamedElement;
23	import org.eclipse.swt.graphics.Image;
24	import org.eclipse.swt.widgets.Display;
25
26	public class PluginValidationStatusHandler implements IStatusHandler {
27	public Object handleStatus(IStatus status, Object source) throws CoreException {
28	if (status.getCode() == EclipsePluginValidationOperation.CREATE_EXTENSION_ERROR_CODE)
29	return createExtensionError((String) source);
30	else if (status.getCode() == LaunchPluginValidator.DISPLAY_VALIDATION_ERROR_CODE)
31	displayValidationError((LaunchValidationOperation) source);
32	return null;
33	}
34
35	private Object createExtensionError(String bundleID) {
36	String name = NLS.bind(PDEMessages.EclipsePluginValidationOperation_pluginMissing, bundleID);
37	PDELabelProvider provider = PDEPlugin.getDefault().getLabelProvider();
38	Image image = provider.get(PDEPluginImages.DESC_PLUGIN_OBJ);
39	return new NamedElement(name, image);
40	}
41
42	private void displayValidationError(final LaunchValidationOperation op) throws CoreException {
43	final int[] result = new int[1];
44	final Display display = LauncherUtilsStatusHandler.getDisplay();
45	display.syncExec(new Runnable() {
46	public void run() {
47	PluginStatusDialog dialog = new PluginStatusDialog(display.getActiveShell());
48	dialog.showCancelButton(true);
49	dialog.setInput(op.getInput());
50	result[0] = dialog.open();
51	}
52	});
53	if (result[0] == IDialogConstants.CANCEL_ID)
54	throw new CoreException(Status.CANCEL_STATUS);
55	}
56
57	}