java/compiler/impl/src/com/intellij/packaging/impl/run/BuildArtifactsBeforeRun.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.packaging.impl.run;
  17
  18 import com.intellij.execution.BeforeRunTaskProvider;
  19 import com.intellij.execution.RunManagerEx;
  20 import com.intellij.execution.configurations.RunConfiguration;
  21 import com.intellij.execution.impl.ConfigurationSettingsEditorWrapper;
  22 import com.intellij.ide.DataManager;
  23 import com.intellij.openapi.actionSystem.DataContext;
  24 import com.intellij.openapi.application.ApplicationManager;
  25 import com.intellij.openapi.application.ModalityState;
  26 import com.intellij.openapi.application.ReadAction;
  27 import com.intellij.openapi.application.Result;
  28 import com.intellij.openapi.compiler.*;
  29 import com.intellij.openapi.compiler.Compiler;
  30 import com.intellij.openapi.project.Project;
  31 import com.intellij.openapi.ui.DialogBuilder;
  32 import com.intellij.openapi.ui.DialogWrapper;
  33 import com.intellij.openapi.util.Key;
  34 import com.intellij.openapi.util.Ref;
  35 import com.intellij.packaging.artifacts.Artifact;
  36 import com.intellij.packaging.artifacts.ArtifactManager;
  37 import com.intellij.packaging.artifacts.ArtifactPointer;
  38 import com.intellij.packaging.artifacts.ArtifactPointerManager;
  39 import com.intellij.packaging.impl.compiler.ArtifactAwareCompiler;
  40 import com.intellij.packaging.impl.compiler.ArtifactCompileScope;
  41 import com.intellij.packaging.impl.compiler.IncrementalArtifactsCompiler;
  42 import com.intellij.util.concurrency.Semaphore;
  43 import com.intellij.util.containers.ContainerUtil;
  44 import gnu.trove.THashSet;
  45 import org.jetbrains.annotations.NonNls;
  46 import org.jetbrains.annotations.NotNull;
  47
  48 import javax.swing.*;
  49 import java.util.ArrayList;
  50 import java.util.List;
  51 import java.util.Set;
  52
  53 /**
  54  * @author nik
  55  */
  56 public class BuildArtifactsBeforeRun implements BeforeRunTaskProvider<BuildArtifactsBeforeRunTask> {
  57   @NonNls public static final String BUILD_ARTIFACTS_ID = "BuildArtifacts";
  58   public static final Key<BuildArtifactsBeforeRunTask> ID = Key.create(BUILD_ARTIFACTS_ID);
  59   private Project myProject;
  60
  61   public BuildArtifactsBeforeRun(Project project) {
  62     myProject = project;
  63   }
  64
  65   public Key<BuildArtifactsBeforeRunTask> getId() {
  66     return ID;
  67   }
  68
  69   public String getDescription(RunConfiguration runConfiguration, BuildArtifactsBeforeRunTask task) {
  70     final List<ArtifactPointer> pointers = task.getArtifactPointers();
  71     if (!task.isEnabled() || pointers.isEmpty()) {
  72       return "Build Artifacts";
  73     }
  74     if (pointers.size() == 1) {
  75       return "Build '" + pointers.get(0).getArtifactName() + "' artifact";
  76     }
  77     return "Build " + pointers.size() + " artifacts";
  78   }
  79
  80   public boolean hasConfigurationButton() {
  81     return true;
  82   }
  83
  84   public BuildArtifactsBeforeRunTask createTask(RunConfiguration runConfiguration) {
  85     return new BuildArtifactsBeforeRunTask(myProject);
  86   }
  87
  88   public void configureTask(RunConfiguration runConfiguration, BuildArtifactsBeforeRunTask task) {
  89     final Artifact[] artifacts = ArtifactManager.getInstance(myProject).getArtifacts();
  90     Set<ArtifactPointer> pointers = new THashSet<ArtifactPointer>();
  91     for (Artifact artifact : artifacts) {
  92       pointers.add(ArtifactPointerManager.getInstance(myProject).createPointer(artifact));
  93     }
  94     pointers.addAll(task.getArtifactPointers());
  95     ArtifactChooser chooser = new ArtifactChooser(new ArrayList<ArtifactPointer>(pointers));
  96     chooser.markElements(task.getArtifactPointers());
  97
  98     DialogBuilder builder = new DialogBuilder(myProject);
  99     builder.setTitle("Select Artifacts");
 100     builder.addOkAction();
 101     builder.addCancelAction();
 102     builder.setCenterPanel(chooser);
 103     builder.setPreferedFocusComponent(chooser);
 104     if (builder.show() == DialogWrapper.OK_EXIT_CODE) {
 105       task.setArtifactPointers(chooser.getMarkedElements());
 106     }
 107   }
 108
 109   public boolean executeTask(DataContext context, RunConfiguration configuration, final BuildArtifactsBeforeRunTask task) {
 110     final Ref<Boolean> result = Ref.create(false);
 111     final Semaphore finished = new Semaphore();
 112
 113     final List<Artifact> artifacts = new ArrayList<Artifact>();
 114     new ReadAction() {
 115       protected void run(final Result result) {
 116         for (ArtifactPointer pointer : task.getArtifactPointers()) {
 117           ContainerUtil.addIfNotNull(pointer.getArtifact(), artifacts);
 118         }
 119       }
 120     }.execute();
 121
 122     final CompileStatusNotification callback = new CompileStatusNotification() {
 123       public void finished(boolean aborted, int errors, int warnings, CompileContext compileContext) {
 124         result.set(!aborted && errors == 0);
 125         finished.up();
 126       }
 127     };
 128     final CompilerFilter compilerFilter = new CompilerFilter() {
 129       public boolean acceptCompiler(Compiler compiler) {
 130         return compiler instanceof IncrementalArtifactsCompiler
 131                || compiler instanceof ArtifactAwareCompiler && ((ArtifactAwareCompiler)compiler).shouldRun(artifacts);
 132       }
 133     };
 134
 135     ApplicationManager.getApplication().invokeAndWait(new Runnable() {
 136       public void run() {
 137         final CompilerManager manager = CompilerManager.getInstance(myProject);
 138         finished.down();
 139         manager.make(ArtifactCompileScope.createArtifactsScope(myProject, artifacts), compilerFilter, callback);
 140       }
 141     }, ModalityState.NON_MODAL);
 142
 143     finished.waitFor();
 144     return result.get();
 145   }
 146
 147   public static void setBuildArtifactBeforeRunOption(@NotNull JComponent runConfigurationEditorComponent, @NotNull Artifact artifact, final boolean enable) {
 148     final DataContext dataContext = DataManager.getInstance().getDataContext(runConfigurationEditorComponent);
 149     final ConfigurationSettingsEditorWrapper editor = ConfigurationSettingsEditorWrapper.CONFIGURATION_EDITOR_KEY.getData(dataContext);
 150     if (editor != null) {
 151       final BuildArtifactsBeforeRunTask task = (BuildArtifactsBeforeRunTask)editor.getStepsBeforeLaunch().get(ID);
 152       if (enable) {
 153         task.addArtifact(artifact);
 154         task.setEnabled(true);
 155       }
 156       else {
 157         task.removeArtifact(artifact);
 158         if (task.getArtifactPointers().isEmpty()) {
 159           task.setEnabled(false);
 160         }
 161       }
 162       editor.updateBeforeRunTaskPanel(ID);
 163     }
 164   }
 165
 166   public static void setBuildArtifactBeforeRun(@NotNull Project project, @NotNull RunConfiguration configuration, @NotNull Artifact artifact) {
 167     RunManagerEx runManager = RunManagerEx.getInstanceEx(project);
 168     final BuildArtifactsBeforeRunTask buildArtifactsTask = runManager.getBeforeRunTask(configuration, ID);
 169     if (buildArtifactsTask != null) {
 170       buildArtifactsTask.setEnabled(true);
 171       buildArtifactsTask.addArtifact(artifact);
 172     }
 173   }
 174 }