Attachment #51706 for bug #157059

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




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

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

	public ILaunchOption[] getLaunchOptions();
	
	/**
	 * Returns whether the specified launch option is a valid launch option or not.
	 * Validity is based on if the launch option has been contributed via the <code>launchOptions</code>
	 * extension point or not.
	 * 
	 * @param option the name of the specified launch option
	 * @return true if the sepcified launch option is valid, false otherwise
	 * 
	 * <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 boolean isValidLaunchOption(String 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 ILaunchDelegate[] getLaunchDelegates();
	
	/** 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 ILaunchDelegate[] getLaunchDelegates(String typeid, String mode, String[] options); 
	
	/**
	 * Returns a collection of launch configurations that required migration to be
	 * compatible with current tooling.
	 * 




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




	 * @since 3.2
	 */
	public void setMappedResources(IResource[] resources);
	
	/**
	 * This method is used to set the options for the associated <code>ILaunchConfiguraiton</code>.
	 * @param option the name of the option to set
	 * @param set if the option should be set or removed. true adds the option to the listing, false removes it. 
	 * 
	 * <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 setOption(String option, boolean set);
}




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

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




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

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

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

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

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

			}
		}
	}

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

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

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

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

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

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

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

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

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

Lines 16-22 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchConfigurationWorkingCopy.java (-8 / +23 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;
Lines 40-45 Link Here
40	import org.eclipse.debug.core.ILaunchConfigurationType;	39	import org.eclipse.debug.core.ILaunchConfigurationType;
41	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;	40	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
42		41
		42	import com.ibm.icu.text.MessageFormat;
		43
43	/**	44	/**
44	* A working copy launch configuration	45	* A working copy launch configuration
45	*/	46	*/
Lines 194-200 Link Here
194	}	195	}
195	// write the new file	196	// write the new file
196	writeNewFile();	197	writeNewFile();
197	resetDirty();	198	fDirty = false;
198	}	199	}
199		200
200	/**	201	/**
Lines 350-356 Link Here
350	LaunchConfigurationInfo info = original.getInfo();	351	LaunchConfigurationInfo info = original.getInfo();
351	setInfo(info.getCopy());	352	setInfo(info.getCopy());
352	setContainer(original.getContainer());	353	setContainer(original.getContainer());
353	resetDirty();	354	fDirty = false;
354	}	355	}
355		356
356	/**	357	/**
Lines 404-413 Link Here
404	}	405	}
405		406
406	/**	407	/**
407	* Sets this working copy's state to not dirty.	408	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#setOptions(java.lang.String[])
408	*/	409	*/
409	private void resetDirty() {	410	public void setOption(String option, boolean set) {
410	fDirty = false;	411	try {
		412	List options = getOptions();
		413	if(option != null) {
		414	int idx = options.indexOf(option);
		415	if(idx > -1 && !set) {
		416	options.remove(idx);
		417	}
		418	else if(idx < 0 && set) {
		419	options.add(option);
		420	}
		421	}
		422	getInfo().setAttribute(ATTR_LAUNCH_OPTIONS, (options.size() > 0 ? options : null));
		423	setDirty();
		424	}
		425	catch (CoreException e) {DebugPlugin.log(e);}
411	}	426	}
412		427
413	/**	428	/**
Lines 574-580 Link Here
574	}	589	}
575	setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_PATHS, paths);	590	setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_PATHS, paths);
576	setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_TYPES, types);	591	setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_TYPES, types);
577	}//end setResource	592	}
578		593
579	}//end class	594	}
580		595

Lines 13-19 Link Here

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




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




package org.eclipse.debug.internal.core;

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

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

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

import com.ibm.icu.text.MessageFormat;

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

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

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

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

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

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

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

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

	/* (non-Javadoc)

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

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

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

	/**

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

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

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

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

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





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

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

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

since 3.3

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


Lines 8-13 Link Here

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




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




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

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

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





/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.internal.core;

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

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




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.core;

import java.util.Set;

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

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

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




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.internal.core;

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

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

import com.ibm.icu.text.MessageFormat;

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

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

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

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

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

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

}




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

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




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

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

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

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

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

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

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

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


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

   <annotation>
      <appInfo>
         <meta.section type="copyright"/>
      </appInfo>
      <documentation>
         Copyright (c) 2000, 2005 IBM Corporation and others.&lt;br&gt;
All rights reserved. This program and the accompanying materials are made 
available under the terms of the Eclipse Public License v1.0 which 
accompanies this distribution, and is available at 

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




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





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



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

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

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

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

	/**

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

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 11-16 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationTabGroupViewer.java (+47 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.List;
		15
14	import org.eclipse.core.resources.IResource;	16	import org.eclipse.core.resources.IResource;
15	import org.eclipse.core.resources.ResourcesPlugin;	17	import org.eclipse.core.resources.ResourcesPlugin;
16	import org.eclipse.core.runtime.CoreException;	18	import org.eclipse.core.runtime.CoreException;
Lines 958-966 Link Here
958	return false;	960	return false;
959	}	961	}
960	}	962	}
		963
961	return true;	964	return true;
962	}	965	}
963		966
		967
		968	/**
		969	* <p>
		970	* <strong>EXPERIMENTAL</strong>. This method has been added as
		971	* part of a work in progress. There is no guarantee that this API will
		972	* remain unchanged during the 3.3 release cycle. Please do not use this API
		973	* without consulting with the Platform/Debug team.
		974	* </p>
		975	* @return
		976	*/
		977	public boolean canLaunchWithOptions() {
		978	if(fInitializingTabs) {
		979	return false;
		980	}
		981	//check if selected options exist and that the selected combination can be launched
		982	try {
		983	ILaunchConfigurationWorkingCopy wc = getWorkingCopy();
		984	if(wc != null) {
		985	List options = wc.getOptions();
		986	if(options.size() > 0) {
		987	return DebugPlugin.getDefault().getLaunchManager().getLaunchDelegates(fTabType.getIdentifier(), getLaunchConfigurationDialog().getMode(), (String[]) options.toArray(new String[options.size()])).length > 0;
		988	}
		989	}
		990	}
		991	catch (CoreException e) {
		992	e.printStackTrace();
		993	}
		994	return true;
		995	}
		996
