Example usage for org.eclipse.jdt.core IJavaElementDelta F

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IJavaElementDelta F_CONTENT.

Prototype

int F_CONTENT

To view the source code for org.eclipse.jdt.core IJavaElementDelta F_CONTENT.

Click Source Link

Document

Change flag indicating that the content of the element has changed.

Usage

From source file:com.codenvy.ide.ext.java.server.internal.core.DeltaProcessor.java

License:Open Source License

private void contentChanged(Openable element) {

    boolean isPrimary = false;
    boolean isPrimaryWorkingCopy = false;
    if (element.getElementType() == IJavaElement.COMPILATION_UNIT) {
        CompilationUnit cu = (CompilationUnit) element;
        isPrimary = cu.isPrimary();/*  w  ww .j  av a 2 s  . c  o m*/
        isPrimaryWorkingCopy = isPrimary && cu.isWorkingCopy();
    }
    if (isPrimaryWorkingCopy) {
        // filter out changes to primary compilation unit in working copy mode
        // just report a change to the resource (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=59500)
        currentDelta().changed(element, IJavaElementDelta.F_PRIMARY_RESOURCE);
    } else {
        close(element);
        int flags = IJavaElementDelta.F_CONTENT;
        if (element instanceof JarPackageFragmentRoot) {
            flags |= IJavaElementDelta.F_ARCHIVE_CONTENT_CHANGED;
            // need also to reset project cache otherwise it will be out-of-date
            // see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=162621
            this.projectCachesToReset.add(element.getJavaProject());
        }
        if (isPrimary) {
            flags |= IJavaElementDelta.F_PRIMARY_RESOURCE;
        }
        currentDelta().changed(element, flags);
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.JavaElementDelta.java

License:Open Source License

protected boolean toDebugString(StringBuffer buffer, int flags) {
    boolean prev = super.toDebugString(buffer, flags);

    if ((flags & IJavaElementDelta.F_CHILDREN) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("CHILDREN"); //$NON-NLS-1$
        prev = true;/*from  w  w  w  . j  a  v a2s  .co  m*/
    }
    if ((flags & IJavaElementDelta.F_CONTENT) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("CONTENT"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_MOVED_FROM) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("MOVED_FROM(" + ((JavaElement) getMovedFromElement()).toStringWithAncestors() + ")"); //$NON-NLS-1$ //$NON-NLS-2$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_MOVED_TO) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("MOVED_TO(" + ((JavaElement) getMovedToElement()).toStringWithAncestors() + ")"); //$NON-NLS-1$ //$NON-NLS-2$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_ADDED_TO_CLASSPATH) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("ADDED TO CLASSPATH"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("REMOVED FROM CLASSPATH"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_REORDER) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("REORDERED"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_ARCHIVE_CONTENT_CHANGED) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("ARCHIVE CONTENT CHANGED"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_SOURCEATTACHED) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("SOURCE ATTACHED"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_SOURCEDETACHED) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("SOURCE DETACHED"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_FINE_GRAINED) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("FINE GRAINED"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_PRIMARY_WORKING_COPY) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("PRIMARY WORKING COPY"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_CLASSPATH_CHANGED) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("RAW CLASSPATH CHANGED"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("RESOLVED CLASSPATH CHANGED"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_PRIMARY_RESOURCE) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("PRIMARY RESOURCE"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_OPENED) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("OPENED"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_CLOSED) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("CLOSED"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_AST_AFFECTED) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("AST AFFECTED"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_CATEGORIES) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("CATEGORIES"); //$NON-NLS-1$
        prev = true;
    }
    if ((flags & IJavaElementDelta.F_ANNOTATIONS) != 0) {
        if (prev)
            buffer.append(" | "); //$NON-NLS-1$
        buffer.append("ANNOTATIONS"); //$NON-NLS-1$
        prev = true;
    }
    return prev;
}

From source file:com.codenvy.ide.ext.java.server.internal.core.JavaElementDeltaBuilder.java

License:Open Source License

/**
 * Finds elements which have been added or changed.
 */// w ww.j av a 2s  .co  m
private void findAdditions(IJavaElement newElement, int depth) {
    JavaElementInfo oldInfo = getElementInfo(newElement);
    if (oldInfo == null && depth < this.maxDepth) {
        this.delta.added(newElement);
        added(newElement);
    } else {
        removeElementInfo(newElement);
    }

    if (depth >= this.maxDepth) {
        // mark element as changed
        this.delta.changed(newElement, IJavaElementDelta.F_CONTENT);
        return;
    }

    JavaElementInfo newInfo = null;
    try {
        newInfo = (JavaElementInfo) ((JavaElement) newElement).getElementInfo();
    } catch (JavaModelException npe) {
        return;
    }

    findContentChange(oldInfo, newInfo, newElement);

    if (oldInfo != null && newElement instanceof IParent) {

        IJavaElement[] children = newInfo.getChildren();
        if (children != null) {
            int length = children.length;
            for (int i = 0; i < length; i++) {
                findAdditions(children[i], depth + 1);
            }
        }
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.JavaElementDeltaBuilder.java

License:Open Source License

private void findAnnotationChanges(IAnnotation[] oldAnnotations, IAnnotation[] newAnnotations,
        IJavaElement parent) {//from   ww w.  j  a v a2s  .  com
    ArrayList annotationDeltas = null;
    for (int i = 0, length = newAnnotations.length; i < length; i++) {
        IAnnotation newAnnotation = newAnnotations[i];
        Object oldInfo = this.annotationInfos.remove(newAnnotation);
        if (oldInfo == null) {
            JavaElementDelta annotationDelta = new JavaElementDelta(newAnnotation);
            annotationDelta.added();
            if (annotationDeltas == null)
                annotationDeltas = new ArrayList();
            annotationDeltas.add(annotationDelta);
            continue;
        } else {
            AnnotationInfo newInfo = null;
            try {
                newInfo = (AnnotationInfo) ((JavaElement) newAnnotation).getElementInfo();
            } catch (JavaModelException npe) {
                return;
            }
            if (!Util.equalArraysOrNull(((AnnotationInfo) oldInfo).members, newInfo.members)) {
                JavaElementDelta annotationDelta = new JavaElementDelta(newAnnotation);
                annotationDelta.changed(IJavaElementDelta.F_CONTENT);
                if (annotationDeltas == null)
                    annotationDeltas = new ArrayList();
                annotationDeltas.add(annotationDelta);
            }
        }
    }
    for (int i = 0, length = oldAnnotations.length; i < length; i++) {
        IAnnotation oldAnnotation = oldAnnotations[i];
        if (this.annotationInfos.remove(oldAnnotation) != null) {
            JavaElementDelta annotationDelta = new JavaElementDelta(oldAnnotation);
            annotationDelta.removed();
            if (annotationDeltas == null)
                annotationDeltas = new ArrayList();
            annotationDeltas.add(annotationDelta);
        }
    }
    if (annotationDeltas == null)
        return;
    int size = annotationDeltas.size();
    if (size > 0) {
        JavaElementDelta parentDelta = this.delta.changed(parent, IJavaElementDelta.F_ANNOTATIONS);
        parentDelta.annotationDeltas = (IJavaElementDelta[]) annotationDeltas
                .toArray(new IJavaElementDelta[size]);
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.JavaElementDeltaBuilder.java

License:Open Source License

/**
 * The elements are equivalent, but might have content changes.
 *///ww  w .j  a v a 2 s .com
private void findContentChange(JavaElementInfo oldInfo, JavaElementInfo newInfo, IJavaElement newElement) {
    if (oldInfo instanceof MemberElementInfo && newInfo instanceof MemberElementInfo) {
        if (((MemberElementInfo) oldInfo).getModifiers() != ((MemberElementInfo) newInfo).getModifiers()) {
            this.delta.changed(newElement, IJavaElementDelta.F_MODIFIERS);
        }
        if (oldInfo instanceof AnnotatableInfo && newInfo instanceof AnnotatableInfo) {
            findAnnotationChanges(((AnnotatableInfo) oldInfo).annotations,
                    ((AnnotatableInfo) newInfo).annotations, newElement);
        }
        if (oldInfo instanceof SourceMethodElementInfo && newInfo instanceof SourceMethodElementInfo) {
            SourceMethodElementInfo oldSourceMethodInfo = (SourceMethodElementInfo) oldInfo;
            SourceMethodElementInfo newSourceMethodInfo = (SourceMethodElementInfo) newInfo;
            if (!CharOperation.equals(oldSourceMethodInfo.getReturnTypeName(),
                    newSourceMethodInfo.getReturnTypeName())
                    || !CharOperation.equals(oldSourceMethodInfo.getTypeParameterNames(),
                            newSourceMethodInfo.getTypeParameterNames())
                    || !equals(oldSourceMethodInfo.getTypeParameterBounds(),
                            newSourceMethodInfo.getTypeParameterBounds())) {
                this.delta.changed(newElement, IJavaElementDelta.F_CONTENT);
            }
        } else if (oldInfo instanceof SourceFieldElementInfo && newInfo instanceof SourceFieldElementInfo) {
            if (!CharOperation.equals(((SourceFieldElementInfo) oldInfo).getTypeName(),
                    ((SourceFieldElementInfo) newInfo).getTypeName())) {
                this.delta.changed(newElement, IJavaElementDelta.F_CONTENT);
            }
        } else if (oldInfo instanceof SourceTypeElementInfo && newInfo instanceof SourceTypeElementInfo) {
            SourceTypeElementInfo oldSourceTypeInfo = (SourceTypeElementInfo) oldInfo;
            SourceTypeElementInfo newSourceTypeInfo = (SourceTypeElementInfo) newInfo;
            if (!CharOperation.equals(oldSourceTypeInfo.getSuperclassName(),
                    newSourceTypeInfo.getSuperclassName())
                    || !CharOperation.equals(oldSourceTypeInfo.getInterfaceNames(),
                            newSourceTypeInfo.getInterfaceNames())) {
                this.delta.changed(newElement, IJavaElementDelta.F_SUPER_TYPES);
            }
            if (!CharOperation.equals(oldSourceTypeInfo.getTypeParameterNames(),
                    newSourceTypeInfo.getTypeParameterNames())
                    || !equals(oldSourceTypeInfo.getTypeParameterBounds(),
                            newSourceTypeInfo.getTypeParameterBounds())) {
                this.delta.changed(newElement, IJavaElementDelta.F_CONTENT);
            }
            HashMap oldTypeCategories = oldSourceTypeInfo.categories;
            HashMap newTypeCategories = newSourceTypeInfo.categories;
            if (oldTypeCategories != null) {
                // take the union of old and new categories elements (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=125675)
                Set elements;
                if (newTypeCategories != null) {
                    elements = new HashSet(oldTypeCategories.keySet());
                    elements.addAll(newTypeCategories.keySet());
                } else
                    elements = oldTypeCategories.keySet();
                Iterator iterator = elements.iterator();
                while (iterator.hasNext()) {
                    IJavaElement element = (IJavaElement) iterator.next();
                    String[] oldCategories = (String[]) oldTypeCategories.get(element);
                    String[] newCategories = newTypeCategories == null ? null
                            : (String[]) newTypeCategories.get(element);
                    if (!Util.equalArraysOrNull(oldCategories, newCategories)) {
                        this.delta.changed(element, IJavaElementDelta.F_CATEGORIES);
                    }
                }
            } else if (newTypeCategories != null) {
                Iterator elements = newTypeCategories.keySet().iterator();
                while (elements.hasNext()) {
                    IJavaElement element = (IJavaElement) elements.next();
                    this.delta.changed(element, IJavaElementDelta.F_CATEGORIES); // all categories for this element were removed
                }
            }
        }
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.ModelUpdater.java

License:Open Source License

/**
 * Converts an <code>IResourceDelta</code> and its children into
 * the corresponding <code>IJavaElementDelta</code>s.
 * Return whether the delta corresponds to a resource on the classpath.
 * If it is not a resource on the classpath, it will be added as a non-java
 * resource by the sender of this method.
 *//*from w ww . j a  v a2s  .c o m*/
protected void traverseDelta(IJavaElementDelta delta, IPackageFragmentRoot root, IJavaProject project) {

    boolean processChildren = true;

    Openable element = (Openable) delta.getElement();
    switch (element.getElementType()) {
    case IJavaElement.JAVA_PROJECT:
        project = (IJavaProject) element;
        break;
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        root = (IPackageFragmentRoot) element;
        break;
    case IJavaElement.COMPILATION_UNIT:
        // filter out working copies that are not primary (we don't want to add/remove them to/from the package fragment
        CompilationUnit cu = (CompilationUnit) element;
        if (cu.isWorkingCopy() && !cu.isPrimary()) {
            return;
        }
        // $FALL-THROUGH$
    case IJavaElement.CLASS_FILE:
        processChildren = false;
        break;
    }

    switch (delta.getKind()) {
    case IJavaElementDelta.ADDED:
        elementAdded(element);
        break;
    case IJavaElementDelta.REMOVED:
        elementRemoved(element);
        break;
    case IJavaElementDelta.CHANGED:
        if ((delta.getFlags() & IJavaElementDelta.F_CONTENT) != 0) {
            elementChanged(element);
        }
        break;
    }
    if (processChildren) {
        IJavaElementDelta[] children = delta.getAffectedChildren();
        for (int i = 0; i < children.length; i++) {
            IJavaElementDelta childDelta = children[i];
            traverseDelta(childDelta, root, project);
        }
    }
}

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  va 2 s  .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:com.redhat.ceylon.eclipse.code.explorer.PackageExplorerContentProvider.java

License:Open Source License

private static boolean isStructuralCUChange(int flags) {
    // No refresh on working copy creation (F_PRIMARY_WORKING_COPY)
    return (flags & IJavaElementDelta.F_CHILDREN) != 0 || (flags
            & (IJavaElementDelta.F_CONTENT | IJavaElementDelta.F_FINE_GRAINED)) == IJavaElementDelta.F_CONTENT;
}

From source file:com.technophobia.eclipse.project.cache.listener.ClassFileChangedListener.java

License:Open Source License

private void findChangeNodes(final IJavaElementDelta delta, final Collection<IJavaElementDelta> changeNodes) {
    if (hasFlag(IJavaElementDelta.CHANGED, delta.getKind())) {
        final int flags = delta.getFlags();

        if (hasFlag(IJavaElementDelta.F_CONTENT, flags)) {
            changeNodes.add(delta);/*w  w  w  .ja  va  2  s  . c o m*/
        } else if (hasFlag(IJavaElementDelta.F_CHILDREN, flags)) {
            for (final IJavaElementDelta child : delta.getAffectedChildren()) {
                findChangeNodes(child, changeNodes);
            }
        }
    }
}

From source file:de.fu_berlin.inf.jtourbus.view.TourChangeListener.java

License:Open Source License

void visitInternal(IProgressMonitor pm, IJavaElementDelta delta) {

    IJavaElement elem = delta.getElement();
    IJavaElementDelta[] children = delta.getAffectedChildren();

    if (pm != null)
        pm.beginTask("", children.length + 2);

    if ((delta.getFlags() & IJavaElementDelta.F_CHILDREN) != 0) {

        if (delta.getKind() != IJavaElementDelta.CHANGED) {
            throw new RuntimeException("ASSERT: CHILDREN should always be CHANGE");
        }/*from  ww  w. ja  v a  2  s.  c  om*/

        for (int i = 0; i < children.length; i++) {
            visit(pm, children[i]);
        }
        return;
    }

    switch (delta.getKind()) {
    case IJavaElementDelta.ADDED: {
        if (!((delta.getFlags() & IJavaElementDelta.F_CHILDREN) == 0))
            throw new RuntimeException("ASSERT: ADDED has no children");

        switch (elem.getElementType()) {
        case IJavaElement.JAVA_MODEL:
            throw new RuntimeException("ASSERT: Adding Java Model not possible");
        case IJavaElement.JAVA_PROJECT:
            throw new RuntimeException("ASSERT: Adding Java Project not possible");
        case IJavaElement.PACKAGE_FRAGMENT_ROOT:
            // The user added a source folder

            for (BusStop bs : Utilities.findJTourBusStops(pm, elem.getResource()))
                fContentProvider.fTourPlan.add(bs);
            return;
        case IJavaElement.PACKAGE_FRAGMENT:
            // The user inserted a packaged

            for (BusStop bs : Utilities.findJTourBusStops(pm, elem.getResource()))
                fContentProvider.fTourPlan.add(bs);
            return;
        case IJavaElement.COMPILATION_UNIT: {
            ICompilationUnit cu = (ICompilationUnit) elem;
            if (cu.getPrimary().equals(cu)) {
                for (BusStop bs : Utilities.findJTourBusStops(pm, elem.getResource()))
                    fContentProvider.fTourPlan.add(bs);
            }
            return;
        }
        default:
            ICompilationUnit cu = (ICompilationUnit) delta.getElement()
                    .getAncestor(IJavaElement.COMPILATION_UNIT);

            redoCU(cu, pm);
            return;
        }
    }
    case IJavaElementDelta.REMOVED:
        if (!((delta.getFlags() & IJavaElementDelta.F_CHILDREN) == 0))
            throw new RuntimeException("REMOVED has children");

        switch (elem.getElementType()) {
        case IJavaElement.JAVA_MODEL:
            throw new RuntimeException("ASSERT: Java Model not possible");
        case IJavaElement.JAVA_PROJECT:
            fContentProvider.fTourPlan.removeAll();
            return;
        case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        case IJavaElement.PACKAGE_FRAGMENT:
            fContentProvider.fTourPlan.removeAll();

            for (BusStop bs : Utilities.findJTourBusStops(pm, elem.getJavaProject().getResource()))
                fContentProvider.fTourPlan.add(bs);

            return;
        case IJavaElement.COMPILATION_UNIT: {
            ICompilationUnit cu = (ICompilationUnit) elem;
            if (cu.getPrimary().equals(cu)) {
                fContentProvider.fTourPlan.removeCU(cu);
            }
            return;
        }
        default: {
            ICompilationUnit cu = (ICompilationUnit) delta.getElement()
                    .getAncestor(IJavaElement.COMPILATION_UNIT);

            redoCU(cu, pm);
            return;
        }
        }
    case IJavaElementDelta.CHANGED:
        // F_CONTENT && F_FINE_GRAINED
        if ((delta.getFlags() & IJavaElementDelta.F_CONTENT) != 0
                && (delta.getFlags() & IJavaElementDelta.F_FINE_GRAINED) != 0) {

            ICompilationUnit cu = (ICompilationUnit) delta.getElement()
                    .getAncestor(IJavaElement.COMPILATION_UNIT);

            redoCU(cu, pm);
        }

        // Closing without saving will trigger this event. We thus re-read
        // the file.
        if ((delta.getFlags() & IJavaElementDelta.F_PRIMARY_WORKING_COPY) != 0) {

            ICompilationUnit cu = (ICompilationUnit) delta.getElement();

            /* FIXME */

            redoCU(cu, pm);
        }
        break;
    }
}

Example usage for org.eclipse.jdt.core IJavaElementDelta F_CONTENT

Introduction

Prototype

Document

Usage