Attachment #58480 for bug #74480

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




	 * CONTEXTLAUNCHING
	 */
	public ILaunchConfiguration getDefaultConfiguration(IResource resource) throws CoreException {
		if(resource != null) {
			IProject project = resource.getProject();
			if (project != null) {
				org.osgi.service.prefs.Preferences projectNode = getProjectNode(resource);
				String configValue = projectNode.get(DEFAULT_CONFIGURATION, 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) {
					// 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);
					}
				}
			}
		}

Lines 176-183 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchConfigurationWorkingCopy.java (-2 / +7 lines)
176	if (getParent() != null) {	176	if (getParent() != null) {
177	// save to parent working copy	177	// save to parent working copy
178	LaunchConfigurationWorkingCopy wc = (LaunchConfigurationWorkingCopy) getParent();	178	LaunchConfigurationWorkingCopy wc = (LaunchConfigurationWorkingCopy) getParent();
179	wc.setName(getName());	179	if(fRenamed) {
180	wc.copyFrom(this);	180	wc.rename(getName());
		181	}
		182	else {
		183	wc.setName(getName());
		184	}
		185	wc.setAttributes(getInfo().getAttributes());
181	return wc;	186	return wc;
182	}	187	}
183	else {	188	else {

Lines 154-161 Link Here

(-)ui/org/eclipse/jdt/debug/ui/launchConfigurations/JavaMainTab.java (-1 / +1 lines)
154	elements = new IJavaElement[]{};	154	elements = new IJavaElement[]{};
155	}	155	}
156	int constraints = IJavaSearchScope.SOURCES;	156	int constraints = IJavaSearchScope.SOURCES;
		157	constraints \|= IJavaSearchScope.APPLICATION_LIBRARIES;
157	if (fSearchExternalJarsCheckButton.getSelection()) {	158	if (fSearchExternalJarsCheckButton.getSelection()) {
158	constraints \|= IJavaSearchScope.APPLICATION_LIBRARIES;
159	constraints \|= IJavaSearchScope.SYSTEM_LIBRARIES;	159	constraints \|= IJavaSearchScope.SYSTEM_LIBRARIES;
160	}	160	}
161	IJavaSearchScope searchScope = SearchEngine.createJavaSearchScope(elements, constraints);	161	IJavaSearchScope searchScope = SearchEngine.createJavaSearchScope(elements, constraints);

Lines 92-98 Link Here

