Java RunManagerEx.setSelectedConfiguration方法代码示例

import com.intellij.execution.RunManagerEx; //导入方法依赖的package包/类
public void testReusingConfiguration() {
  RunManagerEx runManager = RunManagerEx.getInstanceEx(myProject);
  PsiClass psiClass = findClass(getModule1(), CLASS_NAME);
  PsiPackage psiPackage = JUnitUtil.getContainingPackage(psiClass);

  ConfigurationContext context = createContext(psiClass);
  assertEquals(null, context.findExisting());
  RunnerAndConfigurationSettings testClass = context.getConfiguration();
  runManager.addConfiguration(testClass,  false);
  context = createContext(psiClass);
  assertSame(testClass, context.findExisting());

  runManager.setSelectedConfiguration(testClass);
  context = createContext(psiPackage);
  assertEquals(null, context.findExisting());
  RunnerAndConfigurationSettings testPackage = context.getConfiguration();
  runManager.addConfiguration(testPackage,  false);
  context = createContext(psiPackage);
  assertSame(testPackage, context.findExisting());
  assertSame(testClass, runManager.getSelectedConfiguration());
  runManager.setSelectedConfiguration(context.findExisting());
  assertSame(testPackage, runManager.getSelectedConfiguration());
}
 

import com.intellij.execution.RunManagerEx; //导入方法依赖的package包/类
@Override
public void createAndRunConfiguration(@NotNull ServerType<?> serverType, @Nullable RemoteServer<?> remoteServer) {
  DeployToServerConfigurationType configurationType = DeployToServerConfigurationTypesRegistrar.getDeployConfigurationType(serverType);
  RunManagerEx runManager = RunManagerEx.getInstanceEx(myProject);
  ConfigurationFactoryEx factory = configurationType.getFactory();
  RunnerAndConfigurationSettings settings = runManager.createRunConfiguration(configurationType.getDisplayName(), factory);
  factory.onNewConfigurationCreated(settings.getConfiguration());
  DeployToServerRunConfiguration<?, ?> runConfiguration = (DeployToServerRunConfiguration<?, ?>)settings.getConfiguration();
  if (remoteServer != null) {
    runConfiguration.setServerName(remoteServer.getName());
  }
  if (RunDialog.editConfiguration(myProject, settings, "Create Deployment Configuration",
                                  DefaultRunExecutor.getRunExecutorInstance())) {
    runManager.addConfiguration(settings, runManager.isConfigurationShared(settings), runManager.getBeforeRunTasks(runConfiguration),
                                false);
    runManager.setSelectedConfiguration(settings);
    ProgramRunnerUtil.executeConfiguration(myProject, settings, DefaultRunExecutor.getRunExecutorInstance());
  }
}
 

import com.intellij.execution.RunManagerEx; //导入方法依赖的package包/类
@Override
protected void perform(@NotNull Project project,
                       @NotNull ProjectSystemId projectSystemId,
                       @NotNull TaskData taskData,
                       @NotNull AnActionEvent e) {
  final ExternalTaskExecutionInfo taskExecutionInfo = ExternalSystemActionUtil.buildTaskInfo(taskData);
  ExternalSystemUtil.runTask(taskExecutionInfo.getSettings(), taskExecutionInfo.getExecutorId(), project, projectSystemId);

  final DataContext dataContext = e.getDataContext();
  final ConfigurationContext context = ConfigurationContext.getFromContext(dataContext);
  RunnerAndConfigurationSettings configuration = context.findExisting();
  RunManagerEx runManager = (RunManagerEx)context.getRunManager();
  if (configuration == null) {
    configuration = context.getConfiguration();
    if (configuration == null) {
      return;
    }
    runManager.setTemporaryConfiguration(configuration);
  }
  runManager.setSelectedConfiguration(configuration);
}
 

import com.intellij.execution.RunManagerEx; //导入方法依赖的package包/类
@Override
public void handleDoubleClickOrEnter(SimpleTree tree, InputEvent inputEvent) {
  final Project project = getExternalProjectsView().getProject();
  ProgramRunnerUtil.executeConfiguration(project, mySettings, DefaultRunExecutor.getRunExecutorInstance());
  final RunManagerEx runManagerEx = RunManagerEx.getInstanceEx(project);
  runManagerEx.setSelectedConfiguration(mySettings);
}
 

import com.intellij.execution.RunManagerEx; //导入方法依赖的package包/类
@Override
public void actionPerformed(AnActionEvent e) {
    final DataContext dataContext = e.getDataContext();
    final ConfigurationContext context = ConfigurationContext.getFromContext(dataContext);
    if (context.getLocation() == null) return;
    final RunManagerEx runManager = (RunManagerEx) context.getRunManager();
    RunnerAndConfigurationSettings setting = context.getConfiguration();
    if (setting == null || setting.getConfiguration() == null || !(setting.getConfiguration() instanceof PTestRunConfiguration)) {
        ConfigurationFromContext config = CONFIG_PRODUCER.createConfigurationFromContext(context);
        if (config == null) return;
        setting = config.getConfigurationSettings();
        runManager.setTemporaryConfiguration(setting);
    } else {
        boolean hasExistingSetting = false;
        for (RunnerAndConfigurationSettings existingSetting : runManager.getConfigurationSettingsList(new PTestConfigurationType())) {
            if (existingSetting.equals(setting)) {
                hasExistingSetting = true;
                break;
            }
        }
        if (!hasExistingSetting) {
            runManager.setTemporaryConfiguration(setting);
        }
    }
    runManager.setSelectedConfiguration(setting);

    ExecutionUtil.runConfiguration(setting, myExecutor);
}
 

