Attachment #52620 for bug #157059

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




import org.eclipse.debug.core.ILaunch;
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.sourcelookup.ISourcePathComputer;
import org.eclipse.jdt.debug.testplugin.AlternateDelegate;

		HashSet modes = new HashSet();
		modes.add("alternate");
		modes.add(ILaunchManager.DEBUG_MODE);
		assertTrue("Should support mixed mode (alternate/debug)", type.supportsModes(modes));
		ILaunchDelegate[] delegates = type.getDelegates(modes);
		assertTrue("missing delegate", delegates.length > 0);
		assertEquals("Wrong number of delegates", 1, delegates.length);
		assertTrue("Wrong delegate", delegates[0].getDelegate() instanceof AlternateDelegate);

		assertNotNull("Missing java application launch config type", type);
		HashSet modes = new HashSet();
		modes.add(ILaunchManager.DEBUG_MODE);
		assertTrue("Should support mode (debug)", type.supportsModes(modes));
		ILaunchDelegate[] delegates = type.getDelegates(modes);
		assertTrue("missing delegate", delegates.length > 0);
		assertEquals("Wrong number of delegates", 1, delegates.length);
		assertTrue("Wrong delegate", delegates[0].getDelegate().getClass().getName().endsWith("JavaLaunchDelegate"));		

		assertNotNull("Missing java application launch config type", type);
		HashSet modes = new HashSet();
		modes.add("alternate");
		assertTrue("Should support mode (alternate)", type.supportsModes(modes));
		ILaunchDelegate[] delegates = type.getDelegates(modes);
		assertTrue("missing delegate", delegates.length > 0);
		assertEquals("Wrong number of delegates", 1, delegates.length);
		assertTrue("Wrong delegate", delegates[0].getDelegate() instanceof AlternateDelegate);		




package org.eclipse.debug.internal.core;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;


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;

 * 
 * @since 3.3
 */
public final class LaunchDelegate implements ILaunchDelegate {
	
	/**
	 * The configuration element for this delegate

	 */
	private ILaunchConfigurationDelegate fDelegate = null;
	
	//a listing of sets of 
	private List fLaunchModes = null;
	private HashSet fModes = null;
	private HashSet fOptions = null;
	private String fType = null;
	
