Example usage for org.eclipse.jdt.core IJavaElement FIELD

List of usage examples for org.eclipse.jdt.core IJavaElement FIELD

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. IJavaElement
  6. FIELD

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IJavaElement FIELD.

Prototype

int FIELD

To view the source code for org.eclipse.jdt.core IJavaElement FIELD.

Click Source Link

Document

Constant representing a field.

Usage

From source file:com.google.gwt.eclipse.core.search.JavaQueryParticipant.java

License:Open Source License

private Set<IIndexedJavaRef> findMatches(PatternQuerySpecification query) {
    // Translate the IJavaSearchConstant element type constants to IJavaElement
    // type constants.
    int elementType;
    switch (query.getSearchFor()) {
    case IJavaSearchConstants.TYPE:
        elementType = IJavaElement.TYPE;
        break;/*from ww  w.  j  a v  a2 s . c  om*/
    case IJavaSearchConstants.FIELD:
        elementType = IJavaElement.FIELD;
        break;
    case IJavaSearchConstants.METHOD:
    case IJavaSearchConstants.CONSTRUCTOR:
        // IJavaElement.METHOD represents both methods & ctors
        elementType = IJavaElement.METHOD;
        break;
    default:
        // We only support searching for types, fields, methods, and ctors
        return Collections.emptySet();
    }

    return JavaRefIndex.getInstance().findElementReferences(query.getPattern(), elementType,
            query.isCaseSensitive());
}

From source file:com.google.gwt.eclipse.core.search.JavaRefIndexTest.java

License:Open Source License

