Attachment #52144 for bug #157059

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

Lines 482-487 Link Here

(-)contexts_Debugger.xml (+5 lines)
482	<topic label="Running and Debugging" href="tasks/task-running_and_debugging.htm"/>	482	<topic label="Running and Debugging" href="tasks/task-running_and_debugging.htm"/>
483	<topic label="Creating a Java application launch configuration" href="tasks/tasks-java-local-configuration.htm"/>	483	<topic label="Creating a Java application launch configuration" href="tasks/tasks-java-local-configuration.htm"/>
484	</context>	484	</context>
		485	<context id="select_launch_options_dialog">
		486	<description>This dialog prompts users to select an available set of conbination of launch options in the event a plugin, no longer provided, has set launch options in the current launch configuration.</description>
		487	<topic label="Running and Debugging" href="tasks/task-running_and_debugging.htm"/>
		488	<topic label="Creating a Java application launch configuration" href="tasks/tasks-java-local-configuration.htm"/>
		489	</context>
485		490
486		491
487		492




	 * @since 3.2
	 */
	protected static final IStatus deleteAssociatedLaunchConfigs = new Status(IStatus.INFO, DEBUG_CORE, 225, EMPTY_STRING, null);
    
	
	
	/**

	 * @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 LaunchDelegate objects stored by id of delegate, or launch config type
	 * launch configuration types).
	 */
	private HashMap fLaunchDelegates = null;
	
	/**
	 * A map of duplicate delegates arranged by config type id
	 */
	private HashMap fDuplicateDelegates = null;

	/**
	 * Collection of launches

	/**
	 * Collection of listeners
	 */
	private ListenerList fListeners = new ListenerList();
	
	/**
	 * Collection of "plural" listeners.

	 * and values are associated configuration elements.
	 */
	private Map sourcePathComputers;

	/**
	 * @see ILaunchManager#addLaunch(ILaunch)
	 */

		}
		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)
	 */
	public ILaunchMode getLaunchMode(String mode) {

		return (ILaunchMode) fLaunchModes.get(mode);
	}
	
	/**
	 * @see org.eclipse.debug.core.ILaunchManager#getLaunchModes()
	 */
	public ILaunchMode[] getLaunchModes() {

		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) {
			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);
			}
		}
	}
	
	/**
	 * 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 LaunchDelegate[] getLaunchDelegates() {
		initializeLaunchDelegates();
		Collection col = fLaunchDelegates.values();
		return (LaunchDelegate[]) col.toArray(new LaunchDelegate[col.size()]);
	}
	
	/** Returns the launch delegates that applies to the specified options for the specified mode and type id
	 * @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 apply 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 LaunchDelegate[] getLaunchDelegates(String typeid, String mode, String[] options) {
		initializeLaunchDelegates();
		LaunchDelegate ld = null;
		boolean applies = true;
		ArrayList list = new ArrayList();
		Set doptions = null;
		for(Iterator iter = fLaunchDelegates.keySet().iterator(); iter.hasNext();) {
			ld = (LaunchDelegate) 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);
				}
				applies = true;
			}
		}
		return (LaunchDelegate[]) list.toArray(new LaunchDelegate[list.size()]);
	}
	
	/**
	 * Returns the listing of launch delegates that apply to the specified 
	 * <code>ILaunchConfigurationType</code> id
	 * @param typeid the id of the launch configuration type to get delegates for 
	 * @return An array of <code>LaunchDelegate</code>s that apply to the specified launch configuration
	 * type, or an empty array, never <code>null</code>
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	public LaunchDelegate[] getLaunchDelegates(String typeid) {
		initializeLaunchDelegates();
		ArrayList list = new ArrayList();
		LaunchDelegate ld = null;
		for(Iterator iter = fLaunchDelegates.keySet().iterator(); iter.hasNext();) {
			ld = (LaunchDelegate) fLaunchDelegates.get(iter.next());
			if(ld.appliesTo(typeid)) {
				list.add(ld);
			}
		}
		return (LaunchDelegate[]) list.toArray(new LaunchDelegate[list.size()]);
	}
	
	/**
	 * Returns the listing of duplicate launch delegates in the form of a <code>HashMap</code>, with the 
	 * object arrangement: 
	 * <p>
	 * <pre>
	 * HashMap<ILaunchConfigurationType, HashMap<string, LaunchDelegate[]>>
	 * </pre>
	 * </p>
	 * <p>
	 * Where the first map is keyed based on <code>ILaunchConfigurationType</code> ids and the inner map
	 * is keyed by mode.
	 * </p> 
	 * @return the map of <code>LaunchDelegate</code>s that are in conflict for type, mode and options
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	public HashMap getDuplicateLaunchDelegates() {
		initializeDuplicateLaunchDelegates();
		return fDuplicateDelegates;
	}
	
	/**
	 * Lazily initializes the listing of duplicate launch delegates
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	private synchronized void initializeDuplicateLaunchDelegates() {
		if(fDuplicateDelegates == null) {
			fDuplicateDelegates = new HashMap();
			//for each delegate get the delegates[]
			LaunchDelegate[] delegates = getLaunchDelegates();
			LaunchDelegate[] dupes = null;
			ILaunchConfigurationType type = null;
			Set modes = null;
			Iterator iter = null;
			Set options = null;
			HashMap tmp = null;
			String mode = null;
			for(int i = 0; i < delegates.length; i++) {
				type = getLaunchConfigurationType(delegates[i].getLaunchConfigurationType());
				options = delegates[i].getOptions();
				modes = type.getSupportedModes();
				for(iter = modes.iterator(); iter.hasNext();) {
					mode = (String) iter.next();
					dupes = getLaunchDelegates(type.getIdentifier(), mode, (String[])options.toArray(new String[options.size()]));
					if(dupes.length > 1) {
						tmp = (HashMap) fDuplicateDelegates.get(type);
						if(tmp == null) {
							tmp = new HashMap(dupes.length);
						}
						tmp.put(mode, dupes);
						fDuplicateDelegates.put(type, tmp);
					}
				}
			}
		}
	}
	
	/**
	 * 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();
			LaunchDelegate 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(IConfigurationElementConstants.DELEGATE) != null) {
					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 27-32 Link Here

(-)core/org/eclipse/debug/internal/core/DebugCoreMessages.java (+2 lines)
27	public static String DebugPlugin_1;	27	public static String DebugPlugin_1;
28	public static String EnvironmentVariableResolver_0;	28	public static String EnvironmentVariableResolver_0;
29		29
		30	public static String LaunchConfigurationInfo_35;
		31
30	public static String LaunchOption_0;	32	public static String LaunchOption_0;
31	public static String SystemPropertyResolver_0;	33	public static String SystemPropertyResolver_0;
32	public static String InputStreamMonitor_label;	34	public static String InputStreamMonitor_label;

Lines 13-22 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchConfiguration.java (-6 / +62 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;
		17	import java.util.HashSet;
18	import java.util.List;	18	import java.util.List;
19	import java.util.Map;	19	import java.util.Map;
		20	import java.util.Set;
20		21
21	import javax.xml.parsers.DocumentBuilder;	22	import javax.xml.parsers.DocumentBuilder;
22	import javax.xml.parsers.DocumentBuilderFactory;	23	import javax.xml.parsers.DocumentBuilderFactory;
Lines 44-49 Link Here
44	import org.eclipse.debug.core.ILaunchConfiguration;	45	import org.eclipse.debug.core.ILaunchConfiguration;
45	import org.eclipse.debug.core.ILaunchConfigurationType;	46	import org.eclipse.debug.core.ILaunchConfigurationType;
46	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;	47	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
		48	import org.eclipse.debug.core.IStatusHandler;
47	import org.eclipse.debug.core.Launch;	49	import org.eclipse.debug.core.Launch;
48	import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;	50	import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;
49	import org.eclipse.debug.core.model.ILaunchConfigurationDelegate2;	51	import org.eclipse.debug.core.model.ILaunchConfigurationDelegate2;
Lines 55-60 Link Here
55	import org.xml.sax.SAXException;	57	import org.xml.sax.SAXException;
56	import org.xml.sax.helpers.DefaultHandler;	58	import org.xml.sax.helpers.DefaultHandler;
57		59
		60	import com.ibm.icu.text.MessageFormat;
		61
58	/**	62	/**
59	* Launch configuration handle.	63	* Launch configuration handle.
60	*	64	*
Lines 82-87 Link Here
82	public static final String ATTR_MAPPED_RESOURCE_TYPES = DebugPlugin.getUniqueIdentifier() + ".MAPPED_RESOURCE_TYPES"; //$NON-NLS-1$	86	public static final String ATTR_MAPPED_RESOURCE_TYPES = DebugPlugin.getUniqueIdentifier() + ".MAPPED_RESOURCE_TYPES"; //$NON-NLS-1$
83		87
84	/**	88	/**
		89	* The listing of applicable launch options for this configuration.
		90	*
		91	* <p>
		92	* <strong>EXPERIMENTAL</strong>. This class has been added as
		93	* part of a work in progress. There is no guarantee that this API will
		94	* remain unchanged during the 3.3 release cycle. Please do not use this API
		95	* without consulting with the Platform/Debug team.
		96	* </p>
		97	* @since 3.3
		98	*/
		99	public static final String ATTR_LAUNCH_OPTIONS = DebugPlugin.getUniqueIdentifier() + ".LAUNCH_OPTIONS"; //$NON-NLS-1$
		100
		101	/**
		102	* Status handler to prompt in the UI thread
		103	*
		104	* @since 3.3
		105	*/
		106	protected static final IStatus promptStatus = new Status(IStatus.INFO, "org.eclipse.debug.ui", 200, "", null); //$NON-NLS-1$//$NON-NLS-2$
		107
		108	/**
		109	* Status handler to prompt the user to resolve the missing launch delegate issue
		110	* @since 3.3
		111	*/
		112	protected static final IStatus delegateNotAvailable = new Status(IStatus.INFO, "org.eclipse.debug.core", 226, "", null); //$NON-NLS-1$ //$NON-NLS-2$
		113
		114	/**
85	* Location this configuration is stored in. This	115	* Location this configuration is stored in. This
86	* is the key for a launch configuration handle.	116	* is the key for a launch configuration handle.
87	*/	117	*/
Lines 271-276 Link Here
271	return getInfo().getListAttribute(attributeName, defaultValue);	301	return getInfo().getListAttribute(attributeName, defaultValue);
272	}	302	}
273		303
		304	/**
		305	* @see org.eclipse.debug.core.ILaunchConfiguration#getAttribute(java.lang.String, java.util.Set)
		306	*/
		307	public Set getAttribute(String attributeName, Set defaultValue) throws CoreException {
		308	return getInfo().getSetAttribute(attributeName, defaultValue);
		309	}
		310
274	/* (non-Javadoc)	311	/* (non-Javadoc)
275	* @see org.eclipse.debug.core.ILaunchConfiguration#getAttribute(java.lang.String, java.util.Map)	312	* @see org.eclipse.debug.core.ILaunchConfiguration#getAttribute(java.lang.String, java.util.Map)
276	*/	313	*/
Lines 320-333 Link Here
320	/**	357	/**
321	* Returns the launch configuration delegate for this	358	* Returns the launch configuration delegate for this
322	* launch configuration, for the specified launch mode.	359	* launch configuration, for the specified launch mode.
323	*
324	* @param mode launch mode	360	* @param mode launch mode
325	* @return launch configuration delegate	361	* @return launch configuration delegate
326	* @exception CoreException if the delegate was unable	362	* @exception CoreException if the delegate was unable
327	* to be created	363	* to be created
328	*/	364	*/
329	protected ILaunchConfigurationDelegate getDelegate(String mode) throws CoreException {	365	protected ILaunchConfigurationDelegate getDelegate(String mode, String[] options) throws CoreException {
330	return getType().getDelegate(mode);	366	return getType().getDelegate(mode, options);
331	}	367	}
332		368
333	/* (non-Javadoc)	369	/* (non-Javadoc)
Lines 480-485 Link Here
480	return getLastLocationSegment();	516	return getLastLocationSegment();
481	}	517	}
482		518
		519	/**
		520	* @see org.eclipse.debug.core.ILaunchConfiguration#getOptions()
		521	*/
		522	public Set getOptions() throws CoreException {
		523	Set options = getAttribute(ATTR_LAUNCH_OPTIONS, (Set)null);
		524	return (options != null ? new HashSet(options) : new HashSet(0));
		525	}
		526
483	/* (non-Javadoc)	527	/* (non-Javadoc)
484	* @see org.eclipse.debug.core.ILaunchConfiguration#getType()	528	* @see org.eclipse.debug.core.ILaunchConfiguration#getType()
485	*/	529	*/
Lines 570-576 Link Here
570	*/	614	*/
571	public ILaunch launch(String mode, IProgressMonitor monitor, boolean build, boolean register) throws CoreException {	615	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	616	// bug 28245 - force the delegate to load in case it is interested in launch notifications
573	ILaunchConfigurationDelegate delegate= getDelegate(mode);	617	ILaunchConfigurationDelegate delegate = null;
		618	Set options = getOptions();
		619	try {
		620	delegate = getDelegate(mode, (String[]) options.toArray(new String[options.size()]));
		621	}
		622	catch(CoreException ce) {
		623	IStatusHandler handler = DebugPlugin.getDefault().getStatusHandler(promptStatus);
		624	handler.handleStatus(delegateNotAvailable, new Object[] {this, mode});
		625
		626	//retry once the problem has been fixed
		627	options = getOptions();
		628	delegate = getDelegate(mode, (String[]) options.toArray(new String[options.size()]));
		629	}
574	ILaunchConfigurationDelegate2 delegate2 = null;	630	ILaunchConfigurationDelegate2 delegate2 = null;
575	if (delegate instanceof ILaunchConfigurationDelegate2) {	631	if (delegate instanceof ILaunchConfigurationDelegate2) {
576	delegate2 = (ILaunchConfigurationDelegate2) delegate;	632	delegate2 = (ILaunchConfigurationDelegate2) delegate;
Lines 690-694 Link Here
690	return getType().supportsMode(mode);	746	return getType().supportsMode(mode);
691	}	747	}
692		748
693	}//end class	749	}
694		750

Lines 16-25 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchConfigurationWorkingCopy.java (-8 / +72 lines)
16	import java.io.FileOutputStream;	16	import java.io.FileOutputStream;
17	import java.io.IOException;	17	import java.io.IOException;
18	import java.io.UnsupportedEncodingException;	18	import java.io.UnsupportedEncodingException;
19	import com.ibm.icu.text.MessageFormat;
20	import java.util.ArrayList;	19	import java.util.ArrayList;
21	import java.util.List;	20	import java.util.List;
22	import java.util.Map;	21	import java.util.Map;
		22	import java.util.Set;
23		23
24	import javax.xml.parsers.ParserConfigurationException;	24	import javax.xml.parsers.ParserConfigurationException;
25	import javax.xml.transform.TransformerException;	25	import javax.xml.transform.TransformerException;
Lines 40-45 Link Here
40	import org.eclipse.debug.core.ILaunchConfigurationType;	40	import org.eclipse.debug.core.ILaunchConfigurationType;
41	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;	41	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
42		42
		43	import com.ibm.icu.text.MessageFormat;
		44
43	/**	45	/**
44	* A working copy launch configuration	46	* A working copy launch configuration
45	*/	47	*/
Lines 194-200 Link Here
194	}	196	}
195	// write the new file	197	// write the new file
196	writeNewFile();	198	writeNewFile();
197	resetDirty();	199	fDirty = false;
198	}	200	}
199		201
200	/**	202	/**
Lines 369-375 Link Here
369	LaunchConfigurationInfo info = original.getInfo();	371	LaunchConfigurationInfo info = original.getInfo();
370	setInfo(info.getCopy());	372	setInfo(info.getCopy());
371	setContainer(original.getContainer());	373	setContainer(original.getContainer());
372	resetDirty();	374	fDirty = false;
373	}	375	}
374		376
375	/**	377	/**
Lines 423-435 Link Here
423	}	425	}
424		426
425	/**	427	/**
426	* Sets this working copy's state to not dirty.	428	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#setOptions(java.lang.String[])
427	*/	429	*/
428	private void resetDirty() {	430	public void addOption(String option) {
429	fDirty = false;	431	try {
		432	Set options = getOptions();
		433	if(option != null && !options.contains(option)) {
		434	options.add(option);
		435	getInfo().setAttribute(ATTR_LAUNCH_OPTIONS, options);
		436	setDirty();
		437	}
		438	}
		439	catch (CoreException e) {DebugPlugin.log(e);}
430	}	440	}
431		441
432	/**	442	/**
		443	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#removeOption(java.lang.String)
		444	*/
		445	public void removeOption(String option) {
		446	try {
		447	Set options = getOptions();
		448	if(options.remove(option)) {
		449	getInfo().setAttribute(ATTR_LAUNCH_OPTIONS, options);
		450	setDirty();
		451	}
		452	}
		453	catch (CoreException e) {DebugPlugin.log(e);}
		454	}
		455
		456	/**
		457	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#setOptions(java.util.List)
		458	*/
		459	public void setOptions(Set options) {
		460	getInfo().setAttribute(ATTR_LAUNCH_OPTIONS, (options.size() > 0 ? options : null));
		461	setDirty();
		462	}
		463
		464	/**
		465	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#addOptions(java.util.Set)
		466	*/
		467	public void addOptions(Set options) {
		468	try {
		469	Set opts = getOptions();
		470	if(opts.addAll(options)) {
		471	getInfo().setAttribute(ATTR_LAUNCH_OPTIONS, opts);
		472	setDirty();
		473	}
		474	}
		475	catch (CoreException e) {
		476	DebugPlugin.log(e);
		477	}
		478	}
		479
		480	/**
		481	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#removeOptions(java.util.Set)
		482	*/
		483	public void removeOptions(Set options) {
		484	try {
		485	Set opts = getOptions();
		486	if(opts.removeAll(options)) {
		487	getInfo().setAttribute(ATTR_LAUNCH_OPTIONS, opts);
		488	setDirty();
		489	}
		490	}
		491	catch (CoreException e) {
		492	DebugPlugin.log(e);
		493	}
		494	}
		495
		496	/**
433	* @see ILaunchConfigurationWorkingCopy#rename(String)	497	* @see ILaunchConfigurationWorkingCopy#rename(String)
434	*/	498	*/
435	public void rename(String name) {	499	public void rename(String name) {
Lines 593-599 Link Here
593	}	657	}
594	setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_PATHS, paths);	658	setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_PATHS, paths);
595	setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_TYPES, types);	659	setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_TYPES, types);
596	}//end setResource	660	}
597		661
598	}//end class	662	}
599		663




 *******************************************************************************/
