com.intellij.ui.popup.list.ListPopupImpl Java Examples

@Nonnull
@Override
public ListPopup createConfirmation(String title, final String yesText, String noText, final Runnable onYes, final Runnable onNo, int defaultOptionIndex) {
  final BaseListPopupStep<String> step = new BaseListPopupStep<String>(title, yesText, noText) {
    @Override
    public PopupStep onChosen(String selectedValue, final boolean finalChoice) {
      return doFinalStep(selectedValue.equals(yesText) ? onYes : onNo);
    }

    @Override
    public void canceled() {
      onNo.run();
    }

    @Override
    public boolean isMnemonicsNavigationEnabled() {
      return true;
    }
  };
  step.setDefaultOptionIndex(defaultOptionIndex);

  final Application app = ApplicationManager.getApplication();
  return app == null || !app.isUnitTestMode() ? new ListPopupImpl(step) : new MockConfirmation(step, yesText);
}
 

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(@Nonnull JList list, XExpression value, int index, boolean selected, boolean hasFocus) {
            append(value.getExpression());
          }
        };
      }
    };
    popup.getList().setFont(EditorUtil.getEditorFont());
    popup.showUnderneathOf(myExpressionEditor.getEditorComponent());
  }
}
 

private static Action createNumberAction(final int number, final ListPopupImpl listPopup, final Executor executor) {
  return new AbstractAction() {
    @Override
    public void actionPerformed(ActionEvent e) {
      if (listPopup.getSpeedSearch().isHoldingFilter()) return;
      for (final Object item : listPopup.getListStep().getValues()) {
        if (item instanceof ItemWrapper && ((ItemWrapper)item).getMnemonic() == number) {
          listPopup.setFinalRunnable(new Runnable() {
            @Override
            public void run() {
              execute((ItemWrapper)item, executor);
            }
          });
          listPopup.closeOk(null);
        }
      }
    }
  };
}
 

private static Action createNumberAction(final int mnemonic,
                                         final ListPopupImpl listPopup,
                                         final Map<PsiElement, GotoRelatedItem> itemsMap,
                                         final Processor<Object> processor) {
  return new AbstractAction() {
    @Override
    public void actionPerformed(ActionEvent e) {
      for (final Object item : listPopup.getListStep().getValues()) {
        if (getMnemonic(item, itemsMap) == mnemonic) {
          listPopup.setFinalRunnable(new Runnable() {
            @Override
            public void run() {
              processor.process(item);
            }
          });
          listPopup.closeOk(null);
        }
      }
    }
  };
}
 

public ListPopup createConfirmation(String title, final String yesText, String noText, final Runnable onYes, final Runnable onNo, int defaultOptionIndex) {

		final BaseListPopupStep<String> step = new BaseListPopupStep<String>(title, new String[]{yesText, noText}) {
			@Override
			public PopupStep onChosen(String selectedValue, final boolean finalChoice) {
				if (selectedValue.equals(yesText)) {
					onYes.run();
				} else {
					onNo.run();
				}
				return FINAL_CHOICE;
			}

			@Override
			public void canceled() {
			}

			@Override
			public boolean isMnemonicsNavigationEnabled() {
				return true;
			}
		};
		step.setDefaultOptionIndex(defaultOptionIndex);

		final ApplicationEx app = ApplicationManagerEx.getApplicationEx();
		return app == null || !app.isUnitTestMode() ? new ListPopupImpl(step) : new MockConfirmation(step, yesText);
	}
 

private void registerActions(final ListPopupImpl popup) {
	if (ApplicationSettings.get().isEnableDelete()) {
		popup.registerAction("delete", KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0), new AbstractAction() {
			public void actionPerformed(ActionEvent e) {
				JList list = popup.getList();
				int selectedIndex = list.getSelectedIndex();
				ListPopupModel model = (ListPopupModel) list.getModel();
				PopupFactoryImpl.ActionItem selectedItem = (PopupFactoryImpl.ActionItem) model.get(selectedIndex);

				if (selectedItem != null && selectedItem.getAction() instanceof MyActionGroup) {
					MyActionGroup action = (MyActionGroup) selectedItem.getAction();
					boolean deleted = ApplicationService.getInstance().getState().removeGoal(action.getGoal());

					if (deleted) {
						model.deleteItem(selectedItem);
						if (selectedIndex == list.getModel().getSize()) { // is last
							list.setSelectedIndex(selectedIndex - 1);
						} else {
							list.setSelectedIndex(selectedIndex);
						}
					}
				}
			}
		});

	}
}
 

