Refactory: remove unused classes, imports, fields and methods.
[phpeclipse.git] / net.sourceforge.phpeclipse.ui / src / net / sourceforge / phpdt / ui / StandardJavaElementContentProvider.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpdt.ui;
12
13 import java.util.ArrayList;
14 import java.util.List;
15
16 import net.sourceforge.phpdt.core.ICompilationUnit;
17 import net.sourceforge.phpdt.core.IJavaElement;
18 import net.sourceforge.phpdt.core.IJavaElementDelta;
19 import net.sourceforge.phpdt.core.IJavaModel;
20 import net.sourceforge.phpdt.core.IJavaProject;
21 import net.sourceforge.phpdt.core.IPackageFragment;
22 import net.sourceforge.phpdt.core.IPackageFragmentRoot;
23 import net.sourceforge.phpdt.core.IParent;
24 import net.sourceforge.phpdt.core.ISourceReference;
25 import net.sourceforge.phpdt.core.JavaCore;
26 import net.sourceforge.phpdt.core.JavaModelException;
27 import net.sourceforge.phpdt.internal.corext.util.JavaModelUtil;
28
29 import org.eclipse.core.resources.IFile;
30 import org.eclipse.core.resources.IFolder;
31 import org.eclipse.core.resources.IProject;
32 import org.eclipse.core.resources.IResource;
33 import org.eclipse.core.runtime.CoreException;
34 import org.eclipse.jface.viewers.ITreeContentProvider;
35 import org.eclipse.jface.viewers.Viewer;
36
37 /**
38  * A base content provider for Java elements. It provides access to the Java
39  * element hierarchy without listening to changes in the Java model. If updating
40  * the presentation on Java model change is required than clients have to
41  * subclass, listen to Java model changes and have to update the UI using
42  * corresponding methods provided by the JFace viewers or their own UI
43  * presentation.
44  * <p>
45  * The following Java element hierarchy is surfaced by this content provider:
46  * <p>
47  * 
48  * <pre>
49  *  Java model (
50  * <code>
51  * IJavaModel
52  * </code>
53  * )
54  *  Java project (
55  * <code>
56  * IJavaProject
57  * </code>
58  * )
59  *  package fragment root (
60  * <code>
61  * IPackageFragmentRoot
62  * </code>
63  * )
64  *  package fragment (
65  * <code>
66  * IPackageFragment
67  * </code>
68  * )
69  *  compilation unit (
70  * <code>
71  * ICompilationUnit
72  * </code>
73  * )
74  *  binary class file (
75  * <code>
76  * IClassFile
77  * </code>
78  * )
79  * </pre>
80  * 
81  * </p>
82  * <p>
83  * Note that when the entire Java project is declared to be package fragment
84  * root, the corresponding package fragment root element that normally appears
85  * between the Java project and the package fragments is automatically filtered
86  * out.
87  * </p>
88  * This content provider can optionally return working copy elements for members
89  * below compilation units. If enabled, working copy members are returned for
90  * those compilation units in the Java element hierarchy for which a shared
91  * working copy exists in JDT core.
92  * 
93  * @see net.sourceforge.phpdt.ui.IWorkingCopyProvider
94  * @see JavaCore#getSharedWorkingCopies(net.sourceforge.phpdt.core.IBufferFactory)
95  * 
96  * @since 2.0
97  */
98 public class StandardJavaElementContentProvider implements
99                 ITreeContentProvider, IWorkingCopyProvider {
100
101         protected static final Object[] NO_CHILDREN = new Object[0];
102
103         protected boolean fProvideMembers = false;
104
105         protected boolean fProvideWorkingCopy = false;
106
107         /**
108          * Creates a new content provider. The content provider does not provide
109          * members of compilation units or class files and it does not provide
110          * working copy elements.
111          */
112         public StandardJavaElementContentProvider() {
113         }
114
115         /**
116          * Creates a new <code>StandardJavaElementContentProvider</code>.
117          * 
118          * @param provideMembers
119          *            if <code>true</code> members below compilation units and
120          *            class files are provided.
121          * @param provideWorkingCopy
122          *            if <code>true</code> the element provider provides working
123          *            copies members of compilation units which have an associated
124          *            working copy in JDT core. Otherwise only original elements are
125          *            provided.
126          */
127         public StandardJavaElementContentProvider(boolean provideMembers,
128                         boolean provideWorkingCopy) {
129                 fProvideMembers = provideMembers;
130                 fProvideWorkingCopy = provideWorkingCopy;
131         }
132
133         /**
134          * Returns whether members are provided when asking for a compilation units
135          * or class file for its children.
136          * 
137          * @return <code>true</code> if the content provider provides members;
138          *         otherwise <code>false</code> is returned
139          */
140         public boolean getProvideMembers() {
141                 return fProvideMembers;
142         }
143
144         /**
145          * Sets whether the content provider is supposed to return members when
146          * asking a compilation unit or class file for its children.
147          * 
148          * @param b
149          *            if <code>true</code> then members are provided. If
150          *            <code>false</code> compilation units and class files are the
151          *            leaves provided by this content provider.
152          */
153         public void setProvideMembers(boolean b) {
154                 fProvideMembers = b;
155         }
156
157         /**
158          * Returns whether the provided members are from a working copy or the
159          * original compilation unit.
160          * 
161          * @return <code>true</code> if the content provider provides working copy
162          *         members; otherwise <code>false</code> is returned
163          * 
164          * @see #setProvideWorkingCopy(boolean)
165          */
166         public boolean getProvideWorkingCopy() {
167                 return fProvideWorkingCopy;
168         }
169
170         /**
171          * Sets whether the members are provided from a shared working copy that
172          * exists for a original compilation unit in the Java element hierarchy.
173          * 
174          * @param b
175          *            if <code>true</code> members are provided from a working
176          *            copy if one exists in JDT core. If <code>false</code> the
177          *            provider always returns original elements.
178          */
179         public void setProvideWorkingCopy(boolean b) {
180                 fProvideWorkingCopy = b;
181         }
182
183         /*
184          * (non-Javadoc)
185          * 
186          * @see IWorkingCopyProvider#providesWorkingCopies()
187          */
188         public boolean providesWorkingCopies() {
189                 return fProvideWorkingCopy;
190         }
191
192         /*
193          * (non-Javadoc) Method declared on IStructuredContentProvider.
194          */
195         public Object[] getElements(Object parent) {
196                 return getChildren(parent);
197         }
198
199         /*
200          * (non-Javadoc) Method declared on IContentProvider.
201          */
202         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
203         }
204
205         /*
206          * (non-Javadoc) Method declared on IContentProvider.
207          */
208         public void dispose() {
209         }
210
211         /*
212          * (non-Javadoc) Method declared on ITreeContentProvider.
213          */
214         public Object[] getChildren(Object element) {
215                 if (!exists(element))
216                         return NO_CHILDREN;
217
218                 try {
219                         if (element instanceof IJavaModel)
220                                 return getJavaProjects((IJavaModel) element);
221
222                         // if (element instanceof IJavaProject)
223                         // return getPackageFragmentRoots((IJavaProject)element);
224                         //                      
225                         if (element instanceof IPackageFragmentRoot)
226                                 return getPackageFragments((IPackageFragmentRoot) element);
227
228                         // if (element instanceof IPackageFragment)
229                         // return getPackageContents((IPackageFragment)element);
230
231                         if (element instanceof IFolder)
232                                 return getResources((IFolder) element);
233
234                         if (fProvideMembers && element instanceof ISourceReference
235                                         && element instanceof IParent) {
236                                 if (fProvideWorkingCopy && element instanceof ICompilationUnit) {
237                                         element = JavaModelUtil
238                                                         .toWorkingCopy((ICompilationUnit) element);
239                                 }
240                                 return ((IParent) element).getChildren();
241                         }
242                 } catch (JavaModelException e) {
243                         return NO_CHILDREN;
244                 }
245                 return NO_CHILDREN;
246         }
247
248         /*
249          * (non-Javadoc)
250          * 
251          * @see ITreeContentProvider
252          */
253         public boolean hasChildren(Object element) {
254                 if (fProvideMembers) {
255                         // assume CUs and class files are never empty
256                         if (element instanceof ICompilationUnit) {
257                                 // ||
258                                 // element instanceof IClassFile) {
259                                 return true;
260                         }
261                 } else {
262                         // don't allow to drill down into a compilation unit or class file
263                         if (element instanceof ICompilationUnit ||
264                         // element instanceof IClassFile ||
265                                         element instanceof IFile)
266                                 return false;
267                 }
268
269                 if (element instanceof IJavaProject) {
270                         IJavaProject jp = (IJavaProject) element;
271                         if (!jp.getProject().isOpen()) {
272                                 return false;
273                         }
274                 }
275
276                 if (element instanceof IParent) {
277                         try {
278                                 // when we have Java children return true, else we fetch all the
279                                 // children
280                                 if (((IParent) element).hasChildren())
281                                         return true;
282                         } catch (JavaModelException e) {
283                                 return true;
284                         }
285                 }
286                 Object[] children = getChildren(element);
287                 return (children != null) && children.length > 0;
288         }
289
290         /*
291          * (non-Javadoc) Method declared on ITreeContentProvider.
292          */
293         public Object getParent(Object element) {
294                 if (!exists(element))
295                         return null;
296                 return internalGetParent(element);
297         }
298
299         private Object[] getPackageFragments(IPackageFragmentRoot root)
300                         throws JavaModelException {
301                 IJavaElement[] fragments = root.getChildren();
302                 // Object[] nonJavaResources= root.getNonJavaResources();
303                 // if (nonJavaResources == null)
304                 return fragments;
305                 // return concatenate(fragments, nonJavaResources);
306         }
307
308         /**
309          * Note: This method is for internal use only. Clients should not call this
310          * method.
311          */
312         // protected Object[] getPackageFragmentRoots(IJavaProject project) throws
313         // JavaModelException {
314         // if (!project.getProject().isOpen())
315         // return NO_CHILDREN;
316         //                      
317         // IPackageFragmentRoot[] roots= project.getPackageFragmentRoots();
318         // List list= new ArrayList(roots.length);
319         // // filter out package fragments that correspond to projects and
320         // // replace them with the package fragments directly
321         // for (int i= 0; i < roots.length; i++) {
322         // IPackageFragmentRoot root= (IPackageFragmentRoot)roots[i];
323         // if (isProjectPackageFragmentRoot(root)) {
324         // Object[] children= root.getChildren();
325         // for (int k= 0; k < children.length; k++)
326         // list.add(children[k]);
327         // }
328         // else if (hasChildren(root)) {
329         // list.add(root);
330         // }
331         // }
332         // return concatenate(list.toArray(), project.getNonJavaResources());
333         // }
334         /**
335          * Note: This method is for internal use only. Clients should not call this
336          * method.
337          */
338         protected Object[] getJavaProjects(IJavaModel jm) throws JavaModelException {
339                 return jm.getJavaProjects();
340         }
341
342         // private Object[] getPackageContents(IPackageFragment fragment) throws
343         // JavaModelException {
344         // if (fragment.getKind() == IPackageFragmentRoot.K_SOURCE) {
345         // return concatenate(fragment.getCompilationUnits(),
346         // fragment.getNonJavaResources());
347         // }
348         // return concatenate(fragment.getClassFiles(),
349         // fragment.getNonJavaResources());
350         // }
351
352         private Object[] getResources(IFolder folder) {
353                 try {
354                         // filter out folders that are package fragment roots
355                         Object[] members = folder.members();
356                         List nonJavaResources = new ArrayList();
357                         for (int i = 0; i < members.length; i++) {
358                                 Object o = members[i];
359                                 // A folder can also be a package fragement root in the
360                                 // following case
361                                 // Project
362                                 // + src <- source folder
363                                 // + excluded <- excluded from class path
364                                 // + included <- a new source folder.
365                                 // Included is a member of excluded, but since it is rendered as
366                                 // a source
367                                 // folder we have to exclude it as a normal child.
368                                 if (o instanceof IFolder) {
369                                         IJavaElement element = JavaCore.create((IFolder) o);
370                                         if (element instanceof IPackageFragmentRoot
371                                                         && element.exists()) {
372                                                 continue;
373                                         }
374                                 }
375                                 nonJavaResources.add(o);
376                         }
377                         return nonJavaResources.toArray();
378                 } catch (CoreException e) {
379                         return NO_CHILDREN;
380                 }
381         }
382
383         /**
384          * Note: This method is for internal use only. Clients should not call this
385          * method.
386          */
387         protected boolean isClassPathChange(IJavaElementDelta delta) {
388
389                 // need to test the flags only for package fragment roots
390                 if (delta.getElement().getElementType() != IJavaElement.PACKAGE_FRAGMENT_ROOT)
391                         return false;
392
393                 int flags = delta.getFlags();
394                 return (delta.getKind() == IJavaElementDelta.CHANGED
395                                 && ((flags & IJavaElementDelta.F_ADDED_TO_CLASSPATH) != 0)
396                                 || ((flags & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) != 0) || ((flags & IJavaElementDelta.F_REORDER) != 0));
397         }
398
399         /**
400          * Note: This method is for internal use only. Clients should not call this
401          * method.
402          */
403         protected Object skipProjectPackageFragmentRoot(IPackageFragmentRoot root) {
404                 try {
405                         if (isProjectPackageFragmentRoot(root))
406                                 return root.getParent();
407                         return root;
408                 } catch (JavaModelException e) {
409                         return root;
410                 }
411         }
412
413         /**
414          * Note: This method is for internal use only. Clients should not call this
415          * method.
416          */
417         protected boolean isPackageFragmentEmpty(IJavaElement element)
418                         throws JavaModelException {
419                 if (element instanceof IPackageFragment) {
420                         IPackageFragment fragment = (IPackageFragment) element;
421                         if (!(fragment.hasChildren()))
422                                 // ||
423                                 // fragment.getNonJavaResources().length > 0) &&
424                                 // fragment.hasSubpackages())
425                                 return true;
426                 }
427                 return false;
428         }
429
430         /**
431          * Note: This method is for internal use only. Clients should not call this
432          * method.
433          */
434         protected boolean isProjectPackageFragmentRoot(IPackageFragmentRoot root)
435                         throws JavaModelException {
436                 IResource resource = root.getResource();
437                 return (resource instanceof IProject);
438         }
439
440         /**
441          * Note: This method is for internal use only. Clients should not call this
442          * method.
443          */
444         protected boolean exists(Object element) {
445                 if (element == null) {
446                         return false;
447                 }
448                 if (element instanceof IResource) {
449                         return ((IResource) element).exists();
450                 }
451                 if (element instanceof IJavaElement) {
452                         return ((IJavaElement) element).exists();
453                 }
454                 return true;
455         }
456
457         /**
458          * Note: This method is for internal use only. Clients should not call this
459          * method.
460          */
461         protected Object internalGetParent(Object element) {
462                 if (element instanceof IJavaProject) {
463                         return ((IJavaProject) element).getJavaModel();
464                 }
465                 // try to map resources to the containing package fragment
466                 if (element instanceof IResource) {
467                         IResource parent = ((IResource) element).getParent();
468                         IJavaElement jParent = JavaCore.create(parent);
469                         // http://bugs.eclipse.org/bugs/show_bug.cgi?id=31374
470                         if (jParent != null && jParent.exists())
471                                 return jParent;
472                         return parent;
473                 }
474
475                 // for package fragments that are contained in a project package
476                 // fragment
477                 // we have to skip the package fragment root as the parent.
478                 if (element instanceof IPackageFragment) {
479                         IPackageFragmentRoot parent = (IPackageFragmentRoot) ((IPackageFragment) element)
480                                         .getParent();
481                         return skipProjectPackageFragmentRoot(parent);
482                 }
483                 if (element instanceof IJavaElement) {
484                         IJavaElement candidate = ((IJavaElement) element).getParent();
485                         // If the parent is a CU we might have shown working copy elements
486                         // below CU level. If so
487                         // return the original element instead of the working copy.
488                         if (candidate != null
489                                         && candidate.getElementType() == IJavaElement.COMPILATION_UNIT) {
490                                 candidate = JavaModelUtil
491                                                 .toOriginal((ICompilationUnit) candidate);
492                         }
493                         return candidate;
494                 }
495                 return null;
496         }
497
498         /**
499          * Note: This method is for internal use only. Clients should not call this
500          * method.
501          */
502         protected static Object[] concatenate(Object[] a1, Object[] a2) {
503                 int a1Len = a1.length;
504                 int a2Len = a2.length;
505                 Object[] res = new Object[a1Len + a2Len];
506                 System.arraycopy(a1, 0, res, 0, a1Len);
507                 System.arraycopy(a2, 0, res, a1Len, a2Len);
508                 return res;
509         }
510
511 }