lang-impl/src/com/intellij/execution/actions/ChooseRunConfigurationAction.java

   1 package com.intellij.execution.actions;
   2
   3 import com.intellij.execution.*;
   4 import com.intellij.execution.configurations.ConfigurationType;
   5 import com.intellij.execution.executors.DefaultRunExecutor;
   6 import com.intellij.execution.impl.EditConfigurationsDialog;
   7 import com.intellij.execution.impl.RunDialog;
   8 import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl;
   9 import com.intellij.execution.junit.RuntimeConfigurationProducer;
  10 import com.intellij.execution.runners.ProgramRunner;
  11 import com.intellij.ide.DataManager;
  12 import com.intellij.ide.util.PropertiesComponent;
  13 import com.intellij.openapi.actionSystem.*;
  14 import com.intellij.openapi.keymap.KeymapUtil;
  15 import com.intellij.openapi.project.Project;
  16 import com.intellij.openapi.ui.popup.ListPopupStep;
  17 import com.intellij.openapi.ui.popup.ListSeparator;
  18 import com.intellij.openapi.ui.popup.PopupStep;
  19 import com.intellij.openapi.ui.popup.util.BaseListPopupStep;
  20 import com.intellij.openapi.util.IconLoader;
  21 import com.intellij.openapi.wm.ToolWindowId;
  22 import com.intellij.ui.popup.list.ListPopupImpl;
  23 import com.intellij.ui.popup.list.PopupListElementRenderer;
  24 import org.jetbrains.annotations.NotNull;
  25 import org.jetbrains.annotations.Nullable;
  26
  27 import javax.swing.*;
  28 import java.awt.*;
  29 import java.awt.event.ActionEvent;
  30 import java.util.ArrayList;
  31 import java.util.Collections;
  32 import java.util.Comparator;
  33 import java.util.List;
  34
  35 /**
  36  * @author spleaner
  37  */
  38 public class ChooseRunConfigurationAction extends AnAction {
  39   private static final Icon EDIT_ICON = IconLoader.getIcon("/actions/editSource.png");
  40   private static final Icon SAVE_ICON = IconLoader.getIcon("/runConfigurations/saveTempConfig.png");
  41
  42   private Executor myCurrentExecutor;
  43   private boolean myEditConfiguration;
  44   private boolean myDeleteConfiguration;
  45
  46   @Override
  47   public void actionPerformed(AnActionEvent e) {
  48     final Project project = e.getData(PlatformDataKeys.PROJECT);
  49     assert project != null;
  50
  51     final Executor executor = getDefaultExecutor();
  52     assert executor != null;
  53
  54     final ListPopupImpl popup = new ListPopupImpl(new ConfigurationListPopupStep(this, project, String.format("%s", executor.getActionName()))) {
  55       @Override
  56       protected ListCellRenderer getListElementRenderer() {
  57         return new RunListElementRenderer(this);
  58       }
  59     };
  60
  61     registerActions(popup);
  62
  63     final String adText = getAdText(getAlternateExecutor());
  64     if (adText != null) {
  65       popup.setAdText(adText);
  66     }
  67
  68     popup.showCenteredInCurrentWindow(project);
  69   }
  70
  71   protected String getAdKey() {
  72     return "run.configuration.alternate.action.ad";
  73   }
  74
  75   @Nullable
  76   protected String getAdText(final Executor alternateExecutor) {
  77     if (alternateExecutor != null && !PropertiesComponent.getInstance().isTrueValue(getAdKey())) {
  78       return String
  79         .format("Hold %s to %s", KeymapUtil.getKeystrokeText(KeyStroke.getKeyStroke("SHIFT")), alternateExecutor.getActionName());
  80     }
  81
  82     if (!PropertiesComponent.getInstance().isTrueValue("run.configuration.edit.ad")) {
  83       return String.format("Press %s to Edit", KeymapUtil.getKeystrokeText(KeyStroke.getKeyStroke("F4")));
  84     }
  85
  86     return null;
  87   }
  88
  89   private void registerActions(final ListPopupImpl popup) {
  90     popup.registerAction("alternateExecutor", KeyStroke.getKeyStroke("shift pressed SHIFT"), new AbstractAction() {
  91       public void actionPerformed(ActionEvent e) {
  92         myCurrentExecutor = getAlternateExecutor();
  93         updatePresentation(popup);
  94       }
  95     });
  96
  97     popup.registerAction("restoreDefaultExecutor", KeyStroke.getKeyStroke("released SHIFT"), new AbstractAction() {
  98       public void actionPerformed(ActionEvent e) {
  99         myCurrentExecutor = getDefaultExecutor();
 100         updatePresentation(popup);
 101       }
 102     });
 103
 104
 105     popup.registerAction("invokeAction", KeyStroke.getKeyStroke("shift ENTER"), new AbstractAction() {
 106       public void actionPerformed(ActionEvent e) {
 107         popup.handleSelect(true);
 108       }
 109     });
 110
 111     popup.registerAction("editConfiguration", KeyStroke.getKeyStroke("F4"), new AbstractAction() {
 112       public void actionPerformed(ActionEvent e) {
 113         myEditConfiguration = true;
 114         try {
 115           popup.handleSelect(true);
 116         }
 117         finally {
 118           myEditConfiguration = false;
 119         }
 120       }
 121     });
 122
 123
 124     popup.registerAction("deleteConfiguration", KeyStroke.getKeyStroke("DELETE"), new AbstractAction() {
 125       public void actionPerformed(ActionEvent e) {
 126         myDeleteConfiguration = true;
 127         try {
 128           popup.handleSelect(true);
 129         }
 130         finally {
 131           myDeleteConfiguration = false;
 132         }
 133       }
 134     });
 135
 136     popup.registerAction("0Action", KeyStroke.getKeyStroke("0"), createNumberAction(0, popup, getDefaultExecutor()));
 137     popup.registerAction("0Action_", KeyStroke.getKeyStroke("shift pressed 0"), createNumberAction(0, popup, getAlternateExecutor()));
 138     popup.registerAction("1Action", KeyStroke.getKeyStroke("1"), createNumberAction(1, popup, getDefaultExecutor()));
 139     popup.registerAction("1Action_", KeyStroke.getKeyStroke("shift pressed 1"), createNumberAction(1, popup, getAlternateExecutor()));
 140     popup.registerAction("2Action", KeyStroke.getKeyStroke("2"), createNumberAction(2, popup, getDefaultExecutor()));
 141     popup.registerAction("2Action_", KeyStroke.getKeyStroke("shift pressed 2"), createNumberAction(2, popup, getAlternateExecutor()));
 142     popup.registerAction("3Action", KeyStroke.getKeyStroke("3"), createNumberAction(3, popup, getDefaultExecutor()));
 143     popup.registerAction("3Action_", KeyStroke.getKeyStroke("shift pressed 3"), createNumberAction(3, popup, getAlternateExecutor()));
 144   }
 145
 146   private void updatePresentation(ListPopupImpl listPopup) {
 147     final Executor executor = getCurrentExecutor();
 148     if (executor != null) {
 149       listPopup.setCaption(executor.getActionName());
 150     }
 151   }
 152
 153   static void execute(final ItemWrapper itemWrapper, final Executor executor) {
 154     if (executor == null) {
 155       return;
 156     }
 157
 158     final DataContext dataContext = DataManager.getInstance().getDataContext();
 159     final Project project = PlatformDataKeys.PROJECT.getData(dataContext);
 160     if (project != null) {
 161       SwingUtilities.invokeLater(new Runnable() {
 162         public void run() {
 163           itemWrapper.perform(project, executor, dataContext);
 164         }
 165       });
 166     }
 167   }
 168
 169   void editConfiguration(@NotNull final Project project, @NotNull final RunnerAndConfigurationSettingsImpl configuration) {
 170     final Executor executor = getCurrentExecutor();
 171     assert executor != null;
 172
 173     PropertiesComponent.getInstance().setValue("run.configuration.edit.ad", Boolean.toString(true));
 174     if (RunDialog.editConfiguration(project, configuration, "Edit configuration settings", executor.getActionName(), executor.getIcon())) {
 175       RunManagerEx.getInstanceEx(project).setSelectedConfiguration(configuration);
 176       ExecutionUtil.executeConfiguration(project, configuration, executor, DataManager.getInstance().getDataContext());
 177     }
 178   }
 179
 180   private void deleteConfiguration(final Project project, final RunnerAndConfigurationSettingsImpl configurationSettings) {
 181     // TODO:
 182   }
 183
 184   @Nullable
 185   protected Executor getDefaultExecutor() {
 186     return DefaultRunExecutor.getRunExecutorInstance();
 187   }
 188
 189   @Nullable
 190   protected Executor getAlternateExecutor() {
 191     return ExecutorRegistry.getInstance().getExecutorById(ToolWindowId.DEBUG);
 192   }
 193
 194   @Nullable
 195   protected Executor getCurrentExecutor() {
 196     return myCurrentExecutor == null ? getDefaultExecutor() : myCurrentExecutor;
 197   }
 198
 199   @Override
 200   public void update(AnActionEvent e) {
 201     final Presentation presentation = e.getPresentation();
 202     final Project project = e.getData(PlatformDataKeys.PROJECT);
 203
 204     presentation.setEnabled(true);
 205     if (project == null || project.isDisposed()) {
 206       presentation.setEnabled(false);
 207       presentation.setVisible(false);
 208       return;
 209     }
 210
 211     if (null == getDefaultExecutor()) {
 212       presentation.setEnabled(false);
 213       presentation.setVisible(false);
 214       return;
 215     }
 216
 217     presentation.setEnabled(true);
 218     presentation.setVisible(true);
 219   }
 220
 221   private static Action createNumberAction(final int number, final ListPopupImpl listPopup, final Executor executor) {
 222     return new AbstractAction() {
 223       public void actionPerformed(ActionEvent e) {
 224         for (Object item : listPopup.getListStep().getValues()) {
 225           if (item instanceof ItemWrapper && ((ItemWrapper)item).getMnemonic() == number) {
 226             listPopup.cancel();
 227             execute((ItemWrapper)item, executor);
 228           }
 229         }
 230       }
 231     };
 232   }
 233
 234   private abstract static class ItemWrapper<T> {
 235     private T myValue;
 236     private boolean myDynamic = false;
 237     private int myMnemonic = -1;
 238
 239     protected ItemWrapper(@Nullable final T value) {
 240       myValue = value;
 241     }
 242
 243     public int getMnemonic() {
 244       return myMnemonic;
 245     }
 246
 247     public void setMnemonic(int mnemonic) {
 248       myMnemonic = mnemonic;
 249     }
 250
 251     public T getValue() {
 252       return myValue;
 253     }
 254
 255     public boolean isDynamic() {
 256       return myDynamic;
 257     }
 258
 259     public void setDynamic(final boolean b) {
 260       myDynamic = b;
 261     }
 262
 263     @Override
 264     public boolean equals(Object o) {
 265       if (this == o) return true;
 266       if (o == null || getClass() != o.getClass()) return false;
 267
 268       ItemWrapper that = (ItemWrapper)o;
 269
 270       if (myValue != null ? !myValue.equals(that.myValue) : that.myValue != null) return false;
 271
 272       return true;
 273     }
 274
 275     @Override
 276     public int hashCode() {
 277       return myValue != null ? myValue.hashCode() : 0;
 278     }
 279
 280     public abstract Icon getIcon();
 281
 282     public abstract String getText();
 283
 284     public abstract void perform(@NotNull final Project project, @NotNull final Executor executor, @NotNull final DataContext context);
 285
 286     @Nullable
 287     public ConfigurationType getType() {
 288       return null;
 289     }
 290
 291     public boolean available(Executor executor) {
 292       return true;
 293     }
 294
 295     public boolean hasActions() {
 296       return false;
 297     }
 298
 299     public PopupStep getNextStep(Project project, ChooseRunConfigurationAction action) {
 300       return PopupStep.FINAL_CHOICE;
 301     }
 302
 303     public static ItemWrapper wrap(@NotNull final Project project,
 304                                    @NotNull final RunnerAndConfigurationSettingsImpl settings,
 305                                    final boolean dynamic) {
 306       final ItemWrapper result = wrap(project, settings);
 307       result.setDynamic(dynamic);
 308       return result;
 309     }
 310
 311     public static ItemWrapper wrap(@NotNull final Project project, @NotNull final RunnerAndConfigurationSettingsImpl settings) {
 312       return new ItemWrapper<RunnerAndConfigurationSettingsImpl>(settings) {
 313         @Override
 314         public void perform(@NotNull Project project, @NotNull Executor executor, @NotNull DataContext context) {
 315           RunManagerEx.getInstanceEx(project).setSelectedConfiguration(getValue());
 316           ExecutionUtil.executeConfiguration(project, getValue(), executor, DataManager.getInstance().getDataContext());
 317         }
 318
 319         @Override
 320         public ConfigurationType getType() {
 321           return getValue().getType();
 322         }
 323
 324         @Override
 325         public Icon getIcon() {
 326           return ExecutionUtil.getConfigurationIcon(project, getValue());
 327         }
 328
 329         @Override
 330         public String getText() {
 331           if (getMnemonic() != -1) {
 332             return String.format("%s", getValue().getName());
 333           }
 334
 335           return getValue().getName();
 336         }
 337
 338         @Override
 339         public boolean hasActions() {
 340           return true;
 341         }
 342
 343         @Override
 344         public boolean available(Executor executor) {
 345           return null != ExecutionUtil.getRunner(executor.getId(), getValue());
 346         }
 347
 348         @Override
 349         public PopupStep getNextStep(@NotNull final Project project, @NotNull final ChooseRunConfigurationAction action) {
 350           return new ConfigurationActionsStep(project, action, getValue());
 351         }
 352       };
 353     }
 354
 355   }
 356
 357   private static final class ConfigurationListPopupStep extends BaseListPopupStep<ItemWrapper> {
 358     private Project myProject;
 359     private ChooseRunConfigurationAction myAction;
 360     private int myDefaultConfiguration = -1;
 361
 362     private ConfigurationListPopupStep(@NotNull final ChooseRunConfigurationAction action,
 363                                        @NotNull final Project project,
 364                                        @NotNull final String title) {
 365       super(title, createSettingsList(project));
 366       myProject = project;
 367       myAction = action;
 368
 369       if (-1 == getDefaultOptionIndex()) {
 370         myDefaultConfiguration = getDynamicIndex();
 371       }
 372     }
 373
 374     private int getDynamicIndex() {
 375       int i = 0;
 376       for (final ItemWrapper wrapper : getValues()) {
 377         if (wrapper.isDynamic()) {
 378           return i;
 379         }
 380         i++;
 381       }
 382
 383       return -1;
 384     }
 385
 386     @Override
 387     public boolean isAutoSelectionEnabled() {
 388       return false;
 389     }
 390
 391     private static ItemWrapper[] createSettingsList(@NotNull final Project project) {
 392       final RunManagerEx manager = RunManagerEx.getInstanceEx(project);
 393
 394       final List<ItemWrapper> result = new ArrayList<ItemWrapper>();
 395
 396       final RunnerAndConfigurationSettingsImpl selectedConfiguration = manager.getSelectedConfiguration();
 397       final RunnerAndConfigurationSettingsImpl context = populateWithDynamicRunners(result, project, manager, selectedConfiguration);
 398
 399       final ConfigurationType[] factories = manager.getConfigurationFactories();
 400       for (final ConfigurationType factory : factories) {
 401         final RunnerAndConfigurationSettingsImpl[] configurations = manager.getConfigurationSettings(factory);
 402         for (final RunnerAndConfigurationSettingsImpl configuration : configurations) {
 403           if (configuration != context) { // exclude context configuration
 404             final ItemWrapper wrapped = ItemWrapper.wrap(project, configuration);
 405             if (configuration == selectedConfiguration) {
 406               wrapped.setMnemonic(1);
 407             }
 408
 409             result.add(wrapped);
 410           }
 411         }
 412       }
 413
 414       //noinspection unchecked
 415       final ItemWrapper edit = new ItemWrapper(null) {
 416         @Override
 417         public Icon getIcon() {
 418           return EDIT_ICON;
 419         }
 420
 421         @Override
 422         public String getText() {
 423           return "Edit configurations...";
 424         }
 425
 426         @Override
 427         public void perform(@NotNull final Project project, @NotNull final Executor executor, @NotNull DataContext context) {
 428           final EditConfigurationsDialog dialog = new EditConfigurationsDialog(project) {
 429             @Override
 430             protected void init() {
 431               setOKButtonText(executor.getStartActionText());
 432               setOKButtonIcon(executor.getIcon());
 433
 434               super.init();
 435             }
 436           };
 437
 438           dialog.show();
 439           if (dialog.isOK()) {
 440             SwingUtilities.invokeLater(new Runnable() {
 441               public void run() {
 442                 final RunnerAndConfigurationSettings configuration = RunManager.getInstance(project).getSelectedConfiguration();
 443                 if (configuration instanceof RunnerAndConfigurationSettingsImpl) {
 444                   ExecutionUtil.executeConfiguration(project, (RunnerAndConfigurationSettingsImpl) configuration, executor, DataManager.getInstance().getDataContext());
 445                 }
 446               }
 447             });
 448           }
 449         }
 450       };
 451
 452       edit.setMnemonic(0);
 453       result.add(0, edit);
 454
 455       return result.toArray(new ItemWrapper[result.size()]);
 456     }
 457
 458     @Nullable
 459     private static RunnerAndConfigurationSettingsImpl populateWithDynamicRunners(final List<ItemWrapper> result,
 460                                                                                  final Project project,
 461                                                                                  final RunManagerEx manager,
 462                                                                                  final RunnerAndConfigurationSettingsImpl selectedConfiguration) {
 463       final DataContext dataContext = DataManager.getInstance().getDataContext();
 464       final ConfigurationContext context = new ConfigurationContext(dataContext);
 465       final RunnerAndConfigurationSettingsImpl existing = context.findExisting();
 466       if (existing != null && existing == selectedConfiguration) {
 467         return null;
 468       }
 469
 470       if (existing == null) {
 471         final List<RuntimeConfigurationProducer> producers = PreferedProducerFind.findPreferedProducers(context.getLocation(), context);
 472         if (producers == null) return null;
 473
 474         Collections.sort(producers, new Comparator<RuntimeConfigurationProducer>() {
 475           public int compare(final RuntimeConfigurationProducer p1, final RuntimeConfigurationProducer p2) {
 476             return p1.getConfigurationType().getDisplayName().compareTo(p2.getConfigurationType().getDisplayName());
 477           }
 478         });
 479
 480         final RunnerAndConfigurationSettingsImpl[] preferred = {null};
 481
 482         int i = 2; // selectedConfiguration == null ? 1 : 2;
 483         for (final RuntimeConfigurationProducer producer : producers) {
 484           final RunnerAndConfigurationSettingsImpl configuration = producer.getConfiguration();
 485           if (configuration != null) {
 486
 487             if (preferred[0] == null) {
 488               preferred[0] = configuration;
 489             }
 490
 491             //noinspection unchecked
 492             final ItemWrapper wrapper = new ItemWrapper(configuration) {
 493               @Override
 494               public Icon getIcon() {
 495                 return IconLoader.getTransparentIcon(ExecutionUtil.getConfigurationIcon(project, configuration), 0.3f);
 496               }
 497
 498               @Override
 499               public String getText() {
 500                 return producers.size() == 1
 501                        ? String.format("%s", configuration.getName())
 502                        : String.format("%s (%s)", configuration.getName(), producer.getConfigurationType().getDisplayName());
 503               }
 504
 505               @Override
 506               public void perform(@NotNull Project project, @NotNull Executor executor, @NotNull DataContext context) {
 507                 manager.setTemporaryConfiguration(configuration);
 508                 RunManagerEx.getInstanceEx(project).setSelectedConfiguration(configuration);
 509                 ExecutionUtil.executeConfiguration(project, configuration, executor, DataManager.getInstance().getDataContext());
 510               }
 511
 512               @Override
 513               public PopupStep getNextStep(@NotNull final Project project, @NotNull final ChooseRunConfigurationAction action) {
 514                 return new ConfigurationActionsStep(project, action, configuration);
 515               }
 516
 517               @Override
 518               public boolean hasActions() {
 519                 return true;
 520               }
 521             };
 522
 523             wrapper.setDynamic(true);
 524             wrapper.setMnemonic(i);
 525             result.add(wrapper);
 526             i++;
 527           }
 528         }
 529
 530         return preferred[0];
 531       }
 532       else {
 533         final ItemWrapper wrapper = ItemWrapper.wrap(project, existing, true);
 534         wrapper.setMnemonic(2); // selectedConfiguration == null ? 1 : 2);
 535         result.add(wrapper);
 536       }
 537
 538       return existing;
 539     }
 540
 541     @Override
 542     public ListSeparator getSeparatorAbove(ItemWrapper value) {
 543       final List<ItemWrapper> configurations = getValues();
 544       final int index = configurations.indexOf(value);
 545       if (index > 0 && index <= configurations.size() - 1) {
 546         final ItemWrapper aboveConfiguration = index == 0 ? null : configurations.get(index - 1);
 547
 548         if (aboveConfiguration != null && aboveConfiguration.isDynamic() != value.isDynamic()) {
 549           return new ListSeparator();
 550         }
 551
 552         final ConfigurationType currentType = value.getType();
 553         final ConfigurationType aboveType = aboveConfiguration == null ? null : aboveConfiguration.getType();
 554         if (aboveType != currentType && currentType != null) {
 555           return new ListSeparator(); // new ListSeparator(currentType.getDisplayName());
 556         }
 557       }
 558
 559       return null;
 560     }
 561
 562     @Override
 563     public boolean isSpeedSearchEnabled() {
 564       return true;
 565     }
 566
 567     @Override
 568     public int getDefaultOptionIndex() {
 569       final RunnerAndConfigurationSettings currentConfiguration = RunManager.getInstance(myProject).getSelectedConfiguration();
 570       if (currentConfiguration == null && myDefaultConfiguration != -1) {
 571         return myDefaultConfiguration;
 572       }
 573
 574       return currentConfiguration instanceof RunnerAndConfigurationSettingsImpl ? getValues()
 575         .indexOf(ItemWrapper.wrap(myProject, (RunnerAndConfigurationSettingsImpl)currentConfiguration)) : -1;
 576     }
 577
 578     @Override
 579     public PopupStep onChosen(final ItemWrapper wrapper, boolean finalChoice) {
 580       if (myAction.myEditConfiguration) {
 581         final Object o = wrapper.getValue();
 582         if (o instanceof RunnerAndConfigurationSettingsImpl) {
 583           SwingUtilities.invokeLater(new Runnable() {
 584             public void run() {
 585               myAction.editConfiguration(myProject, (RunnerAndConfigurationSettingsImpl)o);
 586             }
 587           });
 588
 589           return FINAL_CHOICE;
 590         }
 591       }
 592
 593       if (myAction.myDeleteConfiguration) {
 594         final Object o = wrapper.getValue();
 595         if (o instanceof RunnerAndConfigurationSettingsImpl) {
 596           SwingUtilities.invokeLater(new Runnable() {
 597             public void run() {
 598               myAction.deleteConfiguration(myProject, (RunnerAndConfigurationSettingsImpl)o);
 599             }
 600           });
 601
 602           return FINAL_CHOICE;
 603         }
 604       }
 605
 606       final Executor executor = myAction.getCurrentExecutor();
 607       assert executor != null;
 608
 609       if (finalChoice && wrapper.available(executor)) {
 610         SwingUtilities.invokeLater(new Runnable() {
 611           public void run() {
 612             if (myAction.getCurrentExecutor() == myAction.getAlternateExecutor()) {
 613               PropertiesComponent.getInstance().setValue(myAction.getAdKey(), Boolean.toString(true));
 614             }
 615
 616             wrapper.perform(myProject, executor, DataManager.getInstance().getDataContext());
 617           }
 618         });
 619
 620         return FINAL_CHOICE;
 621       }
 622       else {
 623         return wrapper.getNextStep(myProject, myAction);
 624       }
 625     }
 626
 627     @Override
 628     public boolean hasSubstep(ItemWrapper selectedValue) {
 629       return selectedValue.hasActions();
 630     }
 631
 632     @NotNull
 633     @Override
 634     public String getTextFor(ItemWrapper value) {
 635       return value.getText();
 636     }
 637
 638     @Override
 639     public Icon getIconFor(ItemWrapper value) {
 640       return value.getIcon();
 641     }
 642   }
 643
 644   private static final class ConfigurationActionsStep extends BaseListPopupStep<ActionWrapper> {
 645     private ConfigurationActionsStep(@NotNull final Project project,
 646                                      ChooseRunConfigurationAction action,
 647                                      @NotNull final RunnerAndConfigurationSettingsImpl settings) {
 648       super("Actions", buildActions(project, action, settings));
 649     }
 650
 651     private static ActionWrapper[] buildActions(@NotNull final Project project,
 652                                                 final ChooseRunConfigurationAction action,
 653                                                 @NotNull final RunnerAndConfigurationSettingsImpl settings) {
 654       final List<ActionWrapper> result = new ArrayList<ActionWrapper>();
 655       final Executor[] executors = ExecutorRegistry.getInstance().getRegisteredExecutors();
 656       for (final Executor executor : executors) {
 657         final ProgramRunner runner = RunnerRegistry.getInstance().getRunner(executor.getId(), settings.getConfiguration());
 658         if (runner != null) {
 659           result.add(new ActionWrapper(executor.getActionName(), executor.getIcon()) {
 660             @Override
 661             public void perform() {
 662               RunManagerEx.getInstanceEx(project).setSelectedConfiguration(settings);
 663               ExecutionUtil.executeConfiguration(project, settings, executor, DataManager.getInstance().getDataContext());
 664             }
 665           });
 666         }
 667       }
 668
 669       result.add(new ActionWrapper("Edit...", EDIT_ICON) {
 670         @Override
 671         public void perform() {
 672           action.editConfiguration(project, settings);
 673         }
 674       });
 675
 676       if (RunManager.getInstance(project).isTemporary(settings.getConfiguration())) {
 677         result.add(new ActionWrapper("Save temp configuration", SAVE_ICON) {
 678           @Override
 679           public void perform() {
 680             RunManager.getInstance(project).makeStable(settings.getConfiguration());
 681           }
 682         });
 683       }
 684
 685       return result.toArray(new ActionWrapper[result.size()]);
 686     }
 687
 688     @Override
 689     public PopupStep onChosen(final ActionWrapper selectedValue, boolean finalChoice) {
 690       SwingUtilities.invokeLater(new Runnable() {
 691         public void run() {
 692           selectedValue.perform();
 693         }
 694       });
 695
 696       return FINAL_CHOICE;
 697     }
 698
 699     @Override
 700     public Icon getIconFor(ActionWrapper aValue) {
 701       return aValue.getIcon();
 702     }
 703
 704     @NotNull
 705     @Override
 706     public String getTextFor(ActionWrapper value) {
 707       return value.getName();
 708     }
 709   }
 710
 711   private abstract static class ActionWrapper {
 712     private String myName;
 713     private Icon myIcon;
 714
 715     private ActionWrapper(String name, Icon icon) {
 716       myName = name;
 717       myIcon = icon;
 718     }
 719
 720     public abstract void perform();
 721
 722     public String getName() {
 723       return myName;
 724     }
 725
 726     public Icon getIcon() {
 727       return myIcon;
 728     }
 729   }
 730
 731   private static class RunListElementRenderer extends PopupListElementRenderer {
 732     private JLabel myLabel;
 733     private ListPopupImpl myPopup1;
 734
 735     private RunListElementRenderer(ListPopupImpl popup) {
 736       super(popup);
 737
 738       myPopup1 = popup;
 739     }
 740
 741     @Override
 742     protected JComponent createItemComponent() {
 743       if (myLabel == null) {
 744         myLabel = new JLabel();
 745         myLabel.setPreferredSize(new JLabel("8.").getPreferredSize());
 746       }
 747
 748       final JComponent result = super.createItemComponent();
 749       result.add(myLabel, BorderLayout.WEST);
 750       return result;
 751     }
 752
 753     @Override
 754     protected void customizeComponent(JList list, Object value, boolean isSelected) {
 755       super.customizeComponent(list, value, isSelected);
 756
 757       ListPopupStep<Object> step = myPopup1.getListStep();
 758       boolean isSelectable = step.isSelectable(value);
 759       myLabel.setEnabled(isSelectable);
 760
 761       if (isSelected) {
 762         setSelected(myLabel);
 763       } else {
 764         setDeselected(myLabel);
 765       }
 766
 767       if (value instanceof ItemWrapper) {
 768         final int mnemonic = ((ItemWrapper)value).getMnemonic();
 769         if (mnemonic != -1) {
 770           myLabel.setText(mnemonic + ".");
 771           myLabel.setDisplayedMnemonicIndex(0);
 772         } else {
 773           myLabel.setText("");
 774         }
 775       }
 776     }
 777   }
 778 }