protected WizardPopup createPopup(WizardPopup parent, PopupStep step, Object parentValue) {
  if (step instanceof AsyncPopupStep) {
    return new AsyncPopupImpl(getProject(), parent, (AsyncPopupStep)step, parentValue);
  }
  if (step instanceof ListPopupStep) {
    return new ListPopupImpl(getProject(), parent, (ListPopupStep)step, parentValue);
  }
  else if (step instanceof TreePopupStep) {
    return new TreePopupImpl(getProject(), parent, (TreePopupStep)step, parentValue);
  }
  else {
    throw new IllegalArgumentException(step.getClass().toString());
  }
}
 

@Nonnull
@Override
public ListPopup createListPopup(@Nonnull ListPopupStep step, int maxRowCount) {
  ListPopupImpl popup = new ListPopupImpl(step);
  popup.setMaxRowCount(maxRowCount);
  return popup;
}
 

public static void registerExtraHandleShortcuts(final ListPopupImpl popup, String... actionNames) {
  for (String name : actionNames) {
    KeyStroke stroke = KeymapUtil.getKeyStroke(ActionManager.getInstance().getAction(name).getShortcutSet());
    if (stroke != null) {
      popup.registerAction("handleSelection " + stroke, stroke, new AbstractAction() {
        @Override
        public void actionPerformed(ActionEvent e) {
          popup.handleSelect(true);
        }
      });
    }
  }
}
 

private static Action createNumberAction(final int mnemonic, final ListPopupImpl listPopup, final Map<PsiElement, GotoRelatedItem> itemsMap, final Processor<Object> processor) {
  return new AbstractAction() {
    @Override
    public void actionPerformed(ActionEvent e) {
      for (final Object item : listPopup.getListStep().getValues()) {
        if (getMnemonic(item, itemsMap) == mnemonic) {
          listPopup.setFinalRunnable(() -> processor.process(item));
          listPopup.closeOk(null);
        }
      }
    }
  };
}
 

@Override
protected void showPopup(AnActionEvent e, ListPopup p) {
	final ListPopupImpl popup = (ListPopupImpl) p;
	registerActions(popup);
	super.showPopup(e, popup);
}
 

@Nonnull
@Override
public ListPopup createListPopup(@Nonnull ListPopupStep step) {
  return new ListPopupImpl(step);
}
 

MyPopupListElementRenderer(ListPopupImpl aPopup) {
  super(aPopup);
}
 

@Override
public void actionPerformed(@Nonnull AnActionEvent e) {
  final Project project = getEventProject(e);
  if (project == null) return;


  new Task.Backgroundable(project, XDebuggerBundle.message("xdebugger.attach.action.collectingItems"), true, PerformInBackgroundOption.DEAF) {
    @Override
    public void run(@Nonnull ProgressIndicator indicator) {

      List<AttachItem> allItems = ContainerUtil.immutableList(getTopLevelItems(indicator, project));

      ApplicationManager.getApplication().invokeLater(() -> {
        AttachListStep step = new AttachListStep(allItems, XDebuggerBundle.message("xdebugger.attach.popup.title.default"), project);

        final ListPopup popup = JBPopupFactory.getInstance().createListPopup(step);
        final JList mainList = ((ListPopupImpl)popup).getList();

        ListSelectionListener listener = event -> {
          if (event.getValueIsAdjusting()) return;

          Object item = ((JList)event.getSource()).getSelectedValue();

          // if a sub-list is closed, fallback to the selected value from the main list
          if (item == null) {
            item = mainList.getSelectedValue();
          }

          if (item instanceof AttachToProcessItem) {
            popup.setCaption(((AttachToProcessItem)item).getSelectedDebugger().getDebuggerSelectedTitle());
          }

          if (item instanceof AttachHostItem) {
            AttachHostItem hostItem = (AttachHostItem)item;
            String attachHostName = hostItem.getText(project);
            attachHostName = StringUtil.shortenTextWithEllipsis(attachHostName, 50, 0);

            popup.setCaption(XDebuggerBundle.message("xdebugger.attach.host.popup.title", attachHostName));
          }
        };
        popup.addListSelectionListener(listener);

        // force first valueChanged event
        listener.valueChanged(new ListSelectionEvent(mainList, mainList.getMinSelectionIndex(), mainList.getMaxSelectionIndex(), false));

        popup.showCenteredInCurrentWindow(project);
      }, project.getDisposed());
    }
  }.queue();
}
 

public PopupListElementRendererWithIcon(ListPopupImpl aPopup) {
  super(aPopup);
}
 

private RunListElementRenderer(ListPopupImpl popup, boolean hasSideBar) {
  super(popup);

  myPopup1 = popup;
  myHasSideBar = hasSideBar;
}