1) Added setting of syntax properties to italic, underline and strike through.
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / ui / StandardJavaElementContentProvider.java
index 7f1d21b..5c10738 100644 (file)
@@ -15,15 +15,15 @@ import java.util.List;
 
 import net.sourceforge.phpdt.core.ICompilationUnit;
 import net.sourceforge.phpdt.core.IJavaElement;
-import net.sourceforge.phpdt.core.IJavaElementDelta;
+//import net.sourceforge.phpdt.core.IJavaElementDelta;
 import net.sourceforge.phpdt.core.IJavaModel;
 import net.sourceforge.phpdt.core.IJavaProject;
 import net.sourceforge.phpdt.core.IPackageFragment;
 import net.sourceforge.phpdt.core.IPackageFragmentRoot;
 import net.sourceforge.phpdt.core.IParent;
 import net.sourceforge.phpdt.core.ISourceReference;
-import net.sourceforge.phpdt.core.JavaModelException;
 import net.sourceforge.phpdt.core.JavaCore;
+import net.sourceforge.phpdt.core.JavaModelException;
 import net.sourceforge.phpdt.internal.corext.util.JavaModelUtil;
 
 import org.eclipse.core.resources.IFile;
@@ -34,416 +34,478 @@ import org.eclipse.core.runtime.CoreException;
 import org.eclipse.jface.viewers.ITreeContentProvider;
 import org.eclipse.jface.viewers.Viewer;
 
 /**
- * A base content provider for Java elements. It provides access to the
- * Java element hierarchy without listening to changes in the Java model.
- * If updating the presentation on Java model change is required than 
- * clients have to subclass, listen to Java model changes and have to update
- * the UI using corresponding methods provided by the JFace viewers or their 
- * own UI presentation.
+ * A base content provider for Java elements. It provides access to the Java
+ * element hierarchy without listening to changes in the Java model. If updating
+ * the presentation on Java model change is required than clients have to
+ * subclass, listen to Java model changes and have to update the UI using
+ * corresponding methods provided by the JFace viewers or their own UI
+ * presentation.
  * <p>
  * The following Java element hierarchy is surfaced by this content provider:
  * <p>
+ * 
  * <pre>
-Java model (<code>IJavaModel</code>)
-   Java project (<code>IJavaProject</code>)
-      package fragment root (<code>IPackageFragmentRoot</code>)
-         package fragment (<code>IPackageFragment</code>)
-            compilation unit (<code>ICompilationUnit</code>)
-            binary class file (<code>IClassFile</code>)
+ *  Java model (
+ * <code>
+ * IJavaModel
+ * </code>
+ * )
+ *  Java project (
+ * <code>
+ * IJavaProject
+ * </code>
+ * )
+ *  package fragment root (
+ * <code>
+ * IPackageFragmentRoot
+ * </code>
+ * )
+ *  package fragment (
+ * <code>
+ * IPackageFragment
+ * </code>
+ * )
+ *  compilation unit (
+ * <code>
+ * ICompilationUnit
+ * </code>
+ * )
+ *  binary class file (
+ * <code>
+ * IClassFile
+ * </code>
+ * )
  * </pre>
- * </p>                        
+ * 
+ * </p>
  * <p>
- * 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.
+ * 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.
  * </p>
- * 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.
+ * 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)
+ * @see net.sourceforge.phpdt.ui.IWorkingCopyProvider
+ * @see JavaCore#getSharedWorkingCopies(net.sourceforge.phpdt.core.IBufferFactory)
  * 
  * @since 2.0
  */
