Java RunManagerImpl.addConfiguration方法代码示例

import com.intellij.execution.impl.RunManagerImpl; //导入方法依赖的package包/类
private void addConfigurations() {
  RunManagerImpl runManager = (RunManagerImpl) RunManagerEx.getInstanceEx(project);
  BlazeCommandRunConfigurationType.BlazeCommandRunConfigurationFactory configurationFactory =
      BlazeCommandRunConfigurationType.getInstance().getFactory();

  BlazeCommandRunConfiguration blazeAndroidBinaryConfiguration =
      configurationFactory.createTemplateConfiguration(project);
  blazeAndroidBinaryConfiguration.setName("AndroidBinaryConfiguration");
  blazeAndroidBinaryConfiguration.setTarget(Label.create("//label:android_binary_rule"));

  BlazeCommandRunConfiguration blazeAndroidTestConfiguration =
      configurationFactory.createTemplateConfiguration(project);
  blazeAndroidTestConfiguration.setName("AndroidTestConfiguration");
  blazeAndroidTestConfiguration.setTarget(Label.create("//label:android_test_rule"));

  runManager.addConfiguration(
      runManager.createConfiguration(blazeAndroidBinaryConfiguration, configurationFactory),
      true);
  runManager.addConfiguration(
      runManager.createConfiguration(blazeAndroidTestConfiguration, configurationFactory), true);
}
 

import com.intellij.execution.impl.RunManagerImpl; //导入方法依赖的package包/类
@Override
public void setupRootModel(ModifiableRootModel rootModel) throws ConfigurationException {
    setJavaRootModel(rootModel);

    Project project = rootModel.getProject();
    RunManagerImpl runManager = RunManagerImpl.getInstanceImpl(project);

    //Create "Run dub" configuration
    RunnerAndConfigurationSettings runDubSettings = runManager.findConfigurationByName(RUN_DUB_CONFIG_NAME);
    if(runDubSettings == null) {
        final DLangRunDubConfigurationType configurationType
                = Extensions.findExtension(ConfigurationType.CONFIGURATION_TYPE_EP, DLangRunDubConfigurationType.class);
        final ConfigurationFactory factory = configurationType.getConfigurationFactories()[0];
        runDubSettings = runManager.createRunConfiguration(RUN_DUB_CONFIG_NAME, factory);
        ((ModuleBasedConfiguration) runDubSettings.getConfiguration()).setModule(rootModel.getModule());

        runManager.addConfiguration(runDubSettings, false);
    }
}
 

import com.intellij.execution.impl.RunManagerImpl; //导入方法依赖的package包/类
private void createNewConfiguration(Project project) {
  final RunManagerImpl manager = RunManagerImpl.getInstanceImpl(project);

  final ConfigurationFactory factory =
      configType != null ? configType.getConfigurationFactories()[0] : null;

  EditConfigurationsDialog dialog = new EditConfigurationsDialog(project, factory);

  if (dialog.showAndGet()) {
    RunnerAndConfigurationSettings settings = manager.getSelectedConfiguration();

    if (settings != null) {
      manager.addConfiguration(settings, false /*isShared*/);
    }
  }
}
 

import com.intellij.execution.impl.RunManagerImpl; //导入方法依赖的package包/类
protected void assertAndRunPantsMake(JUnitConfiguration runConfiguration) {

    RunManager runManager = RunManager.getInstance(myProject);
    assertTrue(runManager instanceof RunManagerImpl);
    RunManagerImpl runManagerImpl = (RunManagerImpl) runManager;

    RunnerAndConfigurationSettings runnerAndConfigurationSettings =
      runManagerImpl.createConfiguration(runConfiguration, JUnitConfigurationType.getInstance().getConfigurationFactories()[0]);
    runManagerImpl.addConfiguration(runnerAndConfigurationSettings, false);

    // Make sure PantsMake is the one and only task before JUnit run.
    List<BeforeRunTask<?>> beforeRunTaskList = runManagerImpl.getBeforeRunTasks(runConfiguration);
    assertEquals(1, beforeRunTaskList.size());
    BeforeRunTask task = beforeRunTaskList.iterator().next();
    assertEquals(PantsMakeBeforeRun.ID, task.getProviderId());

    /*
     * Manually invoke BeforeRunTask as {@link ExecutionManager#compileAndRun} launches another task asynchronously,
     * and there is no way to catch that.
     */
    BeforeRunTaskProvider provider = BeforeRunTaskProvider.getProvider(myProject, task.getProviderId());
    assertNotNull(String.format("Cannot find BeforeRunTaskProvider for id='%s'", task.getProviderId()), provider);
    assertTrue(provider.executeTask(null, runConfiguration, null, task));
  }
 

