001: /*******************************************************************************
002: * Copyright (c) 2000, 2006 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: *******************************************************************************/package org.eclipse.jdt.internal.ui.search;
011:
012: import java.util.HashMap;
013: import java.util.HashSet;
014: import java.util.Iterator;
015: import java.util.Map;
016: import java.util.Set;
017:
018: import org.eclipse.core.resources.IResource;
019:
020: import org.eclipse.jface.viewers.AbstractTreeViewer;
021: import org.eclipse.jface.viewers.ITreeContentProvider;
022:
023: import org.eclipse.jdt.core.IClassFile;
024: import org.eclipse.jdt.core.ICompilationUnit;
025: import org.eclipse.jdt.core.IJavaElement;
026: import org.eclipse.jdt.core.IType;
027:
028: import org.eclipse.jdt.ui.StandardJavaElementContentProvider;
029:
030: public class LevelTreeContentProvider extends JavaSearchContentProvider
031: implements ITreeContentProvider {
032: private Map fChildrenMap;
033: private StandardJavaElementContentProvider fContentProvider;
034:
035: public static final int LEVEL_TYPE = 1;
036: public static final int LEVEL_FILE = 2;
037: public static final int LEVEL_PACKAGE = 3;
038: public static final int LEVEL_PROJECT = 4;
039:
040: private static final int[][] JAVA_ELEMENT_TYPES = {
041: { IJavaElement.TYPE },
042: { IJavaElement.CLASS_FILE, IJavaElement.COMPILATION_UNIT },
043: { IJavaElement.PACKAGE_FRAGMENT },
044: { IJavaElement.JAVA_PROJECT,
045: IJavaElement.PACKAGE_FRAGMENT_ROOT },
046: { IJavaElement.JAVA_MODEL } };
047: private static final int[][] RESOURCE_TYPES = { {},
048: { IResource.FILE }, { IResource.FOLDER },
049: { IResource.PROJECT }, { IResource.ROOT } };
050:
051: private static final int MAX_LEVEL = JAVA_ELEMENT_TYPES.length - 1;
052: private int fCurrentLevel;
053:
054: static class FastJavaElementProvider extends
055: StandardJavaElementContentProvider {
056: public Object getParent(Object element) {
057: return internalGetParent(element);
058: }
059: }
060:
061: public LevelTreeContentProvider(JavaSearchResultPage page, int level) {
062: super (page);
063: fCurrentLevel = level;
064: fContentProvider = new FastJavaElementProvider();
065: }
066:
067: public Object getParent(Object child) {
068: Object possibleParent = internalGetParent(child);
069: if (possibleParent instanceof IJavaElement) {
070: IJavaElement javaElement = (IJavaElement) possibleParent;
071: for (int j = fCurrentLevel; j < MAX_LEVEL + 1; j++) {
072: for (int i = 0; i < JAVA_ELEMENT_TYPES[j].length; i++) {
073: if (javaElement.getElementType() == JAVA_ELEMENT_TYPES[j][i]) {
074: return null;
075: }
076: }
077: }
078: } else if (possibleParent instanceof IResource) {
079: IResource resource = (IResource) possibleParent;
080: for (int j = fCurrentLevel; j < MAX_LEVEL + 1; j++) {
081: for (int i = 0; i < RESOURCE_TYPES[j].length; i++) {
082: if (resource.getType() == RESOURCE_TYPES[j][i]) {
083: return null;
084: }
085: }
086: }
087: }
088: if (fCurrentLevel != LEVEL_FILE && child instanceof IType) {
089: IType type = (IType) child;
090: if (possibleParent instanceof ICompilationUnit
091: || possibleParent instanceof IClassFile)
092: possibleParent = type.getPackageFragment();
093: }
094: return possibleParent;
095: }
096:
097: private Object internalGetParent(Object child) {
098: return fContentProvider.getParent(child);
099: }
100:
101: public Object[] getElements(Object inputElement) {
102: return getChildren(inputElement);
103: }
104:
105: protected synchronized void initialize(JavaSearchResult result) {
106: super .initialize(result);
107: fChildrenMap = new HashMap();
108: if (result != null) {
109: Object[] elements = result.getElements();
110: for (int i = 0; i < elements.length; i++) {
111: if (getPage().getDisplayedMatchCount(elements[i]) > 0) {
112: insert(null, null, elements[i]);
113: }
114: }
115: }
116: }
117:
118: protected void insert(Map toAdd, Set toUpdate, Object child) {
119: Object parent = getParent(child);
120: while (parent != null) {
121: if (insertChild(parent, child)) {
122: if (toAdd != null)
123: insertInto(parent, child, toAdd);
124: } else {
125: if (toUpdate != null)
126: toUpdate.add(parent);
127: return;
128: }
129: child = parent;
130: parent = getParent(child);
131: }
132: if (insertChild(getSearchResult(), child)) {
133: if (toAdd != null)
134: insertInto(getSearchResult(), child, toAdd);
135: }
136: }
137:
138: private boolean insertChild(Object parent, Object child) {
139: return insertInto(parent, child, fChildrenMap);
140: }
141:
142: private boolean insertInto(Object parent, Object child, Map map) {
143: Set children = (Set) map.get(parent);
144: if (children == null) {
145: children = new HashSet();
146: map.put(parent, children);
147: }
148: return children.add(child);
149: }
150:
151: protected void remove(Set toRemove, Set toUpdate, Object element) {
152: // precondition here: fResult.getMatchCount(child) <= 0
153:
154: if (hasChildren(element)) {
155: if (toUpdate != null)
156: toUpdate.add(element);
157: } else {
158: if (getPage().getDisplayedMatchCount(element) == 0) {
159: fChildrenMap.remove(element);
160: Object parent = getParent(element);
161: if (parent != null) {
162: if (removeFromSiblings(element, parent)) {
163: remove(toRemove, toUpdate, parent);
164: }
165: } else {
166: if (removeFromSiblings(element, getSearchResult())) {
167: if (toRemove != null)
168: toRemove.add(element);
169: }
170: }
171: } else {
172: if (toUpdate != null) {
173: toUpdate.add(element);
174: }
175: }
176: }
177: }
178:
179: /**
180: * @param element
181: * @param parent
182: * @return returns true if it really was a remove (i.e. element was a child of parent).
183: */
184: private boolean removeFromSiblings(Object element, Object parent) {
185: Set siblings = (Set) fChildrenMap.get(parent);
186: if (siblings != null) {
187: return siblings.remove(element);
188: } else {
189: return false;
190: }
191: }
192:
193: public Object[] getChildren(Object parentElement) {
194: Set children = (Set) fChildrenMap.get(parentElement);
195: if (children == null)
196: return EMPTY_ARR;
197: int limit = getPage().getElementLimit().intValue();
198: if (limit != -1 && limit < children.size()) {
199: Object[] limitedArray = new Object[limit];
200: Iterator iterator = children.iterator();
201: for (int i = 0; i < limit; i++) {
202: limitedArray[i] = iterator.next();
203: }
204: return limitedArray;
205: }
206:
207: return children.toArray();
208: }
209:
210: public boolean hasChildren(Object element) {
211: Set children = (Set) fChildrenMap.get(element);
212: return children != null && !children.isEmpty();
213: }
214:
215: public synchronized void elementsChanged(Object[] updatedElements) {
216: if (getSearchResult() == null)
217: return;
218:
219: AbstractTreeViewer viewer = (AbstractTreeViewer) getPage()
220: .getViewer();
221:
222: Set toRemove = new HashSet();
223: Set toUpdate = new HashSet();
224: Map toAdd = new HashMap();
225: for (int i = 0; i < updatedElements.length; i++) {
226: if (getPage().getDisplayedMatchCount(updatedElements[i]) > 0)
227: insert(toAdd, toUpdate, updatedElements[i]);
228: else
229: remove(toRemove, toUpdate, updatedElements[i]);
230: }
231:
232: viewer.remove(toRemove.toArray());
233: for (Iterator iter = toAdd.keySet().iterator(); iter.hasNext();) {
234: Object parent = iter.next();
235: HashSet children = (HashSet) toAdd.get(parent);
236: viewer.add(parent, children.toArray());
237: }
238: for (Iterator elementsToUpdate = toUpdate.iterator(); elementsToUpdate
239: .hasNext();) {
240: viewer.refresh(elementsToUpdate.next());
241: }
242:
243: }
244:
245: public void clear() {
246: initialize(getSearchResult());
247: getPage().getViewer().refresh();
248: }
249:
250: public void setLevel(int level) {
251: fCurrentLevel = level;
252: initialize(getSearchResult());
253: getPage().getViewer().refresh();
254: }
255:
256: }
|