Java PopupChooserBuilder.setItemChoosenCallback方法代码示例

import com.intellij.openapi.ui.popup.PopupChooserBuilder; //导入方法依赖的package包/类
public static JBPopup createAmbigTreesPopup(final PreviewState previewState,
                                            final AmbiguityInfo ambigInfo) {
	final JBList list = new JBList("Show all phrase interpretations");
	list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
	JBPopupFactory factory = JBPopupFactory.getInstance();
	PopupChooserBuilder builder = factory.createListPopupBuilder(list);
	builder.setItemChoosenCallback(
		new Runnable() {
			@Override
			public void run() {
				popupAmbigTreesDialog(previewState, ambigInfo);
			}
		}
	                              );
	JBPopup popup = builder.createPopup();
	return popup;
}
 

import com.intellij.openapi.ui.popup.PopupChooserBuilder; //导入方法依赖的package包/类
public static JBPopup createLookaheadTreesPopup(final PreviewState previewState,
                                                final LookaheadEventInfo lookaheadInfo) {
	final JBList list = new JBList("Show all lookahead interpretations");
	list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
	JBPopupFactory factory = JBPopupFactory.getInstance();
	PopupChooserBuilder builder = factory.createListPopupBuilder(list);
	builder.setItemChoosenCallback(
		new Runnable() {
			@Override
			public void run() {
				popupLookaheadTreesDialog(previewState, lookaheadInfo);
			}
		}
	                              );

	JBPopup popup = builder.createPopup();
	return popup;
}
 

import com.intellij.openapi.ui.popup.PopupChooserBuilder; //导入方法依赖的package包/类
@Override
public void invoke(@NotNull Project project, Editor editor, @NotNull PsiElement element) throws IncorrectOperationException {
     // filter libraries to only be Camel libraries
    Set<String> artifacts = ServiceManager.getService(project, CamelService.class).getLibraries();

    // find the camel component from those libraries
    boolean consumerOnly = getCamelIdeaUtils().isConsumerEndpoint(element);
    List<String> names = findCamelComponentNamesInArtifact(artifacts, consumerOnly, project);

    // no camel endpoints then exit
    if (names.isEmpty()) {
        return;
    }

    // show popup to chose the component
    JBList list = new JBList(names.toArray(new Object[names.size()]));
    PopupChooserBuilder builder = JBPopupFactory.getInstance().createListPopupBuilder(list);
    builder.setAdText(names.size() + " components");
    builder.setTitle("Add Camel Endpoint");
    builder.setItemChoosenCallback(() -> {
        String line = (String) list.getSelectedValue();
        int pos = editor.getCaretModel().getCurrentCaret().getOffset();
        if (pos > 0) {
            // must run this as write action because we change the source code
            new WriteCommandAction(project, element.getContainingFile()) {
                @Override
                protected void run(@NotNull Result result) throws Throwable {
                    String text = line + ":";
                    editor.getDocument().insertString(pos, text);
                    editor.getCaretModel().moveToOffset(pos + text.length());
                }
            }.execute();
        }
    });

    JBPopup popup = builder.createPopup();
    popup.showInBestPositionFor(editor);
}
 

import com.intellij.openapi.ui.popup.PopupChooserBuilder; //导入方法依赖的package包/类
protected void processIntention(PsiElement psiElement) {
    GLSLIdentifier elementTemp = null;
    if(psiElement instanceof GLSLIdentifier){
        elementTemp = (GLSLIdentifier) psiElement;
    }else{
        PsiElement parent = psiElement.getParent();
        if(parent instanceof GLSLIdentifier){
            elementTemp = (GLSLIdentifier) parent;
        }
    }
    if(elementTemp == null){
        Logger.getInstance(VectorComponentsIntention.class).warn("Could not find GLSLIdentifier for psiElement: "+psiElement);
        return;
    }
    final GLSLIdentifier element = elementTemp;

    String components = element.getText();

    createComponentVariants(components);

    String[] variants = new String[]{components + " -> " + results[0], components + " -> " + results[1]};
    //http://www.jetbrains.net/devnet/message/5208622#5208622
    final JBList list = new JBList((Object[])variants);
    PopupChooserBuilder builder = new PopupChooserBuilder(list);
    builder.setTitle("Select Variant");
    builder.setItemChoosenCallback(new Runnable() {
        public void run() {
            WriteCommandAction writeAction = new WriteCommandAction(element.getProject(), element.getContainingFile()) {
                @Override
                protected void run(@NotNull Result result) throws Throwable {
                    replaceIdentifierElement(element, results[list.getSelectedIndex()]);
                }
            };
            writeAction.execute();
        }
    });
    JBPopup popup = builder.createPopup();
    popup.showInBestPositionFor(getEditor());
}
 

