From 9cb96ecd9bc92da2520745486624af7dad4b5c94 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Wed, 31 Jul 2013 14:53:26 +0200 Subject: [PATCH] first draft of RunConfigurationProducer API --- .../actions/ConfigurationContext.java | 27 ++++ .../actions/ConfigurationFromContext.java | 89 +++++++++++++ .../actions/ConfigurationFromContextImpl.java | 45 +++++++ .../actions/PreferredProducerFind.java | 61 ++++++++- .../actions/RunConfigurationProducer.java | 56 ++++++++ .../impl/ConfigurationFromContextWrapper.java | 59 +++++++++ .../actions/BaseRunConfigurationAction.java | 76 +++++------ .../actions/ChooseRunConfigurationPopup.java | 120 ++++++++---------- .../execution/actions/CreateAction.java | 5 +- 9 files changed, 425 insertions(+), 113 deletions(-) create mode 100644 platform/lang-api/src/com/intellij/execution/actions/ConfigurationFromContext.java create mode 100644 platform/lang-api/src/com/intellij/execution/actions/ConfigurationFromContextImpl.java create mode 100644 platform/lang-api/src/com/intellij/execution/actions/RunConfigurationProducer.java create mode 100644 platform/lang-api/src/com/intellij/execution/impl/ConfigurationFromContextWrapper.java diff --git a/platform/lang-api/src/com/intellij/execution/actions/ConfigurationContext.java b/platform/lang-api/src/com/intellij/execution/actions/ConfigurationContext.java index f8169d56ec7b..de4180472450 100644 --- a/platform/lang-api/src/com/intellij/execution/actions/ConfigurationContext.java +++ b/platform/lang-api/src/com/intellij/execution/actions/ConfigurationContext.java @@ -30,6 +30,7 @@ import com.intellij.openapi.actionSystem.LangDataKeys; import com.intellij.openapi.actionSystem.PlatformDataKeys; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.extensions.Extensions; import com.intellij.openapi.module.Module; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Comparing; @@ -56,6 +57,7 @@ public class ConfigurationContext { public static Key SHARED_CONTEXT = Key.create("SHARED_CONTEXT"); private List myPreferredProducers; + private List myConfigurationsFromContext; public static ConfigurationContext getFromContext(DataContext dataContext) { final ConfigurationContext context = new ConfigurationContext(dataContext); @@ -107,6 +109,11 @@ public class ConfigurationContext { null; } + public void setConfiguration(RunnerAndConfigurationSettings configuration) { + myConfiguration = configuration; + } + + @Deprecated @Nullable public RunnerAndConfigurationSettings updateConfiguration(final RuntimeConfigurationProducer producer) { myConfiguration = producer.getConfiguration(); @@ -139,6 +146,12 @@ public class ConfigurationContext { myExistingConfiguration.set(configuration); } } + for (RunConfigurationProducer producer : Extensions.getExtensions(RunConfigurationProducer.EP_NAME)) { + RunnerAndConfigurationSettings configuration = producer.findExistingConfiguration(this); + if (configuration != null && configuration.getConfiguration() == myRuntimeConfiguration) { + myExistingConfiguration.set(configuration); + } + } } for (RuntimeConfigurationProducer producer : producers) { final RunnerAndConfigurationSettings configuration = producer.findExistingConfiguration(myLocation, this); @@ -146,6 +159,12 @@ public class ConfigurationContext { myExistingConfiguration.set(configuration); } } + for (RunConfigurationProducer producer : Extensions.getExtensions(RunConfigurationProducer.EP_NAME)) { + RunnerAndConfigurationSettings configuration = producer.findExistingConfiguration(this); + if (configuration != null) { + myExistingConfiguration.set(configuration); + } + } return myExistingConfiguration.get(); } @@ -209,6 +228,7 @@ public class ConfigurationContext { return null; } + @Deprecated @Nullable public List findPreferredProducers() { if (myPreferredProducers == null) { @@ -216,4 +236,11 @@ public class ConfigurationContext { } return myPreferredProducers; } + + public List getConfigurationsFromContext() { + if (myConfigurationsFromContext == null) { + myConfigurationsFromContext = PreferredProducerFind.getConfigurationsFromContext(myLocation, this, true); + } + return myConfigurationsFromContext; + } } diff --git a/platform/lang-api/src/com/intellij/execution/actions/ConfigurationFromContext.java b/platform/lang-api/src/com/intellij/execution/actions/ConfigurationFromContext.java new file mode 100644 index 000000000000..a031f5698871 --- /dev/null +++ b/platform/lang-api/src/com/intellij/execution/actions/ConfigurationFromContext.java @@ -0,0 +1,89 @@ +/* + * Copyright 2000-2013 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.actions; + +import com.intellij.execution.RunnerAndConfigurationSettings; +import com.intellij.execution.configurations.ConfigurationType; +import com.intellij.execution.configurations.RunConfiguration; +import com.intellij.psi.PsiElement; +import com.intellij.psi.util.PsiTreeUtil; +import org.jetbrains.annotations.NotNull; + +import java.util.Comparator; + +/** + * Describes a run configuration being created by a context run action. + * + * @author yole + */ +public abstract class ConfigurationFromContext { + @NotNull + public abstract RunnerAndConfigurationSettings getConfigurationSettings(); + + @NotNull + public RunConfiguration getConfiguration() { + return getConfigurationSettings().getConfiguration(); + } + + @NotNull + public ConfigurationType getConfigurationType() { + return getConfiguration().getType(); + } + + @NotNull + public abstract PsiElement getSourceElement(); + + /** + * Called before the configuration created from context is first executed. Can be used to show additional UI for customizing the + * created configuration. + * + * @param context the context + * @param startRunnable the runnable that needs to be called after additional customization is complete. + */ + public void onFirstRun(ConfigurationContext context, Runnable startRunnable) { + startRunnable.run(); + } + + public boolean isPreferredTo(ConfigurationFromContext other) { + return true; + } + + public static final Comparator COMPARATOR = new Comparator() { + @Override + public int compare(ConfigurationFromContext configuration1, ConfigurationFromContext configuration2) { + if (PsiTreeUtil.isAncestor(configuration1.getSourceElement(), configuration2.getSourceElement(), true)) { + return 1; + } + if (PsiTreeUtil.isAncestor(configuration2.getSourceElement(), configuration1.getSourceElement(), true)) { + return -1; + } + if (!configuration1.isPreferredTo(configuration2)) { + return 1; + } + if (!configuration2.isPreferredTo(configuration1)) { + return -1; + } + return 0; + } + }; + + public static final Comparator NAME_COMPARATOR = new Comparator() { + @Override + public int compare(final ConfigurationFromContext p1, final ConfigurationFromContext p2) { + return p1.getConfigurationType().getDisplayName().compareTo(p2.getConfigurationType().getDisplayName()); + } + }; +} diff --git a/platform/lang-api/src/com/intellij/execution/actions/ConfigurationFromContextImpl.java b/platform/lang-api/src/com/intellij/execution/actions/ConfigurationFromContextImpl.java new file mode 100644 index 000000000000..dd6a7f9f1de3 --- /dev/null +++ b/platform/lang-api/src/com/intellij/execution/actions/ConfigurationFromContextImpl.java @@ -0,0 +1,45 @@ +/* + * Copyright 2000-2013 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.actions; + +import com.intellij.execution.RunnerAndConfigurationSettings; +import com.intellij.psi.PsiElement; +import org.jetbrains.annotations.NotNull; + +/** + * @author yole + */ +public class ConfigurationFromContextImpl extends ConfigurationFromContext { + private final RunnerAndConfigurationSettings myConfigurationSettings; + private final PsiElement mySourceElement; + + public ConfigurationFromContextImpl(RunnerAndConfigurationSettings settings, PsiElement element) { + myConfigurationSettings = settings; + mySourceElement = element; + } + + @NotNull + @Override + public RunnerAndConfigurationSettings getConfigurationSettings() { + return myConfigurationSettings; + } + + @NotNull + @Override + public PsiElement getSourceElement() { + return mySourceElement; + } +} diff --git a/platform/lang-api/src/com/intellij/execution/actions/PreferredProducerFind.java b/platform/lang-api/src/com/intellij/execution/actions/PreferredProducerFind.java index 78e4354f8c2a..14b51eee7b37 100644 --- a/platform/lang-api/src/com/intellij/execution/actions/PreferredProducerFind.java +++ b/platform/lang-api/src/com/intellij/execution/actions/PreferredProducerFind.java @@ -19,6 +19,7 @@ package com.intellij.execution.actions; import com.intellij.execution.Location; import com.intellij.execution.RunnerAndConfigurationSettings; import com.intellij.execution.configurations.ConfigurationType; +import com.intellij.execution.impl.ConfigurationFromContextWrapper; import com.intellij.execution.junit.RuntimeConfigurationProducer; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; @@ -38,11 +39,12 @@ class PreferredProducerFind { @Nullable public static RunnerAndConfigurationSettings createConfiguration(@NotNull Location location, final ConfigurationContext context) { - final RuntimeConfigurationProducer preferredProducer = findPreferredProducer(location, context); - return preferredProducer != null ? preferredProducer.getConfiguration() : null; + final ConfigurationFromContext fromContext = findConfigurationFromContext(location, context); + return fromContext != null ? fromContext.getConfigurationSettings() : null; } @Nullable + @Deprecated public static List findPreferredProducers(final Location location, final ConfigurationContext context, final boolean strict) { if (location == null) { return null; @@ -83,9 +85,60 @@ class PreferredProducerFind { return producers; } + public static List getConfigurationsFromContext(final Location location, + final ConfigurationContext context, + final boolean strict) { + if (location == null) { + return null; + } + + //todo load configuration types if not already loaded + Extensions.getExtensions(ConfigurationType.CONFIGURATION_TYPE_EP); + final RuntimeConfigurationProducer[] configurationProducers = + ApplicationManager.getApplication().getExtensions(RuntimeConfigurationProducer.RUNTIME_CONFIGURATION_PRODUCER); + final ArrayList configurationsFromContext = new ArrayList(); + for (final RuntimeConfigurationProducer prototype : configurationProducers) { + final RuntimeConfigurationProducer producer; + try { + producer = prototype.createProducer(location, context); + } + catch (AbstractMethodError e) { + LOG.error(prototype.toString(), e); + continue; + } + if (producer.getConfiguration() != null) { + LOG.assertTrue(producer.getSourceElement() != null, producer); + configurationsFromContext.add(new ConfigurationFromContextWrapper(producer)); + } + } + + for (RunConfigurationProducer producer : Extensions.getExtensions(RunConfigurationProducer.EP_NAME)) { + ConfigurationFromContext fromContext = producer.createConfigurationFromContext(context); + if (fromContext != null) { + configurationsFromContext.add(fromContext); + } + } + + if (configurationsFromContext.isEmpty()) return null; + Collections.sort(configurationsFromContext, ConfigurationFromContext.COMPARATOR); + + if(strict) { + final ConfigurationFromContext first = configurationsFromContext.get(0); + for (Iterator it = configurationsFromContext.iterator(); it.hasNext();) { + ConfigurationFromContext producer = it.next(); + if (producer != first && ConfigurationFromContext.COMPARATOR.compare(producer, first) >= 0) { + it.remove(); + } + } + } + + return configurationsFromContext; + } + + @Nullable - private static RuntimeConfigurationProducer findPreferredProducer(final Location location, final ConfigurationContext context) { - final List producers = findPreferredProducers(location, context, true); + private static ConfigurationFromContext findConfigurationFromContext(final Location location, final ConfigurationContext context) { + final List producers = getConfigurationsFromContext(location, context, true); if (producers != null){ return producers.get(0); } diff --git a/platform/lang-api/src/com/intellij/execution/actions/RunConfigurationProducer.java b/platform/lang-api/src/com/intellij/execution/actions/RunConfigurationProducer.java new file mode 100644 index 000000000000..0d4a754646fa --- /dev/null +++ b/platform/lang-api/src/com/intellij/execution/actions/RunConfigurationProducer.java @@ -0,0 +1,56 @@ +/* + * Copyright 2000-2013 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.actions; + +import com.intellij.execution.RunManager; +import com.intellij.execution.RunnerAndConfigurationSettings; +import com.intellij.execution.configurations.ConfigurationType; +import com.intellij.execution.configurations.RunConfiguration; +import com.intellij.openapi.extensions.ExtensionPointName; +import org.jetbrains.annotations.Nullable; + +/** + * @author yole + */ +public abstract class RunConfigurationProducer { + public static ExtensionPointName EP_NAME = ExtensionPointName.create("com.intellij.runConfigurationProducer"); + private final ConfigurationType myConfigurationType; + + protected RunConfigurationProducer(final ConfigurationType configurationType) { + myConfigurationType = configurationType; + } + + public ConfigurationType getConfigurationType() { + return myConfigurationType; + } + + @Nullable + public abstract ConfigurationFromContext createConfigurationFromContext(ConfigurationContext context); + + public abstract boolean isConfigurationFromContext(RunConfiguration configuration, ConfigurationContext context); + + @Nullable + public RunnerAndConfigurationSettings findExistingConfiguration(ConfigurationContext context) { + final RunManager runManager = RunManager.getInstance(context.getProject()); + final RunnerAndConfigurationSettings[] configurations = runManager.getConfigurationSettings(myConfigurationType); + for (RunnerAndConfigurationSettings configurationSettings : configurations) { + if (isConfigurationFromContext(configurationSettings.getConfiguration(), context)) { + return configurationSettings; + } + } + return null; + } +} diff --git a/platform/lang-api/src/com/intellij/execution/impl/ConfigurationFromContextWrapper.java b/platform/lang-api/src/com/intellij/execution/impl/ConfigurationFromContextWrapper.java new file mode 100644 index 000000000000..59c7aa3d92e0 --- /dev/null +++ b/platform/lang-api/src/com/intellij/execution/impl/ConfigurationFromContextWrapper.java @@ -0,0 +1,59 @@ +/* + * Copyright 2000-2013 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.RunnerAndConfigurationSettings; +import com.intellij.execution.actions.ConfigurationContext; +import com.intellij.execution.actions.ConfigurationFromContext; +import com.intellij.execution.junit.RuntimeConfigurationProducer; +import com.intellij.psi.PsiElement; +import org.jetbrains.annotations.NotNull; + +/** + * Wraps a {@link com.intellij.execution.junit.RuntimeConfigurationProducer} in a {@link com.intellij.execution.actions.ConfigurationFromContext}. + * + * @author yole + */ +public class ConfigurationFromContextWrapper extends ConfigurationFromContext { + private final RuntimeConfigurationProducer myProducer; + + public ConfigurationFromContextWrapper(RuntimeConfigurationProducer producer) { + myProducer = producer; + } + + @Override + public void onFirstRun(ConfigurationContext context, Runnable startRunnable) { + myProducer.perform(context, startRunnable); + } + + @NotNull + @Override + public RunnerAndConfigurationSettings getConfigurationSettings() { + return myProducer.getConfiguration(); + } + + @NotNull + @Override + public PsiElement getSourceElement() { + return myProducer.getSourceElement(); + } + + @Override + public boolean isPreferredTo(ConfigurationFromContext other) { + return other instanceof ConfigurationFromContextWrapper && + myProducer.compareTo(((ConfigurationFromContextWrapper) other).myProducer) < 0; + } +} diff --git a/platform/lang-impl/src/com/intellij/execution/actions/BaseRunConfigurationAction.java b/platform/lang-impl/src/com/intellij/execution/actions/BaseRunConfigurationAction.java index 7a2775b54ab1..a2cf9ffea9df 100644 --- a/platform/lang-impl/src/com/intellij/execution/actions/BaseRunConfigurationAction.java +++ b/platform/lang-impl/src/com/intellij/execution/actions/BaseRunConfigurationAction.java @@ -23,7 +23,6 @@ import com.intellij.execution.configurations.ConfigurationType; import com.intellij.execution.configurations.LocatableConfiguration; import com.intellij.execution.configurations.LocatableConfigurationBase; import com.intellij.execution.configurations.RunConfiguration; -import com.intellij.execution.junit.RuntimeConfigurationProducer; import com.intellij.openapi.actionSystem.*; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.editor.Editor; @@ -41,7 +40,6 @@ import java.awt.event.InputEvent; import java.awt.event.MouseEvent; import java.util.ArrayList; import java.util.Collections; -import java.util.Comparator; import java.util.List; public abstract class BaseRunConfigurationAction extends ActionGroup { @@ -63,20 +61,20 @@ public abstract class BaseRunConfigurationAction extends ActionGroup { final ConfigurationContext context = ConfigurationContext.getFromContext(dataContext); final RunnerAndConfigurationSettings existing = context.findExisting(); if (existing == null) { - final List producers = getEnabledProducers(context); + final List producers = getConfigurationsFromContext(context); if (producers.size() > 1) { final AnAction[] children = new AnAction[producers.size()]; int chldIdx = 0; - for (final RuntimeConfigurationProducer producer : producers) { - final ConfigurationType configurationType = producer.getConfigurationType(); - final RunConfiguration configuration = producer.getConfiguration().getConfiguration(); + for (final ConfigurationFromContext fromContext : producers) { + final ConfigurationType configurationType = fromContext.getConfigurationType(); + final RunConfiguration configuration = fromContext.getConfiguration(); final String actionName = configuration instanceof LocatableConfiguration ? StringUtil.unquoteString(suggestRunActionName((LocatableConfiguration)configuration)) : configurationType.getDisplayName(); final AnAction anAction = new AnAction(actionName, configurationType.getDisplayName(), configurationType.getIcon()) { @Override public void actionPerformed(AnActionEvent e) { - perform(producer, context); + perform(fromContext, context); } }; anAction.getTemplatePresentation().setText(actionName, false); @@ -89,19 +87,19 @@ public abstract class BaseRunConfigurationAction extends ActionGroup { } @NotNull - private List getEnabledProducers(ConfigurationContext context) { - final List preferred = context.findPreferredProducers(); - if (preferred == null) { + private List getConfigurationsFromContext(ConfigurationContext context) { + final List fromContext = context.getConfigurationsFromContext(); + if (fromContext == null) { return Collections.emptyList(); } - final List producers = new ArrayList(); - for (RuntimeConfigurationProducer producer : preferred) { - if (isEnabledFor(producer.getConfiguration().getConfiguration())) { - producers.add(producer); + final List enabledConfigurations = new ArrayList(); + for (ConfigurationFromContext configurationFromContext : fromContext) { + if (isEnabledFor(configurationFromContext.getConfiguration())) { + enabledConfigurations.add(configurationFromContext); } } - return producers; + return enabledConfigurations; } protected boolean isEnabledFor(RunConfiguration configuration) { @@ -113,8 +111,8 @@ public abstract class BaseRunConfigurationAction extends ActionGroup { final ConfigurationContext context = ConfigurationContext.getFromContext(dataContext); final RunnerAndConfigurationSettings existing = context.findExisting(); if (existing == null) { - final List producers = getEnabledProducers(context); - return producers.size() <= 1; + final List fromContext = getConfigurationsFromContext(context); + return fromContext.size() <= 1; } return true; } @@ -125,31 +123,26 @@ public abstract class BaseRunConfigurationAction extends ActionGroup { final ConfigurationContext context = ConfigurationContext.getFromContext(dataContext); final RunnerAndConfigurationSettings existing = context.findExisting(); if (existing == null) { - final List producers = getEnabledProducers(context); + final List producers = getConfigurationsFromContext(context); if (producers.isEmpty()) return; if (producers.size() > 1) { final Editor editor = PlatformDataKeys.EDITOR.getData(dataContext); - Collections.sort(producers, new Comparator() { - @Override - public int compare(final RuntimeConfigurationProducer p1, final RuntimeConfigurationProducer p2) { - return p1.getConfigurationType().getDisplayName().compareTo(p2.getConfigurationType().getDisplayName()); - } - }); + Collections.sort(producers, ConfigurationFromContext.NAME_COMPARATOR); final ListPopup popup = - JBPopupFactory.getInstance().createListPopup(new BaseListPopupStep(ExecutionBundle.message("configuration.action.chooser.title"), producers) { + JBPopupFactory.getInstance().createListPopup(new BaseListPopupStep(ExecutionBundle.message("configuration.action.chooser.title"), producers) { @Override @NotNull - public String getTextFor(final RuntimeConfigurationProducer producer) { + public String getTextFor(final ConfigurationFromContext producer) { return producer.getConfigurationType().getDisplayName(); } @Override - public Icon getIconFor(final RuntimeConfigurationProducer producer) { + public Icon getIconFor(final ConfigurationFromContext producer) { return producer.getConfigurationType().getIcon(); } @Override - public PopupStep onChosen(final RuntimeConfigurationProducer producer, final boolean finalChoice) { + public PopupStep onChosen(final ConfigurationFromContext producer, final boolean finalChoice) { perform(producer, context); return FINAL_CHOICE; } @@ -171,16 +164,15 @@ public abstract class BaseRunConfigurationAction extends ActionGroup { perform(context); } - private void perform(final RuntimeConfigurationProducer producer, final ConfigurationContext context) { - final RunnerAndConfigurationSettings configuration = context.updateConfiguration(producer); - if (configuration != null) { - producer.perform(context, new Runnable() { - @Override - public void run() { - perform(context); - } - }); - } + private void perform(final ConfigurationFromContext configurationFromContext, final ConfigurationContext context) { + RunnerAndConfigurationSettings configurationSettings = configurationFromContext.getConfigurationSettings(); + context.setConfiguration(configurationSettings); + configurationFromContext.onFirstRun(context, new Runnable() { + @Override + public void run() { + perform(context); + } + }); } protected abstract void perform(ConfigurationContext context); @@ -201,13 +193,13 @@ public abstract class BaseRunConfigurationAction extends ActionGroup { else{ presentation.setEnabled(true); presentation.setVisible(true); - final List producers = getEnabledProducers(context); - if (existing == null && !producers.isEmpty()) { + final List fromContext = getConfigurationsFromContext(context); + if (existing == null && !fromContext.isEmpty()) { //todo[nik,anna] it's dirty fix. Otherwise wrong configuration will be returned from context.getConfiguration() - context.updateConfiguration(producers.get(0)); + context.setConfiguration(fromContext.get(0).getConfigurationSettings()); } final String name = suggestRunActionName((LocatableConfiguration)configuration.getConfiguration()); - updatePresentation(presentation, existing != null || producers.size() <= 1 ? name : "", context); + updatePresentation(presentation, existing != null || fromContext.size() <= 1 ? name : "", context); } } diff --git a/platform/lang-impl/src/com/intellij/execution/actions/ChooseRunConfigurationPopup.java b/platform/lang-impl/src/com/intellij/execution/actions/ChooseRunConfigurationPopup.java index d1d726ca8160..3b46b66e1482 100644 --- a/platform/lang-impl/src/com/intellij/execution/actions/ChooseRunConfigurationPopup.java +++ b/platform/lang-impl/src/com/intellij/execution/actions/ChooseRunConfigurationPopup.java @@ -22,7 +22,6 @@ import com.intellij.execution.configurations.UnknownConfigurationType; import com.intellij.execution.impl.EditConfigurationsDialog; import com.intellij.execution.impl.RunDialog; import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl; -import com.intellij.execution.junit.RuntimeConfigurationProducer; import com.intellij.execution.runners.ProgramRunner; import com.intellij.execution.ui.RunContentDescriptor; import com.intellij.icons.AllIcons; @@ -588,79 +587,72 @@ class ChooseRunConfigurationPopup implements ExecutorProvider { final DataContext dataContext = DataManager.getInstance().getDataContext(); final ConfigurationContext context = ConfigurationContext.getFromContext(dataContext); - final List producers = PreferredProducerFind - .findPreferredProducers(context.getLocation(), context, false); + final List producers = PreferredProducerFind.getConfigurationsFromContext(context.getLocation(), + context, false); if (producers == null) return Collections.emptyList(); - Collections.sort(producers, new Comparator() { - @Override - public int compare(final RuntimeConfigurationProducer p1, final RuntimeConfigurationProducer p2) { - return p1.getConfigurationType().getDisplayName().compareTo(p2.getConfigurationType().getDisplayName()); - } - }); + Collections.sort(producers, ConfigurationFromContext.NAME_COMPARATOR); final RunnerAndConfigurationSettings[] preferred = {null}; int i = 2; // selectedConfiguration == null ? 1 : 2; - for (final RuntimeConfigurationProducer producer : producers) { - final RunnerAndConfigurationSettings configuration = producer.getConfiguration(); - if (configuration != null) { - if (existing.keySet().contains(configuration)) { - final ItemWrapper wrapper = existing.get(configuration); - if (wrapper.getMnemonic() != 1) { - wrapper.setMnemonic(i); - i++; - } - } - else { - if (selectedConfiguration != null && configuration.equals(selectedConfiguration)) continue; - contextConfigurations.add(configuration); - - if (preferred[0] == null) { - preferred[0] = configuration; - } - - //noinspection unchecked - final ItemWrapper wrapper = new ItemWrapper(configuration) { - @Override - public Icon getIcon() { - return RunManagerEx.getInstanceEx(project).getConfigurationIcon(configuration); - } - - @Override - public String getText() { - return configuration.getName(); - } - - @Override - public boolean available(Executor executor) { - return canRun(executor, configuration); - } - - @Override - public void perform(@NotNull Project project, @NotNull Executor executor, @NotNull DataContext context) { - manager.setTemporaryConfiguration(configuration); - RunManagerEx.getInstanceEx(project).setSelectedConfiguration(configuration); - doRunConfiguration(configuration, executor, project); - } - - @Override - public PopupStep getNextStep(@NotNull final Project project, @NotNull final ChooseRunConfigurationPopup action) { - return new ConfigurationActionsStep(project, action, configuration, isDynamic()); - } - - @Override - public boolean hasActions() { - return true; - } - }; - - wrapper.setDynamic(true); + for (final ConfigurationFromContext fromContext : producers) { + final RunnerAndConfigurationSettings configuration = fromContext.getConfigurationSettings(); + if (existing.keySet().contains(configuration)) { + final ItemWrapper wrapper = existing.get(configuration); + if (wrapper.getMnemonic() != 1) { wrapper.setMnemonic(i); - result.add(wrapper); i++; } } + else { + if (selectedConfiguration != null && configuration.equals(selectedConfiguration)) continue; + contextConfigurations.add(configuration); + + if (preferred[0] == null) { + preferred[0] = configuration; + } + + //noinspection unchecked + final ItemWrapper wrapper = new ItemWrapper(configuration) { + @Override + public Icon getIcon() { + return RunManagerEx.getInstanceEx(project).getConfigurationIcon(configuration); + } + + @Override + public String getText() { + return configuration.getName(); + } + + @Override + public boolean available(Executor executor) { + return canRun(executor, configuration); + } + + @Override + public void perform(@NotNull Project project, @NotNull Executor executor, @NotNull DataContext context) { + manager.setTemporaryConfiguration(configuration); + RunManagerEx.getInstanceEx(project).setSelectedConfiguration(configuration); + doRunConfiguration(configuration, executor, project); + } + + @Override + public PopupStep getNextStep(@NotNull final Project project, @NotNull final ChooseRunConfigurationPopup action) { + return new ConfigurationActionsStep(project, action, configuration, isDynamic()); + } + + @Override + public boolean hasActions() { + return true; + } + }; + + wrapper.setDynamic(true); + wrapper.setMnemonic(i); + result.add(wrapper); + i++; + } } return contextConfigurations; diff --git a/platform/lang-impl/src/com/intellij/execution/actions/CreateAction.java b/platform/lang-impl/src/com/intellij/execution/actions/CreateAction.java index 279dfc0206dd..a6fd324664af 100644 --- a/platform/lang-impl/src/com/intellij/execution/actions/CreateAction.java +++ b/platform/lang-impl/src/com/intellij/execution/actions/CreateAction.java @@ -23,7 +23,6 @@ import com.intellij.execution.RunnerAndConfigurationSettings; import com.intellij.execution.configurations.RunConfiguration; import com.intellij.execution.impl.RunDialog; import com.intellij.execution.impl.RunManagerImpl; -import com.intellij.execution.junit.RuntimeConfigurationProducer; import com.intellij.openapi.actionSystem.Presentation; import org.jetbrains.annotations.NotNull; @@ -73,8 +72,8 @@ public class CreateAction extends BaseRunConfigurationAction { } protected void updateIcon(final Presentation presentation, final ConfigurationContext context) { - final List producers = context.findPreferredProducers(); - if (producers != null && producers.size() == 1) { //hide fuzzy icon when multiple run configurations are possible + final List fromContext = context.getConfigurationsFromContext(); + if (fromContext != null && fromContext.size() == 1) { //hide fuzzy icon when multiple run configurations are possible presentation.setIcon(context.getConfiguration().getFactory().getIcon()); } }