Java PopupStep类代码示例

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
@Override
public void invoke(@NotNull final Project project, final Editor editor, @NotNull final PsiElement psiElement) throws IncorrectOperationException {

    JBPopupFactory.getInstance().createListPopup(new BaseListPopupStep<String>("Chosen", "Document", "Sample") {

        @Override
        public PopupStep onChosen(String selectedValue, boolean finalChoice) {

            if ("Document".equals(selectedValue)) {
                openDocument(psiElement.getText());
            } else if ("Sample".equals(selectedValue)) {
                openSample(project, editor);
            }

            return super.onChosen(selectedValue, finalChoice);
        }
    }).showInBestPositionFor(editor);
}
 

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
@Override
protected void selectTargets(List<PsiLiteralExpression> targets, final Consumer<List<PsiLiteralExpression>> selectionConsumer) {
  if (targets.size() == 1) {
    selectionConsumer.consume(targets);
  } else {
    JBPopupFactory.getInstance().createListPopup(new BaseListPopupStep<PsiLiteralExpression>("Choose Inspections to Highlight Suppressed Problems from", targets){
      @Override
      public PopupStep onChosen(PsiLiteralExpression selectedValue, boolean finalChoice) {
        selectionConsumer.consume(Collections.singletonList(selectedValue));
        return FINAL_CHOICE;
      }

      @NotNull
      @Override
      public String getTextFor(PsiLiteralExpression value) {
        final Object o = value.getValue();
        LOG.assertTrue(o instanceof String);
        return (String)o;
      }
    }).showInBestPositionFor(myEditor);
  }
}
 

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
@Override
public void fix(final JComponent contextComponent, RelativePoint relativePoint) {
  JBPopupFactory.getInstance().createListPopup(new BaseListPopupStep<ConfigurationErrorQuickFix>(null, myDescription.getFixes()) {
    @NotNull
    @Override
    public String getTextFor(ConfigurationErrorQuickFix value) {
      return value.getActionName();
    }

    @Override
    public PopupStep onChosen(final ConfigurationErrorQuickFix selectedValue, boolean finalChoice) {
      return doFinalStep(new Runnable() {
        @Override
        public void run() {
          selectedValue.performFix();
        }
      });
    }
  }).show(relativePoint);
}
 

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
public static BaseListPopupStep<LibraryType> createChooseTypeStep(final ClasspathPanel classpathPanel,
                                                                  final ParameterizedRunnable<LibraryType> action) {
  return new BaseListPopupStep<LibraryType>(IdeBundle.message("popup.title.select.library.type"), getSuitableTypes(classpathPanel)) {
        @NotNull
        @Override
        public String getTextFor(LibraryType value) {
          return value != null ? value.getCreateActionName() : IdeBundle.message("create.default.library.type.action.name");
        }

        @Override
        public Icon getIconFor(LibraryType aValue) {
          return aValue != null ? aValue.getIcon(null) : PlatformIcons.LIBRARY_ICON;
        }

        @Override
        public PopupStep onChosen(final LibraryType selectedValue, boolean finalChoice) {
          return doFinalStep(new Runnable() {
            @Override
            public void run() {
              action.run(selectedValue);
            }
          });
        }
      };
}
 

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
private static ListPopupStep buildStep(@NotNull final List<Pair<AnAction, KeyStroke>> actions, final DataContext ctx) {
  return new BaseListPopupStep<Pair<AnAction, KeyStroke>>("Choose an action", ContainerUtil.findAll(actions, new Condition<Pair<AnAction, KeyStroke>>() {
    @Override
    public boolean value(Pair<AnAction, KeyStroke> pair) {
      final AnAction action = pair.getFirst();
      final Presentation presentation = action.getTemplatePresentation().clone();
      AnActionEvent event = new AnActionEvent(null, ctx,
                                              ActionPlaces.UNKNOWN,
                                              presentation,
                                              ActionManager.getInstance(),
                                              0);

      ActionUtil.performDumbAwareUpdate(action, event, true);
      return presentation.isEnabled() && presentation.isVisible();
    }
  })) {
    @Override
    public PopupStep onChosen(Pair<AnAction, KeyStroke> selectedValue, boolean finalChoice) {
      invokeAction(selectedValue.getFirst(), ctx);
      return FINAL_CHOICE;
    }
  };
}
 

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
private static ListPopup createPopup(final ArrayList<VirtualFile> files, final ArrayList<Icon> icons) {
  final BaseListPopupStep<VirtualFile> step = new BaseListPopupStep<VirtualFile>("File Path", files, icons) {
    @NotNull
    @Override
    public String getTextFor(final VirtualFile value) {
      return value.getPresentableName();
    }

    @Override
    public PopupStep onChosen(final VirtualFile selectedValue, final boolean finalChoice) {
      final File selectedFile = new File(getPresentableUrl(selectedValue));
      if (selectedFile.exists()) {
        ApplicationManager.getApplication().executeOnPooledThread(new Runnable() {
          @Override
          public void run() {
            openFile(selectedFile);
          }
        });
      }
      return FINAL_CHOICE;
    }
  };

  return JBPopupFactory.getInstance().createListPopup(step);
}
 

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
private void showHistory() {
  List<XExpression> expressions = myExpressionEditor.getRecentExpressions();
  if (!expressions.isEmpty()) {
    ListPopupImpl popup = new ListPopupImpl(new BaseListPopupStep<XExpression>(null, expressions) {
      @Override
      public PopupStep onChosen(XExpression selectedValue, boolean finalChoice) {
        myExpressionEditor.setExpression(selectedValue);
        myExpressionEditor.requestFocusInEditor();
        return FINAL_CHOICE;
      }
    }) {
      @Override
      protected ListCellRenderer getListElementRenderer() {
        return new ColoredListCellRenderer<XExpression>() {
          @Override
          protected void customizeCellRenderer(JList list, XExpression value, int index, boolean selected, boolean hasFocus) {
            append(value.getExpression());
          }
        };
      }
    };
    popup.getList().setFont(EditorUtil.getEditorFont());
    popup.showUnderneathOf(myExpressionEditor.getEditorComponent());
  }
}
 

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
@Override
public PopupStep onChosen(final VirtualFile selectedValue, boolean finalChoice) {
  if (selectedValue == null) {
    myNewBaseSelector.run();
    return null;
  }
  final List<AbstractFilePatchInProgress.PatchChange> selectedChanges = myChangesTreeList.getSelectedChanges();
  if (selectedChanges.size() >= 1) {
    for (AbstractFilePatchInProgress.PatchChange patchChange : selectedChanges) {
      final AbstractFilePatchInProgress patch = patchChange.getPatchInProgress();
      patch.setNewBase(selectedValue);
    }
    updateTree(false);
  }
  return null;
}
 

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
@Override
public PopupStep onChosen(LookupElementAction selectedValue, boolean finalChoice) {
  final LookupElementAction.Result result = selectedValue.performLookupAction();
  if (result == LookupElementAction.Result.HIDE_LOOKUP) {
    myLookup.hideLookup(true);
  } else if (result == LookupElementAction.Result.REFRESH_ITEM) {
    myLookup.updateLookupWidth(myLookupElement);
    myLookup.requestResize();
    myLookup.refreshUi(false, true);
  } else if (result instanceof LookupElementAction.Result.ChooseItem) {
    myLookup.setCurrentItem(((LookupElementAction.Result.ChooseItem)result).item);
    CommandProcessor.getInstance().executeCommand(myLookup.getEditor().getProject(), new Runnable() {
      @Override
      public void run() {
        myLookup.finishLookup(Lookup.AUTO_INSERT_SELECT_CHAR);
      }
    }, null, null);
  }
  return FINAL_CHOICE;
}
 

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
private PopupStep addExcludedFramework(final @NotNull FrameworkType frameworkType) {
  final String projectItem = "In the whole project";
  return new BaseListPopupStep<String>(null, new String[]{projectItem, "In directory..."}) {
    @Override
    public PopupStep onChosen(String selectedValue, boolean finalChoice) {
      if (selectedValue.equals(projectItem)) {
        addAndRemoveDuplicates(frameworkType, null);
        return FINAL_CHOICE;
      }
      else {
        return doFinalStep(new Runnable() {
          @Override
          public void run() {
            chooseDirectoryAndAdd(frameworkType);
          }
        });
      }
    }
  };
}
 

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
public PopupStep onChosen(final ErrorWithFix selectedValue, final boolean finalChoice) {
  if (selectedValue.second instanceof PopupQuickFix) {
    return ((PopupQuickFix) selectedValue.second).getPopupStep();
  }
  if (finalChoice || !myShowSuppresses) {
    return doFinalStep(new Runnable() {
      public void run() {
        CommandProcessor.getInstance().executeCommand(myEditor.getProject(), new Runnable() {
          public void run() {
            selectedValue.second.run();
          }
        }, selectedValue.second.getName(), null);
      }
    });
  }
  if (selectedValue.first.getInspectionId() != null && selectedValue.second.getComponent() != null &&
      !(selectedValue.second instanceof SuppressFix)) {
    ArrayList<ErrorWithFix> suppressList = new ArrayList<ErrorWithFix>();
    buildSuppressFixes(selectedValue.first, suppressList, false);
    return new QuickFixPopupStep(suppressList, false);
  }
  return FINAL_CHOICE;
}
 

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
private void doFix(Editor editor, final DomFileElement<IdeaPlugin> element) {
  if (myEPCandidates.size() == 1) {
    registerExtension(element, myEPCandidates.get(0));
  }
  else {
    final BaseListPopupStep<ExtensionPointCandidate> popupStep =
      new BaseListPopupStep<ExtensionPointCandidate>("Choose Extension Point", myEPCandidates) {
        @Override
        public PopupStep onChosen(ExtensionPointCandidate selectedValue, boolean finalChoice) {
          registerExtension(element, selectedValue);
          return FINAL_CHOICE;
        }
      };
    JBPopupFactory.getInstance().createListPopup(popupStep).showInBestPositionFor(editor);
  }
}
 

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
@Override
public void invoke(@NotNull final Project project, final Editor editor, final PsiFile file) throws IncorrectOperationException {
  final PsiModifierListOwner modifierListOwner = getElement(editor, file);
  if (modifierListOwner == null) throw new IncorrectOperationException();

  BaseListPopupStep<Nls.Capitalization> step =
    new BaseListPopupStep<Nls.Capitalization>(null, Nls.Capitalization.Title, Nls.Capitalization.Sentence) {
      @Override
      public PopupStep onChosen(final Nls.Capitalization selectedValue, boolean finalChoice) {
        new WriteCommandAction.Simple(project) {
          @Override
          protected void run() throws Throwable {
            String nls = Nls.class.getName();
            PsiAnnotation annotation = JavaPsiFacade.getInstance(project).getElementFactory()
              .createAnnotationFromText("@" + nls + "(capitalization = " +
                                        nls + ".Capitalization." + selectedValue.toString() + ")", modifierListOwner);
            new AddAnnotationFix(Nls.class.getName(), modifierListOwner, annotation.getParameterList().getAttributes()).applyFix();
          }
        }.execute();
        return FINAL_CHOICE;
      }
    };
  JBPopupFactory.getInstance().createListPopup(step).showInBestPositionFor(editor);
}
 

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
public static BaseListPopupStep<LibraryType> createChooseTypeStep(final ClasspathPanel classpathPanel,
                                                                  final ParameterizedRunnable<LibraryType> action) {
  return new BaseListPopupStep<LibraryType>(IdeBundle.message("popup.title.select.library.type"), getSuitableTypes(classpathPanel)) {
        @NotNull
        @Override
        public String getTextFor(LibraryType value) {
          return value != null ? value.getCreateActionName() : IdeBundle.message("create.default.library.type.action.name");
        }

        @Override
        public Icon getIconFor(LibraryType aValue) {
          return aValue != null ? aValue.getIcon() : PlatformIcons.LIBRARY_ICON;
        }

        @Override
        public PopupStep onChosen(final LibraryType selectedValue, boolean finalChoice) {
          return doFinalStep(new Runnable() {
            @Override
            public void run() {
              action.run(selectedValue);
            }
          });
        }
      };
}
 

import com.intellij.openapi.ui.popup.PopupStep; //导入依赖的package包/类
private static ListPopup createPopup(final ArrayList<VirtualFile> files, final ArrayList<Icon> icons) {
  final BaseListPopupStep<VirtualFile> step = new BaseListPopupStep<VirtualFile>("File Path", files, icons) {
    @NotNull
    @Override
    public String getTextFor(final VirtualFile value) {
      return value.getPresentableName();
    }

    @Override
    public PopupStep onChosen(final VirtualFile selectedValue, final boolean finalChoice) {
      final File selectedFile = new File(getPresentableUrl(selectedValue));
      if (selectedFile.exists()) {
        ApplicationManager.getApplication().executeOnPooledThread(new Runnable() {
          public void run() {
            openFile(selectedFile);
          }
        });
      }
      return FINAL_CHOICE;
    }
  };

  return JBPopupFactory.getInstance().createListPopup(step);
}