	/**

		fElement = element;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchDelegateProxy#getDelegate()
	 */
	public ILaunchConfigurationDelegate getDelegate() throws CoreException {
		if(fDelegate == null) {
			Object obj = fElement.createExecutableExtension(IConfigurationElementConstants.DELEGATE);

		return fDelegate;
	}

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

		}
		return fType;
	}

	public Set getOptions() {
		if(fOptions == null) {
			fOptions = new HashSet();
			String option = fElement.getAttribute(IConfigurationElementConstants.OPTIONS);
			if(option != null) {
				String[] options = option.split(","); //$NON-NLS-1$
				for(int i = 0; i < options.length; i++) {
					fOptions.add(options[i].trim());
				}
			}
		}
		return fOptions;
	}
	
	/**
	 * Parese a list of modes and creates a new set of them
	 * @param element the configuraiton element to read from
	 * @return a set of launch modes created form a comma seperated list
	 */
	private Set getModes(IConfigurationElement element) {
		if (fModes == null) {
			fModes = new HashSet();
			String modes = element.getAttribute(IConfigurationElementConstants.MODES); 
			if (modes != null) {
				String[] strings = modes.split(","); //$NON-NLS-1$
				for (int i = 0; i < strings.length; i++) {

		return fModes;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchDelegateProxy#getModes()
	 */
	public List getModes() {
		if(fLaunchModes == null) {
			fLaunchModes = new ArrayList();
			IConfigurationElement[] children = fElement.getChildren(IConfigurationElementConstants.MODES_COMBINATION);
			for (int i = 0; i < children.length; i++) {
				fLaunchModes.add(getModes(children[i]));
			}
			if(fLaunchModes.size() == 0) {
				//try to get the modes from the old definition and make each one
				//a seperate set of one element
				String modes = fElement.getAttribute(IConfigurationElementConstants.MODES); 
				if (modes != null) {
					String[] strings = modes.split(","); //$NON-NLS-1$
					HashSet modeset = null;
					for (int i = 0; i < strings.length; i++) {
						modeset = new HashSet();
						modeset.add(strings[i].trim());
						fLaunchModes.add(modeset);
					}
				}
			}
		}
		return fLaunchModes;
	}
	
	/**
	 * Returns the human readable name for this launch delegate
	 * @return the human readable name for this launch delegate, or <code>null</code> if none

	public String getSourcePathComputerId() {
		return fElement.getAttribute(IConfigurationElementConstants.SOURCE_PATH_COMPUTER);
	}

	/**
	 * Returns all combinations of supported options.
	 * 
	 * @return combinations of supported options
	 */
	private Collection getOptionSets() {
		Set optionSets = new HashSet(); 
		optionSets.add(new HashSet()); // seed with the empty option set
		Object[] options = getOptions().toArray();
		boolean grew = false;
		do {
			grew = false;
			Set[] sets = (Set[]) optionSets.toArray(new Set[optionSets.size()]);
			for (int i = 0; i < sets.length; i++) {
				Set optionSet = sets[i];
				for (int j = 0; j < options.length; j++) {
					Object option = options[j];
					Set newOptionSet = new HashSet(optionSet);
					if (newOptionSet.add(option)) {
						if (optionSets.add(newOptionSet)) {
							grew = true;
						}
					}
				}				
			}                                   
		} while (grew);
		return optionSets;
	}
	
	/**
	 * Returns all supported launch mode combinations as sets of modes.
	 *  
	 * @return all supported launch mode combinations
	 */
	List getModeCombinations() {
		Collection optionSets = getOptionSets();
		Object[] modes = getModes().toArray();
		List combinations = new ArrayList(optionSets.size() * modes.length);
		Iterator iterator = optionSets.iterator();
		while (iterator.hasNext()) {
			Set optionSet = (Set) iterator.next();
			for (int i = 0; i < modes.length; i++) {
				Object mode = modes[i];
				Set set = new HashSet(optionSet);
				set.add(mode);
				combinations.add(set);
			}			
		}
		return combinations;
	}
}

Lines 82-87 Link Here

(-)core/org/eclipse/debug/internal/core/IConfigurationElementConstants.java (+5 lines)
82	public static final String MODES = "modes"; //$NON-NLS-1$	82	public static final String MODES = "modes"; //$NON-NLS-1$
83		83
84	/**	84	/**
		85	* the modesCombination node name for a configuraiton element
		86	*/
		87	public static final String MODES_COMBINATION = "modesCombination"; //$NON-NLS-1$
		88
		89	/**
85	* the mode node name for a configuration element	90	* the mode node name for a configuration element
86	*/	91	*/
87	public static final String MODE = "mode"; //$NON-NLS-1$	92	public static final String MODE = "mode"; //$NON-NLS-1$

Lines 29-34 Link Here

(-)core/org/eclipse/debug/internal/core/DebugCoreMessages.java (+2 lines)
29		29
30	public static String LaunchConfigurationInfo_35;	30	public static String LaunchConfigurationInfo_35;
31		31
		32	public static String LaunchConfigurationType_6;
		33
32	public static String LaunchConfigurationType_7;	34	public static String LaunchConfigurationType_7;
33		35
34	public static String LaunchOption_0;	36	public static String LaunchOption_0;




import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.PlatformObject;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.variables.VariablesPlugin;

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;

 */
public class LaunchManager extends PlatformObject implements ILaunchManager, IResourceChangeListener {
	
	
	/**
	 * Constants for xml node names
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	protected static final String MODES = "modes"; //$NON-NLS-1$
	protected static final String TYPEID = "typeid"; //$NON-NLS-1$
	protected static final String ID = "id"; //$NON-NLS-1$
	protected static final String DELEGATE = "delegate"; //$NON-NLS-1$
	protected static final String PREFERRED_DELEGATES = "preferredDelegates"; //$NON-NLS-1$
	protected static final String PREF_PREFERRED_DELEGATES = DebugPlugin.getUniqueIdentifier() + ".PREFERRED_DELEGATES"; //$NON-NLS-1$

	/**
	 * Constant to define debug.core for the status codes
	 * 

	 * 
	 * @since 3.2
	 */
	protected static final String EMPTY_STRING = ""; //$NON-NLS-1$
    
	/**
	 * Status code for which a UI prompter is registered.

	}
	
	/**
	 * Internal class used to hold information about a preferred delegate
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	class PreferredDelegate {
		private ILaunchDelegate fDelegate = null;
		private String fTypeid = null;
		private Set fModes = null;
		
		public PreferredDelegate(ILaunchDelegate delegate, String typeid, Set modes) {
			fDelegate = delegate;
			fTypeid = typeid;
			fModes = modes;
		}
		
		public String getTypeId() {
			return fTypeid;
		}
		
		public Set getModes() {
			return fModes;
		}
		
		public ILaunchDelegate getDelegate() {
			return fDelegate;
		}
	}
	
	/**
	 * Types of notifications
	 */
	public static final int ADDED = 0;

	private HashMap fLaunchDelegates = null;
	
	/**
	 * Initial startup cache of preferred delegate so that the debug prefs are only parsed once
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	private Set fPreferredDelegates = null;
	
	/**
	 * Collection of launches
	 */
	private List fLaunches= new ArrayList(10);

	}
	
	/**
	 * This method is used to initialize a simple listing of all preferred delegates, which is then used by each
	 * <code>ILaunchConfigurationType</code> to find if they have preferred delegates. Once an <code>ILaunchConfigurationType</code>
	 * has used this listing to initialize its preferred delegates ti will maintain changes to its preferred delegate, which are 
	 * then written back to the pref sotre only when the launch manager shuts down.
	 * 
	 * <p>
	 * This cache is not synchronized with the runtime preferred delegates stored in launch configuration types.
	 * </p>
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	private synchronized void initializePreferredDelegates() {
		if(fPreferredDelegates == null) {
			fPreferredDelegates = new HashSet();
			Preferences prefs = DebugPlugin.getDefault().getPluginPreferences();
			String preferred = prefs.getString(LaunchManager.PREF_PREFERRED_DELEGATES);
			if(!EMPTY_STRING.equals(preferred)) {
				try {
					Element root = DebugPlugin.parseDocument(preferred);
					NodeList nodes = root.getElementsByTagName(LaunchManager.DELEGATE);
					Element element = null;
					String tid = null, mod = null, did = null;
					String[] modes = null;
					Set modeset = null;
					LaunchDelegate[] extensions = null;
					ILaunchDelegate delegate = null;
					for(int i = 0; i < nodes.getLength(); i++) {
						element = (Element) nodes.item(i);
						tid = element.getAttribute(LaunchManager.TYPEID);
						if(!EMPTY_STRING.equals(tid)) {
							//get the modes
							mod = element.getAttribute(LaunchManager.MODES);
							modes = mod.split(","); //$NON-NLS-1$
							modeset = new HashSet();
							for(int j = 0; j < modes.length; j++) {
								modeset.add(modes[j].trim());
							}
							//get the delegate id and the delegate
							did = element.getAttribute(LaunchManager.ID);
							extensions = getLaunchDelegates();
							for(int j = 0; j < extensions.length; j++) {
								if(!EMPTY_STRING.equals(did) && did.equals(extensions[j].getId()) 
										&& tid.equals(extensions[j].getLaunchConfigurationTypeId())
										&& extensions[j].getModes().contains(modeset)) {
									delegate = extensions[j]; 
									break;
								}
							}
							//take tid, modeset, delegate and create entry
							if(delegate != null & !EMPTY_STRING.equals(tid) & modeset != null) {
								fPreferredDelegates.add(new PreferredDelegate(delegate, tid, modeset));
							}
						}
					}
				}
				catch (CoreException e) {DebugPlugin.log(e);} 
			}
		}
	}
	
	/**
	 * Allows internal access to a preferred delegate for a given type and mode set
	 * @param typeid the id of the <code>ILaunchConfigurationType</code> to find a delegate for
	 * @param modes ther set of modes for the delegate
	 * @return the preferred delegate for the specified type id and mode set, or <code>null</code> if none
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	protected ILaunchDelegate getPreferredDelegate(String typeid, Set modes) {
		initializePreferredDelegates();
		PreferredDelegate pd = null;
		for(Iterator iter = fPreferredDelegates.iterator(); iter.hasNext();) {
			pd = (PreferredDelegate) iter.next();
			if(pd.getModes().equals(modes) & pd.getTypeId().equals(typeid)) {
				return pd.getDelegate();
			}
		}
		return null;
	}
	
	/**
	 * Returns all launch configurations that are stored locally.
	 * 
	 * @return collection of launch configurations stored locally

			sourceContainerTypes = new HashMap();
			for (int i = 0; i < extensions.length; i++) {
				sourceContainerTypes.put(
						extensions[i].getAttribute(ID),
						new SourceContainerType(extensions[i]));
			}
			extensionPoint= Platform.getExtensionRegistry().getExtensionPoint(DebugPlugin.getUniqueIdentifier(), DebugPlugin.EXTENSION_POINT_SOURCE_PATH_COMPUTERS);

			sourcePathComputers = new HashMap();
			for (int i = 0; i < extensions.length; i++) {
				sourcePathComputers.put(
						extensions[i].getAttribute(ID),
						new SourcePathComputer(extensions[i]));
			}
		}

			String id = null;
			for (int i= 0; i < infos.length; i++) {
				configurationElement = infos[i];
				id = configurationElement.getAttribute(ID);			
				if (id != null) {
					fSourceLocators.put(id,configurationElement);
				} else {

			}
		}
		
		persistPreferredLaunchDelegates();
		clearAllLaunchConfigurations();

		ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
	}

	/**
	 * Saves the listings of preferred launch delegates from all of the launch configuration types
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	private void persistPreferredLaunchDelegates() {
		Preferences prefs = DebugPlugin.getDefault().getPluginPreferences();
		try {
			Document doc = DebugPlugin.newDocument();
			Element root = doc.createElement(PREFERRED_DELEGATES);
			doc.appendChild(root);
			ILaunchConfigurationType[] types = getLaunchConfigurationTypes();
			Map preferred = null;
			Element child = null;
			ILaunchDelegate delegate = null;
			Set modes = null;
			String modestr = EMPTY_STRING;
			for(int i = 0; i < types.length; i++) {
				preferred = ((LaunchConfigurationType)types[i]).getPreferredDelegates();
				if(preferred != null && preferred.size() > 0) {
					for(Iterator iter = preferred.keySet().iterator(); iter.hasNext();) {
						modes = (Set) iter.next();
						delegate = (ILaunchDelegate) preferred.get(modes);
						child = doc.createElement(DELEGATE);
						child.setAttribute(ID, delegate.getId());
						child.setAttribute(TYPEID, types[i].getIdentifier());
						for(Iterator iter2 = modes.iterator(); iter2.hasNext();) {
							modestr += iter2.next();
							if(iter2.hasNext()) {
								modestr += ","; //$NON-NLS-1$
							}
						}
						child.setAttribute(MODES, modes.toString());
						root.appendChild(child);
					}
				}
			}
			String pref = null;
			if(root.hasChildNodes()) {
				pref = serializeDocument(doc);
			}
			if(pref != null) {
				prefs.setValue(PREF_PREFERRED_DELEGATES, pref);
			}
			if(prefs.needsSaving()) {
				DebugPlugin.getDefault().savePluginPreferences();
			}
		} 
		catch (CoreException e) {DebugPlugin.log(e);}
		catch (IOException ioe) {DebugPlugin.log(ioe);}
		catch (TransformerException te) {DebugPlugin.log(te);}
	}
	
	/**
	 * finds and terminates any running launch configurations associated with the given resource
	 * @param resource the resource to search for launch configurations and hence launches for
	 * @since 3.2




 
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;

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.ILaunchMode;
import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;

	 *  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

	private Set fModes = null;
	
	/**
	 * A set of sets containing all of the supported mode combinations of this type
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	private Set fModeCombinations = null;
	
	/**
	 * the default source path computer for this config type
	 * @since 3.3
	 * 

	 * be different delegates for different modes (since 3.0).
	 * Map of modes (Set of modes) to list of delegates
	 */
	private Map fDelegates = null;
	
	/**
	 * The source provider cache entry
	 */
	private LaunchDelegate fSourceProvider = null;
	
	/**
	 * A map of preferred launch delegates for mode combinations
	 * 
	 *  @since 3.3
	 *  
	 *  EXPERIMENTAL
	 */
	private Map fPreferredDelegates = null;
	
	/**
	 * Constructs a new launch configuration type on the

	public ILaunchConfigurationDelegate getDelegate(String mode) throws CoreException {
		Set modes = new HashSet();
		modes.add(mode);
		ILaunchDelegate[] delegates = getDelegates(modes);
		if (delegates.length > 0) {
			return delegates[0].getDelegate();
		}

		throw new CoreException(status);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getDelegates(java.util.Set)
	 */
	public ILaunchDelegate[] getDelegates(Set modes) throws CoreException {
		initializeDelegates();
		initializePreferredDelegates();
		for (int i = 0; i < theModes.length; i++) {
			String mode = (String) theModes[i];
			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));  
			}			
		}
		List delegates = (List) fDelegates.get(modes);
		if (delegates == null) {
			delegates = Collections.EMPTY_LIST;
		}
		return (ILaunchDelegate[]) delegates.toArray(new ILaunchDelegate[delegates.size()]);
	}
	
	/**
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#setPreferredDelegate(java.util.Set, org.eclipse.debug.core.ILaunchDelegateProxy)
	 */
	public void setPreferredDelegate(Set modes, ILaunchDelegate delegate) {
		if(fPreferredDelegates == null) {
			fPreferredDelegates = new HashMap();
		}
		fPreferredDelegates.put(modes, delegate);
	}
	
	/**
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getPreferredDelegate(java.util.Set)
	 */
	public ILaunchDelegate getPreferredDelegate(Set modes) {
		initializePreferredDelegates();
		return (ILaunchDelegate) fPreferredDelegates.get(modes);
	}
	
	/**
	 * Internal use method to allow access to the listing of preferred delegates
	 * @return the map opf preferred delegates
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	public Map getPreferredDelegates() {
		initializePreferredDelegates();
		return fPreferredDelegates;
	}
	
	/**
	 * This method is used to initialize the listing of preferred launch delegates for this type
	 * 
	 * <p>
	 * Undecide if this code should live in the launch manager and have it load a listing of all perferred launch 
	 * delegates that each config type could then query as needed when looking for their preferrred delegate. 
	 * Seems like it would be alot less work...
	 * </p>
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	private synchronized void initializePreferredDelegates() {
		if(fPreferredDelegates == null) {
			fPreferredDelegates = new HashMap();
			initializeDelegates();
			LaunchManager lm = (LaunchManager) DebugPlugin.getDefault().getLaunchManager();
			ILaunchDelegate delegate = null;
			Set modes = null;
			for(Iterator iter = fDelegates.keySet().iterator(); iter.hasNext();) {
				modes = (Set) iter.next();
				delegate = lm.getPreferredDelegate(getIdentifier(), modes);
				if(delegate != null) {
					fPreferredDelegates.put(modes, delegate);
				}
			}
		}
	}
	
	/**
	 * Initializes the listing of launch delegates for this type
	 */
	private synchronized void initializeDelegates() {
		if (fDelegates == null) {
			// initialize delegate
			fDelegates = new Hashtable();
			LaunchDelegate[] launchDelegates = getLaunchDelegateExtensions();
			LaunchDelegate delegate = null;
			List modelist = null;
			for (int i = 0; i < launchDelegates.length; i++) {
				delegate = launchDelegates[i];
				modelist = delegate.getModes();
				for(int j = 0; j < modelist.size(); j++) {
					//cache the delegate based on its set of modes and delegate
					registerDelegate(delegate, (Set) modelist.get(j));
					registerDelegate(delegate, combination);
				}
			}
		}
	}
	
	/**
	 * Returns all launch delegate extensions registered for this configuration type.
	 * 

		return ((LaunchManager) DebugPlugin.getDefault().getLaunchManager()).getLaunchDelegates(getIdentifier());
	}
	
	/**
	 * Caches a delegate keyed using the set of modes that it supports
	 * @param delegate the delegate to cache
	 * @param modes the set of modes that the specified delegate supports
	 */
	private void registerDelegate(LaunchDelegate delegate, Set modes) {
		List delegatesForModes = (List) fDelegates.get(modes);
		if (delegatesForModes == null) {

		if(fModes == null) {
			fModes = new HashSet();
			LaunchDelegate[] delegates = getLaunchDelegateExtensions();
			List modesets = null;
			for(int i= 0; i < delegates.length; i++) {
				modesets = delegates[i].getModes();
				for(Iterator iter = modesets.iterator(); iter.hasNext();) {
					fModes.addAll((Set) iter.next());
				}
			}
		}
		return fModes;
	}
	
	/**
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getSupportedModeCombinations()
	 */
	public Set getSupportedModeCombinations() {
		if(fModeCombinations == null) {
			initializeDelegates();
			fModeCombinations = new HashSet();
			fModeCombinations = fDelegates.keySet();
		}
		//return a clone or bad things happen
		HashSet set = new HashSet();
		for(Iterator iter = fModeCombinations.iterator(); iter.hasNext();) {
			set.add(new HashSet((Set) iter.next()));
		}
		return set;
	}
	
	/**
	 * determines if the specified candidate is suitable for migration by loading it delegate.
	 * @param candidate the candidate to inspect for migration suitability

	 * @see org.eclipse.debug.core.ILaunchConfigurationType#supportsMode(java.lang.String)
	 */
	public boolean supportsMode(String mode) {
		if(fModeCombinations == null) {
			getSupportedModeCombinations();
		}
		Set modes = null;
		for(Iterator iter = fModeCombinations.iterator(); iter.hasNext();) {
			modes = (Set) iter.next();
			if(modes.size() == 1 && modes.contains(mode)) {
				return true;
			}
		}
		return false;
	}
	
	/* (non-Javadoc)

	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#getSupportedModeCombinations()
	 */
	public Set[] getSupportedModeCombinations() {
		initializeDelegates();
		Set combinations = fDelegates.keySet();
		Set[] sets = (Set[])combinations.toArray(new Set[combinations.size()]);
		Set[] copy = new Set[sets.length];
		for (int i = 0; i < copy.length; i++) {
			copy[i] = new HashSet(sets[i]);
		}
		return copy;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchConfigurationType#supportsModeCombination(java.util.Set)
	 */
	public boolean supportsModes(Set modes) {
		if(fModeCombinations == null) {
			getSupportedModeCombinations();
		}
		return fModeCombinations.contains(modes);
	}

}

Lines 65-70 Link Here

(-)core/org/eclipse/debug/internal/core/DebugCoreMessages.properties (+1 lines)
65	LaunchConfigurationType_Launch_delegate_for__0__does_not_implement_required_interface_ILaunchConfigurationDelegate__1=Launch delegate for {0} does not implement required interface ILaunchConfigurationDelegate.	65	LaunchConfigurationType_Launch_delegate_for__0__does_not_implement_required_interface_ILaunchConfigurationDelegate__1=Launch delegate for {0} does not implement required interface ILaunchConfigurationDelegate.
66	LaunchConfigurationType_9=Launch mode {0} not supported for configuration type {1}	66	LaunchConfigurationType_9=Launch mode {0} not supported for configuration type {1}
67	LaunchConfigurationType_7=Launch mode not supported: {0}	67	LaunchConfigurationType_7=Launch mode not supported: {0}
		68	LaunchConfigurationType_6=Launch mode combination {0} not supported for configuration type {1}.
68	LaunchConfigurationType_10=There is no launch delegate registered for configuration type {0}, mode {1}	69	LaunchConfigurationType_10=There is no launch delegate registered for configuration type {0}, mode {1}
69	WatchExpression_0=(Watch expressions not supported)	70	WatchExpression_0=(Watch expressions not supported)
70	NullStreamsProxy_0=Null Stream Monitor	71	NullStreamsProxy_0=Null Stream Monitor




import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchDelegate;
import org.eclipse.debug.core.IStatusHandler;
import org.eclipse.debug.core.Launch;
import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;

     * @see org.eclipse.debug.core.ILaunchConfiguration#launch(java.lang.String, org.eclipse.core.runtime.IProgressMonitor, boolean, boolean)
     */
    public ILaunch launch(String mode, IProgressMonitor monitor, boolean build, boolean register) throws CoreException {
    	if (monitor == null) {
			monitor = new NullProgressMonitor();
		}
		// bug 28245 - force the delegate to load in case it is interested in launch notifications
    	Set modes = getModes();
    	modes.add(mode);
    	ILaunchDelegate[] delegates = getType().getDelegates(modes);
    	ILaunchConfigurationDelegate delegate = null;
    	if (delegates.length == 1) {
    		delegate = delegates[0].getDelegate();
    	} else if (delegates.length == 0) {
    		monitor.setCanceled(true);
    		IStatusHandler handler = DebugPlugin.getDefault().getStatusHandler(promptStatus);
    		handler.handleStatus(delegateNotAvailable, new Object[] {this, mode});
    		IStatus status = new Status(IStatus.CANCEL, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, "No launch delegate found, cancelling launch and returning", null); //$NON-NLS-1$
    		IStatus status = new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), 
    				DebugPlugin.INTERNAL_ERROR, "No launch delegate", null); //$NON-NLS-1$
    		throw new CoreException(status);
    	} else {
    		ILaunchDelegate del = getType().getPreferredDelegate(modes);
    		if(del == null) {
	    		IStatus status = new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, "Duplicate launch delegates", null); //$NON-NLS-1$
	    		throw new CoreException(status);
    		}
    		delegate = del.getDelegate();
    	}
    	
		ILaunchConfigurationDelegate2 delegate2 = null;

		String attribute = getAttribute(DebugPlugin.ATTR_CONSOLE_ENCODING, (String)null);
		launch.setAttribute(DebugPlugin.ATTR_CONSOLE_ENCODING, attribute);
		
				
			monitor= new NullProgressMonitor();
		}		
		// perform initial pre-launch sanity checks
		if (delegate2 != null) {
			if (!(delegate2.preLaunchCheck(this, mode, monitor))) {




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

/**
 * A proxy to a launch configuration delegate. Represents a
 * launch delegate contributed to the <code>org.eclipse.debug.core.launchDelegates</code>
 * extension point. 
 * 
 * @since 3.3
 * <p>
 * <strong>EXPERIMENTAL</strong>. This interface 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 interface ILaunchDelegateProxy {

	/**
	 * Returns this delegate's unique identifier.
	 * 
	 * @return launch delegate identifier
	 */
	public String getId();
	
	/**
	 * Returns a human readable name for this launch delegate
	 * or <code>null</code> if none.
	 * 
	 * @return name or <code>null</code>
	 */
	public String getName();
	
	/**
	 * Returns the name of the plug-in that contributed this delegate.
	 * 
	 * @return contributor name
	 */
	public String getContributorName();
	
	/**
	 * Returns the delegate that performs the actual launch.
	 * Causes the delegate to be instantiated.
	 * 
	 * @return launch delegate
	 * @exception CoreException if unable to instantiate the delegate
	 */
	public ILaunchConfigurationDelegate getDelegate() throws CoreException;
	
	/**
	 * Returns the launch modes this delegate supports.
	 * 
	 * @return launch modes as a set of launch mode identifiers
	 */
	public Set getModes();
	
	/**
	 * Returns the launch modes this delegate supports in combination with
	 * its modes specified by <code>getModes()</code>.
	 * 
	 * @return launch options as a set of launch mode identifiers
	 */
	public Set getOptions();
	
}




	 * without consulting with the Platform/Debug team.
	 * </p>
	 */
	public ILaunchDelegate[] getDelegates(Set modes) throws CoreException;
	
	/**
	 * Returns the preferred launch delegate for this type in the specified mode set
	 * @param modes the set of modes to support
	 * @return the preferred delegate proxy or <code>null</code> if none
	 * @throws CoreException
	 * 
	 * @return all supported launch mode combinations
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 * 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 getPreferredDelegate(Set modes) throws CoreException;
	
	/**
	 * Allows the preferred launch delegate to be setfor this type with the specifie set of modes
	 * @param delegate the delegate proxy to set as the default one
	 * @throws CoreException
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	public void setPreferredDelegate(Set modes, ILaunchDelegate delegate) throws CoreException;
	
	/**
	 * Returns whether this launch configuration supports the specified launch

	 * without consulting with the Platform/Debug team.
	 * </p>
	 */
	public boolean supportsModes(Set modes);
	
	/**
	 * Returns the unique identifier for this type of launch configuration

	 * Returns all of the registered supported modes for this launch configuration type.
	 * This method does not return null.
	 * 
	 * <p>
	 * The returned set does not convey any mode combination capability nor does it describe how or what the type can launch, all this method does is return
	 * a set of strings of all the modes in some way associated with this type 
	 * </p>
	 * 
	 * @return the set of all supported modes
	 * @since 3.2
	 * 
	 * @deprecated Since 3.3 all modes are provided as sets and not individual strings. The method <code>getSupportedModeCombinations</code>
	 * should be used instead to retrive the complete listing of supported modes and their allowable combinations.
	 */
	public Set getSupportedModes();
	
	/**
	 * Returns a <code>java.util.Set</code> of <code>java.util.Set</code>s containing all of the supported mode combinations
	 * for this type
	 * @return a set of sets of all the supported mode combinations supported by this type
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	public Set getSupportedModeCombinations();
	
	/**
	 * Returns whether this launch configuration type is public.  Public configuration
	 * types are available for use by the user, for example, the user can create new
	 * configurations based on public types through the UI.  Private types are not




<?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="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>
      </complexType>
   </element>

   <element name="launchMode">
      <annotation>
         <appInfo>
            <meta.element labelAttribute="name"/>
         </appInfo>
      </annotation>
      <complexType>
         <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>

</schema>




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.debug.core">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.debug.core" id="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">
            <element ref="modeCombination" minOccurs="1" 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>
                  A human readable name for this delegate. This attribute was added in the 3.3. release.

&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>
                  A comma-separated list of the launch modes this 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>
                  A comma-separated list of launch modes this launch delegate supports in combination with its supported modes. This attribute was added in the 3.3 release to allow configurations to be launched in a mixed mode.

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

   <element name="modeCombination">
      <annotation>
         <documentation>
            This element represents a collection of mode combinations that this delegate can launch. Each entry of a modeCombination is a comma seperated listing of a single combination of modes the delegate supports.

For example, a delegate that supports debugging, profiling and code coverage might have a modeCombination of:

[debug, profile, coverage]

since 3.3

EXPERIMENTAL
         </documentation>
      </annotation>
      <complexType>
         <attribute name="modes" type="string" use="required">
            <annotation>
               <documentation>
                  the modes attribute represents a comma seperated listing of a combination of modes that the associated delegate can launch

since 3.3

EXPERIMENTAL
               </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;&gt;
  &lt;/launchDelegate&gt;
  &lt;modeCombination modes=&quot;run, profile&quot;&gt;&lt;/modeCombination&gt;
  &lt;modeCombination modes=&quot;debug, profile, coverage&quot;&gt;&lt;/modeCombination&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 delegate supports mixed mode launching. The delegate supports profiling when launching in run or debug mode, with code coverage in debug mode only.
      </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>




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

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

/**
 * A proxy to a launch configuration delegate. Represents a
 * launch delegate contributed to the <code>org.eclipse.debug.core.launchDelegates</code>
 * extension point. 
 * 
 * @since 3.3
 * <p>
 * <strong>EXPERIMENTAL</strong>. This interface 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 interface ILaunchDelegate {

	/**
	 * Returns this delegate's unique identifier.
	 * 
	 * @return launch delegate identifier
	 */
	public String getId();
	
	/**
	 * Returns a human readable name for this launch delegate
	 * or <code>null</code> if none.
	 * 
	 * @return name or <code>null</code>
	 */
	public String getName();
	
	/**
	 * Returns the name of the plug-in that contributed this delegate.
	 * 
	 * @return contributor name
	 */
	public String getContributorName();
	
	/**
	 * Returns the delegate that performs the actual launch.
	 * Causes the delegate to be instantiated.
	 * 
	 * @return launch delegate
	 * @exception CoreException if unable to instantiate the delegate
	 */
	public ILaunchConfigurationDelegate getDelegate() throws CoreException;
	
	/**
	 * Returns the complete set of launch modes as a list of sets.
	 * If no modes are available an empty list is returned, never <code>null</code>
	 * @return the complete set of launch modes for this delegate as a list
	 * of sets
	 */
	public List getModes();
	
}

Lines 49-54 Link Here

(-)ui/org/eclipse/debug/internal/ui/preferences/DebugPreferencesMessages.java (+4 lines)
49	public static String DebugPreferencePage_26;	49	public static String DebugPreferencePage_26;
50	public static String DebugPreferencePage_27;	50	public static String DebugPreferencePage_27;
51		51
		52	public static String LaunchDelegatesPreferencePage_0;
		53
		54	public static String LaunchDelegatesPreferencePage_1;
		55
52	public static String LaunchingPreferencePage_1;	56	public static String LaunchingPreferencePage_1;
53	public static String LaunchingPreferencePage_2;	57	public static String LaunchingPreferencePage_2;
54	public static String LaunchingPreferencePage_3;	58	public static String LaunchingPreferencePage_3;

Lines 13-19 Link Here

