Java LookupItem类代码示例

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
public static boolean insertParentheses(InsertionContext context,
                                        LookupItem delegate,
                                        final PsiClass psiClass,
                                        final boolean forAnonymous) {
  if (context.getCompletionChar() == '[') {
    return false;
  }

  final PsiElement place = context.getFile().findElementAt(context.getStartOffset());
  assert place != null;
  boolean hasParams = hasConstructorParameters(psiClass, place);

  JavaCompletionUtil.insertParentheses(context, delegate, false, hasParams, forAnonymous);

  return true;
}
 

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
public static boolean isToStrikeout(LookupItem<?> item) {
  final List<PsiMethod> allMethods = item.getUserData(JavaCompletionUtil.ALL_METHODS_ATTRIBUTE);
  if (allMethods != null){
    for (PsiMethod method : allMethods) {
      if (!method.isValid()) { //?
        return false;
      }
      if (!isDeprecated(method)) {
        return false;
      }
    }
    return true;
  }
  else if (item.getObject() instanceof PsiElement) {
    final PsiElement element = (PsiElement)item.getObject();
    if (element.isValid()) {
      return isDeprecated(element);
    }
  }
  return false;
}
 

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
protected void addLookupItem(Set<LookupElement> set, TailType tailType, @Nonnull Object completion, final CompletionVariant variant) {
  LookupElement ret = objectToLookupItem(completion);
  if (ret == null) return;
  if (!(ret instanceof LookupItem)) {
    set.add(ret);
    return;
  }

  LookupItem item = (LookupItem)ret;

  final InsertHandler insertHandler = variant.getInsertHandler();
  if(insertHandler != null && item.getInsertHandler() == null) {
    item.setInsertHandler(insertHandler);
    item.setTailType(TailType.UNKNOWN);
  }
  else if (tailType != TailType.NONE) {
    item.setTailType(tailType);
  }
  final Map<Object, Object> itemProperties = variant.getItemProperties();
  for (final Object key : itemProperties.keySet()) {
    item.setAttribute(key, itemProperties.get(key));
  }

  set.add(ret);
}
 

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
@Override
public void handleInsert(final InsertionContext context, LookupElement lookupElement)
{
	context.commitDocument();

	TailType tailType = getTailType(context.getCompletionChar(), (LookupItem) lookupElement);

	final Editor editor = context.getEditor();
	editor.getCaretModel().moveToOffset(context.getSelectionEndOffset());
	tailType.processTail(editor, context.getSelectionEndOffset());
	editor.getSelectionModel().removeSelection();

	if(tailType == TailType.DOT || context.getCompletionChar() == '.')
	{
		AutoPopupController.getInstance(context.getProject()).autoPopupMemberLookup(editor, null);
	}
}
 

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
private static TailType getTailType(final char completionChar, LookupItem item)
{
	switch(completionChar)
	{
		case '.':
			return new CharTailType('.', false);
		case ',':
			return TailType.COMMA;
		case ';':
			return TailType.SEMICOLON;
		case '=':
			return TailType.EQ;
		case ' ':
			return TailType.SPACE;
		case ':':
			return TailType.CASE_COLON; //?
		case '<':
		case '>':
		case '\"':
	}
	final TailType attr = item.getTailType();
	return attr == TailType.UNKNOWN ? TailType.NONE : attr;
}
 

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
private static LookupElementDecorator<LookupElement> withInsertHandler(final SuggestedNameInfo callback, LookupElement element)
{
	return LookupElementDecorator.withInsertHandler(element, new InsertHandler<LookupElementDecorator<LookupElement>>()
	{
		@Override
		public void handleInsert(InsertionContext context, LookupElementDecorator<LookupElement> item)
		{
			TailType tailType = LookupItem.getDefaultTailType(context.getCompletionChar());
			if(tailType != null)
			{
				context.setAddCompletionChar(false);
				tailType.processTail(context.getEditor(), context.getTailOffset());
			}
			callback.nameChosen(item.getLookupString());
		}
	});
}
 

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
@Override
public void handleInsert(final InsertionContext context, LookupElement lookupElement) {
  context.commitDocument();

  TailType tailType = getTailType(context.getCompletionChar(), (LookupItem)lookupElement);

  final Editor editor = context.getEditor();
  editor.getCaretModel().moveToOffset(context.getSelectionEndOffset());
  tailType.processTail(editor, context.getSelectionEndOffset());
  editor.getSelectionModel().removeSelection();

  if (tailType == TailType.DOT || context.getCompletionChar() == '.') {
    AutoPopupController.getInstance(context.getProject()).autoPopupMemberLookup(editor, null);
  }
}
 

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
private static TailType getTailType(final char completionChar, LookupItem item){
  switch(completionChar){
    case '.': return new CharTailType('.', false);
    case ',': return TailType.COMMA;
    case ';': return TailType.SEMICOLON;
    case '=': return TailType.EQ;
    case ' ': return TailType.SPACE;
    case ':': return TailType.CASE_COLON; //?
    case '<':
    case '>':
    case '\"':
  }
  final TailType attr = item.getTailType();
  return attr == TailType.UNKNOWN ? TailType.NONE : attr;
}
 

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
@Override
public void renderElement(final LookupItem item, final Object element, final LookupElementPresentation presentation) {
  presentation.setIcon(DefaultLookupItemRenderer.getRawIcon(item, presentation.isReal()));

  presentation.setItemText(PsiUtilCore.getName((PsiElement)element));
  presentation.setStrikeout(isToStrikeout(item));

  presentation.setTailText((String)item.getAttribute(LookupItem.TAIL_TEXT_ATTR), item.getAttribute(LookupItem.TAIL_TEXT_SMALL_ATTR) != null);

  PsiType type = ((BeanPropertyElement)element).getPropertyType();
  presentation.setTypeText(type == null ? null : type.getPresentableText());
}
 

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
@Override
public Double weigh(@NotNull LookupElement element, @NotNull CompletionLocation location) {
  final PrioritizedLookupElement prioritized = element.as(PrioritizedLookupElement.CLASS_CONDITION_KEY);
  if (prioritized != null) {
    return prioritized.getPriority();
  }

  final LookupItem item = element.as(LookupItem.CLASS_CONDITION_KEY);
  if (item != null) {
    return item.getPriority();
  }
  return 0.0;
}
 

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
@Override
public boolean handleUserSelection(LookupItem item, Project project) {
  if (!myIsStandard) {
    item.setLookupString(myValue);
  }
  return true;
}
 

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
private static void addResult(CompletionResultSet result, Collection<Lookup> collection, PsiElement position, int offset) {
  result = result.withPrefixMatcher(findPrefixStatic(position, offset));

  for (Lookup lookup : collection) {
    final LookupItem<Lookup> item = new LookupItem<Lookup>(lookup, lookup.toString());
    item.setInsertHandler(INSERT_HANDLER);
    if (lookup.isKeyword()) {
      item.setBold();
    }
    result.addElement(item);
  }
}
 

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
private void handleInsertInner(InsertionContext context, LookupItem item, final char completionChar) {
  final Project project = context.getProject();
  final Editor editor = context.getEditor();
  final Document document = editor.getDocument();
  PsiDocumentManager.getInstance(project).commitDocument(document);

  TailType tailType = getTailType(completionChar, item);

  InsertHandlerState state = new InsertHandlerState(context.getSelectionEndOffset(), context.getSelectionEndOffset());

  if (completionChar == Lookup.REPLACE_SELECT_CHAR) {
    removeEndOfIdentifier(context);
  }
  else if(context.getOffsetMap().getOffset(CompletionInitializationContext.IDENTIFIER_END_OFFSET) != context.getSelectionEndOffset()) {
    JavaCompletionUtil.resetParensInfo(context.getOffsetMap());
  }

  handleParentheses(false, false, tailType, context, state);

  context.setTailOffset(state.tailOffset);
  state.caretOffset = processTail(tailType, state.caretOffset, state.tailOffset, editor);
  editor.getSelectionModel().removeSelection();

  if (tailType == TailType.DOT || context.getCompletionChar() == '.') {
    AutoPopupController.getInstance(project).autoPopupMemberLookup(editor, null);
  }

}
 

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
protected TailType getTailType(final char completionChar, LookupItem item){
  switch(completionChar){
    case '.': return new CharTailType('.', false);
    case ',': return TailType.COMMA;
    case ';': return TailType.SEMICOLON;
    case '=': return TailType.EQ;
    case ' ': return TailType.SPACE;
    case ':': return TailType.CASE_COLON; //?
    case '<':
    case '>':
    case '\"':
  }
  final TailType attr = item.getTailType();
  return attr == TailType.UNKNOWN ? TailType.NONE : attr;
}
 