public void testFindElementReferences() {
    addRefGroups();/*  w  w w. j  a v  a  2s  . com*/
    Set<IIndexedJavaRef> refs;

    // Search for a field (using case insensitive search and a pattern that
    // differs in case than the actual element name)
    refs = JavaRefIndex.getInstance().findElementReferences("FIELD1", IJavaElement.FIELD, false);
    assertEquals(1, refs.size());
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello::field1", FILE_1)));

    // Do the same thing, but case sensitive this time
    refs = JavaRefIndex.getInstance().findElementReferences("FIELD1", IJavaElement.FIELD, true);
    assertEquals(0, refs.size());

    // Search for a field that does not exist
    refs = JavaRefIndex.getInstance().findElementReferences("badfield", IJavaElement.FIELD, false);
    assertEquals(0, refs.size());

    // Search for a method
    refs = JavaRefIndex.getInstance().findElementReferences("sayHello", IJavaElement.METHOD, false);
    assertEquals(2, refs.size());
    assertTrue(refs.contains(createJavaRef("@com.hello.Greeter::sayHello(Ljava/lang/String;)", FILE_1)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Greeter::sayHello(Ljava/lang/String;)", FILE_2)));

    // Search for a method using the * wildcard (match 0 or more chars)
    refs = JavaRefIndex.getInstance().findElementReferences("sayH*", IJavaElement.METHOD, true);
    assertEquals(5, refs.size());
    assertTrue(refs.contains(createJavaRef("@com.hello.Greeter::sayHello(Ljava/lang/String;)", FILE_1)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Greeter::sayHello(Ljava/lang/String;)", FILE_2)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello$Inner::sayHi(Ljava/lang/String;)", FILE_2)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello$Inner::sayHi(Ljava/lang/String;)", FILE_1)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello::sayHi(Ljava/lang/String;)", FILE_1)));

    // Search for a method using the ? wildcard (match exactly 1 char)
    refs = JavaRefIndex.getInstance().findElementReferences("sayH?", IJavaElement.METHOD, true);
    assertEquals(3, refs.size());
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello$Inner::sayHi(Ljava/lang/String;)", FILE_1)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello$Inner::sayHi(Ljava/lang/String;)", FILE_2)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello::sayHi(Ljava/lang/String;)", FILE_1)));

    // Search for a method with a parameter list
    refs = JavaRefIndex.getInstance().findElementReferences("sayHello(String)", IJavaElement.METHOD, false);
    assertEquals(2, refs.size());
    assertTrue(refs.contains(createJavaRef("@com.hello.Greeter::sayHello(Ljava/lang/String;)", FILE_1)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Greeter::sayHello(Ljava/lang/String;)", FILE_2)));

    // Search for a method with a parameter list and a fully-qualified type name
    refs = JavaRefIndex.getInstance().findElementReferences("com.hello.Greeter.sayHello(java.lang.String)",
            IJavaElement.METHOD, false);
    assertEquals(2, refs.size());
    assertTrue(refs.contains(createJavaRef("@com.hello.Greeter::sayHello(Ljava/lang/String;)", FILE_1)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Greeter::sayHello(Ljava/lang/String;)", FILE_2)));

    // Search for a method that does not exist
    refs = JavaRefIndex.getInstance().findElementReferences("badMethod", IJavaElement.METHOD, false);
    assertEquals(0, refs.size());

    // Search for a constructor
    refs = JavaRefIndex.getInstance().findElementReferences("Hello()", IJavaElement.METHOD, false);
    assertEquals(1, refs.size());
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello::Hello()", FILE_1)));

    // Search for a constructor that does not exist
    refs = JavaRefIndex.getInstance().findElementReferences("NotThere()", IJavaElement.METHOD, false);
    assertEquals(0, refs.size());

    // Search for a type by its fully-qualified name
    refs = JavaRefIndex.getInstance().findElementReferences("com.hello.Hello", IJavaElement.TYPE, false);
    assertEquals(5, refs.size());
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello::field1", FILE_1)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello::Hello()", FILE_1)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello::sayHi(Ljava/lang/String;)", FILE_1)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello$Inner::sayHi(Ljava/lang/String;)", FILE_1)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello$Inner::sayHi(Ljava/lang/String;)", FILE_2)));

    // Search for a type by the simple (unqualified) name
    refs = JavaRefIndex.getInstance().findElementReferences("Hello", IJavaElement.TYPE, false);
    assertEquals(5, refs.size());
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello::field1", FILE_1)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello::Hello()", FILE_1)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello::sayHi(Ljava/lang/String;)", FILE_1)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello$Inner::sayHi(Ljava/lang/String;)", FILE_1)));
    assertTrue(refs.contains(createJavaRef("@com.hello.Hello$Inner::sayHi(Ljava/lang/String;)", FILE_2)));
}

From source file:com.ibm.research.tagging.java.folding.WaypointAwareJavaFoldingStructureProvider.java

License:Open Source License

@Override
protected void computeFoldingStructure(IJavaElement element, FoldingStructureComputationContext ctx) {
    super.computeFoldingStructure(element, ctx);

    switch (element.getElementType()) {
    case IJavaElement.METHOD:
        return;/*from  w  ww . jav  a 2s  .  c o  m*/

    case IJavaElement.IMPORT_CONTAINER:
    case IJavaElement.TYPE:
    case IJavaElement.FIELD:
    case IJavaElement.INITIALIZER:
        break;
    default:
        return;
    }

    IRegion[] waypointRegions = WaypointDefinitionExtractor.getWaypointRegions(getDocument(),
            (ISourceReference) element);

    for (IRegion region : waypointRegions) {

        JavaProjectionAnnotation annotation = new JavaProjectionAnnotation(true, element, false);
        IRegion normalized = alignRegion(region, ctx);

        /* A null here indicates that we are attempting to fold a single line region */
        if (normalized != null) {
            Position position = createCommentPosition(normalized);
            ctx.addProjectionRange(annotation, position);
        }
    }

}

From source file:com.ibm.research.tours.content.dropadapter.LocalSelectionDropAdapter.java

License:Open Source License

