Attachment #55420 for bug #74480

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




import java.util.Map;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.debug.core.model.IPersistableSourceLocator;

	 */
	public void removeLaunchListener(ILaunchListener listener);
	
	/**
	 * Sets the given launch configuration as the default configuration for the specified
	 * resource. There is only one default configuration per resource and this replaces
	 * any previously existing launch configuration for the resource, if any. Specifying
	 * a configuration of <code>null</code> clears the default configuration for the
	 * given resource. 
	 * 
	 * @param resource resource
	 * @param configuration launch configuration or <code>null</code>
	 * @exception CoreException if unable to set as default
	 * @since 3.3
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 */
	public void setDefaultConfiguration(IResource resource, ILaunchConfiguration configuration) throws CoreException;
	
	/**
	 * Returns the default launch configuration for the specified resource, or <code>null</code>
	 * if none.
	 * 
	 * @param configuration launch configuration
	 * @return launch configuration or <code>null</code>
	 * @exception CoreException if an error occurs retrieving the configuration
	 * @since 3.3
	 * <p>
	 * <strong>EXPERIMENTAL</strong>. This method has been added as
	 * part of a work in progress. There is no guarantee that this API will
	 * remain unchanged during the 3.3 release cycle. Please do not use this API
	 * without consulting with the Platform/Debug team.
	 * </p>
	 */
	public ILaunchConfiguration getDefaultConfiguration(IResource resource) throws CoreException;
}



Lines 50-56 Link Here

(-)core/org/eclipse/debug/core/ILaunchConfigurationWorkingCopy.java (-1 / +45 lines)
50	* a handle to the resulting launch configuration.	50	* a handle to the resulting launch configuration.
51	* Has no effect if this configuration does not need saving.	51	* Has no effect if this configuration does not need saving.
52	* Creates the underlying file if not yet created.	52	* Creates the underlying file if not yet created.
53	*	53	* <p>
		54	* <strong>EXPERIMENTAL</strong> - Since 3.3, if this is a nested
		55	* working copy, the contents of this working copy are saved to the
		56	* parent working copy and the parent working copy is returned without
		57	* effecting the original launch configuration.
		58	* </p>
54	* @exception CoreException if an exception occurs while	59	* @exception CoreException if an exception occurs while
55	* writing this configuration to its underlying file.	60	* writing this configuration to its underlying file.
56	*/	61	*/
Lines 247-250 Link Here
247	* @since 3.3	252	* @since 3.3
248	*/	253	*/
249	public void removeModes(Set modes);	254	public void removeModes(Set modes);
		255
		256	/**
		257	* Returns a working copy of this working copy. Changes to the working copy will
		258	* be applied to this working copy when saved. The working copy will
		259	* refer to this launch configuration as its parent. Changes are only
		260	* saved to the underlying original configuration when the root working
		261	* copy is saved.
		262	*
		263	* @return a working copy of this working copy
		264	* @exception CoreException if this method fails. Reasons include:
		265	* <ul>
		266	* <li>An exception occurs while initializing the contents of the
		267	* working copy from this configuration's underlying storage.</li>
		268	* </ul>
		269	* @see ILaunchConfigurationWorkingCopy#getOriginal()
		270	* @see ILaunchConfigurationWorkingCopy#getParent()
		271	* @since 3.3
		272	* <p>
		273	* <strong>EXPERIMENTAL</strong>. This method has been added as
		274	* part of a work in progress. There is no guarantee that this API will
		275	* remain unchanged during the 3.3 release cycle. Please do not use this API
		276	* without consulting with the Platform/Debug team.
		277	* </p>
		278	*/
		279	public ILaunchConfigurationWorkingCopy getNestedWorkingCopy() throws CoreException;
		280
		281	/**
		282	* Returns the parent of this working copy or <code>null</code> if this working
		283	* copy is not a nested copy of another working copy.
		284	*
		285	* @return parent or <code>null</code>
		286	* <p>
		287	* <strong>EXPERIMENTAL</strong>. This method has been added as
		288	* part of a work in progress. There is no guarantee that this API will
		289	* remain unchanged during the 3.3 release cycle. Please do not use this API
		290	* without consulting with the Platform/Debug team.
		291	* </p>
		292	*/
		293	public ILaunchConfigurationWorkingCopy getParent();
250	}	294	}




import org.eclipse.core.resources.IResourceDeltaVisitor;
import org.eclipse.core.resources.IResourceProxy;
import org.eclipse.core.resources.IResourceProxyVisitor;
import org.eclipse.core.resources.ProjectScope;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.PlatformObject;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.core.variables.VariablesPlugin;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.DebugPlugin;

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

