Attachment #54584 for bug #157059

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




      </page>
      <page
            category="org.eclipse.debug.ui.LaunchingPreferencePage"
            class="org.eclipse.debug.internal.ui.preferences.LaunchersPreferencePage"
            id="org.eclipse.debug.ui.LaunchDelegatesPreferencePage"
            name="%LaunchDelegatesPreferencePage.name">
         <keywordReference

            </or>
         </enabledWhen>
      </page>
      <page
            class="org.eclipse.debug.internal.ui.launchConfigurations.PreferredLaunchersPropertyPage"
            id="org.eclipse.debug.ui.launchConfigurationPropertyPage"
            name="%preferredLaunchersPropertyPage.name">
         <enabledWhen>
            <and>
               <instanceof
                     value="org.eclipse.debug.core.ILaunchConfiguration">
               </instanceof>
            </and>
         </enabledWhen>
      </page>
   </extension>
<!-- commands and their bindings
NOTE: 

Lines 27-32 Link Here

(-)plugin.properties (+2 lines)
27	BreakpointOrganizersName=Breakpoint Organizers	27	BreakpointOrganizersName=Breakpoint Organizers
28	VariableValueEditorsName=Variable Value Editors	28	VariableValueEditorsName=Variable Value Editors
29		29
		30	preferredLaunchersPropertyPage.name=Preferred Launchers
		31
30	BreakpointActionSet.label=Breakpoints	32	BreakpointActionSet.label=Breakpoints
31	CollapseAll.label=Collapse All	33	CollapseAll.label=Collapse All
32	CollapseAll.tooltip= Collapse All	34	CollapseAll.tooltip= Collapse All




import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CLabel;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;

		}
	}		
	
	/**
	 * Creates a check box button using the parents' font
	 * @param parent the parent to add the button to
	 * @param label the label for the button
	 * @param image the image for the button 
	 * @param checked the initial checked state of the button
	 * @return a new checked button set to the initial checked state
	 * @since 3.3
	 */
	public static Button createCheckButton(Composite parent, String label, Image image, boolean checked) {
		Button button = new Button(parent, SWT.CHECK);
		button.setFont(parent.getFont());
		button.setSelection(checked);
		if(image != null) {
			button.setImage(image);
		}
		if(label != null) {
			button.setText(label);
		}
		GridData gd = new GridData();
		button.setLayoutData(gd);
		setButtonDimensionHint(button);
		return button;
	}
	
	/**
	 * Creates and returns a new push button with the given

	}
	
	/**
	 * Creates a new <code>CLabel</code> that will wrap at the specified width and has the specified image
	 * @param parent the parent to add this label to
	 * @param text the text for the label
	 * @param image the image for the label
	 * @param hspan the h span to take up in the parent
	 * @param wrapwidth the with to wrap at
	 * @return a new <code>CLabel</code>
	 * @since 3.3
	 */
	public static CLabel createWrapCLabel(Composite parent, String text, Image image, int hspan, int wrapwidth) {
		CLabel label = new CLabel(parent, SWT.NONE | SWT.WRAP);
		label.setFont(parent.getFont());
		if(text != null) {
			label.setText(text);
		}
		if(image != null) {
			label.setImage(image);
		}
		GridData gd = new GridData(GridData.FILL_HORIZONTAL);
		gd.horizontalSpan = hspan;
		gd.widthHint = wrapwidth;
		label.setLayoutData(gd);
		return label;
	}
	
	/**
	 * Creates a wrapping label
	 * @param parent the parent composite to add this label to
	 * @param text the text to be displayed in the label

Lines 111-116 Link Here

(-)ui/org/eclipse/debug/internal/ui/IDebugHelpContextIds.java (+1 lines)
111	public static final String LAUNCH_CONFIGURATION_DIALOG_PERSPECTIVE_TAB = PREFIX + "launch_configuration_dialog_perspective_tab"; //$NON-NLS-1$	111	public static final String LAUNCH_CONFIGURATION_DIALOG_PERSPECTIVE_TAB = PREFIX + "launch_configuration_dialog_perspective_tab"; //$NON-NLS-1$
112	public static final String LAUNCH_CONFIGURATION_DIALOG_REFRESH_TAB = PREFIX + "launch_configuration_dialog refresh_tab"; //$NON-NLS-1$	112	public static final String LAUNCH_CONFIGURATION_DIALOG_REFRESH_TAB = PREFIX + "launch_configuration_dialog refresh_tab"; //$NON-NLS-1$
113	public static final String LAUNCH_CONFIGURATION_DIALOG_ENVIRONMENT_TAB = PREFIX + "launch_configuration_dialog_environment_tab"; //$NON-NLS-1$	113	public static final String LAUNCH_CONFIGURATION_DIALOG_ENVIRONMENT_TAB = PREFIX + "launch_configuration_dialog_environment_tab"; //$NON-NLS-1$
		114	public static final String LAUNCH_CONFIGURATION_DIALOG_LAUNCHERS_TAB = PREFIX + "launch_configuration_dialog_launchers_tab"; //$NON-NLS-1$
114		115
115	// Working set page	116	// Working set page
116	public static final String WORKING_SET_PAGE = PREFIX + "working_set_page_context"; //$NON-NLS-1$	117	public static final String WORKING_SET_PAGE = PREFIX + "working_set_page_context"; //$NON-NLS-1$




    public static final String PREF_LAUNCH_PERSPECTIVES = IDebugUIConstants.PLUGIN_ID + ".PREF_LAUNCH_PERSPECTIVES"; //$NON-NLS-1$
    
    /**
     * Represents the empty string
     * @since 3.3
     */
    public static final String EMPTY_STRING = ""; //$NON-NLS-1$
    
    /**
     * Preference for enabling/disabling launch configuration filtering based on project accessibilty status
     * 
     * @since 3.2

	 * @since 3.1
	 */
	public static final String PREF_MAX_DETAIL_LENGTH = IDebugUIConstants.PLUGIN_ID + ".max_detail_length"; //$NON-NLS-1$

	/**
	 * Constant to describe the 'list' action for duplicate launch delegate resolution
	 * @since 3.3
	 * EXPERIMENTAL
	 */
	public static final String DELEGATE_ACTION_ID_LIST = "list"; //$NON-NLS-1$
	
	/**
	 * Constant to describe the 'dialog' action for duplicate delegate resolution 
	 * @since 3.3
	 * EXPERIMENTAL
	 */
	public static final String DELEGATE_ACTION_ID_DIALOG = "dialog"; //$NON-NLS-1$
	
	/**
	 * Font for Memory View
	 * 

Lines 34-39 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationsMessages.properties (-3 / +11 lines)
34	CommonTab_8=No file specified for process output	34	CommonTab_8=No file specified for process output
35	CommonTab_9=Variable&s...	35	CommonTab_9=Variable&s...
36		36
		37	LaunchersTab_0=The settings on this tab all you to specify which launcher to use when multiple launchers are available for a configuration and launch mode.
		38	LaunchersTab_1=Enable configuration specific settings
		39	LaunchersTab_2=Launchers
		40	LaunchersTab_3=<a>Change Workspace Settings...</a>
		41	LaunchersTab_4=You must select a preferred launcher for
		42	LaunchersTab_6=You must select a workspace default or configuration specific preferred launcher
		43
37	CompileErrorPromptStatusHandler_0=Errors in Project{0}	44	CompileErrorPromptStatusHandler_0=Errors in Project{0}
38	CompileErrorPromptStatusHandler_1=Errors exist in a required project. Continue launch?	45	CompileErrorPromptStatusHandler_1=Errors exist in a required project. Continue launch?
39	CompileErrorPromptStatusHandler_2=Errors exist in required project{0}: {1}.\nProceed with launch?	46	CompileErrorPromptStatusHandler_2=Errors exist in required project{0}: {1}.\nProceed with launch?
Lines 56-63 Link Here
56	LaunchConfigurationTabGroupViewer_9=The file associated with this launch configuration is read-only and cannot be modified.\n	63	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>.	64	LaunchConfigurationTabGroupViewer_13=Select a supported <a>launch mode</a>.
58	LaunchConfigurationTabGroupViewer_14=Mixed launch mode not supported: {0}	65	LaunchConfigurationTabGroupViewer_14=Mixed launch mode not supported: {0}
59	LaunchConfigurationTabGroupViewer_15=Select preferred <a>launch tooling</a> for this type of configuration.	66	LaunchConfigurationTabGroupViewer_15=More than one launcher available - <a>Select other...</a>
60	LaunchConfigurationTabGroupViewer_16=There is duplicate launch tooling for the mixed mode: {0}	67	LaunchConfigurationTabGroupViewer_16=Using {0} - <a>Select other...</a>
		68	LaunchConfigurationTabGroupViewer_17=Multiple launchers exist - <a>Choose one...</a>
61		69
62	LaunchConfigurationDialog_Create__manage__and_run_launch_configurations_8=Create, manage, and run configurations	70	LaunchConfigurationDialog_Create__manage__and_run_launch_configurations_8=Create, manage, and run configurations
63	LaunchConfigurationDialog_Dele_te_14=De&lete	71	LaunchConfigurationDialog_Dele_te_14=De&lete
Lines 70-76 Link Here
70	LaunchConfigurationDialog_Launch_Configuration_Error_46=Launch Configuration Error	78	LaunchConfigurationDialog_Launch_Configuration_Error_46=Launch Configuration Error
71	LaunchConfigurationDialog_Launch_Configurations_18=Launch Configurations	79	LaunchConfigurationDialog_Launch_Configurations_18=Launch Configurations
72	LaunchConfigurationDialog_Name_required_for_launch_configuration_11=Name required for launch configuration	80	LaunchConfigurationDialog_Name_required_for_launch_configuration_11=Name required for launch configuration
73	LaunchConfigurationDialog_Ne_w_13=Ne&w	81	LaunchConfigurationDialog_Ne_w_13=Ne&w\t\t
74	LaunchConfigurationDialog_No_33=No	82	LaunchConfigurationDialog_No_33=No
75	LaunchConfigurationEditDialog_0=Modify configuration and continue.	83	LaunchConfigurationEditDialog_0=Modify configuration and continue.
76	LaunchConfigurationEditDialog_1=Con&tinue	84	LaunchConfigurationEditDialog_1=Con&tinue

Lines 1-6 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationTabGroupWrapper.java (-32 / +38 lines)
1	package org.eclipse.debug.internal.ui.launchConfigurations;	1	package org.eclipse.debug.internal.ui.launchConfigurations;
2		2
3	import java.util.ArrayList;	3	import java.util.ArrayList;
		4	import java.util.Arrays;
4	import java.util.List;	5	import java.util.List;
5		6
6	import org.eclipse.core.runtime.CoreException;	7	import org.eclipse.core.runtime.CoreException;
Lines 30-35 Link Here
30		31
31	private ILaunchConfigurationTabGroup fGroup = null;	32	private ILaunchConfigurationTabGroup fGroup = null;
32	private String fGroupId = null;	33	private String fGroupId = null;
		34	/**
		35	* listing of tab extensions that we have to create
		36	*/
33	private List fTabs = null;	37	private List fTabs = null;
34	private String fMode = null;	38	private String fMode = null;
35	private ILaunchConfiguration fConfig = null;	39	private ILaunchConfiguration fConfig = null;
Lines 38-43 Link Here
38	* Constructor	42	* Constructor
39	* @param group the existing group to wrapper	43	* @param group the existing group to wrapper
40	* @param groupId the string id of the associated tab group	44	* @param groupId the string id of the associated tab group
		45	* @param config the launch configuration this tab group is opened on