public ITourElement[] convertDropData(Object data) {
    IStructuredSelection selection = (IStructuredSelection) LocalSelectionTransfer.getInstance().getSelection();
    Vector<ITourElement> elements = new Vector<ITourElement>();

    for (Object o : selection.toArray()) {
        if (o instanceof IJavaElement) {
            IJavaElement element = (IJavaElement) o;
            int type = element.getElementType();

            switch (type) {
            case IJavaElement.TYPE: // ok
            case IJavaElement.METHOD: // ok
            case IJavaElement.FIELD: // ok
                //case IJavaElement.IMPORT_DECLARATION : // not intresting
                //case IJavaElement.IMPORT_CONTAINER : // not intresting
                //case IJavaElement.PACKAGE_DECLARATION : // not intresting
                //case IJavaElement.PACKAGE_FRAGMENT : // as resource
                //case IJavaElement.JAVA_PROJECT : // as resource
                //case IJavaElement.CLASS_FILE : // as resource
                elements.add(new ResourceURLTourElement(element));
                continue;
            default:
                break;
            }//w  w  w  .jav  a  2 s  . c  om
        }

        // This will be processed as a resource
        IResource resource = null;

        if (o instanceof IJavaElement) {
            // don't use IAdaptable as for members only the top level type adapts
            resource = ((IJavaElement) o).getResource();
        } else if (o instanceof IAdaptable) {
            resource = (IResource) ((IAdaptable) o).getAdapter(IResource.class);
        }

        if (resource != null)
            elements.add(new ResourceURLTourElement(resource));
        else {
            MessageBox box = new MessageBox(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell());
            box.setText("Unsupported drop operation");
            box.setMessage(o.getClass().getName());
            box.open();
        }
    }

    return elements.toArray(new ITourElement[0]);
}

From source file:com.ibm.research.tours.content.url.delegates.JavaURLTourElementDelegate.java

License:Open Source License

