* 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 org.eclipse.jdt.ui.IWorkingCopyProvider * @see JavaCore#getSharedWorkingCopies(org.eclipse.jdt.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;
}
}