41	*/	46	*/
42	public LaunchConfigurationTabGroupWrapper(ILaunchConfigurationTabGroup group, String groupId, ILaunchConfiguration config) {	47	public LaunchConfigurationTabGroupWrapper(ILaunchConfigurationTabGroup group, String groupId, ILaunchConfiguration config) {
43	fGroup = group;	48	fGroup = group;
Lines 60-68 Link Here
60	*/	65	*/
61	public void dispose() {	66	public void dispose() {
62	if(fTabs != null) {	67	if(fTabs != null) {
63	ILaunchConfigurationTab[] tabs = getTabs();	68	for(int i = 0; i < fTabs.size(); i++) {
64	for(int i = 0; i < tabs.length; i++) {	69	((ILaunchConfigurationTab)fTabs.get(i)).dispose();
65	tabs[i].dispose();
66	}	70	}
67	fTabs = null;	71	fTabs = null;
68	}	72	}
Lines 75-115 Link Here
75	if(fTabs == null) {	79	if(fTabs == null) {
76	try {	80	try {
77	fTabs = new ArrayList();	81	fTabs = new ArrayList();
78	ILaunchConfigurationTab[] tmp = fGroup.getTabs();	82	//add the tab groups' tabs first (defaults)
79	for(int i = 0; i < tmp.length; i++) {	83	fTabs.addAll(Arrays.asList(fGroup.getTabs()));
80	fTabs.add(tmp[i]);	84	//last, add the extensions (if any)
81	}
82	LaunchConfigurationTabExtension[] ext = LaunchConfigurationPresentationManager.getDefault().getTabExtensions(fGroupId, fConfig, fMode);	85	LaunchConfigurationTabExtension[] ext = LaunchConfigurationPresentationManager.getDefault().getTabExtensions(fGroupId, fConfig, fMode);
83	//copy contributed into correct position or end if no id or id is not found	86	//copy contributed into correct position or end if no id or id is not found
84	AbstractLaunchConfigurationTab alct = null;
85	String id = null;	87	String id = null;
86	List item = null;
87	for(int i = 0; i < ext.length; i++) {	88	for(int i = 0; i < ext.length; i++) {
88	id = ext[i].getRelativeTabId();	89	id = ext[i].getRelativeTabId();
89	if(id != null) {	90	if(id != null) {
90	//position specified, try to find it	91	int idx = indexofTab(id);
91	boolean found = false;	92	if(idx > -1) {
92	for(int j = 0; j < tmp.length; j++) {	93	fTabs.add(idx+1, ext[i].getTab());
93	if(tmp[j] instanceof AbstractLaunchConfigurationTab) {
94	alct = (AbstractLaunchConfigurationTab) tmp[j];
95	if(id.equals(alct.getId())) {
96	if(j != tmp.length-1) {
97	item = new ArrayList();
98	item.add(ext[i].getTab());
99	fTabs.addAll(j+1, item);
100	found = true;
101	break;
102	}
103	}
104	}
105	}	94	}
106	if(!found) {	95	else {
107	//id did not match any tabs, add it to the end
108	fTabs.add(ext[i].getTab());	96	fTabs.add(ext[i].getTab());
109	}	97	}
110	}	98	}
111	else {	99	else {
112	//no position specified, add it to the end
113	fTabs.add(ext[i].getTab());	100	fTabs.add(ext[i].getTab());
114	}	101	}
115	}	102	}
Lines 120-133 Link Here
120	}	107	}
121		108
122	/**	109	/**
		110	* Returns the index of the tab matching the specified id
		111	* @param id the id of the tab to find the index for
		112	* @return the index of the tab specified by the id or -1 if not found
		113	*/
		114	private int indexofTab(String id) {
		115	if(id != null) {
		116	Object o = null;
		117	for(int i = 0; i < fTabs.size(); i++) {
		118	o = fTabs.get(i);
		119	if(o instanceof AbstractLaunchConfigurationTab) {
		120	if(id.equals(((AbstractLaunchConfigurationTab)o).getId())) {
		121	return i;
		122	}
		123	}
		124	}
		125	}
		126	return -1;
		127	}
		128
		129	/**
123	* @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#initializeFrom(org.eclipse.debug.core.ILaunchConfiguration)	130	* @see org.eclipse.debug.ui.ILaunchConfigurationTabGroup#initializeFrom(org.eclipse.debug.core.ILaunchConfiguration)
124	*/	131	*/
125	public void initializeFrom(ILaunchConfiguration configuration) {	132	public void initializeFrom(ILaunchConfiguration configuration) {
126	if(fTabs == null) {	133	if(fTabs != null) {
127	getTabs();	134	for(int i = 0; i < fTabs.size(); i++) {
128	}	135	((ILaunchConfigurationTab)fTabs.get(i)).initializeFrom(configuration);
129	for(int i = 0; i < fTabs.size(); i++) {	136	}
130	((ILaunchConfigurationTab)fTabs.get(i)).initializeFrom(configuration);
131	}	137	}
132	}	138	}
133		139




import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.custom.CLabel;
import org.eclipse.swt.custom.CTabFolder;
import org.eclipse.swt.custom.CTabItem;
import org.eclipse.swt.custom.StackLayout;

import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.IWorkbenchPreferenceConstants;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.activities.WorkbenchActivityHelper;

import com.ibm.icu.text.MessageFormat;


								modes.remove(getLaunchConfigurationDialog().getMode());
								ILaunchConfigurationWorkingCopy wc = getWorkingCopy();
								wc.setModes(modes);
								refresh();
								refreshStatus();
							}
						}
					}
					else if(hasMultipleDelegates()) {
						((LaunchConfigurationsDialog)getLaunchConfigurationDialog()).getPropertiesAction().run();
						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]);
								disposeExistingTabs();
								displayInstanceTabs();
							}
						}
					}
				} catch (CoreException ex) {}
			}

	}
	
	/**
	 * Simple method to create a spacer in the page
	 * 
	 * @param composite the composite to add the spacer to
	 * @param columnSpan the amount of space for the spacer
	 * @since 3.2
	 */
	protected void createSpacer(Composite composite, int columnSpan) {
		Label label = new Label(composite, SWT.NONE);
		GridData gd = new GridData();
		gd.horizontalSpan = columnSpan;
		label.setLayoutData(gd);
	}
	
	/**
	 * Creates some help text for the tab group launch types
	 * @param parent thep arent composite
	 * @since 3.2

	private void createGettingStarted(Composite parent) {
		Font font = parent.getFont();
		GridData gd = null;
		int width = parent.getBounds().width - 30;
		SWTUtil.createWrapLabel(parent, LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_1, 1, width);
		SWTUtil.createWrapCLabel(parent, LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_2, DebugUITools.getImage(IInternalDebugUIConstants.IMG_ELCL_NEW_CONFIG), 1, width);
		SWTUtil.createWrapCLabel(parent, LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_6, DebugUITools.getImage(IInternalDebugUIConstants.IMG_ELCL_DUPLICATE_CONFIG), 1, width);
		SWTUtil.createWrapCLabel(parent, LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_4, DebugUITools.getImage(IInternalDebugUIConstants.IMG_ELCL_DELETE_CONFIG), 1, width);
        SWTUtil.createWrapCLabel(parent, LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_8, DebugUITools.getImage(IInternalDebugUIConstants.IMG_ELCL_FILTER_CONFIGS), 1, width);
        SWTUtil.createWrapCLabel(parent, LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_3, DebugUITools.getImage(IInternalDebugUIConstants.IMG_OVR_TRANSPARENT), 1, width);
        createWrapLabel(parent, DebugUITools.getImage(IInternalDebugUIConstants.IMG_ELCL_FILTER_CONFIGS),
        		LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_8);
        createWrapLabel(parent, DebugUITools.getImage(IInternalDebugUIConstants.IMG_OVR_TRANSPARENT), 
        		LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_3);
        
		SWTUtil.createHorizontalSpacer(parent, 2);
		Link link = new Link(parent, SWT.LEFT | SWT.WRAP);
		link.setText(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_5);
		link.setFont(font);
		gd = new GridData(GridData.FILL_HORIZONTAL);
		gd.widthHint = width;
		link.setLayoutData(gd);
		link.addSelectionListener(new SelectionListener() {
			public void widgetSelected(SelectionEvent e) {

			public void widgetDefaultSelected(SelectionEvent e) {}
		});
	}

    /**
     * Create a label on the given parent that wraps text.
     * 
     * @param parent
     * @param text
     */
    private void createWrapLabel(Composite parent, Image image, String text) {
    	CLabel lbl = new CLabel(parent, SWT.NONE | SWT.WRAP);
    	lbl.setImage(image);
        lbl.setFont(parent.getFont());
        lbl.setText(text);
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        gd.widthHint = parent.getBounds().width - 30;
        lbl.setLayoutData(gd);
    }
	
	/**
	 * Creates the tab folder for displaying config instances

	 * @see org.eclipse.jface.viewers.ISelectionProvider#getSelection()
	 */
	public ISelection getSelection() {
		return new StructuredSelection(fWorkingCopy);
			return new StructuredSelection();
		} 
		return new StructuredSelection(getActiveTab());
	}

	/**

			// update error ticks
			CTabItem item = null;
			boolean error = false;
			Image image = null;
			for (int i = 0; i < tabs.length; i++) {
				error = tabs[i].getErrorMessage() != null && !tabs[i].isValid(getWorkingCopy());
				image = tabs[i].getImage();
				item = fTabFolder.getItem(i);
				if(error) {
					item.setImage(DebugUIPlugin.getDefault().getLaunchConfigurationManager().getErrorTabImage(tabs[i]));
				}
				else {
					item.setImage(image);
				}
			}
			showLink();
		}
	}

	/**
	 * Shows the link for either multiple launch delegates or bad launch mode combinations
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	private void showLink() {
		String text = null;
		if(!canLaunchWithModes()) {
			text = LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_13;
		}
		else if(hasMultipleDelegates()) {
			ILaunchDelegate delegate = getPreferredDelegate();
			if(delegate != null) {
				String name = delegate.getName();
				if(name == null) {
					text = LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_15;
				}
				else {
					text = MessageFormat.format(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_16, new String[] {name});
				}
			}
			else {
				text = LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_17;
			}
			fOptionsLink.setVisible(!canLaunchWithModes() || hasDuplicateDelegates());
			fOptionsLink.getParent().layout();
		}
		if(text != null) {
			fOptionsLink.setText(text);
		}
		fOptionsLink.setVisible(!canLaunchWithModes() || hasMultipleDelegates());
		fOptionsLink.getParent().layout();
	}
	
	/**
	 * Returns the preferred launch delegate for the current launch configuration and mode set
	 * @return the preferred launch delegate
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	protected ILaunchDelegate getPreferredDelegate() {
		ILaunchDelegate preferred = null;
		ILaunchConfigurationWorkingCopy config = getWorkingCopy();
		if(config != null) {
			try {
				Set modes = getCurrentModeSet();
				preferred = config.getPreferredDelegate(modes);
				if(preferred == null) {
					preferred = config.getType().getPreferredDelegate(modes);
				}
			}
			catch(CoreException ce) {DebugUIPlugin.log(ce);}
		}
		return preferred;
	}
	
	/**
	 * Returns the listing of modes for the current config
	 * @return the listing of modes for the current config
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 */
	private Set getCurrentModeSet() {
		Set set = new HashSet();
		ILaunchConfigurationWorkingCopy config = getWorkingCopy();
		if(config != null) {
			try {
				set.addAll(config.getModes());
				set.add(getLaunchConfigurationDialog().getMode());
			}
			catch(CoreException ce) {DebugUIPlugin.log(ce);}
		}
		return set;
	}
	
	/**
	 * updates the button states
	 */

		fApplyButton.setEnabled(dirty && canSave());
		fRevertButton.setEnabled(dirty);
	}
	
	/**
	 * Set the specified tab item's icon to an error icon if <code>error</code> is true,
	 * or a transparent icon of the same size otherwise.
	 */
	private void setTabIcon(CTabItem tabItem, boolean error, ILaunchConfigurationTab tab) {
		Image image = null;
		if (error) {
			image = DebugUIPlugin.getDefault().getLaunchConfigurationManager().getErrorTabImage(tab);
		} else {
			image = tab.getImage();
		}
		tabItem.setImage(image);
	}	

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.Viewer#setInput(java.lang.Object)

     */
    protected void setFocusOnName() {
        fNameWidget.setFocus();
        
    }
    
	/**

	 * launch configuration type.
	 */
	private void showInstanceTabsFor(ILaunchConfigurationType configType) {

		// Don't do any work if the current tabs are for the current config type
		if (fTabType != null && fTabType.equals(configType)) { 
			return;
		}
		
		// try to keep on same tab
		Class tabKind = null;
		if (getActiveTab() != null) {
			tabKind = getActiveTab().getClass();
		}
		
		// Build the new tabs
		ILaunchConfigurationTabGroup group = null;
		try {
			group = createGroup();
		} catch (CoreException ce) {
			DebugUIPlugin.errorDialog(getShell(), LaunchConfigurationsMessages.LaunchConfigurationDialog_Error_19, LaunchConfigurationsMessages.LaunchConfigurationDialog_Exception_occurred_creating_launch_configuration_tabs_27,ce); // 
			return;
		}
		disposeExistingTabs();
		showTabsFor(group);
		fTabGroup = group;
		fTabType = configType;
		
		// select same tab as before, if possible
		ILaunchConfigurationTab[] tabs = getTabs();
		CTabItem tab = null;
		String name = EMPTY_STRING;
		Control control = null;
		for (int i = 0; i < tabs.length; i++) {
			tab = new CTabItem(fTabFolder, SWT.BORDER);
			name = tabs[i].getName();
			if (name == null) {
				name = LaunchConfigurationsMessages.LaunchConfigurationDialog_unspecified_28; 
			}
			tab.setText(name);
			tab.setImage(tabs[i].getImage());
			tabs[i].createControl(tab.getParent());
			control = tabs[i].getControl();
			if (control != null) {
				tab.setControl(control);
			}
		}
		//set the default tab as the first one
		setActiveTab(tabs[0]);
		// select same tab as before, if possible
		for (int i = 0; i < tabs.length; i++) {
			if (tabs[i].getClass().equals(tabKind)) {
				setActiveTab(tabs[i]);
				setActiveTab(tab);
				break;
			}
		}

			String mode = fDialog.getMode();
			description = LaunchConfigurationPresentationManager.getDefault().getDescription(configType, mode);
		}	
		if (description == null) {
			description = EMPTY_STRING;
		}
		return description;
	}
	
	/**
	 * Create the tabs in the configuration edit area for the given tab group.
	 */
	private void showTabsFor(ILaunchConfigurationTabGroup tabGroup) {
		// Dispose the current tabs
		disposeExistingTabs();

		fTabGroup = tabGroup;

		// Create the Control for each tab
		ILaunchConfigurationTab[] tabs = tabGroup.getTabs();
		CTabItem tab = null;
		String name = EMPTY_STRING;
		Control control = null;
		for (int i = 0; i < tabs.length; i++) {
			tab = new CTabItem(fTabFolder, SWT.BORDER);
			name = tabs[i].getName();
			if (name == null) {
				name = LaunchConfigurationsMessages.LaunchConfigurationDialog_unspecified_28; 
			}
			tab.setText(name);
			tab.setImage(tabs[i].getImage());
			tabs[i].createControl(tab.getParent());
			control = tabs[i].getControl();
			if (control != null) {
				tab.setControl(control);
			}
		}

	}	
	
	/**
	 * Returns tab group for the given type of launch configuration.
	 * Tabs are initialized to be contained in this dialog.
	 *
	 * @exception CoreException if unable to instantiate a tab group
	 */
	protected ILaunchConfigurationTabGroup createGroup() throws CoreException {
		// Use a final Object array to store the tab group and any exception that
		// results from the Runnable
		final Object[] finalArray = new Object[2];

				if (object instanceof ILaunchConfigurationTab) {
					ILaunchConfigurationTab[] tabs = getTabs();
					for (int i = 0; i < tabs.length; i++) {
						if (tabs[i].equals(object)) {
						if (tab.equals(object)) {
							fCurrentTabIndex = i;
							fTabFolder.setSelection(i);
						}

				return false;
			}
		}
		
		return true;
	}	
	

		try {
			ILaunchConfigurationWorkingCopy wc = getWorkingCopy();
			if(wc != null) {
				return wc.getType().supportsModeCombination(getCurrentModeSet());
				modes.add(getLaunchConfigurationDialog().getMode());
				return wc.getType().supportsModeCombination(modes);
			}
		}  catch (CoreException e) {
		}

		if(fInitializingTabs) {
			return false;
		}
		ILaunchConfiguration config = getWorkingCopy();
		if(config != null) {
			if(hasMultipleDelegates()) {
				return getPreferredDelegate() == null;
			}
		}
		return false;
	}
	
	/**
	 * Determines if the currently showing launch configuration has multiple launch delegates for the same mode set, but does not care
	 * if there has been a default selected yet or not
	 * @return true if the current launch configuraiton has multiple launch delegates, false otherwise
	 */
	private boolean hasMultipleDelegates() {
		ILaunchConfiguration config = getWorkingCopy();
		if(config != null) {
			try {
				Set modes = getCurrentModeSet();
				ILaunchDelegate[] delegates = LaunchConfigurationManager.filterLaunchDelegates(fTabType, modes);
				return delegates.length > 1;
					ILaunchDelegate preferred = fTabType.getPreferredDelegate(modes);
					if(preferred == null) {
						return true;
					}
					else if(WorkbenchActivityHelper.filterItem(new LaunchDelegateContribution(preferred))) {
						return true;
					}
				}
			}
			catch (CoreException ce) {DebugUIPlugin.log(ce);}
		}
		catch(CoreException ce) {DebugUIPlugin.log(ce);}
		return false;
	}
	

				return temp.toString();
			}
		}
		if(getWorkingCopy().isReadOnly()) {
			return LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_9;
				return LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_9;
			}
		}
		//EXPERIMENTAL
		if(!canLaunchWithModes()) {
			Set modes = getCurrentModeSet();
			List names = LaunchConfigurationPresentationManager.getDefault().getLaunchModeNames(modes);
			return MessageFormat.format(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_14, new String[]{names.toString()});
				List names = LaunchConfigurationPresentationManager.getDefault().getLaunchModeNames(modes);
				return MessageFormat.format(LaunchConfigurationsMessages.LaunchConfigurationTabGroupViewer_14, new String[]{names.toString()});
			} catch (CoreException e) {
				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;
	}	

			}
		}
		fCurrentTabIndex = fTabFolder.getSelectionIndex();
		SelectionChangedEvent event = new SelectionChangedEvent(this, getSelection());
		fireSelectionChanged(event);
	}
	
	/**

			if(fTabGroup != null) {
				fTabGroup.initializeFrom(fOriginal);
				fWorkingCopy = fOriginal.getWorkingCopy();
				refresh();
				refreshStatus();
			}
		} 

	 */
	public void setActiveTab(ILaunchConfigurationTab tab) {
		ILaunchConfigurationTab[] tabs = getTabs();
		if(tabs != null) {
			for (int i = 0; i < tabs.length; i++) {
				if (tabs[i].getClass().equals(tab.getClass())) {
					setActiveTab(i);
					return;
				}
			}
		}
	}

