+ * The following Java element hierarchy is surfaced by this content provider: + *
+ * + *
+ * Java model ( + *+ * + * + *+ * IJavaModel + *+ * ) + * Java project ( + *+ * IJavaProject + *+ * ) + * package fragment root ( + *+ * IPackageFragmentRoot + *+ * ) + * package fragment ( + *+ * IPackageFragment + *+ * ) + * compilation unit ( + *+ * ICompilationUnit + *+ * ) + * binary class file ( + *+ * IClassFile + *+ * ) + *
+ * Note that when the entire Java project is declared to be package fragment + * root, the corresponding package fragment root element that normally appears + * between the Java project and the package fragments is automatically filtered + * out. + *
+ * This content provider can optionally return working copy elements for members + * below compilation units. If enabled, working copy members are returned for + * those compilation units in the Java element hierarchy for which a shared + * working copy exists in JDT core. + * + * @see net.sourceforge.phpdt.ui.IWorkingCopyProvider + * @see JavaCore#getSharedWorkingCopies(net.sourceforge.phpdt.core.IBufferFactory) + * + * @since 2.0 + */ +public class StandardJavaElementContentProvider implements + ITreeContentProvider, IWorkingCopyProvider { + + protected static final Object[] NO_CHILDREN = new Object[0]; + + protected boolean fProvideMembers = false; + + protected boolean fProvideWorkingCopy = false; + + /** + * Creates a new content provider. The content provider does not provide + * members of compilation units or class files and it does not provide + * working copy elements. + */ + public StandardJavaElementContentProvider() { + } + + /** + * Creates a newStandardJavaElementContentProvider.
+ *
+ * @param provideMembers
+ * if true members below compilation units and
+ * class files are provided.
+ * @param provideWorkingCopy
+ * if true the element provider provides working
+ * copies members of compilation units which have an associated
+ * working copy in JDT core. Otherwise only original elements are
+ * provided.
+ */
+ public StandardJavaElementContentProvider(boolean provideMembers,
+ boolean provideWorkingCopy) {
+ fProvideMembers = provideMembers;
+ fProvideWorkingCopy = provideWorkingCopy;
+ }
+
+ /**
+ * Returns whether members are provided when asking for a compilation units
+ * or class file for its children.
+ *
+ * @return true if the content provider provides members;
+ * otherwise false is returned
+ */
+ public boolean getProvideMembers() {
+ return fProvideMembers;
+ }
+
+ /**
+ * Sets whether the content provider is supposed to return members when
+ * asking a compilation unit or class file for its children.
+ *
+ * @param b
+ * if true then members are provided. If
+ * false compilation units and class files are the
+ * leaves provided by this content provider.
+ */
+ public void setProvideMembers(boolean b) {
+ fProvideMembers = b;
+ }
+
+ /**
+ * Returns whether the provided members are from a working copy or the
+ * original compilation unit.
+ *
+ * @return true if the content provider provides working copy
+ * members; otherwise false is returned
+ *
+ * @see #setProvideWorkingCopy(boolean)
+ */
+ public boolean getProvideWorkingCopy() {
+ return fProvideWorkingCopy;
+ }
+
+ /**
+ * Sets whether the members are provided from a shared working copy that
+ * exists for a original compilation unit in the Java element hierarchy.
+ *
+ * @param b
+ * if true members are provided from a working
+ * copy if one exists in JDT core. If false the
+ * provider always returns original elements.
+ */
+ public void setProvideWorkingCopy(boolean b) {
+ fProvideWorkingCopy = b;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see IWorkingCopyProvider#providesWorkingCopies()
+ */
+ public boolean providesWorkingCopies() {
+ return fProvideWorkingCopy;
+ }
+
+ /*
+ * (non-Javadoc) Method declared on IStructuredContentProvider.
+ */
+ public Object[] getElements(Object parent) {
+ return getChildren(parent);
+ }
+
+ /*
+ * (non-Javadoc) Method declared on IContentProvider.
+ */
+ public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
+ }
+
+ /*
+ * (non-Javadoc) Method declared on IContentProvider.
+ */
+ public void dispose() {
+ }
+
+ /*
+ * (non-Javadoc) Method declared on ITreeContentProvider.
+ */
+ public Object[] getChildren(Object element) {
+ if (!exists(element))
+ return NO_CHILDREN;
+
+ try {
+ if (element instanceof IJavaModel)
+ return getJavaProjects((IJavaModel) element);
+
+ // if (element instanceof IJavaProject)
+ // return getPackageFragmentRoots((IJavaProject)element);
+ //
+ if (element instanceof IPackageFragmentRoot)
+ return getPackageFragments((IPackageFragmentRoot) element);
+
+ // if (element instanceof IPackageFragment)
+ // return getPackageContents((IPackageFragment)element);
+
+ if (element instanceof IFolder)
+ return getResources((IFolder) element);
+
+ if (fProvideMembers && element instanceof ISourceReference
+ && element instanceof IParent) {
+ if (fProvideWorkingCopy && element instanceof ICompilationUnit) {
+ element = JavaModelUtil
+ .toWorkingCopy((ICompilationUnit) element);
+ }
+ return ((IParent) element).getChildren();
+ }
+ } catch (JavaModelException e) {
+ return NO_CHILDREN;
+ }
+ return NO_CHILDREN;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see ITreeContentProvider
+ */
+ public boolean hasChildren(Object element) {
+ if (fProvideMembers) {
+ // assume CUs and class files are never empty
+ if (element instanceof ICompilationUnit) {
+ // ||
+ // element instanceof IClassFile) {
+ return true;
+ }
+ } else {
+ // don't allow to drill down into a compilation unit or class file
+ if (element instanceof ICompilationUnit ||
+ // element instanceof IClassFile ||
+ element instanceof IFile)
+ return false;
+ }
+
+ if (element instanceof IJavaProject) {
+ IJavaProject jp = (IJavaProject) element;
+ if (!jp.getProject().isOpen()) {
+ return false;
+ }
+ }
+
+ if (element instanceof IParent) {
+ try {
+ // when we have Java children return true, else we fetch all the
+ // children
+ if (((IParent) element).hasChildren())
+ return true;
+ } catch (JavaModelException e) {
+ return true;
+ }
+ }
+ Object[] children = getChildren(element);
+ return (children != null) && children.length > 0;
+ }
+
+ /*
+ * (non-Javadoc) Method declared on ITreeContentProvider.
+ */
+ public Object getParent(Object element) {
+ if (!exists(element))
+ return null;
+ return internalGetParent(element);
+ }
+
+ private Object[] getPackageFragments(IPackageFragmentRoot root)
+ throws JavaModelException {
+ IJavaElement[] fragments = root.getChildren();
+ // Object[] nonJavaResources= root.getNonJavaResources();
+ // if (nonJavaResources == null)
+ return fragments;
+ // return concatenate(fragments, nonJavaResources);
+ }
+
+ /**
+ * Note: This method is for internal use only. Clients should not call this
+ * method.
+ */
+ // protected Object[] getPackageFragmentRoots(IJavaProject project) throws
+ // JavaModelException {
+ // if (!project.getProject().isOpen())
+ // return NO_CHILDREN;
+ //
+ // IPackageFragmentRoot[] roots= project.getPackageFragmentRoots();
+ // List list= new ArrayList(roots.length);
+ // // filter out package fragments that correspond to projects and
+ // // replace them with the package fragments directly
+ // for (int i= 0; i < roots.length; i++) {
+ // IPackageFragmentRoot root= (IPackageFragmentRoot)roots[i];
+ // if (isProjectPackageFragmentRoot(root)) {
+ // Object[] children= root.getChildren();
+ // for (int k= 0; k < children.length; k++)
+ // list.add(children[k]);
+ // }
+ // else if (hasChildren(root)) {
+ // list.add(root);
+ // }
+ // }
+ // return concatenate(list.toArray(), project.getNonJavaResources());
+ // }
+ /**
+ * Note: This method is for internal use only. Clients should not call this
+ * method.
+ */
+ protected Object[] getJavaProjects(IJavaModel jm) throws JavaModelException {
+ return jm.getJavaProjects();
+ }
+
+ // private Object[] getPackageContents(IPackageFragment fragment) throws
+ // JavaModelException {
+ // if (fragment.getKind() == IPackageFragmentRoot.K_SOURCE) {
+ // return concatenate(fragment.getCompilationUnits(),
+ // fragment.getNonJavaResources());
+ // }
+ // return concatenate(fragment.getClassFiles(),
+ // fragment.getNonJavaResources());
+ // }
+
+ private Object[] getResources(IFolder folder) {
+ try {
+ // filter out folders that are package fragment roots
+ Object[] members = folder.members();
+ List nonJavaResources = new ArrayList();
+ for (int i = 0; i < members.length; i++) {
+ Object o = members[i];
+ // A folder can also be a package fragement root in the
+ // following case
+ // Project
+ // + src <- source folder
+ // + excluded <- excluded from class path
+ // + included <- a new source folder.
+ // Included is a member of excluded, but since it is rendered as
+ // a source
+ // folder we have to exclude it as a normal child.
+ if (o instanceof IFolder) {
+ IJavaElement element = JavaCore.create((IFolder) o);
+ if (element instanceof IPackageFragmentRoot
+ && element.exists()) {
+ continue;
+ }
+ }
+ nonJavaResources.add(o);
+ }
+ return nonJavaResources.toArray();
+ } catch (CoreException e) {
+ return NO_CHILDREN;
+ }
+ }
+
+ /**
+ * Note: This method is for internal use only. Clients should not call this
+ * method.
+ */
+ protected boolean isClassPathChange(IJavaElementDelta delta) {
+
+ // need to test the flags only for package fragment roots
+ if (delta.getElement().getElementType() != IJavaElement.PACKAGE_FRAGMENT_ROOT)
+ return false;
+
+ int flags = delta.getFlags();
+ return (delta.getKind() == IJavaElementDelta.CHANGED
+ && ((flags & IJavaElementDelta.F_ADDED_TO_CLASSPATH) != 0)
+ || ((flags & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) != 0) || ((flags & IJavaElementDelta.F_REORDER) != 0));
+ }
+
+ /**
+ * Note: This method is for internal use only. Clients should not call this
+ * method.
+ */
+ protected Object skipProjectPackageFragmentRoot(IPackageFragmentRoot root) {
+ try {
+ if (isProjectPackageFragmentRoot(root))
+ return root.getParent();
+ return root;
+ } catch (JavaModelException e) {
+ return root;
+ }
+ }
+
+ /**
+ * Note: This method is for internal use only. Clients should not call this
+ * method.
+ */
+ protected boolean isPackageFragmentEmpty(IJavaElement element)
+ throws JavaModelException {
+ if (element instanceof IPackageFragment) {
+ IPackageFragment fragment = (IPackageFragment) element;
+ if (!(fragment.hasChildren()))
+ // ||
+ // fragment.getNonJavaResources().length > 0) &&
+ // fragment.hasSubpackages())
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Note: This method is for internal use only. Clients should not call this
+ * method.
+ */
+ protected boolean isProjectPackageFragmentRoot(IPackageFragmentRoot root)
+ throws JavaModelException {
+ IResource resource = root.getResource();
+ return (resource instanceof IProject);
+ }
+
+ /**
+ * Note: This method is for internal use only. Clients should not call this
+ * method.
+ */
+ protected boolean exists(Object element) {
+ if (element == null) {
+ return false;
+ }
+ if (element instanceof IResource) {
+ return ((IResource) element).exists();
+ }
+ if (element instanceof IJavaElement) {
+ return ((IJavaElement) element).exists();
+ }
+ return true;
+ }
+
+ /**
+ * Note: This method is for internal use only. Clients should not call this
+ * method.
+ */
+ protected Object internalGetParent(Object element) {
+ if (element instanceof IJavaProject) {
+ return ((IJavaProject) element).getJavaModel();
+ }
+ // try to map resources to the containing package fragment
+ if (element instanceof IResource) {
+ IResource parent = ((IResource) element).getParent();
+ IJavaElement jParent = JavaCore.create(parent);
+ // http://bugs.eclipse.org/bugs/show_bug.cgi?id=31374
+ if (jParent != null && jParent.exists())
+ return jParent;
+ return parent;
+ }
+
+ // for package fragments that are contained in a project package
+ // fragment
+ // we have to skip the package fragment root as the parent.
+ if (element instanceof IPackageFragment) {
+ IPackageFragmentRoot parent = (IPackageFragmentRoot) ((IPackageFragment) element)
+ .getParent();
+ return skipProjectPackageFragmentRoot(parent);
+ }
+ if (element instanceof IJavaElement) {
+ IJavaElement candidate = ((IJavaElement) element).getParent();
+ // If the parent is a CU we might have shown working copy elements
+ // below CU level. If so
+ // return the original element instead of the working copy.
+ if (candidate != null
+ && candidate.getElementType() == IJavaElement.COMPILATION_UNIT) {
+ candidate = JavaModelUtil
+ .toOriginal((ICompilationUnit) candidate);
+ }
+ return candidate;
+ }
+ return null;
+ }
+
+ /**
+ * Note: This method is for internal use only. Clients should not call this
+ * method.
+ */
+ protected static Object[] concatenate(Object[] a1, Object[] a2) {
+ int a1Len = a1.length;
+ int a2Len = a2.length;
+ Object[] res = new Object[a1Len + a2Len];
+ System.arraycopy(a1, 0, res, 0, a1Len);
+ System.arraycopy(a2, 0, res, a1Len, a2Len);
+ return res;
+ }
+
+}