package org.eclipse.debug.internal.core;

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

import com.ibm.icu.text.MessageFormat;

/**
 * Proxy to a launch option extension
 * 
 * @since 3.3
 */
public class LaunchOption implements ILaunchOption {

	//constants for attribute names
	private static final String ID = "id"; //$NON-NLS-1$
	private static final String LABEL = "label"; //$NON-NLS-1$
	private static final String OPTION = "option"; //$NON-NLS-1$
	
	/**
	 * The associated configuration element

	 * Constructor
	 * @param element the element to associate this launch option with
	 */
	public LaunchOption(IConfigurationElement element) {
		fElement = element;
		verifyAttributesExist();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchOption#getIdentifier()
	 */
	public String getIdentifier() {
		return fElement.getAttribute(IConfigurationElementConstants.ID);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchOption#getLabel()
	 */
	public String getLabel() {
		return fElement.getAttribute(IConfigurationElementConstants.LABEL);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchOption#getOption()
	 */
	public String getOption() {
		return fElement.getAttribute(OPTION);
	}
	
	/**
	 * Checks to ensure that all of the required attributes are present in the <code>IConfigurationElement</code>
	 * @return true if all attributes are present, throws <code>CoreException</code> otherwise
	 * @throws CoreException
	 */
	private void verifyAttributesExist() throws CoreException {
		if(fElement != null) {
			if(fElement.getAttribute(ID) == null) {
				missingAttribute(ID);
			}
			if(fElement.getAttribute(LABEL) == null) {
				missingAttribute(LABEL);
			}
			if(fElement.getAttribute(OPTION) == null) {
				missingAttribute(OPTION);
			}
		}
	}
	
	/**
	 * Throws a <code>CoreException</code> indicating the specified attribute is missing from the extension
	 * point definition
	 * @param attrName the attribute name that is missing
	 * @throws CoreException
	 */
	private void missingAttribute(String attrName) throws CoreException {
		throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, MessageFormat.format(DebugCoreMessages.LaunchOption_0, new String[]{attrName}), null));		 
	}
}




/*******************************************************************************
 * 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$
	}
}

Lines 11-24 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchConfigurationType.java (-151 / +131 lines)
11	package org.eclipse.debug.internal.core;	11	package org.eclipse.debug.internal.core;
12		12
13		13
14	import com.ibm.icu.text.MessageFormat;
15	import java.util.HashSet;	14	import java.util.HashSet;
16	import java.util.Hashtable;	15	import java.util.Hashtable;
17	import java.util.Iterator;
18	import java.util.List;
19	import java.util.Map;	16	import java.util.Map;
20	import java.util.Set;	17	import java.util.Set;
21	import java.util.StringTokenizer;	18
22	import org.eclipse.core.resources.IContainer;	19	import org.eclipse.core.resources.IContainer;
23	import org.eclipse.core.runtime.CoreException;	20	import org.eclipse.core.runtime.CoreException;
24	import org.eclipse.core.runtime.IConfigurationElement;	21	import org.eclipse.core.runtime.IConfigurationElement;
Lines 34-39 Link Here
34	import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;	31	import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;
35	import org.eclipse.debug.core.sourcelookup.ISourcePathComputer;	32	import org.eclipse.debug.core.sourcelookup.ISourcePathComputer;
36		33
		34	import com.ibm.icu.text.MessageFormat;
		35
37	/**	36	/**
38	* A launch configuration type wrappers a configuration	37	* A launch configuration type wrappers a configuration
39	* element for a <code>launchConfigurationType</code>	38	* element for a <code>launchConfigurationType</code>
Lines 41-71 Link Here
41	*/	40	*/
42	public class LaunchConfigurationType extends PlatformObject implements ILaunchConfigurationType {	41	public class LaunchConfigurationType extends PlatformObject implements ILaunchConfigurationType {
43		42
44	private static String MIGRATION_DELEGATE = "migrationDelegate"; //$NON-NLS-1$
45
46	/**	43	/**
47	* The configuration element of the extension.	44	* The configuration element of the extension.
48	*/	45	*/
49	private IConfigurationElement fElement;	46	private IConfigurationElement fElement;
50		47
51	/**	48	/**
52	* Base modes this type supports.	49	* a listing of modes contributed to this launch configuration type
		50	* @since 3.3
		51	*
		52	* <p>
		53	* <strong>EXPERIMENTAL</strong>. This field has been added as
		54	* part of a work in progress. There is no guarantee that this API will
		55	* remain unchanged during the 3.3 release cycle. Please do not use this API
		56	* without consulting with the Platform/Debug team.
		57	* </p>
		58	*/
		59	private Set fModes = null;
		60
		61	/**
		62	* the default source path computer for this config type
		63	* @since 3.3
		64	*
		65	* <p>
		66	* <strong>EXPERIMENTAL</strong>. This field has been added as
		67	* part of a work in progress. There is no guarantee that this API will
		68	* remain unchanged during the 3.3 release cycle. Please do not use this API
		69	* without consulting with the Platform/Debug team.
		70	* </p>
53	*/	71	*/
54	private Set fBaseModes;	72	private ISourcePathComputer fSourcePathComputer = null;
55		73
56	/**	74	/**
57	* Modes that delegates have been contributed for	75	* The source locator id for this config type
58	*/	76	*/
59	private Set fContributedModes;	77	private String fSourceLocator = null;
60		78
61	/**	79	/**
62	* The delegates for launch configurations of this type.	80	* The delegates for launch configurations of this type.
63	* Delegates are instantiated lazily as required. There may	81	* Delegates are instantiated lazily as required. There may
64	* be different delegates for different modes (since 3.0).	82	* be different delegates for different modes (since 3.0).
65	* Map of mode -> delegate	83	* Map of mode to delegate
66	*/	84	*/
67	private Map fDelegates;	85	private Map fDelegates;
68		86
		87	private LaunchDelegate fSourceProvider;
		88
69	/**	89	/**
70	* Constructs a new launch configuration type on the	90	* Constructs a new launch configuration type on the
71	* given configuration element.	91	* given configuration element.
Lines 73-155 Link Here
73	* @param element configuration element	93	* @param element configuration element
74	*/	94	*/
75	protected LaunchConfigurationType(IConfigurationElement element) {	95	protected LaunchConfigurationType(IConfigurationElement element) {
76	setConfigurationElement(element);	96	fElement = element;
77	}	97	}
78		98
79	/* (non-Javadoc)	99	/* (non-Javadoc)
80	* @see org.eclipse.debug.core.ILaunchConfigurationType#getAttribute(java.lang.String)	100	* @see org.eclipse.debug.core.ILaunchConfigurationType#getAttribute(java.lang.String)
81	*/	101	*/
82	public String getAttribute(String attributeName) {	102	public String getAttribute(String attributeName) {
83	return getConfigurationElement().getAttribute(attributeName);	103	return fElement.getAttribute(attributeName);
84	}	104	}
85
86	/**
87	* Returns the set of modes specified in the configuration data.
88	*
89	* @return the set of modes specified in the configuration data
90	*/
91	protected Set getBaseModes() {
92	if (fBaseModes == null) {
93	String modes= getConfigurationElement().getAttribute("modes"); //$NON-NLS-1$
94	if (modes == null) {
95	return new HashSet(0);
96	}
97	StringTokenizer tokenizer= new StringTokenizer(modes, ","); //$NON-NLS-1$
98	fBaseModes = new HashSet(tokenizer.countTokens());
99	while (tokenizer.hasMoreTokens()) {
100	fBaseModes.add(tokenizer.nextToken().trim());
101	}
102	}
103	return fBaseModes;
104	}
105		105
106	/* (non-Javadoc)	106	/* (non-Javadoc)
107	* @see org.eclipse.debug.core.ILaunchConfigurationType#getCategory()	107	* @see org.eclipse.debug.core.ILaunchConfigurationType#getCategory()
108	*/	108	*/
109	public String getCategory() {	109	public String getCategory() {
110	return getConfigurationElement().getAttribute("category"); //$NON-NLS-1$	110	return fElement.getAttribute(IConfigurationElementConstants.CATEGORY);
111	}
112
113	/**
114	* Returns this type's configuration element.
115	*
116	* @return this type's configuration element
117	*/
118	protected IConfigurationElement getConfigurationElement() {
119	return fElement;
120	}
121
122	/**
123	* Returns the set of modes delegates have been contributed for
124	*
125	* @return the set of modes delegates have been contributed for
126	*/
127	protected Set getContributedModes() {
128	if (fContributedModes == null) {
129	fContributedModes = new HashSet(0);
130	// add modes for contributed delegates
131	List delegates = ((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).getContributedDelegates();
132	Iterator iterator = delegates.iterator();
133	while (iterator.hasNext()) {
134	ContributedDelegate delegate = (ContributedDelegate)iterator.next();
135	if (delegate.getLaunchConfigurationType().equals(getIdentifier())) {
136	fContributedModes.addAll(delegate.getModes());
137	}
138	}
139	}
140	return fContributedModes;
141	}	111	}
142		112
143	/**	113	/**
144	* Returns the launch configuration delegate for launch
145	* configurations of this type. The first time this method
146	* is called, the delegate is instantiated.
147	*
148	* @see org.eclipse.debug.core.ILaunchConfigurationType#getDelegate()	114	* @see org.eclipse.debug.core.ILaunchConfigurationType#getDelegate()
149	* @return launch configuration delegate
150	* @exception CoreException if unable to instantiate the
151	* delegate
152	* @deprecated use <code>getDelegate(String)</code> to specify mode
153	*/	115	*/
154	public ILaunchConfigurationDelegate getDelegate() throws CoreException {	116	public ILaunchConfigurationDelegate getDelegate() throws CoreException {
155	return getDelegate(ILaunchManager.RUN_MODE);	117	return getDelegate(ILaunchManager.RUN_MODE);
Lines 159-220 Link Here
159	* @see org.eclipse.debug.core.ILaunchConfigurationType#getDelegate(java.lang.String)	121	* @see org.eclipse.debug.core.ILaunchConfigurationType#getDelegate(java.lang.String)
160	*/	122	*/
161	public ILaunchConfigurationDelegate getDelegate(String mode) throws CoreException {	123	public ILaunchConfigurationDelegate getDelegate(String mode) throws CoreException {
		124	return getDelegate(mode, null);
		125	}
		126
		127	/**
		128	* @see org.eclipse.debug.core.ILaunchConfigurationType#getDelegate(java.lang.String, java.lang.String[])
		129	*/
		130	public ILaunchConfigurationDelegate getDelegate(String mode, String[] options) throws CoreException {
162	if (!supportsMode(mode)) {	131	if (!supportsMode(mode)) {
163	throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, MessageFormat.format(DebugCoreMessages.LaunchConfigurationType_9, new String[] {mode, getIdentifier()}), null));	132	throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, MessageFormat.format(DebugCoreMessages.LaunchConfigurationType_9, new String[] {mode, getIdentifier()}), null));
164	}	133	}
165	if (fDelegates == null) {	134	if (fDelegates == null) {
166	// initialize delegate table with base modes	135	// initialize delegate table with base modes
167	fDelegates = new Hashtable(3);	136	fDelegates = new Hashtable();
168	}	137	}
169	ILaunchConfigurationDelegate delegate = (ILaunchConfigurationDelegate)fDelegates.get(mode);	138	ILaunchConfigurationDelegate delegate = (ILaunchConfigurationDelegate)fDelegates.get(mode);
170	if (delegate == null) {	139	if (delegate == null) {
171	Set modes = getBaseModes();	140	if(fModes.contains(mode)) {
172	if (modes.contains(mode)) {	141	LaunchDelegate[] delegates = ((LaunchManager) DebugPlugin.getDefault().getLaunchManager()).getLaunchDelegates(getIdentifier(), mode, options);
173	Object object = getConfigurationElement().createExecutableExtension("delegate"); //$NON-NLS-1$	142	if(delegates.length > 0) {
174	if (object instanceof ILaunchConfigurationDelegate) {	143	return delegates[0].getDelegate();
175	Iterator iter = modes.iterator();
176	while (iter.hasNext()) {
177	fDelegates.put(iter.next(), object);
178	}
179	return (ILaunchConfigurationDelegate)object;
180	}
181	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));
182	}
183	// contributed modes
184	List contributed = ((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).getContributedDelegates();
185	Iterator iterator = contributed.iterator();
186	while (iterator.hasNext()) {
187	ContributedDelegate contributedDelegate = (ContributedDelegate)iterator.next();
188	if (getIdentifier().equals(contributedDelegate.getLaunchConfigurationType())) {
189	modes = contributedDelegate.getModes();
190	if (modes.contains(mode)) {
191	delegate = contributedDelegate.getDelegate();
192	Iterator modesIterator = modes.iterator();
193	while (modesIterator.hasNext()) {
194	fDelegates.put(modesIterator.next(), delegate);
195	}
196	return delegate;
197	}
198	}	144	}
199	}	145	}
200	} else {	146	}
		147	else {
201	return delegate;	148	return delegate;
202	}	149	}
203	throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, MessageFormat.format(DebugCoreMessages.LaunchConfigurationType_10, new String[] {getIdentifier(), mode}), null));	150	throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, MessageFormat.format(DebugCoreMessages.LaunchConfigurationType_10, new String[] {getIdentifier(), mode}), null));
204	}	151	}
205		152
206	/* (non-Javadoc)	153	/* (non-Javadoc)
207	* @see org.eclipse.debug.core.ILaunchConfigurationType#getIdentifier()	154	* @see org.eclipse.debug.core.ILaunchConfigurationType#getIdentifier()
208	*/	155	*/
209	public String getIdentifier() {	156	public String getIdentifier() {
210	return getConfigurationElement().getAttribute("id"); //$NON-NLS-1$	157	return fElement.getAttribute(IConfigurationElementConstants.ID);
211	}	158	}
212		159
213	/* (non-Javadoc)	160	/* (non-Javadoc)
214	* @see org.eclipse.debug.core.ILaunchConfigurationType#getName()	161	* @see org.eclipse.debug.core.ILaunchConfigurationType#getName()
215	*/	162	*/
216	public String getName() {	163	public String getName() {
217	return getConfigurationElement().getAttribute("name"); //$NON-NLS-1$	164	return fElement.getAttribute(IConfigurationElementConstants.NAME);
218	}	165	}
219		166
220	/* (non-Javadoc)	167	/* (non-Javadoc)
Lines 228-277 Link Here
228	* @see org.eclipse.debug.core.ILaunchConfigurationType#getSourceLocatorId()	175	* @see org.eclipse.debug.core.ILaunchConfigurationType#getSourceLocatorId()
229	*/	176	*/
230	public String getSourceLocatorId() {	177	public String getSourceLocatorId() {
231	String id = getAttribute("sourceLocatorId"); //$NON-NLS-1$	178	if(fSourceLocator == null) {
232	if (id == null) {	179	fSourceLocator = getAttribute(IConfigurationElementConstants.SOURCE_LOCATOR);
233	// check for specification by mode specific delegate	180	//see if the cached source provider knows about it
234	List delegates = ((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).getContributedDelegates();	181	if(fSourceProvider != null) {
235	Iterator iterator = delegates.iterator();	182	fSourceLocator = fSourceProvider.getSourceLocatorId();
236	while (iterator.hasNext() && id == null) {	183	}
237	ContributedDelegate delegate = (ContributedDelegate)iterator.next();	184	//if not provided check all the applicable delegates for one and record the delegate if found,
238	if (delegate.getLaunchConfigurationType().equals(getIdentifier())) {	185	//so it can be reused to try and find the source path computer
239	id = delegate.getSourceLocaterId();	186	if(fSourceLocator == null) {
		187	LaunchDelegate[] delegates = ((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).getLaunchDelegates(getIdentifier());
		188	for(int i = 0; i < delegates.length; i++) {
		189	fSourceLocator = delegates[i].getSourceLocatorId();
		190	if(fSourceLocator != null) {
		191	fSourceProvider = delegates[i];
		192	return fSourceLocator;
		193	}
240	}	194	}
		195	fSourceProvider = null;
241	}	196	}
242	}	197	}
243	return id;	198	return fSourceLocator;
244	}	199	}
245		200
246	/* (non-Javadoc)	201	/* (non-Javadoc)
247	* @see org.eclipse.debug.core.ILaunchConfigurationType#getSourcePathComputer()	202	* @see org.eclipse.debug.core.ILaunchConfigurationType#getSourcePathComputer()
248	*/	203	*/
249	public ISourcePathComputer getSourcePathComputer() {	204	public ISourcePathComputer getSourcePathComputer() {
250	String id = getConfigurationElement().getAttribute("sourcePathComputerId"); //$NON-NLS-1$	205	if(fSourcePathComputer == null) {
251	if (id == null) {	206	//get the id
252	// check for specification by mode specific delegate	207	String id = fElement.getAttribute(IConfigurationElementConstants.SOURCE_PATH_COMPUTER);
253	List delegates = ((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).getContributedDelegates();	208	//ask if the source provider knows about it
254	Iterator iterator = delegates.iterator();	209	if(fSourceProvider != null) {
255	while (iterator.hasNext() && id == null) {	210	id = fSourceProvider.getSourcePathComputerId();
256	ContributedDelegate delegate = (ContributedDelegate)iterator.next();	211	}
257	if (delegate.getLaunchConfigurationType().equals(getIdentifier())) {	212	if(id != null) {
258	id = delegate.getSourcePathComputerId();	213	fSourcePathComputer = DebugPlugin.getDefault().getLaunchManager().getSourcePathComputer(id);
		214	}
		215	else {
		216	//if not provided check all the applicable delegates for one and record the delegate if found,
		217	//so it can be reused to try and find the source path computer
		218	LaunchDelegate[] delegates = ((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).getLaunchDelegates(getIdentifier());
		219	for(int i = 0; i < delegates.length; i++) {
		220	id = delegates[i].getSourcePathComputerId();
		221	if(id != null) {
		222	fSourceProvider = delegates[i];
		223	fSourcePathComputer = DebugPlugin.getDefault().getLaunchManager().getSourcePathComputer(id);
		224	if(fSourcePathComputer != null) {
		225	return fSourcePathComputer;
		226	}
		227	}
259	}	228	}
		229	fSourceProvider = null;
260	}	230	}
		231
261	}	232	}
262	if (id != null && id.length() > 0) {	233	return fSourcePathComputer;
263	return DebugPlugin.getDefault().getLaunchManager().getSourcePathComputer(id);
264	}
265	return null;
266	}	234	}
267		235
268	/* (non-Javadoc)	236	/**
269	* @see org.eclipse.debug.core.ILaunchConfigurationType#getSupportedModes()	237	* @see org.eclipse.debug.core.ILaunchConfigurationType#getSupportedModes()
270	*/	238	*/
271	public Set getSupportedModes() {	239	public Set getSupportedModes() {
272	HashSet modes = new HashSet(getBaseModes());	240	if(fModes == null) {
273	modes.addAll(getContributedModes());	241	fModes = new HashSet();
274	return modes;	242	LaunchDelegate[] delegates = ((LaunchManager) DebugPlugin.getDefault().getLaunchManager()).getLaunchDelegates();
		243	for(int i= 0; i < delegates.length; i++) {
		244	if(delegates[i].appliesTo(getIdentifier())) {
		245	fModes.addAll(delegates[i].getModes());
		246	}
		247	}
		248	}
		249	return fModes;
275	}	250	}
276		251
277	/**	252	/**
Lines 283-296 Link Here
283	* @since 3.2	258	* @since 3.2
284	*/	259	*/
285	public boolean isMigrationCandidate(ILaunchConfiguration candidate) throws CoreException {	260	public boolean isMigrationCandidate(ILaunchConfiguration candidate) throws CoreException {
286	if(getAttribute(MIGRATION_DELEGATE) != null) {	261	if(getAttribute(IConfigurationElementConstants.MIGRATION_DELEGATE) != null) {
287	if(fDelegates == null) {	262	if(fDelegates == null) {
288	fDelegates = new Hashtable();	263	fDelegates = new Hashtable();
289	}	264	}
290	Object delegate = fDelegates.get(MIGRATION_DELEGATE);	265	Object delegate = fDelegates.get(IConfigurationElementConstants.MIGRATION_DELEGATE);
291	if(delegate == null) {	266	if(delegate == null) {
292	delegate = getConfigurationElement().createExecutableExtension(MIGRATION_DELEGATE);	267	delegate = fElement.createExecutableExtension(IConfigurationElementConstants.MIGRATION_DELEGATE);
293	fDelegates.put(MIGRATION_DELEGATE, delegate);	268	fDelegates.put(IConfigurationElementConstants.MIGRATION_DELEGATE, delegate);
294	}	269	}
295	if(delegate instanceof ILaunchConfigurationMigrationDelegate) {	270	if(delegate instanceof ILaunchConfigurationMigrationDelegate) {
296	return ((ILaunchConfigurationMigrationDelegate)delegate).isCandidate(candidate);	271	return ((ILaunchConfigurationMigrationDelegate)delegate).isCandidate(candidate);
Lines 303-309 Link Here
303	* @see org.eclipse.debug.core.ILaunchConfigurationType#isPublic()	278	* @see org.eclipse.debug.core.ILaunchConfigurationType#isPublic()
304	*/	279	*/
305	public boolean isPublic() {	280	public boolean isPublic() {
306	String publicString = getConfigurationElement().getAttribute("public"); //$NON-NLS-1$	281	String publicString = fElement.getAttribute(IConfigurationElementConstants.PUBLIC);
307	if (publicString != null) {	282	if (publicString != null) {
308	if (publicString.equalsIgnoreCase("false")) { //$NON-NLS-1$	283	if (publicString.equalsIgnoreCase("false")) { //$NON-NLS-1$
309	return false;	284	return false;
Lines 320-333 Link Here
320	* @since 3.2	295	* @since 3.2
321	*/	296	*/
322	public void migrate(ILaunchConfiguration candidate) throws CoreException {	297	public void migrate(ILaunchConfiguration candidate) throws CoreException {
323	if(getAttribute(MIGRATION_DELEGATE) != null) {	298	if(getAttribute(IConfigurationElementConstants.MIGRATION_DELEGATE) != null) {
324	if(fDelegates == null) {	299	if(fDelegates == null) {
325	fDelegates = new Hashtable();	300	fDelegates = new Hashtable();
326	}	301	}
327	Object delegate = fDelegates.get(MIGRATION_DELEGATE);	302	Object delegate = fDelegates.get(IConfigurationElementConstants.MIGRATION_DELEGATE);
328	if(delegate == null) {	303	if(delegate == null) {
329	delegate = getConfigurationElement().createExecutableExtension(MIGRATION_DELEGATE);	304	delegate = fElement.createExecutableExtension(IConfigurationElementConstants.MIGRATION_DELEGATE);
330	fDelegates.put(MIGRATION_DELEGATE, delegate);	305	fDelegates.put(IConfigurationElementConstants.MIGRATION_DELEGATE, delegate);
331	}	306	}
332	if(delegate instanceof ILaunchConfigurationMigrationDelegate) {	307	if(delegate instanceof ILaunchConfigurationMigrationDelegate) {
333	((ILaunchConfigurationMigrationDelegate)delegate).migrate(candidate);	308	((ILaunchConfigurationMigrationDelegate)delegate).migrate(candidate);
Lines 339-361 Link Here
339	* @see org.eclipse.debug.core.ILaunchConfigurationType#newInstance(org.eclipse.core.resources.IContainer, java.lang.String)	314	* @see org.eclipse.debug.core.ILaunchConfigurationType#newInstance(org.eclipse.core.resources.IContainer, java.lang.String)
340	*/	315	*/
341	public ILaunchConfigurationWorkingCopy newInstance(IContainer container, String name) {	316	public ILaunchConfigurationWorkingCopy newInstance(IContainer container, String name) {
342	return new LaunchConfigurationWorkingCopy(container, name, this);	317	return new LaunchConfigurationWorkingCopy(container, name, this);
343	}	318	}
344		319
345	/**	320	/**
346	* Sets this type's configuration element.	321	* @see org.eclipse.debug.core.ILaunchConfigurationType#supportsMode(java.lang.String)
347	*
348	* @param element this type's configuration element
349	*/	322	*/
350	private void setConfigurationElement(IConfigurationElement element) {	323	public boolean supportsMode(String mode) {
351	fElement = element;	324	return getSupportedModes().contains(mode);
352	}	325	}
353		326
354	/**	327	/* (non-Javadoc)
355	* @see ILaunchConfigurationType#supportsMode(String)	328	* @see org.eclipse.debug.core.ILaunchConfigurationType#getContributorName()
356	*/	329	*/
357	public boolean supportsMode(String mode) {	330	public String getContributorName() {
358	return getBaseModes().contains(mode) \|\| getContributedModes().contains(mode);	331	return fElement.getContributor().getName();
		332	}
		333
		334	/* (non-Javadoc)
		335	* @see org.eclipse.debug.core.ILaunchConfigurationType#getImageDescriptorId()
		336	*/
		337	public String getImageDescriptorPath() {
		338	return fElement.getAttribute(IConfigurationElementConstants.ICON);
359	}	339	}
360	}	340	}
361		341





 
import java.io.IOException;
import com.ibm.icu.text.MessageFormat;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.ibm.icu.text.MessageFormat;
 
/**
 * The information associated with a launch configuration handle.
 * handle.
 */
public class LaunchConfigurationInfo {
	
	/**
	 * Constants fo XML element names and attrbiutes
	 */
	private static final String KEY = "key"; //$NON-NLS-1$
	private static final String VALUE = "value"; //$NON-NLS-1$
	private static final String SET_ENTRY = "setEntry"; //$NON-NLS-1$
	private static final String LAUNCH_CONFIGURATION = "launchConfiguration"; //$NON-NLS-1$
	private static final String MAP_ENTRY = "mapEntry"; //$NON-NLS-1$
	private static final String LIST_ENTRY = "listEntry"; //$NON-NLS-1$
	private static final String SET_ATTRIBUTE = "setAttribute"; //$NON-NLS-1$
	private static final String MAP_ATTRIBUTE = "mapAttribute"; //$NON-NLS-1$
	private static final String LIST_ATTRIBUTE = "listAttribute"; //$NON-NLS-1$
	private static final String BOOLEAN_ATTRIBUTE = "booleanAttribute"; //$NON-NLS-1$
	private static final String INT_ATTRIBUTE = "intAttribute"; //$NON-NLS-1$
	private static final String STRING_ATTRIBUTE = "stringAttribute"; //$NON-NLS-1$
	private static final String TYPE = "type"; //$NON-NLS-1$
	
	/**
	 * This configurations attribute table. Keys are <code>String</code>s and
	 * values are one of <code>String</code>, <code>Integer</code>, or
	 * <code>Boolean</code>.
	 */
	private HashMap fAttributes;
	

	/**
	 * Sets this configuration's attribute table.
	 * 
	 * @param table
	 *            attribute table
	 */	
	private void setAttributeTable(HashMap table) {
		fAttributes = table;

	}
	
	/**
	 * Returns the <code>String</code> attribute with the given key or the
	 * given default value if undefined.
	 * 
	 * @return attribute specified by given key or the defaultValue if undefined
	 * @throws CoreException
	 *             if the attribute with the given key exists but is not a
	 *             <code>String</code>
	 */
	protected String getStringAttribute(String key, String defaultValue) throws CoreException {
		Object attr = getAttributeTable().get(key);

	}
	
	/**
	 * Returns the <code>int</code> attribute with the given key or the given
	 * default value if undefined.
	 * 
	 * @return attribute specified by given key or the defaultValue if undefined
	 * @throws CoreException
	 *             if the attribute with the given key exists but is not an
	 *             <code>int</code>
	 */
	protected int getIntAttribute(String key, int defaultValue) throws CoreException {
		Object attr = getAttributeTable().get(key);

	}
	
	/**
	 * Returns the <code>boolean</code> attribute with the given key or the
	 * given default value if undefined.
	 * 
	 * @return attribute specified by given key or the defaultValue if undefined
	 * @throws CoreException
	 *             if the attribute with the given key exists but is not a
	 *             <code>boolean</code>
	 */
	protected boolean getBooleanAttribute(String key, boolean defaultValue) throws CoreException {
		Object attr = getAttributeTable().get(key);

	}
	
	/**
	 * Returns the <code>java.util.List</code> attribute with the given key or
	 * the given default value if undefined.
	 * 
	 * @return attribute specified by given key or the defaultValue if undefined
	 * @throws CoreException
	 *             if the attribute with the given key exists but is not a
	 *             <code>java.util.List</code>
	 */
	protected List getListAttribute(String key, List defaultValue) throws CoreException {
		Object attr = getAttributeTable().get(key);

	}
	
	/**
	 * Returns the <code>java.util.Set</code> attribute with the given key or
	 * the given default value if undefined.
	 * 
	 * @return attribute specified by given key or the defaultValue if undefined
	 * @throws CoreException
	 *             if the attribute with the given key exists but is not a
	 *             <code>java.util.Set</code>
	 * 
	 * @since 3.3 EXPERIMENTAL
	 */
	protected Set getSetAttribute(String key, Set defaultValue) throws CoreException {
		Object attr = getAttributeTable().get(key);
		if (attr != null) {
			if (attr instanceof Set) {
				return (Set)attr;
			} 
			throw new DebugException(
				new Status(
				 IStatus.ERROR, DebugPlugin.getUniqueIdentifier(),
				 DebugException.REQUEST_FAILED, MessageFormat.format(DebugCoreMessages.LaunchConfigurationInfo_35, new String[] {key}), null 
				)
			);
		}
		return defaultValue;
	}
	
	/**
	 * Returns the <code>java.util.Map</code> attribute with the given key or
	 * the given default value if undefined.
	 * 
	 * @return attribute specified by given key or the defaultValue if undefined
	 * @throws CoreException
	 *             if the attribute with the given key exists but is not a
	 *             <code>java.util.Map</code>
	 */
	protected Map getMapAttribute(String key, Map defaultValue) throws CoreException {
		Object attr = getAttributeTable().get(key);

		return defaultValue;
	}
	
	/**
	 * Sets this configuration's type.
	 * 
	 * @param type
	 *            launch configuration type
	 */
	protected void setType(ILaunchConfigurationType type) {
		fType = type;
	}
	
	/**
	 * Returns this configuration's type.
	 * 
	 * @return launch configuration type

	}
	
	/**
	 * Sets the given attribute to the given value. Only working copy's should
	 * use this API.
	 * 
	 * @param key
	 *            attribute key
	 * @param value
	 *            attribute value
	 */
	protected void setAttribute(String key, Object value) {
		if (value == null) {

	 * Returns the content of this info as XML
	 * 
	 * @return the content of this info as XML
	 * @throws CoreException
	 *             if a attribute has been set with a null key
	 * @throws IOException
	 *             if an exception occurs creating the XML
	 * @throws ParserConfigurationException
	 *             if an exception occurs creating the XML
	 * @throws TransformerException
	 *             if an exception occurs creating the XML
	 */
	protected String getAsXML() throws CoreException, IOException, ParserConfigurationException, TransformerException {

		Document doc = LaunchManager.getDocument();
		Element configRootElement = doc.createElement(LAUNCH_CONFIGURATION); 
		doc.appendChild(configRootElement);
		
		configRootElement.setAttribute(TYPE, getType().getIdentifier()); 
		
		Iterator keys = getAttributeTable().keySet().iterator();
		while (keys.hasNext()) {

			String valueString = null;
			if (value instanceof String) {
				valueString = (String)value;
				element = createKeyValueElement(doc, STRING_ATTRIBUTE, key, valueString); 
			} else if (value instanceof Integer) {
				valueString = ((Integer)value).toString();
				element = createKeyValueElement(doc, INT_ATTRIBUTE, key, valueString); 
			} else if (value instanceof Boolean) {
				valueString = ((Boolean)value).toString();
				element = createKeyValueElement(doc, BOOLEAN_ATTRIBUTE, key, valueString); 
			} else if (value instanceof List) {				
				element = createListElement(doc, LIST_ATTRIBUTE, key, (List)value); 
			} else if (value instanceof Map) {				
				element = createMapElement(doc, MAP_ATTRIBUTE, key, (Map)value); 
			} else if(value instanceof Set) {
				element = createSetElement(doc, SET_ATTRIBUTE, key, (Set)value); 
			}
			configRootElement.appendChild(element);
		}


	}
	
	/**
	 * Helper method that creates a 'key value' element of the specified type
	 * with the specified attribute values.
	 */
	protected Element createKeyValueElement(Document doc, String elementType, String key, String value) {
		Element element = doc.createElement(elementType);
		element.setAttribute(KEY, key); 
		element.setAttribute(VALUE, value);
		return element;
	}
	
	/**
	 * Creates a new <code>Element</code> for the specified
	 * <code>java.util.List</code>
	 * 
	 * @param doc the doc to add the element to
	 * @param elementType the type of the element
	 * @param setKey the key for the element
	 * @param list the list to fill the new element with
	 * @return the new element
	 */
	protected Element createListElement(Document doc, String elementType, String listKey, List list) {
		Element listElement = doc.createElement(elementType);
		listElement.setAttribute(KEY, listKey); 
		Iterator iterator = list.iterator();
		while (iterator.hasNext()) {
			String value = (String) iterator.next();
			Element element = doc.createElement(LIST_ENTRY); 
			element.setAttribute(VALUE, value);
			listElement.appendChild(element);
		}		
		return listElement;
	}
	
	/**
	 * Creates a new <code>Element</code> for the specified
	 * <code>java.util.Set</code>
	 * 
	 * @param doc the doc to add the element to
	 * @param elementType the type of the element
	 * @param setKey the key for the element
	 * @param set the set to fill the new element with
	 * @return the new element
	 * 
	 * @since 3.3
	 */
	protected Element createSetElement(Document doc, String elementType, String setKey, Set set) {
		Element setElement = doc.createElement(elementType);
		setElement.setAttribute(KEY, setKey);
		Element element = null;
		for(Iterator iter = set.iterator(); iter.hasNext();) {
			element = doc.createElement(SET_ENTRY);
			element.setAttribute(VALUE, (String) iter.next());
			setElement.appendChild(element);
		}
		return setElement;
	}
	
	/**
	 * Creates a new <code>Element</code> for the specified
	 * <code>java.util.Map</code>
	 * 
	 * @param doc the doc to add the element to
	 * @param elementType the type of the element
	 * @param setKey the key for the element
	 * @param map the map to fill the new element with
	 * @return the new element
	 * 
	 */
	protected Element createMapElement(Document doc, String elementType, String mapKey, Map map) {
		Element mapElement = doc.createElement(elementType);
		mapElement.setAttribute(KEY, mapKey); 
		Iterator iterator = map.keySet().iterator();
		while (iterator.hasNext()) {
			String key = (String) iterator.next();
			String value = (String) map.get(key);
			Element element = doc.createElement(MAP_ENTRY); 
			element.setAttribute(KEY, key); 
			element.setAttribute(VALUE, value); 
			mapElement.appendChild(element);
		}		
		return mapElement;		
	}
	
	/**
	 * Initializes the mapping of attributes from the XML file
	 * @param root the root node from the XML document
	 * @throws CoreException 
	 */
	protected void initializeFromXML(Element root) throws CoreException {
		if (!root.getNodeName().equalsIgnoreCase(LAUNCH_CONFIGURATION)) { 
			throw getInvalidFormatDebugException();
		}
		
		// read type
		String id = root.getAttribute(TYPE); 
		if (id == null) {
			throw getInvalidFormatDebugException();
		} 

		setType(type);
		
		NodeList list = root.getChildNodes();
		Node node = null;
		Element element = null;
		String nodeName = null;
		for (int i = 0; i < list.getLength(); ++i) {
			node = list.item(i);
			short nodeType = node.getNodeType();
			if (nodeType == Node.ELEMENT_NODE) {
				element = (Element) node;
				nodeName = element.getNodeName();
				if (nodeName.equalsIgnoreCase(STRING_ATTRIBUTE)) { 
				if (nodeName.equalsIgnoreCase("stringAttribute")) { //$NON-NLS-1$
					setStringAttribute(element);
				} else if (nodeName.equalsIgnoreCase(INT_ATTRIBUTE)) { 
					setIntegerAttribute(element);
				} else if (nodeName.equalsIgnoreCase(BOOLEAN_ATTRIBUTE))  { 
					setBooleanAttribute(element);
				} else if (nodeName.equalsIgnoreCase(LIST_ATTRIBUTE)) {   
					setListAttribute(element);					
				} else if (nodeName.equalsIgnoreCase(MAP_ATTRIBUTE)) {    
					setMapAttribute(element);										
				} else if(nodeName.equalsIgnoreCase(SET_ATTRIBUTE)) { 
					setSetAttribute(element);
				}
			}
		}
	}	
	
	/**
	 * Loads a <code>String</code> from the specified element into the local attribute mapping
	 * @param element the element to load from
	 * @throws CoreException
	 */
	protected void setStringAttribute(Element element) throws CoreException {
		setAttribute(getKeyAttribute(element), getValueAttribute(element));
		String value = getValueAttribute(element);
		setAttribute(key, value);
	}
	
	/**
	 * Loads an <code>Integer</code> from the specified element into the local attribute mapping
	 * @param element the element to load from
	 * @throws CoreException
	 */
	protected void setIntegerAttribute(Element element) throws CoreException {
		setAttribute(getKeyAttribute(element), new Integer(getValueAttribute(element)));
		String value = getValueAttribute(element);
		setAttribute(key, new Integer(value));
	}
	
	/**
	 * Loads a <code>Boolean</code> from the specified element into the local attribute mapping
	 * @param element the element to load from
	 * @throws CoreException
	 */
	protected void setBooleanAttribute(Element element) throws CoreException {
		setAttribute(getKeyAttribute(element), Boolean.valueOf(getValueAttribute(element)));
		String value = getValueAttribute(element);
		setAttribute(key, Boolean.valueOf(value));
	}
	
	/**
	 * Reads a <code>List</code> attribute from the specified XML node and
	 * loads it into the mapping of attributes
	 * 
	 * @param element the element to read the list attribute from
	 * @throws CoreException if the element has an invalid format
	 */
	protected void setListAttribute(Element element) throws CoreException {
		String listKey = element.getAttribute(KEY);  
		NodeList nodeList = element.getChildNodes();
		int entryCount = nodeList.getLength();
		List list = new ArrayList(entryCount);
		Node node = null;
		Element selement = null;
		for (int i = 0; i < entryCount; i++) {
			node = nodeList.item(i);
			if (node.getNodeType() == Node.ELEMENT_NODE) {
				selement = (Element) node;		
				if (!selement.getNodeName().equalsIgnoreCase(LIST_ENTRY)) { 
				String nodeName = subElement.getNodeName();				
				if (!nodeName.equalsIgnoreCase("listEntry")) { //$NON-NLS-1$
					throw getInvalidFormatDebugException();
				}
				list.add(getValueAttribute(selement));
				list.add(value);
			}
		}
		setAttribute(listKey, list);
	}
		
	/**
	 * Reads a <code>Set</code> attribute from the specified XML node and
	 * loads it into the mapping of attributes
	 * 
	 * @param element the element to read the set attribute from
	 * @throws CoreException if the element has an invalid format
	 * 
	 * @since 3.3
	 */
	protected void setSetAttribute(Element element) throws CoreException {
		String setKey = element.getAttribute(KEY);
		NodeList nodeList = element.getChildNodes();
		int entryCount = nodeList.getLength();
		Set set = new HashSet(entryCount);
		Node node = null;
		Element selement = null;
		for(int i = 0; i < entryCount; i++) {
			node = nodeList.item(i);
			if(node.getNodeType() == Node.ELEMENT_NODE) {
				selement = (Element)node;
				if(!selement.getNodeName().equalsIgnoreCase(SET_ENTRY)) { 
					throw getInvalidFormatDebugException();
				}
				set.add(getValueAttribute(selement));
			}
		}
		setAttribute(setKey, set);
	}
	
	/**
	 * Reads a <code>Map</code> attribute from the specified XML node and
	 * loads it into the mapping of attributes
	 * 
	 * @param element the element to read the map attribute from
	 * @throws CoreException if the element has an invalid format
	 */
	protected void setMapAttribute(Element element) throws CoreException {
		String mapKey = element.getAttribute(KEY);  
		NodeList nodeList = element.getChildNodes();
		int entryCount = nodeList.getLength();
		Map map = new HashMap(entryCount);
		Node node = null;
		Element selement = null;
		for (int i = 0; i < entryCount; i++) {
			node = nodeList.item(i);
			if (node.getNodeType() == Node.ELEMENT_NODE) {
				selement = (Element) node;		
				if (!selement.getNodeName().equalsIgnoreCase(MAP_ENTRY)) { 
				String nodeName = subElement.getNodeName();				
				if (!nodeName.equalsIgnoreCase("mapEntry")) { //$NON-NLS-1$
					throw getInvalidFormatDebugException();
				}
				map.put(getKeyAttribute(selement), getValueAttribute(selement));
				String value = getValueAttribute(subElement);
				map.put(key, value);
			}
		}
		setAttribute(mapKey, map);
	}
		
	/**
	 * Returns the <code>String</code> representation of the 'key' attribute from the specified element
	 * @param element the element to read from
	 * @return the value
	 * @throws CoreException
	 */
	protected String getKeyAttribute(Element element) throws CoreException {
		String key = element.getAttribute(KEY);
		if (key == null) {
			throw getInvalidFormatDebugException();
		}
		return key;
	}
	
	/**
	 * Returns the <code>String</code> representation of the 'value' attribute from the specified element
	 * @param element the element to read from
	 * @return the value
	 * @throws CoreException
	 */
	protected String getValueAttribute(Element element) throws CoreException {
		String value = element.getAttribute(VALUE);   
		if (value == null) {
			throw getInvalidFormatDebugException();
		}
		return value;
	}
	
	/**
	 * Returns an invalid format exception for reuse
	 * @return an invalid format exception
	 */
	protected DebugException getInvalidFormatDebugException() {
		return 
			new DebugException(

	}
	
	/**
	 * Two <code>LaunchConfigurationInfo</code> objects are equal if and only
	 * if they have the same type and they have the same set of attributes with
	 * the same values.
	 * 
	 * @see Object#equals(Object)
	 */

	}
	
	/**
	 * Returns whether the two attribute maps are equal, consulting registered
	 * comparator extensions.
	 * 
	 * @param map1  attribute map
	 * @param map2 attribute map
	 * @return whether the two attribute maps are equal
	 */

				if (comp == null) {
					if (fgIsSun14x) {
						if(attr2 instanceof String & attr1 instanceof String) {
							// this is a hack for bug 110215, on SUN 1.4.x, \r
							// is stripped off when the stream is written to the
							// DOM
							// this is not the case for 1.5.x, so to be safe we
							// are stripping \r off all strings before we
							// compare for equality
							attr1 = ((String)attr1).replaceAll("\\r", ""); //$NON-NLS-1$ //$NON-NLS-2$
							attr2 = ((String)attr2).replaceAll("\\r", ""); //$NON-NLS-1$ //$NON-NLS-2$
						}




 * 
 * Example contribution of the debug launch option:
 * <pre>
 * <extension point="org.eclipse.debug.core.launchOptions">
         point="org.eclipse.debug.core.launchOptions">
      <launchOption
            id="org.eclipse.debug.core.debug"
            label="Debug">
            option="debug">
      </launchOption>
   </extension>   
 * </pre>

	public String getLabel();
	
	/**
	 * @return the unique id provided for this option e.g. debug
	 * all lowercase.
	 * @return the option defined by this extension
	 */
	public String getOption();
	
	/**
	 * @return the unique id provided for this option e.g. org.eclipse.debug.core.debug
	 */
	public String getIdentifier();
}





import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;

	public List getAttribute(String attributeName, List defaultValue) throws CoreException;
	
	/**
	 * Returns the <code>java.util.Set</code>-valued attribute with the given name.  
	 * Returns the given default value if the attribute is undefined.
	 *
	 * @param attributeName the name of the attribute
	 * @param defaultValue the value to use if no value is found
	 * @return the value or the default value if no value was found.
	 * @exception CoreException if this method fails. Reasons include:
	 * <ul>
	 * <li>An exception occurs while retrieving the attribute from
	 *  underlying storage.</li>
	 * <li>An attribute with the given name exists, but does not
	 *  have a List value</li>
	 * </ul>
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	public Set getAttribute(String attributeName, Set defaultValue) throws CoreException;
	
	/**
	 * Returns the <code>java.util.Map</code>-valued attribute with the given name.  
	 * Returns the given default value if the attribute is undefined.
	 *

	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 Set getOptions() throws CoreException;
	
	/**
	 * Returns the type of this launch configuration. This is a
	 * handle-only method.
	 * 





import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IResource;

	 * @since 3.2
	 */
	public void setMappedResources(IResource[] resources);
	
	/**
	 * This method is used to set an option for the associated <code>ILaunchConfiguraiton</code>.
	 * 
	 * If the option is <code>null</code>, or is alrready in the current set of options no changes are made
	 * 
	 * @param option the name of the option 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 addOption(String option);
	
	/**
	 * This method is used to remove an option from the associated <code>ILaunchConfiguraiton</code>.
	 * 
	 * If the option is <code>null</code> or not contained in the current set of options no changes are made
	 * 
	 * @param option the name of the option to remove 
	 * 
	 * <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 removeOption(String option);
	
	/**
	 * This method is used to set the options for the associated <code>ILaunchConfiguration</code>.
	 * Unlike <code>ILaunchConfigurationWorkingCopy.setOption(String, boolean)</code>, this method will over-write the existing 
	 * set of options with the new listing specified, it will NOT add the specified listing to the current set of options.
	 * 
	 * If the specified list of options is empty or <code>null</code>, the 'options' attribute is removed from the launch configuration altogether
	 * 
	 * @param options the list of options to replace the currently set ones with
	 * 
	 * <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(Set options);
	
	/**
	 * This method is used to add the set of options to the associated <code>ILaunchConfiguraiton</code>.
	 * The original set of options is maintained and this set is appended to it
	 * 
	 * If the specified list of options is empty or <code>null</code>, no changes are made
	 * 
	 * @param options the set of options to append to the current set of 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.
	 * </p>
	 * @since 3.3
	 */
	public void addOptions(Set options);
	
	/**
	 * This method is used to remove a set of options from the associated <code>ILaunchConfiguraiton</code>.
	 * 
	 * If the set is empty or <code>null</code> no changes are made
	 * 
	 * @param option the name of the option to remove 
	 * 
	 * <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 removeOptions(Set options);
}




	 * @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. 
	 * 
	 */	
	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

	 * Launch configuration types optionally specify this attribute
	 * in their plug-in XML via the <code>sourceLocatorId</code> attribute.  
	 *  
	 * In 3.3 we now search for a source locator id from contributed delegates that apply
	 * to this launch congfiguration type. As we assume only one locator id
	 * will be provided for any one contributed launch configuraiton type, the search is done
	 * on a first-found basis; i.e. the first delegate found is assumed to be the source lookup
	 * provider, and is cached for subsequent uses in source lookup. 
	 *  
	 * @return the identifier of the persistable source locator registered with
	 *  this launch configurations type, or <code>null</code> if unspecified
	 * @since 3.0
	 * 
	 */
	public String getSourceLocatorId();
	

	 * registered with a launch configuration type in plug-in XML via the
	 * <code>sourcePathComputerId</code> attribute.
	 * 
	 * In 3.3 we now will look for a source path computer id from launch delegates that apply
	 * to this launch configuration type. As we assume only one locator id
	 * will be provided for any one contributed launch configuraiton type, the search is done
	 * on a first-found basis; i.e. the first delegate found is assumed to be the source lookup
	 * provider, and is cached for subsequent uses in source lookup. 
	 * 
	 * @return the source path computer registered with this launch configuration
	 * type or <code>null</code> if unspecified
	 * @since 3.0
	 * 
	 */
	public ISourcePathComputer getSourcePathComputer();	
	

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




<?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>




               </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 sourcePathComputer id should be contributed via the &lt;code&gt;launchDelegates&lt;/code&gt; extension point
               </documentation>
            </annotation>
         </attribute>

            <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 sourceLocatorId id should be contributed via the &lt;code&gt;launchDelegates&lt;/code&gt; extension point
               </documentation>
            </annotation>
         </attribute>

               </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>

Lines 8-13 Link Here

(-)schema/launchOptions.exsd (-9 / +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 67-79 Link Here
67	</documentation>	72	</documentation>
68	</annotation>	73	</annotation>
69	</attribute>	74	</attribute>
70	<attribute name="option" type="string" use="required">
71	<annotation>
72	<documentation>
73	the name of the option itself, described as one word all lowercase e.g. debug
74	</documentation>
75	</annotation>
76	</attribute>
77	</complexType>	75	</complexType>
78	</element>	76	</element>
79		77
Lines 101-107 Link Here
101	</launchOption>	99	</launchOption>
102	</extension>	100	</extension>
103	</pre>	101	</pre>
104	</p>	102	</p>
105	</documentation>	103	</documentation>
106	</annotation>	104	</annotation>
107		105
Lines 128-134 Link Here
128	<meta.section type="copyright"/>	126	<meta.section type="copyright"/>
129	</appInfo>	127	</appInfo>
130	<documentation>	128	<documentation>
131	Copyright (c) 2003, 2005 IBM Corporation and others.<br>	129	Copyright (c) 2006 IBM Corporation and others.<br>
132	All rights reserved. This program and the accompanying materials are made	130	All rights reserved. This program and the accompanying materials are made
133	available under the terms of the Eclipse Public License v1.0 which	131	available under the terms of the Eclipse Public License v1.0 which
134	accompanies this distribution, and is available at	132	accompanies this distribution, and is available at




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


Lines 164-172 Link Here

(-)plugin.xml (-3 / +2 lines)
164	<extension	164	<extension
165	point="org.eclipse.debug.core.launchOptions">	165	point="org.eclipse.debug.core.launchOptions">
166	<launchOption	166	<launchOption
167	id="org.eclipse.debug.core.debug"	167	id="debug"
168	label="Debug"	168	label="Debug">
169	option="debug">
170	</launchOption>	169	</launchOption>
171	</extension>	170	</extension>
172		171




/*******************************************************************************
 * 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 interface provides a repository for the names of <code>IConfigurationElement</code> child node ids.
 * @since 3.3
 */
public interface IConfigurationElementConstants {

	/**
	 * 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 label node name for a configuration element
	 */
	public static final String LABEL = "label"; //$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.model.ILaunchConfigurationDelegate;

import com.ibm.icu.text.MessageFormat;

/**
 * Proxy to a launch delegate extension
 * Clients can contribute launch delegates through the <code>launchDelegates</code> extension point
 * 
 * Example contribution of the local java launch delegate
 * <pre>
 * <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"
            type="org.eclipse.jdt.launching.localJavaApplication">
      </launchDelegate>
 * </pre>
 * 
 * Clients are NOT intended to subclass this class
 * 
 * @since 3.3
 */
public final class LaunchDelegate {
	
	/**
	 * 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;
	}
	
	/**
	 * Returns the actual instance of the launch delegate specified 
	 * @return the launch delegate
	 */
	public ILaunchConfigurationDelegate getDelegate() throws CoreException {
		if(fDelegate == null) {
			Object obj = fElement.createExecutableExtension(IConfigurationElementConstants.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;
	}

	/**
	 * @return returns the unique id of the delegate
	 */
	public String getIdentifier() {
		return fElement.getAttribute(IConfigurationElementConstants.ID);
	}

	/**
	 * Returns the id of the associated <code>ILaunchConfigurationType</code> or <code>null</code> if none provided
	 * @return the id of the <code>ILaunchConfigurationType</code> associated with this delegate
	 */
	public String getLaunchConfigurationType() {
		if(fType == null) {
			//fall back to single association if no appliesTo
			fType = fElement.getAttribute(IConfigurationElementConstants.TYPE);
			if(fType == null) {
				//the case when we have passed a launch configuration type to the launch delegate
				fType = fElement.getAttribute(IConfigurationElementConstants.ID);
			}
		}
		return fType;
	}

	/**
	 * Returns the set of options provided to by this delegate
	 * @return the options associated with this delegate. If no options are specified an empty set is
	 * returned, never <code>null</code>.
	 */
	public Set getOptions() {
		if(fOptions == null) {
			fOptions = new HashSet();
			String option = fElement.getAttribute(IConfigurationElementConstants.OPTIONS);
			if(option != null) {
				String[] options = option.split(","); //$NON-NLS-1$
				for(int i = 0; i < options.length; i++) {
					fOptions.add(options[i].trim());
				}
			}
		}
		return fOptions;
	}
	
	/**
	 * 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() {
		if (fModes == null) {
			fModes = new HashSet();
			String modes = fElement.getAttribute(IConfigurationElementConstants.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;
	}
	
	/**
	 * Returns the human readable name for this launch delegate
	 * @return the human readable name for this launch delegate, or <code>null</code> if none
	 */
	public String getName() {
		return fElement.getAttribute(IConfigurationElementConstants.NAME);
	}
	
	/**
	 * Returns the associated source locator id or <code>null</code>
	 * @return the associated source locator id or <code>null</code> if not provided
	 */
	public String getSourceLocatorId() {
		return fElement.getAttribute(IConfigurationElementConstants.SOURCE_LOCATOR);
	}

	/**
	 * Returns the associated source path computer id or <code>null</code>
	 * @return the associated source path computer id or <code>null</code> if not provided
	 */
	public String getSourcePathComputerId() {
		return fElement.getAttribute(IConfigurationElementConstants.SOURCE_PATH_COMPUTER);
	}

	/**
	 * Determines 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) {
		return getLaunchConfigurationType().equals(configtypeId);
	}
	
	/**
	 * Determines 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) {
		return getLaunchConfigurationType().equals(configtypeId) & getModes().contains(mode);
	}

}




   <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"
            sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"
            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"
            sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"
            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"
            sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"
            sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer">

      	 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"
            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"
            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"
            type="org.eclipse.jdt.launching.javaApplet">
      </launchDelegate>
   </extension>   
</plugin>




<!-- 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.
      </documentation>
   </annotation>

   <element name="extension">
      <complexType>

               </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>


&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 




import org.eclipse.debug.internal.ui.LazyModelPresentation;
import org.eclipse.debug.internal.ui.contexts.DebugContextManager;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationDialog;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationEditDialog;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationPropertiesDialog;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationsDialog;

    		
    	return Window.CANCEL;
    }
		
    /**
     * Open the launch configuration dialog on the specified launch
     * configuration. The dialog displays the tabs for a single configuration
     * only (a tree of launch configuration is not displayed)
     * <p>
     * If a status is specified, a status handler is consulted to handle the
     * status. The status handler is passed the instance of the launch
     * configuration dialog that is opened. This gives the status handler an
     * opportunity to perform error handling/initialization as required.
     * </p>
     * @param shell the parent shell for the launch configuration dialog
     * @param configuration the configuration to display
     * @param groupIdentifier group identifier of the launch group the launch configuration
     * belongs to
     * @param status the status to display, or <code>null</code> if none 
     * @return the return code from opening the launch configuration dialog -
     *  one  of <code>Window.OK</code> or <code>Window.CANCEL</code>
     *  
     * @since 3.3
     * 
     * EXPERIMENTAL
     */
    public static int openLaunchConfigurationEditDialog(Shell shell, ILaunchConfiguration configuration, String groupIdentifier, IStatus status) {
    	LaunchGroupExtension group = DebugUIPlugin.getDefault().getLaunchConfigurationManager().getLaunchGroup(groupIdentifier);
    	if (group != null) {
    		LaunchConfigurationEditDialog dialog = new LaunchConfigurationEditDialog(shell, configuration, group);
    		dialog.setInitialStatus(status);
    		return dialog.open();
    	} 
    	return Window.CANCEL;
    }
    
	/**
	 * Saves all dirty editors and builds the workspace according to current
	 * preference settings, and returns whether a launch should proceed.

Lines 29-35 Link Here

(-)ui/org/eclipse/debug/ui/AbstractLaunchConfigurationTab.java (-1 / +1 lines)
29	/**	29	/**
30	* Common function for launch configuration tabs.	30	* Common function for launch configuration tabs.
31	* <p>	31	* <p>
32	* Clients may subclass this class.	32	* Clients s subclass this class.
33	* </p>	33	* </p>
34	* @see ILaunchConfigurationTab	34	* @see ILaunchConfigurationTab
35	* @since 2.0	35	* @since 2.0




	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>).
	 * 

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

Lines 18-23 Link Here

(-)plugin.xml (-1 / +8 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 1314-1320 Link Here
1314	class="org.eclipse.debug.internal.ui.launchConfigurations.DeleteLaunchConfigurationStatusHandler"	1315	class="org.eclipse.debug.internal.ui.launchConfigurations.DeleteLaunchConfigurationStatusHandler"
1315	code="225"	1316	code="225"
1316	id="org.eclipse.debug.ui.deleteAssociatedLaunchConfigs"	1317	id="org.eclipse.debug.ui.deleteAssociatedLaunchConfigs"
1317	plugin="org.eclipse.debug.core"/>	1318	plugin="org.eclipse.debug.core"/>
		1319	<statusHandler
		1320	class="org.eclipse.debug.internal.ui.launchConfigurations.LaunchDelegateNotAvailableHandler"
		1321	code="226"
		1322	id="org.eclipse.debug.ui.statusHandler.launchDelegateNotAvailable"
		1323	plugin="org.eclipse.debug.core">
		1324	</statusHandler>
1318	</extension>	1325	</extension>
1319	<extension	1326	<extension
1320	point="org.eclipse.debug.ui.launchGroups">	1327	point="org.eclipse.debug.ui.launchGroups">

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.IConfigurationElementConstants;
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(IConfigurationElementConstants.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




    }
    
    /**
     * 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 97-102 Link Here

(-)ui/org/eclipse/debug/internal/ui/IDebugHelpContextIds.java (+1 lines)
97	public static final String MAX_DETAILS_LENGTH_DIALOG = PREFIX + "max_details_length_dialog_context"; //$NON-NLS-1$	97	public static final String MAX_DETAILS_LENGTH_DIALOG = PREFIX + "max_details_length_dialog_context"; //$NON-NLS-1$
98	public static final String SELECT_DEFAULT_WORKINGSET_DIALOG = PREFIX + "select_breakpoint_workingset_dialog"; //$NON-NLS-1$	98	public static final String SELECT_DEFAULT_WORKINGSET_DIALOG = PREFIX + "select_breakpoint_workingset_dialog"; //$NON-NLS-1$
99	public static final String DELETE_ASSOCIATED_LAUNCH_CONFIGS_DIALOG = PREFIX + "delete_associated_launch_configs_dialog"; //$NON-NLS-1$	99	public static final String DELETE_ASSOCIATED_LAUNCH_CONFIGS_DIALOG = PREFIX + "delete_associated_launch_configs_dialog"; //$NON-NLS-1$
		100	public static final String SELECT_LAUNCH_OPTIONS_DIALOG = PREFIX + "select_launch_options_dialog"; //$NON-NLS-1$
100		101
101	// Property pages	102	// Property pages
102	public static final String PROCESS_PROPERTY_PAGE = PREFIX + "process_property_page_context"; //$NON-NLS-1$	103	public static final String PROCESS_PROPERTY_PAGE = PREFIX + "process_property_page_context"; //$NON-NLS-1$




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


import com.ibm.icu.text.MessageFormat;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;

import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Shell;

import com.ibm.icu.text.MessageFormat;
 

/**

		topLayout.marginWidth = 5;
		topComp.setLayout(topLayout);
		topComp.setFont(dialogComp.getFont());

		// Set the things that TitleAreaDialog takes care of 
		setTitle(getTitleAreaTitle());
		setMessage(""); //$NON-NLS-1$
		setModeLabelState();
		
		// Build the launch configuration edit area and put it into the composite.
		Composite editAreaComp = createLaunchConfigurationEditArea(topComp);
		gd = new GridData(GridData.FILL_BOTH);
		editAreaComp.setLayoutData(gd);
		editAreaComp.setFont(dialogComp.getFont());
		
		dialogComp.layout(true);
		applyDialogFont(dialogComp);
	}





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



	 */
	protected Set getModes() {
		if (fModes == null) {
			IConfigurationElement[] modes= getConfigurationElement().getChildren(IConfigurationElementConstants.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(IConfigurationElementConstants.MODE);
					fModes.add(mode);
					perspective = element.getAttribute(IConfigurationElementConstants.PERSPECTIVE);
					if (perspective != null) {
						fPerspectives.put(mode, perspective);
					}

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

	 * @since 2.1
	 */	
	protected String getHelpContextId() {
		return getConfigurationElement().getAttribute(IConfigurationElementConstants.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(IConfigurationElementConstants.ID); 
	}
	
	/**

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

	/**

	public String getDescription(String mode) {
		String description = null;
		
		IConfigurationElement[] children = fConfig.getChildren(IConfigurationElementConstants.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(IConfigurationElementConstants.DESCRIPTION);
				}
			}
		} 
		if (description == null){
			description = fConfig.getAttribute(IConfigurationElementConstants.DESCRIPTION);
		}
		
		if (description == null)

Lines 11-16 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationTabGroupViewer.java (-7 / +109 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.HashSet;
		15	import java.util.Set;
		16
14	import org.eclipse.core.resources.IResource;	17	import org.eclipse.core.resources.IResource;
15	import org.eclipse.core.resources.ResourcesPlugin;	18	import org.eclipse.core.resources.ResourcesPlugin;
16	import org.eclipse.core.runtime.CoreException;	19	import org.eclipse.core.runtime.CoreException;
Lines 20-25 Link Here
20	import org.eclipse.debug.core.ILaunchConfiguration;	23	import org.eclipse.debug.core.ILaunchConfiguration;
21	import org.eclipse.debug.core.ILaunchConfigurationType;	24	import org.eclipse.debug.core.ILaunchConfigurationType;
22	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;	25	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
		26	import org.eclipse.debug.internal.core.LaunchManager;
23	import org.eclipse.debug.internal.ui.DebugUIPlugin;	27	import org.eclipse.debug.internal.ui.DebugUIPlugin;
24	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	28	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
25	import org.eclipse.debug.internal.ui.SWTUtil;	29	import org.eclipse.debug.internal.ui.SWTUtil;
Lines 29-34 Link Here
29	import org.eclipse.debug.ui.ILaunchConfigurationTabGroup;	33	import org.eclipse.debug.ui.ILaunchConfigurationTabGroup;
30	import org.eclipse.jface.dialogs.Dialog;	34	import org.eclipse.jface.dialogs.Dialog;
31	import org.eclipse.jface.dialogs.ErrorDialog;	35	import org.eclipse.jface.dialogs.ErrorDialog;
		36	import org.eclipse.jface.dialogs.IDialogConstants;
32	import org.eclipse.jface.viewers.ISelection;	37	import org.eclipse.jface.viewers.ISelection;
33	import org.eclipse.jface.viewers.IStructuredSelection;	38	import org.eclipse.jface.viewers.IStructuredSelection;
34	import org.eclipse.jface.viewers.SelectionChangedEvent;	39	import org.eclipse.jface.viewers.SelectionChangedEvent;
Lines 69-75 Link Here
69	* buttons.	74	* buttons.
70	*/	75	*/
71	public class LaunchConfigurationTabGroupViewer extends Viewer {	76	public class LaunchConfigurationTabGroupViewer extends Viewer {
72		77
73	private final String EMPTY_STRING = ""; //$NON-NLS-1$	78	private final String EMPTY_STRING = ""; //$NON-NLS-1$
74	/**	79	/**
75	* Containing launch dialog	80	* Containing launch dialog
Lines 162-167 Link Here
162	private Composite fTabPlaceHolder = null;	167	private Composite fTabPlaceHolder = null;
163		168
164	/**	169	/**
		170	* A link to allow users to select a valid set of launch options for the specified mode
		171	* @since 3.3
		172	* EXPERIMENTAL
		173	*/
		174	private Link fOptionsLink = null;
		175
		176	/**
165	* A new composite replacing the perspectives tab	177	* A new composite replacing the perspectives tab
166	* @since 3.2	178	* @since 3.2
167	*/	179	*/
Lines 239-245 Link Here
239	fTabPlaceHolder = new Composite(mainComp, SWT.NONE);	251	fTabPlaceHolder = new Composite(mainComp, SWT.NONE);
240	fTabPlaceHolder.setLayout(new StackLayout());	252	fTabPlaceHolder.setLayout(new StackLayout());
241	gd = new GridData(GridData.FILL_BOTH);	253	gd = new GridData(GridData.FILL_BOTH);
242	gd.horizontalSpan = 2;
243	fTabPlaceHolder.setLayoutData(gd);	254	fTabPlaceHolder.setLayoutData(gd);
244		255
245	fGettingStarted = new Composite(fTabPlaceHolder, SWT.NONE);	256	fGettingStarted = new Composite(fTabPlaceHolder, SWT.NONE);
Lines 256-262 Link Here
256	fTabComposite.setLayout(layout);	267	fTabComposite.setLayout(layout);
257	gd = new GridData(GridData.FILL_BOTH);	268	gd = new GridData(GridData.FILL_BOTH);
258	fTabComposite.setLayoutData(gd);	269	fTabComposite.setLayoutData(gd);
259		270
260	fNameLabel = new Label(fTabComposite, SWT.HORIZONTAL \| SWT.LEFT);	271	fNameLabel = new Label(fTabComposite, SWT.HORIZONTAL \| SWT.LEFT);
261	fNameLabel.setText(LaunchConfigurationsMessages.LaunchConfigurationDialog__Name__16);	272	fNameLabel.setText(LaunchConfigurationsMessages.LaunchConfigurationDialog__Name__16);
262	fNameLabel.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING));	273	fNameLabel.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING));
Lines 272-285 Link Here
272		283
273	createTabFolder(fTabComposite);	284	createTabFolder(fTabComposite);
274		285
275	Composite buttonComp = new Composite(mainComp, SWT.NONE);	286	Composite blComp = SWTUtil.createComposite(mainComp, mainComp.getFont(), 2, 1, GridData.FILL_HORIZONTAL);
		287	Composite linkComp = SWTUtil.createComposite(blComp, blComp.getFont(), 1, 1, GridData.FILL_HORIZONTAL);
		288	// a link for launch options
		289	fOptionsLink = new Link(linkComp, SWT.NONE);
		290	fOptionsLink.setText(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_13);
		291	fOptionsLink.setFont(linkComp.getFont());
		292	gd = new GridData(GridData.BEGINNING);
		293	fOptionsLink.setLayoutData(gd);
		294	fOptionsLink.addSelectionListener(new SelectionListener() {
		295	public void widgetSelected(SelectionEvent e) {
		296	//collect the options available
		297	SelectLaunchOptionsDialog sld = new SelectLaunchOptionsDialog(getShell(),
		298	getLaunchConfigurationDialog().getMode(),
		299	((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).getLaunchDelegates(fTabType.getIdentifier()));
		300	if(sld.open() == IDialogConstants.OK_ID) {
		301	//set the options to the config
		302	Object[] res = sld.getResult();
		303	if(res != null) {
		304	HashSet list = new HashSet();
		305	for(int i = 0; i < res.length; i++) {
		306	list.add(res[i]);
		307	}
		308	ILaunchConfigurationWorkingCopy wc = getWorkingCopy();
		309	wc.setOptions(list);
		310	refresh();
		311	refreshStatus();
		312	}
		313	}
		314	}
		315	public void widgetDefaultSelected(SelectionEvent e) {}
		316	});
		317	fOptionsLink.setVisible(false);
		318
		319	Composite buttonComp = new Composite(blComp, SWT.NONE);
276	GridLayout buttonCompLayout = new GridLayout();	320	GridLayout buttonCompLayout = new GridLayout();
277	buttonCompLayout.numColumns = 2;	321	buttonCompLayout.numColumns = 2;
278	buttonComp.setLayout(buttonCompLayout);	322	buttonComp.setLayout(buttonCompLayout);
279	gd = new GridData(GridData.HORIZONTAL_ALIGN_END);	323	gd = new GridData(GridData.HORIZONTAL_ALIGN_END);
280	gd.horizontalSpan = 2;
281	buttonComp.setLayoutData(gd);	324	buttonComp.setLayoutData(gd);
282		325
283	fApplyButton = new Button(buttonComp, SWT.PUSH);	326	fApplyButton = new Button(buttonComp, SWT.PUSH);
284	fApplyButton.setText(LaunchConfigurationsMessages.LaunchConfigurationDialog__Apply_17);	327	fApplyButton.setText(LaunchConfigurationsMessages.LaunchConfigurationDialog__Apply_17);
285	gd = new GridData(GridData.HORIZONTAL_ALIGN_END);	328	gd = new GridData(GridData.HORIZONTAL_ALIGN_END);
Lines 305-310 Link Here
305	}	348	}
306		349
307	/**	350	/**
		351	* Shows/hides the options link on the top of the viewer
		352	* @param show true if the link should be visible, false otherwise
		353	* @since 3.3
		354	*
		355	* EXPERIMENTAL
		356	*/
		357	protected void showOptionsLink(boolean show) {
		358	fOptionsLink.setVisible(show);
		359	}
		360
		361	/**
308	* Simple method to create a spacer in the page	362	* Simple method to create a spacer in the page
309	*	363	*
310	* @param composite the composite to add the spacer to	364	* @param composite the composite to add the spacer to
Lines 485-491 Link Here
485	error = tabs[i].getErrorMessage() != null;	539	error = tabs[i].getErrorMessage() != null;
486	item = fTabFolder.getItem(i);	540	item = fTabFolder.getItem(i);
487	setTabIcon(item, error, tabs[i]);	541	setTabIcon(item, error, tabs[i]);
488	}	542	}
		543	fOptionsLink.setVisible(!canLaunchWithOptions());
489	}	544	}
490	}	545	}
491		546
Lines 961-970 Link Here
961	return false;	1016	return false;
962	}	1017	}
963	}	1018	}
		1019
964	return true;	1020	return true;
965	}	1021	}
966		1022
967	/**	1023	/**
		1024	* Determines if the tab groups that is currently visible can launch with the currently selected
		1025	* set of options.
		1026	*
		1027	* <p>
		1028	* <strong>EXPERIMENTAL</strong>. This method has been added as
		1029	* part of a work in progress. There is no guarantee that this API will
		1030	* remain unchanged during the 3.3 release cycle. Please do not use this API
		1031	* without consulting with the Platform/Debug team.
		1032	* </p>
		1033	* @return
		1034	*/
		1035	public boolean canLaunchWithOptions() {
		1036	if(fInitializingTabs) {
		1037	return false;
		1038	}
		1039	//check if selected options exist and that the selected combination can be launched
		1040	try {
		1041	ILaunchConfigurationWorkingCopy wc = getWorkingCopy();
		1042	if(wc != null) {
		1043	Set options = wc.getOptions();
		1044	if(options.size() > 0) {
		1045	return ((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).getLaunchDelegates(fTabType.getIdentifier(), getLaunchConfigurationDialog().getMode(), (String[]) options.toArray(new String[options.size()])).length > 0;
		1046	}
		1047	}
		1048	}
		1049	catch (CoreException e) {
		1050	e.printStackTrace();
		1051	}
		1052	return true;
		1053	}
		1054
		1055	/**
968	* Returns the current error message or <code>null</code> if none.	1056	* Returns the current error message or <code>null</code> if none.
969	*/	1057	*/
970	public String getErrorMesssage() {	1058	public String getErrorMesssage() {
Lines 991-996 Link Here
991	return message;	1079	return message;
992	}	1080	}
993		1081
		1082	//EXPERIMENTAL
994	ILaunchConfigurationTab[] allTabs = getTabs();	1083	ILaunchConfigurationTab[] allTabs = getTabs();
995	for (int i = 0; i < allTabs.length; i++) {	1084	for (int i = 0; i < allTabs.length; i++) {
996	ILaunchConfigurationTab tab = allTabs[i];	1085	ILaunchConfigurationTab tab = allTabs[i];
Lines 1012-1017 Link Here
1012	return LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_9;	1101	return LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_9;
1013	}	1102	}
1014	}	1103	}
		1104	if(!canLaunchWithOptions()) {
		1105	try {
		1106	Object o = getInput();
		1107	String name = null;
		1108	if(o instanceof ILaunchConfiguration) {
		1109	ILaunchConfiguration lc = (ILaunchConfiguration) o;
		1110	name = LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_14+lc.getName();
		1111	}
		1112	return (name == null ? LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_10 : name) + LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_11+getLaunchConfigurationDialog().getMode()+LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_12+getWorkingCopy().getOptions().toString();
		1113	} catch (CoreException e) {
		1114	e.printStackTrace();
		1115	}
		1116	}
1015	return null;	1117	return null;
1016	}	1118	}
1017		1119

Lines 68-74 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationDialog.java (-1 / +1 lines)
68	public void updateButtons() {	68	public void updateButtons() {
69	// Launch button	69	// Launch button
70	getTabViewer().refresh();	70	getTabViewer().refresh();
71	getButton(ID_LAUNCH_BUTTON).setEnabled(getTabViewer().canLaunch());	71	getButton(ID_LAUNCH_BUTTON).setEnabled(getTabViewer().canLaunch() & getTabViewer().canLaunchWithOptions());
72		72
73	}	73	}
74		74

Lines 44-49 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationsMessages.properties (-1 / +16 lines)
44	LaunchConfigurationDialog__Apply_17=Appl&y	44	LaunchConfigurationDialog__Apply_17=Appl&y
45	LaunchConfigurationDialog__Name__16=&Name:	45	LaunchConfigurationDialog__Name__16=&Name:
46	LaunchConfigurationDialog_An_exception_occurred_while_retrieving_launch_configurations_20=An exception occurred while retrieving launch configurations	46	LaunchConfigurationDialog_An_exception_occurred_while_retrieving_launch_configurations_20=An exception occurred while retrieving launch configurations
		47
47	LaunchConfigurationTabGroupViewer_0={0} is an invalid character in launch configuration name {1}	48	LaunchConfigurationTabGroupViewer_0={0} is an invalid character in launch configuration name {1}
48	LaunchConfigurationTabGroupViewer_1=Configure launch settings from this dialog:	49	LaunchConfigurationTabGroupViewer_1=Configure launch settings from this dialog:
49	LaunchConfigurationTabGroupViewer_2=- Press the 'New' button to create a configuration of the selected type.	50	LaunchConfigurationTabGroupViewer_2=- Press the 'New' button to create a configuration of the selected type.
Lines 53-58 Link Here
53	LaunchConfigurationTabGroupViewer_5=Configure launch perspective settings from the <a>Perspectives</a> preference page.	54	LaunchConfigurationTabGroupViewer_5=Configure launch perspective settings from the <a>Perspectives</a> preference page.
54	LaunchConfigurationTabGroupViewer_8=- Press the 'Filter' button to configure filtering options.	55	LaunchConfigurationTabGroupViewer_8=- Press the 'Filter' button to configure filtering options.
55	LaunchConfigurationTabGroupViewer_9=The file associated with this launch configuration is read-only and cannot be modified.\n	56	LaunchConfigurationTabGroupViewer_9=The file associated with this launch configuration is read-only and cannot be modified.\n
		57	LaunchConfigurationTabGroupViewer_10=The selected configuration
		58	LaunchConfigurationTabGroupViewer_11=\ cannot be launched with the set of options:
		59	LaunchConfigurationTabGroupViewer_12=\ and
		60	LaunchConfigurationTabGroupViewer_13=Select a supported set of <a>launch options</a> for this mode.
		61	LaunchConfigurationTabGroupViewer_14=Configuration
		62
56	LaunchConfigurationDialog_Create__manage__and_run_launch_configurations_8=Create, manage, and run configurations	63	LaunchConfigurationDialog_Create__manage__and_run_launch_configurations_8=Create, manage, and run configurations
57	LaunchConfigurationDialog_Dele_te_14=De&lete	64	LaunchConfigurationDialog_Dele_te_14=De&lete
58	LaunchConfigurationDialog_Discard_changes__38=Discard changes?	65	LaunchConfigurationDialog_Discard_changes__38=Discard changes?
Lines 66-71 Link Here
66	LaunchConfigurationDialog_Name_required_for_launch_configuration_11=Name required for launch configuration	73	LaunchConfigurationDialog_Name_required_for_launch_configuration_11=Name required for launch configuration
67	LaunchConfigurationDialog_Ne_w_13=Ne&w	74	LaunchConfigurationDialog_Ne_w_13=Ne&w
68	LaunchConfigurationDialog_No_33=No	75	LaunchConfigurationDialog_No_33=No
		76	LaunchConfigurationEditDialog_0=Modify configuration and continue.
		77	LaunchConfigurationEditDialog_1=Continue
69	LaunchConfigurationDialog_Ready_to_launch_2=Ready to launch	78	LaunchConfigurationDialog_Ready_to_launch_2=Ready to launch
70	LaunchConfigurationDialog_Save_changes__31=Save changes?	79	LaunchConfigurationDialog_Save_changes__31=Save changes?
71	LaunchConfigurationDialog_The_configuration___29=The configuration "{0}" has unsaved changes. Do you wish to save them?	80	LaunchConfigurationDialog_The_configuration___29=The configuration "{0}" has unsaved changes. Do you wish to save them?
Lines 97-103 Link Here
97	LaunchConfigurationPropertiesDialog_Edit_launch_configuration_properties_1=Edit launch configuration properties	106	LaunchConfigurationPropertiesDialog_Edit_launch_configuration_properties_1=Edit launch configuration properties
98	LaunchConfigurationPropertiesDialog_Properties_for__0__2=Properties for {0}	107	LaunchConfigurationPropertiesDialog_Properties_for__0__2=Properties for {0}
99		108
100	LaunchConfigurationDialog_Modify_attributes_and_launch__1=Modify attributes and launch.	109	LaunchConfigurationDialog_Modify_attributes_and_launch__1=Edit configuration and launch.
101		110
102	LaunchConfigurationTabGroupViewer_No_tabs_defined_for_launch_configuration_type__0__1=No tabs defined for launch configuration type {0}	111	LaunchConfigurationTabGroupViewer_No_tabs_defined_for_launch_configuration_type__0__1=No tabs defined for launch configuration type {0}
103		112
Lines 163-165 Link Here
163	CollapseAllLaunchConfigurationAction_0=Collapse All	172	CollapseAllLaunchConfigurationAction_0=Collapse All
164	CollapseAllLaunchConfigurationAction_1=Collapses all expanded launch configurations.	173	CollapseAllLaunchConfigurationAction_1=Collapses all expanded launch configurations.
165	CollapseAllLaunchConfigurationAction_2=This action collapses all of the launch configurations currently visible and expanded.	174	CollapseAllLaunchConfigurationAction_2=This action collapses all of the launch configurations currently visible and expanded.
		175	SelectLaunchOptionsDialog_0=\ (with no options)
		176	SelectLaunchOptionsDialog_1=:
		177	SelectLaunchOptionsDialog_2=A plugin that once provided the ability to launch the saved set of launch options for the current launch configuration is no longer available. As such, you must select a valid set of launch options that can be launched
		178	SelectLaunchOptionsDialog_3=Select Launch Options
		179	SelectLaunchOptionsDialog_4=&Select a supported options combination:
		180	SelectLaunchOptionsDialog_5=\ for




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.IConfigurationElementConstants;
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(IConfigurationElementConstants.ID), mode);
		return (extension != null ? extension.getDescription(mode) : null);
	}	
	

Lines 58-63 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationsMessages.java (+22 lines)
58	public static String LaunchConfigurationDialog__Apply_17;	58	public static String LaunchConfigurationDialog__Apply_17;
59	public static String LaunchConfigurationDialog__Name__16;	59	public static String LaunchConfigurationDialog__Name__16;
60	public static String LaunchConfigurationDialog_An_exception_occurred_while_retrieving_launch_configurations_20;	60	public static String LaunchConfigurationDialog_An_exception_occurred_while_retrieving_launch_configurations_20;
		61
		62	public static String LaunchConfigurationEditDialog_0;
		63
		64	public static String LaunchConfigurationEditDialog_1;
61	public static String LaunchConfigurationTabGroupViewer_0;	65	public static String LaunchConfigurationTabGroupViewer_0;
62	public static String LaunchConfigurationDialog_Create__manage__and_run_launch_configurations_8;	66	public static String LaunchConfigurationDialog_Create__manage__and_run_launch_configurations_8;
63	public static String LaunchConfigurationDialog_Dele_te_14;	67	public static String LaunchConfigurationDialog_Dele_te_14;
Lines 89-95 Link Here
89	public static String LaunchConfigurationsDialog_Information_3;	93	public static String LaunchConfigurationsDialog_Information_3;
90	public static String LaunchConfigurationPresentationManager_No_tab_group_defined_for_launch_configuration_type__0__3;	94	public static String LaunchConfigurationPresentationManager_No_tab_group_defined_for_launch_configuration_type__0__3;
91		95
		96	public static String LaunchConfigurationTabGroupViewer_14;
		97
92	public static String LaunchConfigurationTabGroupViewer_9;	98	public static String LaunchConfigurationTabGroupViewer_9;
		99	public static String LaunchConfigurationTabGroupViewer_10;
		100	public static String LaunchConfigurationTabGroupViewer_11;
		101	public static String LaunchConfigurationTabGroupViewer_12;
		102	public static String LaunchConfigurationTabGroupViewer_13;
93	public static String PerspectiveManager_Error_1;	103	public static String PerspectiveManager_Error_1;
94	public static String PerspectiveManager_Unable_to_switch_perpsectives_as_specified_by_launch___0__4;	104	public static String PerspectiveManager_Unable_to_switch_perpsectives_as_specified_by_launch___0__4;
95	public static String PerspectiveManager_Unable_to_switch_to_perspective___0__2;	105	public static String PerspectiveManager_Unable_to_switch_to_perspective___0__2;
Lines 203-206 Link Here
203		213
204	public static String CollapseAllLaunchConfigurationAction_2;	214	public static String CollapseAllLaunchConfigurationAction_2;
205		215
		216	public static String SelectLaunchOptionsDialog_0;
		217
		218	public static String SelectLaunchOptionsDialog_1;
		219
		220	public static String SelectLaunchOptionsDialog_2;
		221
		222	public static String SelectLaunchOptionsDialog_3;
		223
		224	public static String SelectLaunchOptionsDialog_4;
		225
		226	public static String SelectLaunchOptionsDialog_5;
		227
206	}	228	}

Lines 526-532 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationsDialog.java (-2 / +2 lines)
526	IStructuredSelection selection = (IStructuredSelection)fLaunchConfigurationView.getViewer().getSelection();	526	IStructuredSelection selection = (IStructuredSelection)fLaunchConfigurationView.getViewer().getSelection();
527	Object target = selection.getFirstElement();	527	Object target = selection.getFirstElement();
528	if (target instanceof ILaunchConfiguration) {	528	if (target instanceof ILaunchConfiguration) {
529	if (getTabViewer().canLaunch()) {	529	if (getTabViewer().canLaunch() & getTabViewer().canLaunchWithOptions()) {
530	handleLaunchPressed();	530	handleLaunchPressed();
531	}	531	}
532	} else {	532	} else {
Lines 1431-1437 Link Here
1431	getDeleteAction().setEnabled(getDeleteAction().isEnabled());	1431	getDeleteAction().setEnabled(getDeleteAction().isEnabled());
1432	getDuplicateAction().setEnabled(getDuplicateAction().isEnabled());	1432	getDuplicateAction().setEnabled(getDuplicateAction().isEnabled());
1433	getTabViewer().refresh();	1433	getTabViewer().refresh();
1434	getButton(ID_LAUNCH_BUTTON).setEnabled(getTabViewer().canLaunch());	1434	getButton(ID_LAUNCH_BUTTON).setEnabled(getTabViewer().canLaunch() & getTabViewer().canLaunchWithOptions());
1435	}	1435	}
1436		1436
1437	/* (non-Javadoc)	1437	/* (non-Javadoc)




public class EditLaunchConfigurationAction extends SelectionListenerAction {
	
	private ILaunchConfiguration fConfiguration = null;
	private String fMode = null;
	private boolean fTerminated = false;

	/**
	 * Constructs a new action.

					}	
					setLaunchConfiguration(configuration);
					setMode(launch.getLaunchMode());
					setIsTerminated(launch.isTerminated());
					setText(MessageFormat.format(ActionMessages.EditLaunchConfigurationAction_1, new String[]{configuration.getName()})); 
					ImageDescriptor descriptor = null;
					try {

		return fMode;
	}
	
	protected boolean isTerminated() {
		return fTerminated;
	}
	
	protected void setIsTerminated(boolean terminated) {
		fTerminated = terminated;
	}
	
	/**
	 * @see org.eclipse.jface.action.IAction#run()
	 */
	public void run() {
		ILaunchGroup group = DebugUITools.getLaunchGroup(getLaunchConfiguration(), getMode());
		if (group != null) {
			if(isTerminated()) {
				DebugUITools.openLaunchConfigurationDialog(
					DebugUIPlugin.getShell(), getLaunchConfiguration(),
					group.getIdentifier(), null);
			}
			else {
				DebugUITools.openLaunchConfigurationEditDialog(
						DebugUIPlugin.getShell(), getLaunchConfiguration(),
						group.getIdentifier(), null);
			}
		}
	}


Lines 258-264 Link Here

(-)ui/org/eclipse/debug/internal/ui/sourcelookup/SourceLookupPanel.java (-1 / +2 lines)
258	if (type == null) {	258	if (type == null) {
259	type = configuration.getType().getSourceLocatorId();	259	type = configuration.getType().getSourceLocatorId();
260	}	260	}
261	}catch(CoreException e){	261	}
		262	catch(CoreException e){
262	setErrorMessage(e.getMessage());	263	setErrorMessage(e.getMessage());
263	return;	264	return;
264	}	265	}




<?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>




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.internal.ui.launchConfigurations;

import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Shell;

/**
 * This class is used to construct a launch configuraityon dialog used to edit a launch configuration and continue,
 * not allowing a launch to occur.
 * 
 * @since 3.3
 * 
 * EXPERIMENTAL
 */
public class LaunchConfigurationEditDialog extends LaunchConfigurationDialog {

	public LaunchConfigurationEditDialog(Shell shell, ILaunchConfiguration launchConfiguration, LaunchGroupExtension group) {
		super(shell, launchConfiguration, group);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationPropertiesDialog#getTitleAreaTitle()
	 */
	protected String getTitleAreaTitle() {
		return LaunchConfigurationsMessages.LaunchConfigurationEditDialog_0; 
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationPropertiesDialog#createButtonsForButtonBar(org.eclipse.swt.widgets.Composite)
	 */
	protected void createButtonsForButtonBar(Composite parent) {
		createButton(parent, ID_CLOSE_BUTTON, LaunchConfigurationsMessages.LaunchConfigurationEditDialog_1, true);  
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationPropertiesDialog#updateButtons()
	 */
	public void updateButtons() {
		getTabViewer().refresh();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationPropertiesDialog#getDialogSettingsSectionName()
	 */
	protected String getDialogSettingsSectionName() {
		return IDebugUIConstants.PLUGIN_ID + ".LAUNCH_CONFIGURATION_EDIT_DIALOG_SECTION"; //$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.ui;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.debug.internal.core.IConfigurationElementConstants;
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 final class LaunchConfigurationTabExtension {

	/**
	 * 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;
	}
	
	/**
	 * Returns the unique id ofthe tab
	 * @return the unique id of the tab
	 */
	public String getIdentifier() {
		return fElement.getAttribute(IConfigurationElementConstants.ID);
	}

	/**
	 * 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() {
		return fElement.getAttribute(IConfigurationElementConstants.NAME);
	}

	/**
	 * Returns the instantiated class of this tab
	 * @return the instantiated class of this tab
	 */
	public ILaunchConfigurationTab getTab() {
		try {
			Object object = fElement.createExecutableExtension(IConfigurationElementConstants.CLASS);
			if(object instanceof ILaunchConfigurationTab) {
				return (ILaunchConfigurationTab) object;
			}
		} catch (CoreException e) {DebugUIPlugin.log(e);}
		return null;
	}

	/**
	 * 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() {
		return fElement.getAttribute(IConfigurationElementConstants.GROUP);
	}

}




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

import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationListener;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.swt.widgets.Composite;

/**
 * This class provides a basis for the contribution of an <code>ILaunchConfigurationTab</code> which manipulates
 * a specified launch modification option.
 * 
 * This class is intended to be subclassed by clients, and should be subclassed if a tab with an option it contributed
 * 
 * @since 3.3
 * 
 * EXPERIMENTAL
 */
public abstract class AbstractOptionLaunchConfigurationTab extends AbstractLaunchConfigurationTab implements ILaunchConfigurationListener {
	
	/**
	 * This method returns the name of the option that this tab controls
	 * @return the name of the option that this tab is to control
	 */
	public abstract Set getOptions();
	
	/**
	 * This method is used to update the controls associated with setting the option for this tab.
	 * Update of the control takes place when a launch configuration has changed, which can occur when a tab 
	 * is deactivated, or if an option is modified outside of the tabs' control.
	 * @param options the current list of options from the working copy
	 */
	public abstract void updateOptionControls(Set options);
	
	/**
	 * @see org.eclipse.debug.ui.ILaunchConfigurationTab#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public void createControl(Composite parent) {
		DebugPlugin.getDefault().getLaunchManager().addLaunchConfigurationListener(this);
	}
	
	/**
	 * @see org.eclipse.debug.ui.ILaunchConfigurationTab#dispose()
	 */
	public void dispose() {
		DebugPlugin.getDefault().getLaunchManager().removeLaunchConfigurationListener(this);
		super.dispose();
	}

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

	/**
	 * @see org.eclipse.debug.core.ILaunchConfigurationListener#launchConfigurationRemoved(org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public void launchConfigurationRemoved(ILaunchConfiguration configuration) {}
	
	/**
	 * @see org.eclipse.debug.core.ILaunchConfigurationListener#launchConfigurationChanged(org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public void launchConfigurationChanged(ILaunchConfiguration configuration) {
		try {
			updateOptionControls(configuration.getOptions());
		} 
		catch (CoreException e) {DebugUIPlugin.log(e);}
	}

}




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

import java.util.Set;

import org.eclipse.debug.internal.core.LaunchDelegate;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.IDebugHelpContextIds;
import org.eclipse.debug.internal.ui.SWTUtil;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.SelectionDialog;

/**
 * This class provides a dialog to present the user with a list of of viable launch options in the event 
 * the plugin that provides either a launch option or a contributed launch delegate is no longer available.
 * The user can select one of the launch mode/option configuration sform this dialog and repair the option 
 * configuration state of the the current launch configuration
 * 
 *  @since 3.3
 *  
 *  EXPERIMENTAL
 */
public class SelectLaunchOptionsDialog extends SelectionDialog {

	/**
	 * Builds labels for list control of the form: Mode + (no options) | [optionslist]
	 */
	class OptionsLabelProvider implements ILabelProvider {
		public Image getImage(Object element) {return null;}
		public String getText(Object element) {
			LaunchDelegate del = (LaunchDelegate) element;
			Set set = del.getOptions();
			return del.getName() + LaunchConfigurationsMessages.SelectLaunchOptionsDialog_5 + fMode + (set.isEmpty() ? LaunchConfigurationsMessages.SelectLaunchOptionsDialog_0 : LaunchConfigurationsMessages.SelectLaunchOptionsDialog_1 + set);
		}
		public void addListener(ILabelProviderListener listener) {}
		public void dispose() {}
		public boolean isLabelProperty(Object element, String property) {return false;}
		public void removeListener(ILabelProviderListener listener) {}
	}
	
	private static final String SETTINGS_ID = IDebugUIConstants.PLUGIN_ID + ".SELECT_LAUNCH_OPTIONS_DIALOG"; //$NON-NLS-1$
	
	private LaunchDelegate[] fDelegates = null;
	private String fMode = null;
	private Object[] fResult = null;
	private CheckboxTableViewer fTableViewer = null;
	private Table fTable  = null;
	
	/**
	 * Constructor
	 * @param parentShell the parent shell
	 * @param message the message for the dialog
	 * @param options the listing of arrays of options (each entry in the list must be an <code>Set</code> of options)
	 */
	public SelectLaunchOptionsDialog(Shell parentShell, String mode, LaunchDelegate[] delegates) {
		super(parentShell);
		super.setMessage(LaunchConfigurationsMessages.SelectLaunchOptionsDialog_2);
		super.setTitle(LaunchConfigurationsMessages.SelectLaunchOptionsDialog_3);
		setShellStyle(getShellStyle() | SWT.RESIZE);
		fDelegates = delegates;
		fMode = mode;
	}
	
	/**
	 * @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createDialogArea(Composite parent) {
		initializeDialogUnits(parent);
		Composite comp = (Composite) super.createDialogArea(parent);
		SWTUtil.createLabel(comp, LaunchConfigurationsMessages.SelectLaunchOptionsDialog_4, 1);
		fTable = new Table(comp, SWT.BORDER | SWT.SINGLE | SWT.CHECK);
		fTable.setLayoutData(new GridData(GridData.FILL_BOTH));
		fTableViewer = new CheckboxTableViewer(fTable);
		fTableViewer.setLabelProvider(new OptionsLabelProvider());
		fTableViewer.setContentProvider(new ArrayContentProvider());
		fTableViewer.setInput(fDelegates);
		fTableViewer.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				fTableViewer.setAllChecked(false);
				fTableViewer.setChecked(event.getElement(), true);
			}
		});
		Dialog.applyDialogFont(comp);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(comp, IDebugHelpContextIds.SELECT_LAUNCH_OPTIONS_DIALOG);
		return comp;
	}
	
	/**
	 * @see org.eclipse.ui.dialogs.SelectionDialog#getResult()
	 */
	public Object[] getResult() {
		return fResult;
	}

	/**
	 * @see org.eclipse.jface.dialogs.Dialog#okPressed()
	 */
	protected void okPressed() {
		Object[] o =  fTableViewer.getCheckedElements();
		if(o.length > 0) {
			fResult = ((LaunchDelegate)o[0]).getOptions().toArray();
		}
		super.okPressed();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.dialogs.SelectionDialog#getDialogBoundsSettings()
	 */
	protected IDialogSettings getDialogBoundsSettings() {
		IDialogSettings settings = DebugUIPlugin.getDefault().getDialogSettings();
		IDialogSettings section = settings.getSection(SETTINGS_ID);
		if (section == null) {
			section = settings.addNewSection(SETTINGS_ID);
		} 
		return section;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.Dialog#getInitialSize()
	 */
	protected Point getInitialSize() {
		IDialogSettings settings = getDialogBoundsSettings();
		if(settings != null) {
			try {
				int width = settings.getInt("DIALOG_WIDTH"); //$NON-NLS-1$
				int height = settings.getInt("DIALOG_HEIGHT"); //$NON-NLS-1$
				if(width > 0 & height > 0) {
					return new Point(width, height);
				}
			}
			catch (NumberFormatException nfe) {
				return new Point(350, 400);
			}
		}
		return new Point(350, 400);
	}

}




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

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.IStatusHandler;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.ui.DebugUITools;

/**
 * This class provides a mechanism to prompt users in the UI thread from debug.core in the case where
 * a launch delegate has gone missing and a new choice needs to be made in the launch dialog.
 * 
 * @since 3.3
 * 
 * EXPERIMENTAL
 */
public class LaunchDelegateNotAvailableHandler implements IStatusHandler {

	/**
	 * @see org.eclipse.debug.core.IStatusHandler#handleStatus(org.eclipse.core.runtime.IStatus, java.lang.Object)
	 */
	public Object handleStatus(IStatus status, Object source) throws CoreException {
		if(source instanceof Object[]) {
			Object[] infos = (Object[]) source;
			if(infos.length == 2) {
				ILaunchConfiguration config = (ILaunchConfiguration) infos[0];
				String mode = (String) infos[1];
				DebugUITools.openLaunchConfigurationEditDialog(DebugUIPlugin.getShell(), 
						config, 
						DebugUITools.getLaunchGroup(config, mode).getIdentifier(),
						null);
			}
		}
		return Status.OK_STATUS;
	}
}

Return to bug 157059

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 10-35 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchOption.java (-51 / +3 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.debug.internal.core;	11	package org.eclipse.debug.internal.core;
12		12
13	import org.eclipse.core.runtime.CoreException;
14	import org.eclipse.core.runtime.IConfigurationElement;	13	import org.eclipse.core.runtime.IConfigurationElement;
15	import org.eclipse.core.runtime.IStatus;
16	import org.eclipse.core.runtime.Status;
17	import org.eclipse.debug.core.DebugPlugin;
18	import org.eclipse.debug.core.ILaunchOption;	14	import org.eclipse.debug.core.ILaunchOption;
19		15
20	import com.ibm.icu.text.MessageFormat;
21
22	/**	16	/**
23	* Proxy to a launch option extension	17	* Proxy to a launch option extension
24	*	18	*
25	* @since 3.3	19	* @since 3.3
26	*/	20	*/
27	public class LaunchOption implements ILaunchOption {	21	public class LaunchOption implements ILaunchOption {
28
29	//constants for attribute names
30	private static final String ID = "id"; //$NON-NLS-1$
31	private static final String LABEL = "label"; //$NON-NLS-1$
32	private static final String OPTION = "option"; //$NON-NLS-1$
33		22
34	/**	23	/**
35	* The associated configuration element	24	* The associated configuration element
Lines 40-97 Link Here
40	* Constructor	29	* Constructor
41	* @param element the element to associate this launch option with	30	* @param element the element to associate this launch option with
42	*/	31	*/
43	public LaunchOption(IConfigurationElement element) throws CoreException {	32	public LaunchOption(IConfigurationElement element) {
44	fElement = element;	33	fElement = element;
45	verifyAttributesExist();
46	}	34	}
47		35
48	/* (non-Javadoc)	36	/* (non-Javadoc)
49	* @see org.eclipse.debug.core.ILaunchOption#getIdentifier()	37	* @see org.eclipse.debug.core.ILaunchOption#getIdentifier()
50	*/	38	*/
51	public String getIdentifier() {	39	public String getIdentifier() {
52	return fElement.getAttribute(ID);	40	return fElement.getAttribute(IConfigurationElementConstants.ID);
53	}	41	}
54		42
55	/* (non-Javadoc)	43	/* (non-Javadoc)
56	* @see org.eclipse.debug.core.ILaunchOption#getLabel()	44	* @see org.eclipse.debug.core.ILaunchOption#getLabel()
57	*/	45	*/
58	public String getLabel() {	46	public String getLabel() {
59	return fElement.getAttribute(LABEL);	47	return fElement.getAttribute(IConfigurationElementConstants.LABEL);
60	}
61
62	/* (non-Javadoc)
63	* @see org.eclipse.debug.core.ILaunchOption#getOption()
64	*/
65	public String getOption() {
66	return fElement.getAttribute(OPTION);
67	}
68
69	/**
70	* Checks to ensure that all of the required attributes are present in the <code>IConfigurationElement</code>
71	* @return true if all attributes are present, throws <code>CoreException</code> otherwise
72	* @throws CoreException
73	*/
74	private void verifyAttributesExist() throws CoreException {
75	if(fElement != null) {
76	if(fElement.getAttribute(ID) == null) {
77	missingAttribute(ID);
78	}
79	if(fElement.getAttribute(LABEL) == null) {
80	missingAttribute(LABEL);
81	}
82	if(fElement.getAttribute(OPTION) == null) {
83	missingAttribute(OPTION);
84	}
85	}
86	}
87
88	/**
89	* Throws a <code>CoreException</code> indicating the specified attribute is missing from the extension
90	* point definition
91	* @param attrName the attribute name that is missing
92	* @throws CoreException
93	*/
94	private void missingAttribute(String attrName) throws CoreException {
95	throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, MessageFormat.format(DebugCoreMessages.LaunchOption_0, new String[]{attrName}), null));
96	}	48	}
97	}	49	}

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 42-47 Link Here

(-)core/org/eclipse/debug/internal/core/DebugCoreMessages.properties (-1 / +2 lines)
42	LaunchConfigurationInfo_Invalid_launch_configuration_XML__10=Invalid launch configuration XML.	42	LaunchConfigurationInfo_Invalid_launch_configuration_XML__10=Invalid launch configuration XML.
43	LaunchConfigurationInfo_missing_type=Launch configuration type id \"{0}\" does not exist.\nPossible causes:\n\tMissing specification of a launch type (missing plug-in)\n\tIncorrect launch configuration XML	43	LaunchConfigurationInfo_missing_type=Launch configuration type id \"{0}\" does not exist.\nPossible causes:\n\tMissing specification of a launch type (missing plug-in)\n\tIncorrect launch configuration XML
44	LaunchConfigurationInfo_36=A null key has been specified for an attribute in this launch configuration	44	LaunchConfigurationInfo_36=A null key has been specified for an attribute in this launch configuration
		45	LaunchConfigurationInfo_35=Attribute {0} is not of type java.util.Set.
45	LaunchConfigurationWorkingCopy__0__occurred_generating_launch_configuration_XML__1={0} occurred generating launch configuration XML.	46	LaunchConfigurationWorkingCopy__0__occurred_generating_launch_configuration_XML__1={0} occurred generating launch configuration XML.
46	LaunchConfigurationWorkingCopy_Specified_container_for_launch_configuration_does_not_exist_2=Specified container for launch configuration does not exist	47	LaunchConfigurationWorkingCopy_Specified_container_for_launch_configuration_does_not_exist_2=Specified container for launch configuration does not exist
47	LaunchConfigurationWorkingCopy_5=Unable to save launch configuration.	48	LaunchConfigurationWorkingCopy_5=Unable to save launch configuration.
Lines 63-68 Link Here
63	RuntimeProcess_Exit_value_not_available_until_process_terminates__1=Exit value not available until process terminates.	64	RuntimeProcess_Exit_value_not_available_until_process_terminates__1=Exit value not available until process terminates.
64	LaunchConfigurationType_Launch_delegate_for__0__does_not_implement_required_interface_ILaunchConfigurationDelegate__1=Launch delegate for {0} does not implement required interface ILaunchConfigurationDelegate.	65	LaunchConfigurationType_Launch_delegate_for__0__does_not_implement_required_interface_ILaunchConfigurationDelegate__1=Launch delegate for {0} does not implement required interface ILaunchConfigurationDelegate.
65	LaunchConfigurationType_9=Launch mode {0} not supported for configuration type {1}	66	LaunchConfigurationType_9=Launch mode {0} not supported for configuration type {1}
66	LaunchConfigurationType_10=Launch delegate not registered for configuration type {0}, mode {1}	67	LaunchConfigurationType_10=There is no launch delegate registered for configuration type {0}, mode {1}
67	WatchExpression_0=(Watch expressions not supported)	68	WatchExpression_0=(Watch expressions not supported)
68	NullStreamsProxy_0=Null Stream Monitor	69	NullStreamsProxy_0=Null Stream Monitor

Lines 16-27 Link Here

(-)core/org/eclipse/debug/core/ILaunchOption.java (-12 / +3 lines)
16	*	16	*
17	* Example contribution of the debug launch option:	17	* Example contribution of the debug launch option:
18	* <pre>	18	* <pre>
19	* <extension	19	* <extension point="org.eclipse.debug.core.launchOptions">
20	point="org.eclipse.debug.core.launchOptions">
21	<launchOption	20	<launchOption
22	id="org.eclipse.debug.core.debug"	21	id="org.eclipse.debug.core.debug"
23	label="Debug"	22	label="Debug">
24	option="debug">
25	</launchOption>	23	</launchOption>
26	</extension>	24	</extension>
27	* </pre>	25	* </pre>
Lines 45-58 Link Here
45	public String getLabel();	43	public String getLabel();
46		44
47	/**	45	/**
48	* Returns the launch option defined for this extension. The option is non-translatable, one word and	46	* @return the unique id provided for this option e.g. debug
49	* all lowercase.
50	* @return the option defined by this extension
51	*/
52	public String getOption();
53
54	/**
55	* @return the unique id provided for this option e.g. org.eclipse.debug.core.debug
56	*/	47	*/
57	public String getIdentifier();	48	public String getIdentifier();
58	}	49	}

Lines 229-235 Link Here

(-)core/org/eclipse/debug/core/ILaunchManager.java (-2 / +2 lines)
229	* @param optionId the unique id of the launch option	229	* @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	230	* @return the lauch option associated with ther specified id or <code>null</code> if not found
231	* <p>	231	* <p>
232	* <strong>EXPERIMENTAL</strong>. This ,method has been added as	232	* <strong>EXPERIMENTAL</strong>. This method has been added as
233	* part of a work in progress. There is no guarantee that this API will	233	* 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	234	* remain unchanged during the 3.3 release cycle. Please do not use this API
235	* without consulting with the Platform/Debug team.	235	* without consulting with the Platform/Debug team.
Lines 242-248 Link Here
242	* Returns all registered launch options	242	* Returns all registered launch options
243	* @return all registered launch options	243	* @return all registered launch options
244	* <p>	244	* <p>
245	* <strong>EXPERIMENTAL</strong>. This ,method has been added as	245	* <strong>EXPERIMENTAL</strong>. This method has been added as
246	* part of a work in progress. There is no guarantee that this API will	246	* 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	247	* remain unchanged during the 3.3 release cycle. Please do not use this API
248	* without consulting with the Platform/Debug team.	248	* without consulting with the Platform/Debug team.

Lines 13-18 Link Here

(-)core/org/eclipse/debug/core/ILaunchConfiguration.java (+36 lines)
13		13
14	import java.util.List;	14	import java.util.List;
15	import java.util.Map;	15	import java.util.Map;
		16	import java.util.Set;
16		17
17	import org.eclipse.core.resources.IFile;	18	import org.eclipse.core.resources.IFile;
18	import org.eclipse.core.resources.IResource;	19	import org.eclipse.core.resources.IResource;
Lines 190-195 Link Here
190	public List getAttribute(String attributeName, List defaultValue) throws CoreException;	191	public List getAttribute(String attributeName, List defaultValue) throws CoreException;
191		192
192	/**	193	/**
		194	* Returns the <code>java.util.Set</code>-valued attribute with the given name.
		195	* Returns the given default value if the attribute is undefined.
		196	*
		197	* @param attributeName the name of the attribute
		198	* @param defaultValue the value to use if no value is found
		199	* @return the value or the default value if no value was found.
		200	* @exception CoreException if this method fails. Reasons include:
		201	* <ul>
		202	* <li>An exception occurs while retrieving the attribute from
		203	* underlying storage.</li>
		204	* <li>An attribute with the given name exists, but does not
		205	* have a List value</li>
		206	* </ul>
		207	*
		208	* @since 3.3
		209	*
		210	* EXPERIMENTAL
		211	*/
		212	public Set getAttribute(String attributeName, Set defaultValue) throws CoreException;
		213
		214	/**
193	* Returns the <code>java.util.Map</code>-valued attribute with the given name.	215	* Returns the <code>java.util.Map</code>-valued attribute with the given name.
194	* Returns the given default value if the attribute is undefined.	216	* Returns the given default value if the attribute is undefined.
195	*	217	*
Lines 304-309 Link Here
304	public String getName();	326	public String getName();
305		327
306	/**	328	/**
		329	*
		330	* @return returns the options that this configuration supports
		331	*
		332	* <p>
		333	* <strong>EXPERIMENTAL</strong>. This method has been added as
		334	* part of a work in progress. There is no guarantee that this API will
		335	* remain unchanged during the 3.3 release cycle. Please do not use this API
		336	* without consulting with the Platform/Debug team.
		337	* </p>
		338	* @since 3.3
		339	*/
		340	public Set getOptions() throws CoreException;
		341
		342	/**
307	* Returns the type of this launch configuration. This is a	343	* Returns the type of this launch configuration. This is a
308	* handle-only method.	344	* handle-only method.
309	*	345	*

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 60-81 Link Here

(-)schema/launchConfigurationTypes.exsd (-3 / +46 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-111 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 sourcePathComputer id should be contributed via the <code>launchDelegates</code> extension point
109	</documentation>	131	</documentation>
110	</annotation>	132	</annotation>
111	</attribute>	133	</attribute>
Lines 113-118 Link Here
113	<annotation>	135	<annotation>
114	<documentation>	136	<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.	137	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.
		138
		139	With new API changes for 3.3M3 the sourceLocatorId id should be contributed via the <code>launchDelegates</code> extension point
116	</documentation>	140	</documentation>
117	</annotation>	141	</annotation>
118	</attribute>	142	</attribute>
Lines 126-131 Link Here
126	</appInfo>	150	</appInfo>
127	</annotation>	151	</annotation>
128	</attribute>	152	</attribute>
		153	<attribute name="icon" type="string">
		154	<annotation>
		155	<documentation>
		156	The id of the icon for this launch configuraiton type.
		157
		158	since 3.3
		159
		160	<p>
		161	<strong>EXPERIMENTAL</strong>. This element has been added as
		162	part of a work in progress. There is no guarantee that this API will
		163	remain unchanged during the 3.3 release cycle. Please do not use this API
		164	without consulting with the Platform/Debug team.
		165	</p>
		166	</documentation>
		167	<appInfo>
		168	<meta.attribute kind="resource"/>
		169	</appInfo>
		170	</annotation>
		171	</attribute>
129	</complexType>	172	</complexType>
130	</element>	173	</element>
131		174

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 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/internal/core/IConfigurationElementConstants.java (+118 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.core;
12
13	/**
14	* This interface provides a repository for the names of <code>IConfigurationElement</code> child node ids.
15	* @since 3.3
16	*/
17	public interface IConfigurationElementConstants {
18
19	/**
20	* The id node name for a configuration element
21	*/
22	public static final String ID = "id"; //$NON-NLS-1$
23
24	/**
25	* the name node name for a configuration element
26	*/
27	public static final String NAME = "name"; //$NON-NLS-1$
28
29	/**
30	* the category node name for a configuration element
31	*/
32	public static final String CATEGORY = "category"; //$NON-NLS-1$
33
34	/**
35	* the launchMode node name for a configuration element
36	*/
37	public static final String LAUNCH_MODE = "launchMode"; //$NON-NLS-1$
38
39	/**
40	* the label node name for a configuration element
41	*/
42	public static final String LABEL = "label"; //$NON-NLS-1$
43
44	/**
45	* the description node name for a configuration element
46	*/
47	public static final String DESCRIPTION = "description"; //$NON-NLS-1$
48
49	/**
50	* the helpContextId node name for a configuration element
51	*/
52	public static final String HELP_CONTEXT_ID = "helpContextId"; //$NON-NLS-1$
53
54	/**
55	* the icon node name for a configuration element
56	*/
57	public static final String ICON = "icon"; //$NON-NLS-1$
58
59	/**
60	* the public node name for a configuration element
61	*/
62	public static final String PUBLIC = "public"; //$NON-NLS-1$
63
64	/**
65	* the perspective node name for a configuration element
66	*/
67	public static final String PERSPECTIVE = "perspective"; //$NON-NLS-1$
68
69	/**
70	* the modes node name for a configuration element
71	*/
72	public static final String MODES = "modes"; //$NON-NLS-1$
73
74	/**
75	* the mode node name for a configuration element
76	*/
77	public static final String MODE = "mode"; //$NON-NLS-1$
78
79	/**
80	* the type node name for a configuration element
81	*/
82	public static final String TYPE = "type"; //$NON-NLS-1$
83
84	/**
85	* the option node name for a configuration element
86	*/
87	public static final String OPTIONS = "options"; //$NON-NLS-1$
88
89	/**
90	* the delegate node name for a configuration element
91	*/
92	public static final String DELEGATE = "delegate"; //$NON-NLS-1$
93
94	/**
95	* the group node name for a configuration element
96	*/
97	public static final String GROUP = "group"; //$NON-NLS-1$
98
99	/**
100	* the class node name for a configuration element
101	*/
102	public static final String CLASS = "class"; //$NON-NLS-1$
103
104	/**
105	* the sourcePathComputerId node name for a configuration element
106	*/
107	public static final String SOURCE_PATH_COMPUTER = "sourcePathComputerId"; //$NON-NLS-1$
108
109	/**
110	* the sourceLocatorId node name for a configuration element
111	*/
112	public static final String SOURCE_LOCATOR = "sourceLocatorId"; //$NON-NLS-1$
113
114	/**
115	* the migrationDelegate node name for a configuration element
116	*/
117	public static final String MIGRATION_DELEGATE = "migrationDelegate"; //$NON-NLS-1$
118	}

Lines 27-54 Link Here

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

Lines 2-14 Link Here

(-)schema/launchConfigurationTypeImages.exsd (-31 / +22 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	</documentation>
11	</annotation>	11	</annotation>
12		12
13	<element name="extension">	13	<element name="extension">
14	<complexType>	14	<complexType>
Lines 22-45 Link Here
22	</documentation>	22	</documentation>
23	</annotation>	23	</annotation>
24	</attribute>	24	</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>	25	</complexType>
40	</element>	26	</element>
41		27
42	<element name="launchConfigurationTypeImage">	28	<element name="launchConfigurationTypeImage">
		29	<annotation>
		30	<documentation>
		31	<p>In 3.3, if possible, the image for a launch configuration type should be moved to the launch configuration type extension contribution</p>
		32	</documentation>
		33	</annotation>
43	<complexType>	34	<complexType>
44	<attribute name="id" type="string" use="required">	35	<attribute name="id" type="string" use="required">
45	<annotation>	36	<annotation>
Lines 51-57 Link Here
51	<attribute name="configTypeID" type="string" use="required">	42	<attribute name="configTypeID" type="string" use="required">
52	<annotation>	43	<annotation>
53	<documentation>	44	<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).	45	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>	46	</documentation>
56	</annotation>	47	</annotation>
57	</attribute>	48	</attribute>
Lines 77-100 Link Here
77		68
78	<p>	69	<p>
79	<pre>	70	<pre>
80	<extension point="org.eclipse.debug.ui.launchConfigurationTypeImages">	71	<extension point="org.eclipse.debug.ui.launchConfigurationTypeImages">
81	<launchConfigurationTypeImage	72	<launchConfigurationTypeImage
82	id="com.example.FirstLaunchConfigurationTypeImage"	73	id="com.example.FirstLaunchConfigurationTypeImage"
83	configTypeID="com.example.FirstLaunchConfigurationType"	74	configTypeID="com.example.FirstLaunchConfigurationType"
84	icon="icons/FirstLaunchConfigurationType.gif">	75	icon="icons/FirstLaunchConfigurationType.gif">
85	</launchConfigurationTypeImage>	76	</launchConfigurationTypeImage>
86	</extension>	77	</extension>
87	</pre>	78	</pre>
88	</p>	79	</p>
89	</documentation>	80	</documentation>
90	</annotation>	81	</annotation>
91		82
92	<annotation>	83	<annotation>
93	<appInfo>	84	<appInfo>
94	<meta.section type="copyright"/>	85	<meta.section type="copyright"/>
95	</appInfo>	86	</appInfo>
96	<documentation>	87	<documentation>
97	Copyright (c) 2000, 2005 IBM Corporation and others.<br>	88	Copyright (c) 2000, 2005 IBM Corporation and others.<br>
98	All rights reserved. This program and the accompanying materials are made	89	All rights reserved. This program and the accompanying materials are made
99	available under the terms of the Eclipse Public License v1.0 which	90	available under the terms of the Eclipse Public License v1.0 which
100	accompanies this distribution, and is available at	91	accompanies this distribution, and is available at

Lines 35-40 Link Here

(-)ui/org/eclipse/debug/ui/DebugUITools.java (-1 / +34 lines)
35	import org.eclipse.debug.internal.ui.LazyModelPresentation;	35	import org.eclipse.debug.internal.ui.LazyModelPresentation;
36	import org.eclipse.debug.internal.ui.contexts.DebugContextManager;	36	import org.eclipse.debug.internal.ui.contexts.DebugContextManager;
37	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationDialog;	37	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationDialog;
		38	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationEditDialog;
38	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;	39	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
39	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationPropertiesDialog;	40	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationPropertiesDialog;
40	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationsDialog;	41	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationsDialog;
Lines 458-464 Link Here
458		459
459	return Window.CANCEL;	460	return Window.CANCEL;
460	}	461	}
461		462
		463	/**
		464	* Open the launch configuration dialog on the specified launch
		465	* configuration. The dialog displays the tabs for a single configuration
		466	* only (a tree of launch configuration is not displayed)
		467	* <p>
		468	* If a status is specified, a status handler is consulted to handle the
		469	* status. The status handler is passed the instance of the launch
		470	* configuration dialog that is opened. This gives the status handler an
		471	* opportunity to perform error handling/initialization as required.
		472	* </p>
		473	* @param shell the parent shell for the launch configuration dialog
		474	* @param configuration the configuration to display
		475	* @param groupIdentifier group identifier of the launch group the launch configuration
		476	* belongs to
		477	* @param status the status to display, or <code>null</code> if none
		478	* @return the return code from opening the launch configuration dialog -
		479	* one of <code>Window.OK</code> or <code>Window.CANCEL</code>
		480	*
		481	* @since 3.3
		482	*
		483	* EXPERIMENTAL
		484	*/
		485	public static int openLaunchConfigurationEditDialog(Shell shell, ILaunchConfiguration configuration, String groupIdentifier, IStatus status) {
		486	LaunchGroupExtension group = DebugUIPlugin.getDefault().getLaunchConfigurationManager().getLaunchGroup(groupIdentifier);
		487	if (group != null) {
		488	LaunchConfigurationEditDialog dialog = new LaunchConfigurationEditDialog(shell, configuration, group);
		489	dialog.setInitialStatus(status);
		490	return dialog.open();
		491	}
		492	return Window.CANCEL;
		493	}
		494
462	/**	495	/**
463	* Saves all dirty editors and builds the workspace according to current	496	* Saves all dirty editors and builds the workspace according to current
464	* preference settings, and returns whether a launch should proceed.	497	* preference settings, and returns whether a launch should proceed.

Lines 36-42 Link Here

(-)ui/org/eclipse/debug/internal/ui/actions/EditLaunchConfigurationAction.java (-4 / +21 lines)
36	public class EditLaunchConfigurationAction extends SelectionListenerAction {	36	public class EditLaunchConfigurationAction extends SelectionListenerAction {
37		37
38	private ILaunchConfiguration fConfiguration = null;	38	private ILaunchConfiguration fConfiguration = null;
39	private String fMode =null;	39	private String fMode = null;
		40	private boolean fTerminated = false;
40		41
41	/**	42	/**
42	* Constructs a new action.	43	* Constructs a new action.
Lines 87-92 Link Here
87	}	88	}
88	setLaunchConfiguration(configuration);	89	setLaunchConfiguration(configuration);
89	setMode(launch.getLaunchMode());	90	setMode(launch.getLaunchMode());
		91	setIsTerminated(launch.isTerminated());
90	setText(MessageFormat.format(ActionMessages.EditLaunchConfigurationAction_1, new String[]{configuration.getName()}));	92	setText(MessageFormat.format(ActionMessages.EditLaunchConfigurationAction_1, new String[]{configuration.getName()}));
91	ImageDescriptor descriptor = null;	93	ImageDescriptor descriptor = null;
92	try {	94	try {
Lines 123-137 Link Here
123	return fMode;	125	return fMode;
124	}	126	}
125		127
		128	protected boolean isTerminated() {
		129	return fTerminated;
		130	}
		131
		132	protected void setIsTerminated(boolean terminated) {
		133	fTerminated = terminated;
		134	}
		135
126	/**	136	/**
127	* @see org.eclipse.jface.action.IAction#run()	137	* @see org.eclipse.jface.action.IAction#run()
128	*/	138	*/
129	public void run() {	139	public void run() {
130	ILaunchGroup group = DebugUITools.getLaunchGroup(getLaunchConfiguration(), getMode());	140	ILaunchGroup group = DebugUITools.getLaunchGroup(getLaunchConfiguration(), getMode());
131	if (group != null) {	141	if (group != null) {
132	DebugUITools.openLaunchConfigurationDialog(	142	if(isTerminated()) {
133	DebugUIPlugin.getShell(), getLaunchConfiguration(),	143	DebugUITools.openLaunchConfigurationDialog(
134	group.getIdentifier(), null);	144	DebugUIPlugin.getShell(), getLaunchConfiguration(),
		145	group.getIdentifier(), null);
		146	}
		147	else {
		148	DebugUITools.openLaunchConfigurationEditDialog(
		149	DebugUIPlugin.getShell(), getLaunchConfiguration(),
		150	group.getIdentifier(), null);
		151	}
135	}	152	}
136	}	153	}
137		154

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>

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/AbstractOptionLaunchConfigurationTab.java (+83 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	import java.util.Set;
14
15	import org.eclipse.core.runtime.CoreException;
16	import org.eclipse.debug.core.DebugPlugin;
17	import org.eclipse.debug.core.ILaunchConfiguration;
18	import org.eclipse.debug.core.ILaunchConfigurationListener;
19	import org.eclipse.debug.internal.ui.DebugUIPlugin;
20	import org.eclipse.swt.widgets.Composite;
21
22	/**
23	* This class provides a basis for the contribution of an <code>ILaunchConfigurationTab</code> which manipulates
24	* a specified launch modification option.
25	*
26	* This class is intended to be subclassed by clients, and should be subclassed if a tab with an option it contributed
27	*
28	* @since 3.3
29	*
30	* EXPERIMENTAL
31	*/
32	public abstract class AbstractOptionLaunchConfigurationTab extends AbstractLaunchConfigurationTab implements ILaunchConfigurationListener {
33
34	/**
35	* This method returns the name of the option that this tab controls
36	* @return the name of the option that this tab is to control
37	*/
38	public abstract Set getOptions();
39
40	/**
41	* This method is used to update the controls associated with setting the option for this tab.
42	* Update of the control takes place when a launch configuration has changed, which can occur when a tab
43	* is deactivated, or if an option is modified outside of the tabs' control.
44	* @param options the current list of options from the working copy
45	*/
46	public abstract void updateOptionControls(Set options);
47
48	/**
49	* @see org.eclipse.debug.ui.ILaunchConfigurationTab#createControl(org.eclipse.swt.widgets.Composite)
50	*/
51	public void createControl(Composite parent) {
52	DebugPlugin.getDefault().getLaunchManager().addLaunchConfigurationListener(this);
53	}
54
55	/**
56	* @see org.eclipse.debug.ui.ILaunchConfigurationTab#dispose()
57	*/
58	public void dispose() {
59	DebugPlugin.getDefault().getLaunchManager().removeLaunchConfigurationListener(this);
60	super.dispose();
61	}
62
63	/**
64	* @see org.eclipse.debug.core.ILaunchConfigurationListener#launchConfigurationAdded(org.eclipse.debug.core.ILaunchConfiguration)
65	*/
66	public void launchConfigurationAdded(ILaunchConfiguration configuration) {}
67
68	/**
69	* @see org.eclipse.debug.core.ILaunchConfigurationListener#launchConfigurationRemoved(org.eclipse.debug.core.ILaunchConfiguration)
70	*/
71	public void launchConfigurationRemoved(ILaunchConfiguration configuration) {}
72
73	/**
74	* @see org.eclipse.debug.core.ILaunchConfigurationListener#launchConfigurationChanged(org.eclipse.debug.core.ILaunchConfiguration)
75	*/
76	public void launchConfigurationChanged(ILaunchConfiguration configuration) {
77	try {
78	updateOptionControls(configuration.getOptions());
79	}
80	catch (CoreException e) {DebugUIPlugin.log(e);}
81	}
82
83	}