KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > jdt > internal > ui > workingsets > WorkingSetFilter


1 /*******************************************************************************
2  * Copyright (c) 2000, 2007 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Eclipse Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/epl-v10.html
7  *
8  * Contributors:
9  * IBM Corporation - initial API and implementation
10  *******************************************************************************/

11 package org.eclipse.jdt.internal.ui.workingsets;
12
13 import org.eclipse.core.runtime.IAdaptable;
14 import org.eclipse.core.runtime.IPath;
15
16 import org.eclipse.core.resources.IResource;
17
18 import org.eclipse.jface.viewers.Viewer;
19
20 import org.eclipse.ui.IWorkingSet;
21
22 import org.eclipse.jdt.core.IJavaElement;
23 import org.eclipse.jdt.core.IJavaProject;
24 import org.eclipse.jdt.core.IMember;
25 import org.eclipse.jdt.core.IPackageFragmentRoot;
26 import org.eclipse.jdt.core.JavaCore;
27
28 import org.eclipse.jdt.internal.ui.packageview.PackageFragmentRootContainer;
29 import org.eclipse.jdt.internal.ui.packageview.ClassPathContainer.RequiredProjectWrapper;
30 import org.eclipse.jdt.internal.ui.viewsupport.JavaViewerFilter;
31
32 /**
33  * Working set filter for Java viewers.
34  */