import com.intellij.execution.RunManagerEx; //导入方法依赖的package包/类
private static void selectSomeTaskConfiguration(RunManagerEx runManager) {
	for (RunnerAndConfigurationSettings settings : runManager.getAllSettings()) {
		if (settings.getConfiguration() instanceof TaskConfiguration) {
			runManager.setSelectedConfiguration(settings);
			return;
		}
	}
}
 

import com.intellij.execution.RunManagerEx; //导入方法依赖的package包/类
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
  final Project project = e.getRequiredData(CommonDataKeys.PROJECT);
  ExecuteGradleTaskHistoryService historyService = ExecuteGradleTaskHistoryService.getInstance(project);
  GradleRunTaskDialog dialog = new GradleRunTaskDialog(project, historyService.getHistory());
  String lastWorkingDirectory = historyService.getWorkDirectory();
  if (lastWorkingDirectory.length() == 0) {
    lastWorkingDirectory = obtainAppropriateWorkingDirectory(e);
  }

  dialog.setWorkDirectory(lastWorkingDirectory);

  if (StringUtil.isEmptyOrSpaces(historyService.getCanceledCommand())) {
    if (historyService.getHistory().size() > 0) {
      dialog.setCommandLine(historyService.getHistory().get(0));
    }
  }
  else {
    dialog.setCommandLine(historyService.getCanceledCommand());
  }

  if (!dialog.showAndGet()) {
    historyService.setCanceledCommand(dialog.getCommandLine());
    return;
  }

  historyService.setCanceledCommand(null);

  String fullCommandLine = dialog.getCommandLine();
  fullCommandLine = fullCommandLine.trim();

  String workDirectory = dialog.getWorkDirectory();

  historyService.addCommand(fullCommandLine, workDirectory);

  final ExternalTaskExecutionInfo taskExecutionInfo;
  try {
    taskExecutionInfo = buildTaskInfo(workDirectory, fullCommandLine);
  }
  catch (CommandLineArgumentException ex) {
    final NotificationData notificationData = new NotificationData(
      "<b>Command-line arguments cannot be parsed</b>",
      "<i>" + fullCommandLine + "</i> \n" + ex.getMessage(),
      NotificationCategory.WARNING, NotificationSource.TASK_EXECUTION
    );
    notificationData.setBalloonNotification(true);
    ExternalSystemNotificationManager.getInstance(project).showNotification(GradleConstants.SYSTEM_ID, notificationData);
    return;
  }
  RunManagerEx runManager = RunManagerEx.getInstanceEx(project);

  ExternalSystemUtil.runTask(taskExecutionInfo.getSettings(), taskExecutionInfo.getExecutorId(), project, GradleConstants.SYSTEM_ID);

  RunnerAndConfigurationSettings configuration =
    ExternalSystemUtil.createExternalSystemRunnerAndConfigurationSettings(taskExecutionInfo.getSettings(),
                                                                          project, GradleConstants.SYSTEM_ID);
  if (configuration == null) return;

  final RunnerAndConfigurationSettings existingConfiguration = runManager.findConfigurationByName(configuration.getName());
  if(existingConfiguration == null) {
    runManager.setTemporaryConfiguration(configuration);
  } else {
    runManager.setSelectedConfiguration(existingConfiguration);
  }
}
 

import com.intellij.execution.RunManagerEx; //导入方法依赖的package包/类
public static <SC extends ServerConfiguration, DC extends DeploymentConfiguration>
DeployToServerRunConfiguration<SC, DC> createRunConfiguration(RemoteServer<SC> account,
                                                              Module module,
                                                              DeploymentSource deploymentSource,
                                                              DC deploymentConfiguration) {
  Project project = module.getProject();

  String accountName = account.getName();

  String name = generateRunConfigurationName(accountName, module.getName());

  final RunManagerEx runManager = RunManagerEx.getInstanceEx(project);
  ConfigurationFactory configurationFactory = getRunConfigurationType(account.getType()).getConfigurationFactories()[0];
  final RunnerAndConfigurationSettings runSettings = runManager.createRunConfiguration(name, configurationFactory);

  final DeployToServerRunConfiguration<SC, DC> result = (DeployToServerRunConfiguration<SC, DC>)runSettings.getConfiguration();

  result.setServerName(accountName);

  result.setDeploymentSource(deploymentSource);

  result.setDeploymentConfiguration(deploymentConfiguration);

  ((ConfigurationFactoryEx)configurationFactory).onNewConfigurationCreated(runSettings.getConfiguration());

  runManager.addConfiguration(runSettings, false);
  runManager.setSelectedConfiguration(runSettings);

  return result;
}