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

Introduction

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

Prototype

int CLASS_FILE

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

Click Source Link

Document

Constant representing a class file.

Usage

From source file:com.drgarbage.bytecodevisualizer.editors.BytecodeEditor.java

License:Apache License

/**
 * Selects the given line and revaluate visible position.
 * @param bytecodeDocumentLine the line number of the bytecode document
 * @param elementName // w w  w. j a v  a2s  .  com
 * @param elementType the element type one of {@link IJavaElement IJavaElement.CLASS_FILE},
 *       {@link IJavaElement IJavaElement.FIELD} or {@link IJavaElement IJavaElement.METHOD}.
 * @see IJavaElement
 */
public void selectBytecodeLineAndReveal(int bytecodeDocumentLine, String elementName, int elementType) {
    IDocument document = byteCodeDocumentProvider.getBytecodeDocument(getBytecodeEditorInput());
    try {
        /* get line information */
        IRegion region = document.getLineInformation(bytecodeDocumentLine);
        int lineStartOffset = region.getOffset();
        int lineLenght = region.getLength();
        String lineString = document.get(lineStartOffset, lineLenght);

        if (elementName == null) {
            super.selectAndReveal(lineStartOffset, 0);
        }

        int elementIndex, elementLength;
        switch (elementType) {
        case IJavaElement.CLASS_FILE:
            elementIndex = lineString.indexOf(" " + elementName + " {") + 1;
            break;
        case IJavaElement.FIELD:
            elementIndex = lineString.indexOf(" " + elementName + ";") + 1;
            break;
        case IJavaElement.METHOD:
            elementIndex = lineString.indexOf(" " + elementName + "(") + 1;
            break;
        default:
            elementIndex = 0;
            elementLength = 0;
        }

        /* name not found */
        if (elementIndex == 0) {
            elementLength = 0;
        } else {
            elementLength = elementName.length();
        }

        super.selectAndReveal(lineStartOffset + elementIndex, elementLength);

    } catch (BadLocationException e) {
        /*nothing to do */}
}

From source file:com.drgarbage.bytecodevisualizer.editors.BytecodeEditor.java

License:Apache License

/**
 * Selects the line for the given element:
 * - ClassFileSection// www.  j  a  v  a 2 s. co  m
 * - MethodSection
 * - Variable
 * 
 * @param element
 * @param line
 * @param markLine true if the line has to be marked
 */
public void setSelection(IJavaElement element, int line, boolean markLine) {

    if (element == null) {
        return;
    }

    switch (element.getElementType()) {
    case IJavaElement.FIELD: /* select field */
        String fieldName = element.getElementName();
        IFieldSection fieldSection = byteCodeDocumentProvider.getClassFileDocument()
                .findFieldSection(fieldName);
        if (fieldSection != null) {
            selectBytecodeLineAndReveal(fieldSection.getBytecodeDocumentLine(), fieldName, IJavaElement.FIELD);
        }
        break;
    case IJavaElement.METHOD: /* select method */
        IMethod method = (IMethod) element;
        try {
            String methodName;
            if (method.isConstructor()) {
                methodName = "<init>";
            } else {
                methodName = method.getElementName();
            }

            String methodSignature = ClassFileDocumentsUtils.resolveMethodSignature(method);
            IMethodSection methodSection = byteCodeDocumentProvider.getClassFileDocument()
                    .findMethodSection(methodName, methodSignature);

            if (methodSection != null) {
                if (line == IClassFileEditor.INVALID_LINE || line == IClassFileEditor.METHOD_DECLARATION_LINE) {

                    if (method.isConstructor()) {
                        methodName = method.getElementName();
                    }
                    selectBytecodeLineAndReveal(methodSection.getFirstLine(), methodName, IJavaElement.METHOD);
                } else {
                    selectLineAndRevaluate2(methodSection.getBytecodeLine(line) - 1, markLine);
                }
                break;
            }

        } catch (JavaModelException e) {
            BytecodeVisualizerPlugin
                    .log(new Status(IStatus.ERROR, BytecodeVisualizerPlugin.PLUGIN_ID, e.getMessage(), e));
        }

    default:
        /* select class */
        IClassFileDocument doc = byteCodeDocumentProvider.getClassFileDocument();
        if (doc != null) {
            int docLine = doc.getClassSignatureDocumentLine();
            selectBytecodeLineAndReveal(docLine, element.getElementName(), IJavaElement.CLASS_FILE);
        }
    }

    /* call cursor hook */
    doHandleCursorPositionChanged();
}

From source file:com.google.inject.tools.ideplugin.eclipse.EclipseJavaElement.java

License:Apache License