Lines 99-106 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationsMessages.java (+9 lines)
99		99
100	public static String LaunchConfigurationTabGroupViewer_16;	100	public static String LaunchConfigurationTabGroupViewer_16;
101		101
		102	public static String LaunchConfigurationTabGroupViewer_17;
102	public static String LaunchConfigurationTabGroupViewer_9;	103	public static String LaunchConfigurationTabGroupViewer_9;
103	public static String LaunchConfigurationTabGroupViewer_13;	104	public static String LaunchConfigurationTabGroupViewer_13;
		105
		106	public static String LaunchersTab_3;
		107	public static String LaunchersTab_4;
		108	public static String LaunchersTab_6;
104	public static String PerspectiveManager_Error_1;	109	public static String PerspectiveManager_Error_1;
105	public static String PerspectiveManager_Unable_to_switch_perpsectives_as_specified_by_launch___0__4;	110	public static String PerspectiveManager_Unable_to_switch_perpsectives_as_specified_by_launch___0__4;
106	public static String PerspectiveManager_Unable_to_switch_to_perspective___0__2;	111	public static String PerspectiveManager_Unable_to_switch_to_perspective___0__2;
Lines 215-219 Link Here
215	public static String SelectLaunchOptionsDialog_2;	220	public static String SelectLaunchOptionsDialog_2;
216	public static String SelectLaunchOptionsDialog_3;	221	public static String SelectLaunchOptionsDialog_3;
217	public static String SelectLaunchOptionsDialog_4;	222	public static String SelectLaunchOptionsDialog_4;
		223
		224	public static String LaunchersTab_0;
		225	public static String LaunchersTab_1;
		226	public static String LaunchersTab_2;
218		227
219	}	228	}




		return (AbstractLaunchConfigurationAction)fLaunchConfigurationView.getAction(DuplicateLaunchConfigurationAction.ID_DUPLICATE_ACTION);
	}
  	
  	/**
  	 * returns the properties action 
  	 * @return the 'Properties' action from the context menu of the launch view
  	 * 
  	 * @since 3.3
  	 * EXPERIMENTAL
  	 */
  	protected IAction getPropertiesAction() {
  		return fLaunchConfigurationView.getAction(LaunchConfigurationPropertiesAction.ID_PROPERTIES_ACTION);
  	}
  	
	/**
	 * Gets the help context id
	 * 




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

import java.util.ArrayList;

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.IDialogConstants;
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.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
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.Group;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.SelectionDialog;


 * EXPERIMENTAL
 */
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 SelectLaunchDelegatePanel fPanel = null;
	private Table fTable  = null;
	private ILaunchDelegate[] fDelegates = null;
	private Text fDescriptionText = null;
	private final String EMPTY_STRING = ""; //$NON-NLS-1$
	
	/**
	 * Constructor
	 * @param parentShell the parent shell

	protected Control createDialogArea(Composite parent) {
		initializeDialogUnits(parent);
		Composite comp = (Composite) super.createDialogArea(parent);
		fPanel = new SelectLaunchDelegatePanel(comp);
		fPanel.initialize(fDelegates);
		CheckboxTableViewer viewer = fPanel.getTableViewer();
		viewer.addCheckStateListener(new ICheckStateListener() {
		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);
				getButton(IDialogConstants.OK_ID).setEnabled(true);
			}
		});
		fTableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent event) {
				IStructuredSelection ss = (IStructuredSelection) event.getSelection();
				if(ss != null && !ss.isEmpty()) {
					fDescriptionText.setText(((ILaunchDelegate)ss.getFirstElement()).getDescription());
				}
				else {
					fDescriptionText.setText(EMPTY_STRING);
				}
			}
		});
		Group group = SWTUtil.createGroup(comp, LaunchConfigurationsMessages.SelectLaunchDelegatesDialog_3, 1, 1, GridData.FILL_BOTH);
		fDescriptionText = SWTUtil.createText(group, SWT.WRAP | SWT.READ_ONLY, 1, GridData.FILL_BOTH);
		fDescriptionText.setBackground(group.getBackground());
		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 delegate = fPanel.getSelectedDelegate();
		if(delegate != null) {
			ArrayList list = new ArrayList();
			list.add(delegate);
			setResult(list);
		}
		super.okPressed();
	}

Lines 75-80 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationView.java (-2 / +13 lines)
75	private DeleteLaunchConfigurationAction fDeleteAction;	75	private DeleteLaunchConfigurationAction fDeleteAction;
76	private DuplicateLaunchConfigurationAction fDuplicateAction;	76	private DuplicateLaunchConfigurationAction fDuplicateAction;
77	private CollapseAllLaunchConfigurationAction fCollapseAllAction;	77	private CollapseAllLaunchConfigurationAction fCollapseAllAction;
		78	private LaunchConfigurationPropertiesAction fPropertiesAction;
78		79
79	/**	80	/**
80	* Action for providing filtering to the Launch Configuraiton Dialog	81	* Action for providing filtering to the Launch Configuraiton Dialog
Lines 101-106 Link Here
101	fLaunchGroup = launchGroup;	102	fLaunchGroup = launchGroup;
102	}	103	}
103		104
		105	/**
		106	* Constructor
		107	* @param launchGroup
		108	* @param filters
		109	*/