public void start() {
    if (fTourElement.getTextHighlighting()) {
        fMarkerAnnotationPreferences = EditorsPlugin.getDefault().getMarkerAnnotationPreferences();
        List annotations = fMarkerAnnotationPreferences.getAnnotationPreferences();

        for (Object o : annotations) {
            AnnotationPreference info = (AnnotationPreference) o;
            String type = (String) info.getAnnotationType();

            if (type.equals("com.ibm.research.tours.content.tourtextannotation"))
                fAnnotationPreference = info;
        }//from   ww w  .jav a  2 s .  c o m

        fStore = EditorsPlugin.getDefault().getPreferenceStore();
        fStore.setValue(fAnnotationPreference.getHighlightPreferenceKey(),
                fTourElement.getTextHighlighting() ? "true" : "false");
        fStore.setValue(fAnnotationPreference.getOverviewRulerPreferenceKey(),
                fTourElement.getShowInOverview() ? "true" : "false");
        fStore.setValue(fAnnotationPreference.getVerticalRulerPreferenceKey(),
                fTourElement.getShowInVertical() ? "true" : "false");

        fStore.setValue(fAnnotationPreference.getHighlightPreferenceKey(), "false");
        fStore.setValue(fAnnotationPreference.getTextPreferenceKey(), "false");

        // This code is `duplicated!!! 
        ITextEffect effect = fTourElement.getSelectedTextEffect();

        if (effect instanceof HighlightedTextEffect) {
            fStore.setValue(fAnnotationPreference.getHighlightPreferenceKey(), "true");
            fStore.setValue(fAnnotationPreference.getTextPreferenceKey(), "false");
        } else if (effect instanceof SquigglesTextEffect) {
            fStore.setValue(fAnnotationPreference.getTextStylePreferenceKey(),
                    AnnotationPreference.STYLE_SQUIGGLES);
            fStore.setValue(fAnnotationPreference.getTextPreferenceKey(), "true");
        } else if (effect instanceof UnderlinedTextEffect) {
            fStore.setValue(fAnnotationPreference.getTextStylePreferenceKey(),
                    AnnotationPreference.STYLE_UNDERLINE);
            fStore.setValue(fAnnotationPreference.getTextPreferenceKey(), "true");
        } else if (effect instanceof BoxTextEffect) {
            fStore.setValue(fAnnotationPreference.getTextStylePreferenceKey(), AnnotationPreference.STYLE_BOX);
            fStore.setValue(fAnnotationPreference.getTextPreferenceKey(), "true");
        } else if (effect instanceof VerticalBarTextEffect) {
            fStore.setValue(fAnnotationPreference.getTextStylePreferenceKey(),
                    AnnotationPreference.STYLE_IBEAM);
            fStore.setValue(fAnnotationPreference.getTextPreferenceKey(), "true");
        } else if (effect instanceof NativeProblemUnderlineTextEffect) {
            fStore.setValue(fAnnotationPreference.getTextStylePreferenceKey(),
                    AnnotationPreference.STYLE_PROBLEM_UNDERLINE);
            fStore.setValue(fAnnotationPreference.getTextPreferenceKey(), "true");
        } else if (effect instanceof DashedBoxTextEffect) {
            fStore.setValue(fAnnotationPreference.getTextStylePreferenceKey(),
                    AnnotationPreference.STYLE_DASHED_BOX);
            fStore.setValue(fAnnotationPreference.getTextPreferenceKey(), "true");
        } else
            fStore.setValue(fAnnotationPreference.getTextPreferenceKey(), "false");

        if (fTourElement.getTextPresentationColor() != null) {
            String color = fTourElement.getTextPresentationColor().red + ","
                    + fTourElement.getTextPresentationColor().green + ","
                    + fTourElement.getTextPresentationColor().blue;
            fStore.setValue(fAnnotationPreference.getColorPreferenceKey(), color);
        }
    }

    try {
        fRange = null;

        if (fElement.getElementType() == IJavaElement.TYPE) {
            IType type = (IType) fElement;
            fRange = type.getSourceRange();
        } else if (fElement.getElementType() == IJavaElement.METHOD) {
            IMethod method = (IMethod) fElement;
            fRange = method.getSourceRange();
        } else if (fElement.getElementType() == IJavaElement.FIELD) {
            IField field = (IField) fElement;
            fRange = field.getSourceRange();
        }

        if (fRange != null) {
            fMarker = fElement.getResource().createMarker("com.ibm.research.tours.content.tourtextmarker");
            fMarker.setAttribute(IMarker.CHAR_START, fRange.getOffset());
            fMarker.setAttribute(IMarker.CHAR_END, fRange.getOffset() + fRange.getLength());
        }
    } catch (CoreException e) {
        e.printStackTrace();
    }
}

From source file:com.ibm.research.tours.content.url.JavaURL.java

License:Open Source License

public String toPortableString() {
    String base = URLParser.ECLIPSE_PREAMBLE + fElement.getResource().getFullPath().toPortableString();

    if (fElement.getElementType() == IJavaElement.TYPE) {
        IType type = (IType) fElement;/*from  w ww.  ja  v  a2s  .co  m*/
        String typeParam = TYPE_PARAM + URLParser.PARAMETER_EQUALS + TYPE_TYPE;
        String nameParam = SIGNATURE_PARAM + URLParser.PARAMETER_EQUALS + type.getTypeQualifiedName('.');
        return base + URLParser.PARAMETER_START + typeParam + URLParser.PARAMETER_DELIM + nameParam;
    }
    if (fElement.getElementType() == IJavaElement.FIELD) {
        IField field = (IField) fElement;
        String typeParam = TYPE_PARAM + URLParser.PARAMETER_EQUALS + FIELD_TYPE;
        String nameParam = SIGNATURE_PARAM + URLParser.PARAMETER_EQUALS
                + field.getDeclaringType().getTypeQualifiedName('.') + "." + field.getElementName();
        return base + URLParser.PARAMETER_START + typeParam + URLParser.PARAMETER_DELIM + nameParam;
    }
    if (fElement.getElementType() == IJavaElement.METHOD) {
        IMethod method = (IMethod) fElement;
        String signature = null;

        try {
            signature = Signature.toPortableString(method.getSignature(), method.getElementName(), false,
                    false);
        } catch (JavaModelException e) {
            e.printStackTrace();
        }

        String typeParam = TYPE_PARAM + URLParser.PARAMETER_EQUALS + METHOD_TYPE;
        String nameParam = SIGNATURE_PARAM + URLParser.PARAMETER_EQUALS
                + method.getDeclaringType().getTypeQualifiedName('.') + "." + signature;
        return base + URLParser.PARAMETER_START + typeParam + URLParser.PARAMETER_DELIM + nameParam;
    }
    return "";
}

