Attachment #58895 for bug #74480

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




/*******************************************************************************
 * 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_10;
	public static String ContextRunner_11;
	public static String ContextRunner_12;
	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=Neither the selected resource or its' associated project are 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
ContextRunner_10=Would you like to try and launch the parent project [{0}] of {1}?
ContextRunner_11=Launch Parent Project?
ContextRunner_12=&Always launch project if resource is not launchable
OpenLaunchDialogAction_0=Open {0} Dialog...
OpenLaunchDialogAction_1=&Open {0} Dialog...




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

import java.util.ArrayList;
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.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;


 * @see ContextLaunchingAction
 * @see ContextLaunchingToolbarAction
 * @see ILaunchListener
 * @see org.eclipse.debug.core.ILaunchManager
 * 
 *  @since 3.3
 *  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);
					}
				}
			}
			else {
				handleUnknownContext(mode);
			}
		}
		catch(CoreException ce) {DebugUIPlugin.log(ce);}
	}
	
	/**
	 * Handles the case where the context is unknown: Meaning that nothing can be launched.
	 * @param mode the mode
	 */
	protected void handleUnknownContext(String mode) {
		ILaunchConfiguration config = getLastLaunch(mode);
		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);
					}
				}
			}
			//2. launch last if no resource
			config = getLastLaunch(mode);
			if(config != null) {
				DebugUITools.launch(config, mode);
				return;
			}
			
		}
		catch(CoreException ce) {DebugUIPlugin.log(ce);}
	}
	
	/**

	}
	
	/**
	 * Returns the <code>ILaunchGroup</code> that corresponds to the specified mode
	 * @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 <code>ILaunchGroup</code> that corresponds to the specified mode, or <code>null</code>
	 */
	protected ILaunchGroup resolveLaunchGroup(String mode) {
		//TODO might not return the group we want

	}
	
	/**
	 * Returns if the parent project should be checked automatically
	 * @return true if the parent project should checked automatically, false otherwise
	 */
	protected boolean shouldCheckParent() {
		return DebugUIPlugin.getDefault().getPreferenceStore().getBoolean(IInternalDebugUIConstants.PREF_LAUNCH_PARENT_PROJECT);
		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
	 * @param resource
	 * @param mode
	 * @return if the context was launched in the given mode or not
	 * @throws CoreException
	 */
	protected boolean selectAndLaunch(IResource resource, String mode) throws CoreException {
		List configs = getLaunchConfigurationManager().getApplicableLaunchConfigurations(resource);
		int csize = configs.size();
		if(csize == 1) {
			DebugUITools.launch((ILaunchConfiguration) configs.get(0), mode);
		List exts = getLaunchShortcuts(resource);
		if(exts.size() == 1) {
			//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) {
			List exts = getLaunchConfigurationManager().getLaunchShortcuts(resource);
			int esize = exts.size();
			if(esize == 1) {
				LaunchShortcutExtension ext = (LaunchShortcutExtension) exts.get(0);
				ext.launch(new StructuredSelection(resource), mode);
				return true;
			}
			if(esize > 1) {
				return showShortcutSelectionDialog(resource, mode);
			}
			if(esize < 1) {
				IProject project = resource.getProject();
				if(project != null && !project.equals(resource)) {
					if(!shouldCheckParent()) {
						String msg = MessageFormat.format(ContextMessages.ContextRunner_10, new String[] {project.getName(), resource.getName()});
						MessageDialogWithToggle mdwt = new MessageDialogWithToggle(DebugUIPlugin.getShell(), 
								ContextMessages.ContextRunner_11, 
								null, 
								msg,
								MessageDialog.QUESTION, 
								new String[] {IDialogConstants.YES_LABEL, IDialogConstants.CANCEL_LABEL},
								0, 
								ContextMessages.ContextRunner_12,
								false);
						if(mdwt.open() == IDialogConstants.YES_ID) {
							DebugUIPlugin.getDefault().getPreferenceStore().setValue(IInternalDebugUIConstants.PREF_LAUNCH_PARENT_PROJECT, mdwt.getToggleState());
							selectAndLaunch(project, mode);
						}
					}
					else {
						selectAndLaunch(project, mode);
					}
				}
				else {
					MessageDialog.openInformation(DebugUIPlugin.getShell(), ContextMessages.ContextRunner_0, ContextMessages.ContextRunner_7);
				}
			}
			return false;
		}
		else if(csize > 1){
			ILaunchConfiguration config = getMRUConfiguration(configs, mode);
			if(config != null) {
				DebugUITools.launch(config, mode);
			}
			else {
				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 the associated launch configuration from the MRU listing or <code>null</code> if there isn't one
	 */
	protected ILaunchConfiguration getMRUConfiguration(List configurations, String mode) {
		ILaunchGroup group = resolveLaunchGroup(mode);
		if(group != null) {
			LaunchHistory history = DebugUIPlugin.getDefault().getLaunchConfigurationManager().getLaunchHistory(group.getIdentifier());
			ILaunchConfiguration config = null;
			for(Iterator iter = configurations.iterator(); iter.hasNext();) {
				config = (ILaunchConfiguration) iter.next();
				if(history.contains(config)) {
					return config;
				}
			}
		}
		return null;
	}
	
	/**
	 * 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;
						}
					}
				}
			}
			
		}
		return null;
	}
	
	/**
	 * Returns the associated launch configuration name of the currently selected context, or the empty string.
	 * @param mode the mode for the label request
	 * @return the associated launch configuration name of the currently selected context or the empty string. 
	 * @return the name of the currently selected context or the empty string. 
	 */
	public String getContextName(String mode) {
		Object o = getCurrentContext();
		ILaunchConfiguration config = getLaunchConfigurationManager().isSharedConfig(o);
		if(config != null) {
			return config.getName();
		}
		else {
			if(o instanceof IAdaptable) {
				Object a = ((IAdaptable)o).getAdapter(IResource.class);
				if(a != null) {
					IResource res = (IResource) a;
					String lbl = resolveConfigName(res, mode);
					if(!"".equals(lbl)) { //$NON-NLS-1$
						return lbl;
					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$
						}
					}
				}
			}
			config = getLastLaunch(mode);
			if(config != null) {
				return config.getName();
			}
		}
		return ""; //$NON-NLS-1$
	}
	
	/**
	 * Returns the name of the <code>ILaunchConfiguration</code> that corresponds to the specified <code>IResource</code>
	 * @param resource the resource
	 * @param mode the mode
	 * @return the name of the associated launch configuration, or the empty string if none
		return DebugUIPlugin.getDefault().getPreferenceStore().getBoolean(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH);
	}
	
	/**
	 * Returns the launch manager
	 * @return the launch manager
	 */
	protected LaunchManager getLaunchManager() {
		return (LaunchManager) DebugPlugin.getDefault().getLaunchManager();
	}
	
	/**
	 * @see org.eclipse.debug.core.ILaunchListener#launchAdded(org.eclipse.debug.core.ILaunch)
	 */
	protected String resolveConfigName(IResource resource, String mode) {
		if(resource != null) {
			try {
				ILaunchConfiguration config = null;
				List configs = getLaunchConfigurationManager().getApplicableLaunchConfigurations(resource);
				if(configs.size() == 1) {
					config = (ILaunchConfiguration) configs.get(0);
				}
				else if(configs.size() > 1){
					config = getMRUConfiguration(configs, mode);
					if(config == null) {
						return "..."; //$NON-NLS-1$
					}
				}
				else {
					//no configs
					List shortcuts = getLaunchConfigurationManager().getLaunchShortcuts(resource);
					if(shortcuts.size() > 0) {
						return "..."; //$NON-NLS-1$
					}
				}
				if(config != null) {
					return config.getName();
				}
				getLaunchManager().removeLaunchListener(this);
				fMakeProjectDefault = false;
				fMakeResourceDefault = false;
			}
			catch (CoreException ce) {DebugUIPlugin.log(ce);}
		}
		return ""; //$NON-NLS-1$
	}
	
	/**
	 * Returns if context launching is enabled
	 * @return if context launching is enabled
	 * @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
	 */
	public boolean isContextLaunchEnabled() {
		return DebugUIPlugin.getDefault().getPreferenceStore().getBoolean(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH);
		if(config != null && config.exists()) {
			DebugUITools.launch(config, mode);
			return true;
		}
		else {
			return false;
		}
	}
	
	/**
	 * Returns the launch configuration manager
	 * @return the launch configuration manager
	public void launchChanged(ILaunch launch) {}

	/**
	 * @see org.eclipse.debug.core.ILaunchListener#launchRemoved(org.eclipse.debug.core.ILaunch)
	 */
	protected LaunchConfigurationManager getLaunchConfigurationManager() {
		return DebugUIPlugin.getDefault().getLaunchConfigurationManager();
	}
}




/*******************************************************************************
 * 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 BooleanFieldEditor(IInternalDebugUIConstants.PREF_LAUNCH_PARENT_PROJECT, DebugPreferencesMessages.ContextLaunchingPreferencePage_0, comp);
				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++) {

Lines 18-25 Link Here

(-)ui/org/eclipse/debug/internal/ui/preferences/DebugPreferencesMessages.properties (-2 / +1 lines)
18	ConsolePreferencePage_Wrap_text_1=Fixed &width console	18	ConsolePreferencePage_Wrap_text_1=Fixed &width console
19	ContextualLaunchPreferencePage_0=This page is used to edit contextual launching options (EXPERIMENTAL).	19	ContextualLaunchPreferencePage_0=This page is used to edit contextual launching options (EXPERIMENTAL).
20	ContextualLaunchPreferencePage_1=&Enable contextual launching.	20	ContextualLaunchPreferencePage_1=&Enable contextual launching.
21	ContextLaunchingPreferencePage_0=Launch previous when no context available	21	ContextLaunchingPreferencePage_0=Always launch &related project if context is not launchable
22	ContextLaunchingPreferencePage_1=Launch project of un-runnable context
23	ConsolePreferencePage_Console_width=&Maximum character width:	22	ConsolePreferencePage_Console_width=&Maximum character width:
24	ConsolePreferencePage_Limit_console_output_1=&Limit console output	23	ConsolePreferencePage_Limit_console_output_1=&Limit console output
25	ConsolePreferencePage_Console_buffer_size__characters___2=Console &buffer size (characters):	24	ConsolePreferencePage_Console_buffer_size__characters___2=Console &buffer size (characters):





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;

	}

	/**
	 * 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) {

			List list = new ArrayList();
			list.add(resource);
			IEvaluationContext context = new EvaluationContext(null, list);
			context.setAllowPluginActivation(true);
			context.addVariable("selection", list); //$NON-NLS-1$
			HashSet set = new HashSet();
			for(Iterator iter = exts.iterator(); iter.hasNext();) {

	}
	
	/**
	 * 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>
	 * type id or an empty list, 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 all launch shortcuts for the given category
	 *
	 * @return all launch shortcuts

	 * 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




	}
	
	/**
	 * Returns if either the history listing or the favorites listing contain the specified <code>ILaunchConfiguration</code>
	 * @param config the config to look for
	 * @return true if one of the listing contains the specified config, false otherwise
	 * @since 3.3
	 * CONTEXTLAUNCHING
	 */
	public boolean contains(ILaunchConfiguration config) {
		return fHistory.contains(config) || fFavorites.contains(config);
	}
	
	/**
	 * Adds the given configuration to this history
	 * 
	 * @param configuration




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();

		ArrayList result = new ArrayList();
		Iterator iter = fSelection.iterator();
		while (iter.hasNext()) {
			Object next = iter.next();
			result.add(next);
		}
		return result;
	}

Lines 186-193 Link Here

(-)ui/org/eclipse/debug/ui/actions/AbstractLaunchHistoryAction.java (-3 / +3 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(getMode());
191	}	191	}
192	String mode = getMode();	192	String mode = getMode();
193	if (mode.equals(ILaunchManager.RUN_MODE)) {	193	if (mode.equals(ILaunchManager.RUN_MODE)) {
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 / +1 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);	54	prefs.setDefault(IInternalDebugUIConstants.PREF_LAUNCH_PARENT_PROJECT, false);
55	prefs.setDefault(IInternalDebugUIConstants.PREF_ALWAYS_RUN_PROJECT_CONFIGURATION, MessageDialogWithToggle.PROMPT);
56		55
57	//View Management preference page	56	//View Management preference page
58	prefs.setDefault(IDebugUIConstants.PREF_MANAGE_VIEW_PERSPECTIVES, IDebugUIConstants.ID_DEBUG_PERSPECTIVE);	57	prefs.setDefault(IDebugUIConstants.PREF_MANAGE_VIEW_PERSPECTIVES, IDebugUIConstants.ID_DEBUG_PERSPECTIVE);




     * @since 3.3
     * CONTEXTLAUNCHING
     */ 
    public static final String PREF_USE_CONTEXTUAL_LAUNCH = IDebugUIConstants.PLUGIN_ID + ".UseContextualLaunch"; //$NON-NLS-1$
    
    /**
     * Boolean preference indicating if we should always consider the parent project when
     * a selected context is not runnable
     * 
     *  @since 3.3
     *  
     *  CONTEXTLAUNCHING
     */
    public static final String PREF_LAUNCH_PARENT_PROJECT = IDebugUIConstants.PLUGIN_ID + ".LaunchParentProject"; //$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.




               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 java.util.ArrayList;
import java.util.List;

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;
import org.eclipse.ui.activities.WorkbenchActivityHelper;

/**
 * Tests the capabilities of launch shortcuts from the <code>LaunchShortcuts</code> extension point

	 * For this test there should be a minimum of two shortcuts found.
	 */
	public void testGetApplicableLaunchShortcuts() {
		assertTrue("there should be 2 or more shortcuts", getApplicableLaunchShortcuts("org.eclipse.jdt.launching.localJavaApplication").size() >= 2);
		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);
	}
	
	/**
	 * 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
	 * @return a listing of <code>LaunchShortcutExtension</code>s that are associated with the specified launch configuration
	 * type id or an empty list, never <code>null</code>
	 * 
	 * @since 3.3
	 */
	public List getApplicableLaunchShortcuts(String typeid) {
		List list = new ArrayList();
		LaunchShortcutExtension ext = null;
		List shortcuts = getLaunchConfigurationManager().getLaunchShortcuts();
		for(int i = 0; i < shortcuts.size(); i++) {
			ext = (LaunchShortcutExtension) shortcuts.get(i);
			if(ext.getAssociatedConfigurationTypes().contains(typeid) && !WorkbenchActivityHelper.filterItem(ext)) {
				list.add(ext);
			}
			ext = lcm.getDefaultLaunchShortcut(project);
			assertNull("there should be no default launch shortcut for the test project", ext);
		} 
		catch (CoreException e) {
			fail();
		}
		return list;
	}
}

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	}




	 * 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 {

Return to bug 74480

Lines 208-232 Link Here

(-)ui/org/eclipse/debug/internal/ui/IInternalDebugUIConstants.java (-14 / +5 lines)
208	* @since 3.3	208	* @since 3.3
209	* CONTEXTLAUNCHING	209	* CONTEXTLAUNCHING
210	*/	210	*/
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	214	* Boolean preference indicating if we should always consider the parent project when
		215	* a selected context is not runnable
215	*	216	*
216	* @since 3.3	217	* @since 3.3
217	*
218	* CONTEXTLAUNCHING	218	* CONTEXTLAUNCHING
219	*/	219	*/
220	public static final String PREF_ALWAYS_RUN_LAST_LAUNCH = IDebugUIConstants.PLUGIN_ID + ".AlwaysRunLastLaunch"; //$NON-NLS-1$	220	public static final String PREF_LAUNCH_PARENT_PROJECT = IDebugUIConstants.PLUGIN_ID + ".LaunchParentProject"; //$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		221
231	/**	222	/**
232	* String preference controlling whether editors are saved before launching.	223	* String preference controlling whether editors are saved before launching.

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

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	}

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 (-8 / +6 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;	14	public static String ContextRunner_10;
16	public static String ContextRunner_2;	15	public static String ContextRunner_11;
17	public static String ContextRunner_3;	16	public static String ContextRunner_12;
18	public static String ContextRunner_4;
19	public static String ContextRunner_5;
20	public static String ContextRunner_6;
21
22	public static String ContextRunner_7;	17	public static String ContextRunner_7;
		18	public static String ContextRunner_8;
		19	public static String ContextRunner_9;
23	public static String OpenLaunchDialogAction_0;	20	public static String OpenLaunchDialogAction_0;
		21	public static String OpenLaunchDialogAction_1;
24	static {	22	static {
25	// initialize resource bundle	23	// initialize resource bundle
26	NLS.initializeMessages(BUNDLE_NAME, ContextMessages.class);	24	NLS.initializeMessages(BUNDLE_NAME, ContextMessages.class);

Lines 1-9 Link Here

(-)ui/org/eclipse/debug/internal/ui/contextlaunching/ContextMessages.properties (-7 / +7 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
7	ContextRunner_6=Neither the selected resource or its' associated project are launchable.
8	ContextRunner_7=The current context cannot be launched, and there are no recent launches.	2	ContextRunner_7=The current context cannot be launched, and there are no recent launches.
9	OpenLaunchDialogAction_0=Open {0} Dialog	3	ContextRunner_8=&Select a configuration to launch:
		4	ContextRunner_9=Select Configuration
		5	ContextRunner_10=Would you like to try and launch the parent project [{0}] of {1}?
		6	ContextRunner_11=Launch Parent Project?
		7	ContextRunner_12=&Always launch project if resource is not launchable
		8	OpenLaunchDialogAction_0=Open {0} Dialog...
		9	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 17-27 Link Here

(-)ui/org/eclipse/debug/internal/ui/preferences/ContextLaunchingPreferencePage.java (-12 / +3 lines)
17	import org.eclipse.debug.internal.ui.IDebugHelpContextIds;	17	import org.eclipse.debug.internal.ui.IDebugHelpContextIds;
18	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;	18	import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
19	import org.eclipse.debug.internal.ui.SWTUtil;	19	import org.eclipse.debug.internal.ui.SWTUtil;
20	import org.eclipse.jface.dialogs.MessageDialogWithToggle;
21	import org.eclipse.jface.preference.BooleanFieldEditor;	20	import org.eclipse.jface.preference.BooleanFieldEditor;
22	import org.eclipse.jface.preference.FieldEditor;	21	import org.eclipse.jface.preference.FieldEditor;
23	import org.eclipse.jface.preference.PreferencePage;	22	import org.eclipse.jface.preference.PreferencePage;
24	import org.eclipse.jface.preference.RadioGroupFieldEditor;
25	import org.eclipse.swt.layout.GridData;	23	import org.eclipse.swt.layout.GridData;
26	import org.eclipse.swt.widgets.Composite;	24	import org.eclipse.swt.widgets.Composite;
27	import org.eclipse.swt.widgets.Control;	25	import org.eclipse.swt.widgets.Control;
Lines 69-85 Link Here
69	//use contextual launch	67	//use contextual launch
70	FieldEditor edit = new BooleanFieldEditor(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH, DebugPreferencesMessages.ContextualLaunchPreferencePage_1, comp);	68	FieldEditor edit = new BooleanFieldEditor(IInternalDebugUIConstants.PREF_USE_CONTEXTUAL_LAUNCH, DebugPreferencesMessages.ContextualLaunchPreferencePage_1, comp);
71	fFieldEditors.add(edit);	69	fFieldEditors.add(edit);
72		70
73	edit = new RadioGroupFieldEditor(IInternalDebugUIConstants.PREF_ALWAYS_RUN_LAST_LAUNCH, DebugPreferencesMessages.ContextLaunchingPreferencePage_0, 3,	71	edit = new BooleanFieldEditor(IInternalDebugUIConstants.PREF_LAUNCH_PARENT_PROJECT, DebugPreferencesMessages.ContextLaunchingPreferencePage_0, comp);
74	new String[][] {{DebugPreferencesMessages.LaunchingPreferencePage_3, MessageDialogWithToggle.ALWAYS},
75	{DebugPreferencesMessages.LaunchingPreferencePage_5, MessageDialogWithToggle.PROMPT}},
76	comp, true);
77	fFieldEditors.add(edit);
78	edit = new RadioGroupFieldEditor(IInternalDebugUIConstants.PREF_ALWAYS_RUN_PROJECT_CONFIGURATION, DebugPreferencesMessages.ContextLaunchingPreferencePage_1, 3,
79	new String[][] {{DebugPreferencesMessages.LaunchingPreferencePage_7, MessageDialogWithToggle.ALWAYS},
80	{DebugPreferencesMessages.LaunchingPreferencePage_9, MessageDialogWithToggle.PROMPT}},
81	comp, true);
82	fFieldEditors.add(edit);	72	fFieldEditors.add(edit);
		73
83	//init the field editors	74	//init the field editors
84	FieldEditor editor;	75	FieldEditor editor;
85	for(int i = 0; i < fFieldEditors.size(); i++) {	76	for(int i = 0; i < fFieldEditors.size(); i++) {

Lines 34-40 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationManager.java (-93 / +133 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	* Creates a listing of the launch shortcut extensions that are applicable to the underlying resource
		601	* @param resource the underlying resource
		602	* @return a listing of applicable launch shortcuts or an empty list, never <code>null</code>
		603	* @throws CoreException
		604	* @since 3.3
		605	*/
		606	public List getLaunchShortcuts(IResource resource) throws CoreException {
		607	List list = new ArrayList();
		608	List sc = getLaunchShortcuts();
		609	List ctxt = new ArrayList();
		610	ctxt.add(resource);
		611	IEvaluationContext context = new EvaluationContext(null, ctxt);
		612	context.addVariable("selection", ctxt); //$NON-NLS-1$
		613	LaunchShortcutExtension ext = null;
		614	for(Iterator iter = sc.iterator(); iter.hasNext();) {
		615	ext = (LaunchShortcutExtension) iter.next();
		616	if(ext.evalEnablementExpression(context, ext.getContextualLaunchEnablementExpression()) && !WorkbenchActivityHelper.filterItem(ext)) {
		617	if(!list.contains(ext)) {
		618	list.add(ext);
		619	}
		620	}
		621	}
		622	return list;
		623	}
		624
		625	/**
603	* Returns a listing of all of the <code>ILaunchConfigurationType</code>s that apply to the currently	626	* Returns a listing of all of the <code>ILaunchConfigurationType</code>s that apply to the currently
604	* specified <code>IResource</code>.	627	* specified <code>IResource</code>.
605	*	628	*
606	* @param resource the resource context	629	* @param resource the resource context
607	* @return a listing of applicable <code>ILaunchConfigurationType</code>s, or an empty list, never <code>null</code>	630	* @return a listing of applicable <code>ILaunchConfigurationType</code>s, or an empty list, never <code>null</code>
608	* @since 3.3	631	* @since 3.3
609	* EXPERIMENTAL
610	* CONTEXTLAUNCHING	632	* CONTEXTLAUNCHING
611	*/	633	*/
612	public List getApplicableConfigurationTypes(IResource resource) {	634	public List getApplicableConfigurationTypes(IResource resource) {
Lines 617-622 Link Here
617	List list = new ArrayList();	639	List list = new ArrayList();
618	list.add(resource);	640	list.add(resource);
619	IEvaluationContext context = new EvaluationContext(null, list);	641	IEvaluationContext context = new EvaluationContext(null, list);
		642	context.setAllowPluginActivation(true);
620	context.addVariable("selection", list); //$NON-NLS-1$	643	context.addVariable("selection", list); //$NON-NLS-1$
621	HashSet set = new HashSet();	644	HashSet set = new HashSet();
622	for(Iterator iter = exts.iterator(); iter.hasNext();) {	645	for(Iterator iter = exts.iterator(); iter.hasNext();) {
Lines 641-667 Link Here
641	}	664	}
642		665
643	/**	666	/**
644	* Returns a listing of all applicable <code>LaunchShortcutExtension</code>s for the given	667	* Returns a list of the <code>ILaunchConfiguration</code>s that apply to the specified <code>IResource</code>
645	* launch configuration type id.	668	* @param resource the resource
646	* @param typeid the id of the launch configuration	669	* @return a listing of applicable <code>ILaunchConfiguration</code>s for the specified <code>IResource</code> or an empty
647	* @return a listing of <code>LaunchShortcutExtension</code>s that are associated with the specified launch configuration	670	* list if none, never <code>null</code>
648	* type id or an empty list, never <code>null</code>
649	*
650	* @since 3.3	671	* @since 3.3
651	*/	672	*/
652	public List getApplicableLaunchShortcuts(String typeid) {	673	public List getApplicableLaunchConfigurations(IResource resource) {
653	List list = new ArrayList();	674	ArrayList list = new ArrayList();
654	LaunchShortcutExtension ext = null;	675	IPath resourcePath = resource.getFullPath();
655	for(int i = 0; i < fLaunchShortcuts.size(); i++) {	676	try {
656	ext = (LaunchShortcutExtension) fLaunchShortcuts.get(i);	677	List types = getApplicableConfigurationTypes(resource);
657	if(ext.getAssociatedConfigurationTypes().contains(typeid)) {	678	List configs = new ArrayList();
658	list.add(ext);	679	ILaunchConfiguration[] configurations = getLaunchManager().getLaunchConfigurations();
		680	for(int i = 0; i < configurations.length; i++) {
		681	if(types.contains(configurations[i].getType())) {
		682	if(configurations[i].isMigrationCandidate()) {
		683	configurations[i].migrate();
		684	}
		685	configs.add(configurations[i]);
		686	}
659	}	687	}
		688	ILaunchConfiguration configuration = null;
		689	IResource[] resources = null;
		690	for (Iterator iter = configs.iterator(); iter.hasNext();) {
		691	configuration = (ILaunchConfiguration) iter.next();
		692	if(acceptConfiguration(configuration)) {
		693	if(configuration.contentsEqual(getLaunchManager().getDefaultConfiguration(resource))) {
		694	list.add(configuration);
		695	}
		696	else {
		697	resources = configuration.getMappedResources();
		698	if (resources != null) {
		699	for (int j = 0; j < resources.length; j++) {
		700	if (resource.equals(resources[j]) \|\| resourcePath.isPrefixOf(resources[j].getFullPath())) {
		701	list.add(configuration);
		702	break;
		703	}
		704	}
		705	}
		706	else {
		707	//in the event the config has no mapping
		708	list.add(configuration);
		709	}
		710	}
		711	}
		712	}
		713	} catch (CoreException e) {
		714	list.clear();
		715	DebugPlugin.log(e);
660	}	716	}
661	return list;	717	return list;
662	}	718	}
663		719
664	/**	720	/**
		721	* Returns if the specified configuration should be considered as a potential candidate
		722	* @param config
		723	* @return if the specified configuration should be considered as a potential candidate
		724	* @throws CoreException
		725	*/
		726	private boolean acceptConfiguration(ILaunchConfiguration config) throws CoreException {
		727	if(config != null && !DebugUITools.isPrivate(config)) {
		728	if(!"org.eclipse.ui.externaltools".equals(config.getType().getCategory())) { //$NON-NLS-1$
		729	return true;
		730	}
		731	else {
		732	IResource[] res = config.getMappedResources();
		733	if(res != null) {
		734	return true;
		735	}
		736	}
		737	}
		738	return false;
		739	}
		740
		741	/**
665	* Returns all launch shortcuts for the given category	742	* Returns all launch shortcuts for the given category
666	*	743	*
667	* @return all launch shortcuts	744	* @return all launch shortcuts
Lines 738-746 Link Here
738	* or <code>null</code>	815	* or <code>null</code>
739	*	816	*
740	* @since 3.3	817	* @since 3.3
741	*
742	* EXPERIMENTAL
743	* CONTEXTLAUNCHING
744	*/	818	*/
745	public LaunchShortcutExtension getLaunchShortcut(String id) {	819	public LaunchShortcutExtension getLaunchShortcut(String id) {
746	loadLaunchShortcuts();	820	loadLaunchShortcuts();
Lines 755-760 Link Here
755	}	829	}
756		830
757	/**	831	/**
		832	* Returns the shared config from the selected resource or <code>null</code> if the selected resources is not a shared config
		833	* @param receiver the object to test if it is a shared launch configuration
		834	* @return the shared config from the selected resource or <code>null</code> if the selected resources is not a shared config
		835	* @since 3.3
		836	*/
		837	public ILaunchConfiguration isSharedConfig(Object receiver) {
		838	if(receiver instanceof IFile) {
		839	IFile file = (IFile) receiver;
		840	String ext = file.getFileExtension();
		841	if(ext == null) {
		842	return null;
		843	}
		844	if(ext.equals("launch")) { //$NON-NLS-1$
		845	ILaunchConfiguration config = DebugPlugin.getDefault().getLaunchManager().getLaunchConfiguration(file);
		846	if(config != null && config.exists()) {
		847	return config;
		848	}
		849	}
		850	}
		851	else if(receiver instanceof IFileEditorInput) {
		852	IFileEditorInput input = (IFileEditorInput) receiver;
		853	return isSharedConfig(input.getFile());
		854	}
		855	return null;
		856	}
		857
		858	/**
758	* Returns the image used to display an error in the given tab	859	* Returns the image used to display an error in the given tab
759	*/	860	*/
760	public Image getErrorTabImage(ILaunchConfigurationTab tab) {	861	public Image getErrorTabImage(ILaunchConfigurationTab tab) {
Lines 815-820 Link Here
815	}	916	}
816		917
817	/**	918	/**
		919	* Returns the singleton instance of the launch manager
		920	* @return the singleton instance of the launch manager
		921	* @since 3.3
		922	*/
		923	private LaunchManager getLaunchManager() {
		924	return (LaunchManager) DebugPlugin.getDefault().getLaunchManager();
		925	}
		926
		927	/**
818	* Restore launch history	928	* Restore launch history
819	*/	929	*/
820	private void loadLaunchHistories() {	930	private void loadLaunchHistories() {
Lines 835-910 Link Here
835	}	945	}
836		946
837	/**	947	/**
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.	948	* Returns the default launch group for the given mode.
909	*	949	*
910	* @param mode	950	* @param mode

Lines 73-78 Link Here

(-)ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchHistory.java (+11 lines)
73	}	73	}
74		74
75	/**	75	/**
		76	* Returns if either the history listing or the favorites listing contain the specified <code>ILaunchConfiguration</code>
		77	* @param config the config to look for
		78	* @return true if one of the listing contains the specified config, false otherwise
		79	* @since 3.3
		80	* CONTEXTLAUNCHING
		81	*/
		82	public boolean contains(ILaunchConfiguration config) {
		83	return fHistory.contains(config) \|\| fFavorites.contains(config);
		84	}
		85
		86	/**
76	* Adds the given configuration to this history	87	* Adds the given configuration to this history
77	*	88	*
78	* @param configuration	89	* @param configuration

Lines 20-34 Link Here

(-)ui/org/eclipse/debug/ui/actions/ContextualLaunchAction.java (-39 / +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.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 299-305 Link Here
299	ArrayList result = new ArrayList();	303	ArrayList result = new ArrayList();
300	Iterator iter = fSelection.iterator();	304	Iterator iter = fSelection.iterator();
301	while (iter.hasNext()) {	305	while (iter.hasNext()) {
302	result.add(iter.next());	306	Object next = iter.next();
		307	result.add(next);
303	}	308	}
304	return result;	309	return result;
305	}	310	}

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-21 Link Here

(-)tests/org/eclipse/jdt/debug/tests/launching/LaunchShortcutTests.java (-28 / +23 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;	13	import java.util.ArrayList;
14	import org.eclipse.core.runtime.CoreException;	14	import java.util.List;
		15
15	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;	16	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
16	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchShortcutExtension;	17	import org.eclipse.debug.internal.ui.launchConfigurations.LaunchShortcutExtension;
17	import org.eclipse.jdt.core.IJavaProject;
18	import org.eclipse.jdt.debug.tests.AbstractDebugTest;	18	import org.eclipse.jdt.debug.tests.AbstractDebugTest;
		19	import org.eclipse.ui.activities.WorkbenchActivityHelper;
19		20
20	/**	21	/**
21	* Tests the capabilities of launch shortcuts from the <code>LaunchShortcuts</code> extension point	22	* Tests the capabilities of launch shortcuts from the <code>LaunchShortcuts</code> extension point
Lines 95-128 Link Here
95	* For this test there should be a minimum of two shortcuts found.	96	* For this test there should be a minimum of two shortcuts found.
96	*/	97	*/
97	public void testGetApplicableLaunchShortcuts() {	98	public void testGetApplicableLaunchShortcuts() {
98	LaunchConfigurationManager lcm = getLaunchConfigurationManager();	99	assertTrue("there should be 2 or more shortcuts", getApplicableLaunchShortcuts("org.eclipse.jdt.launching.localJavaApplication").size() >= 2);
99	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);
101	}	100	}
102		101
103	/**	102	/**
104	* test that a default launch shortcut can be set, persisted and retrieved	103	* Returns a listing of all applicable <code>LaunchShortcutExtension</code>s for the given
105	*/	104	* launch configuration type id.
106	public void testSetDefaultLaunchShortcut() {	105	* @param typeid the id of the launch configuration
107	LaunchConfigurationManager lcm = getLaunchConfigurationManager();	106	* @return a listing of <code>LaunchShortcutExtension</code>s that are associated with the specified launch configuration
108	assertNotNull("the launch configuration manager should not be null", lcm);	107	* type id or an empty list, never <code>null</code>
109	LaunchShortcutExtension ext = getJavaApplicationLaunchShortcut();	108	*
110	assertNotNull("the java launch shortcut should not be null", ext);	109	* @since 3.3
111	IJavaProject jproject = getJavaProject();	110	*/
112	assertNotNull("the java project should not be null", jproject);	111	public List getApplicableLaunchShortcuts(String typeid) {
113	IProject project = jproject.getProject();	112	List list = new ArrayList();
114	assertNotNull("the project should not be null", project);	113	LaunchShortcutExtension ext = null;
115	try {	114	List shortcuts = getLaunchConfigurationManager().getLaunchShortcuts();
116	assertNull("there should be no default launch shortcut for the test project", lcm.getDefaultLaunchShortcut(project));	115	for(int i = 0; i < shortcuts.size(); i++) {
117	lcm.setDefaultLaunchShortcut(project, ext);	116	ext = (LaunchShortcutExtension) shortcuts.get(i);
118	ext = lcm.getDefaultLaunchShortcut(project);	117	if(ext.getAssociatedConfigurationTypes().contains(typeid) && !WorkbenchActivityHelper.filterItem(ext)) {
119	assertNotNull("the default launch shortcut should be the java app shortcut", ext);	118	list.add(ext);
120	lcm.setDefaultLaunchShortcut(project, null);	119	}
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	}	120	}
		121	return list;
127	}	122	}
128	}	123	}