private String getType(IJavaElement element, String signature) {
    try {//from  w ww  . ja va  2  s.c  o  m
        IType type = null;
        ICompilationUnit compilationUnit = (ICompilationUnit) element
                .getAncestor(IJavaElement.COMPILATION_UNIT);
        if (compilationUnit != null) {
            type = compilationUnit.getAllTypes()[0];

        } else {
            IClassFile classFile = (IClassFile) element.getAncestor(IJavaElement.CLASS_FILE);
            if (classFile != null) {
                type = classFile.getType();
            }
        }
        String resolvedSignature = TypeUtil.resolveTypeSignature(type, signature, false);
        String className = getClassNameFromResolvedSignature(resolvedSignature);
        return className;
    } catch (Throwable e) {
        return null;
    }
}

From source file:com.google.inject.tools.ideplugin.eclipse.EclipseJavaElement.java

License:Apache License

private boolean findIsConcreteClass(String signature) {
    try {//from  w w  w .  java 2 s. co  m
        IType type = null;
        ICompilationUnit compilationUnit = (ICompilationUnit) element
                .getAncestor(IJavaElement.COMPILATION_UNIT);
        if (compilationUnit != null) {
            type = compilationUnit.getAllTypes()[0];

        } else {
            IClassFile classFile = (IClassFile) element.getAncestor(IJavaElement.CLASS_FILE);
            if (classFile != null) {
                type = classFile.getType();
            }
        }
        IType resolvedType = TypeUtil.resolveType(type, signature);
        return findIsConcreteClass(resolvedType);
    } catch (Throwable throwable) {
        return false;
    }
}

From source file:com.iw.plugins.spindle.ui.util.Revealer.java

License:Mozilla Public License

/**
 * @param useSelection//from   ww w  . j a  v a2 s . c  o  m
 * @return
 */
private static ISelection checkSelectionForJarEntryFile(ISelection useSelection, IJavaProject jproject) {
    if (useSelection.isEmpty() || !(useSelection instanceof IStructuredSelection))
        return useSelection;

    IStructuredSelection structured = (IStructuredSelection) useSelection;
    Object first = structured.getFirstElement();
    if (structured.size() > 1 || !(first instanceof IJarEntryResource))
        return useSelection;

    IJarEntryResource jarResource = (IJarEntryResource) first;

    IPath path = jarResource.getFullPath().removeFileExtension();
    String name = path.lastSegment();

    IPackageFragment[] fragments = null;
    try {
        if (jproject != null) {

            IPackageFragment frag = (IPackageFragment) jarResource.getParent();
            if (frag != null)
                fragments = new IPackageFragment[] { frag };

        } else {
            fragments = JarEntryFileUtil.getPackageFragments(ResourcesPlugin.getWorkspace().getRoot(),
                    jarResource);
        }
        if (fragments.length != 1)
            return useSelection;

        // check to see if there is an IClassFile in the package
        IJavaElement[] children = fragments[0].getChildren();
        if (children.length > 0) {
            IClassFile revealInstead = null;
            for (int i = 0; i < children.length; i++) {
                if (children[i].getElementType() != IJavaElement.CLASS_FILE)
                    continue;

                revealInstead = (IClassFile) children[i];
                String temp = revealInstead.getElementName();
                temp = temp.substring(0, temp.length() - 6);
                if (temp.equals(name))
                    return new StructuredSelection(revealInstead);
            }
            if (revealInstead != null)
                return new StructuredSelection(revealInstead);
        }
        return new StructuredSelection(fragments[0]);

    } catch (CoreException e) {
        UIPlugin.log(e);
    }
    return useSelection;
}

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//from w w  w.jav  a  2  s  .com
 * @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.mountainminds.eclemma.internal.ui.coverageview.SelectionTracker.java

License:Open Source License

/**
 * Try to identify a nested java element of the given element from a textual
 * selection in its source code. This might be possible if the given element
 * is a compilation unit or class file.//from  ww w .j a  v a  2 s.c  om
 * 
 * @param unit
 *          unit to search
 * @param selection
 *          selection within this unit
 * @return nested element or the unit itself
 */
private IJavaElement findElementAtCursor(IJavaElement unit, ISelection selection) {
    int pos = -1;
    if (selection instanceof ITextSelection) {
        pos = ((ITextSelection) selection).getOffset();
    }
    if (selection instanceof IMarkSelection) {
        pos = ((IMarkSelection) selection).getOffset();
    }
    if (pos == -1)
        return unit;
    IJavaElement element = null;
    try {
        switch (unit.getElementType()) {
        case IJavaElement.COMPILATION_UNIT:
            element = ((ICompilationUnit) unit).getElementAt(pos);
            break;
        case IJavaElement.CLASS_FILE:
            element = ((IClassFile) unit).getElementAt(pos);
            break;
        }
    } catch (JavaModelException e) {
        // we ignore this
    }
    return element == null ? unit : element;
}

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/*from w ww  .  ja  v a2 s  . co  m*/
 * @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;
    }
}

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