(-)ui/org/eclipse/debug/internal/ui/preferences/PerspectivePreferencePage.java (-12 / +23 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.HashMap;	17	import java.util.HashMap;
19	import java.util.Iterator;	18	import java.util.Iterator;
Lines 47-52 Link Here
47	import org.eclipse.swt.events.SelectionAdapter;	46	import org.eclipse.swt.events.SelectionAdapter;
48	import org.eclipse.swt.events.SelectionEvent;	47	import org.eclipse.swt.events.SelectionEvent;
49	import org.eclipse.swt.graphics.Font;	48	import org.eclipse.swt.graphics.Font;
		49	import org.eclipse.swt.graphics.Point;
50	import org.eclipse.swt.layout.GridData;	50	import org.eclipse.swt.layout.GridData;
51	import org.eclipse.swt.layout.GridLayout;	51	import org.eclipse.swt.layout.GridLayout;
52	import org.eclipse.swt.widgets.Combo;	52	import org.eclipse.swt.widgets.Combo;
Lines 71-76 Link Here
71	import org.xml.sax.SAXException;	71	import org.xml.sax.SAXException;
72	import org.xml.sax.helpers.DefaultHandler;	72	import org.xml.sax.helpers.DefaultHandler;
73		73
		74	import com.ibm.icu.text.MessageFormat;
		75
74	/**	76	/**
75	* Provides one place to set perspective preferences	77	* Provides one place to set perspective preferences
76	*	78	*
Lines 254-285 Link Here
254	HashMap map = (HashMap) fTypeInformationMapping.get(typeobj);	256	HashMap map = (HashMap) fTypeInformationMapping.get(typeobj);
255	if(map == null) {	257	if(map == null) {
256	map = new HashMap();	258	map = new HashMap();
257	}//end if	259	}
258	map.put(mode, (perspective != null ? perspective : IDebugUIConstants.PERSPECTIVE_NONE));	260	map.put(mode, (perspective != null ? perspective : IDebugUIConstants.PERSPECTIVE_NONE));
259	fTypeInformationMapping.put(typeobj, map);	261	fTypeInformationMapping.put(typeobj, map);
260	}//end if	262	}
261	}// end if	263	}
262	}// end if	264	}
263	}// end for	265	}
264	}// end try	266	}
265	catch (ParserConfigurationException e) {DebugUIPlugin.log(e);}	267	catch (ParserConfigurationException e) {DebugUIPlugin.log(e);}
266	catch (SAXException e) {DebugUIPlugin.log(e);}	268	catch (SAXException e) {DebugUIPlugin.log(e);}
267	catch (IOException e) {DebugUIPlugin.log(e);}	269	catch (IOException e) {DebugUIPlugin.log(e);}
268	}// end if	270	}
269	perspec.load();	271	perspec.load();
270	suspend.load();	272	suspend.load();
271	TreeItem item = findLastSelected(getPreferenceStore().getString(LAST_SELECTED_CONFIGTYPE));	273	TreeItem item = findLastSelected(getPreferenceStore().getString(LAST_SELECTED_CONFIGTYPE));
272	if (item != null) {	274	if (item != null) {
273	fTree.setSelection(new TreeItem[] { item });	275	fTree.setSelection(new TreeItem[] { item });
274	}// end if	276	}
275	else {	277	else {
276	if(fTree.getItemCount() > 0) {	278	if(fTree.getItemCount() > 0) {
277	fTree.setSelection(new TreeItem[] { fTree.getItem(0) });	279	fTree.setSelection(new TreeItem[] { fTree.getItem(0) });
278	}	280	}
279	}// end else	281	}
280	fCurrentType = (ILaunchConfigurationType) ((IStructuredSelection) fViewer.getSelection()).getFirstElement();	282	fCurrentType = (ILaunchConfigurationType) ((IStructuredSelection) fViewer.getSelection()).getFirstElement();
281	buildComboBoxes(fCurrentType);	283	buildComboBoxes(fCurrentType);
282	}// restoreState	284	}
283		285
284	/**	286	/**
285	* Sets the default perspectives for the modes of an ILaunchConfiguration	287	* Sets the default perspectives for the modes of an ILaunchConfiguration
Lines 373-381 Link Here
373	}	375	}
374	}	376	}
375	}	377	}
376	fPerspectiveComp.layout();	378	fPerspectiveComp.layout(new Control[] {fComboPlaceHolder});
		379	resizeShell();
377	}	380	}
378		381
		382	private void resizeShell() {
		383	Point pnt = this.getShell().getSize();
		384	Point p = this.getShell().computeSize(SWT.DEFAULT, SWT.DEFAULT);
		385	if(pnt.x < p.x) {
		386	this.getShell().setSize(p);
		387	}
		388	}
		389
379	/**	390	/**
380	* Handles the change in selection from the launch configuration listing	391	* Handles the change in selection from the launch configuration listing
381	*	392	*

Lines 123-125 Link Here

(-)ui/org/eclipse/debug/internal/ui/preferences/DebugPreferencesMessages.properties (+2 lines)
123	LaunchConfigurationsPreferencePage_1=Launch Configurations	123	LaunchConfigurationsPreferencePage_1=Launch Configurations
124	LaunchConfigurationsPreferencePage_2=Delete configurations when associated project is deleted	124	LaunchConfigurationsPreferencePage_2=Delete configurations when associated project is deleted
125	LaunchConfigurationsPreferencePage_3=Apply window &working set(s)	125	LaunchConfigurationsPreferencePage_3=Apply window &working set(s)
		126	LaunchDelegatesPreferencePage_0=Launch Delegates
		127	LaunchDelegatesPreferencePage_1=The settings on this page are used to select a preferred launch delegate in the event there are duplicates.





import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Set;


		public void removeListener(ILabelProviderListener listener) {}
	}
	
	private static final String SETTINGS_ID = IDebugUIConstants.PLUGIN_ID + ".SELECT_LAUNCH_MODES_DIALOG"; //$NON-NLS-1$
	
	private CheckboxTableViewer fTableViewer = null;
	private Table fTable  = null;
	private List fValidModes = null;
	
	/**
	 * Constructor
	 * @param parentShell the parent shell
	 * @param mode the current mode context
	 * @param configuration the current launch configuration context
	 * 
	 * @throws CoreException
	 */
	public SelectLaunchModesDialog(Shell parentShell, String mode, ILaunchConfiguration configuration) throws CoreException {
		super(parentShell);
		super.setMessage(LaunchConfigurationsMessages.SelectLaunchOptionsDialog_2);
		super.setTitle(LaunchConfigurationsMessages.SelectLaunchOptionsDialog_3);
		setShellStyle(getShellStyle() | SWT.RESIZE);
		fValidModes = new ArrayList();
		Set modes = configuration.getType().getSupportedModeCombinations();
		Set modeset = null;
		for(Iterator iter = modes.iterator(); iter.hasNext();) {
			modeset = (Set) iter.next();
			if(modeset.contains(mode)) {
				fValidModes.add(modeset);
			}
		}
	}

		fTableViewer = new CheckboxTableViewer(fTable);
		fTableViewer.setLabelProvider(new OptionsLabelProvider());
		fTableViewer.setContentProvider(new ArrayContentProvider());
		fTableViewer.setInput(fValidModes.toArray());
		fTableViewer.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				fTableViewer.setAllChecked(false);

			}
		});
		Dialog.applyDialogFont(comp);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(comp, IDebugHelpContextIds.SELECT_LAUNCH_MODES_DIALOG);
		return comp;
	}


Lines 56-61 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationsMessages.properties (+5 lines)
56	LaunchConfigurationTabGroupViewer_9=The file associated with this launch configuration is read-only and cannot be modified.\n	56	LaunchConfigurationTabGroupViewer_9=The file associated with this launch configuration is read-only and cannot be modified.\n
57	LaunchConfigurationTabGroupViewer_13=Select a supported <a>launch mode</a>.	57	LaunchConfigurationTabGroupViewer_13=Select a supported <a>launch mode</a>.
58	LaunchConfigurationTabGroupViewer_14=Mixed launch mode not supported: {0}	58	LaunchConfigurationTabGroupViewer_14=Mixed launch mode not supported: {0}
		59	LaunchConfigurationTabGroupViewer_15=Select a preferred <a>launch delegate</a>.
		60	LaunchConfigurationTabGroupViewer_16=There are duplicate launch delegates for mixed mode: {0}
59		61
60	LaunchConfigurationDialog_Create__manage__and_run_launch_configurations_8=Create, manage, and run configurations	62	LaunchConfigurationDialog_Create__manage__and_run_launch_configurations_8=Create, manage, and run configurations
61	LaunchConfigurationDialog_Dele_te_14=De&lete	63	LaunchConfigurationDialog_Dele_te_14=De&lete
Lines 172-174 Link Here
172	SelectLaunchOptionsDialog_2=A plug-in that once provided the ability to launch the saved set of launch options for the current launch configuration is no longer available. As such, you must select a valid set of launch options that can be launched	174	SelectLaunchOptionsDialog_2=A plug-in that once provided the ability to launch the saved set of launch options for the current launch configuration is no longer available. As such, you must select a valid set of launch options that can be launched
173	SelectLaunchOptionsDialog_3=Select Launch Mode	175	SelectLaunchOptionsDialog_3=Select Launch Mode
174	SelectLaunchOptionsDialog_4=&Select a supported mode combination:	176	SelectLaunchOptionsDialog_4=&Select a supported mode combination:
		177	SelectLaunchDelegatesDialog_0=There is more than one launch delegate capable of launching the current configuration in the current mode. Please select which launch delegate you would like to use to continue launching.
		178	SelectLaunchDelegatesDialog_1=Select Launch Delegate
		179	SelectLaunchDelegatesDialog_2=Select a &preferred launch delegate:

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() & getTabViewer().canLaunchWithOptions());	71	getButton(ID_LAUNCH_BUTTON).setEnabled(getTabViewer().canLaunch() & getTabViewer().canLaunchWithModes() & !getTabViewer().hasDuplicateDelegates());
72		72
73	}	73	}
74		74




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


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


import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchDelegate;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.SWTUtil;

		
		Composite blComp = SWTUtil.createComposite(mainComp, mainComp.getFont(), 2, 1, GridData.FILL_HORIZONTAL);
		Composite linkComp = SWTUtil.createComposite(blComp, blComp.getFont(), 1, 1, GridData.FILL_HORIZONTAL);

	//a link for launch options
		fOptionsLink = new Link(linkComp, SWT.NONE);
		
		fOptionsLink.setFont(linkComp.getFont());
		gd = new GridData(GridData.BEGINNING);
		fOptionsLink.setLayoutData(gd);

			public void widgetSelected(SelectionEvent e) {
				//collect the options available
				try {
					if(!canLaunchWithModes()) {
						SelectLaunchModesDialog sld = new SelectLaunchModesDialog(getShell(), 
								getLaunchConfigurationDialog().getMode(), getWorkingCopy());
						if(sld.open() == IDialogConstants.OK_ID) {
							//set the options to the config
							Object[] res = sld.getResult();
							if(res != null) {
								Set modes = (Set) res[0];
								modes.remove(getLaunchConfigurationDialog().getMode());
								ILaunchConfigurationWorkingCopy wc = getWorkingCopy();
								wc.setModes(modes);
								refresh();
								refreshStatus();
							}
						}
					}
					else if(hasDuplicateDelegates()) {
						Set modes = new HashSet();
						modes.add(getLaunchConfigurationDialog().getMode());
						modes.addAll(getWorkingCopy().getModes());
						SelectLaunchDelegatesDialog sld = new SelectLaunchDelegatesDialog(getShell(), fTabType.getDelegates(modes));
						if(sld.open() == IDialogConstants.OK_ID) {
							Object[] res = sld.getResult();
							if(res != null) {
								fTabType.setPreferredDelegate(modes, (ILaunchDelegate) res[0]);
								refresh();
								refreshStatus();
							}
						}
					}
				} catch (CoreException ex) {}
			}
			public void widgetDefaultSelected(SelectionEvent e) {}
		});

	}
	
	/**
	 * Shows/hides the options link on the top of the viewer
	 * @param show true if the link should be visible, false otherwise
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	protected void showOptionsLink(boolean show) {
		fOptionsLink.setVisible(show);
	}
	
	/**
	 * Simple method to create a spacer in the page
	 * 
	 * @param composite the composite to add the spacer to

		if (fInitializingTabs) {
			return;
		}
		
		ILaunchConfigurationTab[] tabs = getTabs();
		if (!fInitializingTabs && tabs != null) {
			// update the working copy from the active tab

				item = fTabFolder.getItem(i);
				setTabIcon(item, error, tabs[i]);
			}
			if(!canLaunchWithModes()) {
				fOptionsLink.setText(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_13);
			}
			else if(hasDuplicateDelegates()) {
				fOptionsLink.setText(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_15);
			}
			fOptionsLink.setVisible(!canLaunchWithModes() || hasDuplicateDelegates());
		}
	}


	 * </p>
	 * @return
	 */
	public boolean canLaunchWithModes() {
		if(fInitializingTabs) {
			return false;
		}

			if(wc != null) {
				Set modes = wc.getModes();
				modes.add(getLaunchConfigurationDialog().getMode());
				return wc.getType().supportsModes(modes);
			}
		}  catch (CoreException e) {
		}

	}
	
	/**
	 * Returns if the type currently showing in the tab group viewer has duplicate launch delegates for the given set of modes.
	 * 
	 * The given set of modes comprises the current mode that the launch dialog was opened in as well as any modes that have been set on the launch
	 * configuration.
	 * @return the true if there are duplicates, false otherwise
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	public boolean hasDuplicateDelegates() {
		if(fInitializingTabs) {
			return false;
		}
		try {
			ILaunchConfiguration config = getWorkingCopy();
			if(config != null) {
				Set modes = config.getModes();
				modes.add(getLaunchConfigurationDialog().getMode());
				if(fTabType.getDelegates(modes).length > 1) {
					return fTabType.getPreferredDelegate(modes) == null;
				}
			}
		}
		catch(CoreException ce) {DebugUIPlugin.log(ce);}
		return false;
	}
	
	/**
	 * Returns the current error message or <code>null</code> if none.
	 */
	public String getErrorMesssage() {

			return message;
		}
		
	//EXPERIMENTAL
		ILaunchConfigurationTab[] allTabs = getTabs();
		for (int i = 0; i < allTabs.length; i++) {
			ILaunchConfigurationTab tab = allTabs[i];

				return LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_9;
			}
		}
		//EXPERIMENTAL
		if(!canLaunchWithModes()) {
			try {
				Set modes = getWorkingCopy().getModes();
				modes.add(getLaunchConfigurationDialog().getMode());

				return e.getMessage();
			}
		}
		if(hasDuplicateDelegates()) {
			try {
				Set modes = getWorkingCopy().getModes();
				modes.add(getLaunchConfigurationDialog().getMode());
				List names = LaunchConfigurationPresentationManager.getDefault().getLaunchModeNames(modes);
				return MessageFormat.format(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_16, new String[] {names.toString()});
			}
			catch (CoreException e) {DebugUIPlugin.log(e);}
		}
		return null;
	}	
	




import org.eclipse.debug.core.IStatusHandler;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.swt.widgets.Shell;