964	/**	997	/**
965	* Returns the current error message or <code>null</code> if none.	998	* Returns the current error message or <code>null</code> if none.
966	*/	999	*/
Lines 988-993 Link Here
988	return message;	1021	return message;
989	}	1022	}
990		1023
		1024	//EXPERIMENTAL
991	ILaunchConfigurationTab[] allTabs = getTabs();	1025	ILaunchConfigurationTab[] allTabs = getTabs();
992	for (int i = 0; i < allTabs.length; i++) {	1026	for (int i = 0; i < allTabs.length; i++) {
993	ILaunchConfigurationTab tab = allTabs[i];	1027	ILaunchConfigurationTab tab = allTabs[i];
Lines 1004-1009 Link Here
1004	return temp.toString();	1038	return temp.toString();
1005	}	1039	}
1006	}	1040	}
		1041	if(!canLaunchWithOptions()) {
		1042	try {
		1043	Object o = getInput();
		1044	String name = null;
		1045	if(o instanceof ILaunchConfiguration) {
		1046	ILaunchConfiguration lc = (ILaunchConfiguration) o;
		1047	name = LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_9+lc.getName();
		1048	}
		1049	return (name == null ? LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_10 : name) + LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_11+getLaunchConfigurationDialog().getMode()+LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_12+getWorkingCopy().getOptions().toString();
		1050	} catch (CoreException e) {
		1051	e.printStackTrace();
		1052	}
		1053	}
1007	return null;	1054	return null;
1008	}	1055	}
1009		1056

Lines 88-93 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationsMessages.java (+8 lines)
88	public static String LaunchConfigurationsDialog_Warning_2;	88	public static String LaunchConfigurationsDialog_Warning_2;
89	public static String LaunchConfigurationsDialog_Information_3;	89	public static String LaunchConfigurationsDialog_Information_3;
90	public static String LaunchConfigurationPresentationManager_No_tab_group_defined_for_launch_configuration_type__0__3;	90	public static String LaunchConfigurationPresentationManager_No_tab_group_defined_for_launch_configuration_type__0__3;
		91
		92	public static String LaunchConfigurationTabGroupViewer_10;
		93
		94	public static String LaunchConfigurationTabGroupViewer_11;
		95
		96	public static String LaunchConfigurationTabGroupViewer_12;
		97
		98	public static String LaunchConfigurationTabGroupViewer_9;
91	public static String PerspectiveManager_Error_1;	99	public static String PerspectiveManager_Error_1;
92	public static String PerspectiveManager_Unable_to_switch_perpsectives_as_specified_by_launch___0__4;	100	public static String PerspectiveManager_Unable_to_switch_perpsectives_as_specified_by_launch___0__4;
93	public static String PerspectiveManager_Unable_to_switch_to_perspective___0__2;	101	public static String PerspectiveManager_Unable_to_switch_to_perspective___0__2;