import com.intellij.execution.impl.RunManagerImpl; //导入方法依赖的package包/类
@Override
public void perform(final ConfigurationContext context) {
  final RunManagerImpl runManager = (RunManagerImpl)context.getRunManager();
  final RunnerAndConfigurationSettings configuration = context.getConfiguration();
  final RunnerAndConfigurationSettings template = runManager.getConfigurationTemplate(configuration.getFactory());
  final RunConfiguration templateConfiguration = template.getConfiguration();
  runManager.addConfiguration(configuration,
                              runManager.isConfigurationShared(template),
                              runManager.getBeforeRunTasks(templateConfiguration),
                              false);
  runManager.setSelectedConfiguration(configuration);
}
 

import com.intellij.execution.impl.RunManagerImpl; //导入方法依赖的package包/类
@Override
public void actionPerformed(AnActionEvent e) {
  final AntBuildFile buildFile = getCurrentBuildFile();
  if (buildFile == null || !buildFile.exists()) {
    return;
  }

  TreePath selectionPath = myTree.getSelectionPath();
  if (selectionPath == null) return;
  final DefaultMutableTreeNode node = (DefaultMutableTreeNode) selectionPath.getLastPathComponent();
  final Object userObject = node.getUserObject();
  AntBuildTarget target = null;
  if (userObject instanceof AntTargetNodeDescriptor) {
    AntTargetNodeDescriptor targetNodeDescriptor = (AntTargetNodeDescriptor)userObject;
    target = targetNodeDescriptor.getTarget();
  }
  else if (userObject instanceof AntBuildFileNodeDescriptor){
    AntBuildModel model = ((AntBuildFileNodeDescriptor)userObject).getBuildFile().getModel();
    target = model.findTarget(model.getDefaultTargetName());
  }
  String name = target != null ? target.getDisplayName() : null;
  if (target == null || name == null) {
    return;
  }

  RunManagerImpl runManager = (RunManagerImpl)RunManager.getInstance(e.getProject());
  RunnerAndConfigurationSettings settings =
    runManager.createRunConfiguration(name, AntRunConfigurationType.getInstance().getFactory());
  AntRunConfiguration configuration  = (AntRunConfiguration)settings.getConfiguration();
  configuration.acceptSettings(target);
  if (RunDialog.editConfiguration(e.getProject(), settings, ExecutionBundle
    .message("create.run.configuration.for.item.dialog.title", configuration.getName()))) {
    runManager.addConfiguration(settings,
                                runManager.isConfigurationShared(settings),
                                runManager.getBeforeRunTasks(settings.getConfiguration()), false);
    runManager.setSelectedConfiguration(settings);
  }
}
 

import com.intellij.execution.impl.RunManagerImpl; //导入方法依赖的package包/类
private List<BeforeRunTask<?>> getBeforeRunTask(RunConfiguration configuration) {
  RunManagerImpl runManager = (RunManagerImpl) RunManager.getInstance(myProject);
  RunnerAndConfigurationSettingsImpl configurationSettings = new RunnerAndConfigurationSettingsImpl(runManager, configuration, true);
  runManager.addConfiguration(configurationSettings, true);
  List<BeforeRunTask<?>> tasks = runManager.getBeforeRunTasks(configuration);
  runManager.removeConfiguration(configurationSettings);
  return tasks;
}
 

import com.intellij.execution.impl.RunManagerImpl; //导入方法依赖的package包/类
@Override
public void perform(final ConfigurationContext context) {
  final RunManagerImpl runManager = (RunManagerImpl)context.getRunManager();
  final RunnerAndConfigurationSettings configuration = context.getConfiguration();
  final RunnerAndConfigurationSettings template = runManager.getConfigurationTemplate(configuration.getFactory());
  final RunConfiguration templateConfiguration = template.getConfiguration();
  runManager.addConfiguration(configuration,
                              runManager.isConfigurationShared(template),
                              runManager.getBeforeRunTasks(templateConfiguration),
                              false);
  runManager.setActiveConfiguration(configuration);
}