/**
 * This class provides a mechanism to prompt users in the UI thread from debug.core in the case where

		if(source instanceof Object[]) {
			Object[] infos = (Object[]) source;
			if(infos.length == 2) {
				final ILaunchConfiguration config = (ILaunchConfiguration) infos[0];
				final String mode = (String) infos[1];
				final Shell shell = DebugUIPlugin.getShell();
				Runnable runnable = new Runnable() {
					public void run() {
						DebugUITools.openLaunchConfigurationDialog(shell, config, DebugUITools.getLaunchGroup(config, mode).getIdentifier(), null);
					}
				};
				DebugUIPlugin.getStandardDisplay().asyncExec(runnable);
			}
		}
		return Status.OK_STATUS;

Lines 95-100 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationsMessages.java (+10 lines)
95		95
96	public static String LaunchConfigurationTabGroupViewer_14;	96	public static String LaunchConfigurationTabGroupViewer_14;
97		97
		98	public static String LaunchConfigurationTabGroupViewer_15;
		99
		100	public static String LaunchConfigurationTabGroupViewer_16;
		101
98	public static String LaunchConfigurationTabGroupViewer_9;	102	public static String LaunchConfigurationTabGroupViewer_9;
99	public static String LaunchConfigurationTabGroupViewer_13;	103	public static String LaunchConfigurationTabGroupViewer_13;
100	public static String PerspectiveManager_Error_1;	104	public static String PerspectiveManager_Error_1;
Lines 210-215 Link Here
210		214
211	public static String CollapseAllLaunchConfigurationAction_2;	215	public static String CollapseAllLaunchConfigurationAction_2;
212		216
		217	public static String SelectLaunchDelegatesDialog_0;
		218
		219	public static String SelectLaunchDelegatesDialog_1;
		220
		221	public static String SelectLaunchDelegatesDialog_2;
		222
213	public static String SelectLaunchOptionsDialog_2;	223	public static String SelectLaunchOptionsDialog_2;
214		224
215	public static String SelectLaunchOptionsDialog_3;	225	public static String SelectLaunchOptionsDialog_3;

Lines 526-532 Link Here

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

Lines 19-24 Link Here

(-)plugin.properties (+1 lines)
19	ConsoleFont.label= Console font	19	ConsoleFont.label= Console font
20	ConsoleLineTrackersExtensionName= Console Line Trackers	20	ConsoleLineTrackersExtensionName= Console Line Trackers
21	LaunchingPreferencePage.name=Launching	21	LaunchingPreferencePage.name=Launching
		22	LaunchDelegatesPreferencePage.name=Launch Delegates
22	ViewManagementPreferencePage.name=View Management	23	ViewManagementPreferencePage.name=View Management
23	ConsolePreferencePage.name=Console	24	ConsolePreferencePage.name=Console
24	DebugModelContextBindingsName=Debug Model Context Bindings	25	DebugModelContextBindingsName=Debug Model Context Bindings

Lines 145-150 Link Here

(-)plugin.xml (+13 lines)
145	name="%LaunchConfigurationsPage.name">	145	name="%LaunchConfigurationsPage.name">
146	<keywordReference id="org.eclipse.debug.ui.launchconfigurations"/>	146	<keywordReference id="org.eclipse.debug.ui.launchconfigurations"/>
147	</page>	147	</page>
		148	<page
		149	category="org.eclipse.debug.ui.LaunchingPreferencePage"
		150	class="org.eclipse.debug.internal.ui.preferences.LaunchDelegatesPreferencePage"
		151	id="org.eclipse.debug.ui.LaunchDelegatesPreferencePage"
		152	name="%LaunchDelegatesPreferencePage.name">
		153	<keywordReference
		154	id="org.eclipse.debug.ui.launchDelegatesKeywords">
		155	</keywordReference>
		156	</page>
148	</extension>	157	</extension>
149	<extension	158	<extension
150	point="org.eclipse.ui.actionSets">	159	point="org.eclipse.ui.actionSets">
Lines 2293-2298 Link Here
2293	<keyword	2302	<keyword
2294	id="org.eclipse.debug.ui.launchconfigurations"	2303	id="org.eclipse.debug.ui.launchconfigurations"
2295	label="%preferenceKeywords.launchConfigurations"/>	2304	label="%preferenceKeywords.launchConfigurations"/>
		2305	<keyword
		2306	id="org.eclipse.debug.ui.launchDelegatesKeywords"
		2307	label="launch delegate duplicate run debug profile mode configuration">
		2308	</keyword>
2296	</extension>	2309	</extension>
2297	<extension	2310	<extension
2298	point="org.eclipse.ui.importWizards">	2311	point="org.eclipse.ui.importWizards">




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

import java.util.Arrays;

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

import com.ibm.icu.text.MessageFormat;

public class SelectLaunchDelegatesDialog extends SelectionDialog {

	/**
	 * Builds labels for list control
	 */
	class DelegatesLabelProvider implements ILabelProvider {
		public Image getImage(Object element) {return null;}
		public String getText(Object element) {
			if(element instanceof ILaunchDelegate) {
				ILaunchDelegate ldp = (ILaunchDelegate) element;
				String name = ldp.getName();
				if(name == null) {
					name = ldp.getContributorName();
				}
				return name;
			}
			return element.toString();
		}
		public void addListener(ILabelProviderListener listener) {}
		public void dispose() {}
		public boolean isLabelProperty(Object element, String property) {return false;}
		public void removeListener(ILabelProviderListener listener) {}
	}
	
	private static final String SETTINGS_ID = IDebugUIConstants.PLUGIN_ID + ".SELECT_LAUNCH_DELEGATES_DIALOG"; //$NON-NLS-1$
	
	private CheckboxTableViewer fTableViewer = null;
	private Table fTable  = null;
	private ILaunchDelegate[] fDelegates = null;
	
	/**
	 * Constructor
	 * @param parentShell the parent shell
	 * @param delegates the current delegates context
	 * 
	 * @throws CoreException
	 */
	public SelectLaunchDelegatesDialog(Shell parentShell, ILaunchDelegate[] delegates) {
		super(parentShell);
		super.setMessage(MessageFormat.format(LaunchConfigurationsMessages.SelectLaunchDelegatesDialog_0, new String[] {}));
		super.setTitle(LaunchConfigurationsMessages.SelectLaunchDelegatesDialog_1);
		setShellStyle(getShellStyle() | SWT.RESIZE);
		fDelegates = delegates;
	}
	
	/**
	 * @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createDialogArea(Composite parent) {
		initializeDialogUnits(parent);
		Composite comp = (Composite) super.createDialogArea(parent);
		SWTUtil.createLabel(comp, LaunchConfigurationsMessages.SelectLaunchDelegatesDialog_2, 1);
		fTable = new Table(comp, SWT.BORDER | SWT.SINGLE | SWT.CHECK);
		fTable.setLayoutData(new GridData(GridData.FILL_BOTH));
		fTableViewer = new CheckboxTableViewer(fTable);
		fTableViewer.setLabelProvider(new DelegatesLabelProvider());
		fTableViewer.setContentProvider(new ArrayContentProvider());
		fTableViewer.setInput(fDelegates);
		fTableViewer.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				fTableViewer.setAllChecked(false);
				fTableViewer.setChecked(event.getElement(), true);
			}
		});
		Dialog.applyDialogFont(comp);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(comp, IDebugHelpContextIds.SELECT_LAUNCH_DELEGATES_DIALOG);
		return comp;
	}

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

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

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

}




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

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchDelegate;
import org.eclipse.debug.internal.core.LaunchManager;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.DefaultLabelProvider;
import org.eclipse.debug.internal.ui.IDebugHelpContextIds;
import org.eclipse.debug.internal.ui.SWTUtil;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationPresentationManager;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.model.WorkbenchViewerComparator;

/**
 * This class provides a preference page for selecting and changing preferred launch delegates for those of them
 * that have conflicting delegates.
 * 
 * Delegates are considered to be conflicting if they are for the same launc configuraiton type, and apply to the same 
 * mode sets.
 * 
 * @since 3.3
 * 
 * EXPERIMENTAL
 */
public class LaunchDelegatesPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {

	class DuplicateDelegate {
		private ILaunchConfigurationType fType = null;
		private ILaunchDelegate[] fDelegates = null;
		private Set fModes = null;
		
		public DuplicateDelegate(ILaunchConfigurationType type, ILaunchDelegate[] delegates, Set modes) {
			fModes = modes;
			fType = type;
			fDelegates = delegates;
		}
		
		public ILaunchConfigurationType getType() {
			return fType;
		}
		public ILaunchDelegate[] getDelegates() {
			return fDelegates;
		}
		public Set getModeSet() {
			return fModes;
		}
	}
	
	/**
	 * label provider to extend the default one
	 */
	class LabelProvider extends DefaultLabelProvider {
		public String getText(Object element) {
			if(element instanceof ILaunchConfigurationType) {
				return super.getText(element);
			}
			else if(element instanceof DuplicateDelegate) {
				DuplicateDelegate dd = (DuplicateDelegate) element;
				return LaunchConfigurationPresentationManager.getDefault().getLaunchModeNames(dd.getModeSet()).toString();
			}
			else if(element instanceof ILaunchDelegate){
				return ((ILaunchDelegate) element).getName();
			}
			return element.toString();
		}
	}
	
	/**
	 * This class is used to provide content to the tree
	 */
	class TreeProvider implements ITreeContentProvider {
		public Object[] getChildren(Object parentElement) {
			if(parentElement instanceof ILaunchConfigurationType) {
				ILaunchConfigurationType type = (ILaunchConfigurationType) parentElement;
				Set dupes = (Set) fDuplicates.get(type);
				if(dupes != null) {
					return dupes.toArray();
				}
				return null;
			}
			return null;
		}
		public boolean hasChildren(Object element) {
			return element instanceof ILaunchConfigurationType;
		}
		public Object[] getElements(Object inputElement) {
			if(inputElement instanceof Map) {
				return ((Map)inputElement).keySet().toArray();
			}
			return null;
		}
		public Object getParent(Object element) {return null;}
		public void dispose() {}
		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {}
	}
	
	private TreeViewer fTreeViewer = null;
	private CheckboxTableViewer fTableViewer = null;
	private Map fDuplicates = null;
	private Map fDupeSelections = null;
	private boolean fDirty = false;
	
	/**
	 * Constructor
	 */
	public LaunchDelegatesPreferencePage() {
		setTitle(DebugPreferencesMessages.LaunchDelegatesPreferencePage_0);
	}

	/**
	 * @see org.eclipse.jface.preference.PreferencePage#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public void createControl(Composite parent) {
		super.createControl(parent);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(getControl(), IDebugHelpContextIds.LAUNCH_DELEGATES_PREFERENCE_PAGE);
		getDefaultsButton().setEnabled(false);
	}

	/**
	 * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createContents(Composite parent) {
		Composite comp = SWTUtil.createComposite(parent, parent.getFont(), 2, 1, GridData.FILL_BOTH);
		SWTUtil.createWrapLabel(comp, DebugPreferencesMessages.LaunchDelegatesPreferencePage_1, 2, 300);
		
	//tree
		Tree tree = new Tree(comp, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.SINGLE);
		GridData gd = new GridData(GridData.FILL_BOTH);
		gd.grabExcessHorizontalSpace = false;
		tree.setLayoutData(gd);
		fTreeViewer = new TreeViewer(tree);
		fTreeViewer.setComparator(new WorkbenchViewerComparator());
		fTreeViewer.setContentProvider(new TreeProvider());
		fTreeViewer.setLabelProvider(new LabelProvider());
		fTreeViewer.setInput(fDuplicates);
		fTreeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent event) {
				Object obj = ((IStructuredSelection) event.getSelection()).getFirstElement();
				if(obj instanceof DuplicateDelegate) {
					fTableViewer.setAllChecked(false);
					DuplicateDelegate dd = (DuplicateDelegate) obj;
					fTableViewer.setInput(dd.getDelegates());
					obj = fDupeSelections.get(dd);
					if(obj != null) {
						fTableViewer.setChecked(obj, true);
					}
				}
				else {
					fTableViewer.setInput(null);
				}
			}
		});
		
	//table
		Table table = new Table(comp, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.CHECK | SWT.SINGLE);
		gd = new GridData(GridData.FILL_BOTH);
		table.setLayoutData(gd);
		fTableViewer = new CheckboxTableViewer(table);
		fTableViewer.setComparator(new WorkbenchViewerComparator());
		fTableViewer.setLabelProvider(new LabelProvider());
		fTableViewer.setContentProvider(new ArrayContentProvider());
		fTableViewer.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				fDirty = true;
				Object element = event.getElement();
				boolean checked = event.getChecked();
				fTableViewer.setAllChecked(false);
				fTableViewer.setChecked(element, checked);
				//persist the selection
				Object obj = ((IStructuredSelection) fTreeViewer.getSelection()).getFirstElement();
				if(obj instanceof DuplicateDelegate) {
					fDupeSelections.remove(obj);
					if(checked) {
						fDupeSelections.put(obj, element);
					}
				}
			}
		});
		//make a size good enough to see it all at the onset
		comp.setSize(400, 500);
		
		return comp;
	}

	/**
	 * @see org.eclipse.jface.preference.PreferencePage#performOk()
	 */
	public boolean performOk() {
		if(fDirty && fDupeSelections != null && fDupeSelections.size() > 0) {
			fDirty = false;
			DuplicateDelegate dd = null;
			ILaunchDelegate delegate = null;
			for(Iterator iter = fDupeSelections.keySet().iterator(); iter.hasNext();) {
				dd = (DuplicateDelegate) iter.next();
				delegate = (ILaunchDelegate) fDupeSelections.get(dd);
				try {
					dd.getType().setPreferredDelegate(dd.getModeSet(), delegate);
				} 
				catch (CoreException e) {DebugUIPlugin.log(e);}
			}
		}
		return super.performOk();
	}

	/**
	 * @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)
	 */
	public void init(IWorkbench workbench) {
		//init a listing of duplicate delegates arranged by type
		try {
			LaunchManager lm = (LaunchManager) DebugPlugin.getDefault().getLaunchManager();
			ILaunchConfigurationType[] types = lm.getLaunchConfigurationTypes();
			fDuplicates = new HashMap();
			fDupeSelections = new HashMap();
			Set modes = null;
			ILaunchDelegate[] delegates = null;
			Set modeset = null;
			Set tmp = null;
			ILaunchDelegate prefdelegate = null;
			DuplicateDelegate dd = null;
			for(int i = 0; i < types.length; i++) {
				modes = types[i].getSupportedModeCombinations();
				for(Iterator iter = modes.iterator(); iter.hasNext();) {
					modeset = (Set) iter.next();
					delegates = types[i].getDelegates(modeset);
					if(delegates.length > 1) {
						tmp = (Set) fDuplicates.get(types[i]);
						if(tmp == null) {
							tmp = new HashSet();
						}
						dd = new DuplicateDelegate(types[i], delegates, modeset);
						tmp.add(dd);
						fDuplicates.put(types[i], tmp);
						prefdelegate = types[i].getPreferredDelegate(modeset);
						if(prefdelegate != null) {
							fDupeSelections.put(dd, prefdelegate);
						}
					}
				}
			}
		}
		catch(CoreException e) {DebugUIPlugin.log(e);}
	}

}

Lines 487-492 Link Here

(-)contexts_Debugger.xml (+28 lines)
487	<topic label="Running and Debugging" href="tasks/task-running_and_debugging.htm"/>	487	<topic label="Running and Debugging" href="tasks/task-running_and_debugging.htm"/>
488	<topic label="Creating a Java application launch configuration" href="tasks/tasks-java-local-configuration.htm"/>	488	<topic label="Creating a Java application launch configuration" href="tasks/tasks-java-local-configuration.htm"/>
489	</context>	489	</context>
		490	<context id="select_launch_delegates_dialog">
		491	<description>This dialog allows you to select a delegate to continue launching in the event there is more than one delegate available to launch a particular type in a given mode.</description>
		492	<topic label="Running and Debugging" href="tasks/task-running_and_debugging.htm"/>
		493	<topic label="Creating a Java application launch configuration" href="tasks/tasks-java-local-configuration.htm"/>
		494	</context>
490		495
491		496
492		497
Lines 728-757 Link Here
728	</context>	733	</context>
729	<context id="launch_history_preference_page_context" >	734	<context id="launch_history_preference_page_context" >
730	<description>On this page, you can modify launch history and favorites.</description>	735	<description>On this page, you can modify launch history and favorites.</description>
		736	<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>
		737	<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>
731	</context>	738	</context>
732	<context id="debug_action_groups_views_preference_page_context" >	739	<context id="debug_action_groups_views_preference_page_context" >
733	<description>On this page, you can enable and disable actions associated with a debugger. When a group of actions is disabled, the actions will not appear in debug views.</description>	740	<description>On this page, you can enable and disable actions associated with a debugger. When a group of actions is disabled, the actions will not appear in debug views.</description>
		741	<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>
		742	<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>
734	</context>	743	</context>
735	<context id="simple_variable_preference_page_context">	744	<context id="simple_variable_preference_page_context">
736	<description>One this page, you can create and configure simple launch variables which you can reference in launch configurations that support variables.</description>	745	<description>One this page, you can create and configure simple launch variables which you can reference in launch configurations that support variables.</description>
		746	<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>
		747	<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>
737	</context>	748	</context>
738	<context id="table_renderings_preference_page_context">	749	<context id="table_renderings_preference_page_context">
739	<description>On this page, you can configure the memory loading mode in table renderings. </description>	750	<description>On this page, you can configure the memory loading mode in table renderings. </description>
		751	<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>
		752	<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>
740	</context>	753	</context>
741	<context id="perspective_preference_page_context">	754	<context id="perspective_preference_page_context">
742	<description>On this page, you can configure the perspectives used when running and debugging.</description>	755	<description>On this page, you can configure the perspectives used when running and debugging.</description>
		756	<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>
		757	<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>
743	</context>	758	</context>
744	<context id="launching_preference_page_context">	759	<context id="launching_preference_page_context">
745	<description>On this page, you can configure launch options.</description>	760	<description>On this page, you can configure launch options.</description>
		761	<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>
		762	<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>
746	</context>	763	</context>
747	<context id="launch_configuration_preference_page_context">	764	<context id="launch_configuration_preference_page_context">
748	<description>On this page, you can configure the filters used in the launch dialog and migrate launch configurations.</description>	765	<description>On this page, you can configure the filters used in the launch dialog and migrate launch configurations.</description>
		766	<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>
		767	<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>
749	</context>	768	</context>
750	<context id="view_management_preference_page_context">	769	<context id="view_management_preference_page_context">
751	<description>On this page, you can select the perspectives that debug related views will be opened in automatically.</description>	770	<description>On this page, you can select the perspectives that debug related views will be opened in automatically.</description>
		771	<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>
		772	<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>
752	</context>	773	</context>
753	<context id="resetMemoryMonitor_preference_page_context" >	774	<context id="resetMemoryMonitor_preference_page_context" >
754	<description>On this page, you can configure the reset memory monitor behavior. </description>	775	<description>On this page, you can configure the reset memory monitor behavior. </description>
		776	<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>
		777	<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>
		778	</context>
		779	<context id="launch_delegate_preferencef_page_context">
		780	<description>On this page, you can select default launch delegates in the event there are duplicates</description>
		781	<topic label="Debug Preferences" href="reference/preferences/ref-debug.htm"/>
		782	<topic label="Debugger Concepts" href="concepts/cdebugger.htm"/>
755	</context>	783	</context>
756		784
757	<!--	785	<!--

Return to bug 157059

Lines 16-22 Link Here