104	public LaunchConfigurationView(LaunchGroupExtension launchGroup, ViewerFilter[] filters) {	110	public LaunchConfigurationView(LaunchGroupExtension launchGroup, ViewerFilter[] filters) {
105	super();	111	super();
106	fLaunchGroup = launchGroup;	112	fLaunchGroup = launchGroup;
Lines 181-186 Link Here
181		187
182	fFilterAction = new FilterLaunchConfigurationAction();	188	fFilterAction = new FilterLaunchConfigurationAction();
183	setAction(FilterLaunchConfigurationAction.ID_FILTER_ACTION, fFilterAction);	189	setAction(FilterLaunchConfigurationAction.ID_FILTER_ACTION, fFilterAction);
		190
		191	fPropertiesAction = new LaunchConfigurationPropertiesAction((LaunchConfigurationsDialog) LaunchConfigurationsDialog.getCurrentlyVisibleLaunchConfigurationDialog(), getViewer());
		192	setAction(LaunchConfigurationPropertiesAction.ID_PROPERTIES_ACTION, fPropertiesAction);
		193
184	}	194	}
185		195
186	/**	196	/**
Lines 198-203 Link Here
198	menu.add(fDuplicateAction);	208	menu.add(fDuplicateAction);
199	menu.add(fDeleteAction);	209	menu.add(fDeleteAction);
200	menu.add(new Separator());	210	menu.add(new Separator());
		211	menu.add(fPropertiesAction);
201	}	212	}
202		213
203	/**	214	/**
Lines 223-228 Link Here
223	fDuplicateAction.dispose();	234	fDuplicateAction.dispose();
224	fFilterAction = null;	235	fFilterAction = null;
225	fCollapseAllAction = null;	236	fCollapseAllAction = null;
		237	fPropertiesAction.dispose();
226	getLaunchManager().removeLaunchConfigurationListener(this);	238	getLaunchManager().removeLaunchConfigurationListener(this);
227	}	239	}
228		240
Lines 277-284 Link Here
277	/**	289	/**
278	* @see org.eclipse.debug.core.ILaunchConfigurationListener#launchConfigurationChanged(org.eclipse.debug.core.ILaunchConfiguration)	290	* @see org.eclipse.debug.core.ILaunchConfigurationListener#launchConfigurationChanged(org.eclipse.debug.core.ILaunchConfiguration)
279	*/	291	*/
280	public void launchConfigurationChanged(ILaunchConfiguration configuration) {	292	public void launchConfigurationChanged(ILaunchConfiguration configuration) {}
281	}
282		293
283	/**	294	/**
284	* @see org.eclipse.debug.core.ILaunchConfigurationListener#launchConfigurationRemoved(org.eclipse.debug.core.ILaunchConfiguration)	295	* @see org.eclipse.debug.core.ILaunchConfigurationListener#launchConfigurationRemoved(org.eclipse.debug.core.ILaunchConfiguration)

Lines 175-181 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationPresentationManager.java (-3 / +6 lines)
175	}	175	}
176		176
177	/**	177	/**
178	* Returns the tab group for the given launch configutation, its type and the mode the dialog opened in	178	* Returns the tab group for the given launch configutation and the mode the dialog opened in
179	* @param type the type of the configuration	179	* @param type the type of the configuration
180	* @param config	180	* @param config
181	* @param mode	181	* @param mode
Lines 195-201 Link Here
195	/**	195	/**
196	* Returns the proxy elements for all contributed tabs for the specified tab group id	196	* Returns the proxy elements for all contributed tabs for the specified tab group id
197	* @param groupid the id of the tab group	197	* @param groupid the id of the tab group
198	* @param type the type the tab group is opened on	198	* @param config the config the tab group is opened on
199	* @param mode the mode the associated launch dialog is opened on	199	* @param mode the mode the associated launch dialog is opened on
200	* @return the listing of all of the tab extensions or an empty array, never <code>null</code>	200	* @return the listing of all of the tab extensions or an empty array, never <code>null</code>
201	*	201	*
Lines 241-247 Link Here
241	//filter to preferred delegate (if there is one)	241	//filter to preferred delegate (if there is one)
242	HashSet modes = (HashSet) config.getModes();	242	HashSet modes = (HashSet) config.getModes();
243	modes.add(mode);	243	modes.add(mode);
244	ILaunchDelegate delegate = config.getType().getPreferredDelegate(modes);	244	ILaunchDelegate delegate = config.getPreferredDelegate(modes);
		245	if(delegate == null) {
		246	delegate = config.getType().getPreferredDelegate(modes);
		247	}
245	if(delegate != null) {	248	if(delegate != null) {
246	if(tabs[i].getDelegateSet().contains(delegate.getId())) {	249	if(tabs[i].getDelegateSet().contains(delegate.getId())) {
247	set.add(tabs[i]);	250	set.add(tabs[i]);

Lines 72-79 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/CreateLaunchConfigurationAction.java (-2 / +1 lines)
72	tabGroup.createTabs(dialog, dialog.getMode());	72	tabGroup.createTabs(dialog, dialog.getMode());
73	ILaunchConfigurationTab[] tabs = tabGroup.getTabs();	73	ILaunchConfigurationTab[] tabs = tabGroup.getTabs();
74	for (int i = 0; i < tabs.length; i++) {	74	for (int i = 0; i < tabs.length; i++) {
75	ILaunchConfigurationTab tab = tabs[i];	75	tabs[i].setLaunchConfigurationDialog(dialog);
76	tab.setLaunchConfigurationDialog(dialog);
77	}	76	}
78	tabGroup.setDefaults(wc);	77	tabGroup.setDefaults(wc);
79	tabGroup.dispose();	78	tabGroup.dispose();




/*******************************************************************************
 * 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.Group;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.Text;
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
 * 
 * TODO create a help topic for this page....it needs a good description
 * 
 * EXPERIMENTAL
 */
public class LaunchDelegatesPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {

	/**
	 * Class to collect and persist attributes to sufficiently describe a dupicate launch delegate
	 */
	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, provides labels to both the tree and table of this page
	 */
	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;
	private Text fDescription = null;
	
	/**
	 * 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);
	}

	/**
	 * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createContents(Composite parent) {
		Composite comp = SWTUtil.createComposite(parent, 2, 1, GridData.FILL_BOTH);
		SWTUtil.createWrapLabel(comp, DebugPreferencesMessages.LaunchDelegatesPreferencePage_1, 2, 300);
		
		SWTUtil.createVerticalSpacer(comp, 1);
	//tree
		Composite comp1 = SWTUtil.createComposite(comp, 1, 1, GridData.FILL_VERTICAL);
		SWTUtil.createLabel(comp1, DebugPreferencesMessages.LaunchDelegatesPreferencePage_2, 1);
		Tree tree = new Tree(comp1, 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.expandToLevel(2);
		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
		Composite comp2 = SWTUtil.createComposite(comp, comp.getFont(), 1, 1, GridData.FILL_BOTH);
		SWTUtil.createLabel(comp2, DebugPreferencesMessages.LaunchDelegatesPreferencePage_3, 1);
		Table table = new Table(comp2, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.CHECK | SWT.SINGLE);
		table.setLayoutData(new GridData(GridData.FILL_BOTH));
		fTableViewer = new CheckboxTableViewer(table);
		fTableViewer.setComparator(new WorkbenchViewerComparator());
		fTableViewer.setLabelProvider(new LabelProvider());
		fTableViewer.setContentProvider(new ArrayContentProvider());
		fTableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent event) {
				IStructuredSelection ss = (IStructuredSelection) event.getSelection();
				if(ss != null && !ss.isEmpty()) {
					fDescription.setText(((ILaunchDelegate)ss.getFirstElement()).getDescription());
				}
				else {
					fDescription.setText(""); //$NON-NLS-1$
				}
			}
		});
		fTableViewer.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				fDirty = true;
				Object element = event.getElement();
				boolean checked = event.getChecked();
				fTableViewer.setAllChecked(false);
				//always set checked, this way users cannot 'undo' a change to selecting a preferred delegate
				//The story for this is that on startup if there are dupes, the user is prompted to pick a delegate, after that they cannot 
				//return to a state of not being able to launch something, but can pick a different delegate
				fTableViewer.setChecked(element, true);
				//persist the selection
				Object obj = ((IStructuredSelection) fTreeViewer.getSelection()).getFirstElement();
				if(obj instanceof DuplicateDelegate) {
					fDupeSelections.remove(obj);
					if(checked) {
						fDupeSelections.put(obj, element);
					}
				}
			}
		});
		Group group = SWTUtil.createGroup(comp, DebugPreferencesMessages.LaunchDelegatesPreferencePage_4, 1, 2, GridData.FILL_BOTH);
		fDescription = SWTUtil.createText(group, SWT.WRAP | SWT.READ_ONLY, 1, GridData.FILL_BOTH);
		fDescription.setBackground(group.getBackground());
		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);}
			}
		}
		if(getPreferenceStore().needsSaving()) {
			DebugUIPlugin.getDefault().savePluginPreferences();
		}
		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 {
			setPreferenceStore(DebugUIPlugin.getDefault().getPreferenceStore());
			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 66-72 Link Here

(-)schema/launchConfigurationTabs.exsd (-1 / +1 lines)
66	<attribute name="class" type="string" use="required">	66	<attribute name="class" type="string" use="required">
67	<annotation>	67	<annotation>
68	<documentation>	68	<documentation>
69	fully qualified name of the java class that implemnents <code>ILaunchConfigurationTab</code>.	69	fully qualified name of the java class that implements <code>ILaunchConfigurationTab</code>.
70	</documentation>	70	</documentation>
71	<appInfo>	71	<appInfo>
72	<meta.attribute kind="java" basedOn="org.eclipse.debug.ui.ILaunchConfigurationTab"/>	72	<meta.attribute kind="java" basedOn="org.eclipse.debug.ui.ILaunchConfigurationTab"/>




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

import org.eclipse.debug.core.ILaunchDelegate;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.SWTUtil;
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.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.model.WorkbenchViewerComparator;

/**
 * This class provides a reusable panel for the present a listing of <code>ILaunchDelegate</code>s to a user 
 * with a description field
 * 
 * EXPERIMENTAL
 * @since 3.3
 */
public class SelectLaunchDelegatePanel {

	/**
	 * Builds labels for table 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 Table fTable = null;
	private CheckboxTableViewer fTableViewer = null;
	private Text fDescriptionText = null;
	
	/**
	 * Constructor
	 * @param parent
	 * @param initialSelection
	 */
	public SelectLaunchDelegatePanel(Composite parent) {
		createControl(parent);
	}
	
	/**
	 * Creates the selection control on the specified parent composite
	 * @param parent the parent to add this control to
	 */
	protected void createControl(Composite parent) {
		Composite comp  = SWTUtil.createComposite(parent, 1, 1, GridData.FILL_BOTH);
		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.setComparator(new WorkbenchViewerComparator());
		fTableViewer.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				fTableViewer.setCheckedElements(new Object[] {event.getElement()});
			}
		});
		fTableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent event) {
				IStructuredSelection ss = (IStructuredSelection) event.getSelection();
				if(ss != null && !ss.isEmpty()) {
					fDescriptionText.setText(((ILaunchDelegate)ss.getFirstElement()).getDescription());
				}
				else {
					fDescriptionText.setText(IInternalDebugUIConstants.EMPTY_STRING);
				}
			}
		});
		Group group = SWTUtil.createGroup(comp, LaunchConfigurationsMessages.SelectLaunchDelegatesDialog_3, 1, 1, GridData.FILL_BOTH);
		fDescriptionText = SWTUtil.createText(group, SWT.WRAP | SWT.READ_ONLY, 1, GridData.FILL_BOTH);
		fDescriptionText.setBackground(group.getBackground());
	}
	
	/**
	 * This method initializes the input to the launch delegates viewer, and should be called before trying to set the selection 
	 * @param delegates the listing of delegates to set as input for this viewer
	 */
	public void initialize(ILaunchDelegate[] delegates) {
		fTableViewer.setInput(delegates);
	}
	
	/**
	 * Returns the currently checked launch delegate
	 * @return the currently selected launch delegate or <code>null</code> if none are checked
	 */
	public ILaunchDelegate getSelectedDelegate() {
		Object[] checked = fTableViewer.getCheckedElements();
		if(checked.length > 0) {
			return (ILaunchDelegate) checked[0];
		}
		return null;
	}
	
	/**
	 * Sets the enabled state of the panels' usable controls
	 * @param enabled the enabled state desired for the panels' usable controls
	 */
	public void setEnabled(boolean enabled) {
		fTable.setEnabled(enabled);
	}
	
	/**
	 * This method will both select and set as checked the specified delegate, if found in the table viewer
	 * @param delegate the delegate to set as selected AND checked in the table view
	 */
	public void setSelection(ILaunchDelegate delegate) {
		if(delegate != null) {
			fTableViewer.setSelection(new StructuredSelection(delegate));
			fTableViewer.setCheckedElements(new Object[] {delegate});
		}
		else {
			fTableViewer.setSelection(new StructuredSelection());
			fTableViewer.setAllChecked(false);
		}
	}
	
	/**
	 * Returns the check table viewer so subclasses can work directly with it
	 * @return the check box table viewer from this control
	 */
	protected CheckboxTableViewer getTableViewer() {
		return fTableViewer;
	}

}




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