(-)ui/org/eclipse/jdt/internal/debug/ui/launcher/JavaApplicationLaunchShortcut.java (-1 / +3 lines)
92	try {	92	try {
93	IJavaElement[] javaElements = getJavaElements(elements);	93	IJavaElement[] javaElements = getJavaElements(elements);
94	MainMethodSearchEngine engine = new MainMethodSearchEngine();	94	MainMethodSearchEngine engine = new MainMethodSearchEngine();
95	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(javaElements, false);	95	int constraints = IJavaSearchScope.SOURCES;
		96	constraints \|= IJavaSearchScope.APPLICATION_LIBRARIES;
		97	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(javaElements, constraints);
96	return engine.searchMainMethods(context, scope, true);	98	return engine.searchMainMethods(context, scope, true);
97	} catch (InvocationTargetException e) {	99	} catch (InvocationTargetException e) {
98	throw (CoreException)e.getTargetException();	100	throw (CoreException)e.getTargetException();




/*******************************************************************************
 * Copyright (c) 2007 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.contextlaunching;

import org.eclipse.debug.core.ILaunchManager;

/**
 * Specialization of <code>ContextLaunchingAction</code> for profile mode
 * 
 * @see ContextLaunchingAction
 * @see ILaunchManager
 * @see RunContextLaunchingAction
 * @see DebugContextLaunchingAction
 * 
 * @since 3.3
 * EXPERIMENTAL
 * CONTEXTLAUNCHING
 */
public class ProfileContextLaunchingAction extends ContextLaunchingAction {

	/**
	 * Constructor
	 */
	public ProfileContextLaunchingAction() {
		super(ILaunchManager.PROFILE_MODE);
	}

}




/*******************************************************************************
 * Copyright (c) 2007 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.contextlaunching;

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.widgets.Event;
import org.eclipse.ui.IActionDelegate2;

/**
 * A universal context launching action for popup menus. 
 * This action gets its immediate context from what was right-clicked
 * on to present the action.
 * 
 * @see ContextRunner
 * @see IActionDelegate2
 * @see RunContextLaunchingAction
 * @see DebugContextLaunchingAction
 * @see ProfileContextLaunchingAction
 * 
 * @since 3.3
 * EXPERIMENTAL
 * CONTEXTLAUNCHING
 */
public class ContextLaunchingAction implements IActionDelegate2 {

	/**
	 * the mode the action is created on
	 */
	private String fMode = null;
	
	/**
	 * Constructor
	 * @param mode
	 */
	public ContextLaunchingAction(String mode) {
		fMode = mode;
	}

	/**
	 * @see org.eclipse.ui.IActionDelegate2#dispose()
	 */
	public void dispose() {}

	/**
	 * @see org.eclipse.ui.IActionDelegate2#init(org.eclipse.jface.action.IAction)
	 */
	public void init(IAction action) {}

	/**
	 * @see org.eclipse.ui.IActionDelegate2#runWithEvent(org.eclipse.jface.action.IAction, org.eclipse.swt.widgets.Event)
	 */
	public void runWithEvent(IAction action, Event event) {
		ContextRunner.getDefault().launch(fMode);
	}
	
	/**
	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
	 */
	public void run(IAction action) {
		//not called
	}

	/**
	 * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
	 */
	public void selectionChanged(IAction action, ISelection selection) {}
}




 */
public class ContextMessages extends NLS {
	private static final String BUNDLE_NAME = "org.eclipse.debug.internal.ui.contextlaunching.ContextMessages"; //$NON-NLS-1$
	
	public static String ContextRunner_0;
	public static String ContextRunner_1;
	public static String ContextRunner_2;
	public static String ContextRunner_3;
	public static String ContextRunner_4;
	public static String ContextRunner_5;
	public static String ContextRunner_6;

	public static String ContextRunner_7;
	public static String ContextRunner_8;
	public static String ContextRunner_9;
	public static String OpenLaunchDialogAction_0;
	public static String OpenLaunchDialogAction_1;
	static {
		// initialize resource bundle
		NLS.initializeMessages(BUNDLE_NAME, ContextMessages.class);




/*******************************************************************************
 * Copyright (c) 2007 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.contextlaunching;

import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchGroupExtension;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.widgets.Event;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;

/**
 * A wrapper class for a context launching toolbar action
 * 
 * @see ContextRunner
 * @see ContextLaunchingAction
 * @see Action
 * @see IWorkbenchWindowActionDelegate
 * 
 *  @since 3.3
 *  EXPERIMENTAL
 *  CONTEXTLAUNCHING
 */
public class ContextLaunchingToolbarAction extends Action implements IWorkbenchWindowActionDelegate {

	/**
	 * The mode this action applies to
	 */
	private String fMode = null;
	
	/**
	 * Constructor
	 * @param id
	 */
	public ContextLaunchingToolbarAction(String id) {
		LaunchGroupExtension extension = DebugUIPlugin.getDefault().getLaunchConfigurationManager().getLaunchGroup(id);
		if (extension != null) {
			fMode = extension.getMode();
			setText(extension.getLabel());
			setImageDescriptor(extension.getImageDescriptor());
		}
	}

	/**
	 * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#dispose()
	 */
	public void dispose() {}

	/**
	 * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#init(org.eclipse.ui.IWorkbenchWindow)
	 */
	public void init(IWorkbenchWindow window) {}
	
	/**
	 * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
	 */
	public void selectionChanged(IAction action, ISelection selection) {}

	/**
	 * @see org.eclipse.jface.action.Action#runWithEvent(org.eclipse.swt.widgets.Event)
	 */
	public void runWithEvent(Event event) {
		ContextRunner.getDefault().launch(fMode);
	}

	/**
	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
	 */
	public void run(IAction action) {
		//do nothing
	}
}




ContextRunner_0=Unable To Launch
ContextRunner_1=There is no way to launch the currently selected context, would you like to {0} the last thing you launched?
ContextRunner_2=&Always perform this action
ContextRunner_3=Not Runnable
ContextRunner_4={0} is not runnable, would you like to check its'' parent project for a way to run it?
ContextRunner_5=Cannot Launch
ContextRunner_6=The selected resource is not launchable.
ContextRunner_7=The current context cannot be launched, and there are no recent launches.
ContextRunner_8=&Select a configuration to launch:
ContextRunner_9=Select Configuration
OpenLaunchDialogAction_0=Open {0} Dialog...
OpenLaunchDialogAction_1=&Open {0} Dialog...




 *******************************************************************************/
package org.eclipse.debug.internal.ui.contextlaunching;

import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.expressions.EvaluationContext;
import org.eclipse.core.expressions.IEvaluationContext;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchListener;
import org.eclipse.debug.core.ILaunchMode;
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.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchHistory;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchShortcutExtension;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchShortcutSelectionDialog;

import org.eclipse.debug.ui.ILaunchGroup;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.MessageDialogWithToggle;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.window.Window;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPartSite;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.dialogs.ListDialog;
import com.ibm.icu.text.MessageFormat;

/**
 * Static runner for context launching to provide the base capability of context 

 *  EXPERIMENTAL
 *  CONTEXTLAUNCHING
 */
public final class ContextRunner {
	
	/**
	 * The singleton instance of the context runner
	 */
	private static ContextRunner fgInstance = null;
	
	/**

		}
		return fgInstance;
	}

	/**
	 * The underlying resource that is derived from the object context of the 
	 * run(Object, String) method
	 */
	private IResource fBackingResource = null;
	private boolean fMakeResourceDefault = false;
	private boolean fMakeProjectDefault = false;
	
	/**
	 * Performs the context launching given the object context and the mode to launch in.

	 */
	public void launch(String mode) {
		try {
			//1. resolve resource
			Object context = getCurrentContext();
			ILaunchConfiguration config = null;
			if(context != null) {
				if(context instanceof IAdaptable) {
					IResource resource = (IResource) ((IAdaptable)context).getAdapter(IResource.class);
			}
			config = isSharedConfigEditorInput(context);
			if(config != null) {
				DebugUITools.launch(config, mode);
				return;
			}
			if(context instanceof IAdaptable) {
				IAdaptable adapt = (IAdaptable) context;
				//try to get the ILaunchConfiguration adapter first
				config = (ILaunchConfiguration) adapt.getAdapter(ILaunchConfiguration.class);
				if(config != null) {
					DebugUITools.launch(config, mode);
					return;
				}
				else {
					//try to get the resource adapter from the context
					IResource resource = (IResource) adapt.getAdapter(IResource.class);
					if(resource != null) {
						selectAndLaunch(resource, mode);
						return;
						if(config != null && config.exists()) {
							//the default config is available
							DebugUITools.launch(config, mode);
							return;
						}
						else {
							//there is no default config
							getLaunchManager().setDefaultConfiguration(resource, null);
							selectAndLaunch(fBackingResource, mode);
							return;
						}
					}
					else {
						handleUnknownContext(mode);
					}
				}
			}
			//2. launch last if no resource
			config = getLastLaunch(mode);
			if(config != null) {
				DebugUITools.launch(config, mode);
				return;
			}
			
		}
		catch(CoreException ce) {DebugUIPlugin.log(ce);}
	}

		if(config == null) {
			MessageDialog.openInformation(DebugUIPlugin.getShell(), ContextMessages.ContextRunner_0, ContextMessages.ContextRunner_7);
		}
		else {
			String prompt = DebugUIPlugin.getDefault().getPreferenceStore().getString(IInternalDebugUIConstants.PREF_ALWAYS_RUN_LAST_LAUNCH);
			if(MessageDialogWithToggle.PROMPT.equals(prompt)) {
				ILaunchMode lmode = getLaunchManager().getLaunchMode(mode);
				MessageDialogWithToggle mdwt = MessageDialogWithToggle.openYesNoQuestion(DebugUIPlugin.getShell(), ContextMessages.ContextRunner_0,
						MessageFormat.format(ContextMessages.ContextRunner_1, new String[] {DebugUIPlugin.removeAccelerators(lmode.getLabel().toLowerCase())}), ContextMessages.ContextRunner_2, 
						false, null, null);
				int ret = mdwt.getReturnCode();
				boolean checked = mdwt.getToggleState();
				if(ret == IDialogConstants.YES_ID) {
					//get launch history for the given mode and do it 
					DebugUITools.launch(config, mode);
					if(checked) {
						DebugUIPlugin.getDefault().getPreferenceStore().putValue(IInternalDebugUIConstants.PREF_ALWAYS_RUN_LAST_LAUNCH, MessageDialogWithToggle.ALWAYS);
					}
				}
			}
			else if(MessageDialogWithToggle.ALWAYS.equals(prompt)) {
				DebugUITools.launch(config, mode);
			}
		}
	}
	
	/**

	}
	
	/**
	 * This method return if the editor input is from a shared java launch configuration file or not
	 * @param receiver the editor input to examine
	 * @return true if the editor input is from a shared launch configuration file, false otherwise.
	 */
	public ILaunchConfiguration isSharedConfigEditorInput(Object receiver) {
		if(receiver instanceof IFileEditorInput) {
			IFileEditorInput input = (IFileEditorInput) receiver;
			return isSharedConfig(input.getFile());
		}
		return null;
	}
	
	/**
	 * Returns the launch group that corresponds to the specified mode
	 * @param mode the mode to find the launch group
	 * @return the launch group that corresponds to the specified mode

	}
	
	/**
	 * Returns the shared config from the selected resource or <code>null</code> if the selected resources is not a shared config
	 * @param receiver
	 * @return the shared config from the selected resource or <code>null</code> if the selected resources is not a shared config
	 */
	public ILaunchConfiguration isSharedConfig(Object receiver) {
		if(receiver instanceof IFile) {
			IFile file = (IFile) receiver;
			String ext = file.getFileExtension();
			if(ext == null) {
				return null;
			}
			if(ext.equals("launch")) { //$NON-NLS-1$
				ILaunchConfiguration config = DebugPlugin.getDefault().getLaunchManager().getLaunchConfiguration(file);
				if(config != null && config.exists()) {
					return config;
				}
			}
		}
		return null;
	}
	
	/**
	 * Prompts the user to select a way of launching the current resource, where a 'way'
	 * is defined as a launch shortcut, and returns if a launch took place
	 * @param adapt the adaptable type the specified resource was derived from

	 * @throws CoreException
	 */
	protected boolean selectAndLaunch(IResource resource, String mode) throws CoreException {
		List configs = getLaunchConfigurationManager().getApplicableLaunchConfigurations(resource);
		int csize = configs.size();
		List exts = getLaunchConfigurationManager().getLaunchShortcuts(resource);
		int esize = exts.size();
		if(csize == 1) {
			DebugUITools.launch((ILaunchConfiguration) configs.get(0), mode);
			//just launch it and set it as the default
			LaunchShortcutExtension ext = (LaunchShortcutExtension) exts.get(0);
			ext.launch(new StructuredSelection(resource), mode);
			return true;
		}
		if(csize < 1) {
			if(esize == 1) {
				LaunchShortcutExtension ext = (LaunchShortcutExtension) exts.get(0);
				ext.launch(new StructuredSelection(resource), mode);
				return true;
				selectAndLaunch(resource.getProject(), mode);
			}
			else if(MessageDialogWithToggle.PROMPT.equals(prompt)) {
				MessageDialogWithToggle mdwt = MessageDialogWithToggle.openYesNoQuestion(DebugUIPlugin.getShell(), ContextMessages.ContextRunner_3,
						MessageFormat.format(ContextMessages.ContextRunner_4, new String[] {fBackingResource.getName()}),
						ContextMessages.ContextRunner_2, false, null, null);
				int ret = mdwt.getReturnCode();
				boolean checked = mdwt.getToggleState();
				if(ret == IDialogConstants.YES_ID) {
					if(checked) {
						DebugUIPlugin.getDefault().getPreferenceStore().putValue(IInternalDebugUIConstants.PREF_ALWAYS_RUN_PROJECT_CONFIGURATION, MessageDialogWithToggle.ALWAYS);
					}
					selectAndLaunch(resource.getProject(), mode);
				}
			}
			if(esize > 1) {
				return showShortcutSelectionDialog(resource, mode);
			}
			if(esize < 1) {
				//TODO check project?? should we prompt?
				MessageDialog.openError(DebugUIPlugin.getShell(), ContextMessages.ContextRunner_5, ContextMessages.ContextRunner_6);
			}
		}
		else if(csize > 1){
			if(!launchMRU(configs, mode)) {
				return showConfigurationSelectionDialog(configs, mode);
			}
		}
		return false;
	}
	
	/**
	 * Launches the first occurance of any one of the configurations in the provided list, if they are found in the launch history
	 * for the corresponding launch group
	 * @param configurations
	 * @param mode
	 * @return true if something launched, false otherwise
	 */
	protected boolean launchMRU(List configurations, String mode) {
		ILaunchGroup group = resolveLaunchGroup(mode);
		if(group != null) {
			LaunchHistory history = DebugUIPlugin.getDefault().getLaunchConfigurationManager().getLaunchHistory(group.getIdentifier());
			HashSet set = new HashSet(configurations);
			ILaunchConfiguration[] configarray = history.getHistory();
			for(int i = 0; i < configarray.length; i++) {
				if(set.contains(configarray[i])) {
					DebugUITools.launch(configarray[i], mode);
					return true;
				}
			}
		}
		return false;
	}
	
	/**
	 * Presents the user with a dialog to pick the launch configuration to launch
	 * @param configurations the listing of applicable configurations to present
	 * @param mode the mode
	 * @return true if something was launched, false otherwise
	 */
	protected boolean showConfigurationSelectionDialog(List configurations, String mode) {
		ListDialog lsd = new ListDialog(DebugUIPlugin.getShell());
		lsd.setContentProvider(new ArrayContentProvider());
		lsd.setLabelProvider(new DefaultLabelProvider());
		lsd.setMessage(ContextMessages.ContextRunner_8);
		lsd.setTitle(ContextMessages.ContextRunner_9);
		lsd.setInput(configurations);
		if(lsd.open() == IDialogConstants.OK_ID) {
			ILaunchConfiguration config = (ILaunchConfiguration) lsd.getResult()[0];
			DebugUITools.launch(config, mode);
			return true;
		}
		return false;
	}
	
	/**
	 * Presents a selection dialog to the user to pick a launch shortcut
	 * @param resource the resource context
	 * @param mode the mode
	 * @return true if something was launched, false otherwise
	 */
	protected boolean showShortcutSelectionDialog(IResource resource, String mode) {
		LaunchShortcutSelectionDialog dialog = new LaunchShortcutSelectionDialog(resource, mode);
		if (dialog.open() == Window.OK) {
			Object[] result = dialog.getResult();
			if(result.length > 0) {
				LaunchShortcutExtension method = (LaunchShortcutExtension) result[0];
				if(method != null) {
					method.launch(new StructuredSelection(resource), mode);
					return true;
			ext = (LaunchShortcutExtension) iter.next();
			if(ext.evalEnablementExpression(context, ext.getContextualLaunchEnablementExpression())) {
				if(!list.contains(ext)) {
					list.add(ext);
				}
			}
		}
		return false;
	}
	
	/**

	 * <li>IEditorInput</li>
	 * <li>Object where <i>object</i> is the first element in the selection obtained from the 
	 * selection provider of the currently selected workbench part</li>
	 * <li><code>null</code>, if the current context is unknown</li>
	 * </ol>
	 * @return the currently selected context to consider for launching, or <code>null</code>.
	 *

							else if(sel instanceof ITextSelection) {
								return part;
							}
							return sel;
						}
						else {
							//default to returning the part, which can be further queried for adapters
							return part;
						}
					}

	 */
	public String getContextName() {
		Object o = getCurrentContext();
		ILaunchConfiguration config = getLaunchConfigurationManager().isSharedConfig(o);
		if(config != null) {
			return config.getName();
		}
		else {
			if(o instanceof IAdaptable) {
				IAdaptable adapt = (IAdaptable) o;
				Object a = adapt.getAdapter(ILaunchConfiguration.class);
				if(a != null) {
					return ((ILaunchConfiguration) a).getName();
				}
				else {
					a = adapt.getAdapter(IResource.class);
					if(a != null) {
						IResource res = (IResource) a;
						return (res.isAccessible() ? res.getName() : ""); //$NON-NLS-1$
					else {
						a = adapt.getAdapter(IResource.class);
						if(a != null) {
							IResource res = (IResource) a;
							return (res.isAccessible() ? res.getName() : ""); //$NON-NLS-1$
						}
					}
				}
			}

	 * Returns if context launching is enabled
	 * @return if context launching is enabled
	 */
	public boolean isContextLaunchEnabled() {
		return DebugUIPlugin.getDefault().getPreferenceStore().getBoolean(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH);
	}
	

	}
	
	/**
	 * Returns the launch configuration manager
	 * @return the launch configuration manager
	public void launchAdded(ILaunch launch) {
		if(fBackingResource != null) {
			try {
				if(fMakeResourceDefault) {
					getLaunchManager().setDefaultConfiguration(fBackingResource, launch.getLaunchConfiguration());
				}
				if(fMakeProjectDefault) {
					getLaunchManager().setDefaultConfiguration(fBackingResource.getProject(), launch.getLaunchConfiguration());
				}
				getLaunchManager().removeLaunchListener(this);
				fMakeProjectDefault = false;
				fMakeResourceDefault = false;
			}
			catch(CoreException ce) {DebugUIPlugin.log(ce);}
		}
	}

	/**
	 * Handles launching the default launch configuration for the specified resource, if there is no default
	 * this method delegates to the <code>handleUnknownContext</code> method to figure out what to do
	 * @param res the resource to find the default configuration for
	 * @param mode the mode to launch it in
	 * @return true if the method launched something false otherwise
	 * @throws CoreException
	 */
	protected LaunchConfigurationManager getLaunchConfigurationManager() {
		return DebugUIPlugin.getDefault().getLaunchConfigurationManager();
		if(config != null && config.exists()) {
			DebugUITools.launch(config, mode);
			return true;
		}
		else {
			return false;
		}
	}
	
	/**
	 * @see org.eclipse.debug.core.ILaunchListener#launchChanged(org.eclipse.debug.core.ILaunch)
	 */
	public void launchChanged(ILaunch launch) {}

	/**
	 * @see org.eclipse.debug.core.ILaunchListener#launchRemoved(org.eclipse.debug.core.ILaunch)
	 */
	public void launchRemoved(ILaunch launch) {}
	
}




/*******************************************************************************
 * Copyright (c) 2007 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.contextlaunching;

import org.eclipse.debug.core.ILaunchManager;

/**
 * Specialization of <code>ContextLaunchingAction</code> for run mode
 * 
 * @see ContextLaunchingAction
 * @see ILaunchManager
 * @see DebugContextLaunchingAction
 * @see ProfileContextLaunchingAction
 * 
 * @since 3.3
 * EXPERIMENTAL
 * CONTEXTLAUNCHING
 */
public class RunContextLaunchingAction extends ContextLaunchingAction {

	/**
	 * Constructor
	 */
	public RunContextLaunchingAction() {
		super(ILaunchManager.RUN_MODE);
	}

}




/*******************************************************************************
 * Copyright (c) 2007 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.contextlaunching;

import org.eclipse.debug.core.ILaunchManager;

/**
 * Specialization of <code>ContextLaunchingAction</code> for debug mode
 * 
 * @see ContextLaunchingAction
 * @see ILaunchManager
 * @see RunContextLaunchingAction
 * @see ProfileContextLaunchingAction
 * 
 * @since 3.3
 * EXPERIMENTAL
 * CONTEXTLAUNCHING
 */
public class DebugContextLaunchingAction extends ContextLaunchingAction {
	
	/**
	 * Constructor
	 */
	public DebugContextLaunchingAction() {
		super(ILaunchManager.DEBUG_MODE);
	}
}

Lines 127-132 Link Here

(-)ui/org/eclipse/debug/internal/ui/actions/ActionMessages.properties (+2 lines)
127	ModifyWatchpointAction_0=Error	127	ModifyWatchpointAction_0=Error
128	ModifyWatchpointAction_1=Failed to modify watchpoint	128	ModifyWatchpointAction_1=Failed to modify watchpoint
129	LaunchShortcutsAction_1=(none applicable)	129	LaunchShortcutsAction_1=(none applicable)
		130	LaunchConfigurationAction_0=&{0} {1}
130	FindDialog_1=&Specify an element to select (? = any character, * = any String):	131	FindDialog_1=&Specify an element to select (? = any character, * = any String):
131	FindDialog_3=Find	132	FindDialog_3=Find
132	FindAction_0=&Find...	133	FindAction_0=&Find...
Lines 165-167 Link Here
165	ConfigureColumnsAction_0=Select &Columns...	166	ConfigureColumnsAction_0=Select &Columns...
166	ConfigureColumnsAction_1=Select the &columns to display:	167	ConfigureColumnsAction_1=Select the &columns to display:
167	ConfigureColumnsAction_2=Select Columns	168	ConfigureColumnsAction_2=Select Columns
		169	ContextualLaunchAction_0={0} (default)

Lines 38-43 Link Here

(-)ui/org/eclipse/debug/internal/ui/actions/ActionMessages.java (+4 lines)
38	public static String ConfigureColumnsAction_0;	38	public static String ConfigureColumnsAction_0;
39	public static String ConfigureColumnsAction_1;	39	public static String ConfigureColumnsAction_1;
40	public static String ConfigureColumnsAction_2;	40	public static String ConfigureColumnsAction_2;
		41
		42	public static String ContextualLaunchAction_0;
41		43
42	public static String CopyToClipboardActionDelegate_Problem_Copying_to_Clipboard_1;	44	public static String CopyToClipboardActionDelegate_Problem_Copying_to_Clipboard_1;
43	public static String CopyToClipboardActionDelegate_There_was_a_problem_when_accessing_the_system_clipboard__Retry__2;	45	public static String CopyToClipboardActionDelegate_There_was_a_problem_when_accessing_the_system_clipboard__Retry__2;
Lines 56-61 Link Here
56	public static String EnableBreakpointAction_Enabling_breakpoints_3;	58	public static String EnableBreakpointAction_Enabling_breakpoints_3;
57	public static String EnableBreakpointAction_Exceptions_occurred_enabling_the_breakpoint_s___4;	59	public static String EnableBreakpointAction_Exceptions_occurred_enabling_the_breakpoint_s___4;
58		60
		61	public static String LaunchConfigurationAction_0;
		62
59	public static String OpenBreakpointMarkerAction__Go_to_File_1;	63	public static String OpenBreakpointMarkerAction__Go_to_File_1;
60	public static String OpenBreakpointMarkerAction_Exceptions_occurred_attempting_to_open_the_editor_for_the_breakpoint_resource_2;	64	public static String OpenBreakpointMarkerAction_Exceptions_occurred_attempting_to_open_the_editor_for_the_breakpoint_resource_2;
61	public static String OpenBreakpointMarkerAction_Go_to_Breakpoint_1;	65	public static String OpenBreakpointMarkerAction_Go_to_Breakpoint_1;

Lines 45-52 Link Here

(-)ui/org/eclipse/debug/internal/ui/actions/LaunchShortcutAction.java (-2 lines)
45	updateEnablement();	45	updateEnablement();
46	}	46	}
47		47
48
49
50	/**	48	/**
51	* Runs with either the active editor or workbench selection.	49	* Runs with either the active editor or workbench selection.
52	*	50	*




import org.eclipse.core.runtime.Platform;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
import org.eclipse.debug.ui.actions.ILaunchable;

/**

					return Platform.getAdapterManager().hasAdapter(receiver, ILaunchable.class.getName());
				}
		}
		if("resource".equals(property)) { //$NON-NLS-1$
			IResource res = getResource(receiver);
			if(res != null) {
				return res.isAccessible();
			}
		}
		if("contextlaunch".equals(property)) { //$NON-NLS-1$
			if(DebugUIPlugin.getDefault().getPreferenceStore().getBoolean(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH)) {
				try {
					IResource res = getResource(receiver);
					if(res != null) {
						return res.isAccessible() && getLaunchConfiguraitonManager().getLaunchShortcuts(getResource(receiver)).size() > 0 && getLaunchConfiguraitonManager().isSharedConfig(receiver) == null;
					}
					return false;
				} 
				catch (CoreException e) {return false;}
			}
			catch (CoreException e) {return false;}
		}
		return false;
	}

	/**
	 * Returns the launch configuration manager
	 * @return the launch configuration manager
	 */
	protected LaunchConfigurationManager getLaunchConfiguraitonManager() {
		return DebugUIPlugin.getDefault().getLaunchConfigurationManager();
	}
	
	/**
	 * Returns the resource this property page is open on.
	 * 
	 * @return resource




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

import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.resource.ImageDescriptor;

/**
 * This class provides an action warpper for adding shared launch configuration actions to the context menu
 * of the Run->... menu item
 * 
 * @since 3.3
 */
public class SharedLaunchConfigAction extends Action {

	private ILaunchConfiguration fConfig;
	private String fMode;
	
	/**
	 * Consturtor
	 * @param text the text for the action
	 * @param image the image for the action
	 */
	public SharedLaunchConfigAction(ILaunchConfiguration config, String mode, ImageDescriptor image) {
		super(config.getName(), image);
		fConfig = config;
		fMode = mode;
	}
	
	/**
	 * Allows access to the launch configuration associated with the action
	 * @return the associated launch configuration
	 */
	public ILaunchConfiguration getLaunchConfiguration() {
		return fConfig;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.Action#run()
	 */
	public void run() {
		DebugUITools.launch(fConfig, fMode);
	}

}




 *******************************************************************************/
package org.eclipse.debug.internal.ui.preferences;

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

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.internal.ui.IDebugHelpContextIds;
import org.eclipse.debug.internal.ui.SWTUtil;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationComparator;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;

	private Set fOriginalCandidates;
	
	/**
	 * Holds configurations that need to be saved when the page closes
	 */
	private Set fChangedConfigurations = new HashSet();
	
	/**
	 * List of the applicable launch config types for the backing resource
	 */
	private List fTypeCandidates = null;

	}

	/**
	 * @see org.eclipse.jface.dialogs.DialogPage#dispose()
	 */
	public void dispose() {
		if(fOriginalCandidates != null) {
			fOriginalCandidates.clear();
			fOriginalCandidates = null;
		}
		if(fChangedConfigurations != null) {
			fChangedConfigurations.clear();
			fChangedConfigurations = null;
		}
		super.dispose();
	}

	/**
	 * Returns the viewer displaying possible default configurations.
	 * 
	 * @return viewer

	protected Set collectConfigCandidates(IResource resource) {
		if(fOriginalCandidates == null) {
			fOriginalCandidates = new HashSet();
			IPath resourcePath = resource.getFullPath();
			try {
				List configs = DebugUIPlugin.getDefault().getLaunchConfigurationManager().getApplicableLaunchConfigurations(resource);
				for(Iterator iter = configs.iterator(); iter.hasNext();) {
					fOriginalCandidates.add(((ILaunchConfiguration)iter.next()).getWorkingCopy());
				for(int i = 0; i < configurations.length; i++) {
					if(types.contains(configurations[i].getType())) {
						if(configurations[i].isMigrationCandidate()) {
							configurations[i].migrate();
						}
						configs.add(configurations[i]);
					}
				}
				ILaunchConfiguration configuration = null;
				IResource[] resources = null;
				for (Iterator iter = configs.iterator(); iter.hasNext();) {
					configuration = (ILaunchConfiguration) iter.next();
					if(acceptConfiguration(configuration)) { 
						if(configuration.contentsEqual(getLaunchManager().getDefaultConfiguration(resource))) {
							fOriginalCandidates.add(configuration.getWorkingCopy());
						}
						else {
							resources = configuration.getMappedResources();
							if (resources != null) {
								for (int j = 0; j < resources.length; j++) {
									if (resource.equals(resources[j]) || resourcePath.isPrefixOf(resources[j].getFullPath())) {
										fOriginalCandidates.add(configuration.getWorkingCopy());
										break;
									}
								}
							}
							else {
								//in the event the config has no mapping
								fOriginalCandidates.add(configuration.getWorkingCopy());
							}
						}
					}
				}
			} catch (CoreException e) {
				fOriginalCandidates.clear();
				DebugPlugin.log(e);
			}
			catch(CoreException ce) {DebugUIPlugin.log(ce);}
		}
		return fOriginalCandidates;
	}
	
	
	 * Returns if the specified configuration should be considered as a potential candidate
	 * @param config
	 * @return if the specified configuration should be considered as a potential candidate
	 * @throws CoreException
	 */
	private boolean acceptConfiguration(ILaunchConfiguration config) throws CoreException {
		if(config != null && !DebugUITools.isPrivate(config)) {
			if(!"org.eclipse.ui.externaltools".equals(config.getType().getCategory())) { //$NON-NLS-1$
				return true;
			}
			else {
				IResource[] res = config.getMappedResources();
				if(res != null) {
					return true;
				}
			}
		}
		return false;
	}
	
	/**
	 * Returns the resource this property page is open on.

			}
		}
	//add
		iter = fChangedConfigurations.iterator();
		while (iter.hasNext()) {
			ILaunchConfigurationWorkingCopy currentConfig = (ILaunchConfigurationWorkingCopy) iter.next();
			try{
				currentConfig.doSave();
			} catch (CoreException e) {
				DebugPlugin.logMessage("Problem saving changes to configuration " + currentConfig.getName(), e); //$NON-NLS-1$
					DebugPlugin.logMessage("Problem saving changes to configuration " + currentConfig.getName(), e); //$NON-NLS-1$
				}
			}
		}
		

	private Set getConfigurationNames() {
		Set names = new HashSet();
		Iterator iter = fOriginalCandidates.iterator();
		Object o = null;
		while (iter.hasNext()) {
			names.add(((ILaunchConfiguration)iter.next()).getName());
		}
		iter = fChangedConfigurations.iterator();
		while (iter.hasNext()) {
			names.add(((ILaunchConfiguration)iter.next()).getName());
		}
		return names;
	}

			ILaunchConfigurationWorkingCopy copy = configuration.copy(
					((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).generateUniqueLaunchConfigurationNameFrom(configuration.getName(), getConfigurationNames()));
			copy.setAttributes(configuration.getAttributes());
			fChangedConfigurations.add(copy);
			fViewer.add(copy);
			fViewer.setSelection(new StructuredSelection(copy));
		} catch (CoreException e) {
			setErrorMessage(e.getMessage());

		ILaunchConfiguration[] configurations = getSelectedConfigurations();
		for (int i = 0; i < configurations.length; i++) {
			fDeletedConfigurations.add(configurations[i]);
			fChangedConfigurations.remove(configurations[i]);
			fViewer.remove(configurations[i]);
		}
		fViewer.refresh();
		if (indices[0] < table.getItemCount()) {
			fViewer.setSelection(new StructuredSelection(table.getItem(indices[0]).getData()));
		} else if (table.getItemCount() > 0) {

	 * Edit the selection
	 */
	private void handleEdit() {
		ILaunchConfigurationWorkingCopy config = getSelectedConfigurations()[0]; 
		if(edit(config) == IDialogConstants.OK_ID) {
			fChangedConfigurations.add(config);
			fViewer.refresh();
		}
	}

	/**

							((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).
							generateUniqueLaunchConfigurationNameFrom("New_configuration", getConfigurationNames())); //$NON-NLS-1$
					if (edit(wc) == Window.OK) {
						fChangedConfigurations.add(wc);
						fViewer.add(wc);
						fViewer.setSelection(new StructuredSelection(wc));
					}
				} catch (CoreException e) {




import org.eclipse.debug.internal.ui.IDebugHelpContextIds;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.SWTUtil;
import org.eclipse.jface.dialogs.MessageDialogWithToggle;
import org.eclipse.jface.preference.BooleanFieldEditor;
import org.eclipse.jface.preference.FieldEditor;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.jface.preference.RadioGroupFieldEditor;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

	//use contextual launch
		FieldEditor edit = new BooleanFieldEditor(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH, DebugPreferencesMessages.ContextualLaunchPreferencePage_1, comp);	
		fFieldEditors.add(edit);
			
		edit = new RadioGroupFieldEditor(IInternalDebugUIConstants.PREF_ALWAYS_RUN_LAST_LAUNCH, DebugPreferencesMessages.ContextLaunchingPreferencePage_0, 3, 
				new String[][] {{DebugPreferencesMessages.LaunchingPreferencePage_3, MessageDialogWithToggle.ALWAYS}, 
				 {DebugPreferencesMessages.LaunchingPreferencePage_5, MessageDialogWithToggle.PROMPT}},
				 comp, true);	
		fFieldEditors.add(edit);
		edit = new RadioGroupFieldEditor(IInternalDebugUIConstants.PREF_ALWAYS_RUN_PROJECT_CONFIGURATION, DebugPreferencesMessages.ContextLaunchingPreferencePage_1, 3, 
				new String[][] {{DebugPreferencesMessages.LaunchingPreferencePage_7, MessageDialogWithToggle.ALWAYS}, 
				 {DebugPreferencesMessages.LaunchingPreferencePage_9, MessageDialogWithToggle.PROMPT}},
				 comp, true);	
		fFieldEditors.add(edit);
	//init the field editors
		FieldEditor editor;
		for(int i = 0; i < fFieldEditors.size(); i++) {





import org.eclipse.core.expressions.EvaluationContext;
import org.eclipse.core.expressions.IEvaluationContext;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ISaveContext;
import org.eclipse.core.resources.ISaveParticipant;

import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunch;

import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.ILaunchHistoryChangedListener;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.debug.ui.ILaunchConfigurationTab;
import org.eclipse.debug.ui.ILaunchGroup;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.activities.IWorkbenchActivitySupport;
import org.eclipse.ui.activities.WorkbenchActivityHelper;
import org.osgi.service.prefs.BackingStoreException;
import org.osgi.service.prefs.Preferences;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

	}

	/**
	 * Returns the list of launch shortcuts that have been filtered to conform to current workbench activities
	 * @return a workbench activity filtered list of launch shortcuts, or an empty list, never <code>null</code>
	 * @since 3.3 
	 */
	public List getActivityFilteredLaunchShortcuts() {
		List shortcuts = new ArrayList();
		List sc = getLaunchShortcuts();
		LaunchShortcutExtension ext = null;
		for(Iterator iter = sc.iterator(); iter.hasNext();) {
			ext = (LaunchShortcutExtension) iter.next();
			if(!WorkbenchActivityHelper.filterItem(ext)) {
				if(!shortcuts.contains(ext)) {
					shortcuts.add(ext);
				}
			}
		}
		return shortcuts;
	}
	
	/**
	 * Creates a listing of the launch shortcut extensions that are applicable to the underlying resource
	 * @param resource the underlying resource
	 * @return a listing of applicable launch shortcuts or an empty list, never <code>null</code>
	 * @throws CoreException
	 * @since 3.3
	 */
	public List getLaunchShortcuts(IResource resource) throws CoreException {
		List list = new ArrayList(); 
		List sc = getLaunchShortcuts();
		List ctxt = new ArrayList();
		ctxt.add(resource);
		IEvaluationContext context = new EvaluationContext(null, ctxt);
		context.addVariable("selection", ctxt); //$NON-NLS-1$
		LaunchShortcutExtension ext = null;
		for(Iterator iter = sc.iterator(); iter.hasNext();) {
			ext = (LaunchShortcutExtension) iter.next();
			if(ext.evalEnablementExpression(context, ext.getContextualLaunchEnablementExpression()) && !WorkbenchActivityHelper.filterItem(ext)) {
				if(!list.contains(ext)) {
					list.add(ext);
				}
			}
		}
		return list;
	}
	
	/**
	 * Returns a listing of all of the <code>ILaunchConfigurationType</code>s that apply to the currently
	 * specified <code>IResource</code>.
	 * 
	 * @param resource the resource context
	 * @return a listing of applicable <code>ILaunchConfigurationType</code>s, or an empty list, never <code>null</code>
	 * @since 3.3
	 * EXPERIMENTAL
	 * CONTEXTLAUNCHING
	 */
	public List getApplicableConfigurationTypes(IResource resource) {

	}
	
	/**
	 * Returns a list of the <code>ILaunchConfiguration</code>s that apply to the specified <code>IResource</code>
	 * @param resource the resource
	 * @return a listing of applicable <code>ILaunchConfiguration</code>s for the specified <code>IResource</code> or an empty 
	 * list if none, never <code>null</code>
	 * @since 3.3
	 */
	public List getApplicableLaunchConfigurations(IResource resource) {
		ArrayList list = new ArrayList();
		IPath resourcePath = resource.getFullPath();
		try {
			List types = getApplicableConfigurationTypes(resource);
			List configs = new ArrayList();
			ILaunchConfiguration[] configurations = getLaunchManager().getLaunchConfigurations();
			for(int i = 0; i < configurations.length; i++) {
				if(types.contains(configurations[i].getType())) {
					if(configurations[i].isMigrationCandidate()) {
						configurations[i].migrate();
					}
					configs.add(configurations[i]);
				}
			}
			ILaunchConfiguration configuration = null;
			IResource[] resources = null;
			for (Iterator iter = configs.iterator(); iter.hasNext();) {
				configuration = (ILaunchConfiguration) iter.next();
				if(acceptConfiguration(configuration)) { 
					if(configuration.contentsEqual(getLaunchManager().getDefaultConfiguration(resource))) {
						list.add(configuration);
					}
					else {
						resources = configuration.getMappedResources();
						if (resources != null) {
							for (int j = 0; j < resources.length; j++) {
								if (resource.equals(resources[j]) || resourcePath.isPrefixOf(resources[j].getFullPath())) {
									list.add(configuration);
									break;
								}
							}
						}
						else {
							//in the event the config has no mapping
							list.add(configuration);
						}
					}
				}
			}
		} catch (CoreException e) {
			list.clear();
			DebugPlugin.log(e);
		}
		return list;
	}
	
	/**
	 * Returns if the specified configuration should be considered as a potential candidate
	 * @param config
	 * @return if the specified configuration should be considered as a potential candidate
	 * @throws CoreException
	 */
	private boolean acceptConfiguration(ILaunchConfiguration config) throws CoreException {
		if(config != null && !DebugUITools.isPrivate(config)) {
			if(!"org.eclipse.ui.externaltools".equals(config.getType().getCategory())) { //$NON-NLS-1$
				return true;
			}
			else {
				IResource[] res = config.getMappedResources();
				if(res != null) {
					return true;
				}
			}
		}
		return false;
	}
	
	/**
	 * Returns a listing of all applicable <code>LaunchShortcutExtension</code>s for the given
	 * launch configuration type id.
	 * @param typeid the id of the launch configuration

	 * or <code>null</code>
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 * CONTEXTLAUNCHING
	 */
	public LaunchShortcutExtension getLaunchShortcut(String id) {
		loadLaunchShortcuts();

	}
	
	/**
	 * Returns the shared config from the selected resource or <code>null</code> if the selected resources is not a shared config
	 * @param receiver the object to test if it is a shared launch configuration
	 * @return the shared config from the selected resource or <code>null</code> if the selected resources is not a shared config
	 * @since 3.3
	 */
	public ILaunchConfiguration isSharedConfig(Object receiver) {
		if(receiver instanceof IFile) {
			IFile file = (IFile) receiver;
			String ext = file.getFileExtension();
			if(ext == null) {
				return null;
			}
			if(ext.equals("launch")) { //$NON-NLS-1$
				ILaunchConfiguration config = DebugPlugin.getDefault().getLaunchManager().getLaunchConfiguration(file);
				if(config != null && config.exists()) {
					return config;
				}
			}
		}
		else if(receiver instanceof IFileEditorInput) {
			IFileEditorInput input = (IFileEditorInput) receiver;
			return isSharedConfig(input.getFile());
		}
		return null;
	}
	
	/**
	 * Returns the image used to display an error in the given tab
	 */
	public Image getErrorTabImage(ILaunchConfigurationTab tab) {

	}	
	
	/**
	 * Returns the singleton instance of the launch manager
	 * @return the singleton instance of the launch manager
	 * @since 3.3
	 */
	private LaunchManager getLaunchManager() {
		return (LaunchManager) DebugPlugin.getDefault().getLaunchManager();
	}
	
	/**
	 * Restore launch history
	 */
	private void loadLaunchHistories() {

	}
	
	/**
	 * This method allows a default launch shortcut to be specified for the given resource. This sets
	 * a default way of <i>how</i> something should be launched, not what specific <code>ILaunchConfiguration</code>
	 * will do the launching. Passing in <code>null</code> for a shortcut will remove the attribute.
	 * 
	 * @see {@link ILaunchManager#setDefaultConfiguration(IResource, ILaunchConfiguration)}
	 * @param resource the resource to map the specified launch shortcut to
	 * @param shortcut the shortcut to map
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 * CONTEXTLAUNCHING
	 */
	public void setDefaultLaunchShortcut(IResource resource, LaunchShortcutExtension shortcut) 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 shortcut on and within projects.", null)); //$NON-NLS-1$ (internal error)
		}
		Preferences node = getInstanceNode(resource);
		if(shortcut != null) {
			node.put(IConfigurationElementConstants.DEFAULT_LAUNCH_SHORTCUT, shortcut.getId());
		}
		else {
			node.remove(IConfigurationElementConstants.DEFAULT_LAUNCH_SHORTCUT);
		}
		try {
			node.flush();
		} 
		catch (BackingStoreException e) {DebugUIPlugin.log(e);}
	}
	
	/**
	 * This method allows access to the default <code>LaunchShortcutExtension</code> for
	 * the specified <code>IResource</code>.
	 * 
	 * @see {@link ILaunchManager#getDefaultConfiguration(IResource)}
	 * @param resource the resource
	 * @return the corresponding <code>LaunchShortcutExtension</code> for the given <code>IResource</code>,
	 * or <code>null</code> if there is not one.
	 * 
	 * @since 3.3
	 * 
	 * EXPERIMENTAL
	 * CONTEXTLAUNCHING
	 */
	public LaunchShortcutExtension getDefaultLaunchShortcut(IResource resource) {
		IProject project = resource.getProject();
		if (project != null) {
			Preferences node = getInstanceNode(resource);
			String id = node.get(IConfigurationElementConstants.DEFAULT_LAUNCH_SHORTCUT, null);
			if(id != null) {
				return getLaunchShortcut(id);
			}
		}
		return null;
	}
	
	/**
	 * Returns the node for instance project preferences
	 * @param resource the resource to get the node for
	 * @return the instance node for debug UI
	 */
	private org.osgi.service.prefs.Preferences getInstanceNode(IResource resource) {
		org.osgi.service.prefs.Preferences node = Platform.getPreferencesService().getRootNode();
		node = node.node(InstanceScope.SCOPE).node(DebugUIPlugin.getUniqueIdentifier());
		return node.node(resource.getFullPath().makeRelative().toString());
	}
	
	/**
	 * Returns the default launch group for the given mode.
	 * 
	 * @param mode




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.contextlaunching.ContextRunner;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.PlatformUI;

	 */
	private String fMode = null;
	private IResource fResource = null;
	private boolean fChecked = false;
	private boolean fProject = false;
	private boolean fShowProject = false;
	private boolean fShowResource = false;
	
	/**
	 * Constructor

	 * @param resource
	 * @param mode
	 */
	public LaunchShortcutSelectionDialog(IResource resource, String mode) {
		super(DebugUIPlugin.getShell());
		setShellStyle(getShellStyle() | SWT.RESIZE);
		fResource = resource;
		fMode = mode;
		fShowProject = showproject;
		fShowResource = showresource;
		ILaunchMode lmode = DebugPlugin.getDefault().getLaunchManager().getLaunchMode(fMode);
		String modename = fMode;
		if (lmode != null) {

	protected Control createDialogArea(Composite container) {
		Composite comp = (Composite) super.createDialogArea(container);
		try {
			List input = new ArrayList(DebugUIPlugin.getDefault().getLaunchConfigurationManager().getLaunchShortcuts(fResource));
			Button butt = null;
			if(!input.isEmpty()) {
				if(fShowResource) {
					butt = SWTUtil.createCheckButton(comp, MessageFormat.format(LaunchConfigurationsMessages.LaunchShortcutSelectionDialog_2, new String[] {fResource.getName()}), null, fChecked);
					butt.addSelectionListener(new SelectionListener() {
						public void widgetDefaultSelected(SelectionEvent e) {}
						public void widgetSelected(SelectionEvent e) {
							fChecked = ((Button)e.getSource()).getSelection();
						}
					});
				}
				if(fShowProject) {
					butt = SWTUtil.createCheckButton(comp, MessageFormat.format(LaunchConfigurationsMessages.LaunchShortcutSelectionDialog_3, new String[] {fResource.getProject().getName()}), null, false);
					butt.addSelectionListener(new SelectionListener() {
						public void widgetDefaultSelected(SelectionEvent e) {}
						public void widgetSelected(SelectionEvent e) {
							fProject = ((Button)e.getSource()).getSelection();
						}
					});
				}
			}
			getTableViewer().setInput(input);
		}
		catch(CoreException ce) {DebugUIPlugin.log(ce);}
		return comp;
	}
 
	/**
	 * Returns if the launched config from the selected shortcut should be made the default for the underlying resource
	 * @return if the launched config should be made the default
	 */
	public boolean makeDefault() {
		return fChecked;
	}
	
	/**
	 * Returns if the launched config from the selected shortcut should be made the default for the underlying resources' associated project
	 * @return if the launched config from the selected shortcut should be made the default for the underlying resources' associated project
	 */
	public boolean makeProjectDefault() {
		return fProject;
	}
}




import org.eclipse.core.expressions.EvaluationContext;
import org.eclipse.core.expressions.Expression;
import org.eclipse.core.expressions.IEvaluationContext;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.actions.ActionMessages;
import org.eclipse.debug.internal.ui.actions.LaunchConfigurationAction;
import org.eclipse.debug.internal.ui.actions.LaunchShortcutAction;
import org.eclipse.debug.internal.ui.actions.SharedLaunchConfigAction;
import org.eclipse.debug.internal.ui.contextlaunching.ContextRunner;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchShortcutExtension;
import org.eclipse.debug.ui.DebugUITools;

import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.activities.WorkbenchActivityHelper;

import com.ibm.icu.text.MessageFormat;

/**
 * An action delegate that builds a context menu with applicable launch shortcuts
 * for a specific launch mode.

		menu.addMenuListener(new MenuAdapter() {
			public void menuShown(MenuEvent e) {
				if (fFillMenu) {
					try {
						Menu m = (Menu)e.widget;
						MenuItem[] items = m.getItems();
						for (int i=0; i < items.length; i++) {
							items[i].dispose();
						}
						fillMenu(m);
					}
					catch(CoreException ce) {}
					fFillMenu = false;
				}
			}

	}
	
	/**
	 * Returns the resource this menu is open on.
	 * 
	 * @return resource
	 * @param menu the menu to add the new action to.
	 * @since 3.3
	 */
	protected IResource getResource(Object element) {
		IResource resource = null;
		if (element instanceof IResource) {
			resource = (IResource) element;
		} else if (element instanceof IAdaptable) {
			resource = (IResource) ((IAdaptable)element).getAdapter(IResource.class);
		}
		return resource;
        } catch (CoreException e) {
        }
	}
	
    /**
     * Fills the menu with applicable launch shortcuts
     * @param menu The menu to fill
     */
	protected void fillMenu(Menu menu) throws CoreException {
		if (fSelection == null) {
			return;
		}
		IEvaluationContext context = createContext();
		//add in any selected shared configs before the rest of the items to launch as
		//feature fix for 
		//CONTEXTLAUNCHING
		Object obj = fSelection.getFirstElement();
		int accelerator = 1;
		ILaunchConfiguration config = getLaunchManager().getDefaultConfiguration(getResource(obj));
		if(config != null && config.exists() && config.supportsMode(fMode)) {
        	IAction action = new LaunchConfigurationAction(config, fMode, MessageFormat.format(ActionMessages.ContextualLaunchAction_0, new String[] {config.getName()}), DebugUITools.getDefaultImageDescriptor(config), accelerator++);
            ActionContributionItem item = new ActionContributionItem(action);
            item.fill(menu, -1);
            new MenuItem(menu, SWT.SEPARATOR);
		}
		config = getLaunchConfigurationManager().isSharedConfig(obj);
        if(config != null && config.exists() && config.supportsMode(fMode)) {
        	IAction action = new LaunchConfigurationAction(config, fMode, config.getName(), DebugUITools.getDefaultImageDescriptor(config), accelerator++);
            ActionContributionItem item = new ActionContributionItem(action);
            item.fill(menu, -1);
            new MenuItem(menu, SWT.SEPARATOR);
		}
		List allShortCuts = getLaunchConfigurationManager().getLaunchShortcuts();
		Iterator iter = allShortCuts.iterator();

			catch (CoreException e) {DebugUIPlugin.log(e);}
		}
		iter = filteredShortCuts.iterator();
		
		List categories = new ArrayList();
		while (iter.hasNext()) {
			LaunchShortcutExtension ext = (LaunchShortcutExtension) iter.next();

Lines 186-192 Link Here

(-)ui/org/eclipse/debug/ui/actions/AbstractLaunchHistoryAction.java (-2 / +2 lines)
186	String launchName= configuration.getName();	186	String launchName= configuration.getName();
187	String label = null;	187	String label = null;
188	//CONTEXTLAUNCHING	188	//CONTEXTLAUNCHING
189	if(ContextRunner.isContextLaunchEnabled() && !getLaunchGroupIdentifier().equals("org.eclipse.ui.externaltools.launchGroup")) { //$NON-NLS-1$	189	if(ContextRunner.getDefault().isContextLaunchEnabled() && !getLaunchGroupIdentifier().equals("org.eclipse.ui.externaltools.launchGroup")) { //$NON-NLS-1$
190	launchName = ContextRunner.getDefault().getContextName();	190	launchName = ContextRunner.getDefault().getContextName();
191	}	191	}
192	String mode = getMode();	192	String mode = getMode();
Lines 342-348 Link Here
342	if (fAction == null) {	342	if (fAction == null) {
343	initialize(action);	343	initialize(action);
344	}	344	}
345	if(ContextRunner.isContextLaunchEnabled()) {	345	if(ContextRunner.getDefault().isContextLaunchEnabled()) {
346	updateTooltip();	346	updateTooltip();
347	}	347	}
348	}	348	}




import org.eclipse.debug.internal.ui.IDebugHelpContextIds;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.contextlaunching.ContextMessages;
import org.eclipse.debug.internal.ui.contextlaunching.ContextRunner;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchGroupExtension;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchHistory;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;

 * </p>
 * @since 2.1
 */
public class OpenLaunchDialogAction extends Action implements IActionDelegate2, IWorkbenchWindowActionDelegate {

	/**
	 * Launch group identifier

	/**
	 * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#dispose()
	 */
	public void dispose() {}
		DebugUIPlugin.getDefault().getPreferenceStore().removePropertyChangeListener(this);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IActionDelegate2#init(org.eclipse.jface.action.IAction)
	 */
	public void init(IAction action) {
		fBackingAction = action;
		DebugUIPlugin.getDefault().getPreferenceStore().addPropertyChangeListener(this);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IDebugHelpContextIds.OPEN_LAUNCH_CONFIGURATION_ACTION);
		updateActionState();
	}

		LaunchGroupExtension extension = DebugUIPlugin.getDefault().getLaunchConfigurationManager().getLaunchGroup(fIdentifier);
		if(fBackingAction == null) {
			//there is no backing action, like a toolbar action delegate
			setText(MessageFormat.format(ContextMessages.OpenLaunchDialogAction_0, new String[] {extension.getLabel()}));
			setImageDescriptor(extension.getImageDescriptor());
				setImageDescriptor(null);
			}
			else {
				setText(extension.getLabel() + "..."); //$NON-NLS-1$
				setImageDescriptor(extension.getImageDescriptor());
			}
			setEnabled(existsConfigTypesForMode());
		}
		else {
			fBackingAction.setText(MessageFormat.format(ContextMessages.OpenLaunchDialogAction_1, new String[] {DebugUIPlugin.removeAccelerators(extension.getLabel())}));
			fBackingAction.setImageDescriptor(extension.getImageDescriptor());
			fBackingAction.setEnabled(existsConfigTypesForMode());
		}
	}
	
	/**




import org.eclipse.core.expressions.EvaluationContext;
import org.eclipse.core.expressions.Expression;
import org.eclipse.core.expressions.IEvaluationContext;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchMode;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.actions.ActionMessages;
import org.eclipse.debug.internal.ui.actions.LaunchConfigurationAction;
import org.eclipse.debug.internal.ui.actions.LaunchShortcutAction;
import org.eclipse.debug.internal.ui.contextlaunching.ContextRunner;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchShortcutExtension;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.ILaunchGroup;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ActionContributionItem;

import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MenuAdapter;
import org.eclipse.swt.events.MenuEvent;
import org.eclipse.swt.widgets.Control;

import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.activities.WorkbenchActivityHelper;

import com.ibm.icu.text.MessageFormat;

/**
 * A cascading sub-menu that shows all launch shortcuts pertinent to a
 * selection. This action is similar to <code>ContextualLaunchAction</code>

	}	
	
	/**
	 * Returns the resource this menu is open on.
	 * 
	 * @return resource
	 */
	protected IResource getResource(Object element) {
		IResource resource = null;
		if (element instanceof IResource) {
			resource = (IResource) element;
		} else if (element instanceof IAdaptable) {
			resource = (IResource) ((IAdaptable)element).getAdapter(IResource.class);
		}
		return resource;
	}
	
	/**
	 * Fills the flyout menu 
	 */
	private void fillMenu() {
		try {
			Object selection = ContextRunner.getDefault().getCurrentContext();
			int accelerator = 1;
			ILaunchConfiguration config = DebugPlugin.getDefault().getLaunchManager().getDefaultConfiguration(getResource(selection));
			if(config != null && config.exists() && config.supportsMode(getMode())) {
	        	IAction action = new LaunchConfigurationAction(config, getMode(), MessageFormat.format(ActionMessages.ContextualLaunchAction_0, new String[] {config.getName()}), DebugUITools.getDefaultImageDescriptor(config), accelerator++);
	            ActionContributionItem item = new ActionContributionItem(action);
	            item.fill(fCreatedMenu, -1);
	            new MenuItem(fCreatedMenu, SWT.SEPARATOR);
			}
			config = getLaunchConfigurationManager().isSharedConfig(selection);
	        if(config != null && config.exists() && config.supportsMode(getMode())) {
	        	IAction action = new LaunchConfigurationAction(config, getMode(), config.getName(), DebugUITools.getDefaultImageDescriptor(config), accelerator++);
	            ActionContributionItem item = new ActionContributionItem(action);
	            item.fill(fCreatedMenu, -1);
	            new MenuItem(fCreatedMenu, SWT.SEPARATOR);
			}
		}
		catch(CoreException ce) {DebugUIPlugin.log(ce);}
		IEvaluationContext context = createContext();
		List allShortCuts = getLaunchConfigurationManager().getLaunchShortcuts(fGroup.getCategory());
		// filters one time for each shortcut. Running filters can be expensive.
		// Also, only *LOADED* plug-ins get their filters run.
		List /* <LaunchShortcutExtension> */ allShortCuts = getLaunchConfigurationManager().getLaunchShortcuts(fGroup.getCategory());
		Iterator iter = allShortCuts.iterator();
		List filteredShortCuts = new ArrayList(10);
		while (iter.hasNext()) {





import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.contextlaunching.ContextLaunchingToolbarAction;
import org.eclipse.debug.internal.ui.contextlaunching.ContextRunner;
import org.eclipse.debug.internal.ui.launchConfigurations.OrganizeFavoritesAction;
import org.eclipse.debug.ui.DebugUITools;

	 */
	protected void fillMenu(Menu menu) {
		super.fillMenu(menu);

		// Separator between history and common actions
		if (menu.getItemCount() > 0) {
			addSeparator(menu);
		}
		addToMenu(menu, new LaunchShortcutsAction(getLaunchGroupIdentifier()), -1);
		if(!getLaunchGroupIdentifier().equals("org.eclipse.ui.externaltools.launchGroup")) { //$NON-NLS-1$
			if(ContextRunner.isContextLaunchEnabled()) {
				addToMenu(menu, new ContextLaunchingToolbarAction(getLaunchGroupIdentifier()), -1);
			}
			else {
				addToMenu(menu, new LaunchShortcutsAction(getLaunchGroupIdentifier()), -1);
			}
		}
		addToMenu(menu, getOpenDialogAction(), -1);
		addToMenu(menu, new OrganizeFavoritesAction(getLaunchGroupIdentifier()), -1);
	}

	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
	 */
	public void run(IAction action) {
		if(ContextRunner.getDefault().isContextLaunchEnabled()) {
		if(ContextRunner.isContextLaunchEnabled() && !getLaunchGroupIdentifier().equals("org.eclipse.ui.externaltools.launchGroup")) { //$NON-NLS-1$
			ContextRunner.getDefault().launch(getMode());
		}
		else {

Lines 51-58 Link Here

(-)ui/org/eclipse/debug/internal/ui/DebugUIPreferenceInitializer.java (-2 lines)
51		51
52	//contextual launching preference page	52	//contextual launching preference page
53	prefs.setDefault(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH, false);	53	prefs.setDefault(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH, false);
54	prefs.setDefault(IInternalDebugUIConstants.PREF_ALWAYS_RUN_LAST_LAUNCH, MessageDialogWithToggle.PROMPT);
55	prefs.setDefault(IInternalDebugUIConstants.PREF_ALWAYS_RUN_PROJECT_CONFIGURATION, MessageDialogWithToggle.PROMPT);
56		54
57	//View Management preference page	55	//View Management preference page
58	prefs.setDefault(IDebugUIConstants.PREF_MANAGE_VIEW_PERSPECTIVES, IDebugUIConstants.ID_DEBUG_PERSPECTIVE);	56	prefs.setDefault(IDebugUIConstants.PREF_MANAGE_VIEW_PERSPECTIVES, IDebugUIConstants.ID_DEBUG_PERSPECTIVE);




    public static final String PREF_USE_CONTEXTUAL_LAUNCH= IDebugUIConstants.PLUGIN_ID + ".UseContextualLaunch"; //$NON-NLS-1$
    
    /**
     * always/never/prompt preference indicating the action for the event when there is no context to launch during context launching 
     * 
     * @since 3.3
     *  
     *  CONTEXTLAUNCHING
     */
    public static final String PREF_ALWAYS_RUN_LAST_LAUNCH = IDebugUIConstants.PLUGIN_ID + ".AlwaysRunLastLaunch"; //$NON-NLS-1$
    
    /**
     * always/never/prompt preference indicating the action to take when an un-runnable file is the context
     * 
     * @since 3.3
     * 
     * CONTEXTLAUNCHING
     */
    public static final String PREF_ALWAYS_RUN_PROJECT_CONFIGURATION = IDebugUIConstants.PLUGIN_ID + ".ALwaysRunProjectConfiguration"; //$NON-NLS-1$
    
    /**
     * String preference controlling whether editors are saved before launching.
     * Valid values are either "always", "never", or "prompt".
     * If "always" or "never", launching will save editors (or not) automatically.




               id="org.eclipse.debug.ui.contextualLaunch.profile.submenu">
        </action>    
        <enablement>
          <test property="org.eclipse.debug.ui.launchable" value="profile"/>
          	<test property="org.eclipse.debug.ui.launchable" value="profile"/>
          	<not>
          		<test property="org.eclipse.debug.ui.contextlaunch" />
          	</not>
          </and>
        </enablement>        
      </objectContribution>
      <objectContribution

               id="org.eclipse.debug.ui.contextualLaunch.debug.submenu">
         </action>
         <enablement>
         	<test property="org.eclipse.debug.ui.launchable" value="debug"/>
          	<test property="org.eclipse.debug.ui.launchable" value="debug"/>
          	<not>
          		<test property="org.eclipse.debug.ui.contextlaunch" />
          	</not>
          </and>
         </enablement>     
       </objectContribution>    
       <objectContribution

               id="org.eclipse.debug.ui.contextualLaunch.run.submenu">
         </action>                  
         <enablement>
          <and>
          	<test property="org.eclipse.debug.ui.launchable" value="run"/>
          	<not>
          		<test property="org.eclipse.debug.ui.contextlaunch" />
          	</not>
          </and>
         </enablement>
      </objectContribution>
       <objectContribution
             id="org.eclipse.debug.ui.contextlaunch.debugas"
             objectClass="org.eclipse.core.runtime.IAdaptable">
          <action
                class="org.eclipse.debug.internal.ui.contextlaunching.DebugContextLaunchingAction"
                enablesFor="1"
                icon="icons/full/etool16/debug_exc.gif"
                id="org.eclipse.debug.ui.contextlaunch.debugas"
                label="%ContextLaunchingDebugMenu.name"
                menubarPath="additions"
                tooltip="%ContextLaunchingDebugMenu.tooltip">
          </action>
          <enablement>
          <and>
            <test
                  property="org.eclipse.debug.ui.resource"
                  />
          	<test
                 property="org.eclipse.debug.ui.contextlaunch"
                 />
          	<test property="org.eclipse.debug.ui.launchable" value="debug"/>
          </and>
         </enablement>
       </objectContribution>
       <objectContribution
             id="org.eclipse.debug.ui.contextlaunch.profileas"
             objectClass="org.eclipse.core.runtime.IAdaptable">
          <action
                class="org.eclipse.debug.internal.ui.contextlaunching.ProfileContextLaunchingAction"
                enablesFor="1"
                icon="icons/full/etool16/profile_exc.gif"
                id="org.eclipse.debug.ui.contextlaunch.profileas"
                label="%ContextLaunchingProfileMenu.name"
                menubarPath="additions"
                tooltip="%ContextLaunchingProfileMenu.tooltip">
          </action>
          <enablement>
          <and>
            <test
                  property="org.eclipse.debug.ui.resource"
                  />
          	<test property="org.eclipse.debug.ui.contextlaunch" />
          	<test property="org.eclipse.debug.ui.launchable" value="profile"/>
          </and>
         </enablement> 
       </objectContribution>
   <!-- console additions -->
      <objectContribution
            id="org.eclipse.debug.ui.contextlaunch.runas"
            objectClass="org.eclipse.core.runtime.IAdaptable">
         <action
               class="org.eclipse.debug.internal.ui.contextlaunching.RunContextLaunchingAction"
               enablesFor="1"
               icon="icons/full/etool16/run_exc.gif"
               id="org.eclipse.debug.ui.contextlaunch.runas"
               label="%ContextLaunchingRunMenu.name"
               menubarPath="additions"
               tooltip="%ContextLaunchingRunMenu.tooltip">
         </action>
         <enablement>
          <and>
          	<test property="org.eclipse.debug.ui.contextlaunch" />
          	<test
                 property="org.eclipse.debug.ui.resource"
                 />
          	<test property="org.eclipse.debug.ui.launchable" value="run"/>
          </and>
         </enablement> 
      </objectContribution>
      <viewerContribution
             targetID="org.eclipse.debug.ui.ProcessConsoleType.#ContextMenu"
             id="org.eclipse.debug.ui.processConsoleContextMenu">

               <test
                     property="org.eclipse.debug.ui.contextlaunch"
                     />
               <test
                     property="org.eclipse.debug.ui.contextlaunchable"
                     >
               </test>
               <test
                     property="org.eclipse.debug.ui.resource">
               </test>
            </and>
         </enabledWhen>
      </page>

      </propertyTester>
	  <propertyTester
			namespace="org.eclipse.debug.ui"
			properties="launchable, contextlaunch"
			type="java.lang.Object"
			class="org.eclipse.debug.internal.ui.actions.LaunchablePropertyTester"
			id="org.eclipse.debug.ui.propertyTesters.launchable">		

Lines 195-201 Link Here

(-)ui/org/eclipse/debug/internal/ui/views/variables/details/DetailPaneManager.java (-1 / +1 lines)
195	* @return an evaluatable expression or <code>null</code>	195	* @return an evaluatable expression or <code>null</code>
196	*/	196	*/
197	private Expression getEnablementExpression(){	197	private Expression getEnablementExpression(){
198	// all of this stuff is optional, so...tedius testing is required	198	// all of this stuff is optional, so...tedious testing is required
199	if (fEnablementExpression == null) {	199	if (fEnablementExpression == null) {
200	try{	200	try{
201	IConfigurationElement[] elements = fConfigElement.getChildren(ExpressionTagNames.ENABLEMENT);	201	IConfigurationElement[] elements = fConfigElement.getChildren(ExpressionTagNames.ENABLEMENT);




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

import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.resource.ImageDescriptor;

import com.ibm.icu.text.MessageFormat;

/**
 * This class provides an action wrapper for adding launch configuration actions to the context menu
 * of the Run->... menu item
 * 
 * @since 3.3
 */
public class LaunchConfigurationAction extends Action {

	private ILaunchConfiguration fConfig;
	private String fMode;
	
	/**
	 * Constructor
	 * @param text the text for the action
	 * @param image the image for the action
	 */
	public LaunchConfigurationAction(ILaunchConfiguration config, String mode, String text, ImageDescriptor image, int accelerator) {
		super(MessageFormat.format(ActionMessages.LaunchConfigurationAction_0, new String[] {Integer.toString(accelerator), text}), image);
		fConfig = config;
		fMode = mode;
	}
	
	/**
	 * Allows access to the launch configuration associated with the action
	 * @return the associated launch configuration
	 */
	public ILaunchConfiguration getLaunchConfiguration() {
		return fConfig;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.action.Action#run()
	 */
	public void run() {
		DebugUITools.launch(fConfig, fMode);
	}

}




 *******************************************************************************/
package org.eclipse.jdt.debug.tests.launching;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchShortcutExtension;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.debug.tests.AbstractDebugTest;

/**

		assertNotNull("launch configuration manager cannot be null", lcm);
		assertTrue("there should be 2 or more shortcuts", lcm.getApplicableLaunchShortcuts("org.eclipse.jdt.launching.localJavaApplication").size() >= 2);
	}
	
	/**
	 * test that a default launch shortcut can be set, persisted and retrieved
	 */
	public void testSetDefaultLaunchShortcut() {
		LaunchConfigurationManager lcm = getLaunchConfigurationManager();
		assertNotNull("the launch configuration manager should not be null", lcm);
		LaunchShortcutExtension ext = getJavaApplicationLaunchShortcut();
		assertNotNull("the java launch shortcut should not be null", ext);
		IJavaProject jproject = getJavaProject();
		assertNotNull("the java project should not be null", jproject);
		IProject project = jproject.getProject();
		assertNotNull("the project should not be null", project);
		try {
			assertNull("there should be no default launch shortcut for the test project", lcm.getDefaultLaunchShortcut(project));
			lcm.setDefaultLaunchShortcut(project, ext);
			ext = lcm.getDefaultLaunchShortcut(project);
			assertNotNull("the default launch shortcut should be the java app shortcut", ext);
			lcm.setDefaultLaunchShortcut(project, null);
			ext = lcm.getDefaultLaunchShortcut(project);
			assertNull("there should be no default launch shortcut for the test project", ext);
		} 
		catch (CoreException e) {
			fail();
		}
	}
}

Lines 10-15 Link Here

(-)tests/org/eclipse/jdt/debug/tests/performance/PerfContextualLaunchMenu.java (-1 / +5 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.debug.tests.performance;	11	package org.eclipse.jdt.debug.tests.performance;
12		12
		13	import org.eclipse.core.runtime.CoreException;
13	import org.eclipse.debug.core.ILaunchManager;	14	import org.eclipse.debug.core.ILaunchManager;
14	import org.eclipse.debug.internal.ui.DebugUIPlugin;	15	import org.eclipse.debug.internal.ui.DebugUIPlugin;
15	import org.eclipse.debug.ui.actions.ContextualLaunchAction;	16	import org.eclipse.debug.ui.actions.ContextualLaunchAction;
Lines 90-96 Link Here
90	}	91	}
91		92
92	void showMenu(Menu menu) {	93	void showMenu(Menu menu) {
93	fillMenu(menu);	94	try {
		95	fillMenu(menu);
		96	}
		97	catch(CoreException ce) {}
94	}	98	}
95	}	99	}
96	}	100	}

Return to bug 74480

Lines 2415-2434 Link Here

(-)core/org/eclipse/debug/internal/core/LaunchManager.java (-13 / +15 lines)
2415	* CONTEXTLAUNCHING	2415	* CONTEXTLAUNCHING
2416	*/	2416	*/
2417	public ILaunchConfiguration getDefaultConfiguration(IResource resource) throws CoreException {	2417	public ILaunchConfiguration getDefaultConfiguration(IResource resource) throws CoreException {
2418	IProject project = resource.getProject();	2418	if(resource != null) {
2419	if (project != null) {	2419	IProject project = resource.getProject();
2420	org.osgi.service.prefs.Preferences projectNode = getProjectNode(resource);	2420	if (project != null) {
2421	String configValue = projectNode.get(DEFAULT_CONFIGURATION, null);	2421	org.osgi.service.prefs.Preferences projectNode = getProjectNode(resource);
2422	if (configValue != null) {	2422	String configValue = projectNode.get(DEFAULT_CONFIGURATION, null);
2423	// shared config
2424	IFile file = project.getFile(Path.fromPortableString(configValue));
2425	return getLaunchConfiguration(file);
2426	} else {
2427	org.osgi.service.prefs.Preferences instanceNode = getInstanceNode(resource);
2428	configValue = instanceNode.get(DEFAULT_CONFIGURATION, null);
2429	if (configValue != null) {	2423	if (configValue != null) {
2430	// local config	2424	// shared config
2431	return getLaunchConfiguration(configValue);	2425	IFile file = project.getFile(Path.fromPortableString(configValue));
		2426	return getLaunchConfiguration(file);
		2427	} else {
		2428	org.osgi.service.prefs.Preferences instanceNode = getInstanceNode(resource);
		2429	configValue = instanceNode.get(DEFAULT_CONFIGURATION, null);
		2430	if (configValue != null) {
		2431	// local config
		2432	return getLaunchConfiguration(configValue);
		2433	}
2432	}	2434	}
2433	}	2435	}
2434	}	2436	}

Lines 211-234 Link Here

(-)ui/org/eclipse/debug/internal/ui/IInternalDebugUIConstants.java (-18 lines)
211	public static final String PREF_USE_CONTEXTUAL_LAUNCH= IDebugUIConstants.PLUGIN_ID + ".UseContextualLaunch"; //$NON-NLS-1$	211	public static final String PREF_USE_CONTEXTUAL_LAUNCH= IDebugUIConstants.PLUGIN_ID + ".UseContextualLaunch"; //$NON-NLS-1$
212		212
213	/**	213	/**
214	* always/never/prompt preference indicating the action for the event when there is no context to launch during context launching
215	*
216	* @since 3.3
217	*
218	* CONTEXTLAUNCHING
219	*/
220	public static final String PREF_ALWAYS_RUN_LAST_LAUNCH = IDebugUIConstants.PLUGIN_ID + ".AlwaysRunLastLaunch"; //$NON-NLS-1$
221
222	/**
223	* always/never/prompt preference indicating the action to take when an un-runnable file is the context
224	*
225	* @since 3.3
226	*
227	* CONTEXTLAUNCHING
228	*/
229	public static final String PREF_ALWAYS_RUN_PROJECT_CONFIGURATION = IDebugUIConstants.PLUGIN_ID + ".ALwaysRunProjectConfiguration"; //$NON-NLS-1$
230
231	/**
232	* String preference controlling whether editors are saved before launching.	214	* String preference controlling whether editors are saved before launching.
233	* Valid values are either "always", "never", or "prompt".	215	* Valid values are either "always", "never", or "prompt".
234	* If "always" or "never", launching will save editors (or not) automatically.	216	* If "always" or "never", launching will save editors (or not) automatically.

Lines 883-894 Link Here

(-)plugin.xml (-93 / +3 lines)
883	id="org.eclipse.debug.ui.contextualLaunch.profile.submenu">	883	id="org.eclipse.debug.ui.contextualLaunch.profile.submenu">
884	</action>	884	</action>
885	<enablement>	885	<enablement>
886	<and>	886	<test property="org.eclipse.debug.ui.launchable" value="profile"/>
887	<test property="org.eclipse.debug.ui.launchable" value="profile"/>
888	<not>
889	<test property="org.eclipse.debug.ui.contextlaunch" />
890	</not>
891	</and>
892	</enablement>	887	</enablement>
893	</objectContribution>	888	</objectContribution>
894	<objectContribution	889	<objectContribution
Lines 903-914 Link Here
903	id="org.eclipse.debug.ui.contextualLaunch.debug.submenu">	898	id="org.eclipse.debug.ui.contextualLaunch.debug.submenu">
904	</action>	899	</action>
905	<enablement>	900	<enablement>
906	<and>	901	<test property="org.eclipse.debug.ui.launchable" value="debug"/>
907	<test property="org.eclipse.debug.ui.launchable" value="debug"/>
908	<not>
909	<test property="org.eclipse.debug.ui.contextlaunch" />
910	</not>
911	</and>
912	</enablement>	902	</enablement>
913	</objectContribution>	903	</objectContribution>
914	<objectContribution	904	<objectContribution
Lines 923-1005 Link Here
923	id="org.eclipse.debug.ui.contextualLaunch.run.submenu">	913	id="org.eclipse.debug.ui.contextualLaunch.run.submenu">
924	</action>	914	</action>
925	<enablement>	915	<enablement>
926	<and>
927	<test property="org.eclipse.debug.ui.launchable" value="run"/>	916	<test property="org.eclipse.debug.ui.launchable" value="run"/>
928	<not>
929	<test property="org.eclipse.debug.ui.contextlaunch" />
930	</not>
931	</and>
932	</enablement>	917	</enablement>
933	</objectContribution>	918	</objectContribution>
934	<objectContribution
935	id="org.eclipse.debug.ui.contextlaunch.debugas"
936	objectClass="org.eclipse.core.runtime.IAdaptable">
937	<action
938	class="org.eclipse.debug.internal.ui.contextlaunching.DebugContextLaunchingAction"
939	enablesFor="1"
940	icon="icons/full/etool16/debug_exc.gif"
941	id="org.eclipse.debug.ui.contextlaunch.debugas"
942	label="%ContextLaunchingDebugMenu.name"
943	menubarPath="additions"
944	tooltip="%ContextLaunchingDebugMenu.tooltip">
945	</action>
946	<enablement>
947	<and>
948	<test
949	property="org.eclipse.debug.ui.resource"
950	/>
951	<test
952	property="org.eclipse.debug.ui.contextlaunch"
953	/>
954	<test property="org.eclipse.debug.ui.launchable" value="debug"/>
955	</and>
956	</enablement>
957	</objectContribution>
958	<objectContribution
959	id="org.eclipse.debug.ui.contextlaunch.profileas"
960	objectClass="org.eclipse.core.runtime.IAdaptable">
961	<action
962	class="org.eclipse.debug.internal.ui.contextlaunching.ProfileContextLaunchingAction"
963	enablesFor="1"
964	icon="icons/full/etool16/profile_exc.gif"
965	id="org.eclipse.debug.ui.contextlaunch.profileas"
966	label="%ContextLaunchingProfileMenu.name"
967	menubarPath="additions"
968	tooltip="%ContextLaunchingProfileMenu.tooltip">
969	</action>
970	<enablement>
971	<and>
972	<test
973	property="org.eclipse.debug.ui.resource"
974	/>
975	<test property="org.eclipse.debug.ui.contextlaunch" />
976	<test property="org.eclipse.debug.ui.launchable" value="profile"/>
977	</and>
978	</enablement>
979	</objectContribution>
980	<!-- console additions -->	919	<!-- console additions -->
981	<objectContribution
982	id="org.eclipse.debug.ui.contextlaunch.runas"
983	objectClass="org.eclipse.core.runtime.IAdaptable">
984	<action
985	class="org.eclipse.debug.internal.ui.contextlaunching.RunContextLaunchingAction"
986	enablesFor="1"
987	icon="icons/full/etool16/run_exc.gif"
988	id="org.eclipse.debug.ui.contextlaunch.runas"
989	label="%ContextLaunchingRunMenu.name"
990	menubarPath="additions"
991	tooltip="%ContextLaunchingRunMenu.tooltip">
992	</action>
993	<enablement>
994	<and>
995	<test property="org.eclipse.debug.ui.contextlaunch" />
996	<test
997	property="org.eclipse.debug.ui.resource"
998	/>
999	<test property="org.eclipse.debug.ui.launchable" value="run"/>
1000	</and>
1001	</enablement>
1002	</objectContribution>
1003	<viewerContribution	920	<viewerContribution
1004	targetID="org.eclipse.debug.ui.ProcessConsoleType.#ContextMenu"	921	targetID="org.eclipse.debug.ui.ProcessConsoleType.#ContextMenu"
1005	id="org.eclipse.debug.ui.processConsoleContextMenu">	922	id="org.eclipse.debug.ui.processConsoleContextMenu">
Lines 1499-1511 Link Here
1499	<test	1416	<test
1500	property="org.eclipse.debug.ui.contextlaunch"	1417	property="org.eclipse.debug.ui.contextlaunch"
1501	/>	1418	/>
1502	<test
1503	property="org.eclipse.debug.ui.contextlaunchable"
1504	>
1505	</test>
1506	<test
1507	property="org.eclipse.debug.ui.resource">
1508	</test>
1509	</and>	1419	</and>
1510	</enabledWhen>	1420	</enabledWhen>
1511	</page>	1421	</page>
Lines 2147-2153 Link Here
2147	</propertyTester>	2057	</propertyTester>
2148	<propertyTester	2058	<propertyTester
2149	namespace="org.eclipse.debug.ui"	2059	namespace="org.eclipse.debug.ui"
2150	properties="launchable, resource, contextlaunch, contextlaunchable"	2060	properties="launchable, contextlaunch"
2151	type="java.lang.Object"	2061	type="java.lang.Object"
2152	class="org.eclipse.debug.internal.ui.actions.LaunchablePropertyTester"	2062	class="org.eclipse.debug.internal.ui.actions.LaunchablePropertyTester"
2153	id="org.eclipse.debug.ui.propertyTesters.launchable">	2063	id="org.eclipse.debug.ui.propertyTesters.launchable">

Removed Link Here

(-)ui/org/eclipse/debug/internal/ui/contextlaunching/ProfileContextLaunchingAction.java (-36 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 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.contextlaunching;
12
13	import org.eclipse.debug.core.ILaunchManager;
14
15	/**
16	* Specialization of <code>ContextLaunchingAction</code> for profile mode
17	*
18	* @see ContextLaunchingAction
19	* @see ILaunchManager
20	* @see RunContextLaunchingAction
21	* @see DebugContextLaunchingAction
22	*
23	* @since 3.3
24	* EXPERIMENTAL
25	* CONTEXTLAUNCHING
26	*/
27	public class ProfileContextLaunchingAction extends ContextLaunchingAction {
28
29	/**
30	* Constructor
31	*/
32	public ProfileContextLaunchingAction() {
33	super(ILaunchManager.PROFILE_MODE);
34	}
35
36	}

Lines 10-26 Link Here

(-)ui/org/eclipse/debug/internal/ui/contextlaunching/ContextMessages.java (-6 / +3 lines)
10	*/	10	*/
11	public class ContextMessages extends NLS {	11	public class ContextMessages extends NLS {
12	private static final String BUNDLE_NAME = "org.eclipse.debug.internal.ui.contextlaunching.ContextMessages"; //$NON-NLS-1$	12	private static final String BUNDLE_NAME = "org.eclipse.debug.internal.ui.contextlaunching.ContextMessages"; //$NON-NLS-1$
13
14	public static String ContextRunner_0;	13	public static String ContextRunner_0;
15	public static String ContextRunner_1;
16	public static String ContextRunner_2;
17	public static String ContextRunner_3;
18	public static String ContextRunner_4;
19	public static String ContextRunner_5;	14	public static String ContextRunner_5;
20	public static String ContextRunner_6;	15	public static String ContextRunner_6;
21
22	public static String ContextRunner_7;	16	public static String ContextRunner_7;
		17	public static String ContextRunner_8;
		18	public static String ContextRunner_9;
23	public static String OpenLaunchDialogAction_0;	19	public static String OpenLaunchDialogAction_0;
		20	public static String OpenLaunchDialogAction_1;
24	static {	21	static {
25	// initialize resource bundle	22	// initialize resource bundle
26	NLS.initializeMessages(BUNDLE_NAME, ContextMessages.class);	23	NLS.initializeMessages(BUNDLE_NAME, ContextMessages.class);

Lines 1-9 Link Here

(-)ui/org/eclipse/debug/internal/ui/contextlaunching/ContextMessages.properties (-6 / +5 lines)
1	ContextRunner_0=Unable To Launch	1	ContextRunner_0=Unable To Launch
2	ContextRunner_1=There is no way to launch the currently selected context, would you like to {0} the last thing you launched?
3	ContextRunner_2=&Always perform this action
4	ContextRunner_3=Not Runnable
5	ContextRunner_4={0} is not runnable, would you like to check its'' parent project for a way to run it?
6	ContextRunner_5=Cannot Launch	2	ContextRunner_5=Cannot Launch
7	ContextRunner_6=Neither the selected resource or its' associated project are launchable.	3	ContextRunner_6=The selected resource is not launchable.
8	ContextRunner_7=The current context cannot be launched, and there are no recent launches.	4	ContextRunner_7=The current context cannot be launched, and there are no recent launches.
9	OpenLaunchDialogAction_0=Open {0} Dialog	5	ContextRunner_8=&Select a configuration to launch:
		6	ContextRunner_9=Select Configuration
		7	OpenLaunchDialogAction_0=Open {0} Dialog...
		8	OpenLaunchDialogAction_1=&Open {0} Dialog...

Lines 17-23 Link Here

(-)ui/org/eclipse/debug/internal/ui/actions/LaunchablePropertyTester.java (-18 / +19 lines)
17	import org.eclipse.core.runtime.Platform;	17	import org.eclipse.core.runtime.Platform;
18	import org.eclipse.debug.internal.ui.DebugUIPlugin;	18	import org.eclipse.debug.internal.ui.DebugUIPlugin;
19	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	19	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
20	import org.eclipse.debug.internal.ui.contextlaunching.ContextRunner;	20	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
21	import org.eclipse.debug.ui.actions.ILaunchable;	21	import org.eclipse.debug.ui.actions.ILaunchable;
22		22
23	/**	23	/**
Lines 34-62 Link Here
34	return Platform.getAdapterManager().hasAdapter(receiver, ILaunchable.class.getName());	34	return Platform.getAdapterManager().hasAdapter(receiver, ILaunchable.class.getName());
35	}	35	}
36	}	36	}
37	if("resource".equals(property)) { //$NON-NLS-1$
38	IResource res = getResource(receiver);
39	if(res != null) {
40	return res.isAccessible();
41	}
42	}
43	if("contextlaunch".equals(property)) { //$NON-NLS-1$	37	if("contextlaunch".equals(property)) { //$NON-NLS-1$
44	return DebugUIPlugin.getDefault().getPreferenceStore().getBoolean(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH);	38	if(DebugUIPlugin.getDefault().getPreferenceStore().getBoolean(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH)) {
45	}	39	try {
46	if("contextlaunchable".equals(property)) { //$NON-NLS-1$	40	IResource res = getResource(receiver);
47	try {	41	if(res != null) {
48	IResource res = getResource(receiver);	42	return res.isAccessible() && getLaunchConfiguraitonManager().getLaunchShortcuts(getResource(receiver)).size() > 0 && getLaunchConfiguraitonManager().isSharedConfig(receiver) == null;
49	if(res != null) {	43	}
50	return ContextRunner.getDefault().getLaunchShortcuts(getResource(receiver)).size() > 0 && ContextRunner.getDefault().isSharedConfig(receiver) == null;	44	return false;
51	}	45	}
52	return false;	46	catch (CoreException e) {return false;}
53	}	47	}
54	catch (CoreException e) {return false;}
55	}	48	}
56	return false;	49	return false;
57	}	50	}
58		51
59	/**	52	/**
		53	* Returns the launch configuration manager
		54	* @return the launch configuration manager
		55	*/
		56	protected LaunchConfigurationManager getLaunchConfiguraitonManager() {
		57	return DebugUIPlugin.getDefault().getLaunchConfigurationManager();
		58	}
		59
		60	/**
60	* Returns the resource this property page is open on.	61	* Returns the resource this property page is open on.
61	*	62	*
62	* @return resource	63	* @return resource

Removed Link Here

(-)ui/org/eclipse/debug/internal/ui/actions/SharedLaunchConfigAction.java (-55 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.actions;
12
13	import org.eclipse.debug.core.ILaunchConfiguration;
14	import org.eclipse.debug.ui.DebugUITools;
15	import org.eclipse.jface.action.Action;
16	import org.eclipse.jface.resource.ImageDescriptor;
17
18	/**
19	* This class provides an action warpper for adding shared launch configuration actions to the context menu
20	* of the Run->... menu item
21	*
22	* @since 3.3
23	*/
24	public class SharedLaunchConfigAction extends Action {
25
26	private ILaunchConfiguration fConfig;
27	private String fMode;
28
29	/**
30	* Consturtor
31	* @param text the text for the action
32	* @param image the image for the action
33	*/
34	public SharedLaunchConfigAction(ILaunchConfiguration config, String mode, ImageDescriptor image) {
35	super(config.getName(), image);
36	fConfig = config;
37	fMode = mode;
38	}
39
40	/**
41	* Allows access to the launch configuration associated with the action
42	* @return the associated launch configuration
43	*/
44	public ILaunchConfiguration getLaunchConfiguration() {
45	return fConfig;
46	}
47
48	/* (non-Javadoc)
49	* @see org.eclipse.jface.action.Action#run()
50	*/
51	public void run() {
52	DebugUITools.launch(fConfig, fMode);
53	}
54
55	}

Lines 10-16 Link Here

(-)ui/org/eclipse/debug/internal/ui/preferences/RunDebugPropertiesPage.java (-82 / +47 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.debug.internal.ui.preferences;	11	package org.eclipse.debug.internal.ui.preferences;
12		12
13	import java.util.ArrayList;
14	import java.util.Arrays;	13	import java.util.Arrays;
15	import java.util.Collections;	14	import java.util.Collections;
16	import java.util.Comparator;	15	import java.util.Comparator;
Lines 22-28 Link Here
22	import org.eclipse.core.resources.IResource;	21	import org.eclipse.core.resources.IResource;
23	import org.eclipse.core.runtime.CoreException;	22	import org.eclipse.core.runtime.CoreException;
24	import org.eclipse.core.runtime.IAdaptable;	23	import org.eclipse.core.runtime.IAdaptable;
25	import org.eclipse.core.runtime.IPath;
26	import org.eclipse.debug.core.DebugPlugin;	24	import org.eclipse.debug.core.DebugPlugin;
27	import org.eclipse.debug.core.ILaunchConfiguration;	25	import org.eclipse.debug.core.ILaunchConfiguration;
28	import org.eclipse.debug.core.ILaunchConfigurationType;	26	import org.eclipse.debug.core.ILaunchConfigurationType;
Lines 33-40 Link Here
33	import org.eclipse.debug.internal.ui.IDebugHelpContextIds;	31	import org.eclipse.debug.internal.ui.IDebugHelpContextIds;
34	import org.eclipse.debug.internal.ui.SWTUtil;	32	import org.eclipse.debug.internal.ui.SWTUtil;
35	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationComparator;	33	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationComparator;
36	import org.eclipse.debug.ui.DebugUITools;
37	import org.eclipse.debug.ui.IDebugUIConstants;	34	import org.eclipse.debug.ui.IDebugUIConstants;
		35	import org.eclipse.jface.dialogs.IDialogConstants;
38	import org.eclipse.jface.viewers.ArrayContentProvider;	36	import org.eclipse.jface.viewers.ArrayContentProvider;
39	import org.eclipse.jface.viewers.CheckStateChangedEvent;	37	import org.eclipse.jface.viewers.CheckStateChangedEvent;
40	import org.eclipse.jface.viewers.CheckboxTableViewer;	38	import org.eclipse.jface.viewers.CheckboxTableViewer;
Lines 84-89 Link Here
84	private Set fOriginalCandidates;	82	private Set fOriginalCandidates;
85		83
86	/**	84	/**
		85	* Holds configurations that need to be saved when the page closes
		86	*/
		87	private Set fChangedConfigurations = new HashSet();
		88
		89	/**
87	* List of the applicable launch config types for the backing resource	90	* List of the applicable launch config types for the backing resource
88	*/	91	*/
89	private List fTypeCandidates = null;	92	private List fTypeCandidates = null;
Lines 207-212 Link Here
207	}	210	}
208		211
209	/**	212	/**
		213	* @see org.eclipse.jface.dialogs.DialogPage#dispose()
		214	*/
		215	public void dispose() {
		216	if(fOriginalCandidates != null) {
		217	fOriginalCandidates.clear();
		218	fOriginalCandidates = null;
		219	}
		220	if(fChangedConfigurations != null) {
		221	fChangedConfigurations.clear();
		222	fChangedConfigurations = null;
		223	}
		224	super.dispose();
		225	}
		226
		227	/**
210	* Returns the viewer displaying possible default configurations.	228	* Returns the viewer displaying possible default configurations.
211	*	229	*
212	* @return viewer	230	* @return viewer
Lines 253-324 Link Here
253	protected Set collectConfigCandidates(IResource resource) {	271	protected Set collectConfigCandidates(IResource resource) {
254	if(fOriginalCandidates == null) {	272	if(fOriginalCandidates == null) {
255	fOriginalCandidates = new HashSet();	273	fOriginalCandidates = new HashSet();
256	IPath resourcePath = resource.getFullPath();
257	try {	274	try {
258	List types = collectTypeCandidates();	275	List configs = DebugUIPlugin.getDefault().getLaunchConfigurationManager().getApplicableLaunchConfigurations(resource);
259	List configs = new ArrayList();	276	for(Iterator iter = configs.iterator(); iter.hasNext();) {
260	ILaunchConfiguration[] configurations = getLaunchManager().getLaunchConfigurations();	277	fOriginalCandidates.add(((ILaunchConfiguration)iter.next()).getWorkingCopy());
261	for(int i = 0; i < configurations.length; i++) {
262	if(types.contains(configurations[i].getType())) {
263	if(configurations[i].isMigrationCandidate()) {
264	configurations[i].migrate();
265	}
266	configs.add(configurations[i]);
267	}
268	}
269	ILaunchConfiguration configuration = null;
270	IResource[] resources = null;
271	for (Iterator iter = configs.iterator(); iter.hasNext();) {
272	configuration = (ILaunchConfiguration) iter.next();
273	if(acceptConfiguration(configuration)) {
274	if(configuration.contentsEqual(getLaunchManager().getDefaultConfiguration(resource))) {
275	fOriginalCandidates.add(configuration.getWorkingCopy());
276	}
277	else {
278	resources = configuration.getMappedResources();
279	if (resources != null) {
280	for (int j = 0; j < resources.length; j++) {
281	if (resource.equals(resources[j]) \|\| resourcePath.isPrefixOf(resources[j].getFullPath())) {
282	fOriginalCandidates.add(configuration.getWorkingCopy());
283	break;
284	}
285	}
286	}
287	else {
288	//in the event the config has no mapping
289	fOriginalCandidates.add(configuration.getWorkingCopy());
290	}
291	}
292	}
293	}	278	}
294	} catch (CoreException e) {
295	fOriginalCandidates.clear();
296	DebugPlugin.log(e);
297	}	279	}
		280	catch(CoreException ce) {DebugUIPlugin.log(ce);}
298	}	281	}
299	return fOriginalCandidates;	282	return fOriginalCandidates;
300	}	283	}
301		284
302	/**	285
303	* Returns if the specified configuration should be considered as a potential candidate
304	* @param config
305	* @return if the specified configuration should be considered as a potential candidate
306	* @throws CoreException
307	*/
308	private boolean acceptConfiguration(ILaunchConfiguration config) throws CoreException {
309	if(config != null && !DebugUITools.isPrivate(config)) {
310	if(!"org.eclipse.ui.externaltools".equals(config.getType().getCategory())) { //$NON-NLS-1$
311	return true;
312	}
313	else {
314	IResource[] res = config.getMappedResources();
315	if(res != null) {
316	return true;
317	}
318	}
319	}
320	return false;
321	}
322		286
323	/**	287	/**
324	* Returns the resource this property page is open on.	288	* Returns the resource this property page is open on.
Lines 365-379 Link Here
365	}	329	}
366	}	330	}
367	//add	331	//add
368	iter = fOriginalCandidates.iterator();	332	iter = fChangedConfigurations.iterator();
369	while (iter.hasNext()) {	333	while (iter.hasNext()) {
370	ILaunchConfigurationWorkingCopy currentConfig = (ILaunchConfigurationWorkingCopy) iter.next();	334	ILaunchConfigurationWorkingCopy currentConfig = (ILaunchConfigurationWorkingCopy) iter.next();
371	if (currentConfig.isDirty()){	335	try{
372	try{	336	currentConfig.doSave();
373	currentConfig.doSave();	337	} catch (CoreException e) {
374	} catch (CoreException e) {	338	DebugPlugin.logMessage("Problem saving changes to configuration " + currentConfig.getName(), e); //$NON-NLS-1$
375	DebugPlugin.logMessage("Problem saving changes to configuration " + currentConfig.getName(), e); //$NON-NLS-1$
376	}
377	}	339	}
378	}	340	}
379		341
Lines 397-408 Link Here
397	private Set getConfigurationNames() {	359	private Set getConfigurationNames() {
398	Set names = new HashSet();	360	Set names = new HashSet();
399	Iterator iter = fOriginalCandidates.iterator();	361	Iterator iter = fOriginalCandidates.iterator();
400	Object o = null;
401	while (iter.hasNext()) {	362	while (iter.hasNext()) {
402	o = iter.next();	363	names.add(((ILaunchConfiguration)iter.next()).getName());
403	if(o instanceof ILaunchConfiguration) {	364	}
404	names.add(((ILaunchConfiguration)o).getName());	365	iter = fChangedConfigurations.iterator();
405	}	366	while (iter.hasNext()) {
		367	names.add(((ILaunchConfiguration)iter.next()).getName());
406	}	368	}
407	return names;	369	return names;
408	}	370	}
Lines 426-433 Link Here
426	ILaunchConfigurationWorkingCopy copy = configuration.copy(	388	ILaunchConfigurationWorkingCopy copy = configuration.copy(
427	((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).generateUniqueLaunchConfigurationNameFrom(configuration.getName(), getConfigurationNames()));	389	((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).generateUniqueLaunchConfigurationNameFrom(configuration.getName(), getConfigurationNames()));
428	copy.setAttributes(configuration.getAttributes());	390	copy.setAttributes(configuration.getAttributes());
429	fOriginalCandidates.add(copy);	391	fChangedConfigurations.add(copy);
430	fViewer.refresh();	392	fViewer.add(copy);
431	fViewer.setSelection(new StructuredSelection(copy));	393	fViewer.setSelection(new StructuredSelection(copy));
432	} catch (CoreException e) {	394	} catch (CoreException e) {
433	setErrorMessage(e.getMessage());	395	setErrorMessage(e.getMessage());
Lines 444-452 Link Here
444	ILaunchConfiguration[] configurations = getSelectedConfigurations();	406	ILaunchConfiguration[] configurations = getSelectedConfigurations();
445	for (int i = 0; i < configurations.length; i++) {	407	for (int i = 0; i < configurations.length; i++) {
446	fDeletedConfigurations.add(configurations[i]);	408	fDeletedConfigurations.add(configurations[i]);
447	fOriginalCandidates.remove(configurations[i]);	409	fChangedConfigurations.remove(configurations[i]);
		410	fViewer.remove(configurations[i]);
448	}	411	}
449	fViewer.refresh();
450	if (indices[0] < table.getItemCount()) {	412	if (indices[0] < table.getItemCount()) {
451	fViewer.setSelection(new StructuredSelection(table.getItem(indices[0]).getData()));	413	fViewer.setSelection(new StructuredSelection(table.getItem(indices[0]).getData()));
452	} else if (table.getItemCount() > 0) {	414	} else if (table.getItemCount() > 0) {
Lines 458-465 Link Here
458	* Edit the selection	420	* Edit the selection
459	*/	421	*/
460	private void handleEdit() {	422	private void handleEdit() {
461	edit(getSelectedConfigurations()[0]);	423	ILaunchConfigurationWorkingCopy config = getSelectedConfigurations()[0];
462	fViewer.refresh();	424	if(edit(config) == IDialogConstants.OK_ID) {
		425	fChangedConfigurations.add(config);
		426	fViewer.refresh();
		427	}
463	}	428	}
464		429
465	/**	430	/**
Lines 493-500 Link Here
493	((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).	458	((LaunchManager)DebugPlugin.getDefault().getLaunchManager()).
494	generateUniqueLaunchConfigurationNameFrom("New_configuration", getConfigurationNames())); //$NON-NLS-1$	459	generateUniqueLaunchConfigurationNameFrom("New_configuration", getConfigurationNames())); //$NON-NLS-1$
495	if (edit(wc) == Window.OK) {	460	if (edit(wc) == Window.OK) {
496	fOriginalCandidates.add(wc);	461	fChangedConfigurations.add(wc);
497	fViewer.refresh();	462	fViewer.add(wc);
498	fViewer.setSelection(new StructuredSelection(wc));	463	fViewer.setSelection(new StructuredSelection(wc));
499	}	464	}
500	} catch (CoreException e) {	465	} catch (CoreException e) {

Lines 34-40 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationManager.java (-80 / +160 lines)
34		34
35	import org.eclipse.core.expressions.EvaluationContext;	35	import org.eclipse.core.expressions.EvaluationContext;
36	import org.eclipse.core.expressions.IEvaluationContext;	36	import org.eclipse.core.expressions.IEvaluationContext;
37	import org.eclipse.core.resources.IProject;	37	import org.eclipse.core.resources.IFile;
38	import org.eclipse.core.resources.IResource;	38	import org.eclipse.core.resources.IResource;
39	import org.eclipse.core.resources.ISaveContext;	39	import org.eclipse.core.resources.ISaveContext;
40	import org.eclipse.core.resources.ISaveParticipant;	40	import org.eclipse.core.resources.ISaveParticipant;
Lines 43-52 Link Here
43	import org.eclipse.core.runtime.IConfigurationElement;	43	import org.eclipse.core.runtime.IConfigurationElement;
44	import org.eclipse.core.runtime.IExtensionPoint;	44	import org.eclipse.core.runtime.IExtensionPoint;
45	import org.eclipse.core.runtime.IPath;	45	import org.eclipse.core.runtime.IPath;
46	import org.eclipse.core.runtime.IStatus;
47	import org.eclipse.core.runtime.Platform;	46	import org.eclipse.core.runtime.Platform;
48	import org.eclipse.core.runtime.Status;
49	import org.eclipse.core.runtime.preferences.InstanceScope;
50	import org.eclipse.debug.core.DebugException;	47	import org.eclipse.debug.core.DebugException;
51	import org.eclipse.debug.core.DebugPlugin;	48	import org.eclipse.debug.core.DebugPlugin;
52	import org.eclipse.debug.core.ILaunch;	49	import org.eclipse.debug.core.ILaunch;
Lines 63-68 Link Here
63	import org.eclipse.debug.internal.ui.DebugUIPlugin;	60	import org.eclipse.debug.internal.ui.DebugUIPlugin;
64	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	61	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
65	import org.eclipse.debug.internal.ui.ILaunchHistoryChangedListener;	62	import org.eclipse.debug.internal.ui.ILaunchHistoryChangedListener;
		63	import org.eclipse.debug.ui.DebugUITools;
66	import org.eclipse.debug.ui.IDebugUIConstants;	64	import org.eclipse.debug.ui.IDebugUIConstants;
67	import org.eclipse.debug.ui.ILaunchConfigurationTab;	65	import org.eclipse.debug.ui.ILaunchConfigurationTab;
68	import org.eclipse.debug.ui.ILaunchGroup;	66	import org.eclipse.debug.ui.ILaunchGroup;
Lines 70-80 Link Here
70	import org.eclipse.swt.SWT;	68	import org.eclipse.swt.SWT;
71	import org.eclipse.swt.graphics.Image;	69	import org.eclipse.swt.graphics.Image;
72	import org.eclipse.swt.widgets.Display;	70	import org.eclipse.swt.widgets.Display;
		71	import org.eclipse.ui.IFileEditorInput;
73	import org.eclipse.ui.PlatformUI;	72	import org.eclipse.ui.PlatformUI;
74	import org.eclipse.ui.activities.IWorkbenchActivitySupport;	73	import org.eclipse.ui.activities.IWorkbenchActivitySupport;
75	import org.eclipse.ui.activities.WorkbenchActivityHelper;	74	import org.eclipse.ui.activities.WorkbenchActivityHelper;
76	import org.osgi.service.prefs.BackingStoreException;
77	import org.osgi.service.prefs.Preferences;
78	import org.w3c.dom.Document;	75	import org.w3c.dom.Document;
79	import org.w3c.dom.Element;	76	import org.w3c.dom.Element;
80	import org.w3c.dom.Node;	77	import org.w3c.dom.Node;
Lines 600-612 Link Here
600	}	597	}
601		598
602	/**	599	/**
		600	* Returns the list of launch shortcuts that have been filtered to conform to current workbench activities
		601	* @return a workbench activity filtered list of launch shortcuts, or an empty list, never <code>null</code>
		602	* @since 3.3
		603	*/
		604	public List getActivityFilteredLaunchShortcuts() {
		605	List shortcuts = new ArrayList();
		606	List sc = getLaunchShortcuts();
		607	LaunchShortcutExtension ext = null;
		608	for(Iterator iter = sc.iterator(); iter.hasNext();) {
		609	ext = (LaunchShortcutExtension) iter.next();
		610	if(!WorkbenchActivityHelper.filterItem(ext)) {
		611	if(!shortcuts.contains(ext)) {
		612	shortcuts.add(ext);
		613	}
		614	}
		615	}
		616	return shortcuts;
		617	}
		618
		619	/**
		620	* Creates a listing of the launch shortcut extensions that are applicable to the underlying resource
		621	* @param resource the underlying resource
		622	* @return a listing of applicable launch shortcuts or an empty list, never <code>null</code>
		623	* @throws CoreException
		624	* @since 3.3
		625	*/
		626	public List getLaunchShortcuts(IResource resource) throws CoreException {
		627	List list = new ArrayList();
		628	List sc = getLaunchShortcuts();
		629	List ctxt = new ArrayList();
		630	ctxt.add(resource);
		631	IEvaluationContext context = new EvaluationContext(null, ctxt);
		632	context.addVariable("selection", ctxt); //$NON-NLS-1$
		633	LaunchShortcutExtension ext = null;
		634	for(Iterator iter = sc.iterator(); iter.hasNext();) {
		635	ext = (LaunchShortcutExtension) iter.next();
		636	if(ext.evalEnablementExpression(context, ext.getContextualLaunchEnablementExpression()) && !WorkbenchActivityHelper.filterItem(ext)) {
		637	if(!list.contains(ext)) {
		638	list.add(ext);
		639	}
		640	}
		641	}
		642	return list;
		643	}
		644
		645	/**
603	* Returns a listing of all of the <code>ILaunchConfigurationType</code>s that apply to the currently	646	* Returns a listing of all of the <code>ILaunchConfigurationType</code>s that apply to the currently
604	* specified <code>IResource</code>.	647	* specified <code>IResource</code>.
605	*	648	*
606	* @param resource the resource context	649	* @param resource the resource context
607	* @return a listing of applicable <code>ILaunchConfigurationType</code>s, or an empty list, never <code>null</code>	650	* @return a listing of applicable <code>ILaunchConfigurationType</code>s, or an empty list, never <code>null</code>
608	* @since 3.3	651	* @since 3.3
609	* EXPERIMENTAL
610	* CONTEXTLAUNCHING	652	* CONTEXTLAUNCHING
611	*/	653	*/
612	public List getApplicableConfigurationTypes(IResource resource) {	654	public List getApplicableConfigurationTypes(IResource resource) {
Lines 641-646 Link Here
641	}	683	}
642		684
643	/**	685	/**
		686	* Returns a list of the <code>ILaunchConfiguration</code>s that apply to the specified <code>IResource</code>
		687	* @param resource the resource
		688	* @return a listing of applicable <code>ILaunchConfiguration</code>s for the specified <code>IResource</code> or an empty
		689	* list if none, never <code>null</code>
		690	* @since 3.3
		691	*/
		692	public List getApplicableLaunchConfigurations(IResource resource) {
		693	ArrayList list = new ArrayList();
		694	IPath resourcePath = resource.getFullPath();
		695	try {
		696	List types = getApplicableConfigurationTypes(resource);
		697	List configs = new ArrayList();
		698	ILaunchConfiguration[] configurations = getLaunchManager().getLaunchConfigurations();
		699	for(int i = 0; i < configurations.length; i++) {
		700	if(types.contains(configurations[i].getType())) {
		701	if(configurations[i].isMigrationCandidate()) {
		702	configurations[i].migrate();
		703	}
		704	configs.add(configurations[i]);
		705	}
		706	}
		707	ILaunchConfiguration configuration = null;
		708	IResource[] resources = null;
		709	for (Iterator iter = configs.iterator(); iter.hasNext();) {
		710	configuration = (ILaunchConfiguration) iter.next();
		711	if(acceptConfiguration(configuration)) {
		712	if(configuration.contentsEqual(getLaunchManager().getDefaultConfiguration(resource))) {
		713	list.add(configuration);
		714	}
		715	else {
		716	resources = configuration.getMappedResources();
		717	if (resources != null) {
		718	for (int j = 0; j < resources.length; j++) {
		719	if (resource.equals(resources[j]) \|\| resourcePath.isPrefixOf(resources[j].getFullPath())) {
		720	list.add(configuration);
		721	break;
		722	}
		723	}
		724	}
		725	else {
		726	//in the event the config has no mapping
		727	list.add(configuration);
		728	}
		729	}
		730	}
		731	}
		732	} catch (CoreException e) {
		733	list.clear();
		734	DebugPlugin.log(e);
		735	}
		736	return list;
		737	}
		738
		739	/**
		740	* Returns if the specified configuration should be considered as a potential candidate
		741	* @param config
		742	* @return if the specified configuration should be considered as a potential candidate
		743	* @throws CoreException
		744	*/
		745	private boolean acceptConfiguration(ILaunchConfiguration config) throws CoreException {
		746	if(config != null && !DebugUITools.isPrivate(config)) {
		747	if(!"org.eclipse.ui.externaltools".equals(config.getType().getCategory())) { //$NON-NLS-1$
		748	return true;
		749	}
750	else {
751	IResource[] res = config.getMappedResources();
752	if(res != null) {
753	return true;
754	}
755	}
756	}
757	return false;
758	}
759
760	/**
644	* Returns a listing of all applicable <code>LaunchShortcutExtension</code>s for the given	761	* Returns a listing of all applicable <code>LaunchShortcutExtension</code>s for the given
645	* launch configuration type id.	762	* launch configuration type id.
646	* @param typeid the id of the launch configuration	763	* @param typeid the id of the launch configuration
Lines 738-746 Link Here
738	* or <code>null</code>	855	* or <code>null</code>
739	*	856	*
740	* @since 3.3	857	* @since 3.3
741	*
742	* EXPERIMENTAL
743	* CONTEXTLAUNCHING
744	*/	858	*/
745	public LaunchShortcutExtension getLaunchShortcut(String id) {	859	public LaunchShortcutExtension getLaunchShortcut(String id) {
746	loadLaunchShortcuts();	860	loadLaunchShortcuts();
Lines 755-760 Link Here
755	}	869	}
756		870
757	/**	871	/**
		872	* Returns the shared config from the selected resource or <code>null</code> if the selected resources is not a shared config
		873	* @param receiver the object to test if it is a shared launch configuration
		874	* @return the shared config from the selected resource or <code>null</code> if the selected resources is not a shared config
		875	* @since 3.3
		876	*/
		877	public ILaunchConfiguration isSharedConfig(Object receiver) {
		878	if(receiver instanceof IFile) {
		879	IFile file = (IFile) receiver;
		880	String ext = file.getFileExtension();
		881	if(ext == null) {
		882	return null;
		883	}
		884	if(ext.equals("launch")) { //$NON-NLS-1$
		885	ILaunchConfiguration config = DebugPlugin.getDefault().getLaunchManager().getLaunchConfiguration(file);
		886	if(config != null && config.exists()) {
		887	return config;
		888	}
		889	}
		890	}
		891	else if(receiver instanceof IFileEditorInput) {
		892	IFileEditorInput input = (IFileEditorInput) receiver;
		893	return isSharedConfig(input.getFile());
		894	}
		895	return null;
		896	}
		897
		898	/**
758	* Returns the image used to display an error in the given tab	899	* Returns the image used to display an error in the given tab
759	*/	900	*/
760	public Image getErrorTabImage(ILaunchConfigurationTab tab) {	901	public Image getErrorTabImage(ILaunchConfigurationTab tab) {
Lines 815-820 Link Here
815	}	956	}
816		957
817	/**	958	/**
		959	* Returns the singleton instance of the launch manager
		960	* @return the singleton instance of the launch manager
		961	* @since 3.3
		962	*/
		963	private LaunchManager getLaunchManager() {
		964	return (LaunchManager) DebugPlugin.getDefault().getLaunchManager();
		965	}
		966
		967	/**
818	* Restore launch history	968	* Restore launch history
819	*/	969	*/
820	private void loadLaunchHistories() {	970	private void loadLaunchHistories() {
Lines 835-910 Link Here
835	}	985	}
836		986
837	/**	987	/**
838	* This method allows a default launch shortcut to be specified for the given resource. This sets
839	* a default way of <i>how</i> something should be launched, not what specific <code>ILaunchConfiguration</code>
840	* will do the launching. Passing in <code>null</code> for a shortcut will remove the attribute.
841	*
842	* @see {@link ILaunchManager#setDefaultConfiguration(IResource, ILaunchConfiguration)}
843	* @param resource the resource to map the specified launch shortcut to
844	* @param shortcut the shortcut to map
845	*
846	* @since 3.3
847	*
848	* EXPERIMENTAL
849	* CONTEXTLAUNCHING
850	*/
851	public void setDefaultLaunchShortcut(IResource resource, LaunchShortcutExtension shortcut) throws CoreException {
852	IProject project = resource.getProject();
853	if (project == null) {
854	throw new CoreException(new Status(IStatus.ERROR, DebugPlugin.getUniqueIdentifier(),
855	DebugPlugin.INTERNAL_ERROR, "Illegal argument: can only set default launch shortcut on and within projects.", null)); //$NON-NLS-1$ (internal error)
856	}
857	Preferences node = getInstanceNode(resource);
858	if(shortcut != null) {
859	node.put(IConfigurationElementConstants.DEFAULT_LAUNCH_SHORTCUT, shortcut.getId());
860	}
861	else {
862	node.remove(IConfigurationElementConstants.DEFAULT_LAUNCH_SHORTCUT);
863	}
864	try {
865	node.flush();
866	}
867	catch (BackingStoreException e) {DebugUIPlugin.log(e);}
868	}
869
870	/**
871	* This method allows access to the default <code>LaunchShortcutExtension</code> for
872	* the specified <code>IResource</code>.
873	*
874	* @see {@link ILaunchManager#getDefaultConfiguration(IResource)}
875	* @param resource the resource
876	* @return the corresponding <code>LaunchShortcutExtension</code> for the given <code>IResource</code>,
877	* or <code>null</code> if there is not one.
878	*
879	* @since 3.3
880	*
881	* EXPERIMENTAL
882	* CONTEXTLAUNCHING
883	*/
884	public LaunchShortcutExtension getDefaultLaunchShortcut(IResource resource) {
885	IProject project = resource.getProject();
886	if (project != null) {
887	Preferences node = getInstanceNode(resource);
888	String id = node.get(IConfigurationElementConstants.DEFAULT_LAUNCH_SHORTCUT, null);
889	if(id != null) {
890	return getLaunchShortcut(id);
891	}
892	}
893	return null;
894	}
895
896	/**
897	* Returns the node for instance project preferences
898	* @param resource the resource to get the node for
899	* @return the instance node for debug UI
900	*/
901	private org.osgi.service.prefs.Preferences getInstanceNode(IResource resource) {
902	org.osgi.service.prefs.Preferences node = Platform.getPreferencesService().getRootNode();
903	node = node.node(InstanceScope.SCOPE).node(DebugUIPlugin.getUniqueIdentifier());
904	return node.node(resource.getFullPath().makeRelative().toString());
905	}
906
907	/**
908	* Returns the default launch group for the given mode.	988	* Returns the default launch group for the given mode.
909	*	989	*
910	* @param mode	990	* @param mode

Lines 20-34 Link Here

(-)ui/org/eclipse/debug/ui/actions/ContextualLaunchAction.java (-38 / +42 lines)
20	import org.eclipse.core.expressions.EvaluationContext;	20	import org.eclipse.core.expressions.EvaluationContext;
21	import org.eclipse.core.expressions.Expression;	21	import org.eclipse.core.expressions.Expression;
22	import org.eclipse.core.expressions.IEvaluationContext;	22	import org.eclipse.core.expressions.IEvaluationContext;
23	import org.eclipse.core.resources.IFile;	23	import org.eclipse.core.resources.IResource;
24	import org.eclipse.core.runtime.CoreException;	24	import org.eclipse.core.runtime.CoreException;
		25	import org.eclipse.core.runtime.IAdaptable;
25	import org.eclipse.debug.core.DebugPlugin;	26	import org.eclipse.debug.core.DebugPlugin;
26	import org.eclipse.debug.core.ILaunchConfiguration;	27	import org.eclipse.debug.core.ILaunchConfiguration;
27	import org.eclipse.debug.core.ILaunchManager;	28	import org.eclipse.debug.core.ILaunchManager;
28	import org.eclipse.debug.internal.ui.DebugUIPlugin;	29	import org.eclipse.debug.internal.ui.DebugUIPlugin;
		30	import org.eclipse.debug.internal.ui.actions.ActionMessages;
		31	import org.eclipse.debug.internal.ui.actions.LaunchConfigurationAction;
29	import org.eclipse.debug.internal.ui.actions.LaunchShortcutAction;	32	import org.eclipse.debug.internal.ui.actions.LaunchShortcutAction;
30	import org.eclipse.debug.internal.ui.actions.SharedLaunchConfigAction;
31	import org.eclipse.debug.internal.ui.contextlaunching.ContextRunner;
32	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;	33	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
33	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchShortcutExtension;	34	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchShortcutExtension;
34	import org.eclipse.debug.ui.DebugUITools;	35	import org.eclipse.debug.ui.DebugUITools;
Lines 44-55 Link Here
44	import org.eclipse.swt.widgets.Control;	45	import org.eclipse.swt.widgets.Control;
45	import org.eclipse.swt.widgets.Menu;	46	import org.eclipse.swt.widgets.Menu;
46	import org.eclipse.swt.widgets.MenuItem;	47	import org.eclipse.swt.widgets.MenuItem;
47	import org.eclipse.ui.IFileEditorInput;
48	import org.eclipse.ui.IObjectActionDelegate;	48	import org.eclipse.ui.IObjectActionDelegate;
49	import org.eclipse.ui.IWorkbenchPart;	49	import org.eclipse.ui.IWorkbenchPart;
50	import org.eclipse.ui.PlatformUI;	50	import org.eclipse.ui.PlatformUI;
51	import org.eclipse.ui.activities.WorkbenchActivityHelper;	51	import org.eclipse.ui.activities.WorkbenchActivityHelper;
52		52
		53	import com.ibm.icu.text.MessageFormat;
		54
53	/**	55	/**
54	* An action delegate that builds a context menu with applicable launch shortcuts	56	* An action delegate that builds a context menu with applicable launch shortcuts
55	* for a specific launch mode.	57	* for a specific launch mode.
Lines 130-141 Link Here
130	menu.addMenuListener(new MenuAdapter() {	132	menu.addMenuListener(new MenuAdapter() {
131	public void menuShown(MenuEvent e) {	133	public void menuShown(MenuEvent e) {
132	if (fFillMenu) {	134	if (fFillMenu) {
133	Menu m = (Menu)e.widget;	135	try {
134	MenuItem[] items = m.getItems();	136	Menu m = (Menu)e.widget;
135	for (int i=0; i < items.length; i++) {	137	MenuItem[] items = m.getItems();
136	items[i].dispose();	138	for (int i=0; i < items.length; i++) {
		139	items[i].dispose();
		140	}
		141	fillMenu(m);
137	}	142	}
138	fillMenu(m);	143	catch(CoreException ce) {}
139	fFillMenu = false;	144	fFillMenu = false;
140	}	145	}
141	}	146	}
Lines 179-224 Link Here
179	}	184	}
180		185
181	/**	186	/**
182	* Prepares a SharedLaunchConfigAction and adds it to the current menu	187	* Returns the resource this menu is open on.
183	* @param file the file to get the launch configuration from	188	*
184	* @param image the image for the action	189	* @return resource
185	* @param menu the menu to add the new action to.
186	* @since 3.3
187	*/	190	*/
188	private void prepareSharedConfigAction(IFile file, Menu menu) {	191	protected IResource getResource(Object element) {
189	ILaunchConfiguration config = getLaunchManager().getLaunchConfiguration(file);	192	IResource resource = null;
190	try {	193	if (element instanceof IResource) {
191	if(config != null && config.exists() && config.supportsMode(fMode)) {	194	resource = (IResource) element;
192	IAction action = new SharedLaunchConfigAction(config, fMode, DebugUITools.getDefaultImageDescriptor(config));	195	} else if (element instanceof IAdaptable) {
193	ActionContributionItem item= new ActionContributionItem(action);	196	resource = (IResource) ((IAdaptable)element).getAdapter(IResource.class);
194	item.fill(menu, -1);	197	}
195	}	198	return resource;
196	} catch (CoreException e) {
197	}
198	}	199	}
199		200
200	/**	201	/**
201	* Fills the menu with applicable launch shortcuts	202	* Fills the menu with applicable launch shortcuts
202	* @param menu The menu to fill	203	* @param menu The menu to fill
203	*/	204	*/
204	protected void fillMenu(Menu menu) {	205	protected void fillMenu(Menu menu) throws CoreException {
205	if (fSelection == null) {	206	if (fSelection == null) {
206	return;	207	return;
207	}	208	}
208	IEvaluationContext context = createContext();	209	IEvaluationContext context = createContext();
209	//add in any selected shared configs before the rest of the items to launch as
210	//feature fix for
211	//CONTEXTLAUNCHING	210	//CONTEXTLAUNCHING
212	if(!fSelection.isEmpty()) {	211	Object obj = fSelection.getFirstElement();
213	Object obj = fSelection.getFirstElement();	212	int accelerator = 1;
214	if(ContextRunner.getDefault().isSharedConfig(obj) != null) {	213	ILaunchConfiguration config = getLaunchManager().getDefaultConfiguration(getResource(obj));
215	prepareSharedConfigAction((IFile)obj, menu);	214	if(config != null && config.exists() && config.supportsMode(fMode)) {
216	new MenuItem(menu, SWT.SEPARATOR);	215	IAction action = new LaunchConfigurationAction(config, fMode, MessageFormat.format(ActionMessages.ContextualLaunchAction_0, new String[] {config.getName()}), DebugUITools.getDefaultImageDescriptor(config), accelerator++);
217	}	216	ActionContributionItem item = new ActionContributionItem(action);
218	else if(ContextRunner.getDefault().isSharedConfigEditorInput(obj) != null) {	217	item.fill(menu, -1);
219	prepareSharedConfigAction(((IFileEditorInput) obj).getFile(), menu);	218	new MenuItem(menu, SWT.SEPARATOR);
220	new MenuItem(menu, SWT.SEPARATOR);	219	}
221	}	220	config = getLaunchConfigurationManager().isSharedConfig(obj);
		221	if(config != null && config.exists() && config.supportsMode(fMode)) {
		222	IAction action = new LaunchConfigurationAction(config, fMode, config.getName(), DebugUITools.getDefaultImageDescriptor(config), accelerator++);
		223	ActionContributionItem item = new ActionContributionItem(action);
		224	item.fill(menu, -1);
		225	new MenuItem(menu, SWT.SEPARATOR);
222	}	226	}
223	List allShortCuts = getLaunchConfigurationManager().getLaunchShortcuts();	227	List allShortCuts = getLaunchConfigurationManager().getLaunchShortcuts();
224	Iterator iter = allShortCuts.iterator();	228	Iterator iter = allShortCuts.iterator();
Lines 233-239 Link Here
233	catch (CoreException e) {DebugUIPlugin.log(e);}	237	catch (CoreException e) {DebugUIPlugin.log(e);}
234	}	238	}
235	iter = filteredShortCuts.iterator();	239	iter = filteredShortCuts.iterator();
236	int accelerator = 1;	240
237	List categories = new ArrayList();	241	List categories = new ArrayList();
238	while (iter.hasNext()) {	242	while (iter.hasNext()) {
239	LaunchShortcutExtension ext = (LaunchShortcutExtension) iter.next();	243	LaunchShortcutExtension ext = (LaunchShortcutExtension) iter.next();

Lines 18-30 Link Here

(-)ui/org/eclipse/debug/ui/actions/OpenLaunchDialogAction.java (-15 / +9 lines)
18	import org.eclipse.debug.internal.ui.IDebugHelpContextIds;	18	import org.eclipse.debug.internal.ui.IDebugHelpContextIds;
19	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	19	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
20	import org.eclipse.debug.internal.ui.contextlaunching.ContextMessages;	20	import org.eclipse.debug.internal.ui.contextlaunching.ContextMessages;
21	import org.eclipse.debug.internal.ui.contextlaunching.ContextRunner;
22	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchGroupExtension;	21	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchGroupExtension;
23	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchHistory;	22	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchHistory;
24	import org.eclipse.debug.ui.DebugUITools;	23	import org.eclipse.debug.ui.DebugUITools;
25	import org.eclipse.jface.action.Action;	24	import org.eclipse.jface.action.Action;
26	import org.eclipse.jface.action.IAction;	25	import org.eclipse.jface.action.IAction;
27	import org.eclipse.jface.util.IPropertyChangeListener;
28	import org.eclipse.jface.util.PropertyChangeEvent;	26	import org.eclipse.jface.util.PropertyChangeEvent;
29	import org.eclipse.jface.viewers.ISelection;	27	import org.eclipse.jface.viewers.ISelection;
30	import org.eclipse.jface.viewers.IStructuredSelection;	28	import org.eclipse.jface.viewers.IStructuredSelection;
Lines 46-52 Link Here
46	* </p>	44	* </p>
47	* @since 2.1	45	* @since 2.1
48	*/	46	*/
49	public class OpenLaunchDialogAction extends Action implements IPropertyChangeListener, IActionDelegate2, IWorkbenchWindowActionDelegate {	47	public class OpenLaunchDialogAction extends Action implements IActionDelegate2, IWorkbenchWindowActionDelegate {
50		48
51	/**	49	/**
52	* Launch group identifier	50	* Launch group identifier
Lines 102-117 Link Here
102	/**	100	/**
103	* @see org.eclipse.ui.IWorkbenchWindowActionDelegate#dispose()	101	* @see org.eclipse.ui.IWorkbenchWindowActionDelegate#dispose()
104	*/	102	*/
105	public void dispose() {	103	public void dispose() {}
106	DebugUIPlugin.getDefault().getPreferenceStore().removePropertyChangeListener(this);
107	}
108		104
109	/* (non-Javadoc)	105	/* (non-Javadoc)
110	* @see org.eclipse.ui.IActionDelegate2#init(org.eclipse.jface.action.IAction)	106	* @see org.eclipse.ui.IActionDelegate2#init(org.eclipse.jface.action.IAction)
111	*/	107	*/
112	public void init(IAction action) {	108	public void init(IAction action) {
113	fBackingAction = action;	109	fBackingAction = action;
114	DebugUIPlugin.getDefault().getPreferenceStore().addPropertyChangeListener(this);
115	PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IDebugHelpContextIds.OPEN_LAUNCH_CONFIGURATION_ACTION);	110	PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IDebugHelpContextIds.OPEN_LAUNCH_CONFIGURATION_ACTION);
116	updateActionState();	111	updateActionState();
117	}	112	}
Lines 125-140 Link Here
125	LaunchGroupExtension extension = DebugUIPlugin.getDefault().getLaunchConfigurationManager().getLaunchGroup(fIdentifier);	120	LaunchGroupExtension extension = DebugUIPlugin.getDefault().getLaunchConfigurationManager().getLaunchGroup(fIdentifier);
126	if(fBackingAction == null) {	121	if(fBackingAction == null) {
127	//there is no backing action, like a toolbar action delegate	122	//there is no backing action, like a toolbar action delegate
128	if(ContextRunner.isContextLaunchEnabled() && !"org.eclipse.ui.externaltools.launchGroup".equals(fIdentifier)) { //$NON-NLS-1$	123	setText(MessageFormat.format(ContextMessages.OpenLaunchDialogAction_0, new String[] {extension.getLabel()}));
129	setText(MessageFormat.format(ContextMessages.OpenLaunchDialogAction_0, new String[] {extension.getLabel()}));	124	setImageDescriptor(extension.getImageDescriptor());
130	setImageDescriptor(null);
131	}
132	else {
133	setText(extension.getLabel() + "..."); //$NON-NLS-1$
134	setImageDescriptor(extension.getImageDescriptor());
135	}
136	setEnabled(existsConfigTypesForMode());	125	setEnabled(existsConfigTypesForMode());
137	}	126	}
		127	else {
		128	fBackingAction.setText(MessageFormat.format(ContextMessages.OpenLaunchDialogAction_1, new String[] {DebugUIPlugin.removeAccelerators(extension.getLabel())}));
		129	fBackingAction.setImageDescriptor(extension.getImageDescriptor());
		130	fBackingAction.setEnabled(existsConfigTypesForMode());
		131	}
138	}	132	}
139		133
140	/**	134	/**

Lines 20-34 Link Here

(-)ui/org/eclipse/debug/ui/actions/LaunchShortcutsAction.java (-4 / +44 lines)
20	import org.eclipse.core.expressions.EvaluationContext;	20	import org.eclipse.core.expressions.EvaluationContext;
21	import org.eclipse.core.expressions.Expression;	21	import org.eclipse.core.expressions.Expression;
22	import org.eclipse.core.expressions.IEvaluationContext;	22	import org.eclipse.core.expressions.IEvaluationContext;
		23	import org.eclipse.core.resources.IResource;
23	import org.eclipse.core.runtime.CoreException;	24	import org.eclipse.core.runtime.CoreException;
		25	import org.eclipse.core.runtime.IAdaptable;
24	import org.eclipse.debug.core.DebugPlugin;	26	import org.eclipse.debug.core.DebugPlugin;
		27	import org.eclipse.debug.core.ILaunchConfiguration;
25	import org.eclipse.debug.core.ILaunchConfigurationType;	28	import org.eclipse.debug.core.ILaunchConfigurationType;
26	import org.eclipse.debug.core.ILaunchMode;	29	import org.eclipse.debug.core.ILaunchMode;
27	import org.eclipse.debug.internal.ui.DebugUIPlugin;	30	import org.eclipse.debug.internal.ui.DebugUIPlugin;
28	import org.eclipse.debug.internal.ui.actions.ActionMessages;	31	import org.eclipse.debug.internal.ui.actions.ActionMessages;
		32	import org.eclipse.debug.internal.ui.actions.LaunchConfigurationAction;
29	import org.eclipse.debug.internal.ui.actions.LaunchShortcutAction;	33	import org.eclipse.debug.internal.ui.actions.LaunchShortcutAction;
		34	import org.eclipse.debug.internal.ui.contextlaunching.ContextRunner;
30	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;	35	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
31	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchShortcutExtension;	36	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchShortcutExtension;
		37	import org.eclipse.debug.ui.DebugUITools;
32	import org.eclipse.debug.ui.ILaunchGroup;	38	import org.eclipse.debug.ui.ILaunchGroup;
33	import org.eclipse.jface.action.Action;	39	import org.eclipse.jface.action.Action;
34	import org.eclipse.jface.action.ActionContributionItem;	40	import org.eclipse.jface.action.ActionContributionItem;
Lines 37-42 Link Here
37	import org.eclipse.jface.viewers.ISelection;	43	import org.eclipse.jface.viewers.ISelection;
38	import org.eclipse.jface.viewers.ISelectionProvider;	44	import org.eclipse.jface.viewers.ISelectionProvider;
39	import org.eclipse.jface.viewers.IStructuredSelection;	45	import org.eclipse.jface.viewers.IStructuredSelection;
		46	import org.eclipse.swt.SWT;
40	import org.eclipse.swt.events.MenuAdapter;	47	import org.eclipse.swt.events.MenuAdapter;
41	import org.eclipse.swt.events.MenuEvent;	48	import org.eclipse.swt.events.MenuEvent;
42	import org.eclipse.swt.widgets.Control;	49	import org.eclipse.swt.widgets.Control;
Lines 51-56 Link Here
51	import org.eclipse.ui.PlatformUI;	58	import org.eclipse.ui.PlatformUI;
52	import org.eclipse.ui.activities.WorkbenchActivityHelper;	59	import org.eclipse.ui.activities.WorkbenchActivityHelper;
53		60
		61	import com.ibm.icu.text.MessageFormat;
		62
54	/**	63	/**
55	* A cascading sub-menu that shows all launch shortcuts pertinent to a	64	* A cascading sub-menu that shows all launch shortcuts pertinent to a
56	* selection. This action is similar to <code>ContextualLaunchAction</code>	65	* selection. This action is similar to <code>ContextualLaunchAction</code>
Lines 168-181 Link Here
168	}	177	}
169		178
170	/**	179	/**
		180	* Returns the resource this menu is open on.
		181	*
		182	* @return resource
		183	*/
		184	protected IResource getResource(Object element) {
		185	IResource resource = null;
		186	if (element instanceof IResource) {
		187	resource = (IResource) element;
		188	} else if (element instanceof IAdaptable) {
		189	resource = (IResource) ((IAdaptable)element).getAdapter(IResource.class);
		190	}
		191	return resource;
		192	}
		193
		194	/**
171	* Fills the flyout menu	195	* Fills the flyout menu
172	*/	196	*/
173	private void fillMenu() {	197	private void fillMenu() {
		198	try {
		199	Object selection = ContextRunner.getDefault().getCurrentContext();
		200	int accelerator = 1;
		201	ILaunchConfiguration config = DebugPlugin.getDefault().getLaunchManager().getDefaultConfiguration(getResource(selection));
		202	if(config != null && config.exists() && config.supportsMode(getMode())) {
		203	IAction action = new LaunchConfigurationAction(config, getMode(), MessageFormat.format(ActionMessages.ContextualLaunchAction_0, new String[] {config.getName()}), DebugUITools.getDefaultImageDescriptor(config), accelerator++);
		204	ActionContributionItem item = new ActionContributionItem(action);
		205	item.fill(fCreatedMenu, -1);
		206	new MenuItem(fCreatedMenu, SWT.SEPARATOR);
		207	}
		208	config = getLaunchConfigurationManager().isSharedConfig(selection);
		209	if(config != null && config.exists() && config.supportsMode(getMode())) {
		210	IAction action = new LaunchConfigurationAction(config, getMode(), config.getName(), DebugUITools.getDefaultImageDescriptor(config), accelerator++);
		211	ActionContributionItem item = new ActionContributionItem(action);
		212	item.fill(fCreatedMenu, -1);
		213	new MenuItem(fCreatedMenu, SWT.SEPARATOR);
		214	}
		215	}
		216	catch(CoreException ce) {DebugUIPlugin.log(ce);}
174	IEvaluationContext context = createContext();	217	IEvaluationContext context = createContext();
175	// gather all shortcuts and run their filters so that we only run the	218	List allShortCuts = getLaunchConfigurationManager().getLaunchShortcuts(fGroup.getCategory());
176	// filters one time for each shortcut. Running filters can be expensive.
177	// Also, only LOADED plug-ins get their filters run.
178	List /* <LaunchShortcutExtension> */ allShortCuts = getLaunchConfigurationManager().getLaunchShortcuts(fGroup.getCategory());
179	Iterator iter = allShortCuts.iterator();	219	Iterator iter = allShortCuts.iterator();
180	List filteredShortCuts = new ArrayList(10);	220	List filteredShortCuts = new ArrayList(10);
181	while (iter.hasNext()) {	221	while (iter.hasNext()) {

Lines 10-20 Link Here

(-)tests/org/eclipse/jdt/debug/tests/launching/LaunchShortcutTests.java (-29 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.debug.tests.launching;	11	package org.eclipse.jdt.debug.tests.launching;
12		12
13	import org.eclipse.core.resources.IProject;
14	import org.eclipse.core.runtime.CoreException;
15	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;	13	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
16	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchShortcutExtension;	14	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchShortcutExtension;
17	import org.eclipse.jdt.core.IJavaProject;
18	import org.eclipse.jdt.debug.tests.AbstractDebugTest;	15	import org.eclipse.jdt.debug.tests.AbstractDebugTest;
19		16
20	/**	17	/**
Lines 99-128 Link Here
99	assertNotNull("launch configuration manager cannot be null", lcm);	96	assertNotNull("launch configuration manager cannot be null", lcm);
100	assertTrue("there should be 2 or more shortcuts", lcm.getApplicableLaunchShortcuts("org.eclipse.jdt.launching.localJavaApplication").size() >= 2);	97	assertTrue("there should be 2 or more shortcuts", lcm.getApplicableLaunchShortcuts("org.eclipse.jdt.launching.localJavaApplication").size() >= 2);
101	}	98	}
102
103	/**
104	* test that a default launch shortcut can be set, persisted and retrieved
105	*/
106	public void testSetDefaultLaunchShortcut() {
107	LaunchConfigurationManager lcm = getLaunchConfigurationManager();
108	assertNotNull("the launch configuration manager should not be null", lcm);
109	LaunchShortcutExtension ext = getJavaApplicationLaunchShortcut();
110	assertNotNull("the java launch shortcut should not be null", ext);
111	IJavaProject jproject = getJavaProject();
112	assertNotNull("the java project should not be null", jproject);
113	IProject project = jproject.getProject();
114	assertNotNull("the project should not be null", project);
115	try {
116	assertNull("there should be no default launch shortcut for the test project", lcm.getDefaultLaunchShortcut(project));
117	lcm.setDefaultLaunchShortcut(project, ext);
118	ext = lcm.getDefaultLaunchShortcut(project);
119	assertNotNull("the default launch shortcut should be the java app shortcut", ext);
120	lcm.setDefaultLaunchShortcut(project, null);
121	ext = lcm.getDefaultLaunchShortcut(project);
122	assertNull("there should be no default launch shortcut for the test project", ext);
123	}
124	catch (CoreException e) {
125	fail();
126	}
127	}
128	}	99	}