(-)tests/org/eclipse/jdt/debug/tests/core/LaunchDelegateTests.java (-7 / +7 lines)
16	import org.eclipse.debug.core.ILaunch;	16	import org.eclipse.debug.core.ILaunch;
17	import org.eclipse.debug.core.ILaunchConfigurationType;	17	import org.eclipse.debug.core.ILaunchConfigurationType;
18	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;	18	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
19	import org.eclipse.debug.core.ILaunchDelegateProxy;	19	import org.eclipse.debug.core.ILaunchDelegate;
20	import org.eclipse.debug.core.ILaunchManager;	20	import org.eclipse.debug.core.ILaunchManager;
21	import org.eclipse.debug.core.sourcelookup.ISourcePathComputer;	21	import org.eclipse.debug.core.sourcelookup.ISourcePathComputer;
22	import org.eclipse.jdt.debug.testplugin.AlternateDelegate;	22	import org.eclipse.jdt.debug.testplugin.AlternateDelegate;
Lines 79-86 Link Here
79	HashSet modes = new HashSet();	79	HashSet modes = new HashSet();
80	modes.add("alternate");	80	modes.add("alternate");
81	modes.add(ILaunchManager.DEBUG_MODE);	81	modes.add(ILaunchManager.DEBUG_MODE);
82	assertTrue("Should support mixed mode (alternate/debug)", type.supportsModeCombination(modes));	82	assertTrue("Should support mixed mode (alternate/debug)", type.supportsModes(modes));
83	ILaunchDelegateProxy[] delegates = type.getDelegates(modes);	83	ILaunchDelegate[] delegates = type.getDelegates(modes);
84	assertTrue("missing delegate", delegates.length > 0);	84	assertTrue("missing delegate", delegates.length > 0);
85	assertEquals("Wrong number of delegates", 1, delegates.length);	85	assertEquals("Wrong number of delegates", 1, delegates.length);
86	assertTrue("Wrong delegate", delegates[0].getDelegate() instanceof AlternateDelegate);	86	assertTrue("Wrong delegate", delegates[0].getDelegate() instanceof AlternateDelegate);
Lines 96-103 Link Here
96	assertNotNull("Missing java application launch config type", type);	96	assertNotNull("Missing java application launch config type", type);
97	HashSet modes = new HashSet();	97	HashSet modes = new HashSet();
98	modes.add(ILaunchManager.DEBUG_MODE);	98	modes.add(ILaunchManager.DEBUG_MODE);
99	assertTrue("Should support mode (debug)", type.supportsModeCombination(modes));	99	assertTrue("Should support mode (debug)", type.supportsModes(modes));
100	ILaunchDelegateProxy[] delegates = type.getDelegates(modes);	100	ILaunchDelegate[] delegates = type.getDelegates(modes);
101	assertTrue("missing delegate", delegates.length > 0);	101	assertTrue("missing delegate", delegates.length > 0);
102	assertEquals("Wrong number of delegates", 1, delegates.length);	102	assertEquals("Wrong number of delegates", 1, delegates.length);
103	assertTrue("Wrong delegate", delegates[0].getDelegate().getClass().getName().endsWith("JavaLaunchDelegate"));	103	assertTrue("Wrong delegate", delegates[0].getDelegate().getClass().getName().endsWith("JavaLaunchDelegate"));
Lines 113-120 Link Here
113	assertNotNull("Missing java application launch config type", type);	113	assertNotNull("Missing java application launch config type", type);
114	HashSet modes = new HashSet();	114	HashSet modes = new HashSet();
115	modes.add("alternate");	115	modes.add("alternate");
116	assertTrue("Should support mode (alternate)", type.supportsModeCombination(modes));	116	assertTrue("Should support mode (alternate)", type.supportsModes(modes));
117	ILaunchDelegateProxy[] delegates = type.getDelegates(modes);	117	ILaunchDelegate[] delegates = type.getDelegates(modes);
118	assertTrue("missing delegate", delegates.length > 0);	118	assertTrue("missing delegate", delegates.length > 0);
119	assertEquals("Wrong number of delegates", 1, delegates.length);	119	assertEquals("Wrong number of delegates", 1, delegates.length);
120	assertTrue("Wrong delegate", delegates[0].getDelegate() instanceof AlternateDelegate);	120	assertTrue("Wrong delegate", delegates[0].getDelegate() instanceof AlternateDelegate);