import org.eclipse.debug.internal.core.sourcelookup.SourceContainerType;
import org.eclipse.debug.internal.core.sourcelookup.SourcePathComputer;
import org.eclipse.osgi.service.environment.Constants;
import org.osgi.service.prefs.BackingStoreException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

	
	
	/**
	 * 
	 */
	private static final String DEFAULT_CONFIGURATION = "defaultConfiguration";
	/**
	 * Constants for xml node names
	 * 
	 * @since 3.3

            }
        }
        return title;
    }

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchManager#getDefaultConfiguration(org.eclipse.core.resources.IResource)
	 */
	public ILaunchConfiguration getDefaultConfiguration(IResource resource) throws CoreException {
		IProject project = resource.getProject();
		if (project != null) {
			org.osgi.service.prefs.Preferences projectNode = getProjectNode(resource);
			String configValue = projectNode.get(DEFAULT_CONFIGURATION, null);
			if (configValue != null) {
				// shared config
				IFile file = project.getFile(Path.fromPortableString(configValue));
				return getLaunchConfiguration(file);
			} else {
				org.osgi.service.prefs.Preferences instanceNode = getInstanceNode(resource);
				configValue = instanceNode.get(DEFAULT_CONFIGURATION, null);
				if (configValue != null) {
					// local config
					return getLaunchConfiguration(configValue);
				}
			}
		}
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.ILaunchManager#setDefaultConfiguration(org.eclipse.core.resources.IResource, org.eclipse.debug.core.ILaunchConfiguration)
	 */
	public void setDefaultConfiguration(IResource resource, ILaunchConfiguration configuration) throws CoreException {
		IProject project = resource.getProject();
		if (project == null) {
			throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(),
					DebugPlugin.INTERNAL_ERROR, "Illegal argument: can only set default launch configuration on and within projects.", null));
		}
		if (configuration != null && !configuration.isLocal()) {
			if (!configuration.getFile().getProject().equals(project)) {
				throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(),
						DebugPlugin.INTERNAL_ERROR, "A shared launch configuration must be shared in same project that it is a default configuration for.", null));
			}
		}
		
		// remove previous settings, if any
		org.osgi.service.prefs.Preferences projectNode = getProjectNode(resource);
		projectNode.remove(DEFAULT_CONFIGURATION);
		flush(projectNode);
		org.osgi.service.prefs.Preferences instanceNode = getInstanceNode(resource);
		instanceNode.remove(DEFAULT_CONFIGURATION);
		flush(instanceNode);
		
		if (configuration != null) {
			org.osgi.service.prefs.Preferences node = null;
			String configurationValue = null;
			if (configuration.isLocal()) {
				// for local configurations, use workspace (instance) scope preferences
				node = instanceNode;
				if (configuration.isWorkingCopy()) {
					configurationValue = ((ILaunchConfigurationWorkingCopy)configuration).getOriginal().getMemento();
				} else {
					configurationValue = configuration.getMemento();
				}
			} else {
				// for shared configurations, use project scope preferences
				node = projectNode;
				configurationValue = configuration.getFile().getProjectRelativePath().toPortableString();
			}
			node.put(DEFAULT_CONFIGURATION, configurationValue);
			flush(node);
		}
		
	}	
	
	private void flush(org.osgi.service.prefs.Preferences node) {
		try {
			node.flush();
		} catch (BackingStoreException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	private org.osgi.service.prefs.Preferences getProjectNode(IResource resource) {
		org.osgi.service.prefs.Preferences node = Platform.getPreferencesService().getRootNode();
		ProjectScope scope = new ProjectScope(resource.getProject());
		node = scope.getNode(DebugPlugin.getUniqueIdentifier());
		IProject project = resource.getProject();
		if (!resource.equals(project)) {
			node = node.node(resource.getProjectRelativePath().toString());
		}
		return node;
	}
	
	private org.osgi.service.prefs.Preferences getInstanceNode(IResource resource) {
		org.osgi.service.prefs.Preferences node = Platform.getPreferencesService().getRootNode();
		node = node.node(InstanceScope.SCOPE).node(DebugPlugin.getUniqueIdentifier());
		return node.node(resource.getFullPath().makeRelative().toString());
	}
}

Lines 87-92 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchConfigurationWorkingCopy.java (-25 / +79 lines)
87	private IContainer fContainer;	87	private IContainer fContainer;
88		88
89	/**	89	/**
		90	* Parent working copy.
		91	* @since 3.3
		92	*/
		93	private LaunchConfigurationWorkingCopy fParent = null;
		94
		95	/**
90	* Constructs a working copy of the specified launch	96	* Constructs a working copy of the specified launch
91	* configuration.	97	* configuration.
92	*	98	*
Lines 104-109 Link Here
104	}	110	}
105		111
106	/**	112	/**
		113	* Constructs a working copy of the specified launch configuration as its parent.
		114	*
		115	* @param parent launch configuration to make
		116	* a working copy of
		117	* @exception CoreException if unable to initialize this
		118	* working copy's attributes based on the original configuration
		119	*/
		120	protected LaunchConfigurationWorkingCopy(LaunchConfigurationWorkingCopy parent) throws CoreException {
		121	super(parent.getLocation());
		122	setName(parent.getName());
		123	copyFrom(parent);
		124	setOriginal((LaunchConfiguration) parent.getOriginal());
		125	fParent = parent;
		126	fSuppressChange = false;
		127	}
		128
		129	/**
107	* Constructs a copy of the specified launch	130	* Constructs a copy of the specified launch
108	* configuration, with the given (new) name.	131	* configuration, with the given (new) name.
109	*	132	*
Lines 150-184 Link Here
150	* @see ILaunchConfigurationWorkingCopy#doSave()	173	* @see ILaunchConfigurationWorkingCopy#doSave()
151	*/	174	*/
152	public synchronized ILaunchConfiguration doSave() throws CoreException {	175	public synchronized ILaunchConfiguration doSave() throws CoreException {
153	if (isDirty()) {	176	if (fParent == null) {
154	boolean useRunnable= true;	177	if (isDirty()) {
155	if (isLocal()) {	178	boolean useRunnable= true;
156	if (isMoved()) {	179	if (isLocal()) {
157	// If this config was moved from a shared location, saving	180	if (isMoved()) {
158	// it will delete the original from the workspace. Use runnable.	181	// If this config was moved from a shared location, saving
159	useRunnable= !isNew() && !getOriginal().isLocal();	182	// it will delete the original from the workspace. Use runnable.
		183	useRunnable= !isNew() && !getOriginal().isLocal();
		184	} else {
		185	useRunnable= false;
		186	}
		187	}
		188
		189	if (useRunnable) {
		190	IWorkspaceRunnable wr = new IWorkspaceRunnable() {
		191	public void run(IProgressMonitor pm) throws CoreException {
		192	doSave0();
		193	}
		194	};
		195
		196	ResourcesPlugin.getWorkspace().run(wr, null, 0, null);
160	} else {	197	} else {
161	useRunnable= false;	198	//file is persisted in the metadata not the workspace
		199	doSave0();
162	}	200	}
		201
		202	getLaunchManager().setMovedFromTo(null, null);
163	}	203	}
164		204
165	if (useRunnable) {	205	return new LaunchConfiguration(getLocation());
166	IWorkspaceRunnable wr = new IWorkspaceRunnable() {	206	} else {
167	public void run(IProgressMonitor pm) throws CoreException {	207	// save to parent working copy
168	doSave0();	208	fParent.setName(getName());
169	}	209	fParent.copyFrom(this);
170	};	210	return fParent;
171
172	ResourcesPlugin.getWorkspace().run(wr, null, 0, null);
173	} else {
174	//file is persisted in the metadata not the workspace
175	doSave0();
176	}
177
178	getLaunchManager().setMovedFromTo(null, null);
179	}	211	}
180
181	return new LaunchConfiguration(getLocation());
182	}	212	}
183		213
184		214
Lines 635-640 Link Here
635	catch (CoreException ce) {DebugPlugin.log(ce);}	665	catch (CoreException ce) {DebugPlugin.log(ce);}
636	}	666	}
637	}	667	}
		668
		669	/* (non-Javadoc)
		670	* @see org.eclipse.debug.internal.core.LaunchConfiguration#getWorkingCopy()
		671	*/
		672	public ILaunchConfigurationWorkingCopy getWorkingCopy() throws CoreException {
		673	if (fParent == null) {
		674	return super.getWorkingCopy();
		675	} else {
		676	return getNestedWorkingCopy();
		677	}
		678	}