import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.window.IShellProvider;
import org.eclipse.ui.dialogs.PropertyDialogAction;

/**
 * Subclass to allow access the the run method of rht eproperrty dialog action
 * 
 * @since 3.3
 * EXPERIMENTAL
 */
public class LaunchConfigurationPropertiesAction extends PropertyDialogAction {

	/**
	 * Action identifier for IDebugView#getAction(String)
	 */
	public static final String ID_PROPERTIES_ACTION = DebugUIPlugin.getUniqueIdentifier() + ".ID_PROPERTIES_ACTION"; //$NON-NLS-1$
	
	/**
	 * Constructor
	 * @param shell
	 * @param provider
	 */
	public LaunchConfigurationPropertiesAction(IShellProvider shell, ISelectionProvider provider) {
		super(shell, provider);
	}

	/**
	 * @see org.eclipse.ui.dialogs.PropertyDialogAction#run()
	 */
	public void run() {
		super.run();
		((LaunchConfigurationsDialog)LaunchConfigurationsDialog.getCurrentlyVisibleLaunchConfigurationDialog()).getTabViewer().displayInstanceTabs();
	}

	/**
	 * @see org.eclipse.ui.dialogs.PropertyDialogAction#selectionChanged(org.eclipse.jface.viewers.IStructuredSelection)
	 */
	public void selectionChanged(IStructuredSelection selection) {
		if(selection != null && !selection.isEmpty()) {
			Object o = selection.getFirstElement();
			if(o instanceof ILaunchConfiguration) {
				try {
					ILaunchConfiguration config = (ILaunchConfiguration) o;
					Set modes = config.getModes();
					modes.add(LaunchConfigurationsDialog.getCurrentlyVisibleLaunchConfigurationDialog().getMode());
					setEnabled(config.getType().getDelegates(modes).length > 1);
					return;
				}
				catch(CoreException ce) {DebugUIPlugin.log(ce);}
			}
		}
		setEnabled(false);
	}
}




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

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

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.ILaunchConfiguration;
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.IDebugHelpContextIds;
import org.eclipse.debug.internal.ui.SWTUtil;
import org.eclipse.debug.ui.ILaunchConfigurationDialog;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Link;
import org.eclipse.ui.IWorkbenchPropertyPage;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.PropertyPage;

/**
 * This class provides a property page for editing the properties of a launch configuration in the launch dialog
 * 
 *  @since 3.3
 *  EXPERIMENTAL
 */
public class PreferredLaunchersPropertyPage extends PropertyPage implements IWorkbenchPropertyPage {

	private Button fUseSystemLauncher = null;
	private SelectLaunchDelegatePanel fPanel = null;
	
	/**
	 * Constructor
	 */
	public PreferredLaunchersPropertyPage() {}

	/**
	 * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createContents(Composite parent) {
		Composite comp = SWTUtil.createComposite(parent, 1, 1, GridData.FILL_BOTH);
		Label label = SWTUtil.createWrapLabel(comp, LaunchConfigurationsMessages.LaunchersTab_0, 1);
		((GridData)label.getLayoutData()).widthHint = 40;
		SWTUtil.createVerticalSpacer(comp, 1);
		Composite c2 = SWTUtil.createComposite(comp, 2, 1, GridData.FILL_HORIZONTAL);
		fUseSystemLauncher = SWTUtil.createCheckButton(c2, LaunchConfigurationsMessages.LaunchersTab_1, null, true);
		Link link = new Link(c2, SWT.NONE);
		link.setText(LaunchConfigurationsMessages.LaunchersTab_3);
		link.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, true, true, 1, 1));
		
		SWTUtil.createVerticalSpacer(comp, 1);
		fPanel = new SelectLaunchDelegatePanel(comp);
		fPanel.getTableViewer().addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				setValid(isValid());
				
			}
		});
		
		initialize();
		
	//add selection listeners after so we can access the panel
		fUseSystemLauncher.addSelectionListener(new SelectionListener() {
			public void widgetDefaultSelected(SelectionEvent e) {}
			public void widgetSelected(SelectionEvent e) {
				boolean checked = ((Button)e.widget).getSelection();
				fPanel.setEnabled(checked);
				resetDelegate();
				setValid(isValid());
			}
		});
		link.addSelectionListener(new SelectionListener() {
			public void widgetDefaultSelected(SelectionEvent e) {}
			public void widgetSelected(SelectionEvent e) {
				SWTUtil.showPreferencePage("org.eclipse.debug.ui.LaunchDelegatesPreferencePage"); //$NON-NLS-1$
				if(!fUseSystemLauncher.getSelection()) {
					resetDelegate();
					setValid(isValid());
				}
			}
		});
		PlatformUI.getWorkbench().getHelpSystem().setHelp(comp, IDebugHelpContextIds.LAUNCH_CONFIGURATION_DIALOG_LAUNCHERS_TAB);
		return comp;
	}

	/**
	 * Resets the selected and checked delegate in the preferred launcher view part to be the one from the workspace
	 */
	private void resetDelegate() {
		ILaunchConfiguration config = getLaunchConfiguration();
		if(!fUseSystemLauncher.getSelection()) {
			try {
				ILaunchDelegate preferred = config.getType().getPreferredDelegate(getModes());
				if(preferred != null) {
					fPanel.setSelection(preferred);
				}
			}
			catch (CoreException ce) {DebugUIPlugin.log(ce);}
		}
	}
	
	/**
	 * @see org.eclipse.jface.preference.PreferencePage#performDefaults()
	 */
	protected void performDefaults() {
		if(fUseSystemLauncher != null) {
			fUseSystemLauncher.setSelection(false);
			resetDelegate();
			fPanel.setEnabled(false);
		}
		super.performDefaults();
	}

	/**
	 * Initializes the page
	 */
	private void initialize() {
		try {
			fPanel.initialize(getLaunchConfiguration().getType().getDelegates(getModes()));
			ILaunchConfigurationWorkingCopy config = getLaunchConfiguration();
			Set modes = getModes();
			ILaunchDelegate delegate = config.getPreferredDelegate(modes);
			boolean custom = delegate != null;
			fUseSystemLauncher.setSelection(custom);
			fPanel.setEnabled(custom);
			//load the pref settings
			fPanel.initialize(config.getType().getDelegates(modes));
			if(delegate == null) {
				delegate = config.getType().getPreferredDelegate(modes);
			}
			fPanel.setSelection(delegate);
		} 
		catch (CoreException e1) {DebugUIPlugin.log(e1);}
	}
	
	/**
	 * @return the launch configuration backing this property page
	 */
	private ILaunchConfigurationWorkingCopy getLaunchConfiguration() {
		LaunchConfigurationsDialog dialog = (LaunchConfigurationsDialog) LaunchConfigurationsDialog.getCurrentlyVisibleLaunchConfigurationDialog();
		return (ILaunchConfigurationWorkingCopy) ((IStructuredSelection)dialog.getTabViewer().getSelection()).getFirstElement();
	}
	
	/**
	 * @see org.eclipse.jface.preference.PreferencePage#isValid()
	 */
	public boolean isValid() {
		setErrorMessage(null);
		if(fPanel.getSelectedDelegate() == null) {
			if(fUseSystemLauncher.getSelection()) {
				ILaunchConfigurationWorkingCopy config = getLaunchConfiguration();
				setErrorMessage(LaunchConfigurationsMessages.LaunchersTab_4+config.getName());
				return false;
			}
			else {
				setErrorMessage(LaunchConfigurationsMessages.LaunchersTab_6);
				return false;
			}
		}
		return true;
	}

	/**
	 * @see org.eclipse.jface.preference.PreferencePage#performOk()
	 */
	public boolean performOk() {
		ILaunchConfigurationWorkingCopy config = getLaunchConfiguration();
		Set modes = getModes();
		ILaunchDelegate delegate = null;
		if(fUseSystemLauncher.getSelection()) {
			delegate = fPanel.getSelectedDelegate();	
			if(delegate != null) {
				config.setPreferredLaunchDelegate(modes, delegate.getId());
			}
		}
		else {
			config.setPreferredLaunchDelegate(modes, null);
		}
		if(config.isDirty()) {
			try {
				config.doSave();
			} 
			catch (CoreException e) {DebugUIPlugin.log(e);}
		}
		updateLaunchDialog();
		return super.performOk();
	}
	
	/**
	 * @return the complete set of modes that the associated launch configuration is concerned with
	 */
	private Set getModes() {
		Set modes = new HashSet();
		try {
			ILaunchConfigurationWorkingCopy config = getLaunchConfiguration().getWorkingCopy();
			modes = config.getModes();
			modes.add(LaunchConfigurationsDialog.getCurrentlyVisibleLaunchConfigurationDialog().getMode());
		}
		catch (CoreException ce) {DebugUIPlugin.log(ce);}
		return modes;
	}
	
	/**
	 * updates the currently visible launch dialog
	 */
	private void updateLaunchDialog() {
		ILaunchConfigurationDialog dialog = LaunchConfigurationsDialog.getCurrentlyVisibleLaunchConfigurationDialog();
		dialog.updateButtons();
		dialog.updateMessage();
	}
	
}




/*******************************************************************************
 * 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.Group;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.Text;
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
 * 
 * TODO create a help topic for this page....it needs a good description
 * 
 * EXPERIMENTAL
 */
public class LaunchersPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {

	/**
	 * Class to collect and persist attributes to sufficiently describe a dupicate launch delegate
	 */
	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, provides labels to both the tree and table of this page
	 */
	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;
	private Text fDescription = null;
	