Lines 11-19 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchDelegate.java (-73 / +45 lines)
11	package org.eclipse.debug.internal.core;	11	package org.eclipse.debug.internal.core;
12		12
13	import java.util.ArrayList;	13	import java.util.ArrayList;
14	import java.util.Collection;
15	import java.util.HashSet;	14	import java.util.HashSet;
16	import java.util.Iterator;
17	import java.util.List;	15	import java.util.List;
18	import java.util.Set;	16	import java.util.Set;
19		17
Lines 22-28 Link Here
22	import org.eclipse.core.runtime.IStatus;	20	import org.eclipse.core.runtime.IStatus;
23	import org.eclipse.core.runtime.Status;	21	import org.eclipse.core.runtime.Status;
24	import org.eclipse.debug.core.DebugPlugin;	22	import org.eclipse.debug.core.DebugPlugin;
25	import org.eclipse.debug.core.ILaunchDelegateProxy;	23	import org.eclipse.debug.core.ILaunchDelegate;
26	import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;	24	import org.eclipse.debug.core.model.ILaunchConfigurationDelegate;
27		25
28	import com.ibm.icu.text.MessageFormat;	26	import com.ibm.icu.text.MessageFormat;
Lines 47-53 Link Here
47	*	45	*
48	* @since 3.3	46	* @since 3.3
49	*/	47	*/
50	public final class LaunchDelegate implements ILaunchDelegateProxy {	48	public final class LaunchDelegate implements ILaunchDelegate {
51		49
52	/**	50	/**
53	* The configuration element for this delegate	51	* The configuration element for this delegate
Lines 59-67 Link Here
59	*/	57	*/
60	private ILaunchConfigurationDelegate fDelegate = null;	58	private ILaunchConfigurationDelegate fDelegate = null;
61		59
62	//lists of cached entries	60	//a listing of sets of
		61	private List fLaunchModes = null;
63	private HashSet fModes = null;	62	private HashSet fModes = null;
64	private HashSet fOptions = null;
65	private String fType = null;	63	private String fType = null;
66		64
67	/**	65	/**
Lines 72-77 Link Here
72	fElement = element;	70	fElement = element;
73	}	71	}
74		72
		73	/* (non-Javadoc)
		74	* @see org.eclipse.debug.core.ILaunchDelegateProxy#getDelegate()
		75	*/
75	public ILaunchConfigurationDelegate getDelegate() throws CoreException {	76	public ILaunchConfigurationDelegate getDelegate() throws CoreException {
76	if(fDelegate == null) {	77	if(fDelegate == null) {
77	Object obj = fElement.createExecutableExtension(IConfigurationElementConstants.DELEGATE);	78	Object obj = fElement.createExecutableExtension(IConfigurationElementConstants.DELEGATE);
Lines 84-89 Link Here
84	return fDelegate;	85	return fDelegate;
85	}	86	}
86		87
		88	/* (non-Javadoc)
		89	* @see org.eclipse.debug.core.ILaunchDelegateProxy#getId()
		90	*/
87	public String getId() {	91	public String getId() {
88	return fElement.getAttribute(IConfigurationElementConstants.ID);	92	return fElement.getAttribute(IConfigurationElementConstants.ID);
89	}	93	}
Lines 103-127 Link Here
103	}	107	}
104	return fType;	108	return fType;
105	}	109	}
106
107	public Set getOptions() {
108	if(fOptions == null) {
109	fOptions = new HashSet();
110	String option = fElement.getAttribute(IConfigurationElementConstants.OPTIONS);
111	if(option != null) {
112	String[] options = option.split(","); //$NON-NLS-1$
113	for(int i = 0; i < options.length; i++) {
114	fOptions.add(options[i].trim());
115	}
116	}
117	}
118	return fOptions;
119	}
120		110
121	public Set getModes() {	111	/**
		112	* Parese a list of modes and creates a new set of them
		113	* @param element the configuraiton element to read from
		114	* @return a set of launch modes created form a comma seperated list
		115	*/
		116	private Set getModes(IConfigurationElement element) {
122	if (fModes == null) {	117	if (fModes == null) {
123	fModes = new HashSet();	118	fModes = new HashSet();
124	String modes = fElement.getAttribute(IConfigurationElementConstants.MODES);	119	String modes = element.getAttribute(IConfigurationElementConstants.MODES);
125	if (modes != null) {	120	if (modes != null) {
126	String[] strings = modes.split(","); //$NON-NLS-1$	121	String[] strings = modes.split(","); //$NON-NLS-1$
127	for (int i = 0; i < strings.length; i++) {	122	for (int i = 0; i < strings.length; i++) {
Lines 132-137 Link Here
132	return fModes;	127	return fModes;
133	}	128	}
134		129
		130	/* (non-Javadoc)
		131	* @see org.eclipse.debug.core.ILaunchDelegateProxy#getModes()
		132	*/
		133	public List getModes() {
		134	if(fLaunchModes == null) {
		135	fLaunchModes = new ArrayList();
		136	IConfigurationElement[] children = fElement.getChildren(IConfigurationElementConstants.MODES_COMBINATION);
		137	for (int i = 0; i < children.length; i++) {
		138	fLaunchModes.add(getModes(children[i]));
		139	}
		140	if(fLaunchModes.size() == 0) {
		141	//try to get the modes from the old definition and make each one
		142	//a seperate set of one element
		143	String modes = fElement.getAttribute(IConfigurationElementConstants.MODES);
		144	if (modes != null) {
		145	String[] strings = modes.split(","); //$NON-NLS-1$
		146	HashSet modeset = null;
		147	for (int i = 0; i < strings.length; i++) {
		148	modeset = new HashSet();
		149	modeset.add(strings[i].trim());
		150	fLaunchModes.add(modeset);
		151	}
		152	}
		153	}
		154	}
		155	return fLaunchModes;
		156	}
		157
135	/**	158	/**
136	* Returns the human readable name for this launch delegate	159	* Returns the human readable name for this launch delegate
137	* @return the human readable name for this launch delegate, or <code>null</code> if none	160	* @return the human readable name for this launch delegate, or <code>null</code> if none
Lines 164-218 Link Here
164	public String getSourcePathComputerId() {	187	public String getSourcePathComputerId() {
165	return fElement.getAttribute(IConfigurationElementConstants.SOURCE_PATH_COMPUTER);	188	return fElement.getAttribute(IConfigurationElementConstants.SOURCE_PATH_COMPUTER);
166	}	189	}
167
168	/**
169	* Returns all combinations of supported options.
170	*
171	* @return combinations of supported options
172	*/
173	private Collection getOptionSets() {
174	Set optionSets = new HashSet();
175	optionSets.add(new HashSet()); // seed with the empty option set
176	Object[] options = getOptions().toArray();
177	boolean grew = false;
178	do {
179	grew = false;
180	Set[] sets = (Set[]) optionSets.toArray(new Set[optionSets.size()]);
181	for (int i = 0; i < sets.length; i++) {
182	Set optionSet = sets[i];
183	for (int j = 0; j < options.length; j++) {
184	Object option = options[j];
185	Set newOptionSet = new HashSet(optionSet);
186	if (newOptionSet.add(option)) {
187	if (optionSets.add(newOptionSet)) {
188	grew = true;
189	}
190	}
191	}
192	}
193	} while (grew);
194	return optionSets;
195	}
196
197	/**
198	* Returns all supported launch mode combinations as sets of modes.
199	*
200	* @return all supported launch mode combinations
201	*/
202	List getModeCombinations() {
203	Collection optionSets = getOptionSets();
204	Object[] modes = getModes().toArray();
205	List combinations = new ArrayList(optionSets.size() * modes.length);
206	Iterator iterator = optionSets.iterator();
207	while (iterator.hasNext()) {
208	Set optionSet = (Set) iterator.next();
209	for (int i = 0; i < modes.length; i++) {
210	Object mode = modes[i];
211	Set set = new HashSet(optionSet);
212	set.add(mode);
213	combinations.add(set);
214	}
215	}
216	return combinations;
217	}
218	}	190	}

Lines 67-72 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchManager.java (-4 / +201 lines)
67	import org.eclipse.core.runtime.ListenerList;	67	import org.eclipse.core.runtime.ListenerList;
68	import org.eclipse.core.runtime.Platform;	68	import org.eclipse.core.runtime.Platform;
69	import org.eclipse.core.runtime.PlatformObject;	69	import org.eclipse.core.runtime.PlatformObject;
		70	import org.eclipse.core.runtime.Preferences;
70	import org.eclipse.core.runtime.SafeRunner;	71	import org.eclipse.core.runtime.SafeRunner;
71	import org.eclipse.core.runtime.Status;	72	import org.eclipse.core.runtime.Status;
72	import org.eclipse.core.variables.VariablesPlugin;	73	import org.eclipse.core.variables.VariablesPlugin;
Lines 76-81 Link Here
76	import org.eclipse.debug.core.ILaunchConfiguration;	77	import org.eclipse.debug.core.ILaunchConfiguration;
77	import org.eclipse.debug.core.ILaunchConfigurationListener;	78	import org.eclipse.debug.core.ILaunchConfigurationListener;
78	import org.eclipse.debug.core.ILaunchConfigurationType;	79	import org.eclipse.debug.core.ILaunchConfigurationType;
		80	import org.eclipse.debug.core.ILaunchDelegate;
79	import org.eclipse.debug.core.ILaunchListener;	81	import org.eclipse.debug.core.ILaunchListener;
80	import org.eclipse.debug.core.ILaunchManager;	82	import org.eclipse.debug.core.ILaunchManager;
81	import org.eclipse.debug.core.ILaunchMode;	83	import org.eclipse.debug.core.ILaunchMode;
Lines 112-117 Link Here
112	*/	114	*/
113	public class LaunchManager extends PlatformObject implements ILaunchManager, IResourceChangeListener {	115	public class LaunchManager extends PlatformObject implements ILaunchManager, IResourceChangeListener {
114		116
		117
		118	/**
		119	* Constants for xml node names
		120	*
		121	* @since 3.3
		122	*
		123	* EXPERIMENTAL
		124	*/
		125	protected static final String MODES = "modes"; //$NON-NLS-1$
		126	protected static final String TYPEID = "typeid"; //$NON-NLS-1$
		127	protected static final String ID = "id"; //$NON-NLS-1$
		128	protected static final String DELEGATE = "delegate"; //$NON-NLS-1$
		129	protected static final String PREFERRED_DELEGATES = "preferredDelegates"; //$NON-NLS-1$
		130	protected static final String PREF_PREFERRED_DELEGATES = DebugPlugin.getUniqueIdentifier() + ".PREFERRED_DELEGATES"; //$NON-NLS-1$
		131
115	/**	132	/**
116	* Constant to define debug.core for the status codes	133	* Constant to define debug.core for the status codes
117	*	134	*
Lines 131-137 Link Here
131	*	148	*
132	* @since 3.2	149	* @since 3.2
133	*/	150	*/
134	private static final String EMPTY_STRING = ""; //$NON-NLS-1$	151	protected static final String EMPTY_STRING = ""; //$NON-NLS-1$
135		152
136	/**	153	/**
137	* Status code for which a UI prompter is registered.	154	* Status code for which a UI prompter is registered.
Lines 462-467 Link Here
462	}	479	}
463		480
464	/**	481	/**
		482	* Internal class used to hold information about a preferred delegate
		483	* @since 3.3
		484	*
		485	* EXPERIMENTAL
		486	*/
		487	class PreferredDelegate {
		488	private ILaunchDelegate fDelegate = null;
		489	private String fTypeid = null;
		490	private Set fModes = null;
		491
		492	public PreferredDelegate(ILaunchDelegate delegate, String typeid, Set modes) {
		493	fDelegate = delegate;
		494	fTypeid = typeid;
		495	fModes = modes;
		496	}
		497
		498	public String getTypeId() {
		499	return fTypeid;
		500	}
		501
		502	public Set getModes() {
		503	return fModes;
		504	}
		505
		506	public ILaunchDelegate getDelegate() {
		507	return fDelegate;
		508	}
		509	}
		510
		511	/**
465	* Types of notifications	512	* Types of notifications
466	*/	513	*/
467	public static final int ADDED = 0;	514	public static final int ADDED = 0;
Lines 557-562 Link Here
557	private HashMap fLaunchDelegates = null;	604	private HashMap fLaunchDelegates = null;
558		605
559	/**	606	/**
		607	* Initial startup cache of preferred delegate so that the debug prefs are only parsed once
		608	*
		609	* @since 3.3
		610	*
		611	* EXPERIMENTAL
		612	*/
		613	private Set fPreferredDelegates = null;
		614
		615	/**
560	* Collection of launches	616	* Collection of launches
561	*/	617	*/
562	private List fLaunches= new ArrayList(10);	618	private List fLaunches= new ArrayList(10);
Lines 1383-1388 Link Here
1383	}	1439	}
1384		1440
1385	/**	1441	/**
		1442	* This method is used to initialize a simple listing of all preferred delegates, which is then used by each
		1443	* <code>ILaunchConfigurationType</code> to find if they have preferred delegates. Once an <code>ILaunchConfigurationType</code>
		1444	* has used this listing to initialize its preferred delegates ti will maintain changes to its preferred delegate, which are
		1445	* then written back to the pref sotre only when the launch manager shuts down.
		1446	*
		1447	* <p>
		1448	* This cache is not synchronized with the runtime preferred delegates stored in launch configuration types.
		1449	* </p>
		1450	*
		1451	* @since 3.3
		1452	*
		1453	* EXPERIMENTAL
		1454	*/
		1455	private synchronized void initializePreferredDelegates() {
		1456	if(fPreferredDelegates == null) {
		1457	fPreferredDelegates = new HashSet();
		1458	Preferences prefs = DebugPlugin.getDefault().getPluginPreferences();
		1459	String preferred = prefs.getString(LaunchManager.PREF_PREFERRED_DELEGATES);
		1460	if(!EMPTY_STRING.equals(preferred)) {
		1461	try {
		1462	Element root = DebugPlugin.parseDocument(preferred);
		1463	NodeList nodes = root.getElementsByTagName(LaunchManager.DELEGATE);
		1464	Element element = null;
		1465	String tid = null, mod = null, did = null;
		1466	String[] modes = null;
		1467	Set modeset = null;
		1468	LaunchDelegate[] extensions = null;
		1469	ILaunchDelegate delegate = null;
		1470	for(int i = 0; i < nodes.getLength(); i++) {
		1471	element = (Element) nodes.item(i);
		1472	tid = element.getAttribute(LaunchManager.TYPEID);
		1473	if(!EMPTY_STRING.equals(tid)) {
		1474	//get the modes
		1475	mod = element.getAttribute(LaunchManager.MODES);
		1476	modes = mod.split(","); //$NON-NLS-1$
		1477	modeset = new HashSet();
		1478	for(int j = 0; j < modes.length; j++) {
		1479	modeset.add(modes[j].trim());
		1480	}
		1481	//get the delegate id and the delegate
		1482	did = element.getAttribute(LaunchManager.ID);
		1483	extensions = getLaunchDelegates();
		1484	for(int j = 0; j < extensions.length; j++) {
		1485	if(!EMPTY_STRING.equals(did) && did.equals(extensions[j].getId())
		1486	&& tid.equals(extensions[j].getLaunchConfigurationTypeId())
		1487	&& extensions[j].getModes().contains(modeset)) {
		1488	delegate = extensions[j];
		1489	break;
		1490	}
		1491	}
		1492	//take tid, modeset, delegate and create entry
		1493	if(delegate != null & !EMPTY_STRING.equals(tid) & modeset != null) {
		1494	fPreferredDelegates.add(new PreferredDelegate(delegate, tid, modeset));
		1495	}
		1496	}
		1497	}
		1498	}
		1499	catch (CoreException e) {DebugPlugin.log(e);}
		1500	}
		1501	}
		1502	}
		1503
		1504	/**
		1505	* Allows internal access to a preferred delegate for a given type and mode set
1506	* @param typeid the id of the <code>ILaunchConfigurationType</code> to find a delegate for
1507	* @param modes ther set of modes for the delegate
1508	* @return the preferred delegate for the specified type id and mode set, or <code>null</code> if none
1509	*
1510	* @since 3.3
1511	*
1512	* EXPERIMENTAL
1513	*/
1514	protected ILaunchDelegate getPreferredDelegate(String typeid, Set modes) {
1515	initializePreferredDelegates();
1516	PreferredDelegate pd = null;
1517	for(Iterator iter = fPreferredDelegates.iterator(); iter.hasNext();) {
1518	pd = (PreferredDelegate) iter.next();
1519	if(pd.getModes().equals(modes) & pd.getTypeId().equals(typeid)) {
1520	return pd.getDelegate();
1521	}
1522	}
1523	return null;
1524	}
1525
1526	/**
1386	* Returns all launch configurations that are stored locally.	1527	* Returns all launch configurations that are stored locally.
1387	*	1528	*
1388	* @return collection of launch configurations stored locally	1529	* @return collection of launch configurations stored locally
Lines 1634-1640 Link Here
1634	sourceContainerTypes = new HashMap();	1775	sourceContainerTypes = new HashMap();
1635	for (int i = 0; i < extensions.length; i++) {	1776	for (int i = 0; i < extensions.length; i++) {
1636	sourceContainerTypes.put(	1777	sourceContainerTypes.put(
1637	extensions[i].getAttribute("id"), //$NON-NLS-1$	1778	extensions[i].getAttribute(ID),
1638	new SourceContainerType(extensions[i]));	1779	new SourceContainerType(extensions[i]));
1639	}	1780	}
1640	extensionPoint= Platform.getExtensionRegistry().getExtensionPoint(DebugPlugin.getUniqueIdentifier(), DebugPlugin.EXTENSION_POINT_SOURCE_PATH_COMPUTERS);	1781	extensionPoint= Platform.getExtensionRegistry().getExtensionPoint(DebugPlugin.getUniqueIdentifier(), DebugPlugin.EXTENSION_POINT_SOURCE_PATH_COMPUTERS);
Lines 1642-1648 Link Here
1642	sourcePathComputers = new HashMap();	1783	sourcePathComputers = new HashMap();
1643	for (int i = 0; i < extensions.length; i++) {	1784	for (int i = 0; i < extensions.length; i++) {
1644	sourcePathComputers.put(	1785	sourcePathComputers.put(
1645	extensions[i].getAttribute("id"), //$NON-NLS-1$	1786	extensions[i].getAttribute(ID),
1646	new SourcePathComputer(extensions[i]));	1787	new SourcePathComputer(extensions[i]));
1647	}	1788	}
1648	}	1789	}
Lines 1663-1669 Link Here
1663	String id = null;	1804	String id = null;
1664	for (int i= 0; i < infos.length; i++) {	1805	for (int i= 0; i < infos.length; i++) {
1665	configurationElement = infos[i];	1806	configurationElement = infos[i];
1666	id = configurationElement.getAttribute("id"); //$NON-NLS-1$	1807	id = configurationElement.getAttribute(ID);
1667	if (id != null) {	1808	if (id != null) {
1668	fSourceLocators.put(id,configurationElement);	1809	fSourceLocators.put(id,configurationElement);
1669	} else {	1810	} else {
Lines 2015-2026 Link Here
2015	}	2156	}
2016	}	2157	}
2017		2158
		2159	persistPreferredLaunchDelegates();
2018	clearAllLaunchConfigurations();	2160	clearAllLaunchConfigurations();
2019		2161
2020	ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);	2162	ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
2021	}	2163	}
2022		2164
2023	/**	2165	/**
		2166	* Saves the listings of preferred launch delegates from all of the launch configuration types
		2167	*
		2168	* @since 3.3
		2169	*
		2170	* EXPERIMENTAL
		2171	*/
		2172	private void persistPreferredLaunchDelegates() {
		2173	Preferences prefs = DebugPlugin.getDefault().getPluginPreferences();
		2174	try {
		2175	Document doc = DebugPlugin.newDocument();
		2176	Element root = doc.createElement(PREFERRED_DELEGATES);
		2177	doc.appendChild(root);
		2178	ILaunchConfigurationType[] types = getLaunchConfigurationTypes();
		2179	Map preferred = null;
		2180	Element child = null;
		2181	ILaunchDelegate delegate = null;
		2182	Set modes = null;
		2183	String modestr = EMPTY_STRING;
		2184	for(int i = 0; i < types.length; i++) {
		2185	preferred = ((LaunchConfigurationType)types[i]).getPreferredDelegates();
		2186	if(preferred != null && preferred.size() > 0) {
		2187	for(Iterator iter = preferred.keySet().iterator(); iter.hasNext();) {
		2188	modes = (Set) iter.next();
		2189	delegate = (ILaunchDelegate) preferred.get(modes);
		2190	child = doc.createElement(DELEGATE);
		2191	child.setAttribute(ID, delegate.getId());
		2192	child.setAttribute(TYPEID, types[i].getIdentifier());
		2193	for(Iterator iter2 = modes.iterator(); iter2.hasNext();) {
		2194	modestr += iter2.next();
		2195	if(iter2.hasNext()) {
		2196	modestr += ","; //$NON-NLS-1$
		2197	}
		2198	}
		2199	child.setAttribute(MODES, modes.toString());
		2200	root.appendChild(child);
		2201	}
		2202	}
		2203	}
		2204	String pref = null;
		2205	if(root.hasChildNodes()) {
		2206	pref = serializeDocument(doc);
		2207	}
		2208	if(pref != null) {
		2209	prefs.setValue(PREF_PREFERRED_DELEGATES, pref);
		2210	}
		2211	if(prefs.needsSaving()) {
		2212	DebugPlugin.getDefault().savePluginPreferences();
		2213	}
		2214	}
		2215	catch (CoreException e) {DebugPlugin.log(e);}
		2216	catch (IOException ioe) {DebugPlugin.log(ioe);}
		2217	catch (TransformerException te) {DebugPlugin.log(te);}
		2218	}
		2219
		2220	/**
2024	* finds and terminates any running launch configurations associated with the given resource	2221	* finds and terminates any running launch configurations associated with the given resource
2025	* @param resource the resource to search for launch configurations and hence launches for	2222	* @param resource the resource to search for launch configurations and hence launches for
2026	* @since 3.2	2223	* @since 3.2

Removed Link Here

(-)core/org/eclipse/debug/core/ILaunchDelegateProxy.java (-79 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.debug.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	* A proxy to a launch configuration delegate. Represents a
20	* launch delegate contributed to the <code>org.eclipse.debug.core.launchDelegates</code>
21	* extension point.
22	*
23	* @since 3.3
24	* <p>
25	* <strong>EXPERIMENTAL</strong>. This interface has been added as
26	* part of a work in progress. There is no guarantee that this API will
27	* remain unchanged during the 3.3 release cycle. Please do not use this API
28	* without consulting with the Platform/Debug team.
29	* </p>
30	*/
31	public interface ILaunchDelegateProxy {
32
33	/**
34	* Returns this delegate's unique identifier.
35	*
36	* @return launch delegate identifier
37	*/
38	public String getId();
39
40	/**
41	* Returns a human readable name for this launch delegate
42	* or <code>null</code> if none.
43	*
44	* @return name or <code>null</code>
45	*/
46	public String getName();
47
48	/**
49	* Returns the name of the plug-in that contributed this delegate.
50	*
51	* @return contributor name
52	*/
53	public String getContributorName();
54
55	/**
56	* Returns the delegate that performs the actual launch.
57	* Causes the delegate to be instantiated.
58	*
59	* @return launch delegate
60	* @exception CoreException if unable to instantiate the delegate
61	*/
62	public ILaunchConfigurationDelegate getDelegate() throws CoreException;
63
64	/**
65	* Returns the launch modes this delegate supports.
66	*
67	* @return launch modes as a set of launch mode identifiers
68	*/
69	public Set getModes();
70
71	/**
72	* Returns the launch modes this delegate supports in combination with
73	* its modes specified by <code>getModes()</code>.
74	*
75	* @return launch options as a set of launch mode identifiers
76	*/
77	public Set getOptions();
78
79	}

Lines 148-169 Link Here

(-)core/org/eclipse/debug/core/ILaunchConfigurationType.java (-12 / +39 lines)
148	* without consulting with the Platform/Debug team.	148	* without consulting with the Platform/Debug team.
149	* </p>	149	* </p>
150	*/	150	*/
151	public ILaunchDelegateProxy[] getDelegates(Set modes) throws CoreException;	151	public ILaunchDelegate[] getDelegates(Set modes) throws CoreException;
152		152
153	/**	153	/**
154	* Returns a collection of all supported launch mode combinations for	154	* Returns the preferred launch delegate for this type in the specified mode set
155	* this launch configuration type.	155	* @param modes the set of modes to support
		156	* @return the preferred delegate proxy or <code>null</code> if none
		157	* @throws CoreException
156	*	158	*
157	* @return all supported launch mode combinations
158	* @since 3.3	159	* @since 3.3
159	* <p>	160	*
160	* <strong>EXPERIMENTAL</strong>. This method has been added as	161	* EXPERIMENTAL
161	* part of a work in progress. There is no guarantee that this API will
162	* remain unchanged during the 3.3 release cycle. Please do not use this API
163	* without consulting with the Platform/Debug team.
164	* </p>
165	*/	162	*/
166	public Set[] getSupportedModeCombinations();	163	public ILaunchDelegate getPreferredDelegate(Set modes) throws CoreException;
		164
		165	/**
		166	* Allows the preferred launch delegate to be setfor this type with the specifie set of modes
		167	* @param delegate the delegate proxy to set as the default one
		168	* @throws CoreException
		169	*
		170	* @since 3.3
		171	*
		172	* EXPERIMENTAL
		173	*/
		174	public void setPreferredDelegate(Set modes, ILaunchDelegate delegate) throws CoreException;
167		175
168	/**	176	/**
169	* Returns whether this launch configuration supports the specified launch	177	* Returns whether this launch configuration supports the specified launch
Lines 179-185 Link Here
179	* without consulting with the Platform/Debug team.	187	* without consulting with the Platform/Debug team.
180	* </p>	188	* </p>
181	*/	189	*/
182	public boolean supportsModeCombination(Set modes);	190	public boolean supportsModes(Set modes);
183		191
184	/**	192	/**
185	* Returns the unique identifier for this type of launch configuration	193	* Returns the unique identifier for this type of launch configuration
Lines 237-248 Link Here
237	* Returns all of the registered supported modes for this launch configuration type.	245	* Returns all of the registered supported modes for this launch configuration type.
238	* This method does not return null.	246	* This method does not return null.
239	*	247	*
		248	* <p>
		249	* The returned set does not convey any mode combination capability nor does it describe how or what the type can launch, all this method does is return
		250	* a set of strings of all the modes in some way associated with this type
		251	* </p>
		252	*
240	* @return the set of all supported modes	253	* @return the set of all supported modes
241	* @since 3.2	254	* @since 3.2
		255	*
		256	* @deprecated Since 3.3 all modes are provided as sets and not individual strings. The method <code>getSupportedModeCombinations</code>
		257	* should be used instead to retrive the complete listing of supported modes and their allowable combinations.
242	*/	258	*/
243	public Set getSupportedModes();	259	public Set getSupportedModes();
244		260
245	/**	261	/**
		262	* Returns a <code>java.util.Set</code> of <code>java.util.Set</code>s containing all of the supported mode combinations
		263	* for this type
		264	* @return a set of sets of all the supported mode combinations supported by this type
		265	*
		266	* @since 3.3
		267	*
		268	* EXPERIMENTAL
		269	*/
		270	public Set getSupportedModeCombinations();
		271
		272	/**
246	* Returns whether this launch configuration type is public. Public configuration	273	* Returns whether this launch configuration type is public. Public configuration
247	* types are available for use by the user, for example, the user can create new	274	* types are available for use by the user, for example, the user can create new
248	* configurations based on public types through the UI. Private types are not	275	* configurations based on public types through the UI. Private types are not

Lines 1-120 Link Here

(-)schema/launchModes.exsd (-120 / +118 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="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	</complexType>	25	</complexType>
26	</element>	26	</element>
27		27
28	<element name="launchMode">	28	<element name="launchMode">
29	<annotation>	29	<annotation>
30	<appInfo>	30	<appInfo>
31	<meta.element labelAttribute="name"/>	31	<meta.element labelAttribute="name"/>
32	</appInfo>	32	</appInfo>
33	</annotation>	33	</annotation>
34	<complexType>	34	<complexType>
35	<sequence>	35	<attribute name="mode" type="string" use="required">
36	</sequence>	36	<annotation>
37	<attribute name="mode" type="string" use="required">	37	<documentation>
38	<annotation>	38	specifies a unique identifier for this launch mode. The launch modes contributed by the debug plaform are "run", "debug", and "profile".
39	<documentation>	39	</documentation>
40	specifies a unique identifier for this launch mode. The launch modes contributed by the debug plaform are "run", "debug", and "profile".	40	</annotation>
41	</documentation>	41	</attribute>
42	</annotation>	42	<attribute name="label" type="string" use="required">
43	</attribute>	43	<annotation>
44	<attribute name="label" type="string" use="required">	44	<documentation>
45	<annotation>	45	A human-readable label that describes the launch mode
46	<documentation>	46	</documentation>
47	A human-readable label that describes the launch mode	47	<appInfo>
48	</documentation>	48	<meta.attribute translatable="true"/>
49	<appInfo>	49	</appInfo>
50	<meta.attribute translatable="true"/>	50	</annotation>
51	</appInfo>	51	</attribute>
52	</annotation>	52	<attribute name="launchAsLabel" type="string">
53	</attribute>	53	<annotation>
54	<attribute name="launchAsLabel" type="string">	54	<documentation>
55	<annotation>	55	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.
56	<documentation>	56	</documentation>
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.	57	<appInfo>
58	</documentation>	58	<meta.attribute translatable="true"/>
59	<appInfo>	59	</appInfo>
60	<meta.attribute translatable="true"/>	60	</annotation>
61	</appInfo>	61	</attribute>
62	</annotation>	62	</complexType>
63	</attribute>	63	</element>
64	</complexType>	64
65	</element>	65	<annotation>
66		66	<appInfo>
67	<annotation>	67	<meta.section type="since"/>
68	<appInfo>	68	</appInfo>
69	<meta.section type="since"/>	69	<documentation>
70	</appInfo>	70	3.0
71	<documentation>	71	</documentation>
72	3.0	72	</annotation>
73	</documentation>	73
74	</annotation>	74	<annotation>
75		75	<appInfo>
76	<annotation>	76	<meta.section type="examples"/>
77	<appInfo>	77	</appInfo>
78	<meta.section type="examples"/>	78	<documentation>
79	</appInfo>	79	The following is an example of a launch delegate extension point:
80	<documentation>	80
81	The following is an example of a launch delegate extension point:	81	<p>
82		82	<pre>
83	<p>	83	<extension point="org.eclipse.debug.core.launchModes">
84	<pre>	84	<launchMode
85	<extension point="org.eclipse.debug.core.launchModes">	85	mode="profile"
86	<launchMode	86	label="Profile">
87	mode="profile"	87	</launchMode>
88	label="Profile">	88	</extension>
89	</launchMode>	89	</pre>
90	</extension>	90	</p>
91	</pre>	91
92	</p>	92	In the example above, the profile launch mode is contributed.
93		93	</documentation>
94	In the example above, the profile launch mode is contributed.	94	</annotation>
95	</documentation>	95
96	</annotation>	96	<annotation>
97		97	<appInfo>
98	<annotation>	98	<meta.section type="apiInfo"/>
99	<appInfo>	99	</appInfo>
100	<meta.section type="apiInfo"/>	100	<documentation>
101	</appInfo>	101
102	<documentation>	102	</documentation>
103		103	</annotation>
104	</documentation>	104
105	</annotation>	105	<annotation>
106		106	<appInfo>
107	<annotation>	107	<meta.section type="copyright"/>
108	<appInfo>	108	</appInfo>
109	<meta.section type="copyright"/>	109	<documentation>
110	</appInfo>	110	Copyright (c) 2000, 2005 IBM Corporation and others.<br>
111	<documentation>	111	All rights reserved. This program and the accompanying materials are made
112	Copyright (c) 2000, 2005 IBM Corporation and others.<br>	112	available under the terms of the Eclipse Public License v1.0 which
113	All rights reserved. This program and the accompanying materials are made	113	accompanies this distribution, and is available at
114	available under the terms of the Eclipse Public License v1.0 which	114	<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
115	accompanies this distribution, and is available at	115	</documentation>
116	<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>	116	</annotation>
117	</documentation>	117
118	</annotation>	118	</schema>
119
120	</schema>

Lines 1-185 Link Here

(-)schema/launchDelegates.exsd (-185 / +217 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	<attribute name="id" type="string" use="required">	49	<sequence minOccurs="0" maxOccurs="unbounded">
50	<annotation>	50	<element ref="modeCombination" minOccurs="1" maxOccurs="unbounded"/>
51	<documentation>	51	</sequence>
52	specifies a unique identifier for this launch delegate.	52	<attribute name="id" type="string" use="required">
53	</documentation>	53	<annotation>
54	</annotation>	54	<documentation>
55	</attribute>	55	specifies a unique identifier for this launch delegate.
56	<attribute name="name" type="string">	56	</documentation>
57	<annotation>	57	</annotation>
58	<documentation>	58	</attribute>
59	A human readable name for this delegate. This attribute was added in the 3.3. release.	59	<attribute name="name" type="string">
60		60	<annotation>
61	<p>	61	<documentation>
62	<strong>EXPERIMENTAL</strong>. This attribute has been added as	62	A human readable name for this delegate. This attribute was added in the 3.3. release.
63	part of a work in progress. There is no guarantee that this API will	63
64	remain unchanged during the 3.3 release cycle. Please do not use this API	64	<p>
65	without consulting with the Platform/Debug team.	65	<strong>EXPERIMENTAL</strong>. This attribute has been added as
66	</p>	66	part of a work in progress. There is no guarantee that this API will
67	</documentation>	67	remain unchanged during the 3.3 release cycle. Please do not use this API
68	<appInfo>	68	without consulting with the Platform/Debug team.
69	<meta.attribute translatable="true"/>	69	</p>
70	</appInfo>	70	</documentation>
71	</annotation>	71	<appInfo>
72	</attribute>	72	<meta.attribute translatable="true"/>
73	<attribute name="delegate" type="string" use="required">	73	</appInfo>
74	<annotation>	74	</annotation>
75	<documentation>	75	</attribute>
76	specifies the fully qualified name of the Java class that implements <code>ILaunchConfigurationDelegate</code>.	76	<attribute name="delegate" type="string" use="required">
77	Launch configuration instances of this delegate's type will delegate to instances of this class to perform launching.	77	<annotation>
78	</documentation>	78	<documentation>
79	<appInfo>	79	specifies the fully qualified name of the Java class that implements <code>ILaunchConfigurationDelegate</code>.
80	<meta.attribute kind="java" basedOn="org.eclipse.debug.core.model.ILaunchConfigurationDelegate"/>	80	Launch configuration instances of this delegate's type will delegate to instances of this class to perform launching.
81	</appInfo>	81	</documentation>
82	</annotation>	82	<appInfo>
83	</attribute>	83	<meta.attribute kind="java" basedOn="org.eclipse.debug.core.model.ILaunchConfigurationDelegate"/>
84	<attribute name="modes" type="string">	84	</appInfo>
85	<annotation>	85	</annotation>
86	<documentation>	86	</attribute>
87	A comma-separated list of the launch modes this lauch delegate supports.	87	<attribute name="modes" type="string">
88	</documentation>	88	<annotation>
89	</annotation>	89	<documentation>
90	</attribute>	90	A comma-separated list of the launch modes this delegate supports.
91	<attribute name="type" type="string">	91	</documentation>
92	<annotation>	92	</annotation>
93	<documentation>	93	</attribute>
94	identifier of an existing launch configuration type that this launch delegate is capable of launching.	94	<attribute name="type" type="string">
95	</documentation>	95	<annotation>
96	</annotation>	96	<documentation>
97	</attribute>	97	identifier of an existing launch configuration type that this launch delegate is capable of launching.
98	<attribute name="sourcePathComputerId" type="string">	98	</documentation>
99	<annotation>	99	</annotation>
100	<documentation>	100	</attribute>
101	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.	101	<attribute name="sourcePathComputerId" type="string">
102	</documentation>	102	<annotation>
103	</annotation>	103	<documentation>
104	</attribute>	104	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.
105	<attribute name="sourceLocatorId" type="string">	105	</documentation>
106	<annotation>	106	</annotation>
107	<documentation>	107	</attribute>
108	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.	108	<attribute name="sourceLocatorId" type="string">
109	</documentation>	109	<annotation>
110	</annotation>	110	<documentation>
111	</attribute>	111	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.
112	<attribute name="options" type="string">	112	</documentation>
113	<annotation>	113	</annotation>
114	<documentation>	114	</attribute>
115	A comma-separated list of launch modes this launch delegate supports in combination with its supported modes. This attribute was added in the 3.3 release to allow configurations to be launched in a mixed mode.	115	<attribute name="options" type="string">
116		116	<annotation>
117	<p>	117	<documentation>
118	<strong>EXPERIMENTAL</strong>. This attribute has been added as	118	A comma-separated list of launch modes this launch delegate supports in combination with its supported modes. This attribute was added in the 3.3 release to allow configurations to be launched in a mixed mode.
119	part of a work in progress. There is no guarantee that this API will	119
120	remain unchanged during the 3.3 release cycle. Please do not use this API	120	<p>
121	without consulting with the Platform/Debug team.	121	<strong>EXPERIMENTAL</strong>. This attribute has been added as
122	</p>	122	part of a work in progress. There is no guarantee that this API will
123	</documentation>	123	remain unchanged during the 3.3 release cycle. Please do not use this API
124	</annotation>	124	without consulting with the Platform/Debug team.
125	</attribute>	125	</p>
126	</complexType>	126	</documentation>
127	</element>	127	</annotation>
128		128	</attribute>
129	<annotation>	129	</complexType>
130	<appInfo>	130	</element>
131	<meta.section type="since"/>	131
132	</appInfo>	132	<element name="modeCombination">
133	<documentation>	133	<annotation>
134	3.0	134	<documentation>
135	</documentation>	135	This element represents a collection of mode combinations that this delegate can launch. Each entry of a modeCombination is a comma seperated listing of a single combination of modes the delegate supports.
136	</annotation>	136
137		137	For example, a delegate that supports debugging, profiling and code coverage might have a modeCombination of:
138	<annotation>	138
139	<appInfo>	139	[debug, profile, coverage]
140	<meta.section type="examples"/>	140
141	</appInfo>	141	since 3.3
142	<documentation>	142
143	The following is an example of a launch delegate extension point:	143	EXPERIMENTAL
144		144	</documentation>
145	<p>	145	</annotation>
146	<pre>	146	<complexType>
147	<extension point="org.eclipse.debug.core.launchDelegates">	147	<attribute name="modes" type="string" use="required">
148	<launchDelegate	148	<annotation>
149	id="com.example.ExampleProfileDelegate"	149	<documentation>
150	delegate="com.example.ExampleProfileDelegate"	150	the modes attribute represents a comma seperated listing of a combination of modes that the associated delegate can launch
151	type="org.eclipse.jdt.launching.localJavaApplication"	151
152	modes="profile"	152	since 3.3
153	options"run, debug">	153
154	</launchDelegate>	154	EXPERIMENTAL
155	</extension>	155	</documentation>
156	</pre>	156	</annotation>
157	</p>	157	</attribute>
158		158	</complexType>
159	In the example above, the specified launch delegate is contributed to launch Java applications in profile mode. The delegate supports mixed mode launching. The delegate supports profiling when launching in run or debug mode.	159	</element>
160	</documentation>	160
161	</annotation>	161	<annotation>
162		162	<appInfo>
163	<annotation>	163	<meta.section type="since"/>
164	<appInfo>	164	</appInfo>
165	<meta.section type="apiInfo"/>	165	<documentation>
166	</appInfo>	166	3.0
167	<documentation>	167	</documentation>
168	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>.	168	</annotation>
169	</documentation>	169
170	</annotation>	170	<annotation>
171		171	<appInfo>
172	<annotation>	172	<meta.section type="examples"/>
173	<appInfo>	173	</appInfo>
174	<meta.section type="copyright"/>	174	<documentation>
175	</appInfo>	175	The following is an example of a launch delegate extension point:
176	<documentation>	176
177	Copyright (c) 2000, 2005 IBM Corporation and others.<br>	177	<p>
178	All rights reserved. This program and the accompanying materials are made	178	<pre>
179	available under the terms of the Eclipse Public License v1.0 which	179	<extension point="org.eclipse.debug.core.launchDelegates">
180	accompanies this distribution, and is available at	180	<launchDelegate
181	<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>	181	id="com.example.ExampleProfileDelegate"
182	</documentation>	182	delegate="com.example.ExampleProfileDelegate"
183	</annotation>	183	type="org.eclipse.jdt.launching.localJavaApplication">
184		184	</launchDelegate>
185	</schema>	185	<modeCombination modes="run, profile"></modeCombination>
		186	<modeCombination modes="debug, profile, coverage"></modeCombination>
		187	</extension>
		188	</pre>
		189	</p>
		190
		191	In the example above, the specified launch delegate is contributed to launch Java applications in profile mode. The delegate supports mixed mode launching. The delegate supports profiling when launching in run or debug mode, with code coverage in debug mode only.
		192	</documentation>
		193	</annotation>
		194
		195	<annotation>
		196	<appInfo>
		197	<meta.section type="apiInfo"/>
		198	</appInfo>
		199	<documentation>
		200	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>.
		201	</documentation>
		202	</annotation>
		203
		204	<annotation>
		205	<appInfo>
		206	<meta.section type="copyright"/>
		207	</appInfo>
		208	<documentation>
		209	Copyright (c) 2000, 2005 IBM Corporation and others.<br>
		210	All rights reserved. This program and the accompanying materials are made
		211	available under the terms of the Eclipse Public License v1.0 which
		212	accompanies this distribution, and is available at
		213	<a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
		214	</documentation>
		215	</annotation>
		216
		217	</schema>

Lines 11-16 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationTabGroupViewer.java (-34 / +83 lines)
11	package org.eclipse.debug.internal.ui.launchConfigurations;	11	package org.eclipse.debug.internal.ui.launchConfigurations;
12		12
13		13
		14	import java.util.HashSet;
14	import java.util.List;	15	import java.util.List;
15	import java.util.Set;	16	import java.util.Set;
16		17
Lines 23-28 Link Here
23	import org.eclipse.debug.core.ILaunchConfiguration;	24	import org.eclipse.debug.core.ILaunchConfiguration;
24	import org.eclipse.debug.core.ILaunchConfigurationType;	25	import org.eclipse.debug.core.ILaunchConfigurationType;
25	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;	26	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
		27	import org.eclipse.debug.core.ILaunchDelegate;
26	import org.eclipse.debug.internal.ui.DebugUIPlugin;	28	import org.eclipse.debug.internal.ui.DebugUIPlugin;
27	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	29	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
28	import org.eclipse.debug.internal.ui.SWTUtil;	30	import org.eclipse.debug.internal.ui.SWTUtil;
Lines 284-292 Link Here
284		286
285	Composite blComp = SWTUtil.createComposite(mainComp, mainComp.getFont(), 2, 1, GridData.FILL_HORIZONTAL);	287	Composite blComp = SWTUtil.createComposite(mainComp, mainComp.getFont(), 2, 1, GridData.FILL_HORIZONTAL);
286	Composite linkComp = SWTUtil.createComposite(blComp, blComp.getFont(), 1, 1, GridData.FILL_HORIZONTAL);	288	Composite linkComp = SWTUtil.createComposite(blComp, blComp.getFont(), 1, 1, GridData.FILL_HORIZONTAL);
287	// a link for launch options	289
		290	//a link for launch options
288	fOptionsLink = new Link(linkComp, SWT.NONE);	291	fOptionsLink = new Link(linkComp, SWT.NONE);
289	fOptionsLink.setText(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_13);	292
290	fOptionsLink.setFont(linkComp.getFont());	293	fOptionsLink.setFont(linkComp.getFont());
291	gd = new GridData(GridData.BEGINNING);	294	gd = new GridData(GridData.BEGINNING);
292	fOptionsLink.setLayoutData(gd);	295	fOptionsLink.setLayoutData(gd);
Lines 294-316 Link Here
294	public void widgetSelected(SelectionEvent e) {	297	public void widgetSelected(SelectionEvent e) {
295	//collect the options available	298	//collect the options available
296	try {	299	try {
297	SelectLaunchModesDialog sld = new SelectLaunchModesDialog(getShell(),	300	if(!canLaunchWithModes()) {
298	getLaunchConfigurationDialog().getMode(), getWorkingCopy());	301	SelectLaunchModesDialog sld = new SelectLaunchModesDialog(getShell(),
299	if(sld.open() == IDialogConstants.OK_ID) {	302	getLaunchConfigurationDialog().getMode(), getWorkingCopy());
300	//set the options to the config	303	if(sld.open() == IDialogConstants.OK_ID) {
301	Object[] res = sld.getResult();	304	//set the options to the config
302	if(res != null) {	305	Object[] res = sld.getResult();
303	Set modes = (Set) res[0];	306	if(res != null) {
304	modes.remove(getLaunchConfigurationDialog().getMode());	307	Set modes = (Set) res[0];
305	ILaunchConfigurationWorkingCopy wc = getWorkingCopy();	308	modes.remove(getLaunchConfigurationDialog().getMode());
306	wc.setModes(modes);	309	ILaunchConfigurationWorkingCopy wc = getWorkingCopy();
307	refresh();	310	wc.setModes(modes);
308	refreshStatus();	311	refresh();
		312	refreshStatus();
		313	}
309	}	314	}
310	}	315	}
311	} catch (CoreException ex) {	316	else if(hasDuplicateDelegates()) {
312	// TODO:	317	Set modes = new HashSet();
313	}	318	modes.add(getLaunchConfigurationDialog().getMode());
		319	modes.addAll(getWorkingCopy().getModes());
		320	SelectLaunchDelegatesDialog sld = new SelectLaunchDelegatesDialog(getShell(), fTabType.getDelegates(modes));
		321	if(sld.open() == IDialogConstants.OK_ID) {
		322	Object[] res = sld.getResult();
		323	if(res != null) {
		324	fTabType.setPreferredDelegate(modes, (ILaunchDelegate) res[0]);
		325	refresh();
		326	refreshStatus();
		327	}
		328	}
		329	}
		330	} catch (CoreException ex) {}
314	}	331	}
315	public void widgetDefaultSelected(SelectionEvent e) {}	332	public void widgetDefaultSelected(SelectionEvent e) {}
316	});	333	});
Lines 348-364 Link Here
348	}	365	}
349		366
350	/**	367	/**
351	* Shows/hides the options link on the top of the viewer
352	* @param show true if the link should be visible, false otherwise
353	* @since 3.3
354	*
355	* EXPERIMENTAL
356	*/
357	protected void showOptionsLink(boolean show) {
358	fOptionsLink.setVisible(show);
359	}
360
361	/**
362	* Simple method to create a spacer in the page	368	* Simple method to create a spacer in the page
363	*	369	*
364	* @param composite the composite to add the spacer to	370	* @param composite the composite to add the spacer to
Lines 525-531 Link Here
525	if (fInitializingTabs) {	531	if (fInitializingTabs) {
526	return;	532	return;
527	}	533	}
528
529	ILaunchConfigurationTab[] tabs = getTabs();	534	ILaunchConfigurationTab[] tabs = getTabs();
530	if (!fInitializingTabs && tabs != null) {	535	if (!fInitializingTabs && tabs != null) {
531	// update the working copy from the active tab	536	// update the working copy from the active tab
Lines 540-546 Link Here
540	item = fTabFolder.getItem(i);	545	item = fTabFolder.getItem(i);
541	setTabIcon(item, error, tabs[i]);	546	setTabIcon(item, error, tabs[i]);
542	}	547	}
543	fOptionsLink.setVisible(!canLaunchWithOptions());	548	if(!canLaunchWithModes()) {
		549	fOptionsLink.setText(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_13);
		550	}
		551	else if(hasDuplicateDelegates()) {
		552	fOptionsLink.setText(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_15);
		553	}
		554	fOptionsLink.setVisible(!canLaunchWithModes() \|\| hasDuplicateDelegates());
544	}	555	}
545	}	556	}
546		557
Lines 1032-1038 Link Here
1032	* </p>	1043	* </p>
1033	* @return	1044	* @return
1034	*/	1045	*/
1035	public boolean canLaunchWithOptions() {	1046	public boolean canLaunchWithModes() {
1036	if(fInitializingTabs) {	1047	if(fInitializingTabs) {
1037	return false;	1048	return false;
1038	}	1049	}
Lines 1042-1048 Link Here
1042	if(wc != null) {	1053	if(wc != null) {
1043	Set modes = wc.getModes();	1054	Set modes = wc.getModes();
1044	modes.add(getLaunchConfigurationDialog().getMode());	1055	modes.add(getLaunchConfigurationDialog().getMode());
1045	return wc.getType().supportsModeCombination(modes);	1056	return wc.getType().supportsModes(modes);
1046	}	1057	}
1047	} catch (CoreException e) {	1058	} catch (CoreException e) {
1048	}	1059	}
Lines 1050-1055 Link Here
1050	}	1061	}
1051		1062
1052	/**	1063	/**
		1064	* Returns if the type currently showing in the tab group viewer has duplicate launch delegates for the given set of modes.
		1065	*
		1066	* The given set of modes comprises the current mode that the launch dialog was opened in as well as any modes that have been set on the launch
		1067	* configuration.
		1068	* @return the true if there are duplicates, false otherwise
		1069	*
		1070	* @since 3.3
		1071	*
		1072	* EXPERIMENTAL
		1073	*/
		1074	public boolean hasDuplicateDelegates() {
		1075	if(fInitializingTabs) {
		1076	return false;
		1077	}
		1078	try {
		1079	ILaunchConfiguration config = getWorkingCopy();
		1080	if(config != null) {
		1081	Set modes = config.getModes();
		1082	modes.add(getLaunchConfigurationDialog().getMode());
		1083	if(fTabType.getDelegates(modes).length > 1) {
		1084	return fTabType.getPreferredDelegate(modes) == null;
		1085	}
		1086	}
		1087	}
		1088	catch(CoreException ce) {DebugUIPlugin.log(ce);}
		1089	return false;
		1090	}
		1091
		1092	/**
1053	* Returns the current error message or <code>null</code> if none.	1093	* Returns the current error message or <code>null</code> if none.
1054	*/	1094	*/
1055	public String getErrorMesssage() {	1095	public String getErrorMesssage() {
Lines 1076-1082 Link Here
1076	return message;	1116	return message;
1077	}	1117	}
1078		1118
1079	//EXPERIMENTAL
1080	ILaunchConfigurationTab[] allTabs = getTabs();	1119	ILaunchConfigurationTab[] allTabs = getTabs();
1081	for (int i = 0; i < allTabs.length; i++) {	1120	for (int i = 0; i < allTabs.length; i++) {
1082	ILaunchConfigurationTab tab = allTabs[i];	1121	ILaunchConfigurationTab tab = allTabs[i];
Lines 1098-1104 Link Here
1098	return LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_9;	1137	return LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_9;
1099	}	1138	}
1100	}	1139	}
1101	if(!canLaunchWithOptions()) {	1140	//EXPERIMENTAL
		1141	if(!canLaunchWithModes()) {
1102	try {	1142	try {
1103	Set modes = getWorkingCopy().getModes();	1143	Set modes = getWorkingCopy().getModes();
1104	modes.add(getLaunchConfigurationDialog().getMode());	1144	modes.add(getLaunchConfigurationDialog().getMode());
Lines 1108-1113 Link Here
1108	return e.getMessage();	1148	return e.getMessage();
1109	}	1149	}
1110	}	1150	}
		1151	if(hasDuplicateDelegates()) {
		1152	try {
		1153	Set modes = getWorkingCopy().getModes();
		1154	modes.add(getLaunchConfigurationDialog().getMode());
		1155	List names = LaunchConfigurationPresentationManager.getDefault().getLaunchModeNames(modes);
		1156	return MessageFormat.format(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_16, new String[] {names.toString()});
		1157	}
		1158	catch (CoreException e) {DebugUIPlugin.log(e);}
		1159	}
