Manifest-Version: 1.0

Bundle-ManifestVersion: 2

Bundle-Name: %name

Bundle-SymbolicName: org.eclipse.pde.launching;singleton:=true

Bundle-Version: 3.5.0.qualifier

Bundle-RequiredExecutionEnvironment: J2SE-1.4

Bundle-Vendor: %provider-name

Require-Bundle: org.eclipse.jdt.junit.core;bundle-version="[3.6.0,4.0.0)",

 org.eclipse.jdt.launching;bundle-version="[3.2.0,4.0.0)",

 org.eclipse.debug.core;bundle-version="[3.2.0,4.0.0)",

 org.eclipse.core.runtime;bundle-version="[3.1.0,4.0.0)",

 org.eclipse.jdt.core;bundle-version="[3.2.0,4.0.0)",

 org.eclipse.core.variables;bundle-version="[3.1.0,4.0.0)",

 org.eclipse.pde.build;bundle-version="[3.2.0,4.0.0)",

 org.eclipse.pde.core;bundle-version="[3.2.0,4.0.0)",

 org.eclipse.jdt.debug;bundle-version="[3.2.0,4.0.0)",

 org.eclipse.core.filesystem;bundle-version="[1.0.0,2.0.0)"

Bundle-Activator: org.eclipse.pde.launching.launcher.PDELaunchingPlugin

Export-Package: org.eclipse.pde.internal.launching;x-friends:="org.eclipse.pde.ui",

 org.eclipse.pde.internal.launching.launcher;x-friends:="org.eclipse.pde.ui",

 org.eclipse.pde.launching.launcher

Bundle-ActivationPolicy: lazy

Bundle-Localization: plugin

<?xml version="1.0" encoding="UTF-8"?>

<classpath>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/>

	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>

	<classpathentry kind="src" path="src"/>

	<classpathentry kind="output" path="bin"/>

</classpath>

<?xml version='1.0' encoding='UTF-8'?>

<!-- Schema file written by PDE -->

<schema targetNamespace="org.eclipse.pde.ui" xmlns="http://www.w3.org/2001/XMLSchema">

<annotation>

      <appinfo>

         <meta.schema plugin="org.eclipse.pde.ui" id="osgiFrameworks" name="OSGi Frameworks"/>

      </appinfo>

      <documentation>

         <p>

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.

</p>

<p>Registered OSGi frameworks appear on the <b>Plug-in Development > OSGi frameworks</b> preference page, where a default framework can be set.

</p>

      </documentation>

   </annotation>

   <element name="extension">

      <annotation>

         <appinfo>

            <meta.element />

         </appinfo>

      </annotation>

      <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 <code>org.eclipse.pde.launcher.AbstractPDELaunchConfiguration</code>.

               </documentation>

               <appinfo>

                  <meta.attribute kind="java" basedOn="org.eclipse.pde.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 <code>org.eclipse.pde.launcher.OSGiLaunchConfigurationInitializer</code>.  If not specified, the default initializer <code>org.eclipse.pde.launcher.OSGiLaunchConfigurationInitializer</code> is instantiated.

               </documentation>

               <appinfo>

                  <meta.attribute kind="java" basedOn="org.eclipse.pde.launcher.OSGiLaunchConfigurationInitializer"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <annotation>

      <appinfo>

         <meta.section type="since"/>

      </appinfo>

      <documentation>

         3.6

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="examples"/>

      </appinfo>

      <documentation>

         <p>

The following is an example of the extension point:

<pre>

   <extension

         point="org.eclipse.pde.launching.osgiFrameworks">

      <framework

            launcherDelegate="org.eclipse.pde.launcher.EquinoxLaunchConfiguration"

            id="org.eclipse.pde.ui.EquinoxFramework"

            name="%Equinox.shortcut.label" 

            initializer="org.eclipse.pde.internal.launcher.EquinoxInitializer"/>

   </extension>

</pre>

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="apiInfo"/>

      </appinfo>

      <documentation>

         <p>

The value of the attribute <code>launcherDelegate</code> must be a fully qualified name of a Java class that extends <code>org.eclipse.pde.launcher.AbstractPDELaunchConfiguration</code>.  If the launcher is to provide its own source lookup order, then the method <code>setDefaultSourceLocator</code> should be overridden.

</p>

<p>

The value of the attribute <code>initializer</code> must be a fully qualified name of a Java class that extends <code>org.eclipse.launcher.OSGiLaunchConfigurationInitializer</code>.

</p>

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="implementation"/>

      </appinfo>

      <documentation>

         <p>

PDE supplies the Equinox OSGi Framework extension to launch Equinox frameworks.

</p>

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="copyright"/>

      </appinfo>

      <documentation>

         Copyright (c) 2006 IBM Corporation and others.

<br>

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 

<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.

      </documentation>

   </annotation>

</schema>

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>org.eclipse.pde.launching</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.ManifestBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.SchemaBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.pde.PluginNature</nature>

		<nature>org.eclipse.jdt.core.javanature</nature>

	</natures>

</projectDescription>

/*******************************************************************************

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

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

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

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

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

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;

/**

 * A launch delegate for launching OSGi frameworks

 * <p>

 * Clients may subclass and instantiate this class.

 * </p>

 * @since 3.3

 */

public class OSGiLaunchConfigurationDelegate extends LaunchConfigurationDelegate {

	/**

	 * 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 = PDELaunchingPlugin.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 = PDEMessages.OSGiLaunchConfiguration_selected;

			String message = NLS.bind(PDEMessages.OSGiLaunchConfiguration_cannotFindLaunchConfiguration, name);

			IStatus status = new Status(IStatus.ERROR, IPDEConstants.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));

	}

}

/*******************************************************************************

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

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

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

import org.eclipse.pde.internal.launching.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.pde.core.plugin.TargetPlatform;

import org.eclipse.pde.internal.core.TargetPlatformHelper;

import org.eclipse.pde.internal.core.builders.PDEMarkerFactory;

/**

 * An abstract launch delegate for PDE-based launch configurations

 * <p>

 * Clients may subclass this class.

 * </p>

 * @since 3.2

 */

public abstract class AbstractPDELaunchConfiguration extends LaunchConfigurationDelegate {

	protected File fConfigDir = null;

	protected IPDELaunchConfigurationHelper helper = PDELaunchingPlugin.getDefault().getLauncherSettings().getPDELaunchConfigurationHelper();

	/* (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(IPDEConstants.RESTART, false) && configuration instanceof ILaunchConfigurationWorkingCopy) {

				((ILaunchConfigurationWorkingCopy) configuration).setAttribute(IPDEConstants.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);

			helper.handleCoreException(e);

		}

	}

	/**

	 * 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 = PDEMessages.WorkbenchLauncherConfigurationDelegate_noStartup;

			throw new CoreException(PDELaunchingPlugin.getDefault().getLauncherUtils().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(IPDEConstants.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) {

		PDELaunchingPlugin.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) {

		PDELaunchingPlugin.getDefault().getLauncherUtils().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, PDELaunchingPlugin.getDefault().getLauncherSettings().getEclipsePluginValidationOperationHelper());

		LaunchPluginValidator.runValidationOperation(op, monitor);

	}

}

/*******************************************************************************

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

/**

 * Constant definitions for PDE launch configurations.

 * <p>

 * Constant definitions only; not to be implemented.

 * </p>

 * @since 3.2

 * 

 * @noimplement This interface is not intended to be implemented by clients.

 * @noextend This interface is not intended to be extended by clients.

 */

public interface 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.launching.launcher;

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

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

import java.lang.reflect.InvocationTargetException;

import java.net.URL;

import java.util.Hashtable;

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.pde.internal.core.PDEPreferencesManager;

import org.osgi.framework.*;

public class PDELaunchingPlugin extends Plugin implements IPDEConstants {

	// Shared instance

	private static PDELaunchingPlugin fInstance;

	private BundleContext fBundleContext;

	private Hashtable fCounters;

	private IPDELauncherSettings launcherSettings;

	/**

	 * 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 OSGiFrameworkManager fOSGiFrameworkManager;

	private PDEPreferencesManager fPreferenceManager;

	public PDELaunchingPlugin() {

		fInstance = this;

	}

	public PDEPreferencesManager getPreferenceManager() {

		if (fPreferenceManager == null) {

			fPreferenceManager = new PDEPreferencesManager(PLUGIN_ID);

		}

		return fPreferenceManager;

	}

	public URL getInstallURL() {

		return getDefault().getBundle().getEntry("/"); //$NON-NLS-1$

	}

	public static PDELaunchingPlugin getDefault() {

		return fInstance;

	}

	public Hashtable getDefaultNameCounters() {

		if (fCounters == null)

			fCounters = new Hashtable();

		return fCounters;

	}

	public static String getPluginId() {

		return getDefault().getBundle().getSymbolicName();

	}

	public static IWorkspace getWorkspace() {

		return ResourcesPlugin.getWorkspace();

	}

	public static void log(IStatus status) {

		ResourcesPlugin.getPlugin().getLog().log(status);

	}

	public static void logErrorMessage(String message) {

		log(new Status(IStatus.ERROR, getPluginId(), IStatus.ERROR, message, null));

	}

	public static void log(Throwable e) {

		if (e instanceof InvocationTargetException)

			e = ((InvocationTargetException) e).getTargetException();

		IStatus status = null;

		if (e instanceof CoreException)

			status = ((CoreException) e).getStatus();

		else

			status = new Status(IStatus.ERROR, getPluginId(), IStatus.OK, e.getMessage(), e);

		log(status);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.core.runtime.Plugin#start(org.osgi.framework.BundleContext)

	 */

	public void start(BundleContext context) throws Exception {

		super.start(context);

		fBundleContext = context;

		setupLaunchConfigurationListener();

	}

	/**

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

//		}

//		if (fLabelProvider != null) {

//			fLabelProvider.dispose();

//			fLabelProvider = null;

//		}

		if (fDebugPluginUtil != null) {

			fDebugPluginUtil.removeListener();

		}

		getLauncherUtils().shutdown();

		super.stop(context);

	}

	public IPDELaunchListener getLaunchListener() {

		return getLauncherSettings().getLaunchListener();

	}

	public OSGiFrameworkManager getOSGiFrameworkManager() {

		if (fOSGiFrameworkManager == null)

			fOSGiFrameworkManager = new OSGiFrameworkManager();

		return fOSGiFrameworkManager;

	}

	public void setLauncherSettings(IPDELauncherSettings launcherSettings) {

		this.launcherSettings = launcherSettings;

	}

	public IPDELauncherSettings getLauncherSettings() {

		if (launcherSettings == null)

			launcherSettings = new HeadlessPDELauncherSettings();

		return launcherSettings;

	}

	public ILauncherUtils getLauncherUtils() {

		return getLauncherSettings().getLauncherUtils();

	}

	/**

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

			}

		}

	}

}

/*******************************************************************************

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

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

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

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.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.Path;

import org.eclipse.debug.core.ILaunchConfiguration;

import org.eclipse.jdt.core.IJavaProject;

import org.eclipse.jdt.core.IPackageFragmentRoot;

import org.eclipse.jdt.core.JavaCore;

import org.eclipse.jdt.launching.IRuntimeClasspathEntry;

import org.eclipse.jdt.launching.IVMInstall;

import org.eclipse.jdt.launching.JavaRuntime;

import org.eclipse.jdt.launching.StandardSourcePathProvider;

import org.eclipse.pde.internal.core.util.PDEJavaHelper;

/**

 * Generates a source lookup path for all PDE-based launch configurations

 * <p>

 * Clients may subclass this class.

 * </p>

 * @since 3.3

 */

public class PDESourcePathProvider extends StandardSourcePathProvider {

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

			}

		}

	}

}

package org.eclipse.pde.launching.launcher;

import org.eclipse.debug.core.ILaunch;

public interface IPDELaunchListener {

	void manage(ILaunch launch);

	public void shutdown();

}

package org.eclipse.pde.launching.launcher;

import org.eclipse.core.runtime.CoreException;

public interface IPDELaunchConfigurationHelper {

	void handleCoreException(CoreException e);

}

package org.eclipse.pde.launching.launcher;

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

public interface IPDELauncherSettings {

	ILauncherUtils getLauncherUtils();

	IPDELaunchListener getLaunchListener();

	IEclipsePluginValidationOperationHelper getEclipsePluginValidationOperationHelper();

	IPDELaunchConfigurationHelper getPDELaunchConfigurationHelper();

}

/*******************************************************************************

 * 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

 *     EclipseSource Corporation - ongoing enhancements

 *     David Saff <saff@mit.edu> - bug 102632

 *     Ketan Padegaonkar <KetanPadegaonkar@gmail.com> - bug 250340

 *******************************************************************************/

package org.eclipse.pde.launching.launcher;

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

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

import org.eclipse.pde.internal.launching.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.osgi.framework.Version;

/**

 * A launch delegate for launching JUnit Plug-in tests.

 *

 * @since 3.3

 */

public class JUnitLaunchConfigurationDelegate extends org.eclipse.jdt.junit.launcher.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(PDEMessages.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, IPDEConstants.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 = IPDEConstants.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(IPDEConstants.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 IPDEConstants.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 = IPDEConstants.LEGACY_UI_TEST_APPLICATION;

				}

			}

		}

		// launch the UI test application

		if (application == null)

			application = IPDEConstants.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(PDEMessages.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(PDEMessages.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 {