001: /*******************************************************************************
002: * Copyright (c) 2003, 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.ui.internal.navigator.extensions;
011:
012: import java.util.ArrayList;
013: import java.util.Set;
014:
015: import org.eclipse.core.runtime.ISafeRunnable;
016: import org.eclipse.core.runtime.SafeRunner;
017: import org.eclipse.jface.viewers.ITreeContentProvider;
018: import org.eclipse.jface.viewers.ITreePathContentProvider;
019: import org.eclipse.jface.viewers.TreePath;
020: import org.eclipse.jface.viewers.Viewer;
021: import org.eclipse.ui.IMemento;
022: import org.eclipse.ui.internal.navigator.NavigatorContentService;
023: import org.eclipse.ui.internal.navigator.NavigatorPlugin;
024: import org.eclipse.ui.navigator.ICommonContentExtensionSite;
025: import org.eclipse.ui.navigator.ICommonContentProvider;
026: import org.eclipse.ui.navigator.IMementoAware;
027: import org.eclipse.ui.navigator.IPipelinedTreeContentProvider;
028: import org.eclipse.ui.navigator.PipelinedShapeModification;
029: import org.eclipse.ui.navigator.PipelinedViewerUpdate;
030:
031: /**
032: * @since 3.2
033: */
034: public class SafeDelegateTreeContentProvider implements
035: IPipelinedTreeContentProvider, ITreePathContentProvider {
036:
037: private static final TreePath[] NO_PATHS = new TreePath[0];
038:
039: private final ITreeContentProvider contentProvider;
040:
041: private NavigatorContentService contentService;
042:
043: private NavigatorContentDescriptor descriptor;
044:
045: private Viewer viewer;
046:
047: SafeDelegateTreeContentProvider(
048: ITreeContentProvider aContentProvider,
049: NavigatorContentDescriptor aDescriptor,
050: NavigatorContentService theContentService) {
051: super ();
052: contentProvider = aContentProvider;
053: contentService = theContentService;
054: descriptor = aDescriptor;
055: }
056:
057: /**
058: *
059: */
060: public void dispose() {
061: SafeRunner.run(new ISafeRunnable() {
062:
063: public void handleException(Throwable exception) {
064: String msg = exception.getMessage() != null ? exception
065: .getMessage() : exception.toString();
066: NavigatorPlugin.logError(0, msg, exception);
067:
068: }
069:
070: public void run() throws Exception {
071: contentProvider.dispose();
072: }
073:
074: });
075:
076: }
077:
078: /*
079: * (non-Javadoc)
080: *
081: * @see java.lang.Object#equals(java.lang.Object)
082: */
083: public boolean equals(Object anObject) {
084: return contentProvider.equals(anObject);
085: }
086:
087: public Object[] getChildren(Object aParentElement) {
088: if (aParentElement instanceof TreePath) {
089: TreePath tp = (TreePath) aParentElement;
090: return getChildren(tp);
091: }
092: Object[] children = contentProvider.getChildren(aParentElement);
093: contentService.rememberContribution(descriptor, children);
094: return children;
095: }
096:
097: public Object[] getElements(Object anInputElement) {
098: Object[] elements = contentProvider.getElements(anInputElement);
099: contentService.rememberContribution(descriptor, elements);
100: return elements;
101: }
102:
103: public Object getParent(Object anElement) {
104: return contentProvider.getParent(anElement);
105: }
106:
107: public boolean hasChildren(Object anElement) {
108: return contentProvider.hasChildren(anElement);
109: }
110:
111: /*
112: * (non-Javadoc)
113: *
114: * @see java.lang.Object#hashCode()
115: */
116: public int hashCode() {
117: return contentProvider.hashCode();
118: }
119:
120: public void inputChanged(final Viewer aViewer,
121: final Object anOldInput, final Object aNewInput) {
122: viewer = aViewer;
123:
124: SafeRunner.run(new ISafeRunnable() {
125:
126: public void handleException(Throwable exception) {
127: String msg = exception.getMessage() != null ? exception
128: .getMessage() : exception.toString();
129: NavigatorPlugin.logError(0, msg, exception);
130:
131: }
132:
133: public void run() throws Exception {
134: contentProvider.inputChanged(aViewer, anOldInput,
135: aNewInput);
136: }
137:
138: });
139: }
140:
141: /*
142: * (non-Javadoc)
143: *
144: * @see java.lang.Object#toString()
145: */
146: public String toString() {
147: return contentProvider.toString();
148: }
149:
150: /**
151: *
152: * @return The real content provider.
153: */
154: public ITreeContentProvider getDelegateContentProvider() {
155: return contentProvider;
156: }
157:
158: public void restoreState(IMemento aMemento) {
159: if (contentProvider != null
160: && contentProvider instanceof IMementoAware) {
161: ((IMementoAware) contentProvider).restoreState(aMemento);
162: }
163:
164: }
165:
166: public void saveState(IMemento aMemento) {
167: if (contentProvider != null
168: && contentProvider instanceof IMementoAware) {
169: ((IMementoAware) contentProvider).saveState(aMemento);
170: }
171:
172: }
173:
174: public void init(ICommonContentExtensionSite aConfig) {
175: if (contentProvider instanceof ICommonContentProvider) {
176: ((ICommonContentProvider) contentProvider).init(aConfig);
177: }
178: }
179:
180: /*
181: * (non-Javadoc)
182: *
183: * @see org.eclipse.ui.navigator.IPipelinedTreeContentProvider#getPipelinedChildren(java.lang.Object,
184: * java.util.Set)
185: */
186: public void getPipelinedChildren(Object aParent,
187: Set theCurrentChildren) {
188: if (contentProvider instanceof IPipelinedTreeContentProvider) {
189: ((IPipelinedTreeContentProvider) contentProvider)
190: .getPipelinedChildren(aParent, theCurrentChildren);
191: }
192:
193: }
194:
195: /*
196: * (non-Javadoc)
197: *
198: * @see org.eclipse.ui.navigator.IPipelinedTreeContentProvider#getPipelinedElements(java.lang.Object,
199: * java.util.Set)
200: */
201: public void getPipelinedElements(Object anInput,
202: Set theCurrentElements) {
203: if (contentProvider instanceof IPipelinedTreeContentProvider) {
204: ((IPipelinedTreeContentProvider) contentProvider)
205: .getPipelinedElements(anInput, theCurrentElements);
206: }
207: }
208:
209: /*
210: * (non-Javadoc)
211: *
212: * @see org.eclipse.ui.navigator.IPipelinedTreeContentProvider#getPipelinedParent(java.lang.Object,
213: * java.lang.Object)
214: */
215: public Object getPipelinedParent(Object anObject,
216: Object aSuggestedParent) {
217: if (contentProvider instanceof IPipelinedTreeContentProvider) {
218: return ((IPipelinedTreeContentProvider) contentProvider)
219: .getPipelinedParent(anObject, aSuggestedParent);
220: }
221: return anObject;
222: }
223:
224: /*
225: * (non-Javadoc)
226: *
227: * @see org.eclipse.ui.navigator.IPipelinedTreeContentProvider#interceptAdd(org.eclipse.ui.navigator.PipelinedShapeModification)
228: */
229: public PipelinedShapeModification interceptAdd(
230: PipelinedShapeModification anAddModification) {
231: if (contentProvider instanceof IPipelinedTreeContentProvider) {
232: return ((IPipelinedTreeContentProvider) contentProvider)
233: .interceptAdd(anAddModification);
234: }
235: return anAddModification;
236: }
237:
238: /*
239: * (non-Javadoc)
240: *
241: * @see org.eclipse.ui.navigator.IPipelinedTreeContentProvider#interceptRemove(org.eclipse.ui.navigator.PipelinedShapeModification)
242: */
243: public PipelinedShapeModification interceptRemove(
244: PipelinedShapeModification aRemoveModification) {
245: if (contentProvider instanceof IPipelinedTreeContentProvider) {
246: return ((IPipelinedTreeContentProvider) contentProvider)
247: .interceptRemove(aRemoveModification);
248: }
249: return aRemoveModification;
250: }
251:
252: /*
253: * (non-Javadoc)
254: *
255: * @see org.eclipse.ui.navigator.IPipelinedTreeContentProvider#interceptRefresh(org.eclipse.ui.navigator.PipelinedViewerUpdate)
256: */
257: public boolean interceptRefresh(
258: PipelinedViewerUpdate aRefreshSynchronization) {
259: if (contentProvider instanceof IPipelinedTreeContentProvider) {
260: return ((IPipelinedTreeContentProvider) contentProvider)
261: .interceptRefresh(aRefreshSynchronization);
262: }
263: return false;
264: }
265:
266: /*
267: * (non-Javadoc)
268: *
269: * @see org.eclipse.ui.navigator.IPipelinedTreeContentProvider#interceptUpdate(org.eclipse.ui.navigator.PipelinedViewerUpdate)
270: */
271: public boolean interceptUpdate(
272: PipelinedViewerUpdate anUpdateSynchronization) {
273: if (contentProvider instanceof IPipelinedTreeContentProvider) {
274: return ((IPipelinedTreeContentProvider) contentProvider)
275: .interceptUpdate(anUpdateSynchronization);
276: }
277: return false;
278: }
279:
280: /* (non-Javadoc)
281: * @see org.eclipse.jface.viewers.ITreePathContentProvider#getChildren(org.eclipse.jface.viewers.TreePath)
282: */
283: public Object[] getChildren(TreePath parentPath) {
284: if (contentProvider instanceof ITreePathContentProvider) {
285: ITreePathContentProvider tpcp = (ITreePathContentProvider) contentProvider;
286: Object[] children = tpcp.getChildren(parentPath);
287: contentService.rememberContribution(descriptor, children);
288: return children;
289: }
290: return getChildren(parentPath.getLastSegment());
291: }
292:
293: /* (non-Javadoc)
294: * @see org.eclipse.jface.viewers.ITreePathContentProvider#hasChildren(org.eclipse.jface.viewers.TreePath)
295: */
296: public boolean hasChildren(TreePath path) {
297: if (contentProvider instanceof ITreePathContentProvider) {
298: ITreePathContentProvider tpcp = (ITreePathContentProvider) contentProvider;
299: return tpcp.hasChildren(path);
300: }
301: return hasChildren(path.getLastSegment());
302: }
303:
304: /* (non-Javadoc)
305: * @see org.eclipse.jface.viewers.ITreePathContentProvider#getParents(java.lang.Object)
306: */
307: public TreePath[] getParents(Object element) {
308: if (contentProvider instanceof ITreePathContentProvider) {
309: ITreePathContentProvider tpcp = (ITreePathContentProvider) contentProvider;
310: return tpcp.getParents(element);
311: }
312: ArrayList segments = new ArrayList();
313: Object parent = element;
314: do {
315: parent = contentProvider.getParent(parent);
316: if (parent != null && parent != viewer.getInput())
317: segments.add(0, parent);
318: } while (parent != null && parent != viewer.getInput());
319: if (!segments.isEmpty()) {
320: // Loop backwards over the array to create the path.
321: return new TreePath[] { new TreePath(segments.toArray()) };
322: }
323: return NO_PATHS;
324: }
325:
326: }
|