1111	return null;	1160	return null;
1112	}	1161	}
1113		1162

Lines 17-22 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchDelegateNotAvailableHandler.java (-6 / +10 lines)
17	import org.eclipse.debug.core.IStatusHandler;	17	import org.eclipse.debug.core.IStatusHandler;
18	import org.eclipse.debug.internal.ui.DebugUIPlugin;	18	import org.eclipse.debug.internal.ui.DebugUIPlugin;
19	import org.eclipse.debug.ui.DebugUITools;	19	import org.eclipse.debug.ui.DebugUITools;
		20	import org.eclipse.swt.widgets.Shell;
20		21
21	/**	22	/**
22	* This class provides a mechanism to prompt users in the UI thread from debug.core in the case where	23	* This class provides a mechanism to prompt users in the UI thread from debug.core in the case where
Lines 35-46 Link Here
35	if(source instanceof Object[]) {	36	if(source instanceof Object[]) {
36	Object[] infos = (Object[]) source;	37	Object[] infos = (Object[]) source;
37	if(infos.length == 2) {	38	if(infos.length == 2) {
38	ILaunchConfiguration config = (ILaunchConfiguration) infos[0];	39	final ILaunchConfiguration config = (ILaunchConfiguration) infos[0];
39	String mode = (String) infos[1];	40	final String mode = (String) infos[1];
40	DebugUITools.openLaunchConfigurationEditDialog(DebugUIPlugin.getShell(),	41	final Shell shell = DebugUIPlugin.getShell();
41	config,	42	Runnable runnable = new Runnable() {
42	DebugUITools.getLaunchGroup(config, mode).getIdentifier(),	43	public void run() {
43	null);	44	DebugUITools.openLaunchConfigurationDialog(shell, config, DebugUITools.getLaunchGroup(config, mode).getIdentifier(), null);
		45	}
		46	};
		47	DebugUIPlugin.getStandardDisplay().asyncExec(runnable);
44	}	48	}
45	}	49	}
46	return Status.OK_STATUS;	50	return Status.OK_STATUS;

Lines 73-78 Link Here

(-)ui/org/eclipse/debug/internal/ui/IDebugHelpContextIds.java (-1 / +3 lines)
73	public static final String LAUNCHING_PREFERENCE_PAGE = PREFIX + "launching_preference_page_context"; //$NON-NLS-1$	73	public static final String LAUNCHING_PREFERENCE_PAGE = PREFIX + "launching_preference_page_context"; //$NON-NLS-1$
74	public static final String LAUNCH_CONFIGURATION_PREFERENCE_PAGE = PREFIX + "launch_configuration_preference_page_context"; //$NON-NLS-1$	74	public static final String LAUNCH_CONFIGURATION_PREFERENCE_PAGE = PREFIX + "launch_configuration_preference_page_context"; //$NON-NLS-1$
75	public static final String VIEW_MANAGEMENT_PREFERENCE_PAGE = PREFIX + "view_management_preference_page_context"; //$NON-NLS-1$	75	public static final String VIEW_MANAGEMENT_PREFERENCE_PAGE = PREFIX + "view_management_preference_page_context"; //$NON-NLS-1$
		76	public static final String LAUNCH_DELEGATES_PREFERENCE_PAGE = PREFIX + "launch_delegate_preferencef_page_context"; //$NON-NLS-1$
76		77
77	// Dialogs	78	// Dialogs
78	public static final String LAUNCH_CONFIGURATION_DIALOG = PREFIX + "launch_configuration_dialog"; //$NON-NLS-1$	79	public static final String LAUNCH_CONFIGURATION_DIALOG = PREFIX + "launch_configuration_dialog"; //$NON-NLS-1$
Lines 97-103 Link Here
97	public static final String MAX_DETAILS_LENGTH_DIALOG = PREFIX + "max_details_length_dialog_context"; //$NON-NLS-1$	98	public static final String MAX_DETAILS_LENGTH_DIALOG = PREFIX + "max_details_length_dialog_context"; //$NON-NLS-1$
98	public static final String SELECT_DEFAULT_WORKINGSET_DIALOG = PREFIX + "select_breakpoint_workingset_dialog"; //$NON-NLS-1$	99	public static final String SELECT_DEFAULT_WORKINGSET_DIALOG = PREFIX + "select_breakpoint_workingset_dialog"; //$NON-NLS-1$
99	public static final String DELETE_ASSOCIATED_LAUNCH_CONFIGS_DIALOG = PREFIX + "delete_associated_launch_configs_dialog"; //$NON-NLS-1$	100	public static final String DELETE_ASSOCIATED_LAUNCH_CONFIGS_DIALOG = PREFIX + "delete_associated_launch_configs_dialog"; //$NON-NLS-1$
100	public static final String SELECT_LAUNCH_OPTIONS_DIALOG = PREFIX + "select_launch_options_dialog"; //$NON-NLS-1$	101	public static final String SELECT_LAUNCH_MODES_DIALOG = PREFIX + "select_launch_modes_dialog"; //$NON-NLS-1$
		102	public static final String SELECT_LAUNCH_DELEGATES_DIALOG = PREFIX + "select_launch_delegates_dialog"; //$NON-NLS-1$
101		103
102	// Property pages	104	// Property pages
103	public static final String PROCESS_PROPERTY_PAGE = PREFIX + "process_property_page_context"; //$NON-NLS-1$	105	public static final String PROCESS_PROPERTY_PAGE = PREFIX + "process_property_page_context"; //$NON-NLS-1$

Added Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/SelectLaunchDelegatesDialog.java (+143 lines)
1	package org.eclipse.debug.internal.ui.launchConfigurations;
2
3	import java.util.Arrays;
4
5	import org.eclipse.debug.core.ILaunchDelegate;
6	import org.eclipse.debug.internal.ui.DebugUIPlugin;
7	import org.eclipse.debug.internal.ui.IDebugHelpContextIds;
8	import org.eclipse.debug.internal.ui.SWTUtil;
9	import org.eclipse.debug.ui.IDebugUIConstants;
10	import org.eclipse.jface.dialogs.Dialog;
11	import org.eclipse.jface.dialogs.IDialogSettings;
12	import org.eclipse.jface.viewers.ArrayContentProvider;
13	import org.eclipse.jface.viewers.CheckStateChangedEvent;
14	import org.eclipse.jface.viewers.CheckboxTableViewer;
15	import org.eclipse.jface.viewers.ICheckStateListener;
16	import org.eclipse.jface.viewers.ILabelProvider;
17	import org.eclipse.jface.viewers.ILabelProviderListener;
18	import org.eclipse.swt.SWT;
19	import org.eclipse.swt.graphics.Image;
20	import org.eclipse.swt.graphics.Point;
21	import org.eclipse.swt.layout.GridData;
22	import org.eclipse.swt.widgets.Composite;
23	import org.eclipse.swt.widgets.Control;
24	import org.eclipse.swt.widgets.Shell;
25	import org.eclipse.swt.widgets.Table;
26	import org.eclipse.ui.PlatformUI;
27	import org.eclipse.ui.dialogs.SelectionDialog;
28
29	import com.ibm.icu.text.MessageFormat;
30
31	public class SelectLaunchDelegatesDialog extends SelectionDialog {
32
33	/**
34	* Builds labels for list control
35	*/
36	class DelegatesLabelProvider implements ILabelProvider {
37	public Image getImage(Object element) {return null;}
38	public String getText(Object element) {
39	if(element instanceof ILaunchDelegate) {
40	ILaunchDelegate ldp = (ILaunchDelegate) element;
41	String name = ldp.getName();
42	if(name == null) {
43	name = ldp.getContributorName();
44	}
45	return name;
46	}
47	return element.toString();
48	}
49	public void addListener(ILabelProviderListener listener) {}
50	public void dispose() {}
51	public boolean isLabelProperty(Object element, String property) {return false;}
52	public void removeListener(ILabelProviderListener listener) {}
53	}
54
55	private static final String SETTINGS_ID = IDebugUIConstants.PLUGIN_ID + ".SELECT_LAUNCH_DELEGATES_DIALOG"; //$NON-NLS-1$
56
57	private CheckboxTableViewer fTableViewer = null;
58	private Table fTable = null;
59	private ILaunchDelegate[] fDelegates = null;
60
61	/**
62	* Constructor
63	* @param parentShell the parent shell
64	* @param delegates the current delegates context
65	*
66	* @throws CoreException
67	*/
68	public SelectLaunchDelegatesDialog(Shell parentShell, ILaunchDelegate[] delegates) {
69	super(parentShell);
70	super.setMessage(MessageFormat.format(LaunchConfigurationsMessages.SelectLaunchDelegatesDialog_0, new String[] {}));
71	super.setTitle(LaunchConfigurationsMessages.SelectLaunchDelegatesDialog_1);
72	setShellStyle(getShellStyle() \| SWT.RESIZE);
73	fDelegates = delegates;
74	}
75
76	/**
77	* @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
78	*/
79	protected Control createDialogArea(Composite parent) {
80	initializeDialogUnits(parent);
81	Composite comp = (Composite) super.createDialogArea(parent);
82	SWTUtil.createLabel(comp, LaunchConfigurationsMessages.SelectLaunchDelegatesDialog_2, 1);
83	fTable = new Table(comp, SWT.BORDER \| SWT.SINGLE \| SWT.CHECK);
84	fTable.setLayoutData(new GridData(GridData.FILL_BOTH));
85	fTableViewer = new CheckboxTableViewer(fTable);
86	fTableViewer.setLabelProvider(new DelegatesLabelProvider());
87	fTableViewer.setContentProvider(new ArrayContentProvider());
88	fTableViewer.setInput(fDelegates);
89	fTableViewer.addCheckStateListener(new ICheckStateListener() {
90	public void checkStateChanged(CheckStateChangedEvent event) {
91	fTableViewer.setAllChecked(false);
92	fTableViewer.setChecked(event.getElement(), true);
93	}
94	});
95	Dialog.applyDialogFont(comp);
96	PlatformUI.getWorkbench().getHelpSystem().setHelp(comp, IDebugHelpContextIds.SELECT_LAUNCH_DELEGATES_DIALOG);
97	return comp;
98	}
99
100	/**
101	* @see org.eclipse.jface.dialogs.Dialog#okPressed()
102	*/
103	protected void okPressed() {
104	Object[] o = fTableViewer.getCheckedElements();
105	if(o.length > 0) {
106	setResult(Arrays.asList(o));
107	}
108	super.okPressed();
109	}
110
111	/* (non-Javadoc)
112	* @see org.eclipse.ui.dialogs.SelectionDialog#getDialogBoundsSettings()
113	*/
114	protected IDialogSettings getDialogBoundsSettings() {
115	IDialogSettings settings = DebugUIPlugin.getDefault().getDialogSettings();
116	IDialogSettings section = settings.getSection(SETTINGS_ID);
117	if (section == null) {
118	section = settings.addNewSection(SETTINGS_ID);
119	}
120	return section;
121	}
122
123	/* (non-Javadoc)
124	* @see org.eclipse.jface.dialogs.Dialog#getInitialSize()
125	*/
126	protected Point getInitialSize() {
127	IDialogSettings settings = getDialogBoundsSettings();
128	if(settings != null) {
129	try {
130	int width = settings.getInt("DIALOG_WIDTH"); //$NON-NLS-1$
131	int height = settings.getInt("DIALOG_HEIGHT"); //$NON-NLS-1$
132	if(width > 0 & height > 0) {
133	return new Point(width, height);
134	}
135	}
136	catch (NumberFormatException nfe) {
137	return new Point(350, 400);
138	}
139	}
140	return new Point(350, 400);
141	}
142
143	}