import com.intellij.openapi.ui.popup.PopupChooserBuilder; //导入方法依赖的package包/类
private JBPopup buildPopup(final JBList list,
         final Map<Object, String> filterIndex)
{
   final PopupChooserBuilder listPopupBuilder = JBPopupFactory.getInstance().createListPopupBuilder(list);
   listPopupBuilder.setTitle("Run a Forge command");
   listPopupBuilder.setResizable(true);
   listPopupBuilder.addListener(new JBPopupAdapter()
   {
      @Override
      public void onClosed(LightweightWindowEvent event)
      {
         CommandListPopupBuilder.active = false;
      }
   });
   listPopupBuilder.setItemChoosenCallback((Runnable) () -> {
      Object selectedObject = list.getSelectedValue();
      if (selectedObject instanceof UICommand)
      {
         UICommand selectedCommand = (UICommand) selectedObject;

         // Make sure that this cached command is still enabled
         if (selectedCommand.isEnabled(uiContext))
         {
            openWizard(selectedCommand);
         }
      }
   });
   listPopupBuilder.setFilteringEnabled(filterIndex::get);

   return listPopupBuilder.createPopup();
}
 

import com.intellij.openapi.ui.popup.PopupChooserBuilder; //导入方法依赖的package包/类
@Override
protected void selectTargets(final List<PsiMember> targets, final Consumer<List<PsiMember>> selectionConsumer) {
  if (targets.isEmpty()) {
    selectionConsumer.consume(Collections.<PsiMember>emptyList());
    return;
  }
  if (targets.size() == 1) {
    selectionConsumer.consume(Collections.singletonList(targets.get(0)));
    return;
  }
  if (ApplicationManager.getApplication().isUnitTestMode()) {
    selectionConsumer.consume(targets);
    return;
  }
  Collections.sort(targets, new PsiMemberComparator());
  final List<Object> model = new ArrayList<Object>();
  model.add(CodeInsightBundle.message("highlight.thrown.exceptions.chooser.all.entry"));
  model.addAll(targets);
  final JList list = new JBList(model);
  list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  final ListCellRenderer renderer = new NavigationItemListCellRenderer();
  list.setCellRenderer(renderer);
  final PopupChooserBuilder builder = new PopupChooserBuilder(list);
  builder.setFilteringEnabled(new Function<Object, String>() {
    @Override
    public String fun(Object o) {
      if (o instanceof PsiMember) {
        final PsiMember member = (PsiMember)o;
        return member.getName();
      }
      return o.toString();
    }
  });
  if (myImportStatic) {
    builder.setTitle(CodeInsightBundle.message("highlight.imported.members.chooser.title"));
  } else {
    builder.setTitle(CodeInsightBundle.message("highlight.imported.classes.chooser.title"));
  }
  builder.setItemChoosenCallback(new Runnable() {
    @Override
    public void run() {
      final int index= list.getSelectedIndex();
      if (index == 0) {
        selectionConsumer.consume(targets);
      }
      else {
        selectionConsumer.consume(Collections.singletonList(targets.get(index - 1)));
      }
    }
  });
  final JBPopup popup = builder.createPopup();
  popup.showInBestPositionFor(myEditor);
}