import com.intellij.codeInsight.lookup.LookupItem; //导入依赖的package包/类
public static void renderClassItem(LookupElementPresentation presentation, LookupItem item, PsiClass psiClass, boolean diamond) {
  if (!(psiClass instanceof PsiTypeParameter)) {
    presentation.setIcon(DefaultLookupItemRenderer.getRawIcon(item, presentation.isReal()));
  }

  final boolean bold = item.getAttribute(LookupItem.HIGHLIGHTED_ATTR) != null;
  boolean strikeout = JavaElementLookupRenderer.isToStrikeout(item);
  presentation.setItemText(getName(psiClass, item, diamond));
  presentation.setStrikeout(strikeout);
  presentation.setItemTextBold(bold);

  String tailText = getLocationString(item);
  PsiSubstitutor substitutor = (PsiSubstitutor)item.getAttribute(LookupItem.SUBSTITUTOR);

  if (item instanceof PsiTypeLookupItem) {
    if (((PsiTypeLookupItem)item).isIndicateAnonymous() &&
        (psiClass.isInterface() || psiClass.hasModifierProperty(PsiModifier.ABSTRACT)) ||
        ((PsiTypeLookupItem)item).isAddArrayInitializer()) {
      tailText = "{...}" + tailText;
    }
  }
  if (substitutor == null && !diamond && psiClass.getTypeParameters().length > 0) {
    tailText = "<" + StringUtil.join(psiClass.getTypeParameters(), new Function<PsiTypeParameter, String>() {
      @Override
      public String fun(PsiTypeParameter psiTypeParameter) {
        return psiTypeParameter.getName();
      }
    }, "," + (showSpaceAfterComma(psiClass) ? " " : "")) + ">" + tailText;
  }
  presentation.setTailText(tailText, true);
}