Lines 518-524 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationsDialog.java (-2 / +2 lines)
518	IStructuredSelection selection = (IStructuredSelection)fLaunchConfigurationView.getViewer().getSelection();	518	IStructuredSelection selection = (IStructuredSelection)fLaunchConfigurationView.getViewer().getSelection();
519	Object target = selection.getFirstElement();	519	Object target = selection.getFirstElement();
520	if (target instanceof ILaunchConfiguration) {	520	if (target instanceof ILaunchConfiguration) {
521	if (getTabViewer().canLaunch()) {	521	if (getTabViewer().canLaunch() & getTabViewer().canLaunchWithOptions()) {
522	handleLaunchPressed();	522	handleLaunchPressed();
523	}	523	}
524	} else {	524	} else {
Lines 1420-1426 Link Here
1420	getDeleteAction().setEnabled(getDeleteAction().isEnabled());	1420	getDeleteAction().setEnabled(getDeleteAction().isEnabled());
1421	getDuplicateAction().setEnabled(getDuplicateAction().isEnabled());	1421	getDuplicateAction().setEnabled(getDuplicateAction().isEnabled());
1422	getTabViewer().refresh();	1422	getTabViewer().refresh();
1423	getButton(ID_LAUNCH_BUTTON).setEnabled(getTabViewer().canLaunch());	1423	getButton(ID_LAUNCH_BUTTON).setEnabled(getTabViewer().canLaunch() & getTabViewer().canLaunchWithOptions());
1424	}	1424	}
1425		1425
1426	/* (non-Javadoc)	1426	/* (non-Javadoc)




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

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

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

import com.ibm.icu.text.MessageFormat;

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

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

	/**

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

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

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




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

Lines 14-25 Link Here

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




<?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.ui;

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

}




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.internal.ui;

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

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

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

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

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

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

}

Return to bug 157059

Lines 304-309 Link Here

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

Lines 172-175 Link Here

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

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 229-235 Link Here

(-)core/org/eclipse/debug/core/ILaunchManager.java (-2 / +50 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 252-257 Link Here
252	public ILaunchOption[] getLaunchOptions();	252	public ILaunchOption[] getLaunchOptions();
253		253
254	/**	254	/**
		255	* Returns whether the specified launch option is a valid launch option or not.
		256	* Validity is based on if the launch option has been contributed via the <code>launchOptions</code>
		257	* extension point or not.
		258	*
		259	* @param option the name of the specified launch option
		260	* @return true if the sepcified launch option is valid, false otherwise
		261	*
		262	* <strong>EXPERIMENTAL</strong>. This method has been added as
		263	* part of a work in progress. There is no guarantee that this API will
		264	* remain unchanged during the 3.3 release cycle. Please do not use this API
		265	* without consulting with the Platform/Debug team.
		266	* </p>
		267	* @since 3.3
		268	*/
		269	public boolean isValidLaunchOption(String option);
		270
		271	/**
		272	* Returns all of the launch delegates. The rturned listing of delegates cannot be directly used to launch,
		273	* instead the method <code>IlaunchDelegate.getDelegate</code> must be used to acquire an executable form of
		274	* the delegate, allowing us to maintain lazy loading of the delegates themselves.
		275	* @return all of the launch delegates
		276	* @since 3.3
		277	* <p>
		278	* <strong>EXPERIMENTAL</strong>. This method has been added as
		279	* part of a work in progress. There is no guarantee that this API will
		280	* remain unchanged during the 3.3 release cycle. Please do not use this API
		281	* without consulting with the Platform/Debug team.
		282	* </p>
		283	*/
		284	public ILaunchDelegate[] getLaunchDelegates();
		285
		286	/** Returns the launch delegates that applies to the specified options for the specified mode and type id
		287	* @param typeid the <code>ILaunchConfigurationType</code> id
		288	* @param the mode id
		289	* @param options the array of options to find the delegate for
		290	* @return the delegates that apply to the specified launch options for the specified mode and type id
		291	*
		292	* <p>
		293	* <strong>EXPERIMENTAL</strong>. This method has been added as
		294	* part of a work in progress. There is no guarantee that this API will
		295	* remain unchanged during the 3.3 release cycle. Please do not use this API
		296	* without consulting with the Platform/Debug team.
		297	* </p>
		298	* @since 3.3
		299	*/
		300	public ILaunchDelegate[] getLaunchDelegates(String typeid, String mode, String[] options);
		301
		302	/**
255	* Returns a collection of launch configurations that required migration to be	303	* Returns a collection of launch configurations that required migration to be
256	* compatible with current tooling.	304	* compatible with current tooling.
257	*	305	*

Lines 126-135 Link Here

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

Removed Link Here

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

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

Lines 1-155 Link Here

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

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

Added Link Here

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

Lines 27-57 Link Here

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

Lines 2-16 Link Here

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

Lines 46-57 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationsMessages.properties (+4 lines)
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	LaunchConfigurationTabGroupViewer_0={0} is an invalid character in launch configuration name {1}	47	LaunchConfigurationTabGroupViewer_0={0} is an invalid character in launch configuration name {1}
48	LaunchConfigurationTabGroupViewer_1=Configure launch settings from this dialog:	48	LaunchConfigurationTabGroupViewer_1=Configure launch settings from this dialog:
		49	LaunchConfigurationTabGroupViewer_10=The selected configuration
		50	LaunchConfigurationTabGroupViewer_11=\ cannot be launched with the set of options:
		51	LaunchConfigurationTabGroupViewer_12=\ and
49	LaunchConfigurationTabGroupViewer_2=- Press the 'New' button to create a configuration of the selected type.	52	LaunchConfigurationTabGroupViewer_2=- Press the 'New' button to create a configuration of the selected type.
50	LaunchConfigurationTabGroupViewer_3=- Edit or view an existing configuration by selecting it.	53	LaunchConfigurationTabGroupViewer_3=- Edit or view an existing configuration by selecting it.
51	LaunchConfigurationTabGroupViewer_4=- Press the 'Delete' button to remove the selected configuration.	54	LaunchConfigurationTabGroupViewer_4=- Press the 'Delete' button to remove the selected configuration.
52	LaunchConfigurationTabGroupViewer_6=- Press the 'Duplicate' button to copy the selected configuration.	55	LaunchConfigurationTabGroupViewer_6=- Press the 'Duplicate' button to copy the selected configuration.
53	LaunchConfigurationTabGroupViewer_5=Configure launch perspective settings from the <a>Perspectives</a> preference page.	56	LaunchConfigurationTabGroupViewer_5=Configure launch perspective settings from the <a>Perspectives</a> preference page.
54	LaunchConfigurationTabGroupViewer_8=- Press the 'Filter' button to configure filtering options.	57	LaunchConfigurationTabGroupViewer_8=- Press the 'Filter' button to configure filtering options.
		58	LaunchConfigurationTabGroupViewer_9=Configuration
55	LaunchConfigurationDialog_Create__manage__and_run_launch_configurations_8=Create, manage, and run configurations	59	LaunchConfigurationDialog_Create__manage__and_run_launch_configurations_8=Create, manage, and run configurations
56	LaunchConfigurationDialog_Dele_te_14=De&lete	60	LaunchConfigurationDialog_Dele_te_14=De&lete
57	LaunchConfigurationDialog_Discard_changes__38=Discard changes?	61	LaunchConfigurationDialog_Discard_changes__38=Discard changes?

Lines 1037-1042 Link Here

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

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/ILaunchConfigurationTabExtension.java (+50 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.debug.ui;
12
13	/**
14	* Describes a contributed launch configuration tab
15	*
16	* <p>
17	* <strong>EXPERIMENTAL</strong>. This method has been added as
18	* part of a work in progress. There is no guarantee that this API will
19	* remain unchanged during the 3.3 release cycle. Please do not use this API
20	* without consulting with the Platform/Debug team.
21	* </p>
22	* @since 3.3
23	*/
24	public interface ILaunchConfigurationTabExtension {
25
26	/**
27	* Returns the human readable name for the tab, not to be confused with the name that appears on the tab itself
28	* @return the name of the tab
29	*/
30	public String getName();
31
32	/**
33	* Returns the unique id ofthe tab
34	* @return the unique id of the tab
35	*/
36	public String getIdentifier();
37
38	/**
39	* Returns the unique id of the <code>ILaunchConfigurationTabGroup</code> that this tab contributes to
40	* @return the id of the <code>ILaunchConfigurationTabGroup</code> this tab conributes to
41	*/
42	public String getTabGroupId();
43
44	/**
45	* Returns the instantiated class of this tab
46	* @return the instantiated class of this tab
47	*/
48	public ILaunchConfigurationTab getTab();
49
50	}