org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/debug/ui/launchConfigurations/JavaLaunchShortcut.java - jdt/eclipse.jdt.debug - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007, 2015 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.jdt.debug.ui.launchConfigurations;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;

 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.debug.core.DebugPlugin;
 import org.eclipse.debug.core.ILaunchConfiguration;
 import org.eclipse.debug.core.ILaunchConfigurationType;
 import org.eclipse.debug.ui.DebugUITools;
 import org.eclipse.debug.ui.IDebugModelPresentation;
 import org.eclipse.debug.ui.ILaunchShortcut2;
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
 import org.eclipse.jdt.internal.debug.ui.launcher.DebugTypeSelectionDialog;
 import org.eclipse.jdt.internal.debug.ui.launcher.LauncherMessages;
 import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
 import org.eclipse.jface.dialogs.MessageDialog;
 import org.eclipse.jface.operation.IRunnableContext;
 import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.jface.viewers.IStructuredSelection;
 import org.eclipse.jface.window.Window;
 import org.eclipse.swt.widgets.Shell;
 import org.eclipse.ui.IEditorInput;
 import org.eclipse.ui.IEditorPart;
 import org.eclipse.ui.PlatformUI;
 import org.eclipse.ui.dialogs.ElementListSelectionDialog;

 /**
  * Common behavior for Java launch shortcuts
  * <p>
  * This class may be sub-classed.
  * </p>
  * @since 3.3
  */
 public abstract class JavaLaunchShortcut implements ILaunchShortcut2 {

 	/**
 	 * Returns the type of configuration this shortcut is applicable to.
 	 *
 	 * @return the type of configuration this shortcut is applicable to
 	 */
 	protected abstract ILaunchConfigurationType getConfigurationType();

 	/**
 	 * Creates and returns a new configuration based on the specified type.
 	 *
 	 * @param type type to create a launch configuration for
 	 * @return launch configuration configured to launch the specified type
 	 */
 	protected abstract ILaunchConfiguration createConfiguration(IType type);

 	/**
 	 * Finds and returns the types in the given collection of elements that can be launched.
 	 *
 	 * @param elements scope to search for types that can be launched
 	 * @param context progress reporting context
 	 * @return collection of types that can be launched, possibly empty
 	 * @exception InterruptedException if the search is canceled
 	 * @exception CoreException if the search fails
 	 */
 	protected abstract IType[] findTypes(Object[] elements, IRunnableContext context) throws InterruptedException, CoreException;

 	/**
 	 * Returns a title for a type selection dialog used to prompt the user when there is more than
 	 * one type that can be launched.
 	 *
 	 * @return type selection dialog title
 	 */
 	protected abstract String getTypeSelectionTitle();

 	/**
 	 * Returns an error message to use when the editor does not contain a type that can be launched.
 	 *
 	 * @return error message when editor cannot be launched
 	 */
 	protected abstract String getEditorEmptyMessage();

 	/**
 	 * Returns an error message to use when the selection does not contain a type that can be launched.
 	 *
 	 * @return error message when selection cannot be launched
 	 */
 	protected abstract String getSelectionEmptyMessage();

 	/**
 	 * Resolves a type that can be launched from the given scope and launches in the
 	 * specified mode.
 	 *
 	 * @param scope the java elements to consider for a type that can be launched
 	 * @param mode launch mode
 	 * @param selectTitle prompting title for choosing a type to launch
 	 * @param emptyMessage error message when no types are resolved for launching
 	 */
 	private void searchAndLaunch(Object[] scope, String mode, String selectTitle, String emptyMessage) {
 		IType[] types = null;
 		try {
 			types = findTypes(scope, PlatformUI.getWorkbench().getProgressService());
 		}
 		catch (InterruptedException e) {return;}
 		catch (CoreException e) {
 			MessageDialog.openError(getShell(), LauncherMessages.JavaLaunchShortcut_0, e.getMessage());
 			return;
 		}
 		IType type = null;
 		if (types.length == 0) {
 			MessageDialog.openError(getShell(), LauncherMessages.JavaLaunchShortcut_1, emptyMessage);
 		}
 		else if (types.length > 1) {
 			type = chooseType(types, selectTitle);
 		}
 		else {
 			type = types[0];
 		}
 		if (type != null) {
 			launch(type, mode);
 		}
 	}

 	/**
 	 * Prompts the user to select a type from the given types.
 	 *
 	 * @param types the types to choose from
 	 * @param title the selection dialog title
 	 *
 	 * @return the selected type or <code>null</code> if none.
 	 */
 	protected IType chooseType(IType[] types, String title) {
 		DebugTypeSelectionDialog mmsd = new DebugTypeSelectionDialog(JDIDebugUIPlugin.getShell(), types, title);
 		if (mmsd.open() == Window.OK) {
 			return (IType)mmsd.getResult()[0];
 		}
 		return null;
 	}

 	/**
 	 * Launches the given type in the specified mode.
 	 *
 	 * @param type type to launch
 	 * @param mode launch mode
 	 * @since 3.5
 	 */
 	protected void launch(IType type, String mode) {
 		List<ILaunchConfiguration> configs = getCandidates(type, getConfigurationType());
 		if(configs != null) {
 			ILaunchConfiguration config = null;
 			int count = configs.size();
 			if(count == 1) {
 				config = configs.get(0);
 			}
 			else if(count > 1) {
 				config = chooseConfiguration(configs);
 				if(config == null) {
 					return;
 				}
 			}
 			if (config == null) {
 				config = createConfiguration(type);
 			}
 			if (config != null) {
 				DebugUITools.launch(config, mode);
 			}
 		}
 	}

 	/**
 	 * Collect the listing of {@link ILaunchConfiguration}s that apply to the given {@link IType} and {@link ILaunchConfigurationType}
 	 *
 	 * @param type the type
 	 * @param ctype the {@link ILaunchConfigurationType}
 	 * @return the list of {@link ILaunchConfiguration}s or an empty list, never <code>null</code>
 	 * @since 3.8
 	 */
 	List<ILaunchConfiguration> getCandidates(IType type, ILaunchConfigurationType ctype) {
 		List<ILaunchConfiguration> candidateConfigs = Collections.EMPTY_LIST;
 		try {
 			ILaunchConfiguration[] configs = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurations(ctype);
 			candidateConfigs = new ArrayList<>(configs.length);
 			for (int i = 0; i < configs.length; i++) {
 				ILaunchConfiguration config = configs[i];
 				if (config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, "").equals(type.getFullyQualifiedName())) { //$NON-NLS-1$
 					if (config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, "").equals(type.getJavaProject().getElementName())) { //$NON-NLS-1$
 						candidateConfigs.add(config);
 					}
 				}
 			}
 		} catch (CoreException e) {
 			JDIDebugUIPlugin.log(e);
 		}
 		return candidateConfigs;
 	}

 	/**
 	 * Finds and returns an <b>existing</b> configuration to re-launch for the given type,
 	 * or <code>null</code> if there is no existing configuration.
 	 *
 	 * @param type the {@link IType} to try and find the {@link ILaunchConfiguration} for
 	 * @param configType the {@link ILaunchConfigurationType} to try and narrow down the search
 	 *
 	 * @return a configuration to use for launching the given type or <code>null</code> if none
 	 */
 	protected ILaunchConfiguration findLaunchConfiguration(IType type, ILaunchConfigurationType configType) {
 		List<ILaunchConfiguration> configs = getCandidates(type, configType);
 		int count = configs.size();
 		if(count == 1) {
 			return configs.get(0);
 		}
 		if(count > 1) {
 			return chooseConfiguration(configs);
 		}
 		return null;
 	}

 	/**
 	 * Returns a configuration from the given collection of configurations that should be launched,
 	 * or <code>null</code> to cancel. Default implementation opens a selection dialog that allows
 	 * the user to choose one of the specified launch configurations.  Returns the chosen configuration,
 	 * or <code>null</code> if the user cancels.
 	 *
 	 * @param configList list of configurations to choose from
 	 * @return configuration to launch or <code>null</code> to cancel
 	 */
 	protected ILaunchConfiguration chooseConfiguration(List<ILaunchConfiguration> configList) {
 		IDebugModelPresentation labelProvider = DebugUITools.newDebugModelPresentation();
 		ElementListSelectionDialog dialog= new ElementListSelectionDialog(getShell(), labelProvider);
 		dialog.setElements(configList.toArray());
 		dialog.setTitle(getTypeSelectionTitle());
 		dialog.setMessage(LauncherMessages.JavaLaunchShortcut_2);
 		dialog.setMultipleSelection(false);
 		int result = dialog.open();
 		labelProvider.dispose();
 		if (result == Window.OK) {
 			return (ILaunchConfiguration) dialog.getFirstResult();
 		}
 		return null;
 	}

 	/**
 	 * Convenience method to return the active workbench window shell.
 	 *
 	 * @return active workbench window shell
 	 */
 	protected Shell getShell() {
 		return JDIDebugUIPlugin.getActiveWorkbenchShell();
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.debug.ui.ILaunchShortcut#launch(org.eclipse.ui.IEditorPart, java.lang.String)
 	 */
 	@Override
 	public void launch(IEditorPart editor, String mode) {
 		IEditorInput input = editor.getEditorInput();
 		IJavaElement je = input.getAdapter(IJavaElement.class);
 		if (je != null) {
 			searchAndLaunch(new Object[] {je}, mode, getTypeSelectionTitle(), getEditorEmptyMessage());
 		}
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.debug.ui.ILaunchShortcut#launch(org.eclipse.jface.viewers.ISelection, java.lang.String)
 	 */
 	@Override
 	public void launch(ISelection selection, String mode) {
 		if (selection instanceof IStructuredSelection) {
 			searchAndLaunch(((IStructuredSelection)selection).toArray(), mode, getTypeSelectionTitle(), getSelectionEmptyMessage());
 		}
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.debug.ui.ILaunchShortcut2#getLaunchableResource(org.eclipse.ui.IEditorPart)
 	 */
 	@Override
 	public IResource getLaunchableResource(IEditorPart editorpart) {
 		return getLaunchableResource(editorpart.getEditorInput());
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.debug.ui.ILaunchShortcut2#getLaunchableResource(org.eclipse.jface.viewers.ISelection)
 	 */
 	@Override
 	public IResource getLaunchableResource(ISelection selection) {
 		if (selection instanceof IStructuredSelection) {
 			IStructuredSelection ss = (IStructuredSelection) selection;
 			if (ss.size() == 1) {
 				Object element = ss.getFirstElement();
 				if (element instanceof IAdaptable) {
 					return getLaunchableResource((IAdaptable)element);
 				}
 			}
 		}
 		return null;
 	}

 	/**
 	 * Returns the resource containing the Java element associated with the
 	 * given adaptable, or <code>null</code>.
 	 *
 	 * @param adaptable adaptable object
 	 * @return containing resource or <code>null</code>
 	 */
 	private IResource getLaunchableResource(IAdaptable adaptable) {
 		IJavaElement je = adaptable.getAdapter(IJavaElement.class);
 		if (je != null) {
 			return je.getResource();
 		}
 		return null;
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.debug.ui.ILaunchShortcut2#getLaunchConfigurations(org.eclipse.ui.IEditorPart)
 	 */
 	@Override
 	public ILaunchConfiguration[] getLaunchConfigurations(IEditorPart editorpart) {
 		// let the framework resolve configurations based on resource mapping
 		return null;
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.debug.ui.ILaunchShortcut2#getLaunchConfigurations(org.eclipse.jface.viewers.ISelection)
 	 */
 	@Override
 	public ILaunchConfiguration[] getLaunchConfigurations(ISelection selection) {
 		// let the framework resolve configurations based on resource mapping
 		return null;
 	}


 }
	/*******************************************************************************
	* Copyright (c) 2007, 2015 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.jdt.debug.ui.launchConfigurations;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;

	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.debug.core.DebugPlugin;
	import org.eclipse.debug.core.ILaunchConfiguration;
	import org.eclipse.debug.core.ILaunchConfigurationType;
	import org.eclipse.debug.ui.DebugUITools;
	import org.eclipse.debug.ui.IDebugModelPresentation;
	import org.eclipse.debug.ui.ILaunchShortcut2;
	import org.eclipse.jdt.core.IJavaElement;
	import org.eclipse.jdt.core.IType;
	import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
	import org.eclipse.jdt.internal.debug.ui.launcher.DebugTypeSelectionDialog;
	import org.eclipse.jdt.internal.debug.ui.launcher.LauncherMessages;
	import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
	import org.eclipse.jface.dialogs.MessageDialog;
	import org.eclipse.jface.operation.IRunnableContext;
	import org.eclipse.jface.viewers.ISelection;
	import org.eclipse.jface.viewers.IStructuredSelection;
	import org.eclipse.jface.window.Window;
	import org.eclipse.swt.widgets.Shell;
	import org.eclipse.ui.IEditorInput;
	import org.eclipse.ui.IEditorPart;
	import org.eclipse.ui.PlatformUI;
	import org.eclipse.ui.dialogs.ElementListSelectionDialog;

	/**
	* Common behavior for Java launch shortcuts
	* <p>
	* This class may be sub-classed.
	* </p>
	* @since 3.3
	*/
	public abstract class JavaLaunchShortcut implements ILaunchShortcut2 {

	/**
	* Returns the type of configuration this shortcut is applicable to.
	*
	* @return the type of configuration this shortcut is applicable to
	*/
	protected abstract ILaunchConfigurationType getConfigurationType();

	/**
	* Creates and returns a new configuration based on the specified type.
	*
	* @param type type to create a launch configuration for
	* @return launch configuration configured to launch the specified type
	*/
	protected abstract ILaunchConfiguration createConfiguration(IType type);

	/**
	* Finds and returns the types in the given collection of elements that can be launched.
	*
	* @param elements scope to search for types that can be launched
	* @param context progress reporting context
	* @return collection of types that can be launched, possibly empty
	* @exception InterruptedException if the search is canceled
	* @exception CoreException if the search fails
	*/
	protected abstract IType[] findTypes(Object[] elements, IRunnableContext context) throws InterruptedException, CoreException;

	/**
	* Returns a title for a type selection dialog used to prompt the user when there is more than
	* one type that can be launched.
	*
	* @return type selection dialog title
	*/
	protected abstract String getTypeSelectionTitle();

	/**
	* Returns an error message to use when the editor does not contain a type that can be launched.
	*
	* @return error message when editor cannot be launched
	*/
	protected abstract String getEditorEmptyMessage();

	/**
	* Returns an error message to use when the selection does not contain a type that can be launched.
	*
	* @return error message when selection cannot be launched
	*/
	protected abstract String getSelectionEmptyMessage();

	/**
	* Resolves a type that can be launched from the given scope and launches in the
	* specified mode.
	*
	* @param scope the java elements to consider for a type that can be launched
	* @param mode launch mode
	* @param selectTitle prompting title for choosing a type to launch
	* @param emptyMessage error message when no types are resolved for launching
	*/
	private void searchAndLaunch(Object[] scope, String mode, String selectTitle, String emptyMessage) {
	IType[] types = null;
	try {
	types = findTypes(scope, PlatformUI.getWorkbench().getProgressService());
	}
	catch (InterruptedException e) {return;}
	catch (CoreException e) {
	MessageDialog.openError(getShell(), LauncherMessages.JavaLaunchShortcut_0, e.getMessage());
	return;
	}
	IType type = null;
	if (types.length == 0) {
	MessageDialog.openError(getShell(), LauncherMessages.JavaLaunchShortcut_1, emptyMessage);
	}
	else if (types.length > 1) {
	type = chooseType(types, selectTitle);
	}
	else {
	type = types[0];
	}
	if (type != null) {
	launch(type, mode);
	}
	}

	/**
	* Prompts the user to select a type from the given types.
	*
	* @param types the types to choose from
	* @param title the selection dialog title
	*
	* @return the selected type or <code>null</code> if none.
	*/
	protected IType chooseType(IType[] types, String title) {
	DebugTypeSelectionDialog mmsd = new DebugTypeSelectionDialog(JDIDebugUIPlugin.getShell(), types, title);
	if (mmsd.open() == Window.OK) {
	return (IType)mmsd.getResult()[0];
	}
	return null;
	}

	/**
	* Launches the given type in the specified mode.
	*
	* @param type type to launch
	* @param mode launch mode
	* @since 3.5
	*/
	protected void launch(IType type, String mode) {
	List<ILaunchConfiguration> configs = getCandidates(type, getConfigurationType());
	if(configs != null) {
	ILaunchConfiguration config = null;
	int count = configs.size();
	if(count == 1) {
	config = configs.get(0);
	}
	else if(count > 1) {
	config = chooseConfiguration(configs);
	if(config == null) {
	return;
	}
	}
	if (config == null) {
	config = createConfiguration(type);
	}
	if (config != null) {
	DebugUITools.launch(config, mode);
	}
	}
	}

	/**
	* Collect the listing of {@link ILaunchConfiguration}s that apply to the given {@link IType} and {@link ILaunchConfigurationType}
	*
	* @param type the type
	* @param ctype the {@link ILaunchConfigurationType}
	* @return the list of {@link ILaunchConfiguration}s or an empty list, never <code>null</code>
	* @since 3.8
	*/
	List<ILaunchConfiguration> getCandidates(IType type, ILaunchConfigurationType ctype) {
	List<ILaunchConfiguration> candidateConfigs = Collections.EMPTY_LIST;
	try {
	ILaunchConfiguration[] configs = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurations(ctype);
	candidateConfigs = new ArrayList<>(configs.length);
	for (int i = 0; i < configs.length; i++) {
	ILaunchConfiguration config = configs[i];
	if (config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, "").equals(type.getFullyQualifiedName())) { //$NON-NLS-1$
	if (config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, "").equals(type.getJavaProject().getElementName())) { //$NON-NLS-1$
	candidateConfigs.add(config);
	}
	}
	}
	} catch (CoreException e) {
	JDIDebugUIPlugin.log(e);
	}
	return candidateConfigs;
	}

	/**
	* Finds and returns an <b>existing</b> configuration to re-launch for the given type,
	* or <code>null</code> if there is no existing configuration.
	*
	* @param type the {@link IType} to try and find the {@link ILaunchConfiguration} for
	* @param configType the {@link ILaunchConfigurationType} to try and narrow down the search
	*
	* @return a configuration to use for launching the given type or <code>null</code> if none
	*/
	protected ILaunchConfiguration findLaunchConfiguration(IType type, ILaunchConfigurationType configType) {
	List<ILaunchConfiguration> configs = getCandidates(type, configType);
	int count = configs.size();
	if(count == 1) {
	return configs.get(0);
	}
	if(count > 1) {
	return chooseConfiguration(configs);
	}
	return null;
	}

	/**
	* Returns a configuration from the given collection of configurations that should be launched,
	* or <code>null</code> to cancel. Default implementation opens a selection dialog that allows
	* the user to choose one of the specified launch configurations. Returns the chosen configuration,
	* or <code>null</code> if the user cancels.
	*
	* @param configList list of configurations to choose from
	* @return configuration to launch or <code>null</code> to cancel
	*/
	protected ILaunchConfiguration chooseConfiguration(List<ILaunchConfiguration> configList) {
	IDebugModelPresentation labelProvider = DebugUITools.newDebugModelPresentation();
	ElementListSelectionDialog dialog= new ElementListSelectionDialog(getShell(), labelProvider);
	dialog.setElements(configList.toArray());
	dialog.setTitle(getTypeSelectionTitle());
	dialog.setMessage(LauncherMessages.JavaLaunchShortcut_2);
	dialog.setMultipleSelection(false);
	int result = dialog.open();
	labelProvider.dispose();
	if (result == Window.OK) {
	return (ILaunchConfiguration) dialog.getFirstResult();
	}
	return null;
	}

	/**
	* Convenience method to return the active workbench window shell.
	*
	* @return active workbench window shell
	*/
	protected Shell getShell() {
	return JDIDebugUIPlugin.getActiveWorkbenchShell();
	}

	/* (non-Javadoc)
	* @see org.eclipse.debug.ui.ILaunchShortcut#launch(org.eclipse.ui.IEditorPart, java.lang.String)
	*/
	@Override
	public void launch(IEditorPart editor, String mode) {
	IEditorInput input = editor.getEditorInput();
	IJavaElement je = input.getAdapter(IJavaElement.class);
	if (je != null) {
	searchAndLaunch(new Object[] {je}, mode, getTypeSelectionTitle(), getEditorEmptyMessage());
	}
	}

	/* (non-Javadoc)
	* @see org.eclipse.debug.ui.ILaunchShortcut#launch(org.eclipse.jface.viewers.ISelection, java.lang.String)
	*/
	@Override
	public void launch(ISelection selection, String mode) {
	if (selection instanceof IStructuredSelection) {
	searchAndLaunch(((IStructuredSelection)selection).toArray(), mode, getTypeSelectionTitle(), getSelectionEmptyMessage());
	}
	}

	/* (non-Javadoc)
	* @see org.eclipse.debug.ui.ILaunchShortcut2#getLaunchableResource(org.eclipse.ui.IEditorPart)
	*/
	@Override
	public IResource getLaunchableResource(IEditorPart editorpart) {
	return getLaunchableResource(editorpart.getEditorInput());
	}

	/* (non-Javadoc)
	* @see org.eclipse.debug.ui.ILaunchShortcut2#getLaunchableResource(org.eclipse.jface.viewers.ISelection)
	*/
	@Override
	public IResource getLaunchableResource(ISelection selection) {
	if (selection instanceof IStructuredSelection) {
	IStructuredSelection ss = (IStructuredSelection) selection;
	if (ss.size() == 1) {
	Object element = ss.getFirstElement();
	if (element instanceof IAdaptable) {
	return getLaunchableResource((IAdaptable)element);
	}
	}
	}
	return null;
	}

	/**
	* Returns the resource containing the Java element associated with the
	* given adaptable, or <code>null</code>.
	*
	* @param adaptable adaptable object
	* @return containing resource or <code>null</code>
	*/
	private IResource getLaunchableResource(IAdaptable adaptable) {
	IJavaElement je = adaptable.getAdapter(IJavaElement.class);
	if (je != null) {
	return je.getResource();
	}
	return null;
	}

	/* (non-Javadoc)
	* @see org.eclipse.debug.ui.ILaunchShortcut2#getLaunchConfigurations(org.eclipse.ui.IEditorPart)
	*/
	@Override
	public ILaunchConfiguration[] getLaunchConfigurations(IEditorPart editorpart) {
	// let the framework resolve configurations based on resource mapping
	return null;
	}

	/* (non-Javadoc)
	* @see org.eclipse.debug.ui.ILaunchShortcut2#getLaunchConfigurations(org.eclipse.jface.viewers.ISelection)
	*/
	@Override
	public ILaunchConfiguration[] getLaunchConfigurations(ISelection selection) {
	// let the framework resolve configurations based on resource mapping
	return null;
	}


	}