diff --git a/java/compiler/impl/src/com/intellij/packaging/impl/run/BuildArtifactsBeforeRunTask.java b/java/compiler/impl/src/com/intellij/packaging/impl/run/BuildArtifactsBeforeRunTask.java index 0157fb78953a..d312a9475c69 100644 --- a/java/compiler/impl/src/com/intellij/packaging/impl/run/BuildArtifactsBeforeRunTask.java +++ b/java/compiler/impl/src/com/intellij/packaging/impl/run/BuildArtifactsBeforeRunTask.java @@ -31,13 +31,14 @@ import java.util.List; /** * @author nik */ -public class BuildArtifactsBeforeRunTask extends BeforeRunTask { +public class BuildArtifactsBeforeRunTask extends BeforeRunTask { @NonNls public static final String NAME_ATTRIBUTE = "name"; @NonNls public static final String ARTIFACT_ELEMENT = "artifact"; private List myArtifactPointers = new ArrayList(); private final Project myProject; public BuildArtifactsBeforeRunTask(Project project) { + super(BuildArtifactsBeforeRunTaskProvider.ID); myProject = project; } diff --git a/java/compiler/impl/src/com/intellij/packaging/impl/run/BuildArtifactsBeforeRunTaskProvider.java b/java/compiler/impl/src/com/intellij/packaging/impl/run/BuildArtifactsBeforeRunTaskProvider.java index ee2315e3a046..667bd73ea91e 100644 --- a/java/compiler/impl/src/com/intellij/packaging/impl/run/BuildArtifactsBeforeRunTaskProvider.java +++ b/java/compiler/impl/src/com/intellij/packaging/impl/run/BuildArtifactsBeforeRunTaskProvider.java @@ -15,6 +15,7 @@ */ package com.intellij.packaging.impl.run; +import com.intellij.execution.BeforeRunTask; import com.intellij.execution.BeforeRunTaskProvider; import com.intellij.execution.RunManagerEx; import com.intellij.execution.configurations.RunConfiguration; @@ -33,6 +34,7 @@ import com.intellij.openapi.ui.DialogWrapper; import com.intellij.openapi.util.Key; import com.intellij.openapi.util.Ref; import com.intellij.packaging.artifacts.*; +import com.intellij.packaging.impl.artifacts.PlainArtifactType; import com.intellij.packaging.impl.compiler.ArtifactAwareCompiler; import com.intellij.packaging.impl.compiler.ArtifactCompileScope; import com.intellij.packaging.impl.compiler.ArtifactsCompiler; @@ -63,8 +65,8 @@ public class BuildArtifactsBeforeRunTaskProvider extends BeforeRunTaskProvider tasks = runManager.getBeforeRunTasks(configuration, ID); + for (BuildArtifactsBeforeRunTask task : tasks) { final String artifactName = artifact.getName(); final List pointersList = task.getArtifactPointers(); final ArtifactPointer[] pointers = pointersList.toArray(new ArtifactPointer[pointersList.size()]); @@ -83,18 +85,40 @@ public class BuildArtifactsBeforeRunTaskProvider extends BeforeRunTaskProvider pointers = task.getArtifactPointers(); - if (!task.isEnabled() || pointers.isEmpty()) { - return "Build Artifacts"; - } - if (pointers.size() == 1) { - return "Build '" + pointers.get(0).getArtifactName() + "' artifact"; - } - return "Build " + pointers.size() + " artifacts"; + @Override + public Icon getIcon() { + return PlainArtifactType.ARTIFACT_ICON; } - public boolean hasConfigurationButton() { + @Override + public String getName() { + return CompilerBundle.message("build.artifacts.before.run.description.empty"); + } + + @Override + public Icon getTaskIcon(BuildArtifactsBeforeRunTask task) { + List pointers = task.getArtifactPointers(); + if (pointers == null || pointers.isEmpty()) + return getIcon(); + Artifact artifact = pointers.get(0).getArtifact(); + if (artifact == null) + return getIcon(); + return artifact.getArtifactType().getIcon(); + } + + @Override + public String getDescription(BuildArtifactsBeforeRunTask task) { + final List pointers = task.getArtifactPointers(); + if (!task.isEnabled() || pointers.isEmpty()) { + return CompilerBundle.message("build.artifacts.before.run.description.empty"); + } + if (pointers.size() == 1) { + return CompilerBundle.message("build.artifacts.before.run.description.single", pointers.get(0).getArtifactName()); + } + return CompilerBundle.message("build.artifacts.before.run.description.multiple", pointers.size()); + } + + public boolean isConfigurable() { return true; } @@ -115,7 +139,7 @@ public class BuildArtifactsBeforeRunTaskProvider extends BeforeRunTaskProvider result = Ref.create(false); final Semaphore finished = new Semaphore(); @@ -170,27 +203,35 @@ public class BuildArtifactsBeforeRunTaskProvider extends BeforeRunTaskProvider tasks = editor.getStepsBeforeLaunch(); + List myTasks = new ArrayList(); + for (BeforeRunTask task : tasks) { + if (task instanceof BuildArtifactsBeforeRunTask) { + myTasks.add((BuildArtifactsBeforeRunTask)task); + } } - else { - task.removeArtifact(artifact); - if (task.getArtifactPointers().isEmpty()) { - task.setEnabled(false); + for (BuildArtifactsBeforeRunTask task : myTasks) { + if (enable) { + task.addArtifact(artifact); + task.setEnabled(true); + } + else { + task.removeArtifact(artifact); + if (task.getArtifactPointers().isEmpty()) { + task.setEnabled(false); + } } } - editor.updateBeforeRunTaskPanel(ID); } } public static void setBuildArtifactBeforeRun(@NotNull Project project, @NotNull RunConfiguration configuration, @NotNull Artifact artifact) { RunManagerEx runManager = RunManagerEx.getInstanceEx(project); - final BuildArtifactsBeforeRunTask buildArtifactsTask = runManager.getBeforeRunTask(configuration, ID); - if (buildArtifactsTask != null) { - buildArtifactsTask.setEnabled(true); - buildArtifactsTask.addArtifact(artifact); + final List buildArtifactsTasks = runManager.getBeforeRunTasks(configuration, ID); + for (BuildArtifactsBeforeRunTask task : buildArtifactsTasks) { + task.setEnabled(true); + task.addArtifact(artifact); + } } } diff --git a/java/execution/impl/src/com/intellij/compiler/options/CompileStepBeforeRun.java b/java/execution/impl/src/com/intellij/compiler/options/CompileStepBeforeRun.java index 2822a51bac32..4c2a775ccd7e 100644 --- a/java/execution/impl/src/com/intellij/compiler/options/CompileStepBeforeRun.java +++ b/java/execution/impl/src/com/intellij/compiler/options/CompileStepBeforeRun.java @@ -32,12 +32,15 @@ import com.intellij.openapi.compiler.CompilerManager; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.module.Module; import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.IconLoader; import com.intellij.openapi.util.Key; import com.intellij.util.concurrency.Semaphore; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import javax.swing.*; + /** * @author spleaner */ @@ -47,6 +50,9 @@ public class CompileStepBeforeRun extends BeforeRunTaskProvider RUN_CONFIGURATION = Key.create("RUN_CONFIGURATION"); @NonNls protected static final String MAKE_PROJECT_ON_RUN_KEY = "makeProjectOnRun"; + + private static final Icon ICON = IconLoader.getIcon("/actions/compile.png"); + private final Project myProject; public CompileStepBeforeRun(@NotNull final Project project) { @@ -57,10 +63,26 @@ public class CompileStepBeforeRun extends BeforeRunTaskProvider { private MakeBeforeRunTask() { + super(ID); setEnabled(true); } } diff --git a/lib/miglayout-swing.jar b/lib/miglayout-swing.jar new file mode 100644 index 000000000000..81b75f3e6bd3 Binary files /dev/null and b/lib/miglayout-swing.jar differ diff --git a/lib/required_for_dist.txt b/lib/required_for_dist.txt index 1c569232caec..67d57ba064e6 100644 --- a/lib/required_for_dist.txt +++ b/lib/required_for_dist.txt @@ -28,6 +28,7 @@ log4j.jar jgoodies-common-1.2.1.jar jgoodies-looks-2.4.2.jar microba.jar +miglayout-swing.jar nanoxml-2.2.3.jar nekohtml-1.9.14.jar org.eclipse.jdt.core_3.5.2.v_981_R35x.jar diff --git a/lib/src/miglayout-sources.jar b/lib/src/miglayout-sources.jar new file mode 100644 index 000000000000..328016e31f74 Binary files /dev/null and b/lib/src/miglayout-sources.jar differ diff --git a/platform/lang-api/src/com/intellij/execution/BeforeRunTask.java b/platform/lang-api/src/com/intellij/execution/BeforeRunTask.java index b1f8120f1465..fad6015d02f0 100644 --- a/platform/lang-api/src/com/intellij/execution/BeforeRunTask.java +++ b/platform/lang-api/src/com/intellij/execution/BeforeRunTask.java @@ -16,15 +16,28 @@ package com.intellij.execution; +import com.intellij.openapi.util.Key; import org.jdom.Element; +import org.jetbrains.annotations.NotNull; /** * @author Eugene Zhuravlev * Date: May 18, 2009 */ -public abstract class BeforeRunTask implements Cloneable{ +public abstract class BeforeRunTask implements Cloneable { + @NotNull + protected final Key myProviderId; private boolean myIsEnabled; + protected BeforeRunTask(@NotNull Key providerId) { + myProviderId = providerId; + } + + @NotNull + public final Key getProviderId() { + return myProviderId; + } + public boolean isEnabled() { return myIsEnabled; } @@ -59,13 +72,13 @@ public abstract class BeforeRunTask implements Cloneable{ if (o == null || getClass() != o.getClass()) return false; BeforeRunTask that = (BeforeRunTask)o; - + if (myProviderId != that.myProviderId) return false; if (myIsEnabled != that.myIsEnabled) return false; return true; } public int hashCode() { - return (myIsEnabled ? 1 : 0); + return 31 * myProviderId.hashCode() + (myIsEnabled ? 1 : 0); } } diff --git a/platform/lang-api/src/com/intellij/execution/BeforeRunTaskProvider.java b/platform/lang-api/src/com/intellij/execution/BeforeRunTaskProvider.java index 2085bcadf15c..eec2d04f2d39 100644 --- a/platform/lang-api/src/com/intellij/execution/BeforeRunTaskProvider.java +++ b/platform/lang-api/src/com/intellij/execution/BeforeRunTaskProvider.java @@ -25,9 +25,13 @@ package com.intellij.execution; import com.intellij.execution.configurations.RunConfiguration; import com.intellij.openapi.actionSystem.DataContext; import com.intellij.openapi.extensions.ExtensionPointName; +import com.intellij.openapi.extensions.Extensions; +import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Key; import org.jetbrains.annotations.Nullable; +import javax.swing.*; + public abstract class BeforeRunTaskProvider { public static final ExtensionPointName> EXTENSION_POINT_NAME = new ExtensionPointName>("com.intellij.stepsBeforeRunProvider"); @@ -35,9 +39,22 @@ public abstract class BeforeRunTaskProvider { public abstract Key getId(); - public abstract String getDescription(final RunConfiguration runConfiguration, T task); + public abstract String getName(); - public abstract boolean hasConfigurationButton(); + @Nullable + public Icon getIcon() { + return null; + }; + + public abstract String getDescription(T task); + + + @Nullable + public Icon getTaskIcon(T task) { + return null; + } + + public abstract boolean isConfigurable(); /** * @return 'before run' task for the configuration or null, if the task from this provider is not applicable to the specified configuration @@ -50,8 +67,18 @@ public abstract class BeforeRunTaskProvider { */ public abstract boolean configureTask(final RunConfiguration runConfiguration, T task); + public abstract boolean canExecuteTask(RunConfiguration configuration, T task); + public abstract boolean executeTask(DataContext context, RunConfiguration configuration, T task); + /** + * + * @return true if at most one task may be configured + */ + public boolean isSingleton() { + return false; + } + /** * Get runner id that current run is about to be made by * @param context data context that is passed to {@link #executeTask(com.intellij.openapi.actionSystem.DataContext, com.intellij.execution.configurations.RunConfiguration, BeforeRunTask)} @@ -61,4 +88,14 @@ public abstract class BeforeRunTaskProvider { public static String getRunnerId(DataContext context) { return (String)context.getData(RUNNER_ID); } + + @Nullable + public static BeforeRunTaskProvider getProvider(Project project, Key key) { + BeforeRunTaskProvider[] providers = Extensions.getExtensions(BeforeRunTaskProvider.EXTENSION_POINT_NAME, project); + for (BeforeRunTaskProvider provider : providers) { + if (provider.getId() == key) + return (BeforeRunTaskProvider)provider; + } + return null; + } } \ No newline at end of file diff --git a/platform/lang-impl/src/com/intellij/execution/RunManagerEx.java b/platform/lang-impl/src/com/intellij/execution/RunManagerEx.java index b221a829268b..714bc7a2317f 100644 --- a/platform/lang-impl/src/com/intellij/execution/RunManagerEx.java +++ b/platform/lang-impl/src/com/intellij/execution/RunManagerEx.java @@ -24,7 +24,7 @@ import org.jetbrains.annotations.Nullable; import javax.swing.*; import java.util.Collection; -import java.util.Map; +import java.util.List; /** * Manages {@link RunConfiguration}s. @@ -55,20 +55,23 @@ public abstract class RunManagerEx extends RunManager { @NotNull public abstract RunnerAndConfigurationSettings createConfiguration(String name, ConfigurationFactory type); - public abstract void addConfiguration(RunnerAndConfigurationSettings settings, boolean isShared, Map, BeforeRunTask> tasks); + public abstract void addConfiguration(RunnerAndConfigurationSettings settings, boolean isShared, List tasks); public abstract void addConfiguration(final RunnerAndConfigurationSettings settings, final boolean isShared); public abstract boolean isConfigurationShared(RunnerAndConfigurationSettings settings); @NotNull - public abstract Map, BeforeRunTask> getBeforeRunTasks(RunConfiguration settings); - - @Nullable - public abstract T getBeforeRunTask(RunConfiguration settings, Key taskProviderID); + public abstract List getBeforeRunTasks(RunConfiguration settings); @NotNull - public abstract Collection getBeforeRunTasks(Key taskProviderID, boolean includeOnlyActiveTasks); + public abstract List getBeforeRunTasks(RunConfiguration settings, boolean includeOnlyActiveTasks); + + @NotNull + public abstract List getBeforeRunTasks(RunConfiguration settings, Key taskProviderID); + + @NotNull + public abstract List getBeforeRunTasks(Key taskProviderID, boolean includeOnlyActiveTasks); public abstract RunnerAndConfigurationSettings findConfigurationByName(@Nullable final String name); diff --git a/platform/lang-impl/src/com/intellij/execution/impl/BaseExecuteBeforeRunDialog.java b/platform/lang-impl/src/com/intellij/execution/impl/BaseExecuteBeforeRunDialog.java index 638759607a8a..fe59622cc785 100644 --- a/platform/lang-impl/src/com/intellij/execution/impl/BaseExecuteBeforeRunDialog.java +++ b/platform/lang-impl/src/com/intellij/execution/impl/BaseExecuteBeforeRunDialog.java @@ -39,9 +39,8 @@ import java.awt.event.KeyAdapter; import java.awt.event.KeyEvent; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; -import java.util.ArrayList; -import java.util.Enumeration; -import java.util.Set; +import java.util.*; +import java.util.List; public abstract class BaseExecuteBeforeRunDialog extends DialogWrapper { @@ -180,8 +179,12 @@ public abstract class BaseExecuteBeforeRunDialog extend } private boolean isConfigurationAssigned(RunConfiguration configuration) { - final T task = RunManagerEx.getInstanceEx(myProject).getBeforeRunTask(configuration, getTaskID()); - return task != null && isRunning(task); + final java.util.List tasks = RunManagerEx.getInstanceEx(myProject).getBeforeRunTasks(configuration, getTaskID()); + for (T task : tasks) { + if (isRunning(task)) + return true; + } + return false; } protected void doOKAction() { @@ -215,20 +218,24 @@ public abstract class BaseExecuteBeforeRunDialog extend protected abstract boolean isRunning(T task); private void update(RunConfiguration config, boolean enabled, RunManagerImpl runManager) { - T task = runManager.getBeforeRunTask(config, getTaskID()); - if (task == null) return; - + List tasks = runManager.getBeforeRunTasks(config); + BeforeRunTaskProvider provider = BeforeRunTaskProvider.getProvider(myProject, getTaskID()); + if (provider == null) + return; + T task = provider.createTask(config); + update(task); + task.setEnabled(true); if (enabled) { - task.setEnabled(true); - update(task); + if (!tasks.contains(task)) { + tasks.add(task); + } } else { - if (isRunning(task)) { - task.setEnabled(false); - clear(task); + if (tasks.contains(task)) { + tasks.remove(task); } - // do not change the task otherwise } + runManager.setBeforeRunTasks(config, tasks); } protected abstract void update(T task); diff --git a/platform/lang-impl/src/com/intellij/execution/impl/BeforeRunStepsPanel.java b/platform/lang-impl/src/com/intellij/execution/impl/BeforeRunStepsPanel.java new file mode 100644 index 000000000000..d9a797a8cde1 --- /dev/null +++ b/platform/lang-impl/src/com/intellij/execution/impl/BeforeRunStepsPanel.java @@ -0,0 +1,229 @@ +/* + * 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.RunConfiguration; +import com.intellij.execution.configurations.UnknownRunConfiguration; +import com.intellij.openapi.actionSystem.AnAction; +import com.intellij.openapi.actionSystem.AnActionEvent; +import com.intellij.openapi.actionSystem.DefaultActionGroup; +import com.intellij.openapi.actionSystem.impl.SimpleDataContext; +import com.intellij.openapi.extensions.Extensions; +import com.intellij.openapi.ui.popup.JBPopupFactory; +import com.intellij.openapi.ui.popup.ListPopup; +import com.intellij.openapi.util.Condition; +import com.intellij.openapi.util.Key; +import com.intellij.openapi.util.Pair; +import com.intellij.ui.*; +import com.intellij.ui.components.JBList; +import com.intellij.util.containers.hash.HashSet; +import net.miginfocom.swing.MigLayout; +import org.jetbrains.annotations.Nullable; + +import javax.swing.*; +import java.awt.*; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Set; + +/** + * @author Vassiliy Kudryashov + */ +class BeforeRunStepsPanel extends JPanel { + private JCheckBox myShowSettingsBeforeRunCheckBox; + private JBList myList; + private final CollectionListModel myModel; + private RunConfiguration myRunConfiguration; + + private final List originalTasks = new ArrayList(); + private StepsBeforeRunListener myListener; + + BeforeRunStepsPanel(StepsBeforeRunListener listener) { + myListener = listener; + myModel = new CollectionListModel(); + myList = new JBList(myModel); + myList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); + myList.setCellRenderer(new MyListCellRenderer()); + ToolbarDecorator myDecorator = ToolbarDecorator.createDecorator(myList); + myDecorator.setEditAction(new AnActionButtonRunnable() { + @Override + public void run(AnActionButton button) { + int index = myList.getSelectedIndex(); + if (index ==-1) + return; + Pair> selection = getSelection(); + if (selection == null) + return; + BeforeRunTask task = selection.getFirst(); + BeforeRunTaskProvider provider = selection.getSecond(); + if (provider.configureTask(myRunConfiguration, task)) { + myModel.setElementAt(task, index); + } + } + }); + myDecorator.setEditActionUpdater(new AnActionButtonUpdater() { + @Override + public boolean isEnabled(AnActionEvent e) { + Pair> selection = getSelection(); + return selection != null && selection.getSecond().isConfigurable(); + } + }); + myDecorator.setAddAction(new AnActionButtonRunnable() { + @Override + public void run(AnActionButton button) { + doAddAction(button); + } + }); + + myShowSettingsBeforeRunCheckBox = new JCheckBox(ExecutionBundle.message("configuration.edit.before.run")); + + setLayout(new MigLayout("fill, ins 0, gap 10")); + add(myShowSettingsBeforeRunCheckBox, "shrinky, wrap"); + add(myDecorator.createPanel(), "grow, push"); + } + + @Nullable + private Pair> getSelection() { + final int index = myList.getSelectedIndex(); + if (index ==-1) + return null; + BeforeRunTask task = myModel.getElementAt(index); + Key providerId = task.getProviderId(); + BeforeRunTaskProvider provider = BeforeRunTaskProvider.getProvider(myRunConfiguration.getProject(), providerId); + return provider != null ? Pair.create(task, provider) : null; + } + + void doReset(RunnerAndConfigurationSettings settings) { + myRunConfiguration = settings.getConfiguration(); + + originalTasks.clear(); + originalTasks.addAll(RunManagerImpl.getInstanceImpl(myRunConfiguration.getProject()).getBeforeRunTasks(myRunConfiguration, true)); + myModel.replaceAll(originalTasks); + myShowSettingsBeforeRunCheckBox.setSelected(settings.isEditBeforeRun()); + myShowSettingsBeforeRunCheckBox.setEnabled(!(myRunConfiguration instanceof UnknownRunConfiguration)); + } + + public List getTasks(boolean applyCurrentState) { + if (applyCurrentState) { + originalTasks.clear(); + originalTasks.addAll(myModel.getItems()); + } + return Collections.unmodifiableList(originalTasks); + } + + public boolean needEditBeforeRun() { + return myShowSettingsBeforeRunCheckBox.isSelected(); + } + + void doAddAction(AnActionButton button) { + if (myRunConfiguration instanceof UnknownRunConfiguration) { + return; + } + + final JBPopupFactory popupFactory = JBPopupFactory.getInstance(); + final BeforeRunTaskProvider[] providers = Extensions.getExtensions(BeforeRunTaskProvider.EXTENSION_POINT_NAME, + myRunConfiguration.getProject()); + final List activeProviderKeys = getActiveProviderKeys(); + + DefaultActionGroup actionGroup = new DefaultActionGroup(null, false); + for (final BeforeRunTaskProvider provider : providers) { + String providerName = provider.getName(); + if (provider.createTask(myRunConfiguration) == null) + continue; + if (activeProviderKeys.contains(provider.getId()) && provider.isSingleton()) + continue; + AnAction providerAction = new AnAction(providerName, null, provider.getIcon()) { + @Override + public void actionPerformed(AnActionEvent e) { + BeforeRunTask task = provider.createTask(myRunConfiguration); + if (task != null) { + provider.configureTask(myRunConfiguration, task); + if (!provider.canExecuteTask(myRunConfiguration, task)) + return; + } else { + return; + } + task.setEnabled(true); + + Set configurationSet = new HashSet(); + getAllRunBeforeRuns(task, configurationSet); + if (configurationSet.contains(myRunConfiguration)) { + JOptionPane.showMessageDialog(BeforeRunStepsPanel.this, + ExecutionBundle.message("before.launch.panel.cyclic_dependency_warning", + myRunConfiguration.getName(), + provider.getDescription(task)), + ExecutionBundle.message("warning.common.title"),JOptionPane.WARNING_MESSAGE); + return; + } + myModel.add(task); + myListener.fireStepsBeforeRunChanged(); + } + }; + actionGroup.add(providerAction); + } + final ListPopup popup = + popupFactory.createActionGroupPopup(ExecutionBundle.message("add.new.run.configuration.acrtion.name"), actionGroup, + SimpleDataContext.getProjectContext(myRunConfiguration.getProject()), false, false, false, null, + -1, Condition.TRUE); + popup.show(button.getPreferredPopupPoint()); + } + + private List getActiveProviderKeys() { + List result = new ArrayList(); + for (BeforeRunTask task : myModel.getItems()) { + result.add(task.getProviderId()); + } + return result; + } + + private void getAllRunBeforeRuns(BeforeRunTask task, Set configurationSet) { + if (task instanceof RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask) { + RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask runTask + = (RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask)task; + RunConfiguration configuration = runTask.getSettings().getConfiguration(); + + List tasks = RunManagerImpl.getInstanceImpl(configuration.getProject()).getBeforeRunTasks(configuration, true); + for (BeforeRunTask beforeRunTask : tasks) { + if (beforeRunTask instanceof RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask) { + configurationSet.add(((RunConfigurationBeforeRunProvider.RunConfigurableBeforeRunTask)beforeRunTask).getSettings().getConfiguration()); + getAllRunBeforeRuns(beforeRunTask, configurationSet); + } + } + } + } + + interface StepsBeforeRunListener { + void fireStepsBeforeRunChanged(); + } + + private class MyListCellRenderer extends JBList.StripedListCellRenderer { + @Override + public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) { + super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus); + if (value instanceof BeforeRunTask) { + BeforeRunTask task = (BeforeRunTask)value; + BeforeRunTaskProvider provider = BeforeRunTaskProvider.getProvider(myRunConfiguration.getProject(), task.getProviderId()); + if (provider != null) { + setIcon(provider.getTaskIcon(task)); + setText(provider.getDescription(task)); + } + } + return this; + } + } +} diff --git a/platform/lang-impl/src/com/intellij/execution/impl/ConfigurationSettingsEditorWrapper.form b/platform/lang-impl/src/com/intellij/execution/impl/ConfigurationSettingsEditorWrapper.form index 8973059b4e7d..89bbe4fdf05f 100644 --- a/platform/lang-impl/src/com/intellij/execution/impl/ConfigurationSettingsEditorWrapper.form +++ b/platform/lang-impl/src/com/intellij/execution/impl/ConfigurationSettingsEditorWrapper.form @@ -17,13 +17,13 @@ - + - + diff --git a/platform/lang-impl/src/com/intellij/execution/impl/ConfigurationSettingsEditorWrapper.java b/platform/lang-impl/src/com/intellij/execution/impl/ConfigurationSettingsEditorWrapper.java index 6a8b5f35018d..dd93b12e5e12 100644 --- a/platform/lang-impl/src/com/intellij/execution/impl/ConfigurationSettingsEditorWrapper.java +++ b/platform/lang-impl/src/com/intellij/execution/impl/ConfigurationSettingsEditorWrapper.java @@ -17,8 +17,6 @@ package com.intellij.execution.impl; import com.intellij.execution.BeforeRunTask; -import com.intellij.execution.BeforeRunTaskProvider; -import com.intellij.execution.ExecutionBundle; import com.intellij.execution.RunnerAndConfigurationSettings; import com.intellij.execution.configurations.RunConfiguration; import com.intellij.execution.configurations.UnknownRunConfiguration; @@ -27,48 +25,43 @@ import com.intellij.ide.impl.TypeSafeDataProviderAdapter; import com.intellij.openapi.actionSystem.DataKey; import com.intellij.openapi.actionSystem.DataSink; import com.intellij.openapi.actionSystem.TypeSafeDataProvider; -import com.intellij.openapi.extensions.Extensions; import com.intellij.openapi.options.ConfigurationException; import com.intellij.openapi.options.SettingsEditor; -import com.intellij.openapi.ui.FixedSizeButton; import com.intellij.openapi.util.Disposer; -import com.intellij.openapi.util.Key; -import com.intellij.util.ui.UIUtil; -import gnu.trove.THashMap; +import net.miginfocom.swing.MigLayout; import org.jetbrains.annotations.NotNull; import javax.swing.*; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; -import java.util.ArrayList; import java.util.Collections; import java.util.List; -import java.util.Map; /** * User: anna * Date: 27-Mar-2006 */ -public class ConfigurationSettingsEditorWrapper extends SettingsEditor { +public class ConfigurationSettingsEditorWrapper extends SettingsEditor + implements BeforeRunStepsPanel.StepsBeforeRunListener { public static DataKey CONFIGURATION_EDITOR_KEY = DataKey.create("ConfigurationSettingsEditor"); private JPanel myComponentPlace; private JCheckBox myCbStoreProjectConfiguration; private JPanel myWholePanel; - private JPanel myStepsPanel; - private JCheckBox myShowSettingsBeforeRunCheckBox; - private Map, BeforeRunTask> myStepsBeforeLaunch; - private final Map, StepBeforeLaunchRow> myStepBeforeLaunchRows = new THashMap, StepBeforeLaunchRow>(); + private JPanel myBeforeLaunchContainer; + private BeforeRunStepsPanel myBeforeRunStepsPanel; private boolean myStoreProjectConfiguration; - private boolean myEditBeforeRun; private final ConfigurationSettingsEditor myEditor; public ConfigurationSettingsEditorWrapper(final RunnerAndConfigurationSettings settings) { myEditor = new ConfigurationSettingsEditor(settings); Disposer.register(this, myEditor); + myBeforeRunStepsPanel = new BeforeRunStepsPanel(this); + myBeforeLaunchContainer.setLayout(new MigLayout("fill, ins 0")); + myBeforeLaunchContainer.add(myBeforeRunStepsPanel, "grow, push"); doReset(settings); } @@ -76,54 +69,8 @@ public class ConfigurationSettingsEditorWrapper extends SettingsEditor[] providers = Extensions.getExtensions(BeforeRunTaskProvider.EXTENSION_POINT_NAME, - runConfiguration.getProject()); - myStepsPanel.removeAll(); - if (runConfiguration instanceof UnknownRunConfiguration) { - myStepsPanel.setVisible(false); - } - else { - List stepsRows = new ArrayList(); - for (BeforeRunTaskProvider provider : providers) { - final BeforeRunTask task = myStepsBeforeLaunch.get(provider.getId()); - if (task != null) { - final StepBeforeLaunchRow stepRow = new StepBeforeLaunchRow(runConfiguration, provider, task); - myStepBeforeLaunchRows.put(provider.getId(), stepRow); - stepsRows.add(stepRow); - } - } - - int maxStepRowWidth = 0; - for (StepBeforeLaunchRow stepRow : stepsRows) { - maxStepRowWidth = Math.max(maxStepRowWidth, stepRow.getPreferredSize().width); - } - if (maxStepRowWidth * 3 < getComponent().getPreferredSize().width || maxStepRowWidth < 200) { - myStepsPanel.setLayout(new GridLayout(0, 3, UIUtil.DEFAULT_HGAP, UIUtil.DEFAULT_VGAP)); - } else if (maxStepRowWidth * 2 < getComponent().getPreferredSize().width || maxStepRowWidth < 300) { - myStepsPanel.setLayout(new GridLayout(0, 2, UIUtil.DEFAULT_HGAP, UIUtil.DEFAULT_VGAP)); - } else { - myStepsPanel.setLayout(new GridLayout(0, 1, UIUtil.DEFAULT_HGAP, UIUtil.DEFAULT_VGAP)); - } - for (StepBeforeLaunchRow stepRow : stepsRows) { - myStepsPanel.add(stepRow); - } - } - - myEditBeforeRun = settings.isEditBeforeRun(); - myShowSettingsBeforeRunCheckBox = new JCheckBox(ExecutionBundle.message("configuration.edit.before.run")); - myShowSettingsBeforeRunCheckBox.setEnabled(!(runConfiguration instanceof UnknownRunConfiguration)); - myShowSettingsBeforeRunCheckBox.setSelected(myEditBeforeRun); - myShowSettingsBeforeRunCheckBox.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - myEditBeforeRun = myShowSettingsBeforeRunCheckBox.isSelected(); - } - }); - myShowSettingsBeforeRunCheckBox.setVisible(!settings.isTemplate()); - myStepsPanel.add(myShowSettingsBeforeRunCheckBox); + myBeforeRunStepsPanel.doReset(settings); + myBeforeLaunchContainer.setVisible(!(runConfiguration instanceof UnknownRunConfiguration)); myStoreProjectConfiguration = runManager.isConfigurationShared(settings); myCbStoreProjectConfiguration.setEnabled(!(runConfiguration instanceof UnknownRunConfiguration)); @@ -141,15 +88,10 @@ public class ConfigurationSettingsEditorWrapper extends SettingsEditor key) { - myStepBeforeLaunchRows.get(key).update(myStepsBeforeLaunch.get(key)); - } - protected void disposeEditor() { } @@ -172,71 +114,22 @@ public class ConfigurationSettingsEditorWrapper extends SettingsEditor, BeforeRunTask> getStepsBeforeLaunch() { - return Collections.unmodifiableMap(myStepsBeforeLaunch); + public List getStepsBeforeLaunch() { + return Collections.unmodifiableList(myBeforeRunStepsPanel.getTasks(false)); } public boolean isStoreProjectConfiguration() { return myStoreProjectConfiguration; } - private class StepBeforeLaunchRow extends JPanel { - private final JCheckBox myCheckBox; - private FixedSizeButton myButton; - private final RunConfiguration myRunConfiguration; - private final BeforeRunTaskProvider myProvider; - - public StepBeforeLaunchRow(final RunConfiguration runConfiguration, final BeforeRunTaskProvider provider, - final BeforeRunTask beforeRunTask) { - super(new GridBagLayout()); - myRunConfiguration = runConfiguration; - myProvider = provider; - final boolean isChecked = beforeRunTask.isEnabled(); - myCheckBox = new JCheckBox(provider.getDescription(runConfiguration, beforeRunTask), isChecked); - GridBagConstraints gc = new GridBagConstraints(GridBagConstraints.RELATIVE, 0 , 1, 1, 0, 1, GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(0,0,0,0), 0, 0); - add(myCheckBox, gc); - gc.weightx = 1; - if (provider.hasConfigurationButton()) { - myButton = new FixedSizeButton(20); - add(myButton, gc); - - myButton.addActionListener(new ActionListener() { - public void actionPerformed(ActionEvent e) { - if (provider.configureTask(runConfiguration, beforeRunTask)) { - myCheckBox.setText(provider.getDescription(runConfiguration, beforeRunTask)); - fireEditorStateChanged(); - } - } - }); - } - else { - add(Box.createHorizontalBox(), gc); - } - enableSettings(beforeRunTask); - myCheckBox.addActionListener(new ActionListener() { - public void actionPerformed(ActionEvent e) { - beforeRunTask.setEnabled(myCheckBox.isSelected()); - enableSettings(beforeRunTask); - } - }); - } - - private void enableSettings(final BeforeRunTask task) { - if (myButton != null) { - myButton.setEnabled(myCheckBox.isSelected()); - } - myCheckBox.setText(myProvider.getDescription(myRunConfiguration, task)); - } - - public void update(BeforeRunTask task) { - myCheckBox.setSelected(task.isEnabled()); - enableSettings(task); - } + @Override + public void fireStepsBeforeRunChanged() { + fireEditorStateChanged(); } private class MyDataProvider implements TypeSafeDataProvider { diff --git a/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java b/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java index d2672ff88fc1..f15e9fa2c222 100644 --- a/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java +++ b/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java @@ -31,7 +31,6 @@ import com.intellij.openapi.actionSystem.impl.SimpleDataContext; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.components.ProjectComponent; import com.intellij.openapi.diagnostic.Logger; -import com.intellij.openapi.extensions.Extensions; import com.intellij.openapi.project.DumbService; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Disposer; @@ -41,9 +40,7 @@ import org.jetbrains.annotations.Nullable; import javax.swing.*; import java.util.ArrayList; -import java.util.LinkedHashMap; import java.util.List; -import java.util.Map; /** * @author dyoma @@ -99,24 +96,25 @@ public class ExecutionManagerImpl extends ExecutionManager implements ProjectCom final RunConfiguration runConfiguration = (RunConfiguration)configuration; final RunManagerImpl runManager = RunManagerImpl.getInstanceImpl(myProject); - final Map, BeforeRunTask> activeProviders = new LinkedHashMap, BeforeRunTask>(); - for (final BeforeRunTaskProvider provider : Extensions.getExtensions(BeforeRunTaskProvider.EXTENSION_POINT_NAME, myProject)) { - final BeforeRunTask task = runManager.getBeforeRunTask(runConfiguration, provider.getId()); - if (task != null && task.isEnabled()) { - activeProviders.put(provider, task); + final List activeTasks = new ArrayList(); + final List tasks = runManager.getBeforeRunTasks(runConfiguration); + for (BeforeRunTask task : tasks) { + if (task != null && task.isEnabled()) { + activeTasks.add(task); + } } - } ConfigurationPerRunnerSettings configurationSettings = state != null ? state.getConfigurationSettings() : null; final DataContext projectContext = SimpleDataContext.getProjectContext(myProject); final DataContext dataContext = configurationSettings != null ? SimpleDataContext .getSimpleContext(BeforeRunTaskProvider.RUNNER_ID, configurationSettings.getRunnerId(), projectContext) : projectContext; - if (!activeProviders.isEmpty()) { + if (!activeTasks.isEmpty()) { ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { public void run() { - for (BeforeRunTaskProvider provider : activeProviders.keySet()) { - if(!provider.executeTask(dataContext, runConfiguration, activeProviders.get(provider))) { + for (BeforeRunTask task : activeTasks) { + BeforeRunTaskProvider provider = BeforeRunTaskProvider.getProvider(myProject, task.getProviderId()); + if(provider != null && !provider.executeTask(dataContext, runConfiguration, task)) { if (onCancelRunnable != null) { SwingUtilities.invokeLater(onCancelRunnable); } diff --git a/platform/lang-impl/src/com/intellij/execution/impl/RunConfigurable.java b/platform/lang-impl/src/com/intellij/execution/impl/RunConfigurable.java index 4963327c22db..8eea1482dfaf 100644 --- a/platform/lang-impl/src/com/intellij/execution/impl/RunConfigurable.java +++ b/platform/lang-impl/src/com/intellij/execution/impl/RunConfigurable.java @@ -33,7 +33,6 @@ import com.intellij.openapi.ui.popup.PopupStep; import com.intellij.openapi.ui.popup.util.BaseListPopupStep; import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.IconLoader; -import com.intellij.openapi.util.Key; import com.intellij.openapi.wm.IdeFocusManager; import com.intellij.ui.*; import com.intellij.ui.components.JBScrollPane; @@ -65,6 +64,7 @@ import java.awt.event.ActionListener; import java.awt.event.KeyEvent; import java.net.URL; import java.util.*; +import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -895,7 +895,7 @@ class RunConfigurable extends BaseConfigurable { }); final ListPopup popup = popupFactory.createListPopup(new BaseListPopupStep( - ExecutionBundle.message("add.new.run.configuration.acrtion.name"), configurationTypes) { + ExecutionBundle.message("add.new.run.configuration.acrtion.name"), configurationTypes) { @NotNull public String getTextFor(final ConfigurationType type) { @@ -953,7 +953,7 @@ class RunConfigurable extends BaseConfigurable { } }); return new BaseListPopupStep( - ExecutionBundle.message("add.new.run.configuration.action.name", type.getDisplayName()), factories) { + ExecutionBundle.message("add.new.run.configuration.action.name", type.getDisplayName()), factories) { @NotNull public String getTextFor(final ConfigurationFactory value) { @@ -1168,15 +1168,15 @@ class RunConfigurable extends BaseConfigurable { private static class RunConfigurationBean { private final RunnerAndConfigurationSettings mySettings; private final boolean myShared; - private final Map, BeforeRunTask> myStepsBeforeLaunch; + private final List myStepsBeforeLaunch; private final SingleConfigurationConfigurable myConfigurable; public RunConfigurationBean(final RunnerAndConfigurationSettings settings, final boolean shared, - final Map, BeforeRunTask> stepsBeforeLaunch) { + final List stepsBeforeLaunch) { mySettings = settings; myShared = shared; - myStepsBeforeLaunch = Collections.unmodifiableMap(stepsBeforeLaunch); + myStepsBeforeLaunch = Collections.unmodifiableList(stepsBeforeLaunch); myConfigurable = null; } @@ -1196,7 +1196,7 @@ class RunConfigurable extends BaseConfigurable { return myShared; } - public Map, BeforeRunTask> getStepsBeforeLaunch() { + public List getStepsBeforeLaunch() { return myStepsBeforeLaunch; } diff --git a/platform/lang-impl/src/com/intellij/execution/impl/RunConfigurationBeforeRunProvider.java b/platform/lang-impl/src/com/intellij/execution/impl/RunConfigurationBeforeRunProvider.java new file mode 100644 index 000000000000..5aa825b75ca8 --- /dev/null +++ b/platform/lang-impl/src/com/intellij/execution/impl/RunConfigurationBeforeRunProvider.java @@ -0,0 +1,347 @@ +/* + * 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.execution.ui.RunContentDescriptor; +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.IconLoader; +import com.intellij.openapi.util.Key; +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.util.ArrayList; +import java.util.Collection; +import java.util.Iterator; +import java.util.List; + +/** + * @author Vassiliy Kudryashov + */ +public class RunConfigurationBeforeRunProvider +extends BeforeRunTaskProvider { + private static final Icon ICON = IconLoader.getIcon("/actions/execute.png"); + + public static final Key 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 getId() { + return ID; + } + + @Override + public Icon getIcon() { + return ICON; + } + + @Override + public Icon getTaskIcon(RunConfigurableBeforeRunTask task) { + if (task.getSettings() == null) + return null; + return ProgramRunnerUtil.getConfigurationIcon(myProject, 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 + public RunConfigurableBeforeRunTask createTask(RunConfiguration runConfiguration) { + return new RunConfigurableBeforeRunTask(); + } + + @Override + public boolean configureTask(RunConfiguration runConfiguration, RunConfigurableBeforeRunTask task) { + final RunManagerImpl runManager = RunManagerImpl.getInstanceImpl(runConfiguration.getProject()); + + final ArrayList configurations + = new ArrayList(runManager.getSortedConfigurations()); + String executorId = DefaultRunExecutor.getRunExecutorInstance().getId(); + for (Iterator iterator = configurations.iterator(); iterator.hasNext();) { + RunnerAndConfigurationSettings settings = iterator.next(); + final ProgramRunner runner = ProgramRunnerUtil.getRunner(executorId, settings); + if (runner == null) + iterator.remove(); + } + + SelectionDialog dialog = + new SelectionDialog(task.getSettings(), configurations); + dialog.show(); + RunnerAndConfigurationSettings settings = dialog.getSelectedSettings(); + if (settings != null) { + task.setSettings(settings); + return true; + } + else { + return false; + } + } + + @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; + final ExecutionEnvironment environment = new ExecutionEnvironment(runner, settings, myProject); + return runner.canRun(executorId, environment.getRunProfile()); + } + + @Override + public boolean executeTask(final DataContext dataContext, RunConfiguration configuration, RunConfigurableBeforeRunTask task) { + RunnerAndConfigurationSettings settings = task.getSettings(); + if (settings == null) { + return false; + } + final Executor executor = DefaultRunExecutor.getRunExecutorInstance(); + String executorId = executor.getId(); + final ProgramRunner runner = ProgramRunnerUtil.getRunner(executorId, settings); + if (runner == null) + return false; + final ExecutionEnvironment environment = new ExecutionEnvironment(runner, settings, myProject); + if (!runner.canRun(executorId, environment.getRunProfile())) { + return false; + } + else { + final Semaphore targetDone = new Semaphore(); + final boolean[] result = new boolean[1]; + try { + ApplicationManager.getApplication().invokeAndWait(new Runnable() { + + public void run() { + targetDone.down(); + try { + runner.execute(executor, environment, new ProgramRunner.Callback() { + @Override + public void processStarted(RunContentDescriptor descriptor) { + ProcessHandler processHandler = descriptor != null ? descriptor.getProcessHandler() : null; + if (processHandler != null) { + processHandler.addProcessListener(new ProcessAdapter() { + @Override + public void processTerminated(ProcessEvent event) { + result[0] = event.getExitCode() == 0; + targetDone.up(); + } + }); + } + } + }); + } + catch (ExecutionException e) { + LOG.error(e); + } + } + }, ModalityState.NON_MODAL); + } + catch (Exception e) { + LOG.error(e); + return false; + } + targetDone.waitFor(); + return result[0]; + } + } + + class RunConfigurableBeforeRunTask extends BeforeRunTask { + 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 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 mySettings; + private JBList myJBList; + + private SelectionDialog(RunnerAndConfigurationSettings selectedSettings, @NotNull List settings) { + super(myProject); + setTitle("Choose Configuration to Execute"); + mySelectedSettings = selectedSettings; + mySettings = settings; + init(); + myJBList.setSelectedValue(mySelectedSettings, true); + } + + @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(), runManager.isTemporary(configuration) + ? SimpleTextAttributes.GRAY_ATTRIBUTES + : SimpleTextAttributes.REGULAR_ATTRIBUTES); + } + } + }); + return new JBScrollPane(myJBList); + } + + @Nullable + RunnerAndConfigurationSettings getSelectedSettings() { + return mySelectedSettings; + } + } +} diff --git a/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java b/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java index 1bebd81a8414..0061cdad34f7 100644 --- a/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java +++ b/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java @@ -48,11 +48,7 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, private final Map myConfigurations = new LinkedHashMap(); // template configurations are not included here private final Map mySharedConfigurations = new TreeMap(); - /** - * configurationID -> [BeforeTaskProviderName->BeforeRunTask] - */ - private final Map, BeforeRunTask>> myConfigurationToBeforeTasksMap = - new WeakHashMap, BeforeRunTask>>(); + private final Map> myConfigurationToBeforeTasksMap = new WeakHashMap>(); // When readExternal not all configuration may be loaded, so we need to remember the selected configuration // so that when it is eventually loaded, we can mark is as a selected. @@ -244,7 +240,7 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, public void addConfiguration(RunnerAndConfigurationSettings settings, boolean shared, - Map, BeforeRunTask> tasks) { + List tasks) { final RunConfiguration configuration = settings.getConfiguration(); Integer existingId = findConfigurationIdByUniqueName(getUniqueName(settings)); @@ -441,35 +437,12 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, ((RunnerAndConfigurationSettingsImpl)settings).writeExternal(configurationElement); if (!(settings.getConfiguration() instanceof UnknownRunConfiguration)) { - final Map, BeforeRunTask> tasks = getBeforeRunTasks(settings.getConfiguration()); - Map, BeforeRunTask> templateTasks; - if (!settings.isTemplate()) { - final RunnerAndConfigurationSettings templateSettings = getConfigurationTemplate(settings.getFactory()); - templateTasks = getBeforeRunTasks(templateSettings.getConfiguration()); - } - else { - templateTasks = null; - } - final List> order = new ArrayList>(tasks.keySet()); - Collections.sort(order, new Comparator>() { - public int compare(Key o1, Key o2) { - return o1.toString().compareToIgnoreCase(o2.toString()); - } - }); + final List tasks = getBeforeRunTasks(settings.getConfiguration()); final Element methodsElement = new Element(METHOD); - for (Key providerID : order) { - final BeforeRunTask beforeRunTask = tasks.get(providerID); - - if (templateTasks != null) { - final BeforeRunTask templateTask = templateTasks.get(providerID); - if (beforeRunTask.equals(templateTask)) { - continue; // not neccesary saving if the task is the same as template - } - } - + for (BeforeRunTask task : tasks) { final Element child = new Element(OPTION); - child.setAttribute(NAME_ATTR, providerID.toString()); - beforeRunTask.writeExternal(child); + child.setAttribute(NAME_ATTR, task.getProviderId().toString()); + task.writeExternal(child); methodsElement.addContent(child); } configurationElement.addContent(methodsElement); @@ -575,13 +548,13 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, } final Element methodsElement = element.getChild(METHOD); - final Map, BeforeRunTask> map = readStepsBeforeRun(methodsElement, settings); + final List tasks = readStepsBeforeRun(methodsElement, settings); if (settings.isTemplate()) { myTemplateConfigurationsMap.put(factory.getType().getId() + "." + factory.getName(), settings); - setBeforeRunTasks(settings.getConfiguration(), map); + setBeforeRunTasks(settings.getConfiguration(), tasks); } else { - addConfiguration(settings, isShared, map); + addConfiguration(settings, isShared, tasks); if (Boolean.valueOf(element.getAttributeValue(SELECTED_ATTR)).booleanValue()) { //to support old style setSelectedConfiguration(settings); } @@ -590,9 +563,8 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, } @NotNull - private Map, BeforeRunTask> readStepsBeforeRun(final Element child, - RunnerAndConfigurationSettings settings) { - final Map, BeforeRunTask> map = new HashMap, BeforeRunTask>(); + private List readStepsBeforeRun(final Element child, RunnerAndConfigurationSettings settings) { + final List result = new ArrayList(); if (child != null) { for (Object o : child.getChildren(OPTION)) { final Element methodElement = (Element)o; @@ -602,11 +574,11 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, final BeforeRunTask beforeRunTask = provider.createTask(settings.getConfiguration()); if (beforeRunTask != null) { beforeRunTask.readExternal(methodElement); - map.put(id, beforeRunTask); + result.add(beforeRunTask); } } } - return map; + return result; } @@ -730,22 +702,27 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, return shared != null && shared.booleanValue(); } - public Collection getBeforeRunTasks(Key taskProviderID, boolean includeOnlyActiveTasks) { - final Collection tasks = new ArrayList(); + @NotNull + public List getBeforeRunTasks(Key taskProviderID, boolean includeOnlyActiveTasks) { + final List tasks = new ArrayList(); if (includeOnlyActiveTasks) { - final Set checkedTemplates = new HashSet(); + final List checkedTemplates = new ArrayList(); for (RunnerAndConfigurationSettings settings : myConfigurations.values()) { - final BeforeRunTask runTask = getBeforeRunTask(settings.getConfiguration(), taskProviderID); - if (runTask != null && runTask.isEnabled()) { - tasks.add((T)runTask); - } - else { - final RunnerAndConfigurationSettings template = getConfigurationTemplate(settings.getFactory()); - if (!checkedTemplates.contains(template)) { - checkedTemplates.add(template); - final BeforeRunTask templateTask = getBeforeRunTask(template.getConfiguration(), taskProviderID); - if (templateTask != null && templateTask.isEnabled()) { - tasks.add((T)templateTask); + final List runTasks = getBeforeRunTasks(settings.getConfiguration()); + for (BeforeRunTask task : runTasks) { + if (task != null && task.isEnabled() && task.getProviderId() == taskProviderID) { + tasks.add((T)task); + } + else { + final RunnerAndConfigurationSettings template = getConfigurationTemplate(settings.getFactory()); + if (!checkedTemplates.contains(template)) { + checkedTemplates.add(template); + final List templateTasks = getBeforeRunTasks(template.getConfiguration()); + for (BeforeRunTask templateTask : templateTasks) { + if (templateTask != null && templateTask.isEnabled() && templateTask.getProviderId() == taskProviderID) { + tasks.add((T)templateTask); + } + } } } } @@ -753,15 +730,17 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, } else { for (RunnerAndConfigurationSettings settings : myTemplateConfigurationsMap.values()) { - final T task = getBeforeRunTask(settings.getConfiguration(), taskProviderID); - if (task != null) { - tasks.add(task); + final List tasks_ = getBeforeRunTasks(settings.getConfiguration()); + for (BeforeRunTask task : tasks_) { + if (task != null && task.getProviderId() == taskProviderID) + tasks.add((T)task); } } for (RunnerAndConfigurationSettings settings : myConfigurations.values()) { - final T task = getBeforeRunTask(settings.getConfiguration(), taskProviderID); - if (task != null) { - tasks.add(task); + final List tasks_ = getBeforeRunTasks(settings.getConfiguration()); + for (BeforeRunTask task : tasks_) { + if (task != null && task.getProviderId() == taskProviderID) + tasks.add((T)task); } } } @@ -811,49 +790,64 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, return null; } - @Nullable - public T getBeforeRunTask(RunConfiguration settings, Key taskProviderID) { - Map, BeforeRunTask> tasks = myConfigurationToBeforeTasksMap.get(settings); - if (tasks == null) { - tasks = getBeforeRunTasks(settings); - myConfigurationToBeforeTasksMap.put(settings, tasks); + @NotNull + @Override + public List getBeforeRunTasks(RunConfiguration settings, Key taskProviderID) { + List tasks = getBeforeRunTasks(settings); + List result = new ArrayList(); + for (BeforeRunTask task : tasks) { + if (task.getProviderId() == taskProviderID) + result.add((T)task); } - return (T)tasks.get(taskProviderID); + return result; } - public Map, BeforeRunTask> getBeforeRunTasks(final RunConfiguration settings) { - final Map, BeforeRunTask> tasks = myConfigurationToBeforeTasksMap.get(settings); + @NotNull + public List getBeforeRunTasks(final RunConfiguration settings) { + return getBeforeRunTasks(settings, false); + } + @NotNull + @Override + public List getBeforeRunTasks(RunConfiguration settings, boolean includeOnlyActiveTasks) { + final List tasks = myConfigurationToBeforeTasksMap.get(settings); if (tasks != null) { - final Map, BeforeRunTask> _tasks = new HashMap, BeforeRunTask>(); - for (Map.Entry, BeforeRunTask> entry : tasks.entrySet()) { - _tasks.put(entry.getKey(), entry.getValue().clone()); - } - return _tasks; + return getCopies(tasks, includeOnlyActiveTasks); } final RunnerAndConfigurationSettings template = getConfigurationTemplate(settings.getFactory()); - final Map, BeforeRunTask> templateTasks = myConfigurationToBeforeTasksMap.get(template.getConfiguration()); + final List templateTasks = myConfigurationToBeforeTasksMap.get(template.getConfiguration()); if (templateTasks != null) { - final Map, BeforeRunTask> _tasks = new HashMap, BeforeRunTask>(); - for (Map.Entry, BeforeRunTask> entry : templateTasks.entrySet()) { - _tasks.put(entry.getKey(), entry.getValue().clone()); - } - return _tasks; + return getCopies(templateTasks, includeOnlyActiveTasks); } - final Map, BeforeRunTask> _tasks = new HashMap, BeforeRunTask>(); + final List _tasks = new ArrayList(); for (BeforeRunTaskProvider provider : Extensions .getExtensions(BeforeRunTaskProvider.EXTENSION_POINT_NAME, myProject)) { BeforeRunTask task = provider.createTask(settings); if (task != null) { + if (includeOnlyActiveTasks && !task.isEnabled()) + continue; Key providerID = provider.getId(); - _tasks.put(providerID, task); + _tasks.add(task); settings.getFactory().configureBeforeRunTaskDefaults(providerID, task); } } return _tasks; } + @NotNull + private static List getCopies(List original, boolean includeOnlyActiveTasks) { + List result = new ArrayList(); + if (original != null) { + for (BeforeRunTask task : original) { + if (includeOnlyActiveTasks && !task.isEnabled()) + continue; + result.add(task.clone()); + } + } + return result; + } + public void shareConfiguration(final RunConfiguration runConfiguration, final boolean shareConfiguration) { RunnerAndConfigurationSettings settings = getSettings(runConfiguration); boolean shouldFire = settings != null && isConfigurationShared(settings) != shareConfiguration; @@ -864,14 +858,8 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, if (shouldFire) fireRunConfigurationChanged(settings); } - public final void setBeforeRunTasks(final RunConfiguration runConfiguration, Map, BeforeRunTask> tasks) { - final Map, BeforeRunTask> taskMap = getBeforeRunTasks(runConfiguration); - for (Map.Entry, BeforeRunTask> entry : tasks.entrySet()) { - //if (taskMap.containsKey(entry.getKey())) { - taskMap.put(entry.getKey(), entry.getValue()); - //} - } - myConfigurationToBeforeTasksMap.put(runConfiguration, taskMap); + public final void setBeforeRunTasks(final RunConfiguration runConfiguration, List tasks) { + myConfigurationToBeforeTasksMap.put(runConfiguration, tasks); fireBeforeRunTasksUpdated(); } @@ -881,7 +869,7 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, } public void addConfiguration(final RunnerAndConfigurationSettings settings, final boolean isShared) { - addConfiguration(settings, isShared, Collections., BeforeRunTask>emptyMap()); + addConfiguration(settings, isShared, new ArrayList()); } public static RunManagerImpl getInstanceImpl(final Project project) { @@ -958,8 +946,8 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, } private void initProviderMaps() { - myBeforeStepsMap = new HashMap, BeforeRunTaskProvider>(); - myProviderKeysMap = new HashMap>(); + myBeforeStepsMap = new LinkedHashMap, BeforeRunTaskProvider>(); + myProviderKeysMap = new LinkedHashMap>(); for (BeforeRunTaskProvider provider : Extensions .getExtensions(BeforeRunTaskProvider.EXTENSION_POINT_NAME, myProject)) { final Key id = provider.getId(); diff --git a/platform/lang-impl/src/com/intellij/execution/impl/RunnerAndConfigurationSettingsImpl.java b/platform/lang-impl/src/com/intellij/execution/impl/RunnerAndConfigurationSettingsImpl.java index 8cadadbb19d5..5f3116c907f2 100644 --- a/platform/lang-impl/src/com/intellij/execution/impl/RunnerAndConfigurationSettingsImpl.java +++ b/platform/lang-impl/src/com/intellij/execution/impl/RunnerAndConfigurationSettingsImpl.java @@ -368,7 +368,8 @@ public class RunnerAndConfigurationSettingsImpl implements JDOMExternalizable, C @Override public String toString() { - return getType() + ": " + getName(); + ConfigurationType type = getType(); + return (type != null ? type.getDisplayName() + ": " : "" ) + getName(); } private class InfoProvider implements ConfigurationInfoProvider { diff --git a/platform/lang-impl/src/com/intellij/execution/impl/UnknownBeforeRunTaskProvider.java b/platform/lang-impl/src/com/intellij/execution/impl/UnknownBeforeRunTaskProvider.java index 0b2a224ba23b..e5854b8bfccd 100644 --- a/platform/lang-impl/src/com/intellij/execution/impl/UnknownBeforeRunTaskProvider.java +++ b/platform/lang-impl/src/com/intellij/execution/impl/UnknownBeforeRunTaskProvider.java @@ -18,6 +18,7 @@ package com.intellij.execution.impl; import com.intellij.execution.BeforeRunTask; import com.intellij.execution.BeforeRunTaskProvider; +import com.intellij.execution.ExecutionBundle; import com.intellij.execution.configurations.RunConfiguration; import com.intellij.openapi.actionSystem.DataContext; import com.intellij.openapi.util.JDOMUtil; @@ -42,30 +43,42 @@ public class UnknownBeforeRunTaskProvider extends BeforeRunTaskProvider { private Element myConfig; - public UnknownTask() { + public UnknownTask(Key providerId) { + super(providerId); } public void readExternal(Element element) { diff --git a/platform/platform-api/src/com/intellij/ui/CollectionListModel.java b/platform/platform-api/src/com/intellij/ui/CollectionListModel.java index 1d48a44a0e3d..161529538472 100644 --- a/platform/platform-api/src/com/intellij/ui/CollectionListModel.java +++ b/platform/platform-api/src/com/intellij/ui/CollectionListModel.java @@ -50,6 +50,8 @@ public class CollectionListModel extends AbstractListModel { } public void add(@NotNull final List elements) { + if (elements.isEmpty()) + return; int i = myItems.size(); myItems.addAll(elements); fireIntervalAdded(this, i, i + elements.size() - 1); @@ -93,8 +95,7 @@ public class CollectionListModel extends AbstractListModel { } public void replaceAll(@NotNull final List elements) { - myItems.clear(); - myItems.addAll(elements); - fireIntervalAdded(this, 0, elements.size() - 1); + removeAll(); + add(elements); } } diff --git a/platform/platform-api/src/com/intellij/ui/ListUtil.java b/platform/platform-api/src/com/intellij/ui/ListUtil.java index 383a16e50a21..437988e1889f 100644 --- a/platform/platform-api/src/com/intellij/ui/ListUtil.java +++ b/platform/platform-api/src/com/intellij/ui/ListUtil.java @@ -168,9 +168,29 @@ public class ListUtil { if (model instanceof FilteringListModel) { return (DefaultListModel)((FilteringListModel)model).getOriginalModel(); } + if (model instanceof CollectionListModel) { + return getWrapperModel(((CollectionListModel)model)); + } return (DefaultListModel)model; } + private static DefaultListModel getWrapperModel(final CollectionListModel source) { + DefaultListModel model = new DefaultListModel() { + @Override + public Object set(int index, Object element) { + Object o = source.getElementAt(index); + source.setElementAt(element, index); + return o; + } + + @Override + public Object get(int index) { + return source.getElementAt(index); + } + }; + return model; + } + public static boolean canMoveSelectedItemsDown(JList list) { ListModel model = list.getModel(); int[] indices = list.getSelectedIndices(); diff --git a/platform/platform-api/src/com/intellij/ui/components/JBList.java b/platform/platform-api/src/com/intellij/ui/components/JBList.java index d511265209d9..e73b6c0558d9 100644 --- a/platform/platform-api/src/com/intellij/ui/components/JBList.java +++ b/platform/platform-api/src/com/intellij/ui/components/JBList.java @@ -22,6 +22,7 @@ import com.intellij.openapi.util.text.StringUtil; import com.intellij.ui.ComponentWithExpandableItems; import com.intellij.ui.ExpandableItemsHandler; import com.intellij.ui.ExpandableItemsHandlerFactory; +import com.intellij.ui.table.JBTable; import com.intellij.util.ArrayUtil; import com.intellij.util.NotNullFunction; import com.intellij.util.ui.AsyncProcessIcon; @@ -225,4 +226,15 @@ public class JBList extends JList implements ComponentWithEmptyText, ComponentWi public void disableEmptyText() { getEmptyText().setText(""); } + + public static class StripedListCellRenderer extends DefaultListCellRenderer { + @Override + public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) { + super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus); + if (!isSelected && index % 2 == 0) { + setBackground(JBTable.DECORATED_ROW_BG_COLOR); + } + return this; + } + } } diff --git a/platform/platform-api/src/com/intellij/ui/table/JBTable.java b/platform/platform-api/src/com/intellij/ui/table/JBTable.java index d221c9a91d72..f8265bea7c4b 100644 --- a/platform/platform-api/src/com/intellij/ui/table/JBTable.java +++ b/platform/platform-api/src/com/intellij/ui/table/JBTable.java @@ -41,7 +41,7 @@ import java.util.Comparator; import java.util.EventObject; public class JBTable extends JTable implements ComponentWithEmptyText, ComponentWithExpandableItems { - private static final Color DECORATED_ROW_BG_COLOR = new Color(242, 245, 249); + public static final Color DECORATED_ROW_BG_COLOR = new Color(242, 245, 249); private StatusText myEmptyText; private ExpandableItemsHandler myExpandableItemsHandler; diff --git a/platform/platform-impl/platform-impl.iml b/platform/platform-impl/platform-impl.iml index e505978e2610..11055551a29d 100644 --- a/platform/platform-impl/platform-impl.iml +++ b/platform/platform-impl/platform-impl.iml @@ -28,6 +28,7 @@ + diff --git a/platform/platform-resources-en/src/messages/ExecutionBundle.properties b/platform/platform-resources-en/src/messages/ExecutionBundle.properties index bb3a5443a359..425bf9a1b642 100644 --- a/platform/platform-resources-en/src/messages/ExecutionBundle.properties +++ b/platform/platform-resources-en/src/messages/ExecutionBundle.properties @@ -282,6 +282,10 @@ run.configuration.cannot.find.vm.executable=Cannot find VM executable logs.tab.title=Logs before.launch.panel.title=Before Launch +before.launch.panel.cyclic_dependency_warning=''{0}'' has already configured to be launched before {1}.\nSuch cyclic dependencies are not allowed. +before.launch.run.another.configuration=Run another Configuration +before.launch.run.certain.configuration=Run ''{0}'' +before.launch.run.unknown.task=Unknown task action.name.save.as.configuration=Save As default.junit.config.name.all.in.module=All in {0} default.junit.config.name.all.in.package.in.module={0} in {1} diff --git a/platform/testFramework/src/com/intellij/mock/MockRunManager.java b/platform/testFramework/src/com/intellij/mock/MockRunManager.java index cb751f32d734..26cfb96470ab 100644 --- a/platform/testFramework/src/com/intellij/mock/MockRunManager.java +++ b/platform/testFramework/src/com/intellij/mock/MockRunManager.java @@ -10,7 +10,7 @@ import org.jetbrains.annotations.NotNull; import javax.swing.*; import java.util.Collection; import java.util.Collections; -import java.util.Map; +import java.util.List; /** * @author gregsh @@ -100,9 +100,7 @@ public class MockRunManager extends RunManagerEx { } @Override - public void addConfiguration(RunnerAndConfigurationSettings settings, - boolean isShared, - Map, BeforeRunTask> tasks) { + public void addConfiguration(RunnerAndConfigurationSettings settings, boolean isShared, List tasks) { } @Override @@ -116,19 +114,26 @@ public class MockRunManager extends RunManagerEx { @NotNull @Override - public Map, BeforeRunTask> getBeforeRunTasks(RunConfiguration settings) { - return Collections.emptyMap(); - } - - @Override - public T getBeforeRunTask(RunConfiguration settings, Key taskProviderID) { + public List getBeforeRunTasks(RunConfiguration settings) { return null; } @NotNull @Override - public Collection getBeforeRunTasks(Key taskProviderID, boolean includeOnlyActiveTasks) { - return null; + public List getBeforeRunTasks(RunConfiguration settings, boolean includeOnlyActiveTasks) { + return Collections.emptyList(); + } + + @NotNull + @Override + public List getBeforeRunTasks(Key taskProviderID, boolean includeOnlyActiveTasks) { + return Collections.emptyList(); + } + + @NotNull + @Override + public List getBeforeRunTasks(RunConfiguration settings, Key taskProviderID) { + return Collections.emptyList(); } @Override diff --git a/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTask.java b/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTask.java index 136f49bfce28..da5fe11c2bc6 100644 --- a/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTask.java +++ b/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTask.java @@ -26,10 +26,14 @@ import org.jdom.Element; * @author Eugene Zhuravlev * Date: May 18, 2009 */ -public class AntBeforeRunTask extends BeforeRunTask{ +public class AntBeforeRunTask extends BeforeRunTask{ private String myTargetName; private String myAntFileUrl; + public AntBeforeRunTask() { + super(AntBeforeRunTaskProvider.ID); + } + public String getAntFileUrl() { return myAntFileUrl; } diff --git a/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTaskProvider.java b/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTaskProvider.java index 07b5fc38134c..98086d0298a5 100644 --- a/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTaskProvider.java +++ b/plugins/ant/src/com/intellij/lang/ant/config/impl/AntBeforeRunTaskProvider.java @@ -19,6 +19,7 @@ import com.intellij.execution.BeforeRunTaskProvider; import com.intellij.execution.RunManagerEx; import com.intellij.execution.configurations.RunConfiguration; import com.intellij.lang.ant.AntBundle; +import com.intellij.lang.ant.AntIcons; import com.intellij.lang.ant.config.AntBuildFile; import com.intellij.lang.ant.config.AntBuildTarget; import com.intellij.lang.ant.config.AntConfiguration; @@ -29,6 +30,8 @@ import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.vfs.VirtualFileManager; import org.jetbrains.annotations.Nullable; +import javax.swing.*; + /** * @author Vladislav.Kaznacheev */ @@ -38,13 +41,31 @@ public class AntBeforeRunTaskProvider extends BeforeRunTaskProvider getId() { return ID; } - public String getDescription(final RunConfiguration runConfiguration, AntBeforeRunTask task) { + @Override + public String getName() { + return AntBundle.message("ant.target.before.run.description.empty"); + } + + @Override + public Icon getIcon() { + return AntIcons.ANT_TARGET_ICON; + } + + @Override + public Icon getTaskIcon(AntBeforeRunTask task) { + AntBuildTarget antTarget = findTargetToExecute(task); + return antTarget instanceof MetaTarget ? AntIcons.ANT_META_TARGET_ICON : AntIcons.ANT_TARGET_ICON; + } + + @Override + public String getDescription(AntBeforeRunTask task) { final String targetName = task.getTargetName(); if (targetName == null && !task.isEnabled()) { return AntBundle.message("ant.target.before.run.description.empty"); @@ -52,7 +73,7 @@ public class AntBeforeRunTaskProvider extends BeforeRunTaskProvider"); } - public boolean hasConfigurationButton() { + public boolean isConfigurable() { return true; } @@ -80,6 +101,11 @@ public class AntBeforeRunTaskProvider extends BeforeRunTaskProvider tasks = runManager.getBeforeRunTasks(configuration, AntBeforeRunTaskProvider.ID); + if (!tasks.isEmpty()) { + AntBeforeRunTask task = tasks.get(0);//This is legacy code, we had only one task that time task.setEnabled(true); task.setTargetName(targetName); task.setAntFileUrl(buildFileUrl); @@ -847,8 +848,9 @@ public class AntConfigurationImpl extends AntConfigurationBase implements Persis else { for (ConfigurationFactory factory : type.getConfigurationFactories()) { final RunConfiguration template = runManager.getConfigurationTemplate(factory).getConfiguration(); - final AntBeforeRunTask task = runManager.getBeforeRunTask(template, AntBeforeRunTaskProvider.ID); - if (task != null) { + final List tasks = runManager.getBeforeRunTasks(template, AntBeforeRunTaskProvider.ID); + if (!tasks.isEmpty()) { + AntBeforeRunTask task = tasks.get(0);//This is legacy code, we had only one task that time task.setEnabled(true); task.setTargetName(targetName); task.setAntFileUrl(buildFileUrl); diff --git a/plugins/ant/src/com/intellij/lang/ant/refactoring/AntTargetRenameListenerProvider.java b/plugins/ant/src/com/intellij/lang/ant/refactoring/AntTargetRenameListenerProvider.java index 69f318afa946..c1a290f43902 100644 --- a/plugins/ant/src/com/intellij/lang/ant/refactoring/AntTargetRenameListenerProvider.java +++ b/plugins/ant/src/com/intellij/lang/ant/refactoring/AntTargetRenameListenerProvider.java @@ -17,10 +17,10 @@ package com.intellij.lang.ant.refactoring; import com.intellij.execution.BeforeRunTaskProvider; import com.intellij.lang.ant.config.AntConfiguration; +import com.intellij.lang.ant.config.impl.AntBeforeRunTask; import com.intellij.lang.ant.config.impl.AntBeforeRunTaskProvider; import com.intellij.lang.ant.config.impl.AntConfigurationImpl; import com.intellij.lang.ant.psi.AntTarget; -import com.intellij.openapi.extensions.Extensions; import com.intellij.openapi.util.Comparing; import com.intellij.psi.PsiElement; import com.intellij.refactoring.listeners.RefactoringElementListener; @@ -45,11 +45,10 @@ public class AntTargetRenameListenerProvider implements RefactoringElementListen final AntConfiguration configuration = AntConfiguration.getInstance(newElement.getProject()); ((AntConfigurationImpl)configuration).handleTargetRename(oldName, newName); - for (BeforeRunTaskProvider provider : Extensions.getExtensions(AntBeforeRunTaskProvider.EXTENSION_POINT_NAME, newElement.getProject())) { - if (AntBeforeRunTaskProvider.ID.equals(provider.getId())) { - ((AntBeforeRunTaskProvider)provider).handleTargetRename(oldName, newName); - break; - } + BeforeRunTaskProvider provider = + BeforeRunTaskProvider.getProvider(newElement.getProject(), AntBeforeRunTaskProvider.ID); + if (provider instanceof AntBeforeRunTaskProvider) { + ((AntBeforeRunTaskProvider)provider).handleTargetRename(oldName, newName); } } } diff --git a/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleScriptType.java b/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleScriptType.java index 2297c829b253..f10f3ab0505e 100644 --- a/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleScriptType.java +++ b/plugins/gradle/src/org/jetbrains/plugins/gradle/config/GradleScriptType.java @@ -60,6 +60,7 @@ import javax.swing.*; import java.io.File; import java.io.IOException; import java.util.Collection; +import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -97,10 +98,10 @@ public class GradleScriptType extends GroovyScriptType { configuration.setName(configuration.getName() + "." + target); } - final CompileStepBeforeRun.MakeBeforeRunTask runTask = - RunManagerEx.getInstanceEx(file.getProject()).getBeforeRunTask(configuration, CompileStepBeforeRun.ID); - if (runTask != null) { - runTask.setEnabled(false); + final List runTasks = + RunManagerEx.getInstanceEx(file.getProject()).getBeforeRunTasks(configuration, CompileStepBeforeRun.ID); + for (CompileStepBeforeRun.MakeBeforeRunTask task : runTasks) { + task.setEnabled(false); } } diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/gant/GantScriptType.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/gant/GantScriptType.java index faac54dbab44..104a076eb411 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/gant/GantScriptType.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/gant/GantScriptType.java @@ -96,10 +96,10 @@ public class GantScriptType extends GroovyScriptType { configuration.setScriptParameters(target); configuration.setName(configuration.getName() + "." + target); } - final CompileStepBeforeRun.MakeBeforeRunTask runTask = - RunManagerEx.getInstanceEx(file.getProject()).getBeforeRunTask(configuration, CompileStepBeforeRun.ID); - if (runTask != null) { - runTask.setEnabled(false); + final List runTasks = + RunManagerEx.getInstanceEx(file.getProject()).getBeforeRunTasks(configuration, CompileStepBeforeRun.ID); + for (CompileStepBeforeRun.MakeBeforeRunTask task : runTasks) { + task.setEnabled(false); } } diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/mvc/MvcFramework.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/mvc/MvcFramework.java index 4fdb8e73bc98..c30348f74347 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/mvc/MvcFramework.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/mvc/MvcFramework.java @@ -353,9 +353,9 @@ public abstract class MvcFramework { runManager.addConfiguration(runSettings, false); runManager.setActiveConfiguration(runSettings); - final CompileStepBeforeRun.MakeBeforeRunTask runTask = runManager.getBeforeRunTask(configuration, CompileStepBeforeRun.ID); - if (runTask != null) { - runTask.setEnabled(false); + final List runTasks = runManager.getBeforeRunTasks(configuration, CompileStepBeforeRun.ID); + for (CompileStepBeforeRun.MakeBeforeRunTask task : runTasks) { + task.setEnabled(false); } } diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenBeforeRunTask.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenBeforeRunTask.java index d6be660fba56..8a77eb8ac382 100644 --- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenBeforeRunTask.java +++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenBeforeRunTask.java @@ -20,16 +20,12 @@ import com.intellij.openapi.util.io.FileUtil; import org.jdom.Element; import org.jetbrains.idea.maven.project.MavenProject; -public class MavenBeforeRunTask extends BeforeRunTask { +public class MavenBeforeRunTask extends BeforeRunTask { private String myProjectPath; private String myGoal; public MavenBeforeRunTask() { - } - - public MavenBeforeRunTask(String projectPath, String goal) { - myProjectPath = projectPath; - myGoal = goal; + super(MavenBeforeRunTasksProvider.ID); } public String getProjectPath() { diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenBeforeRunTasksProvider.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenBeforeRunTasksProvider.java index 8d2d85409c13..1bf7c920fa8d 100644 --- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenBeforeRunTasksProvider.java +++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/MavenBeforeRunTasksProvider.java @@ -36,12 +36,14 @@ import org.jetbrains.idea.maven.execution.MavenRunnerParameters; import org.jetbrains.idea.maven.navigator.SelectMavenGoalDialog; import org.jetbrains.idea.maven.project.MavenProject; import org.jetbrains.idea.maven.project.MavenProjectsManager; +import org.jetbrains.idea.maven.utils.MavenIcons; import org.jetbrains.idea.maven.utils.MavenLog; +import javax.swing.*; import java.util.Collections; public class MavenBeforeRunTasksProvider extends BeforeRunTaskProvider { - public static final Key TASK_ID = Key.create("Maven.BeforeRunTask"); + public static final Key ID = Key.create("Maven.BeforeRunTask"); private final Project myProject; public MavenBeforeRunTasksProvider(Project project) { @@ -49,10 +51,21 @@ public class MavenBeforeRunTasksProvider extends BeforeRunTaskProvider getId() { - return TASK_ID; + return ID; } - public String getDescription(RunConfiguration runConfiguration, MavenBeforeRunTask task) { + @Override + public String getName() { + return TasksBundle.message("maven.tasks.before.run.empty"); + } + + @Override + public Icon getIcon() { + return MavenIcons.MAVEN_ICON; + } + + @Override + public String getDescription(MavenBeforeRunTask task) { String desc = null; if (task.isEnabled()) { Pair projectAndGoal = getProjectAndGoalChecked(task); @@ -77,7 +90,7 @@ public class MavenBeforeRunTasksProvider extends BeforeRunTaskProvider getTaskID() { - return MavenBeforeRunTasksProvider.TASK_ID; + return MavenBeforeRunTasksProvider.ID; } @Override diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/actions/ToggleBeforeRunTaskAction.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/actions/ToggleBeforeRunTaskAction.java index d73fc3f02d71..62949c591b88 100644 --- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/actions/ToggleBeforeRunTaskAction.java +++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/tasks/actions/ToggleBeforeRunTaskAction.java @@ -40,7 +40,7 @@ public class ToggleBeforeRunTaskAction extends MavenToggleAction { final DataContext context = e.getDataContext(); final Pair desc = getTaskDesc(context); if (desc != null) { - for (MavenBeforeRunTask each : getRunManager(context).getBeforeRunTasks(MavenBeforeRunTasksProvider.TASK_ID, true)) { + for (MavenBeforeRunTask each : getRunManager(context).getBeforeRunTasks(MavenBeforeRunTasksProvider.ID, true)) { if (each.isEnabled() && each.isFor(desc.first, desc.second)) return true; } } diff --git a/resources-en/src/messages/CompilerBundle.properties b/resources-en/src/messages/CompilerBundle.properties index bcac3fc731f1..03756dd9ce92 100644 --- a/resources-en/src/messages/CompilerBundle.properties +++ b/resources-en/src/messages/CompilerBundle.properties @@ -165,6 +165,10 @@ element.type.name.module.test.output=Module Test Output element.type.name.directory=Directory element.type.name.archive=Archive artifact.type.plain=Other +build.artifacts.before.run.description.empty=Build Artifacts +build.artifacts.before.run.description.single=Build ''{0}'' artifact +build.artifacts.before.run.description.multiple=Build {0} artifacts +build.artifacts.before.run.selector.title=Select Artifacts message.text.destination.is.directory={0} Destination is a directory. message.text.error.copying.file.to.file=Error copying ''{0}'' to ''{1}''. diff --git a/resources/src/idea/RichPlatformPlugin.xml b/resources/src/idea/RichPlatformPlugin.xml index 950b924e7452..5355ffbc6da3 100644 --- a/resources/src/idea/RichPlatformPlugin.xml +++ b/resources/src/idea/RichPlatformPlugin.xml @@ -316,6 +316,7 @@ +