License:Open Source License

/**
 * Processes a delta recursively. When more than two children are affected the
 * tree is fully refreshed starting at this node.
 *
 * @param delta the delta to process/*from   w ww .ja v  a 2s .  c o  m*/
 * @param runnables the resulting view changes as runnables (type {@link Runnable})
 * @return true is returned if the conclusion is to refresh a parent of an element. In that case no siblings need
 * to be processed
 * @throws JavaModelException thrown when the access to an element failed
 */
private boolean processDelta(IJavaElementDelta delta, Collection<Runnable> runnables)
        throws JavaModelException {

    int kind = delta.getKind();
    int flags = delta.getFlags();
    IJavaElement element = delta.getElement();
    int elementType = element.getElementType();

    if (elementType != IJavaElement.JAVA_MODEL && elementType != IJavaElement.JAVA_PROJECT) {
        IJavaProject proj = element.getJavaProject();
        if (proj == null || !proj.getProject().isOpen()) // TODO: Not needed if parent already did the 'open' check!
            return false;
    }

    if (elementType == IJavaElement.PACKAGE_FRAGMENT) {
        if ((flags & (IJavaElementDelta.F_CONTENT
                | IJavaElementDelta.F_CHILDREN)) == IJavaElementDelta.F_CONTENT) {
            // TODO: This should never be true for folders (F_CONTENT is only for files)
            if (!fIsFlatLayout) {
                Object parent = getHierarchicalPackageParent((IPackageFragment) element);
                if (!(parent instanceof IPackageFragmentRoot)) {
                    postRefresh(internalGetParent(parent), GRANT_PARENT, element, runnables);
                    return true;
                }
            }
            // content change, without children info (for example resource added/removed to class folder package)
            postRefresh(internalGetParent(element), PARENT, element, runnables);
            return true;
        }

        if (!fIsFlatLayout) {
            if (kind == IJavaElementDelta.REMOVED) {
                final Object parent = getHierarchicalPackageParent((IPackageFragment) element);
                if (parent instanceof IPackageFragmentRoot) {
                    postRemove(element, runnables);
                    return false;
                } else {
                    postRefresh(internalGetParent(parent), GRANT_PARENT, element, runnables);
                    return true;
                }
            } else if (kind == IJavaElementDelta.ADDED) {
                final Object parent = getHierarchicalPackageParent((IPackageFragment) element);
                if (parent instanceof IPackageFragmentRoot) {
                    if (fFoldPackages) {
                        postRefresh(parent, PARENT, element, runnables);
                        return true;
                    } else {
                        postAdd(parent, element, runnables);
                        return false;
                    }
                } else {
                    postRefresh(internalGetParent(parent), GRANT_PARENT, element, runnables);
                    return true;
                }
            }
            handleAffectedChildren(delta, element, runnables);
            return false;
        }
    }

    if (elementType == IJavaElement.COMPILATION_UNIT) {
        ICompilationUnit cu = (ICompilationUnit) element;
        if (!JavaModelUtil.isPrimary(cu)) {
            return false;
        }

        if (!getProvideMembers() && cu.isWorkingCopy() && kind == IJavaElementDelta.CHANGED) {
            return false;
        }

        if (kind == IJavaElementDelta.CHANGED && !isStructuralCUChange(flags)) {
            return false; // test moved ahead
        }

        if (!isOnClassPath(cu)) { // TODO: isOnClassPath expensive! Should be put after all cheap tests
            return false;
        }

    }

    if (elementType == IJavaElement.JAVA_PROJECT) {
        // handle open and closing of a project
        if ((flags & (IJavaElementDelta.F_CLOSED | IJavaElementDelta.F_OPENED)) != 0) {
            postRefresh(element, ORIGINAL, element, runnables);
            return false;
        }
        // if the class path has changed we refresh the entire project
        if ((flags & IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED) != 0) {
            postRefresh(element, ORIGINAL, element, runnables);
            return false;
        }
        // if added it could be that the corresponding IProject is already shown. Remove it first.
        // bug 184296
        if (kind == IJavaElementDelta.ADDED) {
            postRemove(element.getResource(), runnables);
            postAdd(element.getParent(), element, runnables);
            return false;
        }
    }

    if (kind == IJavaElementDelta.REMOVED) {
        Object parent = internalGetParent(element);
        if (element instanceof IPackageFragment) {
            // refresh package fragment root to allow filtering empty (parent) packages: bug 72923
            if (fViewer.testFindItem(parent) != null)
                postRefresh(parent, PARENT, element, runnables);
            return true;

        } else if (element instanceof IPackageFragmentRoot) {
            // libs and class folders can show up twice (in library container and as resource at original location)
            IResource resource = element.getResource();
            if (resource != null && !resource.exists())
                postRemove(resource, runnables);
        }

        postRemove(element, runnables);
        if (parent instanceof IPackageFragment)
            postUpdateIcon((IPackageFragment) parent, runnables);
        // we are filtering out empty subpackages, so we
        // a package becomes empty we remove it from the viewer.
        if (isPackageFragmentEmpty(element.getParent())) {
            if (fViewer.testFindItem(parent) != null)
                postRefresh(internalGetParent(parent), GRANT_PARENT, element, runnables);
            return true;
        }
        return false;
    }

    if (kind == IJavaElementDelta.ADDED) {
        Object parent = internalGetParent(element);
        // we are filtering out empty subpackages, so we
        // have to handle additions to them specially.
        if (parent instanceof IPackageFragment) {
            Object grandparent = internalGetParent(parent);
            // 1GE8SI6: ITPJUI:WIN98 - Rename is not shown in Packages View
            // avoid posting a refresh to an invisible parent
            if (parent.equals(fInput)) {
                postRefresh(parent, PARENT, element, runnables);
            } else {
                // refresh from grandparent if parent isn't visible yet
                if (fViewer.testFindItem(parent) == null)
                    postRefresh(grandparent, GRANT_PARENT, element, runnables);
                else {
                    postRefresh(parent, PARENT, element, runnables);
                }
            }
            return true;
        } else {
            if (element instanceof IPackageFragmentRoot
                    && ((IPackageFragmentRoot) element).getKind() != IPackageFragmentRoot.K_SOURCE) {
                // libs and class folders can show up twice (in library container or under project, and as resource at original location)
                IResource resource = element.getResource();
                if (resource != null) {
                    Object resourceParent = super.internalGetParent(resource);
                    if (resourceParent != null) {
                        IJavaProject proj = element.getJavaProject();
                        if (fShowLibrariesNode || !resourceParent.equals(proj)) {
                            postAdd(resourceParent, resource, runnables);
                        }
                    }
                }
            }
            postAdd(parent, element, runnables);
        }
    }

    if (elementType == IJavaElement.COMPILATION_UNIT || elementType == IJavaElement.CLASS_FILE) {
        if (kind == IJavaElementDelta.CHANGED) {
            // isStructuralCUChange already performed above
            postRefresh(element, ORIGINAL, element, runnables);
        }
        return false;
    }

    if (elementType == IJavaElement.PACKAGE_FRAGMENT_ROOT) {
        // the contents of an external JAR has changed
        if ((flags & IJavaElementDelta.F_ARCHIVE_CONTENT_CHANGED) != 0) {
            postRefresh(element, ORIGINAL, element, runnables);
            return false;
        }
        if ((flags & (IJavaElementDelta.F_CONTENT
                | IJavaElementDelta.F_CHILDREN)) == IJavaElementDelta.F_CONTENT) {
            // TODO: This should never be true for folders (F_CONTENT is only for files)
            // content change, without children info (for example resource added/removed to class folder package)
            postRefresh(internalGetParent(element), PARENT, element, runnables);
            return true;
        }

        // the source attachment of a JAR has changed
        if ((flags & (IJavaElementDelta.F_SOURCEATTACHED | IJavaElementDelta.F_SOURCEDETACHED)) != 0)
            postUpdateIcon(element, runnables);

        if (isClassPathChange(delta)) {
            // throw the towel and do a full refresh of the affected java project.
            postRefresh(element.getJavaProject(), PROJECT, element, runnables);
            return true;
        }
    }

    handleAffectedChildren(delta, element, runnables);
    return false;
}

From source file:de.loskutov.bco.ui.actions.BytecodeAction.java

License:Open Source License

protected TypedElement createTypedElement(IJavaElement javaElement, BitSet modes) {
    String name;//from w ww.  j  a v  a 2  s .  co m
    IClassFile classFile = (IClassFile) javaElement.getAncestor(IJavaElement.CLASS_FILE);
    // existing read-only class files
    if (classFile != null) {
        name = classFile.getPath().toOSString();
        if (!name.endsWith(".class")) { //$NON-NLS-1$
            name += '/' + JdtUtils.getFullBytecodeName(classFile);
        }
    } else {
        // usual eclipse - generated bytecode
        name = JdtUtils.getByteCodePath(javaElement);
    }
    String methodName = null;
    if (javaElement.getElementType() == IJavaElement.METHOD
            || javaElement.getElementType() == IJavaElement.INITIALIZER) {
        methodName = JdtUtils.getMethodSignature(javaElement);
        if (methodName != null) {
            name += ":" + methodName;
        }
    }
    return new TypedElement(name, methodName, TypedElement.TYPE_BYTECODE, javaElement, modes);
}

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

Introduction

Prototype

Document

Usage