org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/LaunchersPreferencePage.java - gerrit/platform/eclipse.platform.debug - Git at Google

 /*******************************************************************************
  * Copyright (c) 2006, 2009 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.IInternalDebugCoreConstants;
 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.SWTFactory;
 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.StructuredSelection;
 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 launch configuration type, and apply to the same
  * mode sets.
  *
  * @since 3.3
  */
 public class LaunchersPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {

 	/**
 	 * Class to collect and persist attributes to sufficiently describe a duplicate 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 = SWTFactory.createComposite(parent, 2, 1, GridData.FILL_BOTH);
 		SWTFactory.createWrapLabel(comp, DebugPreferencesMessages.LaunchDelegatesPreferencePage_1, 2, 300);

 		boolean enabled = fDuplicates.size() > 0;
 		if(!enabled) {
 			SWTFactory.createVerticalSpacer(comp, 1);
 			SWTFactory.createWrapLabel(comp, DebugPreferencesMessages.LaunchersPreferencePage_0, 2, 300);
 		}

 		SWTFactory.createVerticalSpacer(comp, 1);
 	//tree
 		Composite comp1 = SWTFactory.createComposite(comp, 1, 1, GridData.FILL_VERTICAL);
 		SWTFactory.createLabel(comp1, DebugPreferencesMessages.LaunchDelegatesPreferencePage_2, 1);
 		Tree tree = new Tree(comp1, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.SINGLE);
 		tree.setEnabled(enabled);
 		tree.setFont(parent.getFont());
 		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());
 					fTableViewer.setSelection(null);
 					obj = fDupeSelections.get(dd);
 					if(obj != null) {
 						fTableViewer.setChecked(obj, true);
 						fTableViewer.setSelection(new StructuredSelection(obj));
 					}
 				}
 				else {
 					fTableViewer.setInput(null);
 				}
 			}
 		});

 	//table
 		Composite comp2 = SWTFactory.createComposite(comp, comp.getFont(), 1, 1, GridData.FILL_BOTH);
 		SWTFactory.createLabel(comp2, DebugPreferencesMessages.LaunchDelegatesPreferencePage_3, 1);
 		Table table = new Table(comp2, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.CHECK | SWT.SINGLE);
 		table.setEnabled(enabled);
 		table.setLayoutData(new GridData(GridData.FILL_BOTH));
 		table.setFont(parent.getFont());
 		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()) {
 					ILaunchDelegate delegate = (ILaunchDelegate)ss.getFirstElement();
 					fDescription.setText(delegate.getDescription());
 				}
 				else {
 					fDescription.setText(IInternalDebugCoreConstants.EMPTY_STRING);
 				}
 			}
 		});
 		fTableViewer.addCheckStateListener(new ICheckStateListener() {
 			public void checkStateChanged(CheckStateChangedEvent event) {
 				fDirty = true;
 				Object element = event.getElement();
 				boolean checked = event.getChecked();
 				//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.setCheckedElements(new Object[] {element});
 				//set the selection to be the checked element
 				//https://bugs.eclipse.org/bugs/show_bug.cgi?id=233233
 				fTableViewer.setSelection(new StructuredSelection(element));
 				//persist the selection
 				Object obj = ((IStructuredSelection) fTreeViewer.getSelection()).getFirstElement();
 				if(obj instanceof DuplicateDelegate) {
 					fDupeSelections.remove(obj);
 					if(checked) {
 						fDupeSelections.put(obj, element);
 					}
 				}
 			}
 		});
 		Group group = SWTFactory.createGroup(comp, DebugPreferencesMessages.LaunchDelegatesPreferencePage_4, 1, 2, GridData.FILL_BOTH);
 		fDescription = SWTFactory.createText(group, SWT.WRAP | SWT.READ_ONLY, 1, GridData.FILL_BOTH);
 		fDescription.setEnabled(enabled);
 		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);}
 			}
 		}
 		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);}
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2006, 2009 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.IInternalDebugCoreConstants;
	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.SWTFactory;
	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.StructuredSelection;
	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 launch configuration type, and apply to the same
	* mode sets.
	*
	* @since 3.3
	*/
	public class LaunchersPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {

	/**
	* Class to collect and persist attributes to sufficiently describe a duplicate 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 = SWTFactory.createComposite(parent, 2, 1, GridData.FILL_BOTH);
	SWTFactory.createWrapLabel(comp, DebugPreferencesMessages.LaunchDelegatesPreferencePage_1, 2, 300);

	boolean enabled = fDuplicates.size() > 0;
	if(!enabled) {
	SWTFactory.createVerticalSpacer(comp, 1);
	SWTFactory.createWrapLabel(comp, DebugPreferencesMessages.LaunchersPreferencePage_0, 2, 300);
	}

	SWTFactory.createVerticalSpacer(comp, 1);
	//tree
	Composite comp1 = SWTFactory.createComposite(comp, 1, 1, GridData.FILL_VERTICAL);
	SWTFactory.createLabel(comp1, DebugPreferencesMessages.LaunchDelegatesPreferencePage_2, 1);
	Tree tree = new Tree(comp1, SWT.BORDER \| SWT.H_SCROLL \| SWT.V_SCROLL \| SWT.SINGLE);
	tree.setEnabled(enabled);
	tree.setFont(parent.getFont());
	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());
	fTableViewer.setSelection(null);
	obj = fDupeSelections.get(dd);
	if(obj != null) {
	fTableViewer.setChecked(obj, true);
	fTableViewer.setSelection(new StructuredSelection(obj));
	}
	}
	else {
	fTableViewer.setInput(null);
	}
	}
	});

	//table
	Composite comp2 = SWTFactory.createComposite(comp, comp.getFont(), 1, 1, GridData.FILL_BOTH);
	SWTFactory.createLabel(comp2, DebugPreferencesMessages.LaunchDelegatesPreferencePage_3, 1);
	Table table = new Table(comp2, SWT.BORDER \| SWT.H_SCROLL \| SWT.V_SCROLL \| SWT.CHECK \| SWT.SINGLE);
	table.setEnabled(enabled);
	table.setLayoutData(new GridData(GridData.FILL_BOTH));
	table.setFont(parent.getFont());
	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()) {
	ILaunchDelegate delegate = (ILaunchDelegate)ss.getFirstElement();
	fDescription.setText(delegate.getDescription());
	}
	else {
	fDescription.setText(IInternalDebugCoreConstants.EMPTY_STRING);
	}
	}
	});
	fTableViewer.addCheckStateListener(new ICheckStateListener() {
	public void checkStateChanged(CheckStateChangedEvent event) {
	fDirty = true;
	Object element = event.getElement();
	boolean checked = event.getChecked();
	//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.setCheckedElements(new Object[] {element});
	//set the selection to be the checked element
	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=233233
	fTableViewer.setSelection(new StructuredSelection(element));
	//persist the selection
	Object obj = ((IStructuredSelection) fTreeViewer.getSelection()).getFirstElement();
	if(obj instanceof DuplicateDelegate) {
	fDupeSelections.remove(obj);
	if(checked) {
	fDupeSelections.put(obj, element);
	}
	}
	}
	});
	Group group = SWTFactory.createGroup(comp, DebugPreferencesMessages.LaunchDelegatesPreferencePage_4, 1, 2, GridData.FILL_BOTH);
	fDescription = SWTFactory.createText(group, SWT.WRAP \| SWT.READ_ONLY, 1, GridData.FILL_BOTH);
	fDescription.setEnabled(enabled);
	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);}
	}
	}
	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);}
	}

	}