Java JavaContentAssistInvocationContext类代码示例

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
@Override
   protected ContentAssistInvocationContext createContext(ITextViewer viewer, int offset) 
{
         	ICompilationUnit compilationUnit = ((SourceViewer) viewer).getCompilatioUnit();
           if (compilationUnit != null) {
          
               CompletionProposalCollector completionProposalCollector = new CompletionProposalCollector(compilationUnit);
               JavaContentAssistInvocationContext invocContext = new JavaContentAssistInvocationContext(viewer, offset,
               		new NullEditorPart());
               
               completionProposalCollector.setInvocationContext(invocContext);
               return invocContext;
           } else {
               return null;
           }
       
   }
 

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
private static List<ICompletionProposal> computeProposals(
    ICompilationUnit compilationUnit, int offset) throws JavaModelException {
  IBuffer buffer = compilationUnit.getBuffer();
  IDocument document;
  if (buffer instanceof org.eclipse.jdt.internal.ui.javaeditor.DocumentAdapter) {
    document = ((org.eclipse.jdt.internal.ui.javaeditor.DocumentAdapter) buffer).getDocument();
  } else {
    document = new DocumentAdapter(buffer);
  }
  TextViewer viewer = new TextViewer(document, new Point(offset, 0));
  JavaContentAssistInvocationContext context =
      new JavaContentAssistInvocationContext(viewer, offset, compilationUnit);

  List<ICompletionProposal> proposals = new ArrayList<>();
  proposals.addAll(
      new JavaAllCompletionProposalComputer().computeCompletionProposals(context, null));
  //        proposals.addAll(new
  // TemplateCompletionProposalComputer().computeCompletionProposals(context, null));

  Collections.sort(proposals, new RelevanceSorter());
  return proposals;
}
 

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
/**
 * Creates a new completion proposal. All fields are initialized based on the provided
 * information.
 *
 * @param replacementString the actual string to be inserted into the document
 * @param replacementOffset the offset of the text to be replaced
 * @param replacementLength the length of the text to be replaced
 * @param image the image to display for this proposal
 * @param displayString the string to be displayed for the proposal If set to <code>null</code>,
 *     the replacement string will be taken as display string.
 * @param relevance the relevance
 * @param inJavadoc <code>true</code> for a javadoc proposal
 * @param invocationContext the invocation context of this completion proposal or <code>null
 *     </code> not available
 */
