Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.eclipse.xtext.ui.editor.findrefs;
  
  import java.util.Iterator;
  import java.util.List;
  
  import  org.eclipse.core.runtime.IProgressMonitor;
  import  org.eclipse.core.runtime.IStatus;
  import  org.eclipse.core.runtime.Status;
 import  org.eclipse.jface.viewers.ITreeContentProvider;
 import  org.eclipse.jface.viewers.TreeViewer;
 import  org.eclipse.jface.viewers.Viewer;
 import  org.eclipse.search.ui.ISearchResultListener;
 import  org.eclipse.search.ui.SearchResultEvent;
 import  org.eclipse.swt.widgets.Display;
 import  org.eclipse.ui.progress.UIJob;
 

Author(s):
Jan Koehnlein - Initial contribution and API
 
 public class ReferenceSearchResultContentProvider implements ITreeContentProvider, ISearchResultListener,
 
 
 
 	private TreeViewer viewer;
 
 	private List<SearchResultEvent> batchedSearchResultEvents;
 
 	private volatile boolean isUIUpdateScheduled;
 
 		this. = resourceDescriptions;
 		if (resourceDescriptions instanceof IResourceDescription.Event.Source) {
 			((IResourceDescription.Event.SourceresourceDescriptions).addListener(this);
 		}
 	}
 
 	public Object[] getChildren(Object parentElement) {
 		if (parentElement instanceof ReferenceSearchViewTreeNode) {
 			return Iterables.toArray(((ReferenceSearchViewTreeNodeparentElement).getChildren(),
 		}
 		return null;
 	}
 
 	public Object getParent(Object element) {
 		if (element instanceof ReferenceSearchViewTreeNode) {
 			return ((ReferenceSearchViewTreeNodeelement).getParent();
 		}
 		return null;
 	}
 
 	public boolean hasChildren(Object element) {
 		if (element instanceof ReferenceSearchViewTreeNode) {
 			return !((ReferenceSearchViewTreeNodeelement).getChildren().isEmpty();
 		}
 		return false;
 	}
 
 	public Object[] getElements(Object inputElement) {
 		if ( == null || .isEmpty()) {
 			return new Object[0];
 		}
 		return Iterables.toArray(ReferenceSearchViewTreeNode.class);
 	}
 
 	public void dispose() {
 		 = null;
 	}
 
 	public void inputChanged(final Viewer viewerObject oldInputObject newInput) {
 		synchronized (viewer) {
 			if (rootNodes != null) {
 				rootNodes.clear();
			}
			if (oldInput instanceof ReferenceSearchResult) {
				((ReferenceSearchResult) oldInput).removeListener(this);
			}
			if (newInput instanceof ReferenceSearchResult && viewer instanceof TreeViewer) {
				((ReferenceSearchResult) newInput).addListener(this);
				this.viewer = (TreeViewer) viewer;
				for (IReferenceDescription referenceDescription : ((ReferenceSearchResult) newInput)
						.getMatchingReferences()) {
					addReference(referenceDescription, false);
				}
			}
		}
	}
	private void addReference(IReferenceDescription referenceDescriptionboolean isUpdateViewer) {
		URI containerEObjectURI = referenceDescription.getContainerEObjectURI();
		final URI eObjectURI = (containerEObjectURI == null) ? referenceDescription.getSourceEObjectUri()
containerEObjectURI;
		if (resourceDescription != null) {
			ReferenceSearchViewTreeNode resourceNode = resourceNode(resourceDescriptionisUpdateViewer);
			ReferenceSearchViewTreeNode referenceNode = null;
			for (IEObjectDescription eObjectDescription : resourceDescription.getExportedObjects()) {
				if (eObjectDescription.getEObjectURI().equals(eObjectURI)) {
					referenceNode = new ReferenceSearchViewTreeNode(resourceNodereferenceDescription,
							eObjectDescription);
					break;
				}
			}
			if (referenceNode == null && resourceNode != null)
				new ReferenceSearchViewTreeNode(resourceNodereferenceDescriptionreferenceDescription);
		}
	}
	private ReferenceSearchViewTreeNode resourceNode(IResourceDescription resourceDescriptionboolean isUpdateViewer) {
		if ( == null) {
		}
			Object nodeDescription = node.getDescription();
			if (nodeDescription instanceof IResourceDescription) {
				if (((IResourceDescriptionnodeDescription).getURI().equals(resourceDescription.getURI())) {
					return node;
				}
			}
		}
		ReferenceSearchViewTreeNode node = new ReferenceSearchViewTreeNode(nullresourceDescription,
				resourceDescription);
		if (isUpdateViewer) {
			.add(.getInput(), node);
		}
		return node;
	}
	public void searchResultChanged(final SearchResultEvent e) {
		synchronized () {
			batchedSearchResultEvents.add(e);
		}
		}
	}
	private class UIUpdater extends UIJob {
		public UIUpdater() {
			setSystem(true);
		}
		public IStatus runInUIThread(IProgressMonitor monitor) {
			List<SearchResultEvent> events;
			synchronized () {
				events = Lists.newArrayList(batchedSearchResultEvents);
				batchedSearchResultEvents.clear();
			}
			for (SearchResultEvent event : events) {
				if (monitor.isCanceled()) {
					return Status.CANCEL_STATUS;
				}
				if (event instanceof Added) {
else if (event instanceof Reset) {
					if ( != null && !.isEmpty()) {
						synchronized () {
							viewer.remove(viewer.getInput(),
									Iterables.toArray(rootNodes, ReferenceSearchViewTreeNode.class));
							rootNodes = null;
						}
					}
				}
			}
			.refresh();
			.expandToLevel(1);
			return Status.OK_STATUS;
		}
	}
	public void descriptionsChanged(final Event event) {
		Display.getDefault().asyncExec(new Runnable() {
			public void run() {
				if ( != null) {
					for (Delta delta : event.getDeltas()) {
						if (!(delta.getNew() instanceof StatefulResourceDescription)) {
								if (((IResourceDescriptionrootNode.getDescription()).getURI().equals(delta.getUri())) {
									if (delta.getNew() == null) {
										i.remove();
										.remove(rootNode);
										break;
else {
										Iterable<IReferenceDescriptionnewReferenceDescriptions = delta.getNew()
										List<ReferenceSearchViewTreeNoderemovedReferenceNodes = Lists.newArrayList();
										for (ReferenceSearchViewTreeNode referenceNode : rootNode.getChildren()) {
											final URI referenceSourceURI = ((IReferenceDescriptionreferenceNode
											if (!Iterables.any(newReferenceDescriptions,
														public boolean apply(IReferenceDescription input) {
															return input.getSourceEObjectUri().equals(
																	referenceSourceURI);
														}
													})) {
												removedReferenceNodes.add(referenceNode);
											}
										}
										for (ReferenceSearchViewTreeNode removedReferenceNode : removedReferenceNodes) {
											rootNode.removeChild(removedReferenceNode);
										}
										if (rootNode.getChildren().isEmpty()) {
											i.remove();
											.remove(rootNode);
											break;
else {
											.remove(rootNode, Iterables.toArray(removedReferenceNodes,
										}
									}
								}
							}
						}
					}
				}
			}
		});
	}
New to GrepCode? Check out our FAQ X