35 public class WorkingSetFilter extends JavaViewerFilter {
36     
37     private static class WorkingSetCompareEntry {
38         private IPath fResourcePath;
39         private IJavaElement fJavaElement;
40         
41         public WorkingSetCompareEntry(IAdaptable a) {
42             if (a instanceof IJavaElement) {
43                 init((IJavaElement) a);
44             } else if (a instanceof IResource) {
45                 init((IResource) a);
46             } else if (a instanceof RequiredProjectWrapper) {
47                 RequiredProjectWrapper wrapper= (RequiredProjectWrapper) a;
48                 IJavaProject proj= wrapper.getParentClassPathContainer().getJavaProject();
49                 // the project reference is treated like an internal JAR.
50
// that means it will only appear if the parent container project is in the working set
51
IResource fakeInternal= proj.getProject().getFile(wrapper.getProject().getElementName() + "-fake-jar.jar"); //$NON-NLS-1$
52
init(proj.getPackageFragmentRoot(fakeInternal));
53             } else {
54                 IJavaElement je= (IJavaElement) a.getAdapter(IJavaElement.class);
55                 if (je != null) {
56                     init(je);
57                 } else {
58                     IResource resource= (IResource) a.getAdapter(IResource.class);
59                     if (resource != null) {
60                         init(resource);
61                     } else {
62                         fResourcePath= null;
63                         fJavaElement= null;
64                     }
65                 }
66             }
67         }
68         
69         private void init(IResource resource) {
70             fJavaElement= JavaCore.create(resource);
71             fResourcePath= resource.getFullPath();
72         }
73
74         private void init(IJavaElement curr) {
75             fJavaElement= curr;
76             fResourcePath= curr.getPath();
77         }
78         
79         public boolean contains(WorkingSetCompareEntry element) {
80             if (fJavaElement != null && element.fJavaElement != null) {
81                 IJavaElement other= element.fJavaElement;
82                 if (fJavaElement.getElementType() == IJavaElement.JAVA_PROJECT) {
83                     IPackageFragmentRoot pkgRoot= (IPackageFragmentRoot) other.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
84                     if (pkgRoot != null && pkgRoot.isExternal() && pkgRoot.isArchive()) {
85                         if (((IJavaProject) fJavaElement).isOnClasspath(other)) {
86                             return true;
87                         }
88                     }
89                 }
90                 
91                 if (isAncestor(other, fJavaElement) || isAncestor(fJavaElement, other)) {
92                     return true;
93                 }
94                 return false;
95             }
96             if (fResourcePath != null && element.fResourcePath != null) {
97                 IPath other= element.fResourcePath;
98                 if (other.isPrefixOf(fResourcePath) || fResourcePath.isPrefixOf(other))
99                     return true;
100             }
101             return false;
102         }
103         
104         private boolean isAncestor(IJavaElement elem, IJavaElement parent) {
105             IJavaElement anc= elem.getAncestor(parent.getElementType());
106             if (parent.equals(anc)) {
107                 return true;
108             }
109             while (anc instanceof IMember) { // ITypes can be in ITypes
110
anc= anc.getParent().getAncestor(parent.getElementType());
111                 if (parent.equals(anc)) {
112                     return true;
113                 }
114             }
115             return false;
116         }
117     }
118     
119     private IWorkingSet fWorkingSet;
120     
121     private WorkingSetCompareEntry[] fCachedCompareEntries;
122     
123     public WorkingSetFilter() {
124         fWorkingSet= null;
125         fCachedCompareEntries= null;
126     }
127     
128     /**
129      * Returns the working set which is used by this filter.
130      *
131      * @return the working set
132      */

133     public IWorkingSet getWorkingSet() {
134         return fWorkingSet;
135     }
136         
137     /**
138      * Sets this filter's working set.
139      *
140      * @param workingSet the working set
141      */

142     public void setWorkingSet(IWorkingSet workingSet) {
143         if (fWorkingSet != workingSet) {
144             fWorkingSet= workingSet;
145             notifyWorkingSetContentChange();
146         }
147     }
148
149     /* (non-Javadoc)
150      * @see org.eclipse.jdt.internal.ui.filters.JavaViewerFilter#initFilter()
151      */

152     protected void initFilter() {
153         notifyWorkingSetContentChange();
154     }
155
156     /**
157      * Invoke when the content of the current working set changed. Clients are responsible to listen to changes and call this method.
158      */

159     public final void notifyWorkingSetContentChange() {
160         if (fWorkingSet != null) {
161             IAdaptable[] elements= fWorkingSet.getElements();
162             fCachedCompareEntries= new WorkingSetCompareEntry[elements.length];
163             for (int i= 0; i < elements.length; i++) {
164                 fCachedCompareEntries[i]= new WorkingSetCompareEntry(elements[i]);
165             }
166         } else {
167             fCachedCompareEntries= null;
168         }
169     }
170     
171     /* (non-Javadoc)
172      * @see org.eclipse.jdt.internal.ui.filters.JavaViewerFilter#freeFilter()
173      */

174     protected void freeFilter() {
175         fCachedCompareEntries= null;
176     }
177     
178     /*
179      * Overrides method from ViewerFilter.
180      */

181     public boolean select(Viewer viewer, Object JavaDoc parentElement, Object JavaDoc element) {
182         if (fWorkingSet == null || (fWorkingSet.isAggregateWorkingSet() && fWorkingSet.isEmpty()))
183             return true;
184
185         if (element instanceof PackageFragmentRootContainer) {
186             return isEnclosing((PackageFragmentRootContainer)element);
187         }
188         
189         if (element instanceof IAdaptable)
190             return isEnclosing((IAdaptable)element);
191
192         return true;
193     }
194
195     public boolean isEnclosing(IAdaptable a) {
196         WorkingSetCompareEntry curr= new WorkingSetCompareEntry(a);
197         if (fCachedCompareEntries != null) {
198             for (int i= 0; i < fCachedCompareEntries.length; i++) {
199                 if (fCachedCompareEntries[i].contains(curr)) {
200                     return true;
201                 }
202             }
203             return false;
204         }
205         if (fWorkingSet != null) {
206             IAdaptable[] elements= fWorkingSet.getElements();
207             for (int i= 0; i < elements.length; i++) {
208                 if (new WorkingSetCompareEntry(elements[i]).contains(curr)) {
209                     return true;
210                 }
211             }
212         }
213         return false;
214     }
215     
216     private boolean isEnclosing(PackageFragmentRootContainer container) {
217         // check whether the containing package fragment roots are enclosed
218
IAdaptable[] roots= container.getChildren();
219         for (int i= 0; i < roots.length; i++) {
220             if (isEnclosing(roots[i])) {
221                 return true;
222             }
223         }
224         return false;
225     }
226     
227 }
228
Popular Tags