	/**
	 * Constructor
	 */
	public LaunchersPreferencePage() {
		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);
	}

	/**
	 * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createContents(Composite parent) {
		Composite comp = SWTUtil.createComposite(parent, 2, 1, GridData.FILL_BOTH);
		SWTUtil.createWrapLabel(comp, DebugPreferencesMessages.LaunchDelegatesPreferencePage_1, 2, 300);
		
		SWTUtil.createVerticalSpacer(comp, 1);
	//tree
		Composite comp1 = SWTUtil.createComposite(comp, 1, 1, GridData.FILL_VERTICAL);
		SWTUtil.createLabel(comp1, DebugPreferencesMessages.LaunchDelegatesPreferencePage_2, 1);
		Tree tree = new Tree(comp1, 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.expandToLevel(2);
		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
		Composite comp2 = SWTUtil.createComposite(comp, comp.getFont(), 1, 1, GridData.FILL_BOTH);
		SWTUtil.createLabel(comp2, DebugPreferencesMessages.LaunchDelegatesPreferencePage_3, 1);
		Table table = new Table(comp2, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.CHECK | SWT.SINGLE);
		table.setLayoutData(new GridData(GridData.FILL_BOTH));
		fTableViewer = new CheckboxTableViewer(table);
		fTableViewer.setComparator(new WorkbenchViewerComparator());
		fTableViewer.setLabelProvider(new LabelProvider());
		fTableViewer.setContentProvider(new ArrayContentProvider());
		fTableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent event) {
				IStructuredSelection ss = (IStructuredSelection) event.getSelection();
				if(ss != null && !ss.isEmpty()) {
					fDescription.setText(((ILaunchDelegate)ss.getFirstElement()).getDescription());
				}
				else {
					fDescription.setText(""); //$NON-NLS-1$
				}
			}
		});
		fTableViewer.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				fDirty = true;
				Object element = event.getElement();
				boolean checked = event.getChecked();
				fTableViewer.setAllChecked(false);
				//always set checked, this way users cannot 'undo' a change to selecting a preferred delegate
				//The story for this is that on startup if there are dupes, the user is prompted to pick a delegate, after that they cannot 
				//return to a state of not being able to launch something, but can pick a different delegate
				fTableViewer.setChecked(element, true);
				//persist the selection
				Object obj = ((IStructuredSelection) fTreeViewer.getSelection()).getFirstElement();
				if(obj instanceof DuplicateDelegate) {
					fDupeSelections.remove(obj);
					if(checked) {
						fDupeSelections.put(obj, element);
					}
				}
			}
		});
		Group group = SWTUtil.createGroup(comp, DebugPreferencesMessages.LaunchDelegatesPreferencePage_4, 1, 2, GridData.FILL_BOTH);
		fDescription = SWTUtil.createText(group, SWT.WRAP | SWT.READ_ONLY, 1, GridData.FILL_BOTH);
		fDescription.setBackground(group.getBackground());
		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);}
			}
		}
		if(getPreferenceStore().needsSaving()) {
			DebugUIPlugin.getDefault().savePluginPreferences();
		}
		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 {
			setPreferenceStore(DebugUIPlugin.getDefault().getPreferenceStore());
			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 89-94 Link Here

(-)core/org/eclipse/debug/core/ILaunchConfiguration.java (+25 lines)
89	public static final String ATTR_SOURCE_LOCATOR_MEMENTO = DebugPlugin.getUniqueIdentifier() + ".source_locator_memento"; //$NON-NLS-1$	89	public static final String ATTR_SOURCE_LOCATOR_MEMENTO = DebugPlugin.getUniqueIdentifier() + ".source_locator_memento"; //$NON-NLS-1$
90		90
91	/**	91	/**
		92	* Launch configuration attribute storing a list
		93	* of preferred launchers for associated mode sets.
		94	* This attribute is a list of launchers stored by mode set
		95	* and relating to the id of the preferred launcher, which happens to be an <code>ILaunchDelegate</code>
		96	*
		97	* @since 3.3
		98	*/
		99	public static final String ATTR_PREFERRED_LAUNCHERS = DebugPlugin.getUniqueIdentifier() + ".preferred_launchers"; //$NON-NLS-1$
		100
		101	/**
92	* Returns whether the contents of this launch configuration are	102	* Returns whether the contents of this launch configuration are
93	* equal to the contents of the given launch configuration.	103	* equal to the contents of the given launch configuration.
94	*	104	*
Lines 345-350 Link Here
345	public Set getModes() throws CoreException;	355	public Set getModes() throws CoreException;
346		356
347	/**	357	/**
		358	* Returns the preferred launch delegate that has been set on this configuration.
		359	* @return this configuration's preferred launch delegate for the specified mode set, or
		360	* <code>null</code> if one is not specified
		361	*
		362	* <p>
		363	* <strong>EXPERIMENTAL</strong>. This method has been added as
		364	* part of a work in progress. There is no guarantee that this API will
		365	* remain unchanged during the 3.3 release cycle. Please do not use this API
		366	* without consulting with the Platform/Debug team.
		367	* </p>
		368	* @since 3.3
		369	*/
		370	public ILaunchDelegate getPreferredDelegate(Set modes) throws CoreException;
		371
		372	/**
348	* Returns the type of this launch configuration. This is a	373	* Returns the type of this launch configuration. This is a
349	* handle-only method.	374	* handle-only method.
350	*	375	*




	public void setModes(Set modes);
	
	/**
	 * Set the preferred launch delegates' id for the given mode set. Passing in <code>null</code> as a delegate
	 * id will cause the mapping for the specified mode set (if any) to be removed
	 * @param modes the set of modes to set this delegate id for
	 * @param delegateId the id of the delegate to associate as preferred for the specified mode set
	 * 
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 * @since 3.3
	 */
	public void setPreferredLaunchDelegate(Set modes, String delegateId);
	
	/**
	 * Adds the specified launch modes to this configuration's settings.
	 * <p>
	 * Setting launch modes on a configuration allows the configuration to




	 * without consulting with the Platform/Debug team.
	 * </p>
	 */
	public ILaunchDelegate[] getLaunchDelegates() {
		initializeLaunchDelegates();
		Collection col = fLaunchDelegates.values();
		return (ILaunchDelegate[]) col.toArray(new ILaunchDelegate[col.size()]);
	}
	
	/**

	}
	
	/**
	 * This method returns the <code>ILaunchDelegate</code> instance corresponding to the id 
	 * of the launch delegate specified
	 * @param id the id of the <code>ILaunchDelegate</code> to find 
	 * @return the <code>ILaunchDelegate</code> or <code>null</code> if not found
	 * @since 3.3
	 * EXPERIMENTAL
	 */
	public ILaunchDelegate getLaunchDelegate(String id) {
		if(id != null) {
			ILaunchDelegate[] delegates = getLaunchDelegates();
			for(int i = 0; i < delegates.length; i++) {
				if(id.equals(delegates[i].getId())) {
					return delegates[i];
				}
			}
		}
		return null;
	}
	
	/**
	 * Initializes the listing of delegates available to the launching framework
	 * 
	 * <p>

					for(Iterator iter = preferred.keySet().iterator(); iter.hasNext();) {
						modes = (Set) iter.next();
						delegate = (ILaunchDelegate) preferred.get(modes);
						if(delegate != null) {
							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, modestr);
							modestr = EMPTY_STRING;
							root.appendChild(child);
						}
						child.setAttribute(MODES, modestr);
						modestr = EMPTY_STRING;
						root.appendChild(child);
					}
				}
			}

Lines 624-630 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchConfiguration.java (-1 / +18 lines)
624	IStatus status = new Status(IStatus.CANCEL, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, "No launch delegate found, canceling launch and returning", null); //$NON-NLS-1$	624	IStatus status = new Status(IStatus.CANCEL, DebugPlugin.getUniqueIdentifier(), DebugPlugin.INTERNAL_ERROR, "No launch delegate found, canceling launch and returning", null); //$NON-NLS-1$
625	throw new CoreException(status);	625	throw new CoreException(status);
626	} else {	626	} else {
627	ILaunchDelegate del = getType().getPreferredDelegate(modes);	627	ILaunchDelegate del = getPreferredDelegate(modes);
		628	if(del == null) {
		629	del = getType().getPreferredDelegate(modes);
		630	}
628	if(del == null) {	631	if(del == null) {
629	IStatusHandler handler = DebugPlugin.getDefault().getStatusHandler(promptStatus);	632	IStatusHandler handler = DebugPlugin.getDefault().getStatusHandler(promptStatus);
630	IStatus status = (IStatus) handler.handleStatus(duplicateDelegates, new Object[] {this, mode});	633	IStatus status = (IStatus) handler.handleStatus(duplicateDelegates, new Object[] {this, mode});
Lines 777-782 Link Here
777	}	780	}
778	return false;	781	return false;
779	}	782	}
		783
		784	/**
		785	* @see org.eclipse.debug.core.ILaunchConfiguration#getPreferredDelegate(java.util.Set)
		786	*/
		787	public ILaunchDelegate getPreferredDelegate(Set modes) throws CoreException {
		788	Map delegates = getAttribute(ILaunchConfiguration.ATTR_PREFERRED_LAUNCHERS, (Map)null);
		789	if(delegates != null) {
		790	String id = (String) delegates.get(modes.toString());
		791	if(id != null) {
		792	return getLaunchManager().getLaunchDelegate(id);
		793	}
		794	}
		795	return null;
		796	}
780		797
781	}	798	}
782		799




import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

	/**
	 * @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#setModes(java.util.Set)
	 */
	public void setModes(Set modes) {
		getInfo().setAttribute(ATTR_LAUNCH_MODES, (modes.size() > 0 ? modes : null));
		setDirty();
	}

	/**
	 * @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#addModes(java.util.Set)
	 */
	public void addModes(Set modes) {
		try {
			Set opts = getModes();
			if(opts.addAll(modes)) {
				getInfo().setAttribute(ATTR_LAUNCH_MODES, opts);
				setDirty();
			}

		setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_TYPES, types);
	}

	/**
	 * @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#setPreferredLaunchDelegate(java.util.Set, java.lang.String)
	 */
	public void setPreferredLaunchDelegate(Set modes, String delegateId) {
		if(modes != null) {
			try {
				Map delegates = getAttribute(ILaunchConfiguration.ATTR_PREFERRED_LAUNCHERS, (Map)null);
					//copy map to avoid pointer issues
					Map map = new HashMap();
					if(delegates != null) {
						map.putAll(delegates);
					}
					if(delegateId == null) {
						map.remove(modes.toString());
					}
					else {
						map.put(modes.toString(), delegateId);
					}
					setAttribute(ILaunchConfiguration.ATTR_PREFERRED_LAUNCHERS, map);
			}
			catch (CoreException ce) {DebugPlugin.log(ce);}
		}
	}

}


Lines 595-600 Link Here

(-)contexts_Debugger.xml (+4 lines)
595	<topic label="Java application launch configuration" href=" tasks\tasks-java-local-configuration.htm"/>	595	<topic label="Java application launch configuration" href=" tasks\tasks-java-local-configuration.htm"/>
596	<topic label="Source Attachments" href="reference/ref-124.htm"/>	596	<topic label="Source Attachments" href="reference/ref-124.htm"/>
597	</context>	597	</context>
		598	<context id="launch_configuration_dialog_launchers_tab" >
		599	<description>This tab allows you to a specific launchers to use with the selected launch configuration in the event ther is more than one available.</description>
		600	<topic label="Java application launch configuration" href=" tasks\tasks-java-local-configuration.htm"/>
		601	</context>
598		602
599	<!--	603	<!--
600	Memory View	604	Memory View

Return to bug 157059

Lines 147-153 Link Here

(-)plugin.xml (-1 / +13 lines)
147	</page>	147	</page>
148	<page	148	<page
149	category="org.eclipse.debug.ui.LaunchingPreferencePage"	149	category="org.eclipse.debug.ui.LaunchingPreferencePage"
150	class="org.eclipse.debug.internal.ui.preferences.LaunchDelegatesPreferencePage"	150	class="org.eclipse.debug.internal.ui.preferences.LaunchersPreferencePage"
151	id="org.eclipse.debug.ui.LaunchDelegatesPreferencePage"	151	id="org.eclipse.debug.ui.LaunchDelegatesPreferencePage"
152	name="%LaunchDelegatesPreferencePage.name">	152	name="%LaunchDelegatesPreferencePage.name">
153	<keywordReference	153	<keywordReference
Lines 1452-1457 Link Here
1452	</or>	1452	</or>
1453	</enabledWhen>	1453	</enabledWhen>
1454	</page>	1454	</page>
		1455	<page
		1456	class="org.eclipse.debug.internal.ui.launchConfigurations.PreferredLaunchersPropertyPage"
		1457	id="org.eclipse.debug.ui.launchConfigurationPropertyPage"
		1458	name="%preferredLaunchersPropertyPage.name">
		1459	<enabledWhen>
		1460	<and>
		1461	<instanceof
		1462	value="org.eclipse.debug.core.ILaunchConfiguration">
		1463	</instanceof>
		1464	</and>
		1465	</enabledWhen>
		1466	</page>
1455	</extension>	1467	</extension>
1456	<!-- commands and their bindings	1468	<!-- commands and their bindings
1457	NOTE:	1469	NOTE:

Lines 731-736 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationsDialog.java (+11 lines)
731	return (AbstractLaunchConfigurationAction)fLaunchConfigurationView.getAction(DuplicateLaunchConfigurationAction.ID_DUPLICATE_ACTION);	731	return (AbstractLaunchConfigurationAction)fLaunchConfigurationView.getAction(DuplicateLaunchConfigurationAction.ID_DUPLICATE_ACTION);
732	}	732	}
733		733
		734	/**
		735	* returns the properties action
		736	* @return the 'Properties' action from the context menu of the launch view
		737	*
		738	* @since 3.3
		739	* EXPERIMENTAL
		740	*/
		741	protected IAction getPropertiesAction() {
		742	return fLaunchConfigurationView.getAction(LaunchConfigurationPropertiesAction.ID_PROPERTIES_ACTION);
		743	}
		744
