import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
protected void createLaunchConfig(IProject project) throws CoreException {
  // If the default SDK is GWT 2.7 or greater, turn on GWT super dev mode by default.
  boolean turnOnGwtSuperDevMode = GwtVersionUtil.isGwtVersionGreaterOrEqualTo27(JavaCore.create(project));

  ILaunchConfigurationWorkingCopy wc = WebAppLaunchUtil.createLaunchConfigWorkingCopy(project.getName(), project,
      WebAppLaunchUtil.determineStartupURL(project, false), false, turnOnGwtSuperDevMode);
  ILaunchGroup[] groups = DebugUITools.getLaunchGroups();

  ArrayList<String> groupsNames = new ArrayList<String>();
  for (ILaunchGroup group : groups) {
    if (IDebugUIConstants.ID_DEBUG_LAUNCH_GROUP.equals(group.getIdentifier())
        || IDebugUIConstants.ID_RUN_LAUNCH_GROUP.equals(group.getIdentifier())) {
      groupsNames.add(group.getIdentifier());
    }
  }

  wc.setAttribute(IDebugUIConstants.ATTR_FAVORITE_GROUPS, groupsNames);
  wc.doSave();
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
/**
 * Launch a resource. Try to launch using a launch configuration. Used for contextual launches
 * 
 * @param file
 *            source file
 * @param firstInstruction
 *            the first {@link EObject instruction}
 * @param mode
 *            launch mode
 */
public void launch(final IResource file, EObject firstInstruction, final String mode) {

	if (file instanceof IFile) {
		prepareLaunch(file, firstInstruction, mode);

		try {
			ILaunchConfiguration[] configurations = getLaunchConfigurations(file);
			if (configurations.length == 0) {
				// try to create a launch configuration
				configurations = createLaunchConfiguration(file, firstInstruction, mode);
			}

			// launch
			if (configurations.length == 1) {
				configurations[0].launch(mode, new NullProgressMonitor());
			} else {
				// more than one configuration applies
				// open launch dialog for selection
				final ILaunchGroup group = DebugUITools.getLaunchGroup(configurations[0], mode);
				DebugUITools.openLaunchConfigurationDialogOnGroup(PlatformUI.getWorkbench()
						.getActiveWorkbenchWindow().getShell(),
						new StructuredSelection(configurations[0]), group.getIdentifier(), null);
			}

		} catch (CoreException e) {
			// could not create launch configuration, run file directly
			// try {
			// launch(firstInstruction, null, mode, null, new NullProgressMonitor());
			// } catch (CoreException e1) {
			Activator.getDefault().error(e);
			// }
		}
	}
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
/**
 * Creates a {@link ILaunchConfiguration}. If the <code>firstInstruction</code> is <code>null</code> the
 * launch configuration dialog is opened.
 * 
 * @param file
 *            the selected model {@link IFile}
 * @param firstInstruction
 *            the first {@link EObject instruction} or <code>null</code> for interactive selection
 * @param mode
 *            the {@link ILaunchConfiguration#getModes() mode}
 * @return an array of possible {@link ILaunchConfiguration}, can be empty but not <code>null</code>
 * @throws CoreException
 *             if {@link ILaunchConfiguration} initialization fails of models can't be loaded
 */
protected ILaunchConfiguration[] createLaunchConfiguration(final IResource file,
		EObject firstInstruction, final String mode) throws CoreException {
	final ILaunchConfiguration[] res;

	ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
	ILaunchConfigurationType type = manager.getLaunchConfigurationType(getLaunchConfigurationTypeID());

	ILaunchConfigurationWorkingCopy configuration = type.newInstance(null, file.getName());
	configuration.setMappedResources(new IResource[] {file, });
	configuration.setAttribute(AbstractDSLLaunchConfigurationDelegate.RESOURCE_URI, file.getFullPath()
			.toString());
	if (firstInstruction == null) {
		// open configuration for further editing
		final ILaunchGroup group = DebugUITools.getLaunchGroup(configuration, mode);
		if (group != null) {
			configuration.doSave();
			DebugUITools.openLaunchConfigurationDialog(PlatformUI.getWorkbench()
					.getActiveWorkbenchWindow().getShell(), configuration, group.getIdentifier(), null);
		}
		res = new ILaunchConfiguration[] {};
	} else {
		configuration.setAttribute(AbstractDSLLaunchConfigurationDelegate.FIRST_INSTRUCTION_URI,
				EcoreUtil.getURI(firstInstruction).toString());
		// save and return new configuration
		configuration.doSave();
		res = new ILaunchConfiguration[] {configuration, };
	}
	return res;
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
@Override
protected final ILaunchConfiguration[] createLaunchConfiguration(IResource file, EObject firstInstruction, String mode)
		throws CoreException {
	ILaunchConfiguration[] launchConfigs = super.createLaunchConfiguration(file, firstInstruction, mode);

	if (launchConfigs.length == 1) {
		// open configuration for further editing
		if (launchConfigs[0] instanceof ILaunchConfigurationWorkingCopy) {
			ILaunchConfigurationWorkingCopy configuration = (ILaunchConfigurationWorkingCopy) launchConfigs[0];

			String selectedLanguage = configuration.getAttribute(RunConfiguration.LAUNCH_SELECTED_LANGUAGE, "");
			if (selectedLanguage.equals("")) {

				// TODO try to infer possible language and other attribute
				// from project content and environment
				setDefaultsLaunchConfiguration(configuration);

				final ILaunchGroup group = DebugUITools.getLaunchGroup(configuration, mode);
				if (group != null) {
					ILaunchConfiguration savedLaunchConfig = configuration.doSave();
					// open configuration for user validation and inputs
					DebugUITools.openLaunchConfigurationDialogOnGroup(PlatformUI.getWorkbench()
							.getActiveWorkbenchWindow().getShell(), new StructuredSelection(savedLaunchConfig),
							group.getIdentifier(), null);
					// DebugUITools.openLaunchConfigurationDialog(PlatformUI.getWorkbench()
					// .getActiveWorkbenchWindow().getShell(),
					// savedLaunchConfig, group.getIdentifier(), null);
				}
			}
		}
	}
	return launchConfigs;

}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
@Override
public synchronized boolean remove( Object element ) {
  boolean removed = false;
  if( contains( element ) ) {
    for( ILaunchGroup launchGroup : DebugUITools.getLaunchGroups() ) {
      LaunchHistory launchHistory = getLaunchHistory( launchGroup );
      if( launchHistory != null ) {
        launchHistory.removeFromHistory( ( ILaunchConfiguration )element );
      }
    }
    removed = true;
    launchConfigHistory = null;
  }
  return removed;
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
private static LaunchHistory getLaunchHistory( ILaunchGroup launchGroup ) {
  LaunchHistoryAction launchHistoryAction = new LaunchHistoryAction( launchGroup );
  try {
    return launchHistoryAction.getLaunchHistory();
  } finally {
    launchHistoryAction.dispose();
  }
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
private void collect( ILaunchGroup launchGroup ) {
  LaunchHistoryAction launchHistoryAction = new LaunchHistoryAction( launchGroup );
  try {
    if( launchHistoryAction.getLastLaunch() != null ) {
      addAll( launchConfigHistory, launchHistoryAction.getFavorites() );
      addAll( launchConfigHistory, launchHistoryAction.getHistory() );
    }
  } finally {
    launchHistoryAction.dispose();
  }
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
public ILaunchGroup computeLaunchGroup() {
  ILaunchGroup result = null;
  ILaunchMode launchMode = computeLaunchMode();
  if( launchMode != null ) {
    result = DebugUITools.getLaunchGroup( launchConfig, launchMode.getIdentifier() );
  }
  return result;
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
private ILaunchConfiguration getLastLaunchConfig( ILaunchConfiguration launchConfig ) {
  ILaunchConfiguration result = null;
  if( launchMode != null ) {
    ILaunchGroup launchGroup = DebugUITools.getLaunchGroup( launchConfig, launchMode.getIdentifier() );
    if( launchGroup != null ) {
      result = DebugUITools.getLastLaunch( launchGroup.getIdentifier() );
    }
  }
  return result;
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
@Test
public void testComputeLaunchGroupWithSupportedMode() {
  ILaunchMode supportedMode = getSupportedMode();

  ILaunchGroup launchMode = computeLaunchGroup( supportedMode );

  assertThat( launchMode.getMode() ).isEqualTo( supportedMode.getIdentifier() );
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
@Test
public void testComputeLaunchGroupWithUnsupportedMode() {
  ILaunchMode unsupportedMode = getUnsupportedMode();

  ILaunchGroup launchMode = computeLaunchGroup( unsupportedMode );

  assertThat( launchMode.getMode() ).isEqualTo( getSupportedMode().getIdentifier() );
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
@Test
public void testComputeLaunchGroupWithDeletedLaunchConfig() throws CoreException {
  ILaunchMode supportedMode = getSupportedMode();
  ILaunchConfiguration deletedLaunchConfig = launchConfig.doSave();
  deletedLaunchConfig.delete();

  ILaunchGroup launchGroup = new LaunchModeComputer( deletedLaunchConfig, supportedMode ).computeLaunchGroup();

  assertThat( launchGroup ).isNull();
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
/**
    * Re-open config window with the specified launch config
    * @param configuration
    * @param mode
    */
   @VisibleForTesting
public void reopenLaunchConfig(final ILaunchConfiguration configuration, final String mode) {
	if (Utils.isNotEmpty(configuration) && Utils.isNotEmpty(mode)) {
		Display display = getDisplay();
		display.asyncExec(new Runnable() {
			@Override
			public void run() {
				IWorkbenchWindow aww = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
				ILaunchGroup launchGroup = DebugUITools.getLaunchGroup(configuration, mode);
				DebugUITools.openLaunchConfigurationDialog(aww.getShell(), configuration, launchGroup.getIdentifier(), null);
			}
		});
	}
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
private String getLaunchGroupId( ILaunchConfiguration launchConfig ) {
  ILaunchMode preferredLaunchMode = launchSelectionDialog.getLaunchMode();
  LaunchModeComputer launchModeComputer = new LaunchModeComputer( launchConfig, preferredLaunchMode );
  ILaunchGroup launchGroup = launchModeComputer.computeLaunchGroup();
  return launchGroup == null ? null : launchGroup.getIdentifier();
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
LaunchHistoryAction( ILaunchGroup launchGroup ) {
  super( launchGroup.getIdentifier() );
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
@Test
public void testComputeLaunchGroupWithNullLaunchMode() {
  ILaunchGroup launchGroup = computeLaunchGroup( null );

  assertThat( launchGroup.getMode() ).isEqualTo( getSupportedMode().getIdentifier() );
}
 

import org.eclipse.debug.ui.ILaunchGroup; //导入依赖的package包/类
private ILaunchGroup computeLaunchGroup( ILaunchMode preferredLaunchMode ) {
  return new LaunchModeComputer( launchConfig, preferredLaunchMode ).computeLaunchGroup();
}