638		679
		680	/* (non-Javadoc)
		681	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#getNestedWorkingCopy()
		682	*/
		683	public ILaunchConfigurationWorkingCopy getNestedWorkingCopy() throws CoreException {
		684	return new LaunchConfigurationWorkingCopy(this);
		685	}
		686
		687	/* (non-Javadoc)
		688	* @see org.eclipse.debug.core.ILaunchConfigurationWorkingCopy#getParent()
		689	*/
		690	public ILaunchConfigurationWorkingCopy getParent() {
		691	return fParent;
		692	}
639	}	693	}
640		694

Lines 115-120 Link Here

(-)ui/org/eclipse/debug/internal/ui/IDebugHelpContextIds.java (+1 lines)
115	// Property pages	115	// Property pages
116	public static final String PROCESS_PROPERTY_PAGE = PREFIX + "process_property_page_context"; //$NON-NLS-1$	116	public static final String PROCESS_PROPERTY_PAGE = PREFIX + "process_property_page_context"; //$NON-NLS-1$
117	public static final String PROCESS_PAGE_RUN_AT = PREFIX + "process_page_run_at_time_widget"; //$NON-NLS-1$	117	public static final String PROCESS_PAGE_RUN_AT = PREFIX + "process_page_run_at_time_widget"; //$NON-NLS-1$
		118	public static final String EXECUTION_PROPERTY_PAGE = PREFIX + "execution_property_page"; //$NON-NLS-1$
118		119
119	// Launch configuration dialog pages	120	// Launch configuration dialog pages
120	public static final String LAUNCH_CONFIGURATION_DIALOG_COMMON_TAB = PREFIX + "launch_configuration_dialog_common_tab"; //$NON-NLS-1$	121	public static final String LAUNCH_CONFIGURATION_DIALOG_COMMON_TAB = PREFIX + "launch_configuration_dialog_common_tab"; //$NON-NLS-1$

Lines 1394-1399 Link Here

(-)plugin.xml (+7 lines)
1394	</or>	1394	</or>
1395	</enabledWhen>	1395	</enabledWhen>
1396	</page>	1396	</page>
		1397	<page
		1398	adaptable="true"
		1399	class="org.eclipse.debug.internal.ui.launchConfigurations.properties.ExecutionPropertiesPage"
		1400	id="org.eclipse.debug.ui.properties.execution"
		1401	name="Execution"
		1402	objectClass="org.eclipse.core.resources.IResource">
		1403	</page>
1397	</extension>	1404	</extension>
1398	<!-- commands and their bindings	1405	<!-- commands and their bindings
1399	NOTE:	1406	NOTE:




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

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchManager;
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.ui.DebugUITools;
import org.eclipse.debug.ui.ILaunchGroup;
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.ISelection;
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.jface.window.Window;
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.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Table;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.ListDialog;
import org.eclipse.ui.dialogs.PropertyPage;

import com.ibm.icu.text.MessageFormat;

/**
 * Displays execution settings for a resource - associated launch configurations.
 * 
 * @since 3.3
 */
public class ExecutionPropertiesPage extends PropertyPage implements ICheckStateListener, ISelectionChangedListener, SelectionListener {
	
	private CheckboxTableViewer viewer;
	private Button newButton;
	private Button copyButton;
	private Button editButton;
	private Button deleteButton;
	
	/**
	 * List of configurations to be deleted
	 */
	private List deletedConfigurations = new ArrayList();
	
	/**
	 * List of original default candidates for the resource
	 */
	private List originalCandidates;
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createContents(Composite parent) {
		// TODO: add help to documentation
		PlatformUI.getWorkbench().getHelpSystem().setHelp(parent, IDebugHelpContextIds.EXECUTION_PROPERTY_PAGE);
		
		Composite composite = new Composite(parent, SWT.NONE);
		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		GridLayout layout = new GridLayout();
		layout.marginHeight = 0;
		layout.marginWidth = 0;
		composite.setLayout(layout);
		
		SWTUtil.createLabel(composite, MessageFormat.format("&Select default launch settings for {0}:", new String[]{getResource().getName()}), 2);
		
		Composite tableAndButtons = new Composite(composite, SWT.NONE);
		tableAndButtons.setLayoutData(new GridData(GridData.FILL_BOTH));
		layout = new GridLayout();
		layout.marginHeight = 0;
		layout.marginWidth = 0;
		layout.numColumns = 2;
		tableAndButtons.setLayout(layout);
		
		viewer= CheckboxTableViewer.newCheckList(tableAndButtons, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.BORDER);
		viewer.setLabelProvider(new DefaultLabelProvider());
		viewer.setContentProvider(new ArrayContentProvider());
		viewer.setComparator(new LaunchConfigurationComparator());
		viewer.addCheckStateListener(this);
		// Only filter private configurations and external tools to avoid filtering a default
		viewer.addFilter(new PrivateConfigurationFilter());
		viewer.addFilter(new CategoryFilter());
		Table builderTable= viewer.getTable();
		GridData gridData = new GridData(GridData.FILL_BOTH);
		gridData.heightHint = 300;
		builderTable.setLayoutData(gridData);
		
		IResource resource = getResource();
		originalCandidates = getDefaultCandidates(resource);
		viewer.setInput(originalCandidates);
		try {
			ILaunchConfiguration configuration = DebugPlugin.getDefault().getLaunchManager().getDefaultConfiguration(resource);
			if (configuration != null) {
				Iterator iterator = originalCandidates.iterator();
				while (iterator.hasNext()) {
					ILaunchConfigurationWorkingCopy wc = (ILaunchConfigurationWorkingCopy) iterator.next();
					if (configuration.equals(wc.getOriginal())) {
						viewer.setChecked(wc, true);
						break;
					}
				}
			}
		} catch (CoreException e) {
			setErrorMessage(e.getMessage());
		}
		
		Composite buttonArea = new Composite(tableAndButtons, SWT.NONE);
		layout = new GridLayout();
		layout.marginHeight = 0;
		layout.marginWidth = 0;
		buttonArea.setLayout(layout);
		buttonArea.setLayoutData(new GridData(GridData.FILL_VERTICAL));
		newButton = SWTUtil.createPushButton(buttonArea, "New...", null);
		newButton.addSelectionListener(this);
		copyButton = SWTUtil.createPushButton(buttonArea, "Copy...", null);
		copyButton.addSelectionListener(this);
		editButton = SWTUtil.createPushButton(buttonArea, "Edit...", null);
		editButton.addSelectionListener(this);
		deleteButton = SWTUtil.createPushButton(buttonArea, "Delete", null);
		deleteButton.addSelectionListener(this);
		
		viewer.addSelectionChangedListener(this);
		applyDialogFont(composite);
		updateButtons(new StructuredSelection());
		return composite;
	}