From source file:com.microsoft.javapkgsrv.JavaElementLabelComposer.java

License:Open Source License

/**
 * Appends the label for a Java element with the flags as defined by this class.
 *
 * @param element the element to render/* w  w  w . j  a va2s.co  m*/
 * @param flags the rendering flags.
 */
public void appendElementLabel(IJavaElement element, long flags) {
    int type = element.getElementType();
    IPackageFragmentRoot root = null;

    if (type != IJavaElement.JAVA_MODEL && type != IJavaElement.JAVA_PROJECT
            && type != IJavaElement.PACKAGE_FRAGMENT_ROOT)
        root = (IPackageFragmentRoot) element.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
    if (root != null && getFlag(flags, PREPEND_ROOT_PATH)) {
        appendPackageFragmentRootLabel(root, ROOT_QUALIFIED);
        fBuffer.append(CONCAT_STRING);
    }

    switch (type) {
    case IJavaElement.METHOD:
        appendMethodLabel((IMethod) element, flags);
        break;
    case IJavaElement.FIELD:
        appendFieldLabel((IField) element, flags);
        break;
    case IJavaElement.LOCAL_VARIABLE:
        appendLocalVariableLabel((ILocalVariable) element, flags);
        break;
    case IJavaElement.TYPE_PARAMETER:
        appendTypeParameterLabel((ITypeParameter) element, flags);
        break;
    case IJavaElement.INITIALIZER:
        appendInitializerLabel((IInitializer) element, flags);
        break;
    case IJavaElement.TYPE:
        appendTypeLabel((IType) element, flags);
        break;
    case IJavaElement.CLASS_FILE:
        appendClassFileLabel((IClassFile) element, flags);
        break;
    case IJavaElement.COMPILATION_UNIT:
        appendCompilationUnitLabel((ICompilationUnit) element, flags);
        break;
    case IJavaElement.PACKAGE_FRAGMENT:
        appendPackageFragmentLabel((IPackageFragment) element, flags);
        break;
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        appendPackageFragmentRootLabel((IPackageFragmentRoot) element, flags);
        break;
    case IJavaElement.IMPORT_CONTAINER:
    case IJavaElement.IMPORT_DECLARATION:
    case IJavaElement.PACKAGE_DECLARATION:
        appendDeclarationLabel(element, flags);
        break;
    case IJavaElement.JAVA_PROJECT:
    case IJavaElement.JAVA_MODEL:
        fBuffer.append(element.getElementName());
        break;
    default:
        fBuffer.append(element.getElementName());
    }

    if (root != null && getFlag(flags, APPEND_ROOT_PATH)) {
        int offset = fBuffer.length();
        fBuffer.append(CONCAT_STRING);
        appendPackageFragmentRootLabel(root, ROOT_QUALIFIED);
    }
}

From source file:com.microsoft.javapkgsrv.JavaElementLabelComposer.java

License:Open Source License

/**
 * Appends the label for a type. Considers the T_* flags.
 *
 * @param type the element to render//from  ww w  .  j a  va 2 s  .c  o  m
 * @param flags the rendering flags. Flags with names starting with 'T_' are considered.
 */