734	/**	745	/**
735	* Gets the help context id	746	* Gets the help context id
736	*	747	*

Lines 1390-1399 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchManager.java (-12 / +34 lines)
1390	* without consulting with the Platform/Debug team.	1390	* without consulting with the Platform/Debug team.
1391	* </p>	1391	* </p>
1392	*/	1392	*/
1393	public LaunchDelegate[] getLaunchDelegates() {	1393	public ILaunchDelegate[] getLaunchDelegates() {
1394	initializeLaunchDelegates();	1394	initializeLaunchDelegates();
1395	Collection col = fLaunchDelegates.values();	1395	Collection col = fLaunchDelegates.values();
1396	return (LaunchDelegate[]) col.toArray(new LaunchDelegate[col.size()]);	1396	return (ILaunchDelegate[]) col.toArray(new ILaunchDelegate[col.size()]);
1397	}	1397	}
1398		1398
1399	/**	1399	/**
Lines 1421-1426 Link Here
1421	}	1421	}
1422		1422
1423	/**	1423	/**
		1424	* This method returns the <code>ILaunchDelegate</code> instance corresponding to the id
		1425	* of the launch delegate specified
		1426	* @param id the id of the <code>ILaunchDelegate</code> to find
		1427	* @return the <code>ILaunchDelegate</code> or <code>null</code> if not found
		1428	* @since 3.3
		1429	* EXPERIMENTAL
		1430	*/
		1431	public ILaunchDelegate getLaunchDelegate(String id) {
		1432	if(id != null) {
		1433	ILaunchDelegate[] delegates = getLaunchDelegates();
		1434	for(int i = 0; i < delegates.length; i++) {
		1435	if(id.equals(delegates[i].getId())) {
		1436	return delegates[i];
		1437	}
		1438	}
		1439	}
		1440	return null;
		1441	}
		1442
		1443	/**
1424	* Initializes the listing of delegates available to the launching framework	1444	* Initializes the listing of delegates available to the launching framework
1425	*	1445	*
1426	* <p>	1446	* <p>
Lines 2197-2214 Link Here
2197	for(Iterator iter = preferred.keySet().iterator(); iter.hasNext();) {	2217	for(Iterator iter = preferred.keySet().iterator(); iter.hasNext();) {
2198	modes = (Set) iter.next();	2218	modes = (Set) iter.next();
2199	delegate = (ILaunchDelegate) preferred.get(modes);	2219	delegate = (ILaunchDelegate) preferred.get(modes);
2200	child = doc.createElement(DELEGATE);	2220	if(delegate != null) {
2201	child.setAttribute(ID, delegate.getId());	2221	child = doc.createElement(DELEGATE);
2202	child.setAttribute(TYPEID, types[i].getIdentifier());	2222	child.setAttribute(ID, delegate.getId());
2203	for(Iterator iter2 = modes.iterator(); iter2.hasNext();) {	2223	child.setAttribute(TYPEID, types[i].getIdentifier());
2204	modestr += iter2.next();	2224	for(Iterator iter2 = modes.iterator(); iter2.hasNext();) {
2205	if(iter2.hasNext()) {	2225	modestr += iter2.next();
2206	modestr += ","; //$NON-NLS-1$	2226	if(iter2.hasNext()) {
		2227	modestr += ","; //$NON-NLS-1$
		2228	}
2207	}	2229	}
		2230	child.setAttribute(MODES, modestr);
		2231	modestr = EMPTY_STRING;
		2232	root.appendChild(child);
2208	}	2233	}
2209	child.setAttribute(MODES, modestr);
2210	modestr = EMPTY_STRING;
2211	root.appendChild(child);
2212	}	2234	}
2213	}	2235	}
2214	}	2236	}

Lines 15-20 Link Here

(-)ui/org/eclipse/debug/internal/ui/SWTUtil.java (+51 lines)
15	import org.eclipse.jface.dialogs.IDialogConstants;	15	import org.eclipse.jface.dialogs.IDialogConstants;
16	import org.eclipse.jface.resource.JFaceResources;	16	import org.eclipse.jface.resource.JFaceResources;
17	import org.eclipse.swt.SWT;	17	import org.eclipse.swt.SWT;
		18	import org.eclipse.swt.custom.CLabel;
18	import org.eclipse.swt.graphics.Font;	19	import org.eclipse.swt.graphics.Font;
19	import org.eclipse.swt.graphics.Image;	20	import org.eclipse.swt.graphics.Image;
20	import org.eclipse.swt.layout.GridData;	21	import org.eclipse.swt.layout.GridData;
Lines 59-64 Link Here
59	}	60	}
60	}	61	}
61		62
		63	/**
		64	* Creates a check box button using the parents' font
		65	* @param parent the parent to add the button to
		66	* @param label the label for the button
		67	* @param image the image for the button
		68	* @param checked the initial checked state of the button
		69	* @return a new checked button set to the initial checked state
		70	* @since 3.3
		71	*/
		72	public static Button createCheckButton(Composite parent, String label, Image image, boolean checked) {
		73	Button button = new Button(parent, SWT.CHECK);
		74	button.setFont(parent.getFont());
		75	button.setSelection(checked);
		76	if(image != null) {
		77	button.setImage(image);
		78	}
		79	if(label != null) {
		80	button.setText(label);
		81	}
		82	GridData gd = new GridData();
		83	button.setLayoutData(gd);
		84	setButtonDimensionHint(button);
		85	return button;
		86	}