	/**
	 * Returns the resource this property page is open on.
	 * 
	 * @return resource
	 */
	protected IResource getResource() {
		Object element = getElement();
		IResource resource = null;
		if (element instanceof IResource) {
			resource = (IResource) element;
		} else if (element instanceof IAdaptable) {
			resource = (IResource) ((IAdaptable)element).getAdapter(IResource.class);
		}
		return resource;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ICheckStateListener#checkStateChanged(org.eclipse.jface.viewers.CheckStateChangedEvent)
	 */
	public void checkStateChanged(CheckStateChangedEvent event) {
		ILaunchConfiguration configuration = (ILaunchConfiguration) event.getElement();
		// only allow one check
		viewer.setCheckedElements(new Object[]{configuration});
		// validate
		if (!configuration.isLocal()) {
			if (!getResource().getProject().equals(configuration.getFile().getProject())) {
				// a config must be stored in the same project that it is a default config for
				setErrorMessage(MessageFormat.format("Configuration must be located in project {0}", new String[]{getResource().getProject().getName()}));
				setValid(false);
				return;
			}
		}
		setErrorMessage(null);
		setValid(true);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.preference.PreferencePage#performOk()
	 */
	public boolean performOk() {
		Object[] checked = viewer.getCheckedElements();
		try {
			ILaunchConfiguration def = null;
			if (checked.length == 1) {
					def = (ILaunchConfiguration) checked[0];
			}
			DebugPlugin.getDefault().getLaunchManager().setDefaultConfiguration(getResource(), def);
		} catch (CoreException e) {
			setErrorMessage(e.getMessage());
			return false;
		}
		return super.performOk();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.preference.PreferencePage#performDefaults()
	 */
	protected void performDefaults() {
		viewer.setAllChecked(false);
		setErrorMessage(null);
		setValid(true);
		super.performDefaults();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ISelectionChangedListener#selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent)
	 */
	public void selectionChanged(SelectionChangedEvent event) {
		ISelection s = event.getSelection();
		if (s instanceof IStructuredSelection) {
			updateButtons((IStructuredSelection) s);
		}
		
	}

	/**
	 * Update buttons based on the given selection.
	 * 
	 * @param selection
	 */
	private void updateButtons(IStructuredSelection selection) {
		if (selection.size() == 0) {
			editButton.setEnabled(false);
			copyButton.setEnabled(false);
			deleteButton.setEnabled(false);
		} else if (selection.size() == 1) {
			editButton.setEnabled(true);
			copyButton.setEnabled(true);
			deleteButton.setEnabled(true);
		} else {
			editButton.setEnabled(false);
			copyButton.setEnabled(false);
			deleteButton.setEnabled(true);
		}
	}

	/**
	 * Returns a list of potential default configurations candidates for the given
	 * resource. The configurations are working copies.
	 *  
	 * @param resource resource
	 * @return list of default candidates
	 */
	private List getDefaultCandidates(IResource resource) {
		IPath resourcePath = resource.getFullPath();
		ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
		List list = new ArrayList();
		try {
			ILaunchConfiguration[] configurations = manager.getLaunchConfigurations();
			for (int i = 0; i < configurations.length; i++) {
				ILaunchConfiguration configuration = configurations[i];
				IResource[] resources = configuration.getMappedResources();
				if (resources != null) {
					for (int j = 0; j < resources.length; j++) {
						IResource mappedResource = resources[j];
						if (resource.equals(mappedResource) || 
								resourcePath.isPrefixOf(mappedResource.getFullPath())) {
							list.add(configuration.getWorkingCopy());
							break;
						}
					}
				} else {
					// 1. similar to launch dialog - if no resource mapping, display the config
					// 2. only consider the default launch category (applications, *not* external tools)
					if (configuration.getType().getCategory() == null) {
						list.add(configuration.getWorkingCopy());
					}
				}
			}
		} catch (CoreException e) {
			list.clear();
			DebugUIPlugin.log(e);
		}
		return list;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.swt.events.SelectionListener#widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent)
	 */
	public void widgetDefaultSelected(SelectionEvent e) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
	 */
	public void widgetSelected(SelectionEvent e) {
		if (e.widget == newButton) {
			handleNew();
		} else if (e.widget == copyButton) {
			handleCopy();
		} else if (e.widget == deleteButton) {
			handleDelete();
		} else if (e.widget == editButton) {
			handleEdit();
		}
	}
	
	/**
	 * Returns selected configurations.
	 * 
	 * @return selected configurations
	 */
	private ILaunchConfigurationWorkingCopy[] getSelectedConfigurations() {
		Object[] array = ((IStructuredSelection)viewer.getSelection()).toArray();
		ILaunchConfigurationWorkingCopy[] lcs = new ILaunchConfigurationWorkingCopy[array.length];
		System.arraycopy(array, 0, lcs, 0, array.length);
		return lcs;
	}

	/**
	 * Copy the selection
	 */
	private void handleCopy() {
		ILaunchConfigurationWorkingCopy configuration = getSelectedConfigurations()[0];
		try {
			ILaunchConfigurationWorkingCopy copy = configuration.copy(
					DebugPlugin.getDefault().getLaunchManager().generateUniqueLaunchConfigurationNameFrom(configuration.getName()));
			copy.setAttributes(configuration.getAttributes());
			int code = edit(copy);
			if (code == Window.OK) {
				originalCandidates.add(copy);
				viewer.refresh();
				viewer.setSelection(new StructuredSelection(copy));
			}
		} catch (CoreException e) {
			setErrorMessage(e.getMessage());
		}
	}

	/**
	 * Delete the selection
	 */
	private void handleDelete() {
		Table table = viewer.getTable();
		int[] indices = table.getSelectionIndices();
		Arrays.sort(indices);
		ILaunchConfiguration[] configurations = getSelectedConfigurations();
		for (int i = 0; i < configurations.length; i++) {
			deletedConfigurations.add(configurations[i]);
			originalCandidates.remove(configurations[i]);
		}
		viewer.refresh();
		if (indices[0] < table.getItemCount()) {
			viewer.setSelection(new StructuredSelection(table.getItem(indices[0]).getData()));
		} else if (table.getItemCount() > 0) {
			viewer.setSelection(new StructuredSelection(table.getItem(table.getItemCount() - 1).getData()));
		}
	}

	/**
	 * Edit the selection
	 */
	private void handleEdit() {
		edit(getSelectedConfigurations()[0]);
		viewer.refresh();
	}

	/**
	 * Edits the given configuration as a nested working copy.
	 * Returns the code from the dialog used to edit the configuration.
	 * 
	 * @param configuration
	 * @return dialog return code - OK or CANCEL
	 */
	private int edit(ILaunchConfigurationWorkingCopy configuration) {
		try {
			ILaunchConfigurationWorkingCopy copy = configuration.getNestedWorkingCopy();
			ILaunchGroup group = DebugUITools.getLaunchGroup(configuration, ILaunchManager.RUN_MODE);
			if (group == null) {
				group = DebugUITools.getLaunchGroup(configuration, ILaunchManager.DEBUG_MODE);
			}
			int code = DebugUITools.openLaunchConfigurationPropertiesDialog(getShell(), copy, group.getIdentifier());
			if (code == Window.OK) {
				copy.doSave();
			}
			return code;
		} catch (CoreException e) {
			setErrorMessage(e.getMessage());
		}
		return Window.CANCEL;
	}

	/**
	 * Create a new configuration
	 */
	private void handleNew() {
		ILaunchConfigurationType[] types = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurationTypes();
		List avail = new ArrayList(types.length); 
		for (int i = 0; i < types.length; i++) {
			ILaunchConfigurationType type = types[i];
			if (type.getCategory() == null) {
				// TODO: external tools?
				avail.add(type);
			}
		}
		Collections.sort(avail, new Comparator() {
				public int compare(Object o1, Object o2) {
					ILaunchConfigurationType t1 = (ILaunchConfigurationType) o1;
					ILaunchConfigurationType t2 = (ILaunchConfigurationType) o2;
					return t1.getName().compareTo(t2.getName());
				}
			
			});
		ListDialog dialog = new ListDialog(getShell());
		dialog.setTitle("Selection Configuration Type");
		dialog.setContentProvider(new ArrayContentProvider());
		dialog.setLabelProvider(new DefaultLabelProvider());
		dialog.setAddCancelButton(true);
		dialog.setMessage("&Select the kind of configuration to create:");
		dialog.setInput(avail);
		if (dialog.open() == Window.OK) {
			Object[] result = dialog.getResult();
			if (result.length == 1) {
				ILaunchConfigurationType type = (ILaunchConfigurationType) result[0];
				try {
					ILaunchConfigurationWorkingCopy wc = type.newInstance(null, DebugPlugin.getDefault().getLaunchManager().
							generateUniqueLaunchConfigurationNameFrom("New Configuration"));
					if (edit(wc) == Window.OK) {
						originalCandidates.add(wc);
						viewer.refresh();
						viewer.setSelection(new StructuredSelection(wc));
					}
				} catch (CoreException e) {
					setErrorMessage(e.getMessage());
				}
			}
		}
	}
	
}




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

import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;

/**
 * Filters private configurations.
 *
 * @since 3.3
 */
public class PrivateConfigurationFilter extends ViewerFilter {

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
	 */
	public boolean select(Viewer viewer, Object parentElement, Object element) {
		if (element instanceof ILaunchConfiguration) {
			return !DebugUITools.isPrivate((ILaunchConfiguration) element);
		}
		return true;
	}

}




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

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;

/**
 * Filters configurations in non-default launch categories.
 *
 * @since 3.3
 */
public class CategoryFilter extends ViewerFilter {

	/* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
	 */
	public boolean select(Viewer viewer, Object parentElement, Object element) {
		if (element instanceof ILaunchConfiguration) {
			try {
				return ((ILaunchConfiguration)element).getType().getCategory() == null;
			} catch (CoreException e) {
				return false;
			}
		}
		return true;
	}

}




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

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.ui.model.WorkbenchViewerComparator;

/**
 * Groups configurations by type.
 * 
 * @since 3.3
 */
public class LaunchConfigurationComparator extends WorkbenchViewerComparator {

	private static Map categories;
	
	public int category(Object element) {
		Map map = getCategories();
		if (element instanceof ILaunchConfiguration) {
			ILaunchConfiguration configuration = (ILaunchConfiguration) element;
			try {
				Integer i = (Integer) map.get(configuration.getType());
				if (i != null) {
					return i.intValue();
				}
			} catch (CoreException e) {
			}
		}
		return map.size();
	}
	
	private Map getCategories() {
		if (categories == null) {
			categories = new HashMap();
			ILaunchConfigurationType[] lcts = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurationTypes();
			List types = new ArrayList(lcts.length);
			for (int i = 0; i < lcts.length; i++) {
				types.add(lcts[i]);
			}
			Collections.sort(types, new Comparator() {
				public int compare(Object o1, Object o2) {
					ILaunchConfigurationType t1 = (ILaunchConfigurationType) o1;
					ILaunchConfigurationType t2 = (ILaunchConfigurationType) o2;
					return t1.getName().compareTo(t2.getName());
				}
			
			});
			Iterator iterator = types.iterator();
			int i = 0;
			while (iterator.hasNext()) {
				categories.put(iterator.next(), new Integer(i));
				i++;
			}
		}
		return categories;
	}

	
}

Return to bug 74480

Lines 14-19 Link Here

(-)core/org/eclipse/debug/core/ILaunchManager.java (+37 lines)
14	import java.util.Map;	14	import java.util.Map;
15		15
16	import org.eclipse.core.resources.IFile;	16	import org.eclipse.core.resources.IFile;
		17	import org.eclipse.core.resources.IResource;
17	import org.eclipse.core.runtime.CoreException;	18	import org.eclipse.core.runtime.CoreException;
18	import org.eclipse.debug.core.model.IDebugTarget;	19	import org.eclipse.debug.core.model.IDebugTarget;
19	import org.eclipse.debug.core.model.IPersistableSourceLocator;	20	import org.eclipse.debug.core.model.IPersistableSourceLocator;
Lines 459-464 Link Here
459	*/	460	*/
460	public void removeLaunchListener(ILaunchListener listener);	461	public void removeLaunchListener(ILaunchListener listener);
461		462
		463	/**
		464	* Sets the given launch configuration as the default configuration for the specified
		465	* resource. There is only one default configuration per resource and this replaces
		466	* any previously existing launch configuration for the resource, if any. Specifying
		467	* a configuration of <code>null</code> clears the default configuration for the
		468	* given resource.
		469	*
		470	* @param resource resource
		471	* @param configuration launch configuration or <code>null</code>
		472	* @exception CoreException if unable to set as default
		473	* @since 3.3
		474	* <p>
		475	* <strong>EXPERIMENTAL</strong>. This method has been added as
		476	* part of a work in progress. There is no guarantee that this API will
		477	* remain unchanged during the 3.3 release cycle. Please do not use this API
		478	* without consulting with the Platform/Debug team.
		479	* </p>
		480	*/
		481	public void setDefaultConfiguration(IResource resource, ILaunchConfiguration configuration) throws CoreException;
		482
		483	/**
		484	* Returns the default launch configuration for the specified resource, or <code>null</code>
		485	* if none.
		486	*
		487	* @param configuration launch configuration
		488	* @return launch configuration or <code>null</code>
		489	* @exception CoreException if an error occurs retrieving the configuration
		490	* @since 3.3
		491	* <p>
		492	* <strong>EXPERIMENTAL</strong>. This method has been added as
		493	* part of a work in progress. There is no guarantee that this API will
		494	* remain unchanged during the 3.3 release cycle. Please do not use this API
		495	* without consulting with the Platform/Debug team.
		496	* </p>
		497	*/
		498	public ILaunchConfiguration getDefaultConfiguration(IResource resource) throws CoreException;
462	}	499	}
463		500
464		501

Added Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/properties/ExecutionPropertiesPage.java (+449 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.launchConfigurations.properties;
12
13	import java.util.ArrayList;
14	import java.util.Arrays;
15	import java.util.Collections;
16	import java.util.Comparator;
17	import java.util.Iterator;
18	import java.util.List;
19
20	import org.eclipse.core.resources.IResource;
21	import org.eclipse.core.runtime.CoreException;
22	import org.eclipse.core.runtime.IAdaptable;
23	import org.eclipse.core.runtime.IPath;
24	import org.eclipse.debug.core.DebugPlugin;
25	import org.eclipse.debug.core.ILaunchConfiguration;
26	import org.eclipse.debug.core.ILaunchConfigurationType;
27	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
28	import org.eclipse.debug.core.ILaunchManager;
29	import org.eclipse.debug.internal.ui.DebugUIPlugin;
30	import org.eclipse.debug.internal.ui.DefaultLabelProvider;
31	import org.eclipse.debug.internal.ui.IDebugHelpContextIds;
32	import org.eclipse.debug.internal.ui.SWTUtil;
33	import org.eclipse.debug.ui.DebugUITools;
34	import org.eclipse.debug.ui.ILaunchGroup;
35	import org.eclipse.jface.viewers.ArrayContentProvider;
36	import org.eclipse.jface.viewers.CheckStateChangedEvent;
37	import org.eclipse.jface.viewers.CheckboxTableViewer;
38	import org.eclipse.jface.viewers.ICheckStateListener;
39	import org.eclipse.jface.viewers.ISelection;
40	import org.eclipse.jface.viewers.ISelectionChangedListener;
41	import org.eclipse.jface.viewers.IStructuredSelection;
42	import org.eclipse.jface.viewers.SelectionChangedEvent;
43	import org.eclipse.jface.viewers.StructuredSelection;
44	import org.eclipse.jface.window.Window;
45	import org.eclipse.swt.SWT;
46	import org.eclipse.swt.events.SelectionEvent;
47	import org.eclipse.swt.events.SelectionListener;
48	import org.eclipse.swt.layout.GridData;
49	import org.eclipse.swt.layout.GridLayout;
50	import org.eclipse.swt.widgets.Button;
51	import org.eclipse.swt.widgets.Composite;
52	import org.eclipse.swt.widgets.Control;
53	import org.eclipse.swt.widgets.Table;
54	import org.eclipse.ui.PlatformUI;
55	import org.eclipse.ui.dialogs.ListDialog;
56	import org.eclipse.ui.dialogs.PropertyPage;
57
58	import com.ibm.icu.text.MessageFormat;
59
60	/**
61	* Displays execution settings for a resource - associated launch configurations.
62	*
63	* @since 3.3
64	*/
65	public class ExecutionPropertiesPage extends PropertyPage implements ICheckStateListener, ISelectionChangedListener, SelectionListener {
66
67	private CheckboxTableViewer viewer;
68	private Button newButton;
69	private Button copyButton;
70	private Button editButton;
71	private Button deleteButton;
72
73	/**
74	* List of configurations to be deleted
75	*/
76	private List deletedConfigurations = new ArrayList();
77
78	/**
79	* List of original default candidates for the resource
80	*/
81	private List originalCandidates;
82
83	/* (non-Javadoc)
84	* @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
85	*/
86	protected Control createContents(Composite parent) {
87	// TODO: add help to documentation
88	PlatformUI.getWorkbench().getHelpSystem().setHelp(parent, IDebugHelpContextIds.EXECUTION_PROPERTY_PAGE);
89
90	Composite composite = new Composite(parent, SWT.NONE);
91	composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
92	GridLayout layout = new GridLayout();
93	layout.marginHeight = 0;
94	layout.marginWidth = 0;
95	composite.setLayout(layout);
96
97	SWTUtil.createLabel(composite, MessageFormat.format("&Select default launch settings for {0}:", new String[]{getResource().getName()}), 2);
98
99	Composite tableAndButtons = new Composite(composite, SWT.NONE);
100	tableAndButtons.setLayoutData(new GridData(GridData.FILL_BOTH));
101	layout = new GridLayout();
102	layout.marginHeight = 0;
103	layout.marginWidth = 0;
104	layout.numColumns = 2;
105	tableAndButtons.setLayout(layout);
106
107	viewer= CheckboxTableViewer.newCheckList(tableAndButtons, SWT.MULTI \| SWT.H_SCROLL \| SWT.V_SCROLL \| SWT.FULL_SELECTION \| SWT.BORDER);
108	viewer.setLabelProvider(new DefaultLabelProvider());
109	viewer.setContentProvider(new ArrayContentProvider());
110	viewer.setComparator(new LaunchConfigurationComparator());
111	viewer.addCheckStateListener(this);
112	// Only filter private configurations and external tools to avoid filtering a default
113	viewer.addFilter(new PrivateConfigurationFilter());
114	viewer.addFilter(new CategoryFilter());
115	Table builderTable= viewer.getTable();
116	GridData gridData = new GridData(GridData.FILL_BOTH);
117	gridData.heightHint = 300;
118	builderTable.setLayoutData(gridData);
119
120	IResource resource = getResource();
121	originalCandidates = getDefaultCandidates(resource);
122	viewer.setInput(originalCandidates);
123	try {
124	ILaunchConfiguration configuration = DebugPlugin.getDefault().getLaunchManager().getDefaultConfiguration(resource);
125	if (configuration != null) {
126	Iterator iterator = originalCandidates.iterator();
127	while (iterator.hasNext()) {
128	ILaunchConfigurationWorkingCopy wc = (ILaunchConfigurationWorkingCopy) iterator.next();
129	if (configuration.equals(wc.getOriginal())) {
130	viewer.setChecked(wc, true);
131	break;
132	}
133	}
134	}
135	} catch (CoreException e) {
136	setErrorMessage(e.getMessage());
137	}
138
139	Composite buttonArea = new Composite(tableAndButtons, SWT.NONE);
140	layout = new GridLayout();
141	layout.marginHeight = 0;
142	layout.marginWidth = 0;
143	buttonArea.setLayout(layout);
144	buttonArea.setLayoutData(new GridData(GridData.FILL_VERTICAL));
145	newButton = SWTUtil.createPushButton(buttonArea, "New...", null);
146	newButton.addSelectionListener(this);
147	copyButton = SWTUtil.createPushButton(buttonArea, "Copy...", null);
148	copyButton.addSelectionListener(this);
149	editButton = SWTUtil.createPushButton(buttonArea, "Edit...", null);
150	editButton.addSelectionListener(this);
151	deleteButton = SWTUtil.createPushButton(buttonArea, "Delete", null);
152	deleteButton.addSelectionListener(this);
153
154	viewer.addSelectionChangedListener(this);
155	applyDialogFont(composite);
156	updateButtons(new StructuredSelection());
157	return composite;
158	}
159
160	/**
161	* Returns the resource this property page is open on.
162	*
163	* @return resource
164	*/
165	protected IResource getResource() {
166	Object element = getElement();
167	IResource resource = null;
168	if (element instanceof IResource) {
169	resource = (IResource) element;
170	} else if (element instanceof IAdaptable) {
171	resource = (IResource) ((IAdaptable)element).getAdapter(IResource.class);
172	}
173	return resource;
174	}
175
176	/* (non-Javadoc)
177	* @see org.eclipse.jface.viewers.ICheckStateListener#checkStateChanged(org.eclipse.jface.viewers.CheckStateChangedEvent)
178	*/
179	public void checkStateChanged(CheckStateChangedEvent event) {
180	ILaunchConfiguration configuration = (ILaunchConfiguration) event.getElement();
181	// only allow one check
182	viewer.setCheckedElements(new Object[]{configuration});
183	// validate
184	if (!configuration.isLocal()) {
185	if (!getResource().getProject().equals(configuration.getFile().getProject())) {
186	// a config must be stored in the same project that it is a default config for
187	setErrorMessage(MessageFormat.format("Configuration must be located in project {0}", new String[]{getResource().getProject().getName()}));
188	setValid(false);
189	return;
190	}
191	}
192	setErrorMessage(null);
193	setValid(true);
194	}
195
196	/* (non-Javadoc)
197	* @see org.eclipse.jface.preference.PreferencePage#performOk()
198	*/
199	public boolean performOk() {
200	Object[] checked = viewer.getCheckedElements();
201	try {
202	ILaunchConfiguration def = null;
203	if (checked.length == 1) {
204	def = (ILaunchConfiguration) checked[0];
205	}
206	DebugPlugin.getDefault().getLaunchManager().setDefaultConfiguration(getResource(), def);
207	} catch (CoreException e) {
208	setErrorMessage(e.getMessage());
209	return false;
210	}
211	return super.performOk();
212	}
213
214	/* (non-Javadoc)
215	* @see org.eclipse.jface.preference.PreferencePage#performDefaults()
216	*/
217	protected void performDefaults() {
218	viewer.setAllChecked(false);
219	setErrorMessage(null);
220	setValid(true);
221	super.performDefaults();
222	}
223
224	/* (non-Javadoc)
225	* @see org.eclipse.jface.viewers.ISelectionChangedListener#selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent)
226	*/
227	public void selectionChanged(SelectionChangedEvent event) {
228	ISelection s = event.getSelection();
229	if (s instanceof IStructuredSelection) {
230	updateButtons((IStructuredSelection) s);
231	}
232
233	}
234
235	/**
236	* Update buttons based on the given selection.
237	*
238	* @param selection
239	*/
240	private void updateButtons(IStructuredSelection selection) {
241	if (selection.size() == 0) {
242	editButton.setEnabled(false);
243	copyButton.setEnabled(false);
244	deleteButton.setEnabled(false);
245	} else if (selection.size() == 1) {
246	editButton.setEnabled(true);
247	copyButton.setEnabled(true);
248	deleteButton.setEnabled(true);
249	} else {
250	editButton.setEnabled(false);
251	copyButton.setEnabled(false);
252	deleteButton.setEnabled(true);
253	}
254	}
255
256	/**
257	* Returns a list of potential default configurations candidates for the given
258	* resource. The configurations are working copies.
259	*
260	* @param resource resource
261	* @return list of default candidates
262	*/
263	private List getDefaultCandidates(IResource resource) {
264	IPath resourcePath = resource.getFullPath();
265	ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
266	List list = new ArrayList();
267	try {
268	ILaunchConfiguration[] configurations = manager.getLaunchConfigurations();
269	for (int i = 0; i < configurations.length; i++) {
270	ILaunchConfiguration configuration = configurations[i];
271	IResource[] resources = configuration.getMappedResources();
272	if (resources != null) {
273	for (int j = 0; j < resources.length; j++) {
274	IResource mappedResource = resources[j];
275	if (resource.equals(mappedResource) \|\|
276	resourcePath.isPrefixOf(mappedResource.getFullPath())) {
277	list.add(configuration.getWorkingCopy());
278	break;
279	}
280	}
281	} else {
282	// 1. similar to launch dialog - if no resource mapping, display the config
283	// 2. only consider the default launch category (applications, not external tools)
284	if (configuration.getType().getCategory() == null) {
285	list.add(configuration.getWorkingCopy());
286	}
287	}
288	}
289	} catch (CoreException e) {
290	list.clear();
291	DebugUIPlugin.log(e);
292	}
293	return list;
294	}
295
296	/* (non-Javadoc)
297	* @see org.eclipse.swt.events.SelectionListener#widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent)
298	*/
299	public void widgetDefaultSelected(SelectionEvent e) {
300	}
301
302	/* (non-Javadoc)
303	* @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
304	*/
305	public void widgetSelected(SelectionEvent e) {
306	if (e.widget == newButton) {
307	handleNew();
308	} else if (e.widget == copyButton) {
309	handleCopy();
310	} else if (e.widget == deleteButton) {
311	handleDelete();
312	} else if (e.widget == editButton) {
313	handleEdit();
314	}
315	}
316
317	/**
318	* Returns selected configurations.
319	*
320	* @return selected configurations
321	*/
322	private ILaunchConfigurationWorkingCopy[] getSelectedConfigurations() {
323	Object[] array = ((IStructuredSelection)viewer.getSelection()).toArray();
324	ILaunchConfigurationWorkingCopy[] lcs = new ILaunchConfigurationWorkingCopy[array.length];
325	System.arraycopy(array, 0, lcs, 0, array.length);
326	return lcs;
327	}
328
329	/**
330	* Copy the selection
331	*/
332	private void handleCopy() {
333	ILaunchConfigurationWorkingCopy configuration = getSelectedConfigurations()[0];
334	try {
335	ILaunchConfigurationWorkingCopy copy = configuration.copy(
336	DebugPlugin.getDefault().getLaunchManager().generateUniqueLaunchConfigurationNameFrom(configuration.getName()));
337	copy.setAttributes(configuration.getAttributes());
338	int code = edit(copy);
339	if (code == Window.OK) {
340	originalCandidates.add(copy);
341	viewer.refresh();
342	viewer.setSelection(new StructuredSelection(copy));
343	}
344	} catch (CoreException e) {
345	setErrorMessage(e.getMessage());
346	}
347	}
348
349	/**
350	* Delete the selection
351	*/
352	private void handleDelete() {
353	Table table = viewer.getTable();
354	int[] indices = table.getSelectionIndices();
355	Arrays.sort(indices);
356	ILaunchConfiguration[] configurations = getSelectedConfigurations();
357	for (int i = 0; i < configurations.length; i++) {
358	deletedConfigurations.add(configurations[i]);
359	originalCandidates.remove(configurations[i]);
360	}
361	viewer.refresh();
362	if (indices[0] < table.getItemCount()) {
363	viewer.setSelection(new StructuredSelection(table.getItem(indices[0]).getData()));
364	} else if (table.getItemCount() > 0) {
365	viewer.setSelection(new StructuredSelection(table.getItem(table.getItemCount() - 1).getData()));
366	}
367	}
368
369	/**
370	* Edit the selection
371	*/
372	private void handleEdit() {
373	edit(getSelectedConfigurations()[0]);
374	viewer.refresh();
375	}
376
377	/**
378	* Edits the given configuration as a nested working copy.
379	* Returns the code from the dialog used to edit the configuration.
380	*
381	* @param configuration
382	* @return dialog return code - OK or CANCEL
383	*/
384	private int edit(ILaunchConfigurationWorkingCopy configuration) {
385	try {
386	ILaunchConfigurationWorkingCopy copy = configuration.getNestedWorkingCopy();
387	ILaunchGroup group = DebugUITools.getLaunchGroup(configuration, ILaunchManager.RUN_MODE);
388	if (group == null) {
389	group = DebugUITools.getLaunchGroup(configuration, ILaunchManager.DEBUG_MODE);
390	}
391	int code = DebugUITools.openLaunchConfigurationPropertiesDialog(getShell(), copy, group.getIdentifier());
392	if (code == Window.OK) {
393	copy.doSave();
394	}
395	return code;
396	} catch (CoreException e) {
397	setErrorMessage(e.getMessage());
398	}
399	return Window.CANCEL;
400	}
401
402	/**
403	* Create a new configuration
404	*/
405	private void handleNew() {
406	ILaunchConfigurationType[] types = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurationTypes();
407	List avail = new ArrayList(types.length);
408	for (int i = 0; i < types.length; i++) {
409	ILaunchConfigurationType type = types[i];
410	if (type.getCategory() == null) {
411	// TODO: external tools?
412	avail.add(type);
413	}
414	}
415	Collections.sort(avail, new Comparator() {
416	public int compare(Object o1, Object o2) {
417	ILaunchConfigurationType t1 = (ILaunchConfigurationType) o1;
418	ILaunchConfigurationType t2 = (ILaunchConfigurationType) o2;
419	return t1.getName().compareTo(t2.getName());
420	}
421
422	});
423	ListDialog dialog = new ListDialog(getShell());
424	dialog.setTitle("Selection Configuration Type");
425	dialog.setContentProvider(new ArrayContentProvider());
426	dialog.setLabelProvider(new DefaultLabelProvider());
427	dialog.setAddCancelButton(true);
428	dialog.setMessage("&Select the kind of configuration to create:");
429	dialog.setInput(avail);
430	if (dialog.open() == Window.OK) {
431	Object[] result = dialog.getResult();
432	if (result.length == 1) {
433	ILaunchConfigurationType type = (ILaunchConfigurationType) result[0];
434	try {
435	ILaunchConfigurationWorkingCopy wc = type.newInstance(null, DebugPlugin.getDefault().getLaunchManager().
436	generateUniqueLaunchConfigurationNameFrom("New Configuration"));
437	if (edit(wc) == Window.OK) {
438	originalCandidates.add(wc);
439	viewer.refresh();
440	viewer.setSelection(new StructuredSelection(wc));
441	}
442	} catch (CoreException e) {
443	setErrorMessage(e.getMessage());
444	}
445	}
446	}
447	}
448
449	}