path: root/platform/lang-impl/src/com/intellij/execution/impl/RunConfigurationBeforeRunProvider.java

/*
 * Copyright 2000-2012 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.intellij.execution.impl;

import com.intellij.execution.*;
import com.intellij.execution.configurations.ConfigurationType;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.execution.executors.DefaultRunExecutor;
import com.intellij.execution.process.ProcessAdapter;
import com.intellij.execution.process.ProcessEvent;
import com.intellij.execution.process.ProcessHandler;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.execution.runners.ProgramRunner;
import com.intellij.icons.AllIcons;
import com.intellij.openapi.Disposable;
import com.intellij.openapi.actionSystem.DataContext;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.application.ModalityState;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.ui.DialogWrapper;
import com.intellij.openapi.util.Disposer;
import com.intellij.openapi.util.Key;
import com.intellij.openapi.util.Ref;
import com.intellij.ui.ColoredListCellRenderer;
import com.intellij.ui.SimpleTextAttributes;
import com.intellij.ui.components.JBList;
import com.intellij.ui.components.JBScrollPane;
import com.intellij.util.concurrency.Semaphore;
import org.jdom.Attribute;
import org.jdom.Element;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import javax.swing.*;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.*;
import java.util.List;

/**
 * @author Vassiliy Kudryashov
 */