-public class StandardJavaElementContentProvider implements ITreeContentProvider, IWorkingCopyProvider {
+public class StandardJavaElementContentProvider implements
+               ITreeContentProvider, IWorkingCopyProvider {
 
-       protected static final Object[] NO_CHILDREN= new Object[0];
+       protected static final Object[] NO_CHILDREN = new Object[0];
+
+       protected boolean fProvideMembers = false;
+
+       protected boolean fProvideWorkingCopy = false;
 
-       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 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 new <code>StandardJavaElementContentProvider</code>.
-        *
-        * @param provideMembers if <code>true</code> members below compilation units 
-        * and class files are provided. 
-        * @param provideWorkingCopy if <code>true</code> 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.
+        * 
+        * @param provideMembers
+        *            if <code>true</code> members below compilation units and
+        *            class files are provided.
+        * @param provideWorkingCopy
+        *            if <code>true</code> 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;
+       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.
+        * Returns whether members are provided when asking for a compilation units
+        * or class file for its children.
         * 
-        * @return <code>true</code> if the content provider provides members; 
-        * otherwise <code>false</code> is returned
+        * @return <code>true</code> if the content provider provides members;
+        *         otherwise <code>false</code> is returned
         */
-       public boolean getProvideMembers() {
-               return fProvideMembers;
-       }
+//     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.
+        * Sets whether the content provider is supposed to return members when
+        * asking a compilation unit or class file for its children.
         * 
-        * @param b if <code>true</code> then members are provided. 
-        * If <code>false</code> compilation units and class files are the
-        * leaves provided by this content provider.
+        * @param b
+        *            if <code>true</code> then members are provided. If
+        *            <code>false</code> compilation units and class files are the
+        *            leaves provided by this content provider.
         */
-       public void setProvideMembers(boolean b) {
-               fProvideMembers= b;
-       }
-       
+//     public void setProvideMembers(boolean b) {
+//             fProvideMembers = b;
+//     }
+
        /**
-        * Returns whether the provided members are from a working
-        * copy or the original compilation unit. 
+        * Returns whether the provided members are from a working copy or the
+        * original compilation unit.
         * 
-        * @return <code>true</code> if the content provider provides
-        * working copy members; otherwise <code>false</code> is
-        * returned
+        * @return <code>true</code> if the content provider provides working copy
+        *         members; otherwise <code>false</code> is returned
         * 
         * @see #setProvideWorkingCopy(boolean)
         */
-       public boolean getProvideWorkingCopy() {
-               return fProvideWorkingCopy;
-       }
+//     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.
+        * 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 <code>true</code> members are provided from a 
-        * working copy if one exists in JDT core. If <code>false</code> the 
-        * provider always returns original elements.
+        * @param b
+        *            if <code>true</code> members are provided from a working
+        *            copy if one exists in JDT core. If <code>false</code> the
+        *            provider always returns original elements.
         */
-       public void setProvideWorkingCopy(boolean b) {
-               fProvideWorkingCopy= b;
-       }
+//     public void setProvideWorkingCopy(boolean b) {
+//             fProvideWorkingCopy = b;
+//     }
 
-       /* (non-Javadoc)
+       /*
+        * (non-Javadoc)
+        * 
         * @see IWorkingCopyProvider#providesWorkingCopies()
         */
        public boolean providesWorkingCopies() {
                return fProvideWorkingCopy;
        }
 
-       /* (non-Javadoc)
-        * Method declared on IStructuredContentProvider.
+       /*
+        * (non-Javadoc) Method declared on IStructuredContentProvider.
         */
        public Object[] getElements(Object parent) {
                return getChildren(parent);
        }
-       
-       /* (non-Javadoc)
-        * Method declared on IContentProvider.
+
+       /*
+        * (non-Javadoc) Method declared on IContentProvider.
         */
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
        }
 
-       /* (non-Javadoc)
-        * Method declared on IContentProvider.
+       /*
+        * (non-Javadoc) Method declared on IContentProvider.
         */
        public void dispose() {
        }
 
-       /* (non-Javadoc)
-        * Method declared on ITreeContentProvider.
+       /*
+        * (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 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) {
+                               return getResources((IFolder) element);
+
+                       if (fProvideMembers && element instanceof ISourceReference
+                                       && element instanceof IParent) {
                                if (fProvideWorkingCopy && element instanceof ICompilationUnit) {
-                                       element= JavaModelUtil.toWorkingCopy((ICompilationUnit) element);
+                                       element = JavaModelUtil
+                                                       .toWorkingCopy((ICompilationUnit) element);
                                }
-                               return ((IParent)element).getChildren();
+                               return ((IParent) element).getChildren();
                        }
                } catch (JavaModelException e) {
                        return NO_CHILDREN;
-               }               
-               return NO_CHILDREN;     
+               }
+               return NO_CHILDREN;
        }
 
-       /* (non-Javadoc)
+       /*
+        * (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) {
+                       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;
+                       // element instanceof IClassFile ||
+                                       element instanceof IFile)
+                               return false;
                }
-                       
+
                if (element instanceof IJavaProject) {
-                       IJavaProject jp= (IJavaProject)element;
+                       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())
+                               // when we have Java children return true, else we fetch all the
+                               // children
+                               if (((IParent) element).hasChildren())
                                        return true;
-                       } catch(JavaModelException e) {
+                       } catch (JavaModelException e) {
                                return true;
                        }
                }
-               Object[] children= getChildren(element);
+               Object[] children = getChildren(element);
                return (children != null) && children.length > 0;
        }
-        
-       /* (non-Javadoc)
-        * Method declared on ITreeContentProvider.
+
+       /*
+        * (non-Javadoc) Method declared on ITreeContentProvider.
         */
        public Object getParent(Object element) {
                if (!exists(element))
                        return null;
-               return internalGetParent(element);                      
+               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);
+
+       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.
+        * 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());
-//     }
-
+       // 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.
+        * 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[] 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
+                       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
+                               // + 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()) {
+                                       IJavaElement element = JavaCore.create((IFolder) o);
+                                       if (element instanceof IPackageFragmentRoot
+                                                       && element.exists()) {
                                                continue;
                                        }
                                }
                                nonJavaResources.add(o);
                        }
                        return nonJavaResources.toArray();
-               } catch(CoreException e) {
+               } catch (CoreException e) {
                        return NO_CHILDREN;
                }
        }
-       
+
        /**
-        * Note: This method is for internal use only. Clients should not call this method.
+        * 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));
-       }
-       
+//     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.
+        * 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.getParent();
                        return root;
-               } catch(JavaModelException e) {
+               } catch (JavaModelException e) {
                        return root;
                }
        }
-       
+
        /**
-        * Note: This method is for internal use only. Clients should not call this method.
+        * 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;
-       }
+//     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.
+        * 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();
+       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.
+        * 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();
+                       return ((IResource) element).exists();
                }
                if (element instanceof IJavaElement) {
-                       return ((IJavaElement)element).exists();
+                       return ((IJavaElement) element).exists();
                }
                return true;
        }
-       
+
        /**
-        * Note: This method is for internal use only. Clients should not call this method.
+        * 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();
+                       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);
+                       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()) 
+                       if (jParent != null && jParent.exists())
                                return jParent;
                        return parent;
                }
 
-               // for package fragments that are contained in a project package fragment
+               // 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();
+                       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
+                       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);
+                       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.
+        * 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;
-       }
-
+//     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;
+//     }
 
 }