62		87
63	/**	88	/**
64	* Creates and returns a new push button with the given	89	* Creates and returns a new push button with the given
Lines 166-171 Link Here
166	}	191	}
167		192
168	/**	193	/**
		194	* Creates a new <code>CLabel</code> that will wrap at the specified width and has the specified image
		195	* @param parent the parent to add this label to
		196	* @param text the text for the label
		197	* @param image the image for the label
		198	* @param hspan the h span to take up in the parent
		199	* @param wrapwidth the with to wrap at
		200	* @return a new <code>CLabel</code>
		201	* @since 3.3
		202	*/
		203	public static CLabel createWrapCLabel(Composite parent, String text, Image image, int hspan, int wrapwidth) {
		204	CLabel label = new CLabel(parent, SWT.NONE \| SWT.WRAP);
		205	label.setFont(parent.getFont());
		206	if(text != null) {
		207	label.setText(text);
		208	}
		209	if(image != null) {
		210	label.setImage(image);
		211	}
		212	GridData gd = new GridData(GridData.FILL_HORIZONTAL);
		213	gd.horizontalSpan = hspan;
		214	gd.widthHint = wrapwidth;
		215	label.setLayoutData(gd);
		216	return label;
		217	}
		218
		219	/**
169	* Creates a wrapping label	220	* Creates a wrapping label
170	* @param parent the parent composite to add this label to	221	* @param parent the parent composite to add this label to
171	* @param text the text to be displayed in the label	222	* @param text the text to be displayed in the label

Lines 137-142 Link Here

(-)ui/org/eclipse/debug/internal/ui/IInternalDebugUIConstants.java (-15 / +7 lines)
137	public static final String PREF_LAUNCH_PERSPECTIVES = IDebugUIConstants.PLUGIN_ID + ".PREF_LAUNCH_PERSPECTIVES"; //$NON-NLS-1$	137	public static final String PREF_LAUNCH_PERSPECTIVES = IDebugUIConstants.PLUGIN_ID + ".PREF_LAUNCH_PERSPECTIVES"; //$NON-NLS-1$
138		138
139	/**	139	/**
		140	* Represents the empty string
		141	* @since 3.3
		142	*/
		143	public static final String EMPTY_STRING = ""; //$NON-NLS-1$
		144
		145	/**
140	* Preference for enabling/disabling launch configuration filtering based on project accessibilty status	146	* Preference for enabling/disabling launch configuration filtering based on project accessibilty status
141	*	147	*
142	* @since 3.2	148	* @since 3.2
Lines 263-283 Link Here
263	* @since 3.1	269	* @since 3.1
264	*/	270	*/
265	public static final String PREF_MAX_DETAIL_LENGTH = IDebugUIConstants.PLUGIN_ID + ".max_detail_length"; //$NON-NLS-1$	271	public static final String PREF_MAX_DETAIL_LENGTH = IDebugUIConstants.PLUGIN_ID + ".max_detail_length"; //$NON-NLS-1$
266		272
267	/**
268	* Constant to describe the 'list' action for duplicate launch delegate resolution
269	* @since 3.3
270	* EXPERIMENTAL
271	*/
272	public static final String DELEGATE_ACTION_ID_LIST = "list"; //$NON-NLS-1$
273
274	/**
275	* Constant to describe the 'dialog' action for duplicate delegate resolution
276	* @since 3.3
277	* EXPERIMENTAL
278	*/
279	public static final String DELEGATE_ACTION_ID_DIALOG = "dialog"; //$NON-NLS-1$
280
281	/**	273	/**
282	* Font for Memory View	274	* Font for Memory View
283	*	275	*

Removed Link Here

(-)ui/org/eclipse/debug/internal/ui/preferences/LaunchDelegatesPreferencePage.java (-312 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.debug.internal.ui.preferences;
12
13	import java.util.HashMap;
14	import java.util.HashSet;
15	import java.util.Iterator;
16	import java.util.Map;
17	import java.util.Set;
18
19	import org.eclipse.core.runtime.CoreException;
20	import org.eclipse.debug.core.DebugPlugin;
21	import org.eclipse.debug.core.ILaunchConfigurationType;
22	import org.eclipse.debug.core.ILaunchDelegate;
23	import org.eclipse.debug.internal.core.LaunchManager;
24	import org.eclipse.debug.internal.ui.DebugUIPlugin;
25	import org.eclipse.debug.internal.ui.DefaultLabelProvider;
26	import org.eclipse.debug.internal.ui.IDebugHelpContextIds;
27	import org.eclipse.debug.internal.ui.SWTUtil;
28	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationPresentationManager;
29	import org.eclipse.jface.preference.PreferencePage;
30	import org.eclipse.jface.viewers.ArrayContentProvider;
31	import org.eclipse.jface.viewers.CheckStateChangedEvent;
32	import org.eclipse.jface.viewers.CheckboxTableViewer;
33	import org.eclipse.jface.viewers.ICheckStateListener;
34	import org.eclipse.jface.viewers.ISelectionChangedListener;
35	import org.eclipse.jface.viewers.IStructuredSelection;
36	import org.eclipse.jface.viewers.ITreeContentProvider;
37	import org.eclipse.jface.viewers.SelectionChangedEvent;
38	import org.eclipse.jface.viewers.TreeViewer;
39	import org.eclipse.jface.viewers.Viewer;
40	import org.eclipse.swt.SWT;
41	import org.eclipse.swt.layout.GridData;
42	import org.eclipse.swt.widgets.Composite;
43	import org.eclipse.swt.widgets.Control;
44	import org.eclipse.swt.widgets.Group;
45	import org.eclipse.swt.widgets.Table;
46	import org.eclipse.swt.widgets.Text;
47	import org.eclipse.swt.widgets.Tree;
48	import org.eclipse.ui.IWorkbench;
49	import org.eclipse.ui.IWorkbenchPreferencePage;
50	import org.eclipse.ui.PlatformUI;
51	import org.eclipse.ui.model.WorkbenchViewerComparator;
52
53	/**
54	* This class provides a preference page for selecting and changing preferred launch delegates for those of them
55	* that have conflicting delegates.
56	*
57	* Delegates are considered to be conflicting if they are for the same launc configuraiton type, and apply to the same
58	* mode sets.
59	*
60	* @since 3.3
61	*
62	* TODO create a help topic for this page....it needs a good description
63	*
64	* EXPERIMENTAL
65	*/
66	public class LaunchDelegatesPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {
67
68	/**
69	* Class to collect and persist attributes to sufficiently describe a dupicate launch delegate
70	*/
71	class DuplicateDelegate {
72	private ILaunchConfigurationType fType = null;
73	private ILaunchDelegate[] fDelegates = null;
74	private Set fModes = null;
75
76	public DuplicateDelegate(ILaunchConfigurationType type, ILaunchDelegate[] delegates, Set modes) {
77	fModes = modes;
78	fType = type;
79	fDelegates = delegates;
80	}
81
82	public ILaunchConfigurationType getType() {
83	return fType;
84	}
85	public ILaunchDelegate[] getDelegates() {
86	return fDelegates;
87	}
88	public Set getModeSet() {
89	return fModes;
90	}
91	}
92
93	/**
94	* label provider to extend the default one, provides labels to both the tree and table of this page
95	*/
96	class LabelProvider extends DefaultLabelProvider {
97	public String getText(Object element) {
98	if(element instanceof ILaunchConfigurationType) {
99	return super.getText(element);
100	}
101	else if(element instanceof DuplicateDelegate) {
102	DuplicateDelegate dd = (DuplicateDelegate) element;
103	return LaunchConfigurationPresentationManager.getDefault().getLaunchModeNames(dd.getModeSet()).toString();
104	}
105	else if(element instanceof ILaunchDelegate){
106	return ((ILaunchDelegate) element).getName();
107	}
108	return element.toString();
109	}
110	}
111
112	/**
113	* This class is used to provide content to the tree
114	*/
115	class TreeProvider implements ITreeContentProvider {
116	public Object[] getChildren(Object parentElement) {
117	if(parentElement instanceof ILaunchConfigurationType) {
118	ILaunchConfigurationType type = (ILaunchConfigurationType) parentElement;
119	Set dupes = (Set) fDuplicates.get(type);
120	if(dupes != null) {
121	return dupes.toArray();
122	}
123	return null;
124	}
125	return null;
126	}
127	public boolean hasChildren(Object element) {
128	return element instanceof ILaunchConfigurationType;
129	}
130	public Object[] getElements(Object inputElement) {
131	if(inputElement instanceof Map) {
132	return ((Map)inputElement).keySet().toArray();
133	}
134	return null;
135	}
136	public Object getParent(Object element) {return null;}
137	public void dispose() {}
138	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {}
139	}
140
141	private TreeViewer fTreeViewer = null;
142	private CheckboxTableViewer fTableViewer = null;
143	private Map fDuplicates = null;
144	private Map fDupeSelections = null;
145	private boolean fDirty = false;
146	private Text fDescription = null;
147
148	/**
149	* Constructor
150	*/
151	public LaunchDelegatesPreferencePage() {
152	setTitle(DebugPreferencesMessages.LaunchDelegatesPreferencePage_0);
153	}
154
155	/**
156	* @see org.eclipse.jface.preference.PreferencePage#createControl(org.eclipse.swt.widgets.Composite)
157	*/
158	public void createControl(Composite parent) {
159	super.createControl(parent);
160	PlatformUI.getWorkbench().getHelpSystem().setHelp(getControl(), IDebugHelpContextIds.LAUNCH_DELEGATES_PREFERENCE_PAGE);
161	}
162
163	/**
164	* @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
165	*/
166	protected Control createContents(Composite parent) {
167	Composite comp = SWTUtil.createComposite(parent, 2, 1, GridData.FILL_BOTH);
168	SWTUtil.createWrapLabel(comp, DebugPreferencesMessages.LaunchDelegatesPreferencePage_1, 2, 300);
169
170	SWTUtil.createVerticalSpacer(comp, 1);
171	//tree
172	Composite comp1 = SWTUtil.createComposite(comp, 1, 1, GridData.FILL_VERTICAL);
173	SWTUtil.createLabel(comp1, DebugPreferencesMessages.LaunchDelegatesPreferencePage_2, 1);
174	Tree tree = new Tree(comp1, SWT.BORDER \| SWT.H_SCROLL \| SWT.V_SCROLL \| SWT.SINGLE);
175	GridData gd = new GridData(GridData.FILL_BOTH);
176	gd.grabExcessHorizontalSpace = false;
177	tree.setLayoutData(gd);
178	fTreeViewer = new TreeViewer(tree);
179	fTreeViewer.setComparator(new WorkbenchViewerComparator());
180	fTreeViewer.setContentProvider(new TreeProvider());
181	fTreeViewer.setLabelProvider(new LabelProvider());
182	fTreeViewer.setInput(fDuplicates);
183	fTreeViewer.expandToLevel(2);
184	fTreeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
185	public void selectionChanged(SelectionChangedEvent event) {
186	Object obj = ((IStructuredSelection) event.getSelection()).getFirstElement();
187	if(obj instanceof DuplicateDelegate) {
188	fTableViewer.setAllChecked(false);
189	DuplicateDelegate dd = (DuplicateDelegate) obj;
190	fTableViewer.setInput(dd.getDelegates());
191	obj = fDupeSelections.get(dd);
192	if(obj != null) {
193	fTableViewer.setChecked(obj, true);
194	}
195	}
196	else {
197	fTableViewer.setInput(null);
198	}
199	}
200	});
201
202	//table
203	Composite comp2 = SWTUtil.createComposite(comp, comp.getFont(), 1, 1, GridData.FILL_BOTH);
204	SWTUtil.createLabel(comp2, DebugPreferencesMessages.LaunchDelegatesPreferencePage_3, 1);
205	Table table = new Table(comp2, SWT.BORDER \| SWT.H_SCROLL \| SWT.V_SCROLL \| SWT.CHECK \| SWT.SINGLE);
206	table.setLayoutData(new GridData(GridData.FILL_BOTH));
207	fTableViewer = new CheckboxTableViewer(table);
208	fTableViewer.setComparator(new WorkbenchViewerComparator());
209	fTableViewer.setLabelProvider(new LabelProvider());
210	fTableViewer.setContentProvider(new ArrayContentProvider());
211	fTableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
212	public void selectionChanged(SelectionChangedEvent event) {
213	IStructuredSelection ss = (IStructuredSelection) event.getSelection();
214	if(ss != null && !ss.isEmpty()) {
215	fDescription.setText(((ILaunchDelegate)ss.getFirstElement()).getDescription());
216	}
217	else {
218	fDescription.setText(""); //$NON-NLS-1$
219	}
220	}
221	});
222	fTableViewer.addCheckStateListener(new ICheckStateListener() {
223	public void checkStateChanged(CheckStateChangedEvent event) {
224	fDirty = true;
225	Object element = event.getElement();
226	boolean checked = event.getChecked();
227	fTableViewer.setAllChecked(false);
228	//always set checked, this way users cannot 'undo' a change to selecting a preferred delegate
229	//The story for this is that on startup if there are dupes, the user is prompted to pick a delegate, after that they cannot
230	//return to a state of not being able to launch something, but can pick a different delegate
231	fTableViewer.setChecked(element, true);
232	//persist the selection
233	Object obj = ((IStructuredSelection) fTreeViewer.getSelection()).getFirstElement();
234	if(obj instanceof DuplicateDelegate) {
235	fDupeSelections.remove(obj);
236	if(checked) {
237	fDupeSelections.put(obj, element);
238	}
239	}
240	}
241	});
242	Group group = SWTUtil.createGroup(comp, DebugPreferencesMessages.LaunchDelegatesPreferencePage_4, 1, 2, GridData.FILL_BOTH);
243	fDescription = SWTUtil.createText(group, SWT.WRAP \| SWT.READ_ONLY, 1, GridData.FILL_BOTH);
244	fDescription.setBackground(group.getBackground());
245	return comp;
246	}
247
248	/**
249	* @see org.eclipse.jface.preference.PreferencePage#performOk()
250	*/
251	public boolean performOk() {
252	if(fDirty && fDupeSelections != null && fDupeSelections.size() > 0) {
253	fDirty = false;
254	DuplicateDelegate dd = null;
255	ILaunchDelegate delegate = null;
256	for(Iterator iter = fDupeSelections.keySet().iterator(); iter.hasNext();) {
257	dd = (DuplicateDelegate) iter.next();
258	delegate = (ILaunchDelegate) fDupeSelections.get(dd);
259	try {
260	dd.getType().setPreferredDelegate(dd.getModeSet(), delegate);
261	}
262	catch (CoreException e) {DebugUIPlugin.log(e);}
263	}
264	}
265	if(getPreferenceStore().needsSaving()) {
266	DebugUIPlugin.getDefault().savePluginPreferences();
267	}
268	return super.performOk();
269	}
270
271	/**
272	* @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)
273	*/
274	public void init(IWorkbench workbench) {
275	//init a listing of duplicate delegates arranged by type
276	try {
277	setPreferenceStore(DebugUIPlugin.getDefault().getPreferenceStore());
278	LaunchManager lm = (LaunchManager) DebugPlugin.getDefault().getLaunchManager();
279	ILaunchConfigurationType[] types = lm.getLaunchConfigurationTypes();
280	fDuplicates = new HashMap();
281	fDupeSelections = new HashMap();
282	Set modes = null;
283	ILaunchDelegate[] delegates = null;
284	Set modeset = null;
285	Set tmp = null;
286	ILaunchDelegate prefdelegate = null;
287	DuplicateDelegate dd = null;
288	for(int i = 0; i < types.length; i++) {
289	modes = types[i].getSupportedModeCombinations();
290	for(Iterator iter = modes.iterator(); iter.hasNext();) {
291	modeset = (Set) iter.next();
292	delegates = types[i].getDelegates(modeset);
293	if(delegates.length > 1) {
294	tmp = (Set) fDuplicates.get(types[i]);
295	if(tmp == null) {
296	tmp = new HashSet();
297	}
298	dd = new DuplicateDelegate(types[i], delegates, modeset);
299	tmp.add(dd);
300	fDuplicates.put(types[i], tmp);
301	prefdelegate = types[i].getPreferredDelegate(modeset);
302	if(prefdelegate != null) {
303	fDupeSelections.put(dd, prefdelegate);
304	}
305	}
306	}
307	}
308	}
309	catch(CoreException e) {DebugUIPlugin.log(e);}
310	}
311
312	}

Lines 195-200 Link Here

(-)core/org/eclipse/debug/core/ILaunchConfigurationWorkingCopy.java (+16 lines)
195	public void setModes(Set modes);	195	public void setModes(Set modes);
196		196
197	/**	197	/**
		198	* Set the preferred launch delegates' id for the given mode set. Passing in <code>null</code> as a delegate
		199	* id will cause the mapping for the specified mode set (if any) to be removed
		200	* @param modes the set of modes to set this delegate id for
		201	* @param delegateId the id of the delegate to associate as preferred for the specified mode set
		202	*
		203	* <p>
		204	* <strong>EXPERIMENTAL</strong>. This method has been added as
		205	* part of a work in progress. There is no guarantee that this API will
		206	* remain unchanged during the 3.3 release cycle. Please do not use this API
		207	* without consulting with the Platform/Debug team.
		208	* </p>
		209	* @since 3.3
		210	*/
		211	public void setPreferredLaunchDelegate(Set modes, String delegateId);
		212
		213	/**
198	* Adds the specified launch modes to this configuration's settings.	214	* Adds the specified launch modes to this configuration's settings.
199	* <p>	215	* <p>
200	* Setting launch modes on a configuration allows the configuration to	216	* Setting launch modes on a configuration allows the configuration to

Lines 17-22 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchConfigurationWorkingCopy.java (-4 / +29 lines)
17	import java.io.IOException;	17	import java.io.IOException;
18	import java.io.UnsupportedEncodingException;	18	import java.io.UnsupportedEncodingException;
19	import java.util.ArrayList;	19	import java.util.ArrayList;
		20	import java.util.HashMap;
20	import java.util.List;	21	import java.util.List;
21	import java.util.Map;	22	import java.util.Map;
22	import java.util.Set;	23	import java.util.Set;
Lines 408-425 Link Here
408	/**	409	/**
409	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#setModes(java.util.Set)	410	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#setModes(java.util.Set)
410	*/	411	*/
411	public void setModes(Set options) {	412	public void setModes(Set modes) {
412	getInfo().setAttribute(ATTR_LAUNCH_MODES, (options.size() > 0 ? options : null));	413	getInfo().setAttribute(ATTR_LAUNCH_MODES, (modes.size() > 0 ? modes : null));
413	setDirty();	414	setDirty();
414	}	415	}
415		416
416	/**	417	/**
417	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#addModes(java.util.Set)	418	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#addModes(java.util.Set)
418	*/	419	*/
419	public void addModes(Set options) {	420	public void addModes(Set modes) {
420	try {	421	try {
421	Set opts = getModes();	422	Set opts = getModes();
422	if(opts.addAll(options)) {	423	if(opts.addAll(modes)) {
423	getInfo().setAttribute(ATTR_LAUNCH_MODES, opts);	424	getInfo().setAttribute(ATTR_LAUNCH_MODES, opts);
424	setDirty();	425	setDirty();
425	}	426	}
Lines 611-615 Link Here
611	setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_TYPES, types);	612	setAttribute(LaunchConfiguration.ATTR_MAPPED_RESOURCE_TYPES, types);
612	}	613	}
613		614
		615	/**
		616	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#setPreferredLaunchDelegate(java.util.Set, java.lang.String)
		617	*/
		618	public void setPreferredLaunchDelegate(Set modes, String delegateId) {
		619	if(modes != null) {
		620	try {
		621	Map delegates = getAttribute(ILaunchConfiguration.ATTR_PREFERRED_LAUNCHERS, (Map)null);
		622	//copy map to avoid pointer issues
		623	Map map = new HashMap();
		624	if(delegates != null) {
		625	map.putAll(delegates);
		626	}
		627	if(delegateId == null) {
		628	map.remove(modes.toString());
		629	}
		630	else {
		631	map.put(modes.toString(), delegateId);
		632	}
		633	setAttribute(ILaunchConfiguration.ATTR_PREFERRED_LAUNCHERS, map);
		634	}
		635	catch (CoreException ce) {DebugPlugin.log(ce);}
		636	}
		637	}
		638
614	}	639	}
615		640