public JavaCompletionProposal(
    String replacementString,
    int replacementOffset,
    int replacementLength,
    Image image,
    StyledString displayString,
    int relevance,
    boolean inJavadoc,
    JavaContentAssistInvocationContext invocationContext) {
  super(invocationContext);
  Assert.isNotNull(replacementString);
  Assert.isTrue(replacementOffset >= 0);
  Assert.isTrue(replacementLength >= 0);

  setReplacementString(replacementString);
  setReplacementOffset(replacementOffset);
  setReplacementLength(replacementLength);
  setImage(image);
  setStyledDisplayString(
      displayString == null ? new StyledString(replacementString) : displayString);
  setRelevance(relevance);
  setCursorPosition(replacementString.length());
  setInJavadoc(inJavadoc);
  setSortString(displayString == null ? replacementString : displayString.getString());
}
 

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
@Override
protected CompletionProposalCollector createCollector(
    JavaContentAssistInvocationContext context) {
  CompletionProposalCollector collector = super.createCollector(context);
  collector.setIgnored(CompletionProposal.ANNOTATION_ATTRIBUTE_REF, false);
  collector.setIgnored(CompletionProposal.ANONYMOUS_CLASS_DECLARATION, false);
  collector.setIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, false);
  collector.setIgnored(CompletionProposal.FIELD_REF, false);
  collector.setIgnored(CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER, false);
  collector.setIgnored(CompletionProposal.KEYWORD, false);
  collector.setIgnored(CompletionProposal.LABEL_REF, false);
  collector.setIgnored(CompletionProposal.LOCAL_VARIABLE_REF, false);
  collector.setIgnored(CompletionProposal.METHOD_DECLARATION, false);
  collector.setIgnored(CompletionProposal.METHOD_NAME_REFERENCE, false);
  collector.setIgnored(CompletionProposal.METHOD_REF, false);
  collector.setIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION, false);
  collector.setIgnored(CompletionProposal.METHOD_REF_WITH_CASTED_RECEIVER, false);
  collector.setIgnored(CompletionProposal.PACKAGE_REF, false);
  collector.setIgnored(CompletionProposal.POTENTIAL_METHOD_DECLARATION, false);
  collector.setIgnored(CompletionProposal.VARIABLE_DECLARATION, false);
  return collector;
}
 

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
@Override
protected CompletionProposalCollector createCollector(
    JavaContentAssistInvocationContext context) {
  CompletionProposalCollector collector = super.createCollector(context);
  collector.setIgnored(CompletionProposal.ANNOTATION_ATTRIBUTE_REF, false);
  collector.setIgnored(CompletionProposal.ANONYMOUS_CLASS_DECLARATION, false);
  collector.setIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, false);
  collector.setIgnored(CompletionProposal.FIELD_REF, false);
  collector.setIgnored(CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER, false);
  collector.setIgnored(CompletionProposal.KEYWORD, false);
  collector.setIgnored(CompletionProposal.LABEL_REF, false);
  collector.setIgnored(CompletionProposal.LOCAL_VARIABLE_REF, false);
  collector.setIgnored(CompletionProposal.METHOD_DECLARATION, false);
  collector.setIgnored(CompletionProposal.METHOD_NAME_REFERENCE, false);
  collector.setIgnored(CompletionProposal.METHOD_REF, false);
  collector.setIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION, false);
  collector.setIgnored(CompletionProposal.METHOD_REF_WITH_CASTED_RECEIVER, false);
  collector.setIgnored(CompletionProposal.PACKAGE_REF, false);
  collector.setIgnored(CompletionProposal.POTENTIAL_METHOD_DECLARATION, false);
  collector.setIgnored(CompletionProposal.VARIABLE_DECLARATION, false);
  collector.setIgnored(CompletionProposal.TYPE_REF, false);
  return collector;
}
 

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
private List<IContextInformation> addContextInformations(
    JavaContentAssistInvocationContext context, int offset) {
  List<ICompletionProposal> proposals = internalComputeCompletionProposals(offset, context);
  List<IContextInformation> result = new ArrayList<IContextInformation>(proposals.size());
  List<IContextInformation> anonymousResult =
      new ArrayList<IContextInformation>(proposals.size());

  for (Iterator<ICompletionProposal> it = proposals.iterator(); it.hasNext(); ) {
    ICompletionProposal proposal = it.next();
    IContextInformation contextInformation = proposal.getContextInformation();
    if (contextInformation != null) {
      ContextInformationWrapper wrapper = new ContextInformationWrapper(contextInformation);
      wrapper.setContextInformationPosition(offset);
      if (proposal instanceof AnonymousTypeCompletionProposal) anonymousResult.add(wrapper);
      else result.add(wrapper);
    }
  }

  if (result.size() == 0) return anonymousResult;
  return result;
}
 

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
private IJavaCompletionProposal createTypeProposal(
    int relevance, String fullyQualifiedType, JavaContentAssistInvocationContext context)
    throws JavaModelException {
  IType type = context.getCompilationUnit().getJavaProject().findType(fullyQualifiedType);
  if (type == null) return null;

  CompletionProposal proposal =
      CompletionProposal.create(CompletionProposal.TYPE_REF, context.getInvocationOffset());
  proposal.setCompletion(fullyQualifiedType.toCharArray());
  proposal.setDeclarationSignature(type.getPackageFragment().getElementName().toCharArray());
  proposal.setFlags(type.getFlags());
  proposal.setRelevance(relevance);
  proposal.setReplaceRange(context.getInvocationOffset(), context.getInvocationOffset());
  proposal.setSignature(Signature.createTypeSignature(fullyQualifiedType, true).toCharArray());

  if (shouldProposeGenerics(context.getProject()))
    return new LazyGenericTypeProposal(proposal, context);
  else return new LazyJavaTypeCompletionProposal(proposal, context);
}
 

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
public JavaTypeCompletionProposal(
    String replacementString,
    ICompilationUnit cu,
    int replacementOffset,
    int replacementLength,
    Image image,
    StyledString displayString,
    int relevance,
    String fullyQualifiedTypeName,
    JavaContentAssistInvocationContext invocationContext) {
  super(
      replacementString,
      replacementOffset,
      replacementLength,
      image,
      displayString,
      relevance,
      false,
      invocationContext);
  fCompilationUnit = cu;
  fFullyQualifiedTypeName = fullyQualifiedTypeName;
  fUnqualifiedTypeName =
      fullyQualifiedTypeName != null ? Signature.getSimpleName(fullyQualifiedTypeName) : null;
}
 

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
@Override
protected CompletionProposalCollector createCollector(
    JavaContentAssistInvocationContext context) {
  CompletionProposalCollector collector = super.createCollector(context);
  collector.setIgnored(CompletionProposal.JAVADOC_TYPE_REF, false);
  collector.setIgnored(CompletionProposal.JAVADOC_FIELD_REF, false);
  collector.setIgnored(CompletionProposal.JAVADOC_METHOD_REF, false);
  collector.setIgnored(CompletionProposal.JAVADOC_PARAM_REF, false);
  collector.setIgnored(CompletionProposal.JAVADOC_VALUE_REF, false);
  collector.setIgnored(CompletionProposal.JAVADOC_BLOCK_TAG, false);
  collector.setIgnored(CompletionProposal.JAVADOC_INLINE_TAG, false);
  collector.setIgnored(CompletionProposal.TYPE_REF, false);
  collector.setIgnored(CompletionProposal.FIELD_REF, false);
  collector.setIgnored(CompletionProposal.METHOD_REF, false);
  return collector;
}
 

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
@Override
public List<ICompletionProposal> computeCompletionProposals(ContentAssistInvocationContext context, IProgressMonitor monitor) {
	ArrayList<ICompletionProposal> proposals = new ArrayList<ICompletionProposal>();
	System.out.println(context);
	if (context instanceof JavaContentAssistInvocationContext) {
		JavaContentAssistInvocationContext javaContext = (JavaContentAssistInvocationContext) context;
		try {
			if (UmletPluginUtils.hasUmletNature(javaContext.getProject())) {
				IDocument document = context.getDocument();
				if (document != null) {
					computeCompletionProposals(javaContext, document, proposals);
				}
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	return proposals;
}
 

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
private void addChangeSrcToExistingResourceProposals(JavaContentAssistInvocationContext javaContext, ArrayList<ICompletionProposal> proposals, HtmlTagAttr srcAttr) throws CoreException {
	String src = srcAttr.value.getValue();
	// add proposals for resource links
	{
		int prefixStart = src.lastIndexOf('/') + 1;
		int prefixEnd = javaContext.getInvocationOffset() - srcAttr.value.start;
		if (prefixEnd >= 0 && prefixStart < prefixEnd && prefixEnd <= src.length()) {
			String prefix = src.substring(prefixStart, prefixEnd);
			for (String path : collectResourcePaths(javaContext, prefix)) {
				// skip if no change would result
				if (src.equals(path)) {
					continue;
				}
				proposals.add(new ReplacementProposal("Change link to " + path, path, srcAttr.value.start, srcAttr.value.length()));
			}
		}
	}
}
 

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
/**
 * Creates a new completion proposal. All fields are initialized based on the provided
 * information.
 *
 * @param replacementString the actual string to be inserted into the document
 * @param replacementOffset the offset of the text to be replaced
 * @param replacementLength the length of the text to be replaced
 * @param image the image to display for this proposal
 * @param displayString the string to be displayed for the proposal If set to <code>null</code>,
 *        the replacement string will be taken as display string.
 * @param relevance the relevance
 * @param inJavadoc <code>true</code> for a javadoc proposal
 * @param invocationContext the invocation context of this completion proposal or <code>null</code> not available
 */
public JavaCompletionProposal(String replacementString, int replacementOffset, int replacementLength, Image image, StyledString displayString, int relevance, boolean inJavadoc, JavaContentAssistInvocationContext invocationContext) {
	super(invocationContext);
	Assert.isNotNull(replacementString);
	Assert.isTrue(replacementOffset >= 0);
	Assert.isTrue(replacementLength >= 0);

	setReplacementString(replacementString);
	setReplacementOffset(replacementOffset);
	setReplacementLength(replacementLength);
	setImage(image);
	setStyledDisplayString(displayString == null ? new StyledString(replacementString) : displayString);
	setRelevance(relevance);
	setCursorPosition(replacementString.length());
	setInJavadoc(inJavadoc);
	setSortString(displayString == null ? replacementString : displayString.getString());
}
 

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
@Override
protected TemplateEngine computeCompletionEngine(JavaContentAssistInvocationContext context) {
	ICompilationUnit unit= context.getCompilationUnit();
	if (unit == null)
		return null;

	IJavaProject javaProject= unit.getJavaProject();
	if (javaProject == null)
		return null;

	if (isSWTOnClasspath(javaProject)) {
		CompletionContext coreContext= context.getCoreContext();
		if (coreContext != null) {
			int tokenLocation= coreContext.getTokenLocation();
			if ((tokenLocation & CompletionContext.TL_MEMBER_START) != 0) {
				return fSWTMembersTemplateEngine;
			}
			if ((tokenLocation & CompletionContext.TL_STATEMENT_START) != 0) {
				return fSWTStatementsTemplateEngine;
			}
		}
		return fSWTTemplateEngine;
	}

	return null;
}
 

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
@Override
protected CompletionProposalCollector createCollector(JavaContentAssistInvocationContext context) {
	CompletionProposalCollector collector= super.createCollector(context);
	collector.setIgnored(CompletionProposal.ANNOTATION_ATTRIBUTE_REF, false);
	collector.setIgnored(CompletionProposal.ANONYMOUS_CLASS_DECLARATION, false);
	collector.setIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, false);
	collector.setIgnored(CompletionProposal.FIELD_REF, false);
	collector.setIgnored(CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER, false);
	collector.setIgnored(CompletionProposal.KEYWORD, false);
	collector.setIgnored(CompletionProposal.LABEL_REF, false);
	collector.setIgnored(CompletionProposal.LOCAL_VARIABLE_REF, false);
	collector.setIgnored(CompletionProposal.METHOD_DECLARATION, false);
	collector.setIgnored(CompletionProposal.METHOD_NAME_REFERENCE, false);
	collector.setIgnored(CompletionProposal.METHOD_REF, false);
	collector.setIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION, false);
	collector.setIgnored(CompletionProposal.METHOD_REF_WITH_CASTED_RECEIVER, false);
	collector.setIgnored(CompletionProposal.PACKAGE_REF, false);
	collector.setIgnored(CompletionProposal.POTENTIAL_METHOD_DECLARATION, false);
	collector.setIgnored(CompletionProposal.VARIABLE_DECLARATION, false);
	return collector;
}
 

import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; //导入依赖的package包/类
@Override
protected CompletionProposalCollector createCollector(JavaContentAssistInvocationContext context) {
	CompletionProposalCollector collector= super.createCollector(context);
	collector.setIgnored(CompletionProposal.ANNOTATION_ATTRIBUTE_REF, false);
	collector.setIgnored(CompletionProposal.ANONYMOUS_CLASS_DECLARATION, false);
	collector.setIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, false);
	collector.setIgnored(CompletionProposal.FIELD_REF, false);
	collector.setIgnored(CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER, false);
	collector.setIgnored(CompletionProposal.KEYWORD, false);
	collector.setIgnored(CompletionProposal.LABEL_REF, false);
	collector.setIgnored(CompletionProposal.LOCAL_VARIABLE_REF, false);
	collector.setIgnored(CompletionProposal.METHOD_DECLARATION, false);
	collector.setIgnored(CompletionProposal.METHOD_NAME_REFERENCE, false);
	collector.setIgnored(CompletionProposal.METHOD_REF, false);
	collector.setIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION, false);
	collector.setIgnored(CompletionProposal.METHOD_REF_WITH_CASTED_RECEIVER, false);
	collector.setIgnored(CompletionProposal.PACKAGE_REF, false);
	collector.setIgnored(CompletionProposal.POTENTIAL_METHOD_DECLARATION, false);
	collector.setIgnored(CompletionProposal.VARIABLE_DECLARATION, false);
	collector.setIgnored(CompletionProposal.TYPE_REF, false);
	return collector;
}