public class RunConfigurationBeforeRunProvider
extends BeforeRunTaskProvider<RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask> {

  public static final Key<RunConfigurableBeforeRunTask> ID = Key.create("RunConfigurationTask");

  private static final Logger LOG = Logger.getInstance("#com.intellij.execution.impl.RunConfigurationBeforeRunProvider");

  private final Project myProject;

  public RunConfigurationBeforeRunProvider(Project project) {
    myProject = project;
  }

  @Override
  public Key<RunConfigurableBeforeRunTask> getId() {
    return ID;
  }

  @Override
  public Icon getIcon() {
    return AllIcons.Actions.Execute;
  }

  @Override
  public Icon getTaskIcon(RunConfigurableBeforeRunTask task) {
    if (task.getSettings() == null)
      return null;
    return ProgramRunnerUtil.getConfigurationIcon(task.getSettings(), false);
  }

  @Override
  public String getName() {
    return ExecutionBundle.message("before.launch.run.another.configuration");
  }

  @Override
  public String getDescription(RunConfigurableBeforeRunTask task) {
    if (task.getSettings() == null) {
      return ExecutionBundle.message("before.launch.run.another.configuration");
    }
    else {
      return ExecutionBundle.message("before.launch.run.certain.configuration", task.getSettings().getName());
    }
  }

  @Override
  public boolean isConfigurable() {
    return true;
  }

  @Override
  @Nullable
  public RunConfigurableBeforeRunTask createTask(RunConfiguration runConfiguration) {
    if (runConfiguration.getProject().isInitialized()) {
      Collection<RunnerAndConfigurationSettings> configurations =
        RunManagerImpl.getInstanceImpl(runConfiguration.getProject()).getSortedConfigurations();
      if (configurations.isEmpty()
          || (configurations.size() == 1 && configurations.iterator().next().getConfiguration() == runConfiguration)) {
        return null;
      }
    }
    return new RunConfigurableBeforeRunTask();
  }

  @Override
  public boolean configureTask(RunConfiguration runConfiguration, RunConfigurableBeforeRunTask task) {
    SelectionDialog dialog =
      new SelectionDialog(task.getSettings(), getAvailableConfigurations(runConfiguration));
    dialog.show();
    RunnerAndConfigurationSettings settings = dialog.getSelectedSettings();
    if (settings != null) {
      task.setSettings(settings);
      return true;
    }
    else {
      return false;
    }
  }

  @NotNull
  private List<RunnerAndConfigurationSettings> getAvailableConfigurations(RunConfiguration runConfiguration) {
    Project project = runConfiguration.getProject();
    if (project == null || !project.isInitialized())
      return Collections.emptyList();
    final RunManagerImpl runManager = RunManagerImpl.getInstanceImpl(project);

    final ArrayList<RunnerAndConfigurationSettings> configurations
      = new ArrayList<RunnerAndConfigurationSettings>(runManager.getSortedConfigurations());
    String executorId = DefaultRunExecutor.getRunExecutorInstance().getId();
    for (Iterator<RunnerAndConfigurationSettings> iterator = configurations.iterator(); iterator.hasNext();) {
      RunnerAndConfigurationSettings settings = iterator.next();
      final ProgramRunner runner = ProgramRunnerUtil.getRunner(executorId, settings);
      if (runner == null || settings.getConfiguration() == runConfiguration)
        iterator.remove();
    }
    return configurations;
  }

  @Override
  public boolean canExecuteTask(RunConfiguration configuration,
                                RunConfigurableBeforeRunTask task) {
    RunnerAndConfigurationSettings settings = task.getSettings();
    if (settings == null) {
      return false;
    }
    String executorId = DefaultRunExecutor.getRunExecutorInstance().getId();
    final ProgramRunner runner = ProgramRunnerUtil.getRunner(executorId, settings);
    if (runner == null)
      return false;
    return runner.canRun(executorId, settings.getConfiguration());
  }

  @Override
  public boolean executeTask(final DataContext dataContext,
                             RunConfiguration configuration,
                             final ExecutionEnvironment env,
                             RunConfigurableBeforeRunTask task) {
    RunnerAndConfigurationSettings settings = task.getSettings();
    if (settings == null) {
      return false;
    }
    final Executor executor = DefaultRunExecutor.getRunExecutorInstance();
    final String executorId = executor.getId();
    final ProgramRunner runner = ProgramRunnerUtil.getRunner(executorId, settings);
    if (runner == null)
      return false;
    final ExecutionEnvironment environment = new ExecutionEnvironment(executor, runner, settings, myProject);
    environment.setExecutionId(env.getExecutionId());
    if (!ExecutionTargetManager.canRun(settings, env.getExecutionTarget())) {
      return false;
    }

    if (!runner.canRun(executorId, environment.getRunProfile())) {
      return false;
    }
    else {
      final Semaphore targetDone = new Semaphore();
      final Ref<Boolean> result = new Ref<Boolean>(false);
      final Disposable disposable = Disposer.newDisposable();

      myProject.getMessageBus().connect(disposable).subscribe(ExecutionManager.EXECUTION_TOPIC, new ExecutionAdapter() {
        public void processStartScheduled(final String executorIdLocal, final ExecutionEnvironment environmentLocal) {
          if (executorId.equals(executorIdLocal) && environment.equals(environmentLocal)) {
            targetDone.down();
          }
        }

        public void processNotStarted(final String executorIdLocal, @NotNull final ExecutionEnvironment environmentLocal) {
          if (executorId.equals(executorIdLocal) && environment.equals(environmentLocal)) {
            targetDone.up();
          }
        }

        public void processStarted(final String executorIdLocal,
                                   @NotNull final ExecutionEnvironment environmentLocal,
                                   @NotNull final ProcessHandler handler) {
          if (executorId.equals(executorIdLocal) && environment.equals(environmentLocal)) {
            handler.addProcessListener(new ProcessAdapter() {
              public void processTerminated(ProcessEvent event) {
                result.set(event.getExitCode() == 0);
                targetDone.up();
              }
            });
          }
        }
      });

      try {
        ApplicationManager.getApplication().invokeAndWait(new Runnable() {
          @Override
          public void run() {
            try {
              runner.execute(environment);
            }
            catch (ExecutionException e) {
              targetDone.up();
              LOG.error(e);
            }
          }
        }, ModalityState.NON_MODAL);
      }
      catch (Exception e) {
        LOG.error(e);
        Disposer.dispose(disposable);
        return false;
      }

      targetDone.waitFor();
      Disposer.dispose(disposable);

      return result.get();
    }
  }

  class RunConfigurableBeforeRunTask extends BeforeRunTask<RunConfigurableBeforeRunTask> {
    private String myConfigurationName;
    private String myConfigurationType;
    private boolean myInitialized = false;

    private RunnerAndConfigurationSettings mySettings;

    RunConfigurableBeforeRunTask() {
      super(ID);
    }

    @Override
    public void writeExternal(Element element) {
      super.writeExternal(element);
      if (myConfigurationName != null && myConfigurationType != null) {
        element.setAttribute("run_configuration_name", myConfigurationName);
        element.setAttribute("run_configuration_type", myConfigurationType);
      }
      else if (mySettings != null) {
        element.setAttribute("run_configuration_name", mySettings.getName());
        element.setAttribute("run_configuration_type", mySettings.getType().getId());
      }
    }

    @Override
    public void readExternal(Element element) {
      super.readExternal(element);
      Attribute configurationNameAttr = element.getAttribute("run_configuration_name");
      Attribute configurationTypeAttr = element.getAttribute("run_configuration_type");
      myConfigurationName = configurationNameAttr != null ? configurationNameAttr.getValue() : null;
      myConfigurationType = configurationTypeAttr != null ? configurationTypeAttr.getValue() : null;
    }

    void init() {
      if (myInitialized) {
        return;
      }
      if (myConfigurationName != null && myConfigurationType != null) {
        Collection<RunnerAndConfigurationSettings> configurations = RunManagerImpl.getInstanceImpl(myProject).getSortedConfigurations();
        for (RunnerAndConfigurationSettings runConfiguration : configurations) {
          ConfigurationType type = runConfiguration.getType();
          if (myConfigurationName.equals(runConfiguration.getName())
              && type != null
              && myConfigurationType.equals(type.getId())) {
            setSettings(runConfiguration);
            return;
          }
        }
      }
    }

    void setSettings(RunnerAndConfigurationSettings settings) {
      mySettings = settings;
      myInitialized = true;
    }

    RunnerAndConfigurationSettings getSettings() {
      init();
      return mySettings;
    }

    @Override
    public boolean equals(Object o) {
      if (this == o) return true;
      if (o == null || getClass() != o.getClass()) return false;
      if (!super.equals(o)) return false;

      RunConfigurableBeforeRunTask that = (RunConfigurableBeforeRunTask)o;

      if (myConfigurationName != null ? !myConfigurationName.equals(that.myConfigurationName) : that.myConfigurationName != null) return false;
      if (myConfigurationType != null ? !myConfigurationType.equals(that.myConfigurationType) : that.myConfigurationType != null) return false;

      return true;
    }

    @Override
    public int hashCode() {
      int result = super.hashCode();
      result = 31 * result + (myConfigurationName != null ? myConfigurationName.hashCode() : 0);
      result = 31 * result + (myConfigurationType != null ? myConfigurationType.hashCode() : 0);
      return result;
    }
  }

  private class SelectionDialog extends DialogWrapper {
    private RunnerAndConfigurationSettings mySelectedSettings;
    @NotNull private final List<RunnerAndConfigurationSettings> mySettings;
    private JBList myJBList;

    private SelectionDialog(RunnerAndConfigurationSettings selectedSettings, @NotNull List<RunnerAndConfigurationSettings> settings) {
      super(myProject);
      setTitle(ExecutionBundle.message("before.launch.run.another.configuration.choose"));
      mySelectedSettings = selectedSettings;
      mySettings = settings;
      init();
      myJBList.setSelectedValue(mySelectedSettings, true);
      myJBList.addMouseListener(new MouseAdapter() {
        @Override
        public void mouseClicked(MouseEvent e) {
          if (SwingUtilities.isLeftMouseButton(e) && e.getClickCount() ==2) {
            doOKAction();
          }
        }
      });
      FontMetrics fontMetrics = myJBList.getFontMetrics(myJBList.getFont());
      int maxWidth = fontMetrics.stringWidth("m") * 30;
      for (RunnerAndConfigurationSettings setting : settings) {
        maxWidth = Math.max(fontMetrics.stringWidth(setting.getConfiguration().getName()), maxWidth);
      }
      maxWidth += 24;//icon and gap
      myJBList.setMinimumSize(new Dimension(maxWidth, myJBList.getPreferredSize().height));
    }

    @Nullable
    @Override
    protected String getDimensionServiceKey() {
      return "com.intellij.execution.impl.RunConfigurationBeforeRunProvider.dimensionServiceKey;";
    }

    @Override
    protected JComponent createCenterPanel() {
      myJBList = new JBList(mySettings);
      myJBList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
      myJBList.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
        @Override
        public void valueChanged(ListSelectionEvent e) {
          Object selectedValue = myJBList.getSelectedValue();
          if (selectedValue instanceof RunnerAndConfigurationSettings) {
            mySelectedSettings = (RunnerAndConfigurationSettings)selectedValue;
          }
          else {
            mySelectedSettings = null;
          }
          setOKActionEnabled(mySelectedSettings != null);
        }
      });
      myJBList.setCellRenderer(new ColoredListCellRenderer() {
        @Override
        protected void customizeCellRenderer(JList list, Object value, int index, boolean selected, boolean hasFocus) {
          if (value instanceof RunnerAndConfigurationSettings) {
            RunnerAndConfigurationSettings settings = (RunnerAndConfigurationSettings)value;
            RunManagerEx runManager = RunManagerEx.getInstanceEx(myProject);
            setIcon(runManager.getConfigurationIcon(settings));
            RunConfiguration configuration = settings.getConfiguration();
            append(configuration.getName(), settings.isTemporary()
                                            ? SimpleTextAttributes.GRAY_ATTRIBUTES
                                            : SimpleTextAttributes.REGULAR_ATTRIBUTES);
          }
        }
      });
      return new JBScrollPane(myJBList);
    }

    @Nullable
    RunnerAndConfigurationSettings getSelectedSettings() {
      return isOK() ? mySelectedSettings : null;
    }
  }
}