import java.util.ArrayList;

	private Viewer viewer;

		if (aParentElement instanceof TreePath) {

			TreePath tp = (TreePath) aParentElement;

			return getChildren(tp);

		}

		viewer = aViewer;

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.ITreePathContentProvider#getChildren(org.eclipse.jface.viewers.TreePath)

	 */

	public Object[] getChildren(TreePath parentPath) {

		if (contentProvider instanceof ITreePathContentProvider) {

			ITreePathContentProvider tpcp = (ITreePathContentProvider) contentProvider;

			Object[] children = tpcp.getChildren(parentPath);

			contentService.rememberContribution(descriptor, children);

			return children;

		}

		return getChildren(parentPath.getLastSegment());

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.ITreePathContentProvider#hasChildren(org.eclipse.jface.viewers.TreePath)

	 */

	public boolean hasChildren(TreePath path) {

		if (contentProvider instanceof ITreePathContentProvider) {

			ITreePathContentProvider tpcp = (ITreePathContentProvider) contentProvider;

			return tpcp.hasChildren(path);

		}

		return hasChildren(path.getLastSegment());

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.ITreePathContentProvider#getParents(java.lang.Object)

	 */

	public TreePath[] getParents(Object element) {

		if (contentProvider instanceof ITreePathContentProvider) {

			ITreePathContentProvider tpcp = (ITreePathContentProvider) contentProvider;

			return tpcp.getParents(element);

		}

		ArrayList segments = new ArrayList();

		Object parent = element;

		do {

			parent = contentProvider.getParent(parent);

			if (parent != null && parent != viewer.getInput())

				segments.add(parent);

		} while (parent != null && parent != viewer.getInput());

		if (!segments.isEmpty()) {

			// Loop backwards over the array to create the path.

			TreePath path = TreePath.EMPTY;

			for (int j = segments.size() - 1; j >=0; j--) {

				path = path.createChildPath(segments.get(j));

			}

			return new TreePath[] { path };

		}

		return new TreePath[0];

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.ITreePathLabelProvider#updateLabel(org.eclipse.jface.viewers.ViewerLabel, org.eclipse.jface.viewers.TreePath)

	 */

	public void updateLabel(ViewerLabel label, TreePath elementPath) {

		if (delegateLabelProvider instanceof ITreePathLabelProvider) {

			ITreePathLabelProvider tplp = (ITreePathLabelProvider) delegateLabelProvider;

			tplp.updateLabel(label, elementPath);

		} else {

			label.setImage(getImage(elementPath.getLastSegment()));

			label.setText(getText(elementPath.getLastSegment()));

		}

	}

	private Viewer viewer;

		return internalGetChildren(aParentElement);

	}

	private Object[] internalGetChildren(Object aParentElementOrPath) {

		Object aParentElement = internalAsElement(aParentElementOrPath);

						// TODO: could pass tree path through pipeline

		viewer = aViewer;

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.ITreePathContentProvider#getChildren(org.eclipse.jface.viewers.TreePath)

	 */

	public Object[] getChildren(TreePath parentPath) {

		return internalGetChildren(parentPath);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.ITreePathContentProvider#hasChildren(org.eclipse.jface.viewers.TreePath)

	 */

	public boolean hasChildren(TreePath path) {

		Object anElement = internalAsElement(path);

		Set resultInstances = contentService

				.findContentExtensionsByTriggerPoint(anElement);

		NavigatorContentExtension ext;

		for (Iterator itr = resultInstances.iterator(); itr.hasNext();) {

			ext = (NavigatorContentExtension) itr.next();

			if (!ext.isLoaded())

				return true;

			ITreeContentProvider cp = ext.internalGetContentProvider();

			if (cp instanceof ITreePathContentProvider) {

				ITreePathContentProvider tpcp = (ITreePathContentProvider) cp;

				if (tpcp.hasChildren(path)) {

					return true;

				}

			} else if (cp.hasChildren(anElement))

				return true;

		}

		return false;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.ITreePathContentProvider#getParents(java.lang.Object)

	 */

	public TreePath[] getParents(Object anElement) {

		Set extensions = contentService

			.findContentExtensionsWithPossibleChild(anElement);

		Set result = new HashSet();

		NavigatorContentExtension foundExtension;

		NavigatorContentExtension[] overridingExtensions;

		for (Iterator itr = extensions.iterator(); itr.hasNext();) {

			foundExtension = (NavigatorContentExtension) itr.next();

			try {

				if (!shouldDeferToOverridePath(foundExtension.getDescriptor(),

						extensions)) {

					// We know the content provider is a SafeDelegateTreeContentProvider

					// which implements ITreePathContentProvider

					ITreeContentProvider tcp = foundExtension.internalGetContentProvider();

					if (tcp instanceof ITreePathContentProvider) {

						ITreePathContentProvider tpcp = (ITreePathContentProvider) tcp;

						TreePath[] parents = tpcp.getParents(anElement);

						Set parentPaths = asSet(parents);

						overridingExtensions = foundExtension

								.getOverridingExtensionsForPossibleChild(anElement);

						if (overridingExtensions.length > 0) {

							parentPaths = pipelineParents(anElement,

									overridingExtensions, parentPaths);

						}

						result.addAll(parentPaths);

					}

				}

			} catch (RuntimeException re) {

				NavigatorPlugin

						.logError(

								0,

								NLS

										.bind(

												CommonNavigatorMessages.Could_not_provide_children_for_element,

												new Object[] { foundExtension

														.getDescriptor()

														.getId() }), re);

			} catch (Error e) {

				NavigatorPlugin

						.logError(

								0,

								NLS

										.bind(

												CommonNavigatorMessages.Could_not_provide_children_for_element,

												new Object[] { foundExtension

														.getDescriptor()

														.getId() }), e);

			}

		}

		return (TreePath[]) result.toArray(new TreePath[result.size()]);

	}

	/**

	 * Return the objects as a set.

	 * @param objects the objects

	 * @return a set that contains the objects

	 */

	private Set asSet(Object[] objects) {

		Set parentPaths = new HashSet();

		parentPaths.addAll(Arrays.asList(objects));

		return parentPaths;

	}

	/**

	 * Query each of <code>theOverridingExtensions</code> for in order

	 * to adjust the parent paths of the contributor of the element.

	 * 

	 * TODO: This method would be cleaner if TreePaths were added to the pipeline API.

	 * 

	 * @param anInputElement

	 *            The input element in the tree

	 * @param theOverridingExtensions

	 *            The set of overriding extensions that should participate in

	 *            the pipeline chain

	 * @param theParentPaths

	 *            The current elements to return to the viewer (should be

	 *            modifiable)

	 * @return The set of elements to return to the viewer

	 */

	private Set pipelineParents(Object anInputElement,

			NavigatorContentExtension[] theOverridingExtensions,

			Set theParentPaths) {

		IPipelinedTreeContentProvider pipelinedContentProvider;

		NavigatorContentExtension[] overridingExtensions;

		for (int i = 0; i < theOverridingExtensions.length; i++) {

			if (theOverridingExtensions[i].getContentProvider() instanceof IPipelinedTreeContentProvider) {

				pipelinedContentProvider = (IPipelinedTreeContentProvider) theOverridingExtensions[i]

						.getContentProvider();

				Set adjustedParentPaths = new HashSet();

				if (theParentPaths.isEmpty()) {

					// Need to handle the case where the content provider doesn't

					// known the parent but the pipeline does

					Object aSuggestedParent = pipelinedContentProvider.getPipelinedParent(

							anInputElement, null);

					if (aSuggestedParent != null) {

						Collection newPaths = getPathsForElement(pipelinedContentProvider, aSuggestedParent);

						adjustedParentPaths.add(newPaths);

					}

				} else {

					Set pipedParents = new HashSet();

					for (Iterator iter = theParentPaths.iterator(); iter.hasNext();) {

						TreePath parentPath = (TreePath) iter.next();

						Object parentElement = internalAsElement(parentPath);

						// We only want to pipe a parent once even if it is the tail of multiple paths

						if (!pipedParents.contains(parentElement)) {

							pipedParents.add(parentElement);

							// Push the parent through the pipeline

							Object aSuggestedParent = pipelinedContentProvider.getPipelinedParent(

									anInputElement, parentElement);

							// If the parent was modified, get the new path

							if (aSuggestedParent != parentElement) {

								Collection newPaths = getPathsForElement(pipelinedContentProvider, aSuggestedParent);

								adjustedParentPaths.add(newPaths);

							} else {

								adjustedParentPaths.add(parentPath);

							}

						}

					}

				}

				overridingExtensions = theOverridingExtensions[i]

				                                               .getOverridingExtensionsForTriggerPoint(anInputElement);

				if (overridingExtensions.length > 0)

					adjustedParentPaths = pipelineParents(anInputElement,

							overridingExtensions, adjustedParentPaths);

				theParentPaths = adjustedParentPaths;

			}

		}

		return theParentPaths;

	}

	/**

	 * Return all the potential paths for the given element from the given

	 * content provider. This is done by getting the parent paths of

	 * the element and then appending he element to these paths.

	 * @param aContentProvider the content povider

	 * @param anElement the element

	 * @return the tree path fo the given element

	 */

	private Collection getPathsForElement(ITreeContentProvider aContentProvider, Object anElement) {

		List result = new ArrayList();

		if (aContentProvider instanceof ITreePathContentProvider) {

			ITreePathContentProvider tpcp = (ITreePathContentProvider) aContentProvider;

			TreePath[] paths = tpcp.getParents(anElement);

			for (int i = 0; i < paths.length; i++) {

				TreePath path = paths[i];

				result.add(path.createChildPath(anElement));

			}

		} else {

			// We should never get here since SafeDelegateTreeContentProvider is an ITreePathContentProvider

			result.add(TreePath.EMPTY.createChildPath(anElement));

		}

		return result;

	}

	/**

	 * Get the element from an element or tree path argument.

	 * @param parentElementOrPath the element or tree path

	 * @return the element

	 */

	private Object internalAsElement(Object parentElementOrPath) {

		if (parentElementOrPath instanceof TreePath) {

			TreePath tp = (TreePath) parentElementOrPath;

			if (tp.getSegmentCount() > 0) {

				return tp.getLastSegment();

			}

			// If the path is empty, the parent element is the root

			return viewer.getInput();

		}

		return parentElementOrPath;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.ITreePathLabelProvider#updateLabel(org.eclipse.jface.viewers.ViewerLabel, org.eclipse.jface.viewers.TreePath)

	 */

	public void updateLabel(ViewerLabel label, TreePath elementPath) {

		ILabelProvider[] labelProviders = contentService.findRelevantLabelProviders(elementPath.getLastSegment());

		Image image = null;

		for (int i = 0; i < labelProviders.length && image == null; i++) {

			ILabelProvider labelProvider = labelProviders[i];

			if (labelProvider instanceof ITreePathLabelProvider) {

				ITreePathLabelProvider tplp = (ITreePathLabelProvider) labelProvider;

				((ITreePathLabelProvider)tplp).updateLabel(label, elementPath);

			} else {

				label.setImage(getImage(elementPath.getLastSegment()));

				label.setText(getText(elementPath.getLastSegment()));

			}

		}

	}