public void appendTypeLabel(IType type, long flags) {

    if (getFlag(flags, T_FULLY_QUALIFIED)) {
        IPackageFragment pack = type.getPackageFragment();
        if (!pack.isDefaultPackage()) {
            appendPackageFragmentLabel(pack, (flags & QUALIFIER_FLAGS));
            fBuffer.append('.');
        }
    }
    IJavaElement parent = type.getParent();
    if (getFlag(flags, T_FULLY_QUALIFIED | T_CONTAINER_QUALIFIED)) {
        IType declaringType = type.getDeclaringType();
        if (declaringType != null) {
            appendTypeLabel(declaringType, T_CONTAINER_QUALIFIED | (flags & QUALIFIER_FLAGS));
            fBuffer.append('.');
        }
        int parentType = parent.getElementType();
        if (parentType == IJavaElement.METHOD || parentType == IJavaElement.FIELD
                || parentType == IJavaElement.INITIALIZER) { // anonymous or local
            appendElementLabel(parent, 0);
            fBuffer.append('.');
        }
    }

    String typeName;
    boolean isAnonymous = false;
    if (type.isLambda()) {
        typeName = "() -> {...}"; //$NON-NLS-1$
        try {
            String[] superInterfaceSignatures = type.getSuperInterfaceTypeSignatures();
            if (superInterfaceSignatures.length > 0) {
                typeName = typeName + ' ' + getSimpleTypeName(type, superInterfaceSignatures[0]);
            }
        } catch (JavaModelException e) {
            //ignore
        }

    } else {
        typeName = getElementName(type);
        try {
            isAnonymous = type.isAnonymous();
        } catch (JavaModelException e1) {
            // should not happen, but let's play safe:
            isAnonymous = typeName.length() == 0;
        }
        if (isAnonymous) {
            try {
                if (parent instanceof IField && type.isEnum()) {
                    typeName = '{' + ELLIPSIS_STRING + '}';
                } else {
                    String supertypeName;
                    String[] superInterfaceSignatures = type.getSuperInterfaceTypeSignatures();
                    if (superInterfaceSignatures.length > 0) {
                        supertypeName = getSimpleTypeName(type, superInterfaceSignatures[0]);
                    } else {
                        supertypeName = getSimpleTypeName(type, type.getSuperclassTypeSignature());
                    }
                    typeName = "new " + supertypeName + "() {...}";
                }
            } catch (JavaModelException e) {
                //ignore
                typeName = "new Anonymous";
            }
        }
    }
    fBuffer.append(typeName);

    if (getFlag(flags, T_TYPE_PARAMETERS)) {
        if (getFlag(flags, USE_RESOLVED) && type.isResolved()) {
            BindingKey key = new BindingKey(type.getKey());
            if (key.isParameterizedType()) {
                String[] typeArguments = key.getTypeArguments();
                appendTypeArgumentSignaturesLabel(type, typeArguments, flags);
            } else {
                String[] typeParameters = Signature.getTypeParameters(key.toSignature());
                appendTypeParameterSignaturesLabel(typeParameters, flags);
            }
        } else if (type.exists()) {
            try {
                appendTypeParametersLabels(type.getTypeParameters(), flags);
            } catch (JavaModelException e) {
                // ignore
            }
        }
    }

    // category
    if (getFlag(flags, T_CATEGORY) && type.exists()) {
        try {
            appendCategoryLabel(type, flags);
        } catch (JavaModelException e) {
            // ignore
        }
    }

    // post qualification
    if (getFlag(flags, T_POST_QUALIFIED)) {
        int offset = fBuffer.length();
        fBuffer.append(CONCAT_STRING);
        IType declaringType = type.getDeclaringType();
        if (declaringType == null && type.isBinary() && isAnonymous) {
            // workaround for Bug 87165: [model] IType#getDeclaringType() does not work for anonymous binary type
            String tqn = type.getTypeQualifiedName();
            int lastDollar = tqn.lastIndexOf('$');
            if (lastDollar != 1) {
                String declaringTypeCF = tqn.substring(0, lastDollar) + ".class"; //$NON-NLS-1$
                declaringType = type.getPackageFragment().getClassFile(declaringTypeCF).getType();
                try {
                    ISourceRange typeSourceRange = type.getSourceRange();
                    if (declaringType.exists() && SourceRange.isAvailable(typeSourceRange)) {
                        IJavaElement realParent = declaringType.getTypeRoot()
                                .getElementAt(typeSourceRange.getOffset() - 1);
                        if (realParent != null) {
                            parent = realParent;
                        }
                    }
                } catch (JavaModelException e) {
                    // ignore
                }
            }
        }
        if (declaringType != null) {
            appendTypeLabel(declaringType, T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS));
            int parentType = parent.getElementType();
            if (parentType == IJavaElement.METHOD || parentType == IJavaElement.FIELD
                    || parentType == IJavaElement.INITIALIZER) { // anonymous or local
                fBuffer.append('.');
                appendElementLabel(parent, 0);
            }
        } else {
            appendPackageFragmentLabel(type.getPackageFragment(), flags & QUALIFIER_FLAGS);
        }
    }
}

From source file:com.mountainminds.eclemma.internal.core.analysis.TypeTraverser.java

License:Open Source License

private void processType(ITypeVisitor visitor, BinaryTypeName btn, IType type, IProgressMonitor monitor)
        throws JavaModelException {
    final String binaryname = btn.toString();
    monitor.subTask(binaryname);/*from w ww.j a v a  2 s.com*/
    visitor.visit(type, binaryname);
    for (final IJavaElement child : type.getChildren()) {
        if (monitor.isCanceled()) {
            break;
        }
        switch (child.getElementType()) {
        case IJavaElement.TYPE:
            IType nestedtype = (IType) child;
            processType(visitor, btn.nest(nestedtype), nestedtype, monitor);
            break;
        case IJavaElement.METHOD:
        case IJavaElement.INITIALIZER:
        case IJavaElement.FIELD:
            processAnonymousInnerTypes(visitor, btn, (IMember) child, monitor);
            break;
        }
    }
}

From source file:com.redhat.ceylon.eclipse.code.explorer.JavaElementImageProvider.java

License:Open Source License

/**
 * Returns an image descriptor for a java element. This is the base image, no overlays.
 * @param element the element/*www . jav  a  2s  .com*/
 * @param renderFlags the image flags
 * @return returns the image descriptor
 */
public ImageDescriptor getBaseImageDescriptor(IJavaElement element, int renderFlags) {

    try {
        switch (element.getElementType()) {
        case IJavaElement.INITIALIZER:
            return JavaPluginImages.DESC_MISC_PRIVATE; // 23479
        case IJavaElement.METHOD: {
            IMethod method = (IMethod) element;
            IType declType = method.getDeclaringType();
            int flags = method.getFlags();
            if (declType.isEnum() && isDefaultFlag(flags) && method.isConstructor())
                return JavaPluginImages.DESC_MISC_PRIVATE;
            return getMethodImageDescriptor(JavaModelUtil.isInterfaceOrAnnotation(declType), flags);
        }
        case IJavaElement.FIELD: {
            IMember member = (IMember) element;
            IType declType = member.getDeclaringType();
            return getFieldImageDescriptor(JavaModelUtil.isInterfaceOrAnnotation(declType), member.getFlags());
        }
        case IJavaElement.LOCAL_VARIABLE:
            return JavaPluginImages.DESC_OBJS_LOCAL_VARIABLE;

        case IJavaElement.PACKAGE_DECLARATION:
            return JavaPluginImages.DESC_OBJS_PACKDECL;

        case IJavaElement.IMPORT_DECLARATION:
            return JavaPluginImages.DESC_OBJS_IMPDECL;

        case IJavaElement.IMPORT_CONTAINER:
            return JavaPluginImages.DESC_OBJS_IMPCONT;

        case IJavaElement.TYPE: {
            IType type = (IType) element;

            IType declType = type.getDeclaringType();
            boolean isInner = declType != null;
            boolean isInInterfaceOrAnnotation = isInner && JavaModelUtil.isInterfaceOrAnnotation(declType);
            return getTypeImageDescriptor(isInner, isInInterfaceOrAnnotation, type.getFlags(),
                    useLightIcons(renderFlags));
        }

        case IJavaElement.PACKAGE_FRAGMENT_ROOT: {
            IPackageFragmentRoot root = (IPackageFragmentRoot) element;
            IPath attach = root.getSourceAttachmentPath();
            if (root.getKind() == IPackageFragmentRoot.K_BINARY) {
                if (root.isArchive()) {
                    if (root.isExternal()) {
                        if (attach == null) {
                            return JavaPluginImages.DESC_OBJS_EXTJAR;
                        } else {
                            return JavaPluginImages.DESC_OBJS_EXTJAR_WSRC;
                        }
                    } else {
                        if (attach == null) {
                            return JavaPluginImages.DESC_OBJS_JAR;
                        } else {
                            return JavaPluginImages.DESC_OBJS_JAR_WSRC;
                        }
                    }
                } else {
                    if (attach == null) {
                        return JavaPluginImages.DESC_OBJS_CLASSFOLDER;
                    } else {
                        return JavaPluginImages.DESC_OBJS_CLASSFOLDER_WSRC;
                    }
                }
            } else {
                return JavaPluginImages.DESC_OBJS_PACKFRAG_ROOT;
            }
        }

        case IJavaElement.PACKAGE_FRAGMENT:
            return getPackageFragmentIcon(element);

        case IJavaElement.COMPILATION_UNIT:
            return JavaPluginImages.DESC_OBJS_CUNIT;

        case IJavaElement.CLASS_FILE:
            /* this is too expensive for large packages
            try {
               IClassFile cfile= (IClassFile)element;
               if (cfile.isClass())
             return JavaPluginImages.IMG_OBJS_CFILECLASS;
               return JavaPluginImages.IMG_OBJS_CFILEINT;
            } catch(JavaModelException e) {
               // fall through;
            }*/
            return JavaPluginImages.DESC_OBJS_CFILE;

        case IJavaElement.JAVA_PROJECT:
            IJavaProject jp = (IJavaProject) element;
            if (jp.getProject().isOpen()) {
                IProject project = jp.getProject();
                IWorkbenchAdapter adapter = (IWorkbenchAdapter) project.getAdapter(IWorkbenchAdapter.class);
                if (adapter != null) {
                    ImageDescriptor result = adapter.getImageDescriptor(project);
                    if (result != null)
                        return result;
                }
                return DESC_OBJ_PROJECT;
            }
            return DESC_OBJ_PROJECT_CLOSED;

        case IJavaElement.JAVA_MODEL:
            return JavaPluginImages.DESC_OBJS_JAVA_MODEL;

        case IJavaElement.TYPE_PARAMETER:
            return JavaPluginImages.DESC_OBJS_TYPEVARIABLE;

        case IJavaElement.ANNOTATION:
            return JavaPluginImages.DESC_OBJS_ANNOTATION;

        default:
            // ignore. Must be a new, yet unknown Java element
            // give an advanced IWorkbenchAdapter the chance
            IWorkbenchAdapter wbAdapter = (IWorkbenchAdapter) element.getAdapter(IWorkbenchAdapter.class);
            if (wbAdapter != null && !(wbAdapter instanceof JavaWorkbenchAdapter)) { // avoid recursion
                ImageDescriptor imageDescriptor = wbAdapter.getImageDescriptor(element);
                if (imageDescriptor != null) {
                    return imageDescriptor;
                }
            }
            return JavaPluginImages.DESC_OBJS_GHOST;
        }

    } catch (JavaModelException e) {
        if (e.isDoesNotExist())
            return JavaPluginImages.DESC_OBJS_UNKNOWN;
        JavaPlugin.log(e);
        return JavaPluginImages.DESC_OBJS_GHOST;
    }
}