Attachment #50933 for bug #157059

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




   <extension
         point="org.eclipse.debug.core.launchConfigurationTypes">
      <launchConfigurationType
            delegate="org.eclipse.jdt.launching.JavaLaunchDelegate"
            id="org.eclipse.jdt.launching.localJavaApplication"
            migrationDelegate="org.eclipse.jdt.internal.launching.JavaMigrationDelegate"
            modes="run, debug"
            name="%localJavaApplication"
            >
            sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer">
      </launchConfigurationType>
      <launchConfigurationType
            delegate="org.eclipse.jdt.internal.launching.JavaRemoteApplicationLaunchConfigurationDelegate"
            id="org.eclipse.jdt.launching.remoteJavaApplication"
            migrationDelegate="org.eclipse.jdt.internal.launching.JavaMigrationDelegate"
            modes="debug"
            name="%remoteJavaApplication"
            >
            sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer">
      </launchConfigurationType>
      <launchConfigurationType
            delegate="org.eclipse.jdt.internal.launching.JavaAppletLaunchConfigurationDelegate"
            id="org.eclipse.jdt.launching.javaApplet"
            migrationDelegate="org.eclipse.jdt.internal.launching.JavaMigrationDelegate"
            modes="run, debug"
            name="%appletLabel"
            >
            sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer">
      </launchConfigurationType>
   </extension>
   <extension

      	 name= "%jreContainerMarkerProblemName">
      <super type="org.eclipse.core.resources.problemmarker"/>
      <persistent value="true"/>
   </extension>
   <extension
         point="org.eclipse.debug.core.launchDelegates">
      <launchDelegate
            delegate="org.eclipse.jdt.launching.JavaLaunchDelegate"
            id="org.eclipse.jdt.launching.localJavaApplicationDelegate"
            modes="run, debug"
            name="%localJavaApplication"
            sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"
            sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer"
            type="org.eclipse.jdt.launching.localJavaApplication">
      </launchDelegate>
      <launchDelegate
            delegate="org.eclipse.jdt.internal.launching.JavaRemoteApplicationLaunchConfigurationDelegate"
            id="org.eclipse.jdt.launching.remoteJavaApplicationDelegate"
            modes="debug"
            name="%remoteJavaApplication"
            sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"
            sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer"
            type="org.eclipse.jdt.launching.remoteJavaApplication">
      </launchDelegate>
      <launchDelegate
            delegate="org.eclipse.jdt.internal.launching.JavaAppletLaunchConfigurationDelegate"
            id="org.eclipse.jdt.launching.javaAppletDelegate"
            modes="run, debug"
            name="%appletLabel"
            sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"
            sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer"
            type="org.eclipse.jdt.launching.javaApplet">
      </launchDelegate>
   </extension>   
</plugin>

Lines 18-23 Link Here

(-)plugin.xml (+1 lines)
18	<extension-point id="memoryRenderings" name="%memoryRenderingsExtensionPointName" schema="schema/memoryRenderings.exsd"/>	18	<extension-point id="memoryRenderings" name="%memoryRenderingsExtensionPointName" schema="schema/memoryRenderings.exsd"/>
19	<extension-point id="breakpointOrganizers" name="%BreakpointOrganizersName" schema="schema/breakpointOrganizers.exsd"/>	19	<extension-point id="breakpointOrganizers" name="%BreakpointOrganizersName" schema="schema/breakpointOrganizers.exsd"/>
20	<extension-point id="variableValueEditors" name="%VariableValueEditorsName" schema="schema/variableValueEditors.exsd"/>	20	<extension-point id="variableValueEditors" name="%VariableValueEditorsName" schema="schema/variableValueEditors.exsd"/>
		21	<extension-point id="launchConfigurationTabs" name="%LaunchConfigurationTabsExtension.name" schema="schema/launchConfigurationTabs.exsd"/>
21		22
22	<!-- Extensions -->	23	<!-- Extensions -->
23	<extension	24	<extension

Lines 43-48 Link Here

(-)plugin.properties (+2 lines)
43	DebugLaunchGroup.title=Select or configure an application to debug	43	DebugLaunchGroup.title=Select or configure an application to debug
44	DebugModelPresentationExtensionName=Debug Model Presentation	44	DebugModelPresentationExtensionName=Debug Model Presentation
45		45
		46	LaunchConfigurationTabsExtension.name=Launch Configuration Tabs
		47
46	DebugPerspective.name=Debug	48	DebugPerspective.name=Debug
47	DebugPerspective.description=This Debug perspective is designed to support application debugging. It incorporates views for displaying the debug stack, variables and breakpoint management.	49	DebugPerspective.description=This Debug perspective is designed to support application debugging. It incorporates views for displaying the debug stack, variables and breakpoint management.
48		50





import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.debug.internal.core.ConfigurationElementConstants;
import org.eclipse.debug.ui.ILaunchConfigurationTabGroup;



	 */
	protected Set getModes() {
		if (fModes == null) {
			IConfigurationElement[] modes= getConfigurationElement().getChildren(ConfigurationElementConstants.LAUNCH_MODE);
			if (modes.length > 0) {
				fModes = new HashSet(modes.length);
				fPerspectives = new Hashtable(modes.length);
				IConfigurationElement element = null;
				String perspective = null;
				String mode = null;
				for (int i = 0; i < modes.length; i++) {
					element = modes[i];
					mode = element.getAttribute(ConfigurationElementConstants.MODE);
					fModes.add(mode);
					perspective = element.getAttribute(ConfigurationElementConstants.PERSPECTIVE);
					if (perspective != null) {
						fPerspectives.put(mode, perspective);
					}

	 *  tab group is associated with
	 */	
	protected String getTypeIdentifier() {
		return getConfigurationElement().getAttribute(ConfigurationElementConstants.TYPE);
	}
	
	/**

	 * @since 2.1
	 */	
	protected String getHelpContextId() {
		return getConfigurationElement().getAttribute(ConfigurationElementConstants.HELP_CONTEXT_ID);		
	}
	
	/**
	 * Returns the identifier of the tab group
	 * @return the id of the tab group
	 * 
	 * @since 3.3
	 */
	protected String getIdentifier() {
		return getConfigurationElement().getAttribute(ConfigurationElementConstants.ID); 
	}
	
	/**

	 * 	the tab group
	 */
	public ILaunchConfigurationTabGroup newTabGroup() throws CoreException {
		return (ILaunchConfigurationTabGroup)getConfigurationElement().createExecutableExtension(ConfigurationElementConstants.CLASS); 
	}

	/**

	public String getDescription(String mode) {
		String description = null;
		
		IConfigurationElement[] children = fConfig.getChildren(ConfigurationElementConstants.LAUNCH_MODE);
		if (children!= null && children.length != 0) {
			IConfigurationElement child = null;
			for (int i=0; i<children.length; i++) {
				child = children[i];
				if (child.getAttribute("mode").equals(mode)) { //$NON-NLS-1$
					description = child.getAttribute(ConfigurationElementConstants.DESCRIPTION);
				}
			}
		} 
		if (description == null){
			description = fConfig.getAttribute(ConfigurationElementConstants.DESCRIPTION);
		}
		
		if (description == null)




package org.eclipse.debug.internal.ui.launchConfigurations;

 
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.internal.core.ConfigurationElementConstants;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.LaunchConfigurationTabExtension;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.debug.ui.ILaunchConfigurationTab;
import org.eclipse.debug.ui.ILaunchConfigurationTabGroup;

import com.ibm.icu.text.MessageFormat;

	 * used to represent the default tab group (i.e. unspecified mode).
	 */
	private Hashtable fTabGroupExtensions;	
	
	/**
	 * contributed tabs are stored by the tab group id that they contribute to.
	 * each entry is a futher <code>Hashtable</code> consisting of the corrseponding
	 * <code>LaunchConfigurationTabExtension</code> objects for each contributed tab stored by their 
	 * id
	 * 
	 * @since 3.3
	 */
	private Hashtable fContributedTabs;
			
	/**
	 * Constructs the singleton launch configuration presentation

	private LaunchConfigurationPresentationManager() {
		fgDefault = this;
		initializeTabGroupExtensions();
		initializeContributedTabExtensions();
	}

	/**

	 */
	private void initializeTabGroupExtensions() {
		fTabGroupExtensions = new Hashtable();
		IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(DebugUIPlugin.getUniqueIdentifier(), IDebugUIConstants.EXTENSION_POINT_LAUNCH_CONFIGURATION_TAB_GROUPS);
		IConfigurationElement[] groups = extensionPoint.getConfigurationElements();
		LaunchConfigurationTabGroupExtension group = null;
		String typeId = null;
		Map map = null;
		Set modes = null;
		for (int i = 0; i < groups.length; i++) {
			group = new LaunchConfigurationTabGroupExtension(groups[i]);
			typeId = group.getTypeIdentifier();
			map = (Map)fTabGroupExtensions.get(typeId);
			if (map == null) {
				map = new Hashtable();
				fTabGroupExtensions.put(typeId, map);
			} else {
				// verify it references a valid launch configuration type
				ILaunchConfigurationType lct = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurationType(typeId);
				if (lct == null) {
					IStatus status = new Status(IStatus.ERROR, IDebugUIConstants.PLUGIN_ID, IDebugUIConstants.STATUS_INVALID_EXTENSION_DEFINITION,
					 MessageFormat.format("Launch configuration tab group extension {0} refers to non-existent launch configuration type {1}.", (new String[] {groups[i].getAttribute("id"), typeId})), null);  //$NON-NLS-1$ //$NON-NLS-2$
					DebugUIPlugin.log(status);
				}
			}
			modes = group.getModes();
			if (modes == null) {
				// default tabs - store with "*"
				map.put("*", group); //$NON-NLS-1$
			} else {
				// store per mode
				Iterator iterator = modes.iterator();
				while (iterator.hasNext()) {
					map.put(iterator.next(), group);
					// default tabs - store with "*"
					map.put("*", group); //$NON-NLS-1$
				} else {
					// store per mode
					Iterator iterator = modes.iterator();
					while (iterator.hasNext()) {
						map.put(iterator.next(), group);
					}
				}
			}
		}
	}	
	
	/**
	 * This method is used to collect all of the contributed tabs defined by the <code>launchConfigurationTabs</code>
	 * extension point
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 * @since 3.3
	 */
	private void initializeContributedTabExtensions() {
		fContributedTabs = new Hashtable();
		IExtensionPoint epoint = Platform.getExtensionRegistry().getExtensionPoint(DebugUIPlugin.getUniqueIdentifier(), IDebugUIConstants.EXTENSION_POINT_CONTRIBUTED_LAUNCH_TABS);
		IConfigurationElement[] elements = epoint.getConfigurationElements();
		LaunchConfigurationTabExtension tab = null;
		Hashtable element = null;
		for(int i = 0; i < elements.length; i++) {
			tab = new LaunchConfigurationTabExtension(elements[i]);
			element = (Hashtable) fContributedTabs.get(tab.getTabGroupId());
			if(element == null) {
				element = new Hashtable();
				element.put(tab.getIdentifier(), tab);
				fContributedTabs.put(tab.getTabGroupId(), element);
			}
			element.put(tab.getIdentifier(), tab);
		}
	}
	
	/**
	 * Returns the tab group for the given launch configuration type and mode.
	 * 
	 * @param type launch configuration type
	 * @param mode launch mode
	 * @return the tab group for the given type of launch configuration, or <code>null</code> if none
	 * @exception CoreException if an exception occurs creating the group
	 */
	public ILaunchConfigurationTabGroup getTabGroup(ILaunchConfigurationType type, String mode) throws CoreException {

			 MessageFormat.format(LaunchConfigurationsMessages.LaunchConfigurationPresentationManager_No_tab_group_defined_for_launch_configuration_type__0__3, (new String[] {type.getIdentifier()})), null);  
			 throw new CoreException(status);
		} 
		return new LaunchConfigurationTabGroupWrapper(ext.newTabGroup(), ext.getIdentifier());		
	}
	
	/**
	 * Returns the listing of <code>ILaunchConfigurationTab</code>s for the specified <code>ILaunchConfigurationTabGroup</code>.
	 * If no tabs are found for the specified id an empty array is returned, never <code>null</code>
	 * @param groupid
	 * @return the <code>ILaunchConfigurationTab</code>s for the specified <code>ILaunchConfigurationTabGroup</code> id,
	 * or an empty array if none are found
	 * 
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 * @since 3.3
	 */
	public ILaunchConfigurationTab[] createContributedTabs(String groupid) {
		Hashtable tabs = (Hashtable) fContributedTabs.get(groupid);
		ArrayList list = new ArrayList();
		if(tabs != null) {
			LaunchConfigurationTabExtension ext = null;
			for(Iterator iter = tabs.keySet().iterator(); iter.hasNext();) {
				ext = (LaunchConfigurationTabExtension) tabs.get(iter.next());
				if(ext != null) {
					list.add(ext.getTab());
				}
			}
		}
		return (ILaunchConfigurationTab[]) list.toArray(new ILaunchConfigurationTab[list.size()]);
	}
	
	/**

	 */
	public String getDescription(ILaunchConfigurationType configType, String mode) {
		LaunchConfigurationPresentationManager manager = LaunchConfigurationPresentationManager.getDefault();
		LaunchConfigurationTabGroupExtension extension = manager.getExtension(configType.getAttribute(ConfigurationElementConstants.ID), mode);
		return (extension != null ? extension.getDescription(mode) : null);
	}	
	




    }
    
    /**
     * Returns an image descriptor for the icon referenced by the given path
     * and contributor name, or <code>null</code> if none.
     * 
     * @param name the name of the contributor
     * @param path the path of the icon (from the configuration element)
     * @return image descriptor or <code>null</code>
     * @since 3.3
     */
    public static ImageDescriptor getImageDescriptor(String name, String path) {
		Bundle bundle = Platform.getBundle(name);
		if (path != null) {
			URL iconURL = FileLocator.find(bundle , new Path(path), null);
			if (iconURL != null) {
				return ImageDescriptor.createFromURL(iconURL);
			}
		}    	
		return null;
    }
    
    /**
	 * Performs extra filtering for launch configurations based on the prefs set on the 
	 * Launch Configurations page
	 * @param config the config to filter

Lines 14-25 Link Here

(-)ui/org/eclipse/debug/internal/ui/DebugPluginImages.java (-13 / +35 lines)
14		14
15		15
16	import java.net.URL;	16	import java.net.URL;
		17	import java.util.HashSet;
		18	import java.util.Set;
17		19
18	import org.eclipse.core.runtime.FileLocator;	20	import org.eclipse.core.runtime.FileLocator;
19	import org.eclipse.core.runtime.IConfigurationElement;	21	import org.eclipse.core.runtime.IConfigurationElement;
20	import org.eclipse.core.runtime.IExtensionPoint;	22	import org.eclipse.core.runtime.IExtensionPoint;
21	import org.eclipse.core.runtime.Path;	23	import org.eclipse.core.runtime.Path;
22	import org.eclipse.core.runtime.Platform;	24	import org.eclipse.core.runtime.Platform;
		25	import org.eclipse.debug.core.DebugPlugin;
		26	import org.eclipse.debug.core.ILaunchConfigurationType;
		27	import org.eclipse.debug.internal.core.ConfigurationElementConstants;
23	import org.eclipse.debug.ui.IDebugUIConstants;	28	import org.eclipse.debug.ui.IDebugUIConstants;
24	import org.eclipse.jface.resource.ImageDescriptor;	29	import org.eclipse.jface.resource.ImageDescriptor;
25	import org.eclipse.jface.resource.ImageRegistry;	30	import org.eclipse.jface.resource.ImageRegistry;
Lines 230-249 Link Here
230	declareRegistryImage(IInternalDebugUIConstants.IMG_EDIT_SRC_DIR_WIZ, WIZBAN + "editdir_wiz.png"); //$NON-NLS-1$	235	declareRegistryImage(IInternalDebugUIConstants.IMG_EDIT_SRC_DIR_WIZ, WIZBAN + "editdir_wiz.png"); //$NON-NLS-1$
231		236
232	// launch configuration types	237	// launch configuration types
233	IExtensionPoint extensionPoint= Platform.getExtensionRegistry().getExtensionPoint(DebugUIPlugin.getUniqueIdentifier(), IDebugUIConstants.EXTENSION_POINT_LAUNCH_CONFIGURATION_TYPE_IMAGES);	238	//try to get the images from the config types themselves, cache those that could not be found
234	IConfigurationElement[] configElements= extensionPoint.getConfigurationElements();	239	ILaunchConfigurationType[] types = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurationTypes();
235	for (int i = 0; i < configElements.length; i++) {	240	String path = null;
236	IConfigurationElement configElement = configElements[i];	241	Set missing = new HashSet();
237	ImageDescriptor descriptor = DebugUIPlugin.getImageDescriptor(configElement, ATTR_LAUNCH_CONFIG_TYPE_ICON);	242	ImageDescriptor descriptor = null;
238	if (descriptor == null) {	243	for (int i = 0; i < types.length; i++) {
239	descriptor = ImageDescriptor.getMissingImageDescriptor();	244	path = types[i].getImageDescriptorPath();
		245	if(path == null) {
		246	missing.add(types[i].getIdentifier());
		247	}
		248	else {
		249	descriptor = DebugUIPlugin.getImageDescriptor(types[i].getContributorName(), path);
		250	imageRegistry.put(types[i].getIdentifier(), (descriptor == null ? ImageDescriptor.getMissingImageDescriptor() : descriptor));
		251	}
		252	}
		253	if(missing.size() > 0) {
		254	//if we are missing some images try to find them in the deprecated extension point
		255	IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(DebugUIPlugin.getUniqueIdentifier(), IDebugUIConstants.EXTENSION_POINT_LAUNCH_CONFIGURATION_TYPE_IMAGES);
		256	IConfigurationElement[] configElements = extensionPoint.getConfigurationElements();
		257	String configTypeID = null;
		258	for (int i = 0; i < configElements.length; i++) {
		259	configTypeID = configElements[i].getAttribute(ATTR_LAUNCH_CONFIG_TYPE_ID);
		260	if (configTypeID == null) {
		261	// bug 12652
		262	configTypeID = configElements[i].getAttribute(ConfigurationElementConstants.TYPE);
		263	}
		264	if(missing.contains(configTypeID)) {
		265	descriptor = DebugUIPlugin.getImageDescriptor(configElements[i], ATTR_LAUNCH_CONFIG_TYPE_ICON);
		266	imageRegistry.put(configTypeID, (descriptor == null ? ImageDescriptor.getMissingImageDescriptor() : descriptor));
		267	}
240	}	268	}
241	String configTypeID = configElement.getAttribute(ATTR_LAUNCH_CONFIG_TYPE_ID);
242	if (configTypeID == null) {
243	// bug 12652
244	configTypeID = configElement.getAttribute("type"); //$NON-NLS-1$
245	}
246	imageRegistry.put(configTypeID, descriptor);
247	}	269	}
248	}	270	}
249		271




/**
 * A toggle breakpoint action that can be contributed to an object. The action
 * will perform a toggle breakpoint operation for a selected object.
 * 
 * <p>Clients may subclass this class.</p>
 * 
 * <p>
 * Clients may subclass this class.
 * </p>
 * @since 3.0
 */
public abstract class ToggleBreakpointObjectActionDelegate implements IObjectActionDelegate, IActionDelegate2 {




	public static final String EXTENSION_POINT_LAUNCH_CONFIGURATION_TAB_GROUPS= "launchConfigurationTabGroups";	 //$NON-NLS-1$	

	/**
	 * Contributed Launch Configuration Tab extension point indentifier
	 * 
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This constant has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 * 
	 * @since 3.3
	 */
	public static final String EXTENSION_POINT_CONTRIBUTED_LAUNCH_TABS = "launchConfigurationTabs"; //$NON-NLS-1$
	
	/**
	 * Launch shortcuts extension point identifier
	 * (value <code>"launchShortcuts"</code>).
	 * 




<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.debug.ui">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.debug.ui" id="launchConfigurationTypeImages" name="Launch Configuration Type Images"/>
      </appInfo>
      <documentation>
         This extension point provides a way to associate an image with a launch configuration type.

&lt;p&gt;
&lt;strong&gt;EXPERIMENTAL&lt;/strong&gt;. This extension point has been deprecated as
part of a work in progress. There is no guarantee that this API will
remain unchanged during the 3.3 release cycle. Please do not use this API
without consulting with the Platform/Debug team.
&lt;/p&gt;
      </documentation>
   </annotation>

   <element name="extension">
      <annotation>
         <appInfo>
            <meta.element deprecated="true"/>
         </appInfo>
         <documentation>
            &lt;p&gt;In 3.3, the image for a launch configuration type should be provided via the icon attribute in the &lt;code&gt;launchConfigurationTypes&lt;/code&gt; extension point.&lt;/p&gt;
         </documentation>
      </annotation>
      <complexType>
         <sequence>
            <element ref="launchConfigurationTypeImage" minOccurs="0" maxOccurs="unbounded"/>

               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  an optional identifier of the extension instance
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                 an optional name of the extension instance
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="launchConfigurationTypeImage">
      <annotation>
         <documentation>
            &lt;p&gt;In 3.3, if possible, the image for a launch configuration type should be moved to the launch configuration type extension contribution&lt;/p&gt;
         </documentation>
      </annotation>
      <complexType>
         <attribute name="id" type="string" use="required">
            <annotation>

         <attribute name="configTypeID" type="string" use="required">
            <annotation>
               <documentation>
                  specifies the fully qualified ID of a launch configuration type.(in 2.1, this attribute can also be specified using the &quot;type&quot; attribute, to be consistent with the launchConfigurationTabGroups extension point).
               </documentation>
            </annotation>
         </attribute>

            <annotation>
               <documentation>
                  specifies the plugin-relative path of an image file.

&lt;br&gt;&lt;b&gt;To supply an image to the specified launch configuration type, it should be done in the launch configuration type definition.&lt;/b&gt;
               </documentation>
               <appInfo>
                  <meta.attribute kind="resource"/>


&lt;p&gt;
&lt;pre&gt;
 &lt;extension point=&quot;org.eclipse.debug.ui.launchConfigurationTypeImages&quot;&gt;
  &lt;launchConfigurationTypeImage
     id=&quot;com.example.FirstLaunchConfigurationTypeImage&quot;
     configTypeID=&quot;com.example.FirstLaunchConfigurationType&quot;
     icon=&quot;icons/FirstLaunchConfigurationType.gif&quot;&gt;
  &lt;/launchConfigurationTypeImage&gt;
 &lt;/extension&gt;
&lt;/pre&gt;
&lt;/p&gt;
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="copyright"/>
      </appInfo>
      <documentation>
         Copyright (c) 2000, 2005 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 




/*******************************************************************************
 * Copyright (c) 2006 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.debug.internal.ui;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.debug.internal.core.ConfigurationElementConstants;
import org.eclipse.debug.ui.ILaunchConfigurationTabExtension;
import org.eclipse.debug.ui.ILaunchConfigurationTab;

/**
 * Provides a proxy to a launchConfigurationTabs extension point
 * 
 * <p>
 * <strong>EXPERIMENTAL</strong>. This method has been added as
 * part of a work in progress. There is no guarantee that this API will
 * remain unchanged during the 3.3 release cycle. Please do not use this API
 * without consulting with the Platform/Debug team.
 * </p>
 * @since 3.3
 */
public class LaunchConfigurationTabExtension implements ILaunchConfigurationTabExtension {

	/**
	 * The configuration element backing this proxy
	 */
	IConfigurationElement fElement = null;
	
	/**
	 * Constructor
	 * @param element the <code>IConfigurationElement</code> for this proxy
	 */
	public LaunchConfigurationTabExtension(IConfigurationElement element) {
		fElement = element;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.ui.IContributedLaunchConfigurationTab#getIdentifier()
	 */
	public String getIdentifier() {
		return fElement.getAttribute(ConfigurationElementConstants.ID);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.ui.IContributedLaunchConfigurationTab#getName()
	 */
	public String getName() {
		return fElement.getAttribute(ConfigurationElementConstants.NAME);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.ui.IContributedLaunchConfigurationTab#getTab()
	 */
	public ILaunchConfigurationTab getTab() {
		try {
			Object object = fElement.createExecutableExtension(ConfigurationElementConstants.CLASS);
			if(object instanceof ILaunchConfigurationTab) {
				return (ILaunchConfigurationTab) object;
			}
		} catch (CoreException e) {DebugUIPlugin.log(e);}
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.ui.IContributedLaunchConfigurationTab#getTabGroupId()
	 */
	public String getTabGroupId() {
		return fElement.getAttribute(ConfigurationElementConstants.GROUP);
	}

}




package org.eclipse.debug.internal.ui.launchConfigurations;

import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.ui.ILaunchConfigurationDialog;
import org.eclipse.debug.ui.ILaunchConfigurationTab;
import org.eclipse.debug.ui.ILaunchConfigurationTabGroup;

/**
 * This class is used to wrap a contributed <code>ILaunchConfigurationTabGroup</code> with any contributed tabs
 * for that group (from a <code>launchConfigurationTabs</code> extension point).
 * 
 * <p>
 * <strong>EXPERIMENTAL</strong>. This class has been added as
 * part of a work in progress. There is no guarantee that this API will
 * remain unchanged during the 3.3 release cycle. Please do not use this API
 * without consulting with the Platform/Debug team.
 * </p>
 * @since 3.3
 */
public class LaunchConfigurationTabGroupWrapper implements ILaunchConfigurationTabGroup {
	
	private ILaunchConfigurationTabGroup fGroup = null;
	private String fGroupId = null;
	private ILaunchConfigurationTab[] fContributedTabs = null;
	
	/**
	 * Constructor
	 * @param group the existing group to wrapper
	 */
	public LaunchConfigurationTabGroupWrapper(ILaunchConfigurationTabGroup group, String groupId) {
		fGroup = group;
		fGroupId = groupId;
	}
	
	/**
	 * @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#createTabs(org.eclipse.debug.ui.ILaunchConfigurationDialog, java.lang.String)
	 */
	public void createTabs(ILaunchConfigurationDialog dialog, String mode) {
		if(fGroup != null) {
			fGroup.createTabs(dialog, mode);
		}
	}

	/**
	 * @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#dispose()
	 */
	public void dispose() {
		if(fGroup != null) {
			fGroup.dispose();
		}
		if(fContributedTabs != null) {
			for(int i = 0; i < fContributedTabs.length; i++) {
				fContributedTabs[i].dispose();
			}
		}
	}

	/**
	 * @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#getTabs()
	 */
	public ILaunchConfigurationTab[] getTabs() {
		if(fContributedTabs == null) {
			fContributedTabs = LaunchConfigurationPresentationManager.getDefault().createContributedTabs(fGroupId);
		}
		ILaunchConfigurationTab[] grouptabs = fGroup.getTabs();
		ILaunchConfigurationTab[] tabs = new ILaunchConfigurationTab[grouptabs.length + fContributedTabs.length];
		System.arraycopy(grouptabs, 0, tabs, 0, grouptabs.length);
		System.arraycopy(fContributedTabs, 0, tabs, grouptabs.length, fContributedTabs.length);
		return tabs;
	}

	/**
	 * @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#initializeFrom(org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public void initializeFrom(ILaunchConfiguration configuration) {
		if(fGroup != null) {
			fGroup.initializeFrom(configuration);
		}
		if(fContributedTabs == null) {
			getTabs();
		}
		for(int i = 0; i < fContributedTabs.length; i++) {
			fContributedTabs[i].initializeFrom(configuration);
		}
	}

	/**
	 * @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#launched(org.eclipse.debug.core.ILaunch)
	 */
	public void launched(ILaunch launch) {
		if(fGroup != null) {
			fGroup.launched(launch);
		}
	}

	/**
	 * @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#performApply(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy)
	 */
	public void performApply(ILaunchConfigurationWorkingCopy configuration) {
		if(fGroup != null) {
			fGroup.performApply(configuration);
			if(fContributedTabs == null) {
				getTabs();
			}
			for(int i = 0; i < fContributedTabs.length; i++) {
				fContributedTabs[i].performApply(configuration);
			}
		}
	}

	/**
	 * @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#setDefaults(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy)
	 */
	public void setDefaults(ILaunchConfigurationWorkingCopy configuration) {
		if(fGroup != null) {
			fGroup.setDefaults(configuration);
			if(fContributedTabs == null) { 
				getTabs();
			}
			for(int i = 0; i < fContributedTabs.length; i++) {
				fContributedTabs[i].setDefaults(configuration);
			}
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2006 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.debug.ui;

/**
 * Describes a contributed launch configuration tab 
 * 
 * <p>
 * <strong>EXPERIMENTAL</strong>. This method has been added as
 * part of a work in progress. There is no guarantee that this API will
 * remain unchanged during the 3.3 release cycle. Please do not use this API
 * without consulting with the Platform/Debug team.
 * </p>
 * @since 3.3
 */
public interface ILaunchConfigurationTabExtension {
	
	/**
	 * Returns the human readable name for the tab, not to be confused with the name that appears on the tab itself
	 * @return the name of the tab
	 */
	public String getName();
	
	/**
	 * Returns the unique id ofthe tab
	 * @return the unique id of the tab
	 */
	public String getIdentifier();
	
	/**
	 * Returns the unique id of the <code>ILaunchConfigurationTabGroup</code> that this tab contributes to
	 * @return the id of the <code>ILaunchConfigurationTabGroup</code> this tab conributes to
	 */
	public String getTabGroupId();
	
	/**
	 * Returns the instantiated class of this tab
	 * @return the instantiated class of this tab
	 */
	public ILaunchConfigurationTab getTab();

}




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.debug.ui">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.debug.ui" id="launchConfigurationTabs" name="Launch Configuration Tabs"/>
      </appInfo>
      <documentation>
         This extension point is used to allow developers to contribute launch configuration tabs (one or more) to an existing launch configuration tab group.


&lt;p&gt;&lt;strong&gt;EXPERIMENTAL&lt;/strong&gt;. This method has been added as
part of a work in progress. There is no guarantee that this API will
remain unchanged during the 3.3 release cycle. Please do not use this API
without consulting with the Platform/Debug team.&lt;/p&gt;
      </documentation>
   </annotation>

   <element name="extension">
      <complexType>
         <sequence minOccurs="1" maxOccurs="unbounded">
            <element ref="tab"/>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="tab">
      <annotation>
         <documentation>
            describes an individual launch configuration tab contribution
         </documentation>
      </annotation>
      <complexType>
         <attribute name="id" type="string" use="required">
            <annotation>
               <documentation>
                  the unique id of this contributed tab
               </documentation>
            </annotation>
         </attribute>
         <attribute name="group" type="string" use="required">
            <annotation>
               <documentation>
                  the string id of the &lt;code&gt;ILaunchConfigurationTabGroup&lt;/code&gt; that this tab should be contributed to
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string" use="required">
            <annotation>
               <documentation>
                  a human readable name for this tab. the prvided name does not have to be the name that you wish to appear on the tab itself. But it should sufficiently describe your tab.
               </documentation>
            </annotation>
         </attribute>
         <attribute name="class" type="string" use="required">
            <annotation>
               <documentation>
                  the implementation of your tab
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn="org.eclipse.debug.ui.ILaunchConfigurationTab"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

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

   <annotation>
      <appInfo>
         <meta.section type="examples"/>
      </appInfo>
      <documentation>
         The following example adds the tab &quot;FooTab&quot; to the local java application launch tab group.

&lt;p&gt;
&lt;pre&gt;
&lt;extension point=&quot;org.eclipse.debug.ui.launchConfigurationTabs&quot;&gt;
    &lt;tab
      	class=&quot;org.eclipse.jdt.debug.ui.launchConfigurations.FooTab&quot;
        group=&quot;org.eclipse.jdt.debug.ui.launchConfigurationTabGroup.localJavaApplication&quot;
        id=&quot;org.eclipse.jdt.debug.ui.fooTab&quot;
        name=&quot;Foo Tab&quot;&gt;
    &lt;/tab&gt;
 &lt;/extension&gt;	
&lt;/pre&gt;
&lt;/p&gt;
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="apiInfo"/>
      </appInfo>
      <documentation>
         [Enter API information here.]
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="implementation"/>
      </appInfo>
      <documentation>
         [Enter information about supplied implementation of this extension point.]
      </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>




import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;
import org.eclipse.debug.core.model.IPersistableSourceLocator;
import org.eclipse.debug.core.model.IProcess;
import org.eclipse.debug.core.sourcelookup.ISourceContainerType;

	 * @param optionId the unique id of the launch option
	 * @return the lauch option associated with ther specified id or <code>null</code> if not found
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.

	 * Returns all registered launch options
	 * @return all registered launch options
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.

	public ILaunchOption[] getLaunchOptions();
	
	/**
	 * Returns all of the launch delegates. The rturned listing of delegates cannot be directly used to launch,
	 * instead the method <code>IlaunchDelegate.getDelegate</code> must be used to acquire an executable form of
	 * the delegate, allowing us to maintain lazy loading of the delegates themselves.
	 * @return all of the launch delegates
	 * @since 3.3
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 */
	public ILaunchDelegate[] getLaunchDelegates();
	
	/** Returns the launch delegate that applies to the specified options
	 * @param typeid the <code>ILaunchConfigurationType</code> id
	 * @param the mode id
	 * @param options the array of options to find the delegate for
	 * @return the delegates that applie to the specified launch options for the specified mode and type id
	 * 
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 * @since 3.3
	 */
	public ILaunchConfigurationDelegate[] getLaunchDelegates(String typeid, String mode, String[] options);
	
	/**
	 * Returns a collection of launch configurations that required migration to be
	 * compatible with current tooling.
	 * 




	public String getName();		
	
	/**
	 * 
	 * @return returns the options that this configuration supports
	 * 
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 * @since 3.3
	 */
	public String[] getOptions() throws CoreException;
	
	/**
	 * Returns the type of this launch configuration. This is a
	 * handle-only method.
	 * 




	 * @exception CoreException if unable to instantiate the
	 *  delegate
	 * @since 3.0
	 * @deprecated we have introduced launch options in 3.3M3 and delegates can be acquired using the new 
	 * <code>getDelegate(String mode, String[] options)</code> version. If no options are desired or cared about passing <code>null</code>
	 * works as though options are not considered at all. 
	 * 
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 */	
	public ILaunchConfigurationDelegate getDelegate(String mode) throws CoreException;
	
	/**
	 * Returns the launch delegate for the specifed mode with the given options
	 * @param mode the mode to get the delegate for
	 * @param options the options that the delegate must support
	 * @return the <code>ILaunchConfigurationDelegate</code> for the given mode and options, or <code>null</code> if the is not one
	 * @throws CoreException
	 * @since 3.3
	 * 
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 */
	public ILaunchConfigurationDelegate getDelegate(String mode, String[] options) throws CoreException;
	
	/**
	 * Returns the unique identifier for this type of launch configuration
	 * 
	 * @return the unique identifier for this type of launch configuration

	 *  <code>DEBUG_MODE</code>.
	 * @return whether this kind of launch configuration supports the
	 *  specified mode
	 *  
	 */
	public boolean supportsMode(String mode);
	
	/**
	 * Returns the simple name of the plugin that contributed this launch configuration type
	 * @return the name of the contributor
	 * @since 3.3
	 * 
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 */
	public String getContributorName();
	
	/**
	 * Returns the path of the image descriptor for this launch configuration type, which in turn 
	 * is used in <code>DebugPluginImages</code> to load the image registry with config images.
	 * NOTE: the path could be only a fragment, and might require qualification via the bundle of the contributor.
	 * @return the id of the image for this config type
	 * @since 3.3
	 * 
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 */
	public String getImageDescriptorPath();
}




	 * @since 3.2
	 */
	public void setMappedResources(IResource[] resources);
	
	/**
	 * This method is used to set the options for the associated <code>ILaunchConfiguraiton</code>.
	 * @param options the array of options to set
	 * 
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 * @since 3.3
	 */
	public void setOptions(String[] options);
}




package org.eclipse.debug.internal.core;

 
import com.ibm.icu.text.MessageFormat;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.debug.core.ILaunchConfigurationMigrationDelegate;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchDelegate;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;
import org.eclipse.debug.core.sourcelookup.ISourcePathComputer;

import com.ibm.icu.text.MessageFormat;

/**
 * A launch configuration type wrappers a configuration
 * element for a <code>launchConfigurationType</code>

 */
public class LaunchConfigurationType extends PlatformObject implements ILaunchConfigurationType {
	
	private static String MIGRATION_DELEGATE = "migrationDelegate";  //$NON-NLS-1$
	
	/**
	 * The configuration element of the extension.
	 */
	private IConfigurationElement fElement;
	
	/**
	 *  a listing of modes contributed to this launch configuration type
	 *  @since 3.3
	 *  
	 *  <p>
	 * <strong>EXPERIMENTAL</strong>. This field has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 */
	private Set fModes = null;
	
	/**
	 * the default source path computer for this config type
	 * @since 3.3
	 * 
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This field has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 */
	private ISourcePathComputer fSourcePathComputer = null;
	
	/**
	 * The source locator id for this config type
	 */
	private String fSourceLocator = null;
	
	/**
	 * The delegates for launch configurations of this type.
	 * Delegates are instantiated lazily as required. There may
	 * be different delegates for different modes (since 3.0).
	 * Map of mode to delegate
	 */
	private Map fDelegates;
	

	 * @param element configuration element
	 */
	protected LaunchConfigurationType(IConfigurationElement element) {
		fElement = element;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getAttribute(java.lang.String)
	 */
	public String getAttribute(String attributeName) {
		return fElement.getAttribute(attributeName);
	}
	
	/**
	 * Returns the set of modes specified in the configuration data.
	 * 
	 * @return the set of modes specified in the configuration data
	 */
	protected Set getBaseModes() {
		if (fBaseModes == null) {
			String modes= getConfigurationElement().getAttribute("modes"); //$NON-NLS-1$
			if (modes == null) {
				return new HashSet(0);
			}
			StringTokenizer tokenizer= new StringTokenizer(modes, ","); //$NON-NLS-1$
			fBaseModes = new HashSet(tokenizer.countTokens());
			while (tokenizer.hasMoreTokens()) {
				fBaseModes.add(tokenizer.nextToken().trim());
			}
		}
		return fBaseModes;
	}	

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getCategory()
	 */
	public String getCategory() {
		return fElement.getAttribute(ConfigurationElementConstants.CATEGORY);
	}

	/**
	 * Returns this type's configuration element.
	 * 
	 * @return this type's configuration element
	 */
	protected IConfigurationElement getConfigurationElement() {
		return fElement;
	}
	
	/**
	 * Returns the set of modes delegates have been contributed for
	 * 
	 * @return the set of modes delegates have been contributed for
	 */
	protected Set getContributedModes() {
		if (fContributedModes == null) {
			fContributedModes = new HashSet(0);
			// add modes for contributed delegates
			List delegates = ((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).getContributedDelegates();
			Iterator iterator = delegates.iterator();
			while (iterator.hasNext()) {
				ContributedDelegate delegate = (ContributedDelegate)iterator.next();
				if (delegate.getLaunchConfigurationType().equals(getIdentifier())) {
					fContributedModes.addAll(delegate.getModes());
				}
			}
		}
		return fContributedModes;
	}
	
	/**
	 * Returns the launch configuration delegate for launch
	 * configurations of this type. The first time this method
	 * is called, the delegate is instantiated.
	 * 
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getDelegate()
	 * @return launch configuration delegate
	 * @exception CoreException if unable to instantiate the
	 *  delegate
	 * @deprecated use <code>getDelegate(String)</code> to specify mode
	 */
	public ILaunchConfigurationDelegate getDelegate() throws CoreException {
		return getDelegate(ILaunchManager.RUN_MODE);

	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getDelegate(java.lang.String)
	 */
	public ILaunchConfigurationDelegate getDelegate(String mode) throws CoreException {
		return getDelegate(mode, null); 
	}
	
	/**
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getDelegate(java.lang.String, java.lang.String[])
	 */
	public ILaunchConfigurationDelegate getDelegate(String mode, String[] options) throws CoreException {
		if (!supportsMode(mode)) {
			throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, MessageFormat.format(DebugCoreMessages.LaunchConfigurationType_9, new String[] {mode, getIdentifier()}), null));  
		}
		if (fDelegates == null) {
			// initialize delegate table with base modes
			fDelegates = new Hashtable();
		}
		ILaunchConfigurationDelegate delegate = (ILaunchConfigurationDelegate)fDelegates.get(mode);
		if (delegate == null) {
			if(fModes.contains(mode)) {
				ILaunchConfigurationDelegate[] delegates = DebugPlugin.getDefault().getLaunchManager().getLaunchDelegates(getIdentifier(), mode, options);
				if(delegates.length > 0) {
					return delegates[0];
					Iterator iter = modes.iterator();
					while (iter.hasNext()) {
						fDelegates.put(iter.next(), object);
					}
					return (ILaunchConfigurationDelegate)object;
				} 
				throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, MessageFormat.format(DebugCoreMessages.LaunchConfigurationType_Launch_delegate_for__0__does_not_implement_required_interface_ILaunchConfigurationDelegate__1, new String[]{getName()}), null)); 
			} 
			// contributed modes
			List contributed = ((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).getContributedDelegates();
			Iterator iterator = contributed.iterator();
			while (iterator.hasNext()) {
				ContributedDelegate contributedDelegate = (ContributedDelegate)iterator.next();
				if (getIdentifier().equals(contributedDelegate.getLaunchConfigurationType())) {
					modes = contributedDelegate.getModes();
					if (modes.contains(mode)) {
						delegate = contributedDelegate.getDelegate();
						Iterator modesIterator = modes.iterator();
						while (modesIterator.hasNext()) {
							fDelegates.put(modesIterator.next(), delegate); 
						}
						return delegate;
					}
				}
			}
		} 
		else {
			return delegate;
		}
		throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, MessageFormat.format(DebugCoreMessages.LaunchConfigurationType_10, new String[] {getIdentifier(), mode}), null));
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getIdentifier()
	 */
	public String getIdentifier() {
		return fElement.getAttribute(ConfigurationElementConstants.ID);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getName()
	 */
	public String getName() {
		return fElement.getAttribute(ConfigurationElementConstants.NAME);
	}

	/* (non-Javadoc)

	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getSourceLocatorId()
	 */
	public String getSourceLocatorId() {
		if(fSourceLocator == null) {
			//try the type itself
			fSourceLocator = getAttribute(ConfigurationElementConstants.SOURCE_LOCATOR);
			if(fSourceLocator == null) {
				//try from launch manager
				ILaunchDelegate[] delegates = ((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).getLaunchDelegates();
				for(int i = 0; i < delegates.length; i++) {
					if(delegates[i].appliesTo(getIdentifier())) {
						fSourceLocator = delegates[i].getSourceLocatorId();
						if(fSourceLocator != null) {
							return fSourceLocator;
						}
					}
				}
			}
		}
		return fSourceLocator;
	}	

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getSourcePathComputer()
	 */
	public ISourcePathComputer getSourcePathComputer() {
		if(fSourcePathComputer == null) {
			//get the id
			String id = fElement.getAttribute(ConfigurationElementConstants.SOURCE_PATH_COMPUTER);
			LaunchManager lmgr = (LaunchManager)DebugPlugin.getDefault().getLaunchManager();
			if(id == null) {
				//try from the launch manager
				ILaunchDelegate[] delegates = lmgr.getLaunchDelegates();
				for(int i = 0; i < delegates.length; i++) {
					if(delegates[i].appliesTo(getIdentifier())) {
						id = delegates[i].getSourcePathComputerId();
						if(id != null) {
							break;
						}
					}
				}
			}
			if(id != null) {
				fSourcePathComputer = lmgr.getSourcePathComputer(id);
			}
		}
		return fSourcePathComputer;
			return DebugPlugin.getDefault().getLaunchManager().getSourcePathComputer(id);
		}
		return null;
	}

	/**
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getSupportedModes()
	 */
	public Set getSupportedModes() {
		if(fModes == null) {
			fModes = new HashSet();
			ILaunchDelegate[] delegates = DebugPlugin.getDefault().getLaunchManager().getLaunchDelegates();
			for(int i= 0; i < delegates.length; i++) {
				if(delegates[i].appliesTo(getIdentifier())) {
					fModes.addAll(delegates[i].getModes());
				}
			}
		}
		return fModes;
	}

	/**

	 * @since 3.2
	 */
	public boolean isMigrationCandidate(ILaunchConfiguration candidate) throws CoreException {
		if(getAttribute(ConfigurationElementConstants.MIGRATION_DELEGATE) != null) {
			if(fDelegates == null) {
				fDelegates = new Hashtable();
			}
			Object delegate = fDelegates.get(ConfigurationElementConstants.MIGRATION_DELEGATE);
			if(delegate == null) {
				delegate = fElement.createExecutableExtension(ConfigurationElementConstants.MIGRATION_DELEGATE);
				fDelegates.put(ConfigurationElementConstants.MIGRATION_DELEGATE, delegate);
			}
			if(delegate instanceof ILaunchConfigurationMigrationDelegate) {
				return ((ILaunchConfigurationMigrationDelegate)delegate).isCandidate(candidate);

	 * @see org.eclipse.debug.core.ILaunchConfigurationType#isPublic()
	 */
	public boolean isPublic() {
		String publicString = fElement.getAttribute(ConfigurationElementConstants.PUBLIC);
		if (publicString != null) {
			if (publicString.equalsIgnoreCase("false")) { //$NON-NLS-1$
				return false;

	 * @since 3.2
	 */
	public void migrate(ILaunchConfiguration candidate) throws CoreException {
		if(getAttribute(ConfigurationElementConstants.MIGRATION_DELEGATE) != null) { 
			if(fDelegates == null) {
				fDelegates = new Hashtable();
			}
			Object delegate = fDelegates.get(ConfigurationElementConstants.MIGRATION_DELEGATE);
			if(delegate == null) {
				delegate = fElement.createExecutableExtension(ConfigurationElementConstants.MIGRATION_DELEGATE);
				fDelegates.put(ConfigurationElementConstants.MIGRATION_DELEGATE, delegate);
			}
			if(delegate instanceof ILaunchConfigurationMigrationDelegate) {
				((ILaunchConfigurationMigrationDelegate)delegate).migrate(candidate);

	 * @see org.eclipse.debug.core.ILaunchConfigurationType#newInstance(org.eclipse.core.resources.IContainer, java.lang.String)
	 */
	public ILaunchConfigurationWorkingCopy newInstance(IContainer container, String name) {
		return new LaunchConfigurationWorkingCopy(container, name, this);
	}

	/**
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#supportsMode(java.lang.String)
	 * 
	 * @param element this type's configuration element
	 */
	public boolean supportsMode(String mode) {
		return getSupportedModes().contains(mode);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getContributorName()
	 */
	public String getContributorName() {
		return fElement.getContributor().getName();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getImageDescriptorId()
	 */
	public String getImageDescriptorPath() {
		return fElement.getAttribute(ConfigurationElementConstants.ICON);
	}
}





import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationListener;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchDelegate;
import org.eclipse.debug.core.ILaunchListener;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.core.ILaunchMode;

import org.eclipse.debug.core.IStatusHandler;
import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.debug.core.model.IDisconnect;
import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;
import org.eclipse.debug.core.model.IPersistableSourceLocator;
import org.eclipse.debug.core.model.IProcess;
import org.eclipse.debug.core.sourcelookup.AbstractSourceLookupDirector;

	 * @throws IOException if the encoding attempted to be used is not supported
	 */
	public static String serializeDocument(Document doc) throws TransformerException, IOException {
		ByteArrayOutputStream s = new ByteArrayOutputStream();
		TransformerFactory factory = TransformerFactory.newInstance();
		Transformer transformer = factory.newTransformer();
		Transformer transformer= factory.newTransformer();
		transformer.setOutputProperty(OutputKeys.METHOD, "xml"); //$NON-NLS-1$
		transformer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$
		DOMSource source = new DOMSource(doc);
		StreamResult outputTarget = new StreamResult(s);
		StreamResult outputTarget= new StreamResult(s);
		transformer.transform(source, outputTarget);
		
		return s.toString("UTF8"); //$NON-NLS-1$			
	}
	

	private HashMap fLaunchOptions = null;
	
	/**
	 * A map of ILaunchDelegate objects stored by id of delegate, or launch config type
	 * launch configuration types).
	 */
	private HashMap fLaunchDelegates = null;

	/**
	 * Collection of launches

		}
		Iterator iter = list.iterator();
		List configs = new ArrayList(list.size());
		IFile file = null;
		while (iter.hasNext()) {
			file = (IFile)iter.next();
			configs.add(getLaunchConfiguration(file));
		}
		return configs;

				}
			};
			String[] files = directory.list(filter);
			LaunchConfiguration config = null;
			for (int i = 0; i < files.length; i++) {
				config = new LaunchConfiguration(containerPath.append(files[i]));
				configs.add(config);
			}
		}

				try {
					index = Integer.parseInt(trailer);
					baseName = baseName.substring(0, copyIndex);
				} 
				catch (NumberFormatException nfe) {}
			}
		} 
		String newName = baseName;
		
		StringBuffer buffer = null;
		while (isExistingLaunchConfigurationName(newName)) {
			buffer = new StringBuffer(baseName);
			buffer.append(" ("); //$NON-NLS-1$

		List configs = new ArrayList(4);	
		NodeList list = root.getChildNodes();
		int length = list.getLength();
		Node node = null;
		Element entry = null;
		String memento = null;
		for (int i = 0; i < length; ++i) {
			node = list.item(i);
			short type = node.getNodeType();
			if (type == Node.ELEMENT_NODE) {
				entry = (Element) node;
				if (!entry.getNodeName().equals("launchConfiguration")) { //$NON-NLS-1$
				if (!nodeName.equals("launchConfiguration")) { //$NON-NLS-1$
					throw invalidFormat;
				}
				memento = entry.getAttribute("memento"); //$NON-NLS-1$
				if (memento == null) {
					throw invalidFormat;
				}

	
	protected ConfigurationNotifier getConfigurationNotifier() {
		return new ConfigurationNotifier();
	}			
	
	/**
	 * Returns a list of launch delegates contributed for existing launch configuration
	 * types.
	 * 
	 * @return list of ContributedDelegate
	 */
	protected List getContributedDelegates() {
		initializeContributedDelegates();
		return fContributedDelegates;
	}		
	
	/**
	 * @see ILaunchManager#getDebugTargets()

		synchronized (fLaunches) {
			List allTargets= new ArrayList(fLaunches.size());
			if (fLaunches.size() > 0) {
				Iterator e = fLaunches.iterator();
				IDebugTarget[] targets = null;
				while (e.hasNext()) {
					targets = ((ILaunch) e.next()).getDebugTargets();
					for (int i = 0; i < targets.length; i++) {
						allTargets.add(targets[i]);
					}

		if (configEnv == null) {
			return null;
		}
		Map env = new HashMap();
		// build base environment
		boolean append = configuration.getAttribute(ATTR_APPEND_ENVIRONMENT_VARIABLES, true);
		boolean append= configuration.getAttribute(ATTR_APPEND_ENVIRONMENT_VARIABLES, true);
		if (append) {
			env.putAll(getNativeEnvironmentCasePreserved());
		}

		// Add variables from config
		Iterator iter= configEnv.entrySet().iterator();
		boolean win32= Platform.getOS().equals(Constants.OS_WIN32);
		Map.Entry entry = null;
		String key = null;
		String value = null;
		Object nativeValue = null;
		Iterator envIter = null;
		Map.Entry nativeEntry = null;
		String nativeKey = null;
		while (iter.hasNext()) {
			entry = (Map.Entry) iter.next();
			key = (String) entry.getKey();
            value = (String) entry.getValue();
            // translate any string substitution variables
            if (value != null) {
                value = VariablesPlugin.getDefault().getStringVariableManager().performStringSubstitution(value);

            boolean added= false;
			if (win32) {
                // First, check if the key is an exact match for an existing key.
				nativeValue = env.get(key);
                if (nativeValue != null) {
                    // If an exact match is found, just replace the value
                    env.put(key, value);

                    // Win32 vars are case-insensitive. If an exact match isn't found, iterate to
                    // check for a case-insensitive match. We maintain the key's case (see bug 86725),
                    // but do a case-insensitive comparison (for example, "pAtH" will still override "PATH").
                    envIter = env.entrySet().iterator();
                    while (envIter.hasNext()) {
                        nativeEntry = (Map.Entry) envIter.next();
                        nativeKey = (String) (nativeEntry).getKey();
                        if (nativeKey.equalsIgnoreCase(key)) {
                            nativeEntry.setValue(value);
                            added = true;
                            break;
                        }
                    }

            }
		}		
		
		iter = env.entrySet().iterator();
		List strings = new ArrayList(env.size());
		StringBuffer buffer = null;
		while (iter.hasNext()) {
			entry = (Map.Entry) iter.next();
			buffer = new StringBuffer((String) entry.getKey());
			buffer.append('=').append((String) entry.getValue());
			strings.add(buffer.toString());
		}

	public ILaunchConfiguration[] getLaunchConfigurations(ILaunchConfigurationType type) throws CoreException {
		Iterator iter = getAllLaunchConfigurations().iterator();
		List configs = new ArrayList();
		ILaunchConfiguration config = null;
		while (iter.hasNext()) {
			config = (ILaunchConfiguration)iter.next();
			if (config.getType().equals(type)) {
				configs.add(config);
			}

		return (ILaunchConfiguration[])configs.toArray(new ILaunchConfiguration[configs.size()]);
	}
	
	
	/**
	 * Returns all launch configurations that are stored as resources
	 * in the given project.

	protected List getLaunchConfigurations(IProject project) {
		Iterator iter = getAllLaunchConfigurations().iterator();
		List configs = new ArrayList();
		ILaunchConfiguration config = null;
		IFile file = null;
		while (iter.hasNext()) {
			config = (ILaunchConfiguration)iter.next();
			file = config.getFile();
			if (file != null && file.getProject().equals(project)) {
				configs.add(config);
			}

		}
	}
	
	/**)
	 * @see org.eclipse.debug.core.ILaunchManager#getLaunchMode(java.lang.String)
	 * @deprecated launch modes are removed for 3.3M3 in favour of launching with options
	 */
	public ILaunchMode getLaunchMode(String mode) {
		initializeLaunchModes();
		return (ILaunchMode) fLaunchModes.get(mode);
	}
	
	/**
	 * @see org.eclipse.debug.core.ILaunchManager#getLaunchModes()
	 * @deprecated launch modes are removed for 3.3M3 in favour of launching with options
	 */
	public ILaunchMode[] getLaunchModes() {
		initializeLaunchModes();

		Collection col = fLaunchOptions.values();
		return (ILaunchOption[])col.toArray(new ILaunchOption[col.size()]);
	}
	
	/**
	 * Initializes the listing of registered launch options. Does no work if the mapping is already populated.
	 * 
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 * @since 3.3  
	 */
	private synchronized void initializeLaunchOptions() {
		if(fLaunchOptions == null) {
			try {
				IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(DebugPlugin.getUniqueIdentifier(), DebugPlugin.EXTENSION_POINT_LAUNCH_OPTIONS);
				IConfigurationElement[] infos = extensionPoint.getConfigurationElements();
				fLaunchOptions = new HashMap();
				ILaunchOption option = null;
				for(int i =  0; i < infos.length; i++) {
					option = new LaunchOption(infos[i]);
					fLaunchOptions.put(option.getIdentifier(), option);
				}
			}
			catch(CoreException ce) {DebugPlugin.log(ce);}
		}
	}
	
	/**
	 * @see org.eclipse.debug.core.ILaunchManager#getLaunchDelegates()
	 */
	public ILaunchDelegate[] getLaunchDelegates() {
		initializeLaunchDelegates();
		Collection col = fLaunchDelegates.values();
		return (ILaunchDelegate[]) col.toArray(new ILaunchDelegate[col.size()]);
	}
	
	/**
	 * @see org.eclipse.debug.core.ILaunchManager#getLaunchDelegate(java.lang.String, java.lang.String, java.lang.String[])
	 */
	public ILaunchConfigurationDelegate[] getLaunchDelegates(String typeid, String mode, String[] options) {
		try {
			initializeLaunchDelegates();
			ILaunchDelegate ld = null;
			boolean applies = true;
			ArrayList list = new ArrayList();
			Set doptions = null;
			for(Iterator iter = fLaunchDelegates.keySet().iterator(); iter.hasNext();) {
				ld = (ILaunchDelegate) fLaunchDelegates.get(iter.next());
				doptions = ld.getOptions();
				if(ld.appliesTo(typeid, mode)) {
					if(options != null) {
						if(doptions.size() > 0 & options.length == 0) {
							applies = false;
						}
						for(int i = 0; i < options.length; i++) {
							applies &= doptions.contains(options[i]);
						}
					}
					else if(doptions.size() > 0) {
						applies = false;
					}
					if(applies) {
						list.add(ld.getDelegate());
					}
					applies = true;
				}
			}
			return (ILaunchConfigurationDelegate[]) list.toArray(new ILaunchConfigurationDelegate[list.size()]);
		}
		catch(CoreException ce) {}
		return null;
	}
	
	/**
	 * Initializes the listing of delegates available to the launching framework
	 * 
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 * @since 3.3
	 */
	private synchronized void initializeLaunchDelegates() {
		if(fLaunchDelegates == null) {
			fLaunchDelegates = new HashMap();
			//get all launch delegate contributions
			IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(DebugPlugin.getUniqueIdentifier(), DebugPlugin.EXTENSION_POINT_LAUNCH_DELEGATES);
			IConfigurationElement[] infos = extensionPoint.getConfigurationElements();
			ILaunchDelegate delegate = null;
			for(int i = 0; i < infos.length; i++) {
				delegate = new LaunchDelegate(infos[i]);
				fLaunchDelegates.put(delegate.getIdentifier(), delegate);
			}
			//get all delegates from launch configuration type contributions
			extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(DebugPlugin.getUniqueIdentifier(), DebugPlugin.EXTENSION_POINT_LAUNCH_CONFIGURATION_TYPES);
			infos = extensionPoint.getConfigurationElements();
			for(int i = 0; i < infos.length; i++) {
				//must check to see if delegate is provided in contribution
				if(infos[i].getAttribute("delegate") != null) { //$NON-NLS-1$
					delegate = new LaunchDelegate(infos[i]);
					fLaunchDelegates.put(delegate.getIdentifier(), delegate);
				}
			}
		}
	}
	
	/**
	 * Returns all launch configurations that are stored locally.
	 * 

			if (Platform.getOS().equals(Constants.OS_WIN32)) {
				fgNativeEnv= new HashMap();
				Iterator entries = casePreserved.entrySet().iterator();
				Map.Entry entry = null;
				String key = null;
				while (entries.hasNext()) {
					entry = (Entry) entries.next();
					key = ((String)entry.getKey()).toUpperCase();
					fgNativeEnv.put(key, entry.getValue());
				}
			} else {

	 */
	public IProcess[] getProcesses() {
		synchronized (fLaunches) {
			List allProcesses = new ArrayList(fLaunches.size());
			Iterator e = fLaunches.iterator();
			IProcess[] processes = null;
			while (e.hasNext()) {
				processes = ((ILaunch) e.next()).getProcesses();
				for (int i= 0; i < processes.length; i++) {
					allProcesses.add(processes[i]);
				}

			IExtensionPoint extensionPoint= Platform.getExtensionRegistry().getExtensionPoint(DebugPlugin.getUniqueIdentifier(), DebugPlugin.EXTENSION_POINT_LAUNCH_CONFIGURATION_COMPARATORS);
			IConfigurationElement[] infos= extensionPoint.getConfigurationElements();
			fComparators = new HashMap(infos.length);
			IConfigurationElement configurationElement = null;
			String attr = null;
			for (int i= 0; i < infos.length; i++) {
				configurationElement = infos[i];
				attr = configurationElement.getAttribute("attribute"); //$NON-NLS-1$			
				if (attr != null) {
					fComparators.put(attr, new LaunchConfigurationComparator(configurationElement));
				} else {

			}
		}
	}

	/**
	 * Initializes the listing of <code>LaunchConfigurationType</code>s.
	 * to an existing launch configuration type).
	 */
	private synchronized void initializeContributedDelegates() {
		if (fContributedDelegates == null) {
			IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(DebugPlugin.getUniqueIdentifier(), DebugPlugin.EXTENSION_POINT_LAUNCH_DELEGATES);
			IConfigurationElement[] infos = extensionPoint.getConfigurationElements();
			fContributedDelegates = new ArrayList(infos.length);
			for (int i= 0; i < infos.length; i++) {		
				fContributedDelegates.add(new ContributedDelegate(infos[i]));
			}
		}
	}
	
	private synchronized void initializeLaunchConfigurationTypes() {
		if (fLaunchConfigurationTypes == null) {
			hookResourceChangeListener();
			IExtensionPoint extensionPoint= Platform.getExtensionRegistry().getExtensionPoint(DebugPlugin.getUniqueIdentifier(), DebugPlugin.EXTENSION_POINT_LAUNCH_CONFIGURATION_TYPES);
			IConfigurationElement[] infos = extensionPoint.getConfigurationElements();
			fLaunchConfigurationTypes = new ArrayList(infos.length);
			for (int i= 0; i < infos.length; i++) {		
				fLaunchConfigurationTypes.add(new LaunchConfigurationType(infos[i]));
				LaunchConfigurationType configType = new LaunchConfigurationType(configurationElement); 			
				fLaunchConfigurationTypes.add(configType);
			}
		}
	}

	 * 
	 * @exception CoreException if an exception occurs reading
	 *  the extensions
	 *  
	 */
	private synchronized void initializeLaunchModes() {
		if (fLaunchModes == null) {

			catch (CoreException e) {DebugPlugin.log(e);}
		}
	}

	/**
	 * Initializes the listing of registered launch options. Does no work if the mapping is already populated.
	 * @since 3.3  
	 */
	private synchronized void initializeLaunchOptions() {
		if(fLaunchOptions == null) {
			try {
				IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(DebugPlugin.getUniqueIdentifier(), DebugPlugin.EXTENSION_POINT_LAUNCH_OPTIONS);
				IConfigurationElement[] infos = extensionPoint.getConfigurationElements();
				fLaunchOptions = new HashMap();
				ILaunchOption option = null;
				for(int i =  0; i < infos.length; i++) {
					option = new LaunchOption(infos[i]);
					fLaunchOptions.put(option.getIdentifier(), option);
				}
			}
			catch(CoreException ce) {DebugPlugin.log(ce);}
		}
	}
	
	/**
	 * Initializes source container type and source path computer extensions.

			IExtensionPoint extensionPoint= Platform.getExtensionRegistry().getExtensionPoint(DebugPlugin.getUniqueIdentifier(), DebugPlugin.EXTENSION_POINT_SOURCE_LOCATORS);
			IConfigurationElement[] infos= extensionPoint.getConfigurationElements();
			fSourceLocators= new HashMap(infos.length);
			IConfigurationElement configurationElement = null;
			String id = null;
			for (int i= 0; i < infos.length; i++) {
				configurationElement = infos[i];
				id = configurationElement.getAttribute("id"); //$NON-NLS-1$			
				if (id != null) {
					fSourceLocators.put(id,configurationElement);
				} else {

		if (!configs.isEmpty()) {
			Iterator iterator = configs.iterator();
			while (iterator.hasNext()) {
				launchConfigurationDeleted((ILaunchConfiguration)iterator.next());
				launchConfigurationDeleted(configuration);
			}
		}
		//bug 12134

		if (!configs.isEmpty()) {
			Iterator iterator = configs.iterator();
			while (iterator.hasNext()) {
				launchConfigurationAdded((ILaunchConfiguration) iterator.next());
				launchConfigurationAdded(config);
			}			
		}
	}

        fLaunchesListeners = new ListenerList();
        fLaunchConfigurationListeners = new ListenerList();
		ILaunch[] launches = getLaunches();
		ILaunch launch = null;
		for (int i= 0; i < launches.length; i++) {
			launch = launches[i];
			try {
                if (launch instanceof IDisconnect) {
                    IDisconnect disconnect = (IDisconnect)launch;

	 */
	protected void verifyConfigurations(List verify, List valid) {
		Iterator configs = verify.iterator();
		ILaunchConfiguration config = null;
		while (configs.hasNext()) {
			config = (ILaunchConfiguration)configs.next();
			if (isValid(config)) {
				valid.add(config);
			}

Lines 13-19 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchConfiguration.java (-6 / +33 lines)
13		13
14	import java.io.IOException;	14	import java.io.IOException;
15	import java.io.StringReader;	15	import java.io.StringReader;
16	import com.ibm.icu.text.MessageFormat;
17	import java.util.ArrayList;	16	import java.util.ArrayList;
18	import java.util.List;	17	import java.util.List;
19	import java.util.Map;	18	import java.util.Map;
Lines 55-60 Link Here
55	import org.xml.sax.SAXException;	54	import org.xml.sax.SAXException;
56	import org.xml.sax.helpers.DefaultHandler;	55	import org.xml.sax.helpers.DefaultHandler;
57		56
		57	import com.ibm.icu.text.MessageFormat;
		58
58	/**	59	/**
59	* Launch configuration handle.	60	* Launch configuration handle.
60	*	61	*
Lines 82-87 Link Here
82	public static final String ATTR_MAPPED_RESOURCE_TYPES = DebugPlugin.getUniqueIdentifier() + ".MAPPED_RESOURCE_TYPES"; //$NON-NLS-1$	83	public static final String ATTR_MAPPED_RESOURCE_TYPES = DebugPlugin.getUniqueIdentifier() + ".MAPPED_RESOURCE_TYPES"; //$NON-NLS-1$
83		84
84	/**	85	/**
		86	* The listing of applicable launch options for this configuration.
		87	*
		88	* <p>
		89	* <strong>EXPERIMENTAL</strong>. This class has been added as
		90	* part of a work in progress. There is no guarantee that this API will
		91	* remain unchanged during the 3.3 release cycle. Please do not use this API
		92	* without consulting with the Platform/Debug team.
		93	* </p>
		94	* @since 3.3
		95	*/
		96	public static final String ATTR_LAUNCH_OPTIONS = DebugPlugin.getUniqueIdentifier() + ".LAUNCH_OPTIONS"; //$NON-NLS-1$
		97
		98	/**
85	* Location this configuration is stored in. This	99	* Location this configuration is stored in. This
86	* is the key for a launch configuration handle.	100	* is the key for a launch configuration handle.
87	*/	101	*/
Lines 320-333 Link Here
320	/**	334	/**
321	* Returns the launch configuration delegate for this	335	* Returns the launch configuration delegate for this
322	* launch configuration, for the specified launch mode.	336	* launch configuration, for the specified launch mode.
323	*
324	* @param mode launch mode	337	* @param mode launch mode
325	* @return launch configuration delegate	338	* @return launch configuration delegate
326	* @exception CoreException if the delegate was unable	339	* @exception CoreException if the delegate was unable
327	* to be created	340	* to be created
328	*/	341	*/
329	protected ILaunchConfigurationDelegate getDelegate(String mode) throws CoreException {	342	protected ILaunchConfigurationDelegate getDelegate(String mode, String[] options) throws CoreException {
330	return getType().getDelegate(mode);	343	return getType().getDelegate(mode, options);
331	}	344	}
332		345
333	/* (non-Javadoc)	346	/* (non-Javadoc)
Lines 480-485 Link Here
480	return getLastLocationSegment();	493	return getLastLocationSegment();
481	}	494	}
482		495
		496	/**
		497	* @see org.eclipse.debug.core.ILaunchConfiguration#getOptions()
		498	*/
		499	public String[] getOptions() throws CoreException {
		500	String str = getAttribute(ATTR_LAUNCH_OPTIONS, (String)null);
		501	if(str != null) {
		502	String[] atts = str.split(","); //$NON-NLS-1$
		503	if(atts != null) {
		504	return atts;
		505	}
		506	}
		507	return new String[0];
		508	}
		509
483	/* (non-Javadoc)	510	/* (non-Javadoc)
484	* @see org.eclipse.debug.core.ILaunchConfiguration#getType()	511	* @see org.eclipse.debug.core.ILaunchConfiguration#getType()
485	*/	512	*/
Lines 570-576 Link Here
570	*/	597	*/
571	public ILaunch launch(String mode, IProgressMonitor monitor, boolean build, boolean register) throws CoreException {	598	public ILaunch launch(String mode, IProgressMonitor monitor, boolean build, boolean register) throws CoreException {
572	// bug 28245 - force the delegate to load in case it is interested in launch notifications	599	// bug 28245 - force the delegate to load in case it is interested in launch notifications
573	ILaunchConfigurationDelegate delegate= getDelegate(mode);	600	ILaunchConfigurationDelegate delegate = getDelegate(mode, getOptions());
574	ILaunchConfigurationDelegate2 delegate2 = null;	601	ILaunchConfigurationDelegate2 delegate2 = null;
575	if (delegate instanceof ILaunchConfigurationDelegate2) {	602	if (delegate instanceof ILaunchConfigurationDelegate2) {
576	delegate2 = (ILaunchConfigurationDelegate2) delegate;	603	delegate2 = (ILaunchConfigurationDelegate2) delegate;
Lines 690-694 Link Here
690	return getType().supportsMode(mode);	717	return getType().supportsMode(mode);
691	}	718	}
692		719
693	}//end class	720	}
694		721




/*******************************************************************************
 * Copyright (c) 2000, 2006 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.debug.internal.core;

import com.ibm.icu.text.MessageFormat;
import java.util.HashSet;
import java.util.Set;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;

/**
 * A placeholder for a launch delegate contributed for a launch mode for an
 * existing launch configuration type.
 */
public class ContributedDelegate {

	/**
	 * The configuration element of the extension.
	 */
	private IConfigurationElement fElement;
	
	/**
	 * Modes this delegate supports.
	 */
	private Set fModes;
	
	/**
	 * Delegate, or <code>null</code> if not yet instantiated.
	 */
	private ILaunchConfigurationDelegate fDelegate;
	
	/**
	 * Constructs a new contributed delegate on the
	 * given configuration element.
	 * 
	 * @param element configuration element
	 */
	protected ContributedDelegate(IConfigurationElement element) {
		setConfigurationElement(element);
	}
	
	/**
	 * Sets this delegate's configuration element.
	 * 
	 * @param element this delegate's configuration element
	 */
	private void setConfigurationElement(IConfigurationElement element) {
		fElement = element;
	}
	
	/**
	 * Returns this delegate's configuration element.
	 * 
	 * @return this delegate's configuration element
	 */
	protected IConfigurationElement getConfigurationElement() {
		return fElement;
	}	
	
	/**
	 * Returns the set of modes specified in the configuration data.
	 * 
	 * @return the set of modes specified in the configuration data
	 */
	protected Set getModes() {
		if (fModes == null) {
			String modes= getConfigurationElement().getAttribute("modes"); //$NON-NLS-1$
			if (modes == null) {
				return new HashSet(0);
			}
			String[] strings = modes.split(","); //$NON-NLS-1$
			fModes = new HashSet(3);
			for (int i = 0; i < strings.length; i++) {
				String string = strings[i];
				fModes.add(string.trim());
			}
		}
		return fModes;
	}
	
	/**
	 * Returns the type identifier of launch configuration type this delegate is
	 * contributed to.
	 */
	protected String getLaunchConfigurationType() {
		return getConfigurationElement().getAttribute("type"); //$NON-NLS-1$
	}
	
	protected ILaunchConfigurationDelegate getDelegate() throws CoreException {
		if (fDelegate == null) {
			Object object = getConfigurationElement().createExecutableExtension("delegate"); //$NON-NLS-1$
			if (object instanceof ILaunchConfigurationDelegate) {
				fDelegate = (ILaunchConfigurationDelegate)object;
			} else {
				throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, MessageFormat.format(DebugCoreMessages.LaunchConfigurationType_Launch_delegate_for__0__does_not_implement_required_interface_ILaunchConfigurationDelegate__1, new String[]{getIdentifier()}), null)); 
			}		
		}
		return fDelegate;
	}
	
	/**
	 * Returns the identifier of this extension point.
	 */
	protected String getIdentifier() {
		return getConfigurationElement().getAttribute("id"); //$NON-NLS-1$
	}	
	
	/**
	 * Returns the source path computer id specified by this launch delegate 
	 * or <code>null</code> if none.
	 * 
	 * @return the source path computer id specified by this launch delegate 
	 * or <code>null</code> if none
	 * 
	 * @since 3.1
	 */
	protected String getSourcePathComputerId() {
		return getConfigurationElement().getAttribute("sourcePathComputerId"); //$NON-NLS-1$
	}
	
	/**
	 * Returns the source locater id specified by this launch delegate 
	 * or <code>null</code> if none.
	 * 
	 * @return the source locater id specified by this launch delegate 
	 * or <code>null</code> if none
	 * 
	 * @since 3.1
	 */
	protected String getSourceLocaterId() {
		return getConfigurationElement().getAttribute("sourceLocatorId"); //$NON-NLS-1$
	}
}




	}
	
	/**
	 * @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#setOptions(java.lang.String[])
	 */
	public void setOptions(String[] options) {
		String str = null;
		if(options != null) {
			str = ""; //$NON-NLS-1$
			for(int i = 0; i < options.length; i++) {
				str += options[i];
				if(i < options.length-1) {
					str += ","; //$NON-NLS-1$
				}
			}
		}
		setAttribute(ATTR_LAUNCH_OPTIONS, str);
	}
	
	/**
	 * Sets this working copy's state to not dirty.
	 */
	private void resetDirty() {

		}
		setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_PATHS, paths);
		setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_TYPES, types);
	}

}


Lines 8-13 Link Here

(-)schema/launchOptions.exsd (-2 / +7 lines)
8	<documentation>	8	<documentation>
9	This extension point is used to contribute launch options to the launch manager.	9	This extension point is used to contribute launch options to the launch manager.
10	Launch options are used as modifiers when executing a launch configuration.	10	Launch options are used as modifiers when executing a launch configuration.
		11
		12	<p><strong>EXPERIMENTAL</strong>. This method has been added as
		13	part of a work in progress. There is no guarantee that this API will
		14	remain unchanged during the 3.3 release cycle. Please do not use this API
		15	without consulting with the Platform/Debug team.</p>
11	</documentation>	16	</documentation>
12	</annotation>	17	</annotation>
13		18
Lines 101-107 Link Here
101	</launchOption>	106	</launchOption>
102	</extension>	107	</extension>
103	</pre>	108	</pre>
104	</p>	109	</p>
105	</documentation>	110	</documentation>
106	</annotation>	111	</annotation>
107		112
Lines 128-134 Link Here
128	<meta.section type="copyright"/>	133	<meta.section type="copyright"/>
129	</appInfo>	134	</appInfo>
130	<documentation>	135	<documentation>
131	Copyright (c) 2003, 2005 IBM Corporation and others.<br>	136	Copyright (c) 2006 IBM Corporation and others.<br>
132	All rights reserved. This program and the accompanying materials are made	137	All rights reserved. This program and the accompanying materials are made
133	available under the terms of the Eclipse Public License v1.0 which	138	available under the terms of the Eclipse Public License v1.0 which
134	accompanies this distribution, and is available at	139	accompanies this distribution, and is available at




               </documentation>
            </annotation>
         </attribute>
         <attribute name="delegate" type="string">
            <annotation>
               <documentation>
                  specifies the fully qualified name of the Java class that implements &lt;code&gt;ILaunchConfigurationDelegate&lt;/code&gt;.
Launch configuration instances of this type will delegate to instances of this class to perform launching.

With new API changes for 3.3M3 the delegate should be contributed via the &lt;code&gt;launchDelegates&lt;/code&gt; extension point
&lt;p&gt;
&lt;strong&gt;EXPERIMENTAL&lt;/strong&gt;. This attribute has been deprecated as
part of a work in progress. There is no guarantee that this API will
remain unchanged during the 3.3 release cycle. Please do not use this API
without consulting with the Platform/Debug team.
&lt;/p&gt;
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn="org.eclipse.debug.core.model.ILaunchConfigurationDelegate" deprecated="true"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="modes" type="string">
            <annotation>
               <documentation>
                  specifies a comma-separated list of the modes this type of lauch configuration supports - &quot;run&quot; and/or &quot;debug&quot;.

With new API changes for 3.3M3 the delegate should be contributed via the &lt;code&gt;launchDelegates&lt;/code&gt; extension point

&lt;p&gt;
&lt;strong&gt;EXPERIMENTAL&lt;/strong&gt;. This attribute has been deprecated as
part of a work in progress. There is no guarantee that this API will
remain unchanged during the 3.3 release cycle. Please do not use this API
without consulting with the Platform/Debug team.
&lt;/p&gt;
               </documentation>
               <appInfo>
                  <meta.attribute deprecated="true"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="name" type="string" use="required">

            <annotation>
               <documentation>
                  The unique identifier of a sourcePathComputer extension that is used to compute a default source lookup path for launch configurations of this type. This atttribute was added in the 3.0 release.

With new API changes for 3.3M3 the delegate should be contributed via the &lt;code&gt;launchDelegates&lt;/code&gt; extension point
               </documentation>
               <appInfo>
                  <meta.attribute deprecated="true"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="sourceLocatorId" type="string">
            <annotation>
               <documentation>
                  The unique identifier of a sourceLocator extension that is used to create the source locator for sessions launched using launch configurations of this type. This atttribute was added in the 3.0 release.

With new API changes for 3.3M3 the delegate should be contributed via the &lt;code&gt;launchDelegates&lt;/code&gt; extension point
               </documentation>
               <appInfo>
                  <meta.attribute deprecated="true"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="migrationDelegate" type="string">

               </appInfo>
            </annotation>
         </attribute>
         <attribute name="icon" type="string">
            <annotation>
               <documentation>
                  The id of the icon for this launch configuraiton type.

since 3.3

&lt;p&gt;
&lt;strong&gt;EXPERIMENTAL&lt;/strong&gt;. This element has been added as
part of a work in progress. There is no guarantee that this API will
remain unchanged during the 3.3 release cycle. Please do not use this API
without consulting with the Platform/Debug team.
&lt;/p&gt;
               </documentation>
               <appInfo>
                  <meta.attribute kind="resource"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>





<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.debug.core">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.debug.core" id="launchDelegates" name="Launch Delegates"/>
      </appInfo>
      <documentation>
         This extension point provides a mechanism for contributing a launch delegate to an existing launch configuration type for one or more launch modes. Since launch modes are extensible, it may be neccessary to contribute additional launch delegates to an existing launch configuration type. Each launch delegate is contributed for a specific launch configuration type. A launch delegate supports one or more launch modes, and specifies a delegate responsible for the implementation of launching.
      </documentation>
   </annotation>

   <element name="extension">
      <complexType>
         <sequence>
            <element ref="launchDelegate" minOccurs="1" maxOccurs="unbounded"/>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  a fully qualified identifier of the target extension point
               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  an optional identifier of the extension instance
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  an optional name of the extension instance
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="launchDelegate">
      <annotation>
         <appInfo>
            <meta.element labelAttribute="name"/>
         </appInfo>
      </annotation>
      <complexType>
         <sequence minOccurs="0" maxOccurs="unbounded">
         </sequence>
         <attribute name="id" type="string" use="required">
            <annotation>
               <documentation>
                  specifies a unique identifier for this launch delegate.
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  specifies a human readable name for this delegate

since 3.3M3

&lt;p&gt;
&lt;strong&gt;EXPERIMENTAL&lt;/strong&gt;. This attribute has been added as
part of a work in progress. There is no guarantee that this API will
remain unchanged during the 3.3 release cycle. Please do not use this API
without consulting with the Platform/Debug team.
&lt;/p&gt;
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="delegate" type="string" use="required">
            <annotation>
               <documentation>
                  specifies the fully qualified name of the Java class that implements &lt;code&gt;ILaunchConfigurationDelegate&lt;/code&gt;.
Launch configuration instances of this delegate&apos;s type will delegate to instances of this class to perform launching.
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn="org.eclipse.debug.core.model.ILaunchConfigurationDelegate"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="modes" type="string">
            <annotation>
               <documentation>
                  specifies a comma-separated list of the modes this lauch delegate supports.
               </documentation>
            </annotation>
         </attribute>
         <attribute name="type" type="string">
            <annotation>
               <documentation>
                  identifier of an existing launch configuration type that this launch delegate is capable of launching.
               </documentation>
            </annotation>
         </attribute>
         <attribute name="sourcePathComputerId" type="string">
            <annotation>
               <documentation>
                  The unique identifier of a sourcePathComputer extension that is used to compute a default source lookup path for launch configurations of this type. Since 3.1, this attribute cab be specified in a launchDelegate extension when unspecified in the assocaited launchConfigurationType extension. Only one source path computer can be specified per launch configuration type.
               </documentation>
            </annotation>
         </attribute>
         <attribute name="sourceLocatorId" type="string">
            <annotation>
               <documentation>
                  The unique identifier of a sourceLocator extension that is used to create the source locator for sessions launched using launch configurations of this type. Since 3.1, this attribute can be specified in a launchDelegate extension when unspecified in the assocaited launchConfigurationType extension. Only one source locater can be specified per launch configuration type.
               </documentation>
            </annotation>
         </attribute>
         <attribute name="options" type="string">
            <annotation>
               <documentation>
                  This attribute allows contributors to sepcify what options this delegate can apply to other than the specified modes

since 3.3M3

&lt;p&gt;
&lt;strong&gt;EXPERIMENTAL&lt;/strong&gt;. This attribute has been added as
part of a work in progress. There is no guarantee that this API will
remain unchanged during the 3.3 release cycle. Please do not use this API
without consulting with the Platform/Debug team.
&lt;/p&gt;
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

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

   <annotation>
      <appInfo>
         <meta.section type="examples"/>
      </appInfo>
      <documentation>
         The following is an example of a launch delegate extension point:

&lt;p&gt;
&lt;pre&gt;
 &lt;extension point=&quot;org.eclipse.debug.core.launchDelegates&quot;&gt;
  &lt;launchDelegate
   id=&quot;com.example.ExampleProfileDelegate&quot;
   delegate=&quot;com.example.ExampleProfileDelegate&quot;
   type=&quot;org.eclipse.jdt.launching.localJavaApplication&quot;
   modes=&quot;profile&quot;&gt;
  &lt;/launchDelegate&gt;
 &lt;/extension&gt;
&lt;/pre&gt;
&lt;/p&gt;

In the example above, the specified launch delegate is contributed to launch Java applications in profile mode.

The previous example has been deprecated as of 3.3M3, but left in for brevity. See the following example for new usage.

&lt;p&gt;
&lt;pre&gt;
&lt;extension point=&quot;org.eclipse.debug.core.launchDelegates&quot;&gt;
      &lt;launchDelegate
            delegate=&quot;org.eclipse.jdt.launching.JavaLaunchDelegate&quot;
            id=&quot;org.eclipse.jdt.launching.JavaLaunchDelegate&quot;
            type=&quot;org.eclipse.jdt.launching.localJavaApplication&quot;
      modes=&quot;profile&quot;&gt;
      &lt;/launchDelegate&gt;
   &lt;/extension&gt;   
&lt;/pre&gt;
&lt;/p&gt;

In 3.3 mode-based launching has been deprecated, and in its place we have provided launching with options. Options are contributed via the &lt;code&gt;launchOptions&lt;/code&gt; extension point and can be referenced here to describe what options your launch delegate supports. Options are further arranged in the form of expressions that can be evaluated to determine suitablility of your delegate for a variety of combinations of options.
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="apiInfo"/>
      </appInfo>
      <documentation>
         Value of the attribute &lt;b&gt;delegate&lt;/b&gt; must be a fully qualified name of a Java class that implements the interface &lt;b&gt;org.eclipse.debug.core.model.ILaunchConfigurationDelegate&lt;/b&gt;.
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="copyright"/>
      </appInfo>
      <documentation>
         Copyright (c) 2000, 2005 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>




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.debug.core">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.debug.core" id="launchModes" name="Launch Modes"/>
      </appInfo>
      <documentation>
         This extension point provides a mechanism for contributing launch modes to the debug platform. The debug platform defines modes for &quot;run&quot;, &quot;debug&quot;, and &quot;profile&quot;.
      </documentation>
   </annotation>

   <element name="extension">
      <complexType>
         <sequence>
            <element ref="launchMode" minOccurs="0" maxOccurs="unbounded"/>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  a fully qualified identifier of the target extension point
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="launchMode">
      <annotation>
         <appInfo>
            <meta.element labelAttribute="name"/>
         </appInfo>
      </annotation>
      <complexType>
         <sequence>
         </sequence>
         <attribute name="mode" type="string" use="required">
            <annotation>
               <documentation>
                  specifies a unique identifier for this launch mode. The launch modes contributed by the debug plaform are &quot;run&quot;, &quot;debug&quot;, and &quot;profile&quot;.
               </documentation>
            </annotation>
         </attribute>
         <attribute name="label" type="string" use="required">
            <annotation>
               <documentation>
                  A human-readable label that describes the launch mode
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="launchAsLabel" type="string">
            <annotation>
               <documentation>
                  A human-readable label to be used in a launch cascade menu. For example &quot;Run As&quot;. This attribute was added in 3.2 to allow the label to be properly externalized. When unspecified, a default label is created via concatenation.
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

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

   <annotation>
      <appInfo>
         <meta.section type="examples"/>
      </appInfo>
      <documentation>
         The following is an example of a launch delegate extension point:

&lt;p&gt;
&lt;pre&gt;
 &lt;extension point=&quot;org.eclipse.debug.core.launchModes&quot;&gt;
  &lt;launchMode
   mode=&quot;profile&quot;
   label=&quot;Profile&quot;&gt;
  &lt;/launchMode&gt;
 &lt;/extension&gt;
&lt;/pre&gt;
&lt;/p&gt;

In the example above, the profile launch mode is contributed.
      </documentation>
   </annotation>

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

   <annotation>
      <appInfo>
         <meta.section type="copyright"/>
      </appInfo>
      <documentation>
         Copyright (c) 2000, 2005 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>
   <annotation>
      <appInfo>
         <meta.section type="copyright"/>
      </appInfo>
      <documentation>
         Copyright (c) 2000, 2005 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>




  <li>deprecated <code>IDebugUIConstants.ATTR_CONSOLE_ENCODING</code>.</li>
  <li>added <code>DebugUITools.getLastLaunch(String id)</code> - provides access to the last launch in
   each launch group.</li>
   <li>Add <code>launchOptions</code> schema -- provides a new mechanism for providing launch options to the launching framework</li>
   <li>Added <code>ILaunchOption</code> -- which describes a single contributed launch option within the launch manager</li>
   <li>Added <code>ILaunchManager.getLaunchOptions()</code> -- returns and array of all of the <code>ILaunchOptions</code> registered with the launch manager</li>
   <li>Added <code>ILaunchManager.getLaunchOption(String id)</code> -- returns the <code>ILaunchOption</code> associated with the given unique id, or <code>null</code></li>
</ul>

<h2>Summary of Launch Option conversion changes in 3.3</h2>
<ul>
<li>Added <code>launchOptions</code> schema -- provides a new mechanism for providing launch options to the launching framework</li>
   <li>Added interface/class <code>ILaunchOption</code> -- which describes a single contributed launch option within the launch manager</li>
   <li>Added method <code>ILaunchManager.getLaunchOptions()</code> -- returns and array of all of the <code>ILaunchOptions</code> registered with the launch manager</li>
   <li>Added method <code>ILaunchManager.getLaunchOption(String id)</code> -- returns the <code>ILaunchOption</code> associated with the given unique id, or <code>null</code></li>
   <li>Added interface/class <code>ILaunchOption</code> -- which describes a single contributed launch option within the launch manager</li>
   <li>Added method <code>ILaunchConfiguration.getOptions()</code> -- returns the comma seperated listiong of options</li>
   <li>Added method <code>ILaunchConfigurationWorkingCopy.setOptions(String[] options)</code> -- allows the options to be set in the launch configuration</li>
   <li>Added method <code>ILaunchManager.getLaunchDelegates()</code> -- returns all of the registered launch delegates</li>
   <li>Added method <code>ILaunchManager.getLaunchDelegates(String typeid, String mode, String[] options)</code> -- returns the 
   list of delegates that apply to the the specifed mode, config type id and options (if any)</li>
   <li>Added constant <code>ATTR_LAUNCH_OPTIONS</code> to <code>LaunchConfiguration</code></li>
   <li>Added method <code>ILaunchConfigurationType.getContributorName()</code> -- returns the name of the contributor of the type</li>
   <li>Added method <code>ILaunchConfigurationType.getImageDescriptorPath()</code> -- returns the path of the image descriptor (if provided)</li>
   <li>Added method <code>ILaunchConfigurationType.getDelegate(String mode, String[] options)</code> -- returns the launch delegate for the specified mode and options</li>
   <li>Added class <code>ConfigurationElementConstants</code> -- contains common constants for getting child elements of <code>IConfigurationElements</code> 
   <li>Added internal method <code>LaunchManager.initializeLaunchDelegates()</code> -- loads the listing of delegates</li>
   <li>Added internal method <code>LaunchManager.initializeLaunchOptions()</code> -- loads the listing of launch options</li>
   <li>Deprecated method <code>ILaunchConfigurationType.getDelegate(String mode)</code> -- in favour of the new <code>getDelegate(String mode, String[] options) method</code></li>
   <li>Deprecated attribute 'delegate' in <code>launchConfigurationTypes</code> schema, in favour of contributing delegates via the <code>launchDelegates</code> extension point</li>
   <li>Deprecated attribute 'modes' in <code>launchConfigurationTypes</code> schema, in favour of contributing modes via the <code>launchDelegates</code> extension point</li>
   <li>Deprecated attribute 'sourcePathComputerId' in <code>launchConfigurationTypes</code> schema, in favour of contributing it via the <code>launchDelegates</code> extension point</li>
   <li>Deprecated attribute 'sourceLocatorId' in <code>launchConfigurationTypes</code> schema, in favour of contributing it via the <code>launchDelegates</code> extension point</li>
   <li>Added attrbute 'icon' in <code>launchConfigurationTypes</code> schema, in favour of contributing a seperate extension <code>launchConfigurationTypeImages</code></li>
   <li>Added attribute 'name' to the <code>launchDelegates</code> schema, providing a human readable name for the delegate. To be used in duplicate resolution</li>
   <li>Added attribute 'options' to the <code>launchDelegates</code> schema, providing the ability to specify launch options that this delegate can support</li>
   <li>Added interface/class <code>ILaunchConfigurationTabExtension</code> -- provides a proxy to a contributed tab <code>IConfigurationElement</code> element</li>
   <li>Added internal method <code>LauncConfigurationPtresentationManager.initializeContributedTabExtensions</code> -- loads contributed tabs</li>
   <li>Added method <code>LaunchConfigurationPresentationManager.createContributedTabs(String groupid)</code> -- lazily creates the tabs for a specified tabgroup id</li>
   <li>Added constant <code>EXTENSION_POINT_CONTRIBUTED_LAUNCH_TABS</code> to <code>IDebugUIConstants</code></li>
   <li>Added class <code>LaunchConfigurationTabGroupWrapper</code> -- which is used to wrap an existing tab group with its contributed tabs</li>
   <li>Deprecated <code>launchConfigurationTypeImages</code> extension point</li>
</ul>

h2>Oct 3, 2006</h2>
<h3>Problem Reports Fixed</h3>
<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=158760">158760</a>: Warning in latest nightly build and integration build<br>





/*******************************************************************************
 * Copyright (c) 2006 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.debug.core;

import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;

/**
 * This interface describes a launch delegate
 * Clients can contribute launch delegate through the <code>launchDelegates</code> extension point
 * 
 * Example contribution of the local java launch delegate
 * <pre>
 * <launchDelegate
            delegate="org.eclipse.jdt.launching.JavaLaunchDelegate"
            id="org.eclipse.jdt.launching.JavaLaunchDelegate">
         <appliesTo
               type="org.eclipse.jdt.launching.localJavaApplication">
            <option
                  option="debug">
            </option>
         </appliesTo>
      </launchDelegate>
 * </pre>
 * 
 * Clients are NOT intended to implement this interface
 * @since 3.3
 */
public interface ILaunchDelegate {

	/**
	 * @return returns the unique id of the delegate
	 */
	public String getIdentifier();
	
	/**
	 * @return the launch delegate
	 */
	public ILaunchConfigurationDelegate getDelegate() throws CoreException;
	
	/**
	 * One delegate definition can now be associated with more than on launch configuration type.
	 * In this case we need to return them all. In the deprecated case when one delegate is associated
	 * with one type, we only need return the one (a set of only one element)
	 * @return the set of associated launch configuration type ids (String) or the empty set, never <code>null</code>
	 */
	public String getLaunchConfigurationType();
	
	/**
	 * @return the associated source locator id or <code>null</code> if not provided
	 */
	public String getSourceLocatorId();
	
	/**
	 * @return the associated source path computer id or <code>null</code> if not provided
	 */
	public String getSourcePathComputerId();
	
	/**
	 * @return the options associated with this delegate. If no options are specified an empty set is
	 * returned, never <code>null</code>.
	 */
	public Set getOptions();
	
	/**
	 * This method is provided as a backward compatibility measure to allow access to modes, if mode-based
	 * launching is still being used.
	 * 
	 * @return a set of modes for this delegate or the empty set if none are found, never <code>null</code>.
	 */
	public Set getModes();
	
	/**
	 * used to determine if the delegate applies to the specified launch configuration type via its id only (no expression evaluation is done)
	 * @param configtypeId the id of the <code>ILaunchConfigurationType</code>.
	 * @return true if the delegate applies to the associated config type, false otherwise
	 */
	public boolean appliesTo(String configtypeId);
	
	/**
	 * used to determine if the delegate applies to the specified launch configuration type via its id and mode (no expression evaluation is done)
	 * @param configtypeId the id of the <code>ILaunchConfigurationType</code>.
	 * @param mode the mode
	 * @return true if the delegate applies to the associated config type, false otherwise
	 */
	public boolean appliesTo(String configtypeId, String mode);
}




/*******************************************************************************
 * Copyright (c) 2006 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.debug.internal.core;

/**
 * This class provides a repository for the names of <code>IConfigurationElement</code> child node ids.
 * @since 3.3
 * <p>
 * <strong>EXPERIMENTAL</strong>. This class has been added as
 * part of a work in progress. There is no guarantee that this API will
 * remain unchanged during the 3.3 release cycle. Please do not use this API
 * without consulting with the Platform/Debug team.
 * </p>
 */
public class ConfigurationElementConstants {

	/**
	 * The id node name for a configuration element
	 */
	public static final String ID = "id"; //$NON-NLS-1$
	
	/**
	 * the name node name for a configuration element
	 */
	public static final String NAME = "name"; //$NON-NLS-1$
	
	/**
	 * the category node name for a configuration element
	 */
	public static final String CATEGORY = "category"; //$NON-NLS-1$
	
	/**
	 * the launchMode node name for a configuration element
	 */
	public static final String LAUNCH_MODE = "launchMode"; //$NON-NLS-1$
	
	/**
	 * the description node name for a configuration element
	 */
	public static final String DESCRIPTION = "description"; //$NON-NLS-1$
	
	/**
	 * the helpContextId node name for a configuration element
	 */
	public static final String HELP_CONTEXT_ID = "helpContextId"; //$NON-NLS-1$
	
	/**
	 * the icon node name for a configuration element
	 */
	public static final String ICON = "icon"; //$NON-NLS-1$
	
	/**
	 * the public node name for a configuration element
	 */
	public static final String PUBLIC = "public"; //$NON-NLS-1$
	
	/**
	 * the perspective node name for a configuration element
	 */
	public static final String PERSPECTIVE = "perspective"; //$NON-NLS-1$
	
	/**
	 * the modes node name for a configuration element
	 */
	public static final String MODES = "modes"; //$NON-NLS-1$
	
	/**
	 * the mode node name for a configuration element
	 */
	public static final String MODE = "mode"; //$NON-NLS-1$
	
	/**
	 * the type node name for a configuration element
	 */
	public static final String TYPE = "type"; //$NON-NLS-1$
	
	/**
	 * the option node name for a configuration element
	 */
	public static final String OPTIONS = "options"; //$NON-NLS-1$
	
	/**
	 * the delegate node name for a configuration element
	 */
	public static final String DELEGATE = "delegate"; //$NON-NLS-1$
	
	/**
	 * the group node name for a configuration element
	 */
	public static final String GROUP = "group"; //$NON-NLS-1$
	
	/**
	 * the class node name for a configuration element
	 */
	public static final String CLASS = "class"; //$NON-NLS-1$
	
	/**
	 * the sourcePathComputerId node name for a configuration element
	 */
	public static final String SOURCE_PATH_COMPUTER = "sourcePathComputerId"; //$NON-NLS-1$
	
	/**
	 * the sourceLocatorId node name for a configuration element
	 */
	public static final String SOURCE_LOCATOR = "sourceLocatorId"; //$NON-NLS-1$
	
	/**
	 * the migrationDelegate node name for a configuration element
	 */
	public static final String MIGRATION_DELEGATE = "migrationDelegate";  //$NON-NLS-1$
}




/*******************************************************************************
 * Copyright (c) 2006 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.debug.internal.core;

import java.util.HashSet;
import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchDelegate;
import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;

import com.ibm.icu.text.MessageFormat;

/**
 * Proxy to a launch delegate extension
 * 
 * @since 3.3
 */
public class LaunchDelegate implements ILaunchDelegate {
	
	/**
	 * The configuration element for this delegate
	 */
	private IConfigurationElement fElement = null;
	
	/**
	 * The cached delegate. Remains null until asked for, then persisted
	 */
	private ILaunchConfigurationDelegate fDelegate = null;
	
	//lists of cached entries
	private HashSet fModes = null;
	private HashSet fOptions = null;
	private String fType = null;
	
	/**
	 * Constructor
	 * @param element the configuration element to associate with this launch delegate
	 */
	public LaunchDelegate(IConfigurationElement element) {
		fElement = element;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchDelegate#getDelegate()
	 */
	public ILaunchConfigurationDelegate getDelegate() throws CoreException {
		if(fDelegate == null) {
			Object obj = fElement.createExecutableExtension(ConfigurationElementConstants.DELEGATE);
			if(obj instanceof ILaunchConfigurationDelegate) {
				return (ILaunchConfigurationDelegate)obj;
			}
			throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, MessageFormat.format(DebugCoreMessages.LaunchConfigurationType_Launch_delegate_for__0__does_not_implement_required_interface_ILaunchConfigurationDelegate__1, new String[]{getIdentifier()}), null));
		}
		return fDelegate;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchDelegate#getIdentifier()
	 */
	public String getIdentifier() {
		return fElement.getAttribute(ConfigurationElementConstants.ID);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchDelegate#getLaunchConfigurationType()
	 */
	public String getLaunchConfigurationType() {
		if(fType == null) {
			//fall back to single association if no appliesTo
			fType = fElement.getAttribute(ConfigurationElementConstants.TYPE);
			if(fType == null) {
				//the case when we have passed a launch configuration type to the launch delegate
				fType = fElement.getAttribute(ConfigurationElementConstants.ID);
			}
		}
		return fType;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchDelegate#getOptions()
	 */
	public Set getOptions() {
		if(fOptions == null) {
			fOptions = new HashSet();
			String option = fElement.getAttribute(ConfigurationElementConstants.OPTIONS);
			if(option != null) {
				String[] options = option.split(","); //$NON-NLS-1$
				for(int i = 0; i < options.length; i++) {
					fOptions.add(options[i]);
				}
			}
		}
		return fOptions;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchDelegate#getModes()
	 */
	public Set getModes() {
		if (fModes == null) {
			fModes = new HashSet();
			String modes = fElement.getAttribute(ConfigurationElementConstants.MODES); 
			if (modes != null) {
				String[] strings = modes.split(","); //$NON-NLS-1$
				for (int i = 0; i < strings.length; i++) {
					fModes.add(strings[i].trim());
				}
			}
		}
		return fModes;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchDelegate#getSourceLocatorId()
	 */
	public String getSourceLocatorId() {
		return fElement.getAttribute(ConfigurationElementConstants.SOURCE_LOCATOR);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchDelegate#getSourcePathComputerId()
	 */
	public String getSourcePathComputerId() {
		return fElement.getAttribute(ConfigurationElementConstants.SOURCE_PATH_COMPUTER);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchDelegate#appliesTo(java.lang.String)
	 */
	public boolean appliesTo(String configtypeId) {
		return getLaunchConfigurationType().equals(configtypeId);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchDelegate#appliesTo(java.lang.String, java.lang.String)
	 */
	public boolean appliesTo(String configtypeId, String mode) {
		return getLaunchConfigurationType().equals(configtypeId) & getModes().contains(mode);
	}

}

Return to bug 157059

Lines 1037-1042 Link Here

(-)ui/org/eclipse/debug/internal/ui/DebugUIPlugin.java (+20 lines)
1037	}	1037	}
1038		1038
1039	/**	1039	/**
		1040	* Returns an image descriptor for the icon referenced by the given path
		1041	* and contributor name, or <code>null</code> if none.
		1042	*
		1043	* @param name the name of the contributor
		1044	* @param path the path of the icon (from the configuration element)
		1045	* @return image descriptor or <code>null</code>
		1046	* @since 3.3
		1047	*/
		1048	public static ImageDescriptor getImageDescriptor(String name, String path) {
		1049	Bundle bundle = Platform.getBundle(name);
		1050	if (path != null) {
		1051	URL iconURL = FileLocator.find(bundle , new Path(path), null);
		1052	if (iconURL != null) {
		1053	return ImageDescriptor.createFromURL(iconURL);
		1054	}
		1055	}
		1056	return null;
		1057	}
		1058
		1059	/**
1040	* Performs extra filtering for launch configurations based on the prefs set on the	1060	* Performs extra filtering for launch configurations based on the prefs set on the
1041	* Launch Configurations page	1061	* Launch Configurations page
1042	* @param config the config to filter	1062	* @param config the config to filter

Lines 927-932 Link Here

(-)ui/org/eclipse/debug/ui/IDebugUIConstants.java (+14 lines)
927	public static final String EXTENSION_POINT_LAUNCH_CONFIGURATION_TAB_GROUPS= "launchConfigurationTabGroups"; //$NON-NLS-1$	927	public static final String EXTENSION_POINT_LAUNCH_CONFIGURATION_TAB_GROUPS= "launchConfigurationTabGroups"; //$NON-NLS-1$
928		928
929	/**	929	/**
		930	* Contributed Launch Configuration Tab extension point indentifier
		931	*
		932	* <p>
		933	* <strong>EXPERIMENTAL</strong>. This constant has been added as
		934	* part of a work in progress. There is no guarantee that this API will
		935	* remain unchanged during the 3.3 release cycle. Please do not use this API
		936	* without consulting with the Platform/Debug team.
		937	* </p>
		938	*
		939	* @since 3.3
		940	*/
		941	public static final String EXTENSION_POINT_CONTRIBUTED_LAUNCH_TABS = "launchConfigurationTabs"; //$NON-NLS-1$
		942
		943	/**
930	* Launch shortcuts extension point identifier	944	* Launch shortcuts extension point identifier
931	* (value <code>"launchShortcuts"</code>).	945	* (value <code>"launchShortcuts"</code>).
932	*	946	*

Lines 304-309 Link Here

(-)core/org/eclipse/debug/core/ILaunchConfiguration.java (+14 lines)
304	public String getName();	304	public String getName();
305		305
306	/**	306	/**
		307	*
		308	* @return returns the options that this configuration supports
		309	*
		310	* <p>
		311	* <strong>EXPERIMENTAL</strong>. This method has been added as
		312	* part of a work in progress. There is no guarantee that this API will
		313	* remain unchanged during the 3.3 release cycle. Please do not use this API
		314	* without consulting with the Platform/Debug team.
		315	* </p>
		316	* @since 3.3
		317	*/
		318	public String[] getOptions() throws CoreException;
		319
		320	/**
307	* Returns the type of this launch configuration. This is a	321	* Returns the type of this launch configuration. This is a
308	* handle-only method.	322	* handle-only method.
309	*	323	*

Lines 172-175 Link Here

(-)core/org/eclipse/debug/core/ILaunchConfigurationWorkingCopy.java (+14 lines)
172	* @since 3.2	172	* @since 3.2
173	*/	173	*/
174	public void setMappedResources(IResource[] resources);	174	public void setMappedResources(IResource[] resources);
		175
		176	/**
		177	* This method is used to set the options for the associated <code>ILaunchConfiguraiton</code>.
		178	* @param options the array of options to set
		179	*
		180	* <p>
		181	* <strong>EXPERIMENTAL</strong>. This method has been added as
		182	* part of a work in progress. There is no guarantee that this API will
		183	* remain unchanged during the 3.3 release cycle. Please do not use this API
		184	* without consulting with the Platform/Debug team.
		185	* </p>
		186	* @since 3.3
		187	*/
		188	public void setOptions(String[] options);
175	}	189	}

Lines 404-409 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchConfigurationWorkingCopy.java (-2 / +19 lines)
404	}	404	}
405		405
406	/**	406	/**
		407	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#setOptions(java.lang.String[])
		408	*/
		409	public void setOptions(String[] options) {
		410	String str = null;
		411	if(options != null) {
		412	str = ""; //$NON-NLS-1$
		413	for(int i = 0; i < options.length; i++) {
		414	str += options[i];
		415	if(i < options.length-1) {
		416	str += ","; //$NON-NLS-1$
		417	}
		418	}
		419	}
		420	setAttribute(ATTR_LAUNCH_OPTIONS, str);
		421	}
		422
		423	/**
407	* Sets this working copy's state to not dirty.	424	* Sets this working copy's state to not dirty.
408	*/	425	*/
409	private void resetDirty() {	426	private void resetDirty() {
Lines 574-580 Link Here
574	}	591	}
575	setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_PATHS, paths);	592	setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_PATHS, paths);
576	setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_TYPES, types);	593	setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_TYPES, types);
577	}//end setResource	594	}
578		595
579	}//end class	596	}
580		597

Lines 27-57 Link Here

(-)plugin.xml (-12 / +33 lines)
27	<extension	27	<extension
28	point="org.eclipse.debug.core.launchConfigurationTypes">	28	point="org.eclipse.debug.core.launchConfigurationTypes">
29	<launchConfigurationType	29	<launchConfigurationType
30	delegate="org.eclipse.jdt.launching.JavaLaunchDelegate"
31	id="org.eclipse.jdt.launching.localJavaApplication"	30	id="org.eclipse.jdt.launching.localJavaApplication"
32	migrationDelegate="org.eclipse.jdt.internal.launching.JavaMigrationDelegate"	31	migrationDelegate="org.eclipse.jdt.internal.launching.JavaMigrationDelegate"
33	modes="run, debug"
34	name="%localJavaApplication"	32	name="%localJavaApplication"
35	sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"	33	>
36	sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer">
37	</launchConfigurationType>	34	</launchConfigurationType>
38	<launchConfigurationType	35	<launchConfigurationType
39	delegate="org.eclipse.jdt.internal.launching.JavaRemoteApplicationLaunchConfigurationDelegate"
40	id="org.eclipse.jdt.launching.remoteJavaApplication"	36	id="org.eclipse.jdt.launching.remoteJavaApplication"
41	migrationDelegate="org.eclipse.jdt.internal.launching.JavaMigrationDelegate"	37	migrationDelegate="org.eclipse.jdt.internal.launching.JavaMigrationDelegate"
42	modes="debug"
43	name="%remoteJavaApplication"	38	name="%remoteJavaApplication"
44	sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"	39	>
45	sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer">
46	</launchConfigurationType>	40	</launchConfigurationType>
47	<launchConfigurationType	41	<launchConfigurationType
48	delegate="org.eclipse.jdt.internal.launching.JavaAppletLaunchConfigurationDelegate"
49	id="org.eclipse.jdt.launching.javaApplet"	42	id="org.eclipse.jdt.launching.javaApplet"
50	migrationDelegate="org.eclipse.jdt.internal.launching.JavaMigrationDelegate"	43	migrationDelegate="org.eclipse.jdt.internal.launching.JavaMigrationDelegate"
51	modes="run, debug"
52	name="%appletLabel"	44	name="%appletLabel"
53	sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"	45	>
54	sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer">
55	</launchConfigurationType>	46	</launchConfigurationType>
56	</extension>	47	</extension>
57	<extension	48	<extension
Lines 189-193 Link Here
189	name= "%jreContainerMarkerProblemName">	180	name= "%jreContainerMarkerProblemName">
190	<super type="org.eclipse.core.resources.problemmarker"/>	181	<super type="org.eclipse.core.resources.problemmarker"/>
191	<persistent value="true"/>	182	<persistent value="true"/>
		183	</extension>
		184	<extension
		185	point="org.eclipse.debug.core.launchDelegates">
		186	<launchDelegate
		187	delegate="org.eclipse.jdt.launching.JavaLaunchDelegate"
		188	id="org.eclipse.jdt.launching.localJavaApplicationDelegate"
		189	modes="run, debug"
		190	name="%localJavaApplication"
		191	sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"
		192	sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer"
		193	type="org.eclipse.jdt.launching.localJavaApplication">
		194	</launchDelegate>
		195	<launchDelegate
		196	delegate="org.eclipse.jdt.internal.launching.JavaRemoteApplicationLaunchConfigurationDelegate"
		197	id="org.eclipse.jdt.launching.remoteJavaApplicationDelegate"
		198	modes="debug"
		199	name="%remoteJavaApplication"
		200	sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"
		201	sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer"
		202	type="org.eclipse.jdt.launching.remoteJavaApplication">
		203	</launchDelegate>
		204	<launchDelegate
		205	delegate="org.eclipse.jdt.internal.launching.JavaAppletLaunchConfigurationDelegate"
		206	id="org.eclipse.jdt.launching.javaAppletDelegate"
		207	modes="run, debug"
		208	name="%appletLabel"
		209	sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"
		210	sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer"
		211	type="org.eclipse.jdt.launching.javaApplet">
		212	</launchDelegate>
192	</extension>	213	</extension>
193	</plugin>	214	</plugin>

Lines 18-23 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationTabGroupExtension.java (-11 / +26 lines)
18		18
19	import org.eclipse.core.runtime.CoreException;	19	import org.eclipse.core.runtime.CoreException;
20	import org.eclipse.core.runtime.IConfigurationElement;	20	import org.eclipse.core.runtime.IConfigurationElement;
		21	import org.eclipse.debug.internal.core.ConfigurationElementConstants;
21	import org.eclipse.debug.ui.ILaunchConfigurationTabGroup;	22	import org.eclipse.debug.ui.ILaunchConfigurationTabGroup;
22		23
23		24
Lines 84-98 Link Here
84	*/	85	*/
85	protected Set getModes() {	86	protected Set getModes() {
86	if (fModes == null) {	87	if (fModes == null) {
87	IConfigurationElement[] modes= getConfigurationElement().getChildren("launchMode"); //$NON-NLS-1$	88	IConfigurationElement[] modes= getConfigurationElement().getChildren(ConfigurationElementConstants.LAUNCH_MODE);
88	if (modes.length > 0) {	89	if (modes.length > 0) {
89	fModes = new HashSet(modes.length);	90	fModes = new HashSet(modes.length);
90	fPerspectives = new Hashtable(modes.length);	91	fPerspectives = new Hashtable(modes.length);
		92	IConfigurationElement element = null;
		93	String perspective = null;
		94	String mode = null;
91	for (int i = 0; i < modes.length; i++) {	95	for (int i = 0; i < modes.length; i++) {
92	IConfigurationElement element = modes[i];	96	element = modes[i];
93	String mode = element.getAttribute("mode"); //$NON-NLS-1$	97	mode = element.getAttribute(ConfigurationElementConstants.MODE);
94	fModes.add(mode);	98	fModes.add(mode);
95	String perspective = element.getAttribute("perspective"); //$NON-NLS-1$	99	perspective = element.getAttribute(ConfigurationElementConstants.PERSPECTIVE);
96	if (perspective != null) {	100	if (perspective != null) {
97	fPerspectives.put(mode, perspective);	101	fPerspectives.put(mode, perspective);
98	}	102	}
Lines 127-133 Link Here
127	* tab group is associated with	131	* tab group is associated with
128	*/	132	*/
129	protected String getTypeIdentifier() {	133	protected String getTypeIdentifier() {
130	return getConfigurationElement().getAttribute("type"); //$NON-NLS-1$	134	return getConfigurationElement().getAttribute(ConfigurationElementConstants.TYPE);
131	}	135	}
132		136
133	/**	137	/**
Lines 139-145 Link Here
139	* @since 2.1	143	* @since 2.1
140	*/	144	*/
141	protected String getHelpContextId() {	145	protected String getHelpContextId() {
142	return getConfigurationElement().getAttribute("helpContextId"); //$NON-NLS-1$	146	return getConfigurationElement().getAttribute(ConfigurationElementConstants.HELP_CONTEXT_ID);
		147	}
		148
		149	/**
		150	* Returns the identifier of the tab group
		151	* @return the id of the tab group
		152	*
		153	* @since 3.3
		154	*/
		155	protected String getIdentifier() {
		156	return getConfigurationElement().getAttribute(ConfigurationElementConstants.ID);
143	}	157	}
144		158
145	/**	159	/**
Lines 150-156 Link Here
150	* the tab group	164	* the tab group
151	*/	165	*/
152	public ILaunchConfigurationTabGroup newTabGroup() throws CoreException {	166	public ILaunchConfigurationTabGroup newTabGroup() throws CoreException {
153	return (ILaunchConfigurationTabGroup)getConfigurationElement().createExecutableExtension("class"); //$NON-NLS-1$	167	return (ILaunchConfigurationTabGroup)getConfigurationElement().createExecutableExtension(ConfigurationElementConstants.CLASS);
154	}	168	}
155		169
156	/**	170	/**
Lines 163-179 Link Here
163	public String getDescription(String mode) {	177	public String getDescription(String mode) {
164	String description = null;	178	String description = null;
165		179
166	IConfigurationElement[] children = fConfig.getChildren("launchMode"); //$NON-NLS-1$	180	IConfigurationElement[] children = fConfig.getChildren(ConfigurationElementConstants.LAUNCH_MODE);
167	if (children!= null && children.length != 0) {	181	if (children!= null && children.length != 0) {
		182	IConfigurationElement child = null;
168	for (int i=0; i<children.length; i++) {	183	for (int i=0; i<children.length; i++) {
169	IConfigurationElement child = children[i];	184	child = children[i];
170	if (child.getAttribute("mode").equals(mode)) { //$NON-NLS-1$	185	if (child.getAttribute("mode").equals(mode)) { //$NON-NLS-1$
171	description = child.getAttribute("description"); //$NON-NLS-1$	186	description = child.getAttribute(ConfigurationElementConstants.DESCRIPTION);
172	}	187	}
173	}	188	}
174	}	189	}
175	if (description == null){	190	if (description == null){
176	description = fConfig.getAttribute("description"); //$NON-NLS-1$	191	description = fConfig.getAttribute(ConfigurationElementConstants.DESCRIPTION);
177	}	192	}
178		193
179	if (description == null)	194	if (description == null)

Lines 11-16 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationPresentationManager.java (-36 / +97 lines)
11	package org.eclipse.debug.internal.ui.launchConfigurations;	11	package org.eclipse.debug.internal.ui.launchConfigurations;
12		12
13		13
		14	import java.util.ArrayList;
14	import java.util.Hashtable;	15	import java.util.Hashtable;
15	import java.util.Iterator;	16	import java.util.Iterator;
16	import java.util.Map;	17	import java.util.Map;
Lines 22-31 Link Here
22	import org.eclipse.core.runtime.IStatus;	23	import org.eclipse.core.runtime.IStatus;
23	import org.eclipse.core.runtime.Platform;	24	import org.eclipse.core.runtime.Platform;
24	import org.eclipse.core.runtime.Status;	25	import org.eclipse.core.runtime.Status;
25	import org.eclipse.debug.core.DebugPlugin;
26	import org.eclipse.debug.core.ILaunchConfigurationType;	26	import org.eclipse.debug.core.ILaunchConfigurationType;
		27	import org.eclipse.debug.internal.core.ConfigurationElementConstants;
27	import org.eclipse.debug.internal.ui.DebugUIPlugin;	28	import org.eclipse.debug.internal.ui.DebugUIPlugin;
		29	import org.eclipse.debug.internal.ui.LaunchConfigurationTabExtension;
28	import org.eclipse.debug.ui.IDebugUIConstants;	30	import org.eclipse.debug.ui.IDebugUIConstants;
		31	import org.eclipse.debug.ui.ILaunchConfigurationTab;
29	import org.eclipse.debug.ui.ILaunchConfigurationTabGroup;	32	import org.eclipse.debug.ui.ILaunchConfigurationTabGroup;
30		33
31	import com.ibm.icu.text.MessageFormat;	34	import com.ibm.icu.text.MessageFormat;
Lines 49-54 Link Here
49	* used to represent the default tab group (i.e. unspecified mode).	52	* used to represent the default tab group (i.e. unspecified mode).
50	*/	53	*/
51	private Hashtable fTabGroupExtensions;	54	private Hashtable fTabGroupExtensions;
		55
		56	/**
		57	* contributed tabs are stored by the tab group id that they contribute to.
		58	* each entry is a futher <code>Hashtable</code> consisting of the corrseponding
		59	* <code>LaunchConfigurationTabExtension</code> objects for each contributed tab stored by their
		60	* id
		61	*
		62	* @since 3.3
		63	*/
		64	private Hashtable fContributedTabs;
52		65
53	/**	66	/**
54	* Constructs the singleton launch configuration presentation	67	* Constructs the singleton launch configuration presentation
Lines 57-62 Link Here
57	private LaunchConfigurationPresentationManager() {	70	private LaunchConfigurationPresentationManager() {
58	fgDefault = this;	71	fgDefault = this;
59	initializeTabGroupExtensions();	72	initializeTabGroupExtensions();
		73	initializeContributedTabExtensions();
60	}	74	}
61		75
62	/**	76	/**
Lines 75-126 Link Here
75	*/	89	*/
76	private void initializeTabGroupExtensions() {	90	private void initializeTabGroupExtensions() {
77	fTabGroupExtensions = new Hashtable();	91	fTabGroupExtensions = new Hashtable();
78	IExtensionPoint extensionPoint= Platform.getExtensionRegistry().getExtensionPoint(DebugUIPlugin.getUniqueIdentifier(), IDebugUIConstants.EXTENSION_POINT_LAUNCH_CONFIGURATION_TAB_GROUPS);	92	IExtensionPoint extensionPoint = Platform.getExtensionRegistry().getExtensionPoint(DebugUIPlugin.getUniqueIdentifier(), IDebugUIConstants.EXTENSION_POINT_LAUNCH_CONFIGURATION_TAB_GROUPS);
79	IConfigurationElement[] groups = extensionPoint.getConfigurationElements();	93	IConfigurationElement[] groups = extensionPoint.getConfigurationElements();
		94	LaunchConfigurationTabGroupExtension group = null;
		95	String typeId = null;
		96	Map map = null;
		97	Set modes = null;
80	for (int i = 0; i < groups.length; i++) {	98	for (int i = 0; i < groups.length; i++) {
81	LaunchConfigurationTabGroupExtension group = new LaunchConfigurationTabGroupExtension(groups[i]);	99	group = new LaunchConfigurationTabGroupExtension(groups[i]);
82	String typeId = group.getTypeIdentifier();	100	typeId = group.getTypeIdentifier();
83	if (typeId == null) {	101	map = (Map)fTabGroupExtensions.get(typeId);
84	IStatus status = new Status(IStatus.ERROR, IDebugUIConstants.PLUGIN_ID, IDebugUIConstants.STATUS_INVALID_EXTENSION_DEFINITION,	102	if (map == null) {
85	MessageFormat.format("Launch configuration tab group extension {0} does not specify launch configuration type.", (new String[] {groups[i].getAttribute("id")})), null); //$NON-NLS-1$ //$NON-NLS-2$	103	map = new Hashtable();
86	DebugUIPlugin.log(status);	104	fTabGroupExtensions.put(typeId, map);
87	} else {
88	// verify it references a valid launch configuration type
89	ILaunchConfigurationType lct = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurationType(typeId);
90	if (lct == null) {
91	IStatus status = new Status(IStatus.ERROR, IDebugUIConstants.PLUGIN_ID, IDebugUIConstants.STATUS_INVALID_EXTENSION_DEFINITION,
92	MessageFormat.format("Launch configuration tab group extension {0} refers to non-existent launch configuration type {1}.", (new String[] {groups[i].getAttribute("id"), typeId})), null); //$NON-NLS-1$ //$NON-NLS-2$
93	DebugUIPlugin.log(status);
94	}
95	}	105	}
96	if (typeId != null) {	106	modes = group.getModes();
97	// get the map for the config type	107	if (modes == null) {
98	Map map = (Map)fTabGroupExtensions.get(typeId);	108	// default tabs - store with "*"
99	if (map == null) {	109	map.put("*", group); //$NON-NLS-1$
100	map = new Hashtable();	110	} else {
101	fTabGroupExtensions.put(typeId, map);	111	// store per mode
102	}	112	Iterator iterator = modes.iterator();
103	Set modes = group.getModes();	113	while (iterator.hasNext()) {
104	if (modes == null) {	114	map.put(iterator.next(), group);
105	// default tabs - store with "*"
106	map.put("*", group); //$NON-NLS-1$
107	} else {
108	// store per mode
109	Iterator iterator = modes.iterator();
110	while (iterator.hasNext()) {
111	map.put(iterator.next(), group);
112	}
113	}	115	}
114	}	116	}
115	}	117	}
116	}	118	}
117		119
118	/**	120	/**
		121	* This method is used to collect all of the contributed tabs defined by the <code>launchConfigurationTabs</code>
		122	* extension point
		123	* <p>
		124	* <strong>EXPERIMENTAL</strong>. This method has been added as
		125	* part of a work in progress. There is no guarantee that this API will
		126	* remain unchanged during the 3.3 release cycle. Please do not use this API
		127	* without consulting with the Platform/Debug team.
		128	* </p>
		129	* @since 3.3
		130	*/
		131	private void initializeContributedTabExtensions() {
		132	fContributedTabs = new Hashtable();
		133	IExtensionPoint epoint = Platform.getExtensionRegistry().getExtensionPoint(DebugUIPlugin.getUniqueIdentifier(), IDebugUIConstants.EXTENSION_POINT_CONTRIBUTED_LAUNCH_TABS);
		134	IConfigurationElement[] elements = epoint.getConfigurationElements();
		135	LaunchConfigurationTabExtension tab = null;
		136	Hashtable element = null;
		137	for(int i = 0; i < elements.length; i++) {
		138	tab = new LaunchConfigurationTabExtension(elements[i]);
		139	element = (Hashtable) fContributedTabs.get(tab.getTabGroupId());
		140	if(element == null) {
		141	element = new Hashtable();
		142	element.put(tab.getIdentifier(), tab);
		143	fContributedTabs.put(tab.getTabGroupId(), element);
		144	}
		145	element.put(tab.getIdentifier(), tab);
		146	}
		147	}
		148
		149	/**
119	* Returns the tab group for the given launch configuration type and mode.	150	* Returns the tab group for the given launch configuration type and mode.
120	*	151	*
121	* @param type launch configuration type	152	* @param type launch configuration type
122	* @param mode launch mode	153	* @param mode launch mode
123	* @return the tab group for the given type of launch configuration	154	* @return the tab group for the given type of launch configuration, or <code>null</code> if none
124	* @exception CoreException if an exception occurs creating the group	155	* @exception CoreException if an exception occurs creating the group
125	*/	156	*/
126	public ILaunchConfigurationTabGroup getTabGroup(ILaunchConfigurationType type, String mode) throws CoreException {	157	public ILaunchConfigurationTabGroup getTabGroup(ILaunchConfigurationType type, String mode) throws CoreException {
Lines 130-136 Link Here
130	MessageFormat.format(LaunchConfigurationsMessages.LaunchConfigurationPresentationManager_No_tab_group_defined_for_launch_configuration_type__0__3, (new String[] {type.getIdentifier()})), null);	161	MessageFormat.format(LaunchConfigurationsMessages.LaunchConfigurationPresentationManager_No_tab_group_defined_for_launch_configuration_type__0__3, (new String[] {type.getIdentifier()})), null);
131	throw new CoreException(status);	162	throw new CoreException(status);
132	}	163	}
133	return ext.newTabGroup();	164	return new LaunchConfigurationTabGroupWrapper(ext.newTabGroup(), ext.getIdentifier());
		165	}
		166
		167	/**
		168	* Returns the listing of <code>ILaunchConfigurationTab</code>s for the specified <code>ILaunchConfigurationTabGroup</code>.
		169	* If no tabs are found for the specified id an empty array is returned, never <code>null</code>
		170	* @param groupid
		171	* @return the <code>ILaunchConfigurationTab</code>s for the specified <code>ILaunchConfigurationTabGroup</code> id,
		172	* or an empty array if none are found
		173	*
		174	* <p>
		175	* <strong>EXPERIMENTAL</strong>. This method has been added as
		176	* part of a work in progress. There is no guarantee that this API will
		177	* remain unchanged during the 3.3 release cycle. Please do not use this API
		178	* without consulting with the Platform/Debug team.
		179	* </p>
		180	* @since 3.3
		181	*/
		182	public ILaunchConfigurationTab[] createContributedTabs(String groupid) {
		183	Hashtable tabs = (Hashtable) fContributedTabs.get(groupid);
		184	ArrayList list = new ArrayList();
		185	if(tabs != null) {
		186	LaunchConfigurationTabExtension ext = null;
		187	for(Iterator iter = tabs.keySet().iterator(); iter.hasNext();) {
		188	ext = (LaunchConfigurationTabExtension) tabs.get(iter.next());
		189	if(ext != null) {
		190	list.add(ext.getTab());
		191	}
		192	}
		193	}
		194	return (ILaunchConfigurationTab[]) list.toArray(new ILaunchConfigurationTab[list.size()]);
134	}	195	}
135		196
136	/**	197	/**
Lines 187-193 Link Here
187	*/	248	*/
188	public String getDescription(ILaunchConfigurationType configType, String mode) {	249	public String getDescription(ILaunchConfigurationType configType, String mode) {
189	LaunchConfigurationPresentationManager manager = LaunchConfigurationPresentationManager.getDefault();	250	LaunchConfigurationPresentationManager manager = LaunchConfigurationPresentationManager.getDefault();
190	LaunchConfigurationTabGroupExtension extension = manager.getExtension(configType.getAttribute("id"), mode); //$NON-NLS-1$	251	LaunchConfigurationTabGroupExtension extension = manager.getExtension(configType.getAttribute(ConfigurationElementConstants.ID), mode);
191	return (extension != null ? extension.getDescription(mode) : null);	252	return (extension != null ? extension.getDescription(mode) : null);
192	}	253	}
193		254

Lines 27-38 Link Here

(-)ui/org/eclipse/debug/internal/ui/actions/breakpoints/ToggleBreakpointObjectActionDelegate.java (-6 / +3 lines)
27	/**	27	/**
28	* A toggle breakpoint action that can be contributed to an object. The action	28	* A toggle breakpoint action that can be contributed to an object. The action
29	* will perform a toggle breakpoint operation for a selected object.	29	* will perform a toggle breakpoint operation for a selected object.
30	* <p>	30	*
31	* EXPERIMENTAL	31	* <p>Clients may subclass this class.</p>
32	* </p>	32	*
33	* <p>
34	* Clients may subclass this class.
35	* </p>
36	* @since 3.0	33	* @since 3.0
37	*/	34	*/
38	public abstract class ToggleBreakpointObjectActionDelegate implements IObjectActionDelegate, IActionDelegate2 {	35	public abstract class ToggleBreakpointObjectActionDelegate implements IObjectActionDelegate, IActionDelegate2 {

Lines 2-16 Link Here

(-)schema/launchConfigurationTypeImages.exsd (-31 / +39 lines)
2	<!-- Schema file written by PDE -->	2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.debug.ui">	3	<schema targetNamespace="org.eclipse.debug.ui">
4	<annotation>	4	<annotation>
5	<appInfo>	5	<appInfo>
6	<meta.schema plugin="org.eclipse.debug.ui" id="launchConfigurationTypeImages" name="Launch Configuration Type Images"/>	6	<meta.schema plugin="org.eclipse.debug.ui" id="launchConfigurationTypeImages" name="Launch Configuration Type Images"/>
7	</appInfo>	7	</appInfo>
8	<documentation>	8	<documentation>
9	This extension point provides a way to associate an image with a launch configuration type.	9	This extension point provides a way to associate an image with a launch configuration type.
10	</documentation>	10
11	</annotation>	11	<p>
		12	<strong>EXPERIMENTAL</strong>. This extension point has been deprecated as
		13	part of a work in progress. There is no guarantee that this API will
		14	remain unchanged during the 3.3 release cycle. Please do not use this API
		15	without consulting with the Platform/Debug team.
		16	</p>
		17	</documentation>
		18	</annotation>
12		19
13	<element name="extension">	20	<element name="extension">
		21	<annotation>
		22	<appInfo>
		23	<meta.element deprecated="true"/>
		24	</appInfo>
		25	<documentation>
		26	<p>In 3.3, the image for a launch configuration type should be provided via the icon attribute in the <code>launchConfigurationTypes</code> extension point.</p>
		27	</documentation>
		28	</annotation>
14	<complexType>	29	<complexType>
15	<sequence>	30	<sequence>
16	<element ref="launchConfigurationTypeImage" minOccurs="0" maxOccurs="unbounded"/>	31	<element ref="launchConfigurationTypeImage" minOccurs="0" maxOccurs="unbounded"/>
Lines 22-45 Link Here
22	</documentation>	37	</documentation>
23	</annotation>	38	</annotation>
24	</attribute>	39	</attribute>
25	<attribute name="id" type="string">
26	<annotation>
27	<documentation>
28	an optional identifier of the extension instance
29	</documentation>
30	</annotation>
31	</attribute>
32	<attribute name="name" type="string">
33	<annotation>
34	<documentation>
35	an optional name of the extension instance
36	</documentation>
37	</annotation>
38	</attribute>
39	</complexType>	40	</complexType>
40	</element>	41	</element>
41		42
42	<element name="launchConfigurationTypeImage">	43	<element name="launchConfigurationTypeImage">
		44	<annotation>
		45	<documentation>
		46	<p>In 3.3, if possible, the image for a launch configuration type should be moved to the launch configuration type extension contribution</p>
		47	</documentation>
		48	</annotation>
43	<complexType>	49	<complexType>
44	<attribute name="id" type="string" use="required">	50	<attribute name="id" type="string" use="required">
45	<annotation>	51	<annotation>
Lines 51-57 Link Here
51	<attribute name="configTypeID" type="string" use="required">	57	<attribute name="configTypeID" type="string" use="required">
52	<annotation>	58	<annotation>
53	<documentation>	59	<documentation>
54	specifies the fully qualified ID of a launch configuration type.(in 2.1, this attribute can also be specified using the "type" attribute, to be consistent with the launchConfigurationTabGroups extension point).	60	specifies the fully qualified ID of a launch configuration type.(in 2.1, this attribute can also be specified using the "type" attribute, to be consistent with the launchConfigurationTabGroups extension point).
55	</documentation>	61	</documentation>
56	</annotation>	62	</annotation>
57	</attribute>	63	</attribute>
Lines 59-64 Link Here
59	<annotation>	65	<annotation>
60	<documentation>	66	<documentation>
61	specifies the plugin-relative path of an image file.	67	specifies the plugin-relative path of an image file.
		68
		69	<br><b>To supply an image to the specified launch configuration type, it should be done in the launch configuration type definition.</b>
62	</documentation>	70	</documentation>
63	<appInfo>	71	<appInfo>
64	<meta.attribute kind="resource"/>	72	<meta.attribute kind="resource"/>
Lines 77-100 Link Here
77		85
78	<p>	86	<p>
79	<pre>	87	<pre>
80	<extension point="org.eclipse.debug.ui.launchConfigurationTypeImages">	88	<extension point="org.eclipse.debug.ui.launchConfigurationTypeImages">
81	<launchConfigurationTypeImage	89	<launchConfigurationTypeImage
82	id="com.example.FirstLaunchConfigurationTypeImage"	90	id="com.example.FirstLaunchConfigurationTypeImage"
83	configTypeID="com.example.FirstLaunchConfigurationType"	91	configTypeID="com.example.FirstLaunchConfigurationType"
84	icon="icons/FirstLaunchConfigurationType.gif">	92	icon="icons/FirstLaunchConfigurationType.gif">
85	</launchConfigurationTypeImage>	93	</launchConfigurationTypeImage>
86	</extension>	94	</extension>
87	</pre>	95	</pre>
88	</p>	96	</p>
89	</documentation>	97	</documentation>
90	</annotation>	98	</annotation>
91		99
92	<annotation>	100	<annotation>
93	<appInfo>	101	<appInfo>
94	<meta.section type="copyright"/>	102	<meta.section type="copyright"/>
95	</appInfo>	103	</appInfo>
96	<documentation>	104	<documentation>
97	Copyright (c) 2000, 2005 IBM Corporation and others.<br>	105	Copyright (c) 2000, 2005 IBM Corporation and others.<br>
98	All rights reserved. This program and the accompanying materials are made	106	All rights reserved. This program and the accompanying materials are made
99	available under the terms of the Eclipse Public License v1.0 which	107	available under the terms of the Eclipse Public License v1.0 which
100	accompanies this distribution, and is available at	108	accompanies this distribution, and is available at

Added Link Here

(-)ui/org/eclipse/debug/internal/ui/LaunchConfigurationTabExtension.java (+79 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 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.debug.internal.ui;
12
13	import org.eclipse.core.runtime.CoreException;
14	import org.eclipse.core.runtime.IConfigurationElement;
15	import org.eclipse.debug.internal.core.ConfigurationElementConstants;
16	import org.eclipse.debug.ui.ILaunchConfigurationTabExtension;
17	import org.eclipse.debug.ui.ILaunchConfigurationTab;
18
19	/**
20	* Provides a proxy to a launchConfigurationTabs extension point
21	*
22	* <p>
23	* <strong>EXPERIMENTAL</strong>. This method has been added as
24	* part of a work in progress. There is no guarantee that this API will
25	* remain unchanged during the 3.3 release cycle. Please do not use this API
26	* without consulting with the Platform/Debug team.
27	* </p>
28	* @since 3.3
29	*/
30	public class LaunchConfigurationTabExtension implements ILaunchConfigurationTabExtension {
31
32	/**
33	* The configuration element backing this proxy
34	*/
35	IConfigurationElement fElement = null;
36
37	/**
38	* Constructor
39	* @param element the <code>IConfigurationElement</code> for this proxy
40	*/
41	public LaunchConfigurationTabExtension(IConfigurationElement element) {
42	fElement = element;
43	}
44
45	/* (non-Javadoc)
46	* @see org.eclipse.debug.ui.IContributedLaunchConfigurationTab#getIdentifier()
47	*/
48	public String getIdentifier() {
49	return fElement.getAttribute(ConfigurationElementConstants.ID);
50	}
51
52	/* (non-Javadoc)
53	* @see org.eclipse.debug.ui.IContributedLaunchConfigurationTab#getName()
54	*/
55	public String getName() {
56	return fElement.getAttribute(ConfigurationElementConstants.NAME);
57	}
58
59	/* (non-Javadoc)
60	* @see org.eclipse.debug.ui.IContributedLaunchConfigurationTab#getTab()
61	*/
62	public ILaunchConfigurationTab getTab() {
63	try {
64	Object object = fElement.createExecutableExtension(ConfigurationElementConstants.CLASS);
65	if(object instanceof ILaunchConfigurationTab) {
66	return (ILaunchConfigurationTab) object;
67	}
68	} catch (CoreException e) {DebugUIPlugin.log(e);}
69	return null;
70	}
71
72	/* (non-Javadoc)
73	* @see org.eclipse.debug.ui.IContributedLaunchConfigurationTab#getTabGroupId()
74	*/
75	public String getTabGroupId() {
76	return fElement.getAttribute(ConfigurationElementConstants.GROUP);
77	}
78
79	}

Added Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationTabGroupWrapper.java (+128 lines)
1	package org.eclipse.debug.internal.ui.launchConfigurations;
2
3	import org.eclipse.debug.core.ILaunch;
4	import org.eclipse.debug.core.ILaunchConfiguration;
5	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
6	import org.eclipse.debug.ui.ILaunchConfigurationDialog;
7	import org.eclipse.debug.ui.ILaunchConfigurationTab;
8	import org.eclipse.debug.ui.ILaunchConfigurationTabGroup;
9
10	/**
11	* This class is used to wrap a contributed <code>ILaunchConfigurationTabGroup</code> with any contributed tabs
12	* for that group (from a <code>launchConfigurationTabs</code> extension point).
13	*
14	* <p>
15	* <strong>EXPERIMENTAL</strong>. This class has been added as
16	* part of a work in progress. There is no guarantee that this API will
17	* remain unchanged during the 3.3 release cycle. Please do not use this API
18	* without consulting with the Platform/Debug team.
19	* </p>
20	* @since 3.3
21	*/
22	public class LaunchConfigurationTabGroupWrapper implements ILaunchConfigurationTabGroup {
23
24	private ILaunchConfigurationTabGroup fGroup = null;
25	private String fGroupId = null;
26	private ILaunchConfigurationTab[] fContributedTabs = null;
27
28	/**
29	* Constructor
30	* @param group the existing group to wrapper
31	*/
32	public LaunchConfigurationTabGroupWrapper(ILaunchConfigurationTabGroup group, String groupId) {
33	fGroup = group;
34	fGroupId = groupId;
35	}
36
37	/**
38	* @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#createTabs(org.eclipse.debug.ui.ILaunchConfigurationDialog, java.lang.String)
39	*/
40	public void createTabs(ILaunchConfigurationDialog dialog, String mode) {
41	if(fGroup != null) {
42	fGroup.createTabs(dialog, mode);
43	}
44	}
45
46	/**
47	* @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#dispose()
48	*/
49	public void dispose() {
50	if(fGroup != null) {
51	fGroup.dispose();
52	}
53	if(fContributedTabs != null) {
54	for(int i = 0; i < fContributedTabs.length; i++) {
55	fContributedTabs[i].dispose();
56	}
57	}
58	}
59
60	/**
61	* @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#getTabs()
62	*/
63	public ILaunchConfigurationTab[] getTabs() {
64	if(fContributedTabs == null) {
65	fContributedTabs = LaunchConfigurationPresentationManager.getDefault().createContributedTabs(fGroupId);
66	}
67	ILaunchConfigurationTab[] grouptabs = fGroup.getTabs();
68	ILaunchConfigurationTab[] tabs = new ILaunchConfigurationTab[grouptabs.length + fContributedTabs.length];
69	System.arraycopy(grouptabs, 0, tabs, 0, grouptabs.length);
70	System.arraycopy(fContributedTabs, 0, tabs, grouptabs.length, fContributedTabs.length);
71	return tabs;
72	}
73
74	/**
75	* @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#initializeFrom(org.eclipse.debug.core.ILaunchConfiguration)
76	*/
77	public void initializeFrom(ILaunchConfiguration configuration) {
78	if(fGroup != null) {
79	fGroup.initializeFrom(configuration);
80	}
81	if(fContributedTabs == null) {
82	getTabs();
83	}
84	for(int i = 0; i < fContributedTabs.length; i++) {
85	fContributedTabs[i].initializeFrom(configuration);
86	}
87	}
88
89	/**
90	* @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#launched(org.eclipse.debug.core.ILaunch)
91	*/
92	public void launched(ILaunch launch) {
93	if(fGroup != null) {
94	fGroup.launched(launch);
95	}
96	}
97
98	/**
99	* @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#performApply(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy)
100	*/
101	public void performApply(ILaunchConfigurationWorkingCopy configuration) {
102	if(fGroup != null) {
103	fGroup.performApply(configuration);
104	if(fContributedTabs == null) {
105	getTabs();
106	}
107	for(int i = 0; i < fContributedTabs.length; i++) {
108	fContributedTabs[i].performApply(configuration);
109	}
110	}
111	}
112
113	/**
114	* @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#setDefaults(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy)
115	*/
116	public void setDefaults(ILaunchConfigurationWorkingCopy configuration) {
117	if(fGroup != null) {
118	fGroup.setDefaults(configuration);
119	if(fContributedTabs == null) {
120	getTabs();
121	}
122	for(int i = 0; i < fContributedTabs.length; i++) {
123	fContributedTabs[i].setDefaults(configuration);
124	}
125	}
126	}
127
128	}

Added Link Here

(-)ui/org/eclipse/debug/ui/ILaunchConfigurationTabExtension.java (+50 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 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.debug.ui;
12
13	/**
14	* Describes a contributed launch configuration tab
15	*
16	* <p>
17	* <strong>EXPERIMENTAL</strong>. This method has been added as
18	* part of a work in progress. There is no guarantee that this API will
19	* remain unchanged during the 3.3 release cycle. Please do not use this API
20	* without consulting with the Platform/Debug team.
21	* </p>
22	* @since 3.3
23	*/
24	public interface ILaunchConfigurationTabExtension {
25
26	/**
27	* Returns the human readable name for the tab, not to be confused with the name that appears on the tab itself
28	* @return the name of the tab
29	*/
30	public String getName();
31
32	/**
33	* Returns the unique id ofthe tab
34	* @return the unique id of the tab
35	*/
36	public String getIdentifier();
37
38	/**
39	* Returns the unique id of the <code>ILaunchConfigurationTabGroup</code> that this tab contributes to
40	* @return the id of the <code>ILaunchConfigurationTabGroup</code> this tab conributes to
41	*/
42	public String getTabGroupId();
43
44	/**
45	* Returns the instantiated class of this tab
46	* @return the instantiated class of this tab
47	*/
48	public ILaunchConfigurationTab getTab();
49
50	}

Added Link Here

(-)schema/launchConfigurationTabs.exsd (+137 lines)
1	<?xml version='1.0' encoding='UTF-8'?>
2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.debug.ui">
4	<annotation>
5	<appInfo>
6	<meta.schema plugin="org.eclipse.debug.ui" id="launchConfigurationTabs" name="Launch Configuration Tabs"/>
7	</appInfo>
8	<documentation>
9	This extension point is used to allow developers to contribute launch configuration tabs (one or more) to an existing launch configuration tab group.
10
11
12	<p><strong>EXPERIMENTAL</strong>. This method has been added as
13	part of a work in progress. There is no guarantee that this API will
14	remain unchanged during the 3.3 release cycle. Please do not use this API
15	without consulting with the Platform/Debug team.</p>
16	</documentation>
17	</annotation>
18
19	<element name="extension">
20	<complexType>
21	<sequence minOccurs="1" maxOccurs="unbounded">
22	<element ref="tab"/>
23	</sequence>
24	<attribute name="point" type="string" use="required">
25	<annotation>
26	<documentation>
27
28	</documentation>
29	</annotation>
30	</attribute>
31	</complexType>
32	</element>
33
34	<element name="tab">
35	<annotation>
36	<documentation>
37	describes an individual launch configuration tab contribution
38	</documentation>
39	</annotation>
40	<complexType>
41	<attribute name="id" type="string" use="required">
42	<annotation>
43	<documentation>
44	the unique id of this contributed tab
45	</documentation>
46	</annotation>
47	</attribute>
48	<attribute name="group" type="string" use="required">
49	<annotation>
50	<documentation>
51	the string id of the <code>ILaunchConfigurationTabGroup</code> that this tab should be contributed to
52	</documentation>
53	</annotation>
54	</attribute>
55	<attribute name="name" type="string" use="required">
56	<annotation>
57	<documentation>
58	a human readable name for this tab. the prvided name does not have to be the name that you wish to appear on the tab itself. But it should sufficiently describe your tab.
59	</documentation>
60	</annotation>
61	</attribute>
62	<attribute name="class" type="string" use="required">
63	<annotation>
64	<documentation>
65	the implementation of your tab
66	</documentation>
67	<appInfo>
68	<meta.attribute kind="java" basedOn="org.eclipse.debug.ui.ILaunchConfigurationTab"/>
69	</appInfo>
70	</annotation>
71	</attribute>
72	</complexType>
73	</element>
74
75	<annotation>
76	<appInfo>
77	<meta.section type="since"/>
78	</appInfo>
79	<documentation>
80	Eclipse 3.3 M3
81	</documentation>
82	</annotation>
83
84	<annotation>
85	<appInfo>
86	<meta.section type="examples"/>
87	</appInfo>
88	<documentation>
89	The following example adds the tab "FooTab" to the local java application launch tab group.
90
91	<p>
92	<pre>
93	<extension point="org.eclipse.debug.ui.launchConfigurationTabs">
94	<tab
95	class="org.eclipse.jdt.debug.ui.launchConfigurations.FooTab"
96	group="org.eclipse.jdt.debug.ui.launchConfigurationTabGroup.localJavaApplication"
97	id="org.eclipse.jdt.debug.ui.fooTab"
98	name="Foo Tab">
99	</tab>
100	</extension>
101	</pre>
102	</p>
103	</documentation>
104	</annotation>
105
106	<annotation>
107	<appInfo>
108	<meta.section type="apiInfo"/>
109	</appInfo>
110	<documentation>
111	[Enter API information here.]
112	</documentation>
113	</annotation>
114
115	<annotation>
116	<appInfo>
117	<meta.section type="implementation"/>
118	</appInfo>
119	<documentation>
120	[Enter information about supplied implementation of this extension point.]
121	</documentation>
122	</annotation>
123
124	<annotation>
125	<appInfo>
126	<meta.section type="copyright"/>
127	</appInfo>
128	<documentation>
129	Copyright (c) 2006 IBM Corporation and others.<br>
130	All rights reserved. This program and the accompanying materials are made
131	available under the terms of the Eclipse Public License v1.0 which
132	accompanies this distribution, and is available at
133	<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
134	</documentation>
135	</annotation>
136
137	</schema>

Lines 16-21 Link Here

(-)core/org/eclipse/debug/core/ILaunchManager.java (-2 / +34 lines)
16	import org.eclipse.core.resources.IFile;	16	import org.eclipse.core.resources.IFile;
17	import org.eclipse.core.runtime.CoreException;	17	import org.eclipse.core.runtime.CoreException;
18	import org.eclipse.debug.core.model.IDebugTarget;	18	import org.eclipse.debug.core.model.IDebugTarget;
		19	import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;
19	import org.eclipse.debug.core.model.IPersistableSourceLocator;	20	import org.eclipse.debug.core.model.IPersistableSourceLocator;
20	import org.eclipse.debug.core.model.IProcess;	21	import org.eclipse.debug.core.model.IProcess;
21	import org.eclipse.debug.core.sourcelookup.ISourceContainerType;	22	import org.eclipse.debug.core.sourcelookup.ISourceContainerType;
Lines 229-235 Link Here
229	* @param optionId the unique id of the launch option	230	* @param optionId the unique id of the launch option
230	* @return the lauch option associated with ther specified id or <code>null</code> if not found	231	* @return the lauch option associated with ther specified id or <code>null</code> if not found
231	* <p>	232	* <p>
232	* <strong>EXPERIMENTAL</strong>. This ,method has been added as	233	* <strong>EXPERIMENTAL</strong>. This method has been added as
233	* part of a work in progress. There is no guarantee that this API will	234	* part of a work in progress. There is no guarantee that this API will
234	* remain unchanged during the 3.3 release cycle. Please do not use this API	235	* remain unchanged during the 3.3 release cycle. Please do not use this API
235	* without consulting with the Platform/Debug team.	236	* without consulting with the Platform/Debug team.
Lines 242-248 Link Here
242	* Returns all registered launch options	243	* Returns all registered launch options
243	* @return all registered launch options	244	* @return all registered launch options
244	* <p>	245	* <p>
245	* <strong>EXPERIMENTAL</strong>. This ,method has been added as	246	* <strong>EXPERIMENTAL</strong>. This method has been added as
246	* part of a work in progress. There is no guarantee that this API will	247	* part of a work in progress. There is no guarantee that this API will
247	* remain unchanged during the 3.3 release cycle. Please do not use this API	248	* remain unchanged during the 3.3 release cycle. Please do not use this API
248	* without consulting with the Platform/Debug team.	249	* without consulting with the Platform/Debug team.
Lines 252-257 Link Here
252	public ILaunchOption[] getLaunchOptions();	253	public ILaunchOption[] getLaunchOptions();
253		254
254	/**	255	/**
		256	* Returns all of the launch delegates. The rturned listing of delegates cannot be directly used to launch,
		257	* instead the method <code>IlaunchDelegate.getDelegate</code> must be used to acquire an executable form of
		258	* the delegate, allowing us to maintain lazy loading of the delegates themselves.
		259	* @return all of the launch delegates
		260	* @since 3.3
		261	* <p>
		262	* <strong>EXPERIMENTAL</strong>. This method has been added as
		263	* part of a work in progress. There is no guarantee that this API will
		264	* remain unchanged during the 3.3 release cycle. Please do not use this API
		265	* without consulting with the Platform/Debug team.
		266	* </p>
		267	*/
		268	public ILaunchDelegate[] getLaunchDelegates();
		269
		270	/** Returns the launch delegate that applies to the specified options
		271	* @param typeid the <code>ILaunchConfigurationType</code> id
		272	* @param the mode id
		273	* @param options the array of options to find the delegate for
		274	* @return the delegates that applie to the specified launch options for the specified mode and type id
		275	*
		276	* <p>
		277	* <strong>EXPERIMENTAL</strong>. This method has been added as
		278	* part of a work in progress. There is no guarantee that this API will
		279	* remain unchanged during the 3.3 release cycle. Please do not use this API
		280	* without consulting with the Platform/Debug team.
		281	* </p>
		282	* @since 3.3
		283	*/
		284	public ILaunchConfigurationDelegate[] getLaunchDelegates(String typeid, String mode, String[] options);
		285
		286	/**
255	* Returns a collection of launch configurations that required migration to be	287	* Returns a collection of launch configurations that required migration to be
256	* compatible with current tooling.	288	* compatible with current tooling.
257	*	289	*

Lines 126-135 Link Here

(-)core/org/eclipse/debug/core/ILaunchConfigurationType.java (+58 lines)
126	* @exception CoreException if unable to instantiate the	126	* @exception CoreException if unable to instantiate the
127	* delegate	127	* delegate
128	* @since 3.0	128	* @since 3.0
		129	* @deprecated we have introduced launch options in 3.3M3 and delegates can be acquired using the new
		130	* <code>getDelegate(String mode, String[] options)</code> version. If no options are desired or cared about passing <code>null</code>
		131	* works as though options are not considered at all.
		132	*
		133	* <p>
		134	* <strong>EXPERIMENTAL</strong>. This method has been added as
		135	* part of a work in progress. There is no guarantee that this API will
		136	* remain unchanged during the 3.3 release cycle. Please do not use this API
		137	* without consulting with the Platform/Debug team.
		138	* </p>
129	*/	139	*/
130	public ILaunchConfigurationDelegate getDelegate(String mode) throws CoreException;	140	public ILaunchConfigurationDelegate getDelegate(String mode) throws CoreException;
131		141
132	/**	142	/**
		143	* Returns the launch delegate for the specifed mode with the given options
		144	* @param mode the mode to get the delegate for
		145	* @param options the options that the delegate must support
		146	* @return the <code>ILaunchConfigurationDelegate</code> for the given mode and options, or <code>null</code> if the is not one
		147	* @throws CoreException
		148	* @since 3.3
		149	*
		150	* <p>
		151	* <strong>EXPERIMENTAL</strong>. This method has been added as
		152	* part of a work in progress. There is no guarantee that this API will
		153	* remain unchanged during the 3.3 release cycle. Please do not use this API
		154	* without consulting with the Platform/Debug team.
		155	* </p>
		156	*/
		157	public ILaunchConfigurationDelegate getDelegate(String mode, String[] options) throws CoreException;
		158
		159	/**
133	* Returns the unique identifier for this type of launch configuration	160	* Returns the unique identifier for this type of launch configuration
134	*	161	*
135	* @return the unique identifier for this type of launch configuration	162	* @return the unique identifier for this type of launch configuration
Lines 222-227 Link Here
222	* <code>DEBUG_MODE</code>.	249	* <code>DEBUG_MODE</code>.
223	* @return whether this kind of launch configuration supports the	250	* @return whether this kind of launch configuration supports the
224	* specified mode	251	* specified mode
		252	*
225	*/	253	*/
226	public boolean supportsMode(String mode);	254	public boolean supportsMode(String mode);
		255
		256	/**
		257	* Returns the simple name of the plugin that contributed this launch configuration type
		258	* @return the name of the contributor
		259	* @since 3.3
		260	*
		261	* <p>
		262	* <strong>EXPERIMENTAL</strong>. This method has been added as
		263	* part of a work in progress. There is no guarantee that this API will
		264	* remain unchanged during the 3.3 release cycle. Please do not use this API
		265	* without consulting with the Platform/Debug team.
		266	* </p>
		267	*/
		268	public String getContributorName();
		269
		270	/**
		271	* Returns the path of the image descriptor for this launch configuration type, which in turn
		272	* is used in <code>DebugPluginImages</code> to load the image registry with config images.
		273	* NOTE: the path could be only a fragment, and might require qualification via the bundle of the contributor.
		274	* @return the id of the image for this config type
		275	* @since 3.3
		276	*
		277	* <p>
		278	* <strong>EXPERIMENTAL</strong>. This method has been added as
		279	* part of a work in progress. There is no guarantee that this API will
		280	* remain unchanged during the 3.3 release cycle. Please do not use this API
		281	* without consulting with the Platform/Debug team.
		282	* </p>
		283	*/
		284	public String getImageDescriptorPath();
227	}	285	}

Removed Link Here

(-)core/org/eclipse/debug/internal/core/ContributedDelegate.java (-145 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 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.debug.internal.core;
12
13	import com.ibm.icu.text.MessageFormat;
14	import java.util.HashSet;
15	import java.util.Set;
16	import org.eclipse.core.runtime.CoreException;
17	import org.eclipse.core.runtime.IConfigurationElement;
18	import org.eclipse.core.runtime.IStatus;
19	import org.eclipse.core.runtime.Status;
20	import org.eclipse.debug.core.DebugPlugin;
21	import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;
22
23	/**
24	* A placeholder for a launch delegate contributed for a launch mode for an
25	* existing launch configuration type.
26	*/
27	public class ContributedDelegate {
28
29	/**
30	* The configuration element of the extension.
31	*/
32	private IConfigurationElement fElement;
33
34	/**
35	* Modes this delegate supports.
36	*/
37	private Set fModes;
38
39	/**
40	* Delegate, or <code>null</code> if not yet instantiated.
41	*/
42	private ILaunchConfigurationDelegate fDelegate;
43
44	/**
45	* Constructs a new contributed delegate on the
46	* given configuration element.
47	*
48	* @param element configuration element
49	*/
50	protected ContributedDelegate(IConfigurationElement element) {
51	setConfigurationElement(element);
52	}
53
54	/**
55	* Sets this delegate's configuration element.
56	*
57	* @param element this delegate's configuration element
58	*/
59	private void setConfigurationElement(IConfigurationElement element) {
60	fElement = element;
61	}
62
63	/**
64	* Returns this delegate's configuration element.
65	*
66	* @return this delegate's configuration element
67	*/
68	protected IConfigurationElement getConfigurationElement() {
69	return fElement;
70	}
71
72	/**
73	* Returns the set of modes specified in the configuration data.
74	*
75	* @return the set of modes specified in the configuration data
76	*/
77	protected Set getModes() {
78	if (fModes == null) {
79	String modes= getConfigurationElement().getAttribute("modes"); //$NON-NLS-1$
80	if (modes == null) {
81	return new HashSet(0);
82	}
83	String[] strings = modes.split(","); //$NON-NLS-1$
84	fModes = new HashSet(3);
85	for (int i = 0; i < strings.length; i++) {
86	String string = strings[i];
87	fModes.add(string.trim());
88	}
89	}
90	return fModes;
91	}
92
93	/**
94	* Returns the type identifier of launch configuration type this delegate is
95	* contributed to.
96	*/
97	protected String getLaunchConfigurationType() {
98	return getConfigurationElement().getAttribute("type"); //$NON-NLS-1$
99	}
100
101	protected ILaunchConfigurationDelegate getDelegate() throws CoreException {
102	if (fDelegate == null) {
103	Object object = getConfigurationElement().createExecutableExtension("delegate"); //$NON-NLS-1$
104	if (object instanceof ILaunchConfigurationDelegate) {
105	fDelegate = (ILaunchConfigurationDelegate)object;
106	} else {
107	throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, MessageFormat.format(DebugCoreMessages.LaunchConfigurationType_Launch_delegate_for__0__does_not_implement_required_interface_ILaunchConfigurationDelegate__1, new String[]{getIdentifier()}), null));
108	}
109	}
110	return fDelegate;
111	}
112
113	/**
114	* Returns the identifier of this extension point.
115	*/
116	protected String getIdentifier() {
117	return getConfigurationElement().getAttribute("id"); //$NON-NLS-1$
118	}
119
120	/**
121	* Returns the source path computer id specified by this launch delegate
122	* or <code>null</code> if none.
123	*
124	* @return the source path computer id specified by this launch delegate
125	* or <code>null</code> if none
126	*
127	* @since 3.1
128	*/
129	protected String getSourcePathComputerId() {
130	return getConfigurationElement().getAttribute("sourcePathComputerId"); //$NON-NLS-1$
131	}
132
133	/**
134	* Returns the source locater id specified by this launch delegate
135	* or <code>null</code> if none.
136	*
137	* @return the source locater id specified by this launch delegate
138	* or <code>null</code> if none
139	*
140	* @since 3.1
141	*/
142	protected String getSourceLocaterId() {
143	return getConfigurationElement().getAttribute("sourceLocatorId"); //$NON-NLS-1$
144	}
145	}

Lines 60-81 Link Here

(-)schema/launchConfigurationTypes.exsd (-3 / +52 lines)
60	</documentation>	60	</documentation>
61	</annotation>	61	</annotation>
62	</attribute>	62	</attribute>
63	<attribute name="delegate" type="string" use="required">	63	<attribute name="delegate" type="string">
64	<annotation>	64	<annotation>
65	<documentation>	65	<documentation>
66	specifies the fully qualified name of the Java class that implements <code>ILaunchConfigurationDelegate</code>.	66	specifies the fully qualified name of the Java class that implements <code>ILaunchConfigurationDelegate</code>.
67	Launch configuration instances of this type will delegate to instances of this class to perform launching.	67	Launch configuration instances of this type will delegate to instances of this class to perform launching.
		68
		69	With new API changes for 3.3M3 the delegate should be contributed via the <code>launchDelegates</code> extension point
		70	<p>
		71	<strong>EXPERIMENTAL</strong>. This attribute has been deprecated as
		72	part of a work in progress. There is no guarantee that this API will
		73	remain unchanged during the 3.3 release cycle. Please do not use this API
		74	without consulting with the Platform/Debug team.
		75	</p>
68	</documentation>	76	</documentation>
69	<appInfo>	77	<appInfo>
70	<meta.attribute kind="java" basedOn="org.eclipse.debug.core.model.ILaunchConfigurationDelegate"/>	78	<meta.attribute kind="java" basedOn="org.eclipse.debug.core.model.ILaunchConfigurationDelegate" deprecated="true"/>
71	</appInfo>	79	</appInfo>
72	</annotation>	80	</annotation>
73	</attribute>	81	</attribute>
74	<attribute name="modes" type="string" use="required">	82	<attribute name="modes" type="string">
75	<annotation>	83	<annotation>
76	<documentation>	84	<documentation>
77	specifies a comma-separated list of the modes this type of lauch configuration supports - "run" and/or "debug".	85	specifies a comma-separated list of the modes this type of lauch configuration supports - "run" and/or "debug".
		86
		87	With new API changes for 3.3M3 the delegate should be contributed via the <code>launchDelegates</code> extension point
		88
		89	<p>
		90	<strong>EXPERIMENTAL</strong>. This attribute has been deprecated as
		91	part of a work in progress. There is no guarantee that this API will
		92	remain unchanged during the 3.3 release cycle. Please do not use this API
		93	without consulting with the Platform/Debug team.
		94	</p>
78	</documentation>	95	</documentation>
		96	<appInfo>
		97	<meta.attribute deprecated="true"/>
		98	</appInfo>
79	</annotation>	99	</annotation>
80	</attribute>	100	</attribute>
81	<attribute name="name" type="string" use="required">	101	<attribute name="name" type="string" use="required">
Lines 106-119 Link Here
106	<annotation>	126	<annotation>
107	<documentation>	127	<documentation>
108	The unique identifier of a sourcePathComputer extension that is used to compute a default source lookup path for launch configurations of this type. This atttribute was added in the 3.0 release.	128	The unique identifier of a sourcePathComputer extension that is used to compute a default source lookup path for launch configurations of this type. This atttribute was added in the 3.0 release.
		129
		130	With new API changes for 3.3M3 the delegate should be contributed via the <code>launchDelegates</code> extension point
109	</documentation>	131	</documentation>
		132	<appInfo>
		133	<meta.attribute deprecated="true"/>
		134	</appInfo>
110	</annotation>	135	</annotation>
111	</attribute>	136	</attribute>
112	<attribute name="sourceLocatorId" type="string">	137	<attribute name="sourceLocatorId" type="string">
113	<annotation>	138	<annotation>
114	<documentation>	139	<documentation>
115	The unique identifier of a sourceLocator extension that is used to create the source locator for sessions launched using launch configurations of this type. This atttribute was added in the 3.0 release.	140	The unique identifier of a sourceLocator extension that is used to create the source locator for sessions launched using launch configurations of this type. This atttribute was added in the 3.0 release.
		141
		142	With new API changes for 3.3M3 the delegate should be contributed via the <code>launchDelegates</code> extension point
116	</documentation>	143	</documentation>
		144	<appInfo>
		145	<meta.attribute deprecated="true"/>
		146	</appInfo>
117	</annotation>	147	</annotation>
118	</attribute>	148	</attribute>
119	<attribute name="migrationDelegate" type="string">	149	<attribute name="migrationDelegate" type="string">
Lines 126-131 Link Here
126	</appInfo>	156	</appInfo>
127	</annotation>	157	</annotation>
128	</attribute>	158	</attribute>
		159	<attribute name="icon" type="string">
		160	<annotation>
		161	<documentation>
		162	The id of the icon for this launch configuraiton type.
		163
		164	since 3.3
		165
		166	<p>
		167	<strong>EXPERIMENTAL</strong>. This element has been added as
		168	part of a work in progress. There is no guarantee that this API will
		169	remain unchanged during the 3.3 release cycle. Please do not use this API
		170	without consulting with the Platform/Debug team.
		171	</p>
		172	</documentation>
		173	<appInfo>
		174	<meta.attribute kind="resource"/>
		175	</appInfo>
		176	</annotation>
		177	</attribute>
129	</complexType>	178	</complexType>
130	</element>	179	</element>
131		180

Lines 1-155 Link Here

(-)schema/launchDelegates.exsd (-155 / +207 lines)
1	<?xml version='1.0' encoding='UTF-8'?>	1	<?xml version='1.0' encoding='UTF-8'?>
2	<!-- Schema file written by PDE -->	2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.debug.core">	3	<schema targetNamespace="org.eclipse.debug.core">
4	<annotation>	4	<annotation>
5	<appInfo>	5	<appInfo>
6	<meta.schema plugin="org.eclipse.debug.core" id="launchDelegates" name="Launch Delegates"/>	6	<meta.schema plugin="org.eclipse.debug.core" id="launchDelegates" name="Launch Delegates"/>
7	</appInfo>	7	</appInfo>
8	<documentation>	8	<documentation>
9	This extension point provides a mechanism for contributing a launch delegate to an existing launch configuration type for one or more launch modes. Since launch modes are extensible, it may be neccessary to contribute additional launch delegates to an existing launch configuration type. Each launch delegate is contributed for a specific launch configuration type. A launch delegate supports one or more launch modes, and specifies a delegate responsible for the implementation of launching.	9	This extension point provides a mechanism for contributing a launch delegate to an existing launch configuration type for one or more launch modes. Since launch modes are extensible, it may be neccessary to contribute additional launch delegates to an existing launch configuration type. Each launch delegate is contributed for a specific launch configuration type. A launch delegate supports one or more launch modes, and specifies a delegate responsible for the implementation of launching.
10	</documentation>	10	</documentation>
11	</annotation>	11	</annotation>
12		12
13	<element name="extension">	13	<element name="extension">
14	<complexType>	14	<complexType>
15	<sequence>	15	<sequence>
16	<element ref="launchDelegate" minOccurs="1" maxOccurs="unbounded"/>	16	<element ref="launchDelegate" minOccurs="1" maxOccurs="unbounded"/>
17	</sequence>	17	</sequence>
18	<attribute name="point" type="string" use="required">	18	<attribute name="point" type="string" use="required">
19	<annotation>	19	<annotation>
20	<documentation>	20	<documentation>
21	a fully qualified identifier of the target extension point	21	a fully qualified identifier of the target extension point
22	</documentation>	22	</documentation>
23	</annotation>	23	</annotation>
24	</attribute>	24	</attribute>
25	<attribute name="id" type="string">	25	<attribute name="id" type="string">
26	<annotation>	26	<annotation>
27	<documentation>	27	<documentation>
28	an optional identifier of the extension instance	28	an optional identifier of the extension instance
29	</documentation>	29	</documentation>
30	</annotation>	30	</annotation>
31	</attribute>	31	</attribute>
32	<attribute name="name" type="string">	32	<attribute name="name" type="string">
33	<annotation>	33	<annotation>
34	<documentation>	34	<documentation>
35	an optional name of the extension instance	35	an optional name of the extension instance
36	</documentation>	36	</documentation>
37	</annotation>	37	</annotation>
38	</attribute>	38	</attribute>
39	</complexType>	39	</complexType>
40	</element>	40	</element>
41		41
42	<element name="launchDelegate">	42	<element name="launchDelegate">
43	<annotation>	43	<annotation>
44	<appInfo>	44	<appInfo>
45	<meta.element labelAttribute="name"/>	45	<meta.element labelAttribute="name"/>
46	</appInfo>	46	</appInfo>
47	</annotation>	47	</annotation>
48	<complexType>	48	<complexType>
49	<sequence>	49	<sequence minOccurs="0" maxOccurs="unbounded">
50	</sequence>	50	</sequence>
51	<attribute name="id" type="string" use="required">	51	<attribute name="id" type="string" use="required">
52	<annotation>	52	<annotation>
53	<documentation>	53	<documentation>
54	specifies a unique identifier for this launch delegate.	54	specifies a unique identifier for this launch delegate.
55	</documentation>	55	</documentation>
56	</annotation>	56	</annotation>
57	</attribute>	57	</attribute>
58	<attribute name="delegate" type="string" use="required">	58	<attribute name="name" type="string">
59	<annotation>	59	<annotation>
60	<documentation>	60	<documentation>
61	specifies the fully qualified name of the Java class that implements <code>ILaunchConfigurationDelegate</code>.	61	specifies a human readable name for this delegate
62	Launch configuration instances of this delegate's type will delegate to instances of this class to perform launching.	62
63	</documentation>	63	since 3.3M3
64	<appInfo>	64
65	<meta.attribute kind="java" basedOn="org.eclipse.debug.core.model.ILaunchConfigurationDelegate"/>	65	<p>
66	</appInfo>	66	<strong>EXPERIMENTAL</strong>. This attribute has been added as
67	</annotation>	67	part of a work in progress. There is no guarantee that this API will
68	</attribute>	68	remain unchanged during the 3.3 release cycle. Please do not use this API
69	<attribute name="modes" type="string" use="required">	69	without consulting with the Platform/Debug team.
70	<annotation>	70	</p>
71	<documentation>	71	</documentation>
72	specifies a comma-separated list of the modes this lauch delegate supports.	72	<appInfo>
73	</documentation>	73	<meta.attribute translatable="true"/>
74	</annotation>	74	</appInfo>
75	</attribute>	75	</annotation>
76	<attribute name="type" type="string" use="required">	76	</attribute>
77	<annotation>	77	<attribute name="delegate" type="string" use="required">
78	<documentation>	78	<annotation>
79	identifier of an existing launch configuration type that this launch delegate is capable of launching.	79	<documentation>
80	</documentation>	80	specifies the fully qualified name of the Java class that implements <code>ILaunchConfigurationDelegate</code>.
81	</annotation>	81	Launch configuration instances of this delegate's type will delegate to instances of this class to perform launching.
82	</attribute>	82	</documentation>
83	<attribute name="sourcePathComputerId" type="string">	83	<appInfo>
84	<annotation>	84	<meta.attribute kind="java" basedOn="org.eclipse.debug.core.model.ILaunchConfigurationDelegate"/>
85	<documentation>	85	</appInfo>
86	The unique identifier of a sourcePathComputer extension that is used to compute a default source lookup path for launch configurations of this type. Since 3.1, this attribute cab be specified in a launchDelegate extension when unspecified in the assocaited launchConfigurationType extension. Only one source path computer can be specified per launch configuration type.	86	</annotation>
87	</documentation>	87	</attribute>
88	</annotation>	88	<attribute name="modes" type="string">
89	</attribute>	89	<annotation>
90	<attribute name="sourceLocatorId" type="string">	90	<documentation>
91	<annotation>	91	specifies a comma-separated list of the modes this lauch delegate supports.
92	<documentation>	92	</documentation>
93	The unique identifier of a sourceLocator extension that is used to create the source locator for sessions launched using launch configurations of this type. Since 3.1, this attribute can be specified in a launchDelegate extension when unspecified in the assocaited launchConfigurationType extension. Only one source locater can be specified per launch configuration type.	93	</annotation>
94	</documentation>	94	</attribute>
95	</annotation>	95	<attribute name="type" type="string">
96	</attribute>	96	<annotation>
97	</complexType>	97	<documentation>
98	</element>	98	identifier of an existing launch configuration type that this launch delegate is capable of launching.
99		99	</documentation>
100	<annotation>	100	</annotation>
101	<appInfo>	101	</attribute>
102	<meta.section type="since"/>	102	<attribute name="sourcePathComputerId" type="string">
103	</appInfo>	103	<annotation>
104	<documentation>	104	<documentation>
105	3.0	105	The unique identifier of a sourcePathComputer extension that is used to compute a default source lookup path for launch configurations of this type. Since 3.1, this attribute cab be specified in a launchDelegate extension when unspecified in the assocaited launchConfigurationType extension. Only one source path computer can be specified per launch configuration type.
106	</documentation>	106	</documentation>
107	</annotation>	107	</annotation>
108		108	</attribute>
109	<annotation>	109	<attribute name="sourceLocatorId" type="string">
110	<appInfo>	110	<annotation>
111	<meta.section type="examples"/>	111	<documentation>
112	</appInfo>	112	The unique identifier of a sourceLocator extension that is used to create the source locator for sessions launched using launch configurations of this type. Since 3.1, this attribute can be specified in a launchDelegate extension when unspecified in the assocaited launchConfigurationType extension. Only one source locater can be specified per launch configuration type.
113	<documentation>	113	</documentation>
114	The following is an example of a launch delegate extension point:	114	</annotation>
115		115	</attribute>
116	<p>	116	<attribute name="options" type="string">
117	<pre>	117	<annotation>
118	<extension point="org.eclipse.debug.core.launchDelegates">	118	<documentation>
119	<launchDelegate	119	This attribute allows contributors to sepcify what options this delegate can apply to other than the specified modes
120	id="com.example.ExampleProfileDelegate"	120
121	delegate="com.example.ExampleProfileDelegate"	121	since 3.3M3
122	type="org.eclipse.jdt.launching.localJavaApplication"	122
123	modes="profile">	123	<p>
124	</launchDelegate>	124	<strong>EXPERIMENTAL</strong>. This attribute has been added as
125	</extension>	125	part of a work in progress. There is no guarantee that this API will
126	</pre>	126	remain unchanged during the 3.3 release cycle. Please do not use this API
127	</p>	127	without consulting with the Platform/Debug team.
128		128	</p>
129	In the example above, the specified launch delegate is contributed to launch Java applications in profile mode.	129	</documentation>
130	</documentation>	130	</annotation>
131	</annotation>	131	</attribute>
132		132	</complexType>
133	<annotation>	133	</element>
134	<appInfo>	134
135	<meta.section type="apiInfo"/>	135	<annotation>
136	</appInfo>	136	<appInfo>
137	<documentation>	137	<meta.section type="since"/>
138	Value of the attribute <b>delegate</b> must be a fully qualified name of a Java class that implements the interface <b>org.eclipse.debug.core.model.ILaunchConfigurationDelegate</b>.	138	</appInfo>
139	</documentation>	139	<documentation>
140	</annotation>	140	3.0
141		141	</documentation>
142	<annotation>	142	</annotation>
143	<appInfo>	143
144	<meta.section type="copyright"/>	144	<annotation>
145	</appInfo>	145	<appInfo>
146	<documentation>	146	<meta.section type="examples"/>
147	Copyright (c) 2000, 2005 IBM Corporation and others.<br>	147	</appInfo>
148	All rights reserved. This program and the accompanying materials are made	148	<documentation>
149	available under the terms of the Eclipse Public License v1.0 which	149	The following is an example of a launch delegate extension point:
150	accompanies this distribution, and is available at	150
151	<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>	151	<p>
152	</documentation>	152	<pre>
153	</annotation>	153	<extension point="org.eclipse.debug.core.launchDelegates">
154		154	<launchDelegate
155	</schema>	155	id="com.example.ExampleProfileDelegate"
		156	delegate="com.example.ExampleProfileDelegate"
		157	type="org.eclipse.jdt.launching.localJavaApplication"
		158	modes="profile">
		159	</launchDelegate>
		160	</extension>
		161	</pre>
		162	</p>
		163
		164	In the example above, the specified launch delegate is contributed to launch Java applications in profile mode.
		165
		166	The previous example has been deprecated as of 3.3M3, but left in for brevity. See the following example for new usage.
		167
		168	<p>
		169	<pre>
		170	<extension point="org.eclipse.debug.core.launchDelegates">
		171	<launchDelegate
		172	delegate="org.eclipse.jdt.launching.JavaLaunchDelegate"
		173	id="org.eclipse.jdt.launching.JavaLaunchDelegate"
		174	type="org.eclipse.jdt.launching.localJavaApplication"
		175	modes="profile">
		176	</launchDelegate>
		177	</extension>
		178	</pre>
		179	</p>
		180
		181	In 3.3 mode-based launching has been deprecated, and in its place we have provided launching with options. Options are contributed via the <code>launchOptions</code> extension point and can be referenced here to describe what options your launch delegate supports. Options are further arranged in the form of expressions that can be evaluated to determine suitablility of your delegate for a variety of combinations of options.
		182	</documentation>
		183	</annotation>
		184
		185	<annotation>
		186	<appInfo>
		187	<meta.section type="apiInfo"/>
		188	</appInfo>
		189	<documentation>
		190	Value of the attribute <b>delegate</b> must be a fully qualified name of a Java class that implements the interface <b>org.eclipse.debug.core.model.ILaunchConfigurationDelegate</b>.
		191	</documentation>
		192	</annotation>
		193
		194	<annotation>
		195	<appInfo>
		196	<meta.section type="copyright"/>
		197	</appInfo>
		198	<documentation>
		199	Copyright (c) 2000, 2005 IBM Corporation and others.<br>
		200	All rights reserved. This program and the accompanying materials are made
		201	available under the terms of the Eclipse Public License v1.0 which
		202	accompanies this distribution, and is available at
		203	<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
		204	</documentation>
		205	</annotation>
		206
		207	</schema>

Lines 1-134 Link Here

(-)schema/launchModes.exsd (-134 / +120 lines)
1	<?xml version='1.0' encoding='UTF-8'?>	1	<?xml version='1.0' encoding='UTF-8'?>
2	<!-- Schema file written by PDE -->	2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.debug.core">	3	<schema targetNamespace="org.eclipse.debug.core">
4	<annotation>	4	<annotation>
5	<appInfo>	5	<appInfo>
6	<meta.schema plugin="org.eclipse.debug.core" id="launchModes" name="Launch Modes"/>	6	<meta.schema plugin="org.eclipse.debug.core" id="launchModes" name="Launch Modes"/>
7	</appInfo>	7	</appInfo>
8	<documentation>	8	<documentation>
9	This extension point provides a mechanism for contributing launch modes to the debug platform. The debug platform defines modes for "run", "debug", and "profile".	9	This extension point provides a mechanism for contributing launch modes to the debug platform. The debug platform defines modes for "run", "debug", and "profile".
10	</documentation>	10	</documentation>
11	</annotation>	11	</annotation>
12		12
13	<element name="extension">	13	<element name="extension">
14	<complexType>	14	<complexType>
15	<sequence>	15	<sequence>
16	<element ref="launchMode" minOccurs="0" maxOccurs="unbounded"/>	16	<element ref="launchMode" minOccurs="0" maxOccurs="unbounded"/>
17	</sequence>	17	</sequence>
18	<attribute name="point" type="string" use="required">	18	<attribute name="point" type="string" use="required">
19	<annotation>	19	<annotation>
20	<documentation>	20	<documentation>
21	a fully qualified identifier of the target extension point	21	a fully qualified identifier of the target extension point
22	</documentation>	22	</documentation>
23	</annotation>	23	</annotation>
24	</attribute>	24	</attribute>
25	<attribute name="id" type="string">	25	</complexType>
26	<annotation>	26	</element>
27	<documentation>	27
28	an optional identifier of the extension instance	28	<element name="launchMode">
29	</documentation>	29	<annotation>
30	</annotation>	30	<appInfo>
31	</attribute>	31	<meta.element labelAttribute="name"/>
32	<attribute name="name" type="string">	32	</appInfo>
33	<annotation>	33	</annotation>
34	<documentation>	34	<complexType>
35	an optional name of the extension instance	35	<sequence>
36	</documentation>	36	</sequence>
37	</annotation>	37	<attribute name="mode" type="string" use="required">
38	</attribute>	38	<annotation>
39	</complexType>	39	<documentation>
40	</element>	40	specifies a unique identifier for this launch mode. The launch modes contributed by the debug plaform are "run", "debug", and "profile".
41		41	</documentation>
42	<element name="launchMode">	42	</annotation>
43	<annotation>	43	</attribute>
44	<appInfo>	44	<attribute name="label" type="string" use="required">
45	<meta.element labelAttribute="name"/>	45	<annotation>
46	</appInfo>	46	<documentation>
47	</annotation>	47	A human-readable label that describes the launch mode
48	<complexType>	48	</documentation>
49	<sequence>	49	<appInfo>
50	</sequence>	50	<meta.attribute translatable="true"/>
51	<attribute name="mode" type="string" use="required">	51	</appInfo>
52	<annotation>	52	</annotation>
53	<documentation>	53	</attribute>
54	specifies a unique identifier for this launch mode. The launch modes contributed by the debug plaform are "run", "debug", and "profile".	54	<attribute name="launchAsLabel" type="string">
55	</documentation>	55	<annotation>
56	</annotation>	56	<documentation>
57	</attribute>	57	A human-readable label to be used in a launch cascade menu. For example "Run As". This attribute was added in 3.2 to allow the label to be properly externalized. When unspecified, a default label is created via concatenation.
58	<attribute name="label" type="string" use="required">	58	</documentation>
59	<annotation>	59	<appInfo>
60	<documentation>	60	<meta.attribute translatable="true"/>
61	A human-readable label that describes the launch mode	61	</appInfo>
62	</documentation>	62	</annotation>
63	<appInfo>	63	</attribute>
64	<meta.attribute translatable="true"/>	64	</complexType>
65	</appInfo>	65	</element>
66	</annotation>	66
67	</attribute>	67	<annotation>
68	<attribute name="launchAsLabel" type="string">	68	<appInfo>
69	<annotation>	69	<meta.section type="since"/>
70	<documentation>	70	</appInfo>
71	A human-readable label to be used in a launch cascade menu. For example "Run As". This attribute was added in 3.2 to allow the label to be properly externalized. When unspecified, a default label is created via concatenation.	71	<documentation>
72	</documentation>	72	3.0
73	<appInfo>	73	</documentation>
74	<meta.attribute translatable="true"/>	74	</annotation>
75	</appInfo>	75
76	</annotation>	76	<annotation>
77	</attribute>	77	<appInfo>
78	</complexType>	78	<meta.section type="examples"/>
79	</element>	79	</appInfo>
80		80	<documentation>
81	<annotation>	81	The following is an example of a launch delegate extension point:
82	<appInfo>	82
83	<meta.section type="since"/>	83	<p>
84	</appInfo>	84	<pre>
85	<documentation>	85	<extension point="org.eclipse.debug.core.launchModes">
86	3.0	86	<launchMode
87	</documentation>	87	mode="profile"
88	</annotation>	88	label="Profile">
89		89	</launchMode>
90	<annotation>	90	</extension>
91	<appInfo>	91	</pre>
92	<meta.section type="examples"/>	92	</p>
93	</appInfo>	93
94	<documentation>	94	In the example above, the profile launch mode is contributed.
95	The following is an example of a launch delegate extension point:	95	</documentation>
96		96	</annotation>
97	<p>	97
98	<pre>	98	<annotation>
99	<extension point="org.eclipse.debug.core.launchModes">	99	<appInfo>
100	<launchMode	100	<meta.section type="apiInfo"/>
101	mode="profile"	101	</appInfo>
102	label="Profile">	102	<documentation>
103	</launchMode>	103
104	</extension>	104	</documentation>
105	</pre>	105	</annotation>
106	</p>	106
107		107	<annotation>
108	In the example above, the profile launch mode is contributed.	108	<appInfo>
109	</documentation>	109	<meta.section type="copyright"/>
110	</annotation>	110	</appInfo>
111		111	<documentation>
112	<annotation>	112	Copyright (c) 2000, 2005 IBM Corporation and others.<br>
113	<appInfo>	113	All rights reserved. This program and the accompanying materials are made
114	<meta.section type="apiInfo"/>	114	available under the terms of the Eclipse Public License v1.0 which
115	</appInfo>	115	accompanies this distribution, and is available at
116	<documentation>	116	<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
117		117	</documentation>
118	</documentation>	118	</annotation>
119	</annotation>	119
120		120	</schema>
121	<annotation>
122	<appInfo>
123	<meta.section type="copyright"/>
124	</appInfo>
125	<documentation>
126	Copyright (c) 2000, 2005 IBM Corporation and others.<br>
127	All rights reserved. This program and the accompanying materials are made
128	available under the terms of the Eclipse Public License v1.0 which
129	accompanies this distribution, and is available at
130	<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
131	</documentation>
132	</annotation>
133
134	</schema>

Lines 20-32 Link Here

(-)buildnotes_platform-debug.html (-5 / +36 lines)
20	<li>deprecated <code>IDebugUIConstants.ATTR_CONSOLE_ENCODING</code>.</li>	20	<li>deprecated <code>IDebugUIConstants.ATTR_CONSOLE_ENCODING</code>.</li>
21	<li>added <code>DebugUITools.getLastLaunch(String id)</code> - provides access to the last launch in	21	<li>added <code>DebugUITools.getLastLaunch(String id)</code> - provides access to the last launch in
22	each launch group.</li>	22	each launch group.</li>
23	<li>Add <code>launchOptions</code> schema -- provides a new mechanism for providing launch options to the launching framework</li>
24	<li>Added <code>ILaunchOption</code> -- which describes a single contributed launch option within the launch manager</li>
25	<li>Added <code>ILaunchManager.getLaunchOptions()</code> -- returns and array of all of the <code>ILaunchOptions</code> registered with the launch manager</li>
26	<li>Added <code>ILaunchManager.getLaunchOption(String id)</code> -- returns the <code>ILaunchOption</code> associated with the given unique id, or <code>null</code></li>
27	</ul>	23	</ul>
28		24
29	<h2>Oct 3, 2006</h2>	25	<h2>Summary of Launch Option conversion changes in 3.3</h2>
		26	<ul>
		27	<li>Added <code>launchOptions</code> schema -- provides a new mechanism for providing launch options to the launching framework</li>
		28	<li>Added interface/class <code>ILaunchOption</code> -- which describes a single contributed launch option within the launch manager</li>
		29	<li>Added method <code>ILaunchManager.getLaunchOptions()</code> -- returns and array of all of the <code>ILaunchOptions</code> registered with the launch manager</li>
		30	<li>Added method <code>ILaunchManager.getLaunchOption(String id)</code> -- returns the <code>ILaunchOption</code> associated with the given unique id, or <code>null</code></li>
		31	<li>Added interface/class <code>ILaunchOption</code> -- which describes a single contributed launch option within the launch manager</li>
		32	<li>Added method <code>ILaunchConfiguration.getOptions()</code> -- returns the comma seperated listiong of options</li>
		33	<li>Added method <code>ILaunchConfigurationWorkingCopy.setOptions(String[] options)</code> -- allows the options to be set in the launch configuration</li>
		34	<li>Added method <code>ILaunchManager.getLaunchDelegates()</code> -- returns all of the registered launch delegates</li>
		35	<li>Added method <code>ILaunchManager.getLaunchDelegates(String typeid, String mode, String[] options)</code> -- returns the
		36	list of delegates that apply to the the specifed mode, config type id and options (if any)</li>
		37	<li>Added constant <code>ATTR_LAUNCH_OPTIONS</code> to <code>LaunchConfiguration</code></li>
		38	<li>Added method <code>ILaunchConfigurationType.getContributorName()</code> -- returns the name of the contributor of the type</li>
		39	<li>Added method <code>ILaunchConfigurationType.getImageDescriptorPath()</code> -- returns the path of the image descriptor (if provided)</li>
		40	<li>Added method <code>ILaunchConfigurationType.getDelegate(String mode, String[] options)</code> -- returns the launch delegate for the specified mode and options</li>
		41	<li>Added class <code>ConfigurationElementConstants</code> -- contains common constants for getting child elements of <code>IConfigurationElements</code>
		42	<li>Added internal method <code>LaunchManager.initializeLaunchDelegates()</code> -- loads the listing of delegates</li>
		43	<li>Added internal method <code>LaunchManager.initializeLaunchOptions()</code> -- loads the listing of launch options</li>
		44	<li>Deprecated method <code>ILaunchConfigurationType.getDelegate(String mode)</code> -- in favour of the new <code>getDelegate(String mode, String[] options) method</code></li>
		45	<li>Deprecated attribute 'delegate' in <code>launchConfigurationTypes</code> schema, in favour of contributing delegates via the <code>launchDelegates</code> extension point</li>
		46	<li>Deprecated attribute 'modes' in <code>launchConfigurationTypes</code> schema, in favour of contributing modes via the <code>launchDelegates</code> extension point</li>
		47	<li>Deprecated attribute 'sourcePathComputerId' in <code>launchConfigurationTypes</code> schema, in favour of contributing it via the <code>launchDelegates</code> extension point</li>
		48	<li>Deprecated attribute 'sourceLocatorId' in <code>launchConfigurationTypes</code> schema, in favour of contributing it via the <code>launchDelegates</code> extension point</li>
		49	<li>Added attrbute 'icon' in <code>launchConfigurationTypes</code> schema, in favour of contributing a seperate extension <code>launchConfigurationTypeImages</code></li>
		50	<li>Added attribute 'name' to the <code>launchDelegates</code> schema, providing a human readable name for the delegate. To be used in duplicate resolution</li>
		51	<li>Added attribute 'options' to the <code>launchDelegates</code> schema, providing the ability to specify launch options that this delegate can support</li>
		52	<li>Added interface/class <code>ILaunchConfigurationTabExtension</code> -- provides a proxy to a contributed tab <code>IConfigurationElement</code> element</li>
		53	<li>Added internal method <code>LauncConfigurationPtresentationManager.initializeContributedTabExtensions</code> -- loads contributed tabs</li>
		54	<li>Added method <code>LaunchConfigurationPresentationManager.createContributedTabs(String groupid)</code> -- lazily creates the tabs for a specified tabgroup id</li>
		55	<li>Added constant <code>EXTENSION_POINT_CONTRIBUTED_LAUNCH_TABS</code> to <code>IDebugUIConstants</code></li>
		56	<li>Added class <code>LaunchConfigurationTabGroupWrapper</code> -- which is used to wrap an existing tab group with its contributed tabs</li>
		57	<li>Deprecated <code>launchConfigurationTypeImages</code> extension point</li>
		58	</ul>
		59
		60	h2>Oct 3, 2006</h2>
30	<h3>Problem Reports Fixed</h3>	61	<h3>Problem Reports Fixed</h3>
31	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=158760">158760</a>: Warning in latest nightly build and integration build<br>	62	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=158760">158760</a>: Warning in latest nightly build and integration build<br>
32		63

Added Link Here

(-)core/org/eclipse/debug/core/ILaunchDelegate.java (+97 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 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.debug.core;
12
13	import java.util.Set;
14
15	import org.eclipse.core.runtime.CoreException;
16	import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;
17
18	/**
19	* This interface describes a launch delegate
20	* Clients can contribute launch delegate through the <code>launchDelegates</code> extension point
21	*
22	* Example contribution of the local java launch delegate
23	* <pre>
24	* <launchDelegate
25	delegate="org.eclipse.jdt.launching.JavaLaunchDelegate"
26	id="org.eclipse.jdt.launching.JavaLaunchDelegate">
27	<appliesTo
28	type="org.eclipse.jdt.launching.localJavaApplication">
29	<option
30	option="debug">
31	</option>
32	</appliesTo>
33	</launchDelegate>
34	* </pre>
35	*
36	* Clients are NOT intended to implement this interface
37	* @since 3.3
38	*/
39	public interface ILaunchDelegate {
40
41	/**
42	* @return returns the unique id of the delegate
43	*/
44	public String getIdentifier();
45
46	/**
47	* @return the launch delegate
48	*/
49	public ILaunchConfigurationDelegate getDelegate() throws CoreException;
50
51	/**
52	* One delegate definition can now be associated with more than on launch configuration type.
53	* In this case we need to return them all. In the deprecated case when one delegate is associated
54	* with one type, we only need return the one (a set of only one element)
55	* @return the set of associated launch configuration type ids (String) or the empty set, never <code>null</code>
56	*/
57	public String getLaunchConfigurationType();
58
59	/**
60	* @return the associated source locator id or <code>null</code> if not provided
61	*/
62	public String getSourceLocatorId();
63
64	/**
65	* @return the associated source path computer id or <code>null</code> if not provided
66	*/
67	public String getSourcePathComputerId();
68
69	/**
70	* @return the options associated with this delegate. If no options are specified an empty set is
71	* returned, never <code>null</code>.
72	*/
73	public Set getOptions();
74
75	/**
76	* This method is provided as a backward compatibility measure to allow access to modes, if mode-based
77	* launching is still being used.
78	*
79	* @return a set of modes for this delegate or the empty set if none are found, never <code>null</code>.
80	*/
81	public Set getModes();
82
83	/**
84	* used to determine if the delegate applies to the specified launch configuration type via its id only (no expression evaluation is done)
85	* @param configtypeId the id of the <code>ILaunchConfigurationType</code>.
86	* @return true if the delegate applies to the associated config type, false otherwise
87	*/
88	public boolean appliesTo(String configtypeId);
89
90	/**
91	* used to determine if the delegate applies to the specified launch configuration type via its id and mode (no expression evaluation is done)
92	* @param configtypeId the id of the <code>ILaunchConfigurationType</code>.
93	* @param mode the mode
94	* @return true if the delegate applies to the associated config type, false otherwise
95	*/
96	public boolean appliesTo(String configtypeId, String mode);
97	}