/*
* Copyright (c) 2013, the Dart project authors.
*
* Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.eclipse.org/legal/epl-v10.html
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.dart.tools.internal.search.ui;
import com.google.common.base.Objects;
import com.google.common.base.Predicate;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.google.dart.engine.element.Element;
import com.google.dart.engine.element.ExecutableElement;
import com.google.dart.engine.search.MatchKind;
import com.google.dart.engine.search.SearchEngine;
import com.google.dart.engine.search.SearchMatch;
import com.google.dart.engine.source.Source;
import com.google.dart.engine.source.UriKind;
import com.google.dart.engine.utilities.source.SourceRange;
import com.google.dart.tools.core.DartCore;
import com.google.dart.tools.internal.corext.refactoring.util.ExecutionUtils;
import com.google.dart.tools.internal.corext.refactoring.util.RunnableEx;
import com.google.dart.tools.ui.DartPluginImages;
import com.google.dart.tools.ui.DartToolsPlugin;
import com.google.dart.tools.ui.DartUI;
import com.google.dart.tools.ui.internal.text.editor.DartEditor;
import com.google.dart.tools.ui.internal.text.editor.EditorUtility;
import com.google.dart.tools.ui.internal.text.editor.NewDartElementLabelProvider;
import com.google.dart.tools.ui.internal.util.ExceptionHandler;
import com.google.dart.tools.ui.internal.util.SWTUtil;
import org.apache.commons.lang3.ArrayUtils;
import org.eclipse.core.filebuffers.FileBuffers;
import org.eclipse.core.filebuffers.ITextFileBuffer;
import org.eclipse.core.filebuffers.ITextFileBufferManager;
import org.eclipse.core.filebuffers.LocationKind;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceConverter;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StyledString;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.graphics.TextStyle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.progress.UIJob;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Abstract {@link SearchPage} for displaying {@link SearchMatch}s.
*
* @coverage dart.editor.ui.search
*/
public abstract class SearchMatchPage extends SearchPage {
/**
* Item for an element in search results tree.
*/
private static class ElementItem {
private final Element element;
private final List<ElementItem> children = Lists.newArrayList();
private final List<LineItem> lines = Lists.newArrayList();
private ElementItem parent;
private ElementItem prev;
private ElementItem next;
private int numMatches;
public ElementItem(Element element) {
this.element = element;
}
/**
* Adds new {@link SearchMatch}, on the same or new {@link LineItem}.
*/
public void addMatch(SourceLineProvider lineProvider, SearchMatch match) {
ReferenceKind referenceKind = ReferenceKind.of(match.getKind());
Source source = element.getSource();
SourceLine sourceLine = lineProvider.getLine(source, match.getSourceRange().getOffset());
// find target LineItem
LineItem targetLineItem = null;
for (LineItem lineItem : lines) {
if (lineItem.line.equals(sourceLine)) {
targetLineItem = lineItem;
break;
}
}
// new LineItem
if (targetLineItem == null) {
boolean potential = FILTER_POTENTIAL.apply(match);
targetLineItem = new LineItem(this, potential, sourceLine);
lines.add(targetLineItem);
}
// prepare position
SourceRange matchRange = match.getSourceRange();
Position position = new Position(matchRange.getOffset(), matchRange.getLength());
// add new position
targetLineItem.addPosition(position, referenceKind);
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof ElementItem)) {
return false;
}
return Objects.equal(((ElementItem) obj).element, element);
}
@Override
public int hashCode() {
return element != null ? element.hashCode() : 0;
}
public void merge(ElementItem item) {
numMatches += item.numMatches;
List<LineItem> thisLines = Lists.newArrayList(lines);
for (LineItem otherLine : item.lines) {
// try to merge into existing line
boolean merged = false;
for (LineItem thisLine : thisLines) {
merged |= thisLine.merge(otherLine);
}
// add line
if (!merged) {
lines.add(otherLine);
otherLine.item = this;
}
}
}
void addChild(ElementItem child) {
if (child.parent == null) {
child.parent = this;
children.add(child);
}
}
}
/**
* Helper for navigating {@link ElementItem} and {@link LineItem} hierarchy.
*/
private static class ItemCursor {
ElementItem item;
int lineIndex;
ItemCursor(ElementItem item) {
this(item, -1);
}
ItemCursor(ElementItem item, int positionIndex) {
this.item = item;
this.lineIndex = positionIndex;
}
Position getPosition() {
if (item == null) {
return null;
}
if (lineIndex < 0 || lineIndex > item.lines.size() - 1) {
return null;
}
LineItem lineItem = item.lines.get(lineIndex);
LinePosition linePosition = lineItem.positions.get(0);
return linePosition.position;
}
/**
* Moves this {@link ItemCursor} to the next {@link LineItem} in the same or next
* {@link ElementItem}.
*
* @return {@code true} if was moved, or {@code false} if cursor is at the last line.
*/
boolean next() {
ElementItem _item = item;
int _lineIndex = lineIndex;
// try to go to next
if (_next()) {
return true;
}
// rollback
item = _item;
lineIndex = _lineIndex;
return false;
}
/**
* Moves this {@link ItemCursor} to the previous {@link LineItem} in the same or previous
* {@link ElementItem}.
*
* @return {@code true} if was moved, or {@code false} if cursor is at the first line.
*/
boolean prev() {
ElementItem _item = item;
int _lineIndex = lineIndex;
// try to go to previous
if (_prev()) {
return true;
}
// rollback
item = _item;
lineIndex = _lineIndex;
return false;
}
private boolean _next() {
if (item == null) {
return false;
}
// in the same leaf
if (lineIndex < item.lines.size() - 1) {
lineIndex++;
return true;
}
// next leaf
while (true) {
item = item.next;
if (item == null) {
return false;
}
if (!item.lines.isEmpty()) {
lineIndex = 0;
break;
}
}
return true;
}
private boolean _prev() {
if (item == null) {
return false;
}
// in the same leaf
if (lineIndex > 0) {
lineIndex--;
return true;
}
// previous leaf
while (true) {
item = item.prev;
if (item == null) {
return false;
}
if (!item.lines.isEmpty()) {
lineIndex = item.lines.size() - 1;
break;
}
}
return true;
}
}
/**
* Item for a line with one or more matches.
*/
private static class LineItem {
private ElementItem item;
private boolean potential;
private final SourceLine line;
private final List<LinePosition> positions = Lists.newArrayList();
public LineItem(ElementItem item, boolean potential, SourceLine line) {
this.item = item;
this.potential = potential;
this.line = line;
}
/**
* Adds new the {@link LinePosition} with given parameters.
*/
public void addPosition(Position position, ReferenceKind kind) {
positions.add(new LinePosition(position, kind));
}
/**
* Attempts to merge the given {@link LineItem} into this.
*
* @return {@code true} if merge was done, {@code false} if not the same line.
*/
public boolean merge(LineItem other) {
if (!other.line.equals(line)) {
return false;
}
potential |= other.potential;
positions.addAll(other.positions);
return true;
}
}
/**
* Value object with {@link Position} and its {@link ReferenceKind}.
*/
private static class LinePosition {
private final Position position;
private final Position positionSrc;
private final ReferenceKind kind;
public LinePosition(Position position, ReferenceKind kind) {
this.position = position;
this.positionSrc = new Position(position.offset, position.length);
this.kind = kind;
}
}
private static class PreferenceBackgroundStyler extends StyledString.Styler {
private final IPreferenceStore store;
private final String key;
public PreferenceBackgroundStyler(IPreferenceStore store, String key) {
this.store = store;
this.key = key;
}
@Override
public void applyStyles(TextStyle textStyle) {
RGB rgb = PreferenceConverter.getColor(store, key);
if (rgb != null) {
textStyle.background = DartUI.getColorManager().getColor(rgb);
}
}
}
/**
* Coarse-grained kind of the reference. We don't need all details of {@link MatchKind}.
*/
private static enum ReferenceKind {
REFERENCE,
READ,
WRITE;
public static ReferenceKind of(MatchKind kind) {
if (kind == MatchKind.FIELD_READ || kind == MatchKind.VARIABLE_READ) {
return READ;
}
if (kind == MatchKind.FIELD_WRITE || kind == MatchKind.VARIABLE_WRITE
|| kind == MatchKind.VARIABLE_READ_WRITE) {
return WRITE;
}
return REFERENCE;
}
}
/**
* {@link ITreeContentProvider} for {@link ElementItem}s.
*/
private static class SearchContentProvider implements ITreeContentProvider {
@Override
public void dispose() {
}
@Override
public Object[] getChildren(Object parentElement) {
// prepare item
if (!(parentElement instanceof ElementItem)) {
return ArrayUtils.EMPTY_OBJECT_ARRAY;
}
ElementItem item = (ElementItem) parentElement;
// sub-items
List<ElementItem> children = item.children;
if (!children.isEmpty()) {
return children.toArray(new ElementItem[children.size()]);
}
// lines
List<LineItem> lines = item.lines;
return lines.toArray(new LineItem[lines.size()]);
}
@Override
public Object[] getElements(Object inputElement) {
return getChildren(inputElement);
}
@Override
public Object getParent(Object element) {
if (element instanceof ElementItem) {
return ((ElementItem) element).parent;
}
if (element instanceof LineItem) {
return ((LineItem) element).item;
}
return null;
}
@Override
public boolean hasChildren(Object element) {
if (element instanceof ElementItem) {
ElementItem item = (ElementItem) element;
return !item.children.isEmpty() || !item.lines.isEmpty();
}
return false;
}
@Override
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
}
}
/**
* {@link ILabelProvider} for {@link ElementItem}s.
*/
private static class SearchLabelProvider extends NewDartElementLabelProvider {
@Override
public Image getImage(Object elem) {
// element
if (elem instanceof ElementItem) {
ElementItem item = (ElementItem) elem;
return super.getImage(item.element);
}
// line
if (elem instanceof LineItem) {
LineItem item = (LineItem) elem;
// has any write?
for (LinePosition position : item.positions) {
if (position.kind == ReferenceKind.WRITE) {
return DartPluginImages.get(DartPluginImages.IMG_OBJS_SEARCH_WRITEACCESS);
}
}
// has any read?
for (LinePosition position : item.positions) {
if (position.kind == ReferenceKind.READ) {
return DartPluginImages.get(DartPluginImages.IMG_OBJS_SEARCH_READACCESS);
}
}
// just some reference
return DartPluginImages.get(DartPluginImages.IMG_OBJS_SEARCH_OCCURRENCE);
}
// unknown
return null;
}
@Override
public StyledString getStyledText(Object elem) {
if (elem instanceof ElementItem) {
ElementItem item = (ElementItem) elem;
StyledString styledText = super.getStyledText(item.element);
if (item.numMatches == 1) {
styledText.append(" (1 match)", StyledString.COUNTER_STYLER);
} else if (item.numMatches > 1) {
styledText.append(" (" + item.numMatches + " matches)", StyledString.COUNTER_STYLER);
}
return styledText;
} else {
LineItem item = (LineItem) elem;
StyledString styledText = new StyledString(item.line.content);
for (LinePosition linePosition : item.positions) {
StyledString.Styler style = linePosition.kind == ReferenceKind.WRITE
? HIGHLIGHT_WRITE_STYLE : HIGHLIGHT_STYLE;
int styleOffset = linePosition.positionSrc.offset - item.line.start;
int styleLength = linePosition.positionSrc.length;
try {
styledText.setStyle(styleOffset, styleLength, style);
} catch (Throwable e) {
// https://code.google.com/p/dart/issues/detail?id=18576
// Cannot reproduce, just ignore.
}
}
// may be potential match
if (item.potential) {
styledText.append(" ");
styledText.append(" (potential match)", StyledString.DECORATIONS_STYLER);
}
// done
return styledText;
}
}
}
/**
* Information about a single line in some {@link Source}.
*/
private static class SourceLine {
final Source source;
final int start;
final String content;
public SourceLine(Source source, int start, String content) {
this.source = source;
this.start = start;
this.content = content;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof SourceLine)) {
return false;
}
SourceLine other = (SourceLine) obj;
return other.source == source && other.start == start;
}
}
/**
* Helper for transforming offsets in the some {@link Source} into {@link SourceLine} objects.
*/
private static class SourceLineProvider {
private final Map<Source, String> sourceContentMap = Maps.newHashMap();
/**
* @return the {@link SourceLine} for the given {@link Source} and offset; may be {@code null}.
*/
public SourceLine getLine(Source source, int offset) {
String content = getContent(source);
// find start of line
int start = offset;
while (start > 0 && content.charAt(start - 1) != '\n') {
start--;
}
// find end of line
int end = offset;
while (end < content.length() && content.charAt(end) != '\r' && content.charAt(end) != '\n') {
end++;
}
// done
String text = content.substring(start, end);
return new SourceLine(source, start, text);
}
private String getContent(Source source) {
String content = sourceContentMap.get(source);
if (content == null) {
try {
IResource resource = DartCore.getProjectManager().getResource(source);
if (resource instanceof IFile) {
// IFile in workspace, can be open and modified - get contents using FileBuffers.
IFile file = (IFile) resource;
ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager();
IPath path = file.getFullPath();
manager.connect(path, LocationKind.IFILE, null);
try {
ITextFileBuffer buffer = manager.getTextFileBuffer(path, LocationKind.IFILE);
IDocument document = buffer.getDocument();
content = document.get();
sourceContentMap.put(source, content);
} finally {
manager.disconnect(path, LocationKind.IFILE, null);
}
} else {
// It must be an external file, cannot be modified - request its contents directly.
content = source.getContents().getData().toString();
sourceContentMap.put(source, content);
}
} catch (Throwable e) {
return null;
}
}
return content;
}
}
@SuppressWarnings("restriction")
private static final StyledString.Styler HIGHLIGHT_WRITE_STYLE = new PreferenceBackgroundStyler(
org.eclipse.ui.internal.editors.text.EditorsPlugin.getDefault().getPreferenceStore(),
"writeOccurrenceIndicationColor");
@SuppressWarnings("restriction")
private static final StyledString.Styler HIGHLIGHT_STYLE = new PreferenceBackgroundStyler(
org.eclipse.ui.internal.editors.text.EditorsPlugin.getDefault().getPreferenceStore(),
"searchResultIndicationColor");
private static final String SETTINGS_ID = "SearchMatchPage";
private static final String FILTER_SDK_ID = "filter_SDK";
private static final String FILTER_POTENTIAL_ID = "filter_potential";
private static final String FILTER_PROJECT_ID = "filter_project";
private static final ITreeContentProvider CONTENT_PROVIDER = new SearchContentProvider();
/**
* Adds new {@link ElementItem} to the tree.
*/
private static ElementItem addElementItem(Map<Element, ElementItem> itemMap, ElementItem child) {
// put child
Element childElement = child.element;
{
ElementItem existingChild = itemMap.get(childElement);
if (existingChild == null) {
itemMap.put(childElement, child);
} else {
existingChild.merge(child);
child = existingChild;
}
}
// bind child to parent
if (childElement != null) {
Element parentElement = childElement.getEnclosingElement();
ElementItem parent = new ElementItem(parentElement);
parent = addElementItem(itemMap, parent);
parent.addChild(child);
}
// done
return child;
}
/**
* Builds {@link ElementItem} tree out of the given {@link SearchMatch}s.
*/
private static ElementItem buildElementItemTree(List<SearchMatch> matches) {
SourceLineProvider sourceLineProvider = new SourceLineProvider();
ElementItem rootItem = new ElementItem(null);
Map<Element, ElementItem> itemMap = Maps.newHashMap();
itemMap.put(null, rootItem);
for (SearchMatch match : matches) {
Element element = getExecutableElement(match);
ElementItem elementItem = new ElementItem(element);
elementItem.addMatch(sourceLineProvider, match);
addElementItem(itemMap, elementItem);
}
calculateNumMatches(rootItem);
sortLines(rootItem);
linkLeaves(rootItem, null);
return rootItem;
}
/**
* Recursively calculates {@link ElementItem#numMatches} fields.
*/
private static int calculateNumMatches(ElementItem item) {
int result = 0;
for (LineItem lineItem : item.lines) {
result += lineItem.positions.size();
}
for (ElementItem child : item.children) {
result += calculateNumMatches(child);
}
item.numMatches = result;
return result;
}
private static IDialogSettings getDialogSettings() {
return DartToolsPlugin.getDefault().getDialogSettingsSection(SETTINGS_ID);
}
/**
* @return the {@link Element} to use as enclosing in {@link ElementItem} tree.
*/
private static Element getExecutableElement(SearchMatch match) {
Element element = match.getElement();
while (element != null) {
Element executable = element.getAncestor(ExecutableElement.class);
if (executable == null) {
break;
}
element = executable;
}
return element;
}
/**
* Recursively visits {@link ElementItem} and links leaves.
*
* @return the last {@link ElementItem} leaf in the sub-tree.
*/
private static ElementItem linkLeaves(ElementItem item, ElementItem prev) {
// leaf
if (item.children.isEmpty()) {
if (prev != null) {
prev.next = item;
}
item.prev = prev;
prev = item;
return item;
}
// container
ElementItem lastLeaf = prev;
item.next = item.children.get(0);
for (ElementItem child : item.children) {
lastLeaf = linkLeaves(child, lastLeaf);
}
return lastLeaf;
}
/**
* Opens the {@link Position} in the {@link Element}s editor.
*/
private static void openPositionInElement(Element element, Position position) {
try {
IEditorPart editor = DartUI.openInEditor(element);
revealInEditor(editor, position);
} catch (Throwable e) {
ExceptionHandler.handle(e, "Search", "Exception during open.");
}
}
/**
* Reveals the given {@link Position} in the {@link IEditorPart}.
*/
private static void revealInEditor(IEditorPart editor, Position position) {
SourceRange sourceRange = new SourceRange(position.offset, position.length);
EditorUtility.revealInEditor(editor, sourceRange);
}
/**
* Recursively sorts {@link ElementItem}s and {@link LineItem}s.
*/
private static void sortLines(ElementItem item) {
// process lines
Collections.sort(item.lines, new Comparator<LineItem>() {
@Override
public int compare(LineItem o1, LineItem o2) {
return o1.line.start - o2.line.start;
}
});
for (LineItem lineItem : item.lines) {
Collections.sort(lineItem.positions, new Comparator<LinePosition>() {
@Override
public int compare(LinePosition o1, LinePosition o2) {
return o1.position.offset - o2.position.offset;
}
});
}
// process children
Collections.sort(item.children, new Comparator<ElementItem>() {
@Override
public int compare(ElementItem o1, ElementItem o2) {
return o1.element.getNameOffset() - o2.element.getNameOffset();
}
});
for (ElementItem child : item.children) {
sortLines(child);
}
}
private IAction removeAction = new Action() {
{
setToolTipText("Remove Selected Matches");
DartPluginImages.setLocalImageDescriptors(this, "search_rem.gif");
}
@Override
public void run() {
IStructuredSelection selection = (IStructuredSelection) viewer.getSelection();
for (Iterator<?> iter = selection.toList().iterator(); iter.hasNext();) {
Object obj = iter.next();
// LineItem
if (obj instanceof LineItem) {
LineItem lineItem = (LineItem) obj;
ElementItem parentItem = lineItem.item;
List<LineItem> parentLines = parentItem.lines;
// remove this line
parentLines.remove(lineItem);
// it no more lines, remove parent item too
if (parentLines.isEmpty()) {
obj = parentItem;
}
}
// ResultItem
if (obj instanceof ElementItem) {
ElementItem item = (ElementItem) obj;
while (item != null && item.element != null) {
ElementItem parent = item.parent;
parent.children.remove(item);
if (!parent.children.isEmpty()) {
break;
}
item = parent;
}
}
}
calculateNumMatches(rootItem);
// update viewer
viewer.refresh();
// update markers
addMarkers();
}
};
private IAction removeAllAction = new Action() {
{
setToolTipText("Remove All Matches");
DartPluginImages.setLocalImageDescriptors(this, "search_remall.gif");
}
@Override
public void run() {
close();
}
};
private IAction refreshAction = new Action() {
{
setToolTipText("Refresh the Current Search");
DartPluginImages.setLocalImageDescriptors(this, "refresh.gif");
}
@Override
public void run() {
refresh();
}
};
private IAction expandAllAction = new Action() {
{
setToolTipText("Expand All");
DartPluginImages.setLocalImageDescriptors(this, "expandall.gif");
}
@Override
public void run() {
viewer.expandAll();
}
};
private IAction collapseAllAction = new Action() {
{
setToolTipText("Collapse All");
DartPluginImages.setLocalImageDescriptors(this, "collapseall.gif");
}
@Override
public void run() {
viewer.collapseAll();
}
};
private IAction nextAction = new Action() {
{
setToolTipText("Show Next Match");
DartPluginImages.setLocalImageDescriptors(this, "search_next.gif");
}
@Override
public void run() {
openItemNext();
}
};
private IAction prevAction = new Action() {
{
setToolTipText("Show Previous Match");
DartPluginImages.setLocalImageDescriptors(this, "search_prev.gif");
}
@Override
public void run() {
openItemPrev();
}
};
private IAction filterSdkAction = new Action(null, IAction.AS_CHECK_BOX) {
{
setToolTipText("Hide SDK and package matches");
DartPluginImages.setLocalImageDescriptors(this, "search_filter_sdk.png");
}
@Override
public void run() {
filterEnabledSdk = isChecked();
getDialogSettings().put(FILTER_SDK_ID, filterEnabledSdk);
refresh();
}
};
private IAction filterPotentialAction = new Action(null, IAction.AS_CHECK_BOX) {
{
setToolTipText("Hide potential matches");
DartPluginImages.setLocalImageDescriptors(this, "search_filter_potential.png");
}
@Override
public void run() {
filterEnabledPotential = isChecked();
getDialogSettings().put(FILTER_POTENTIAL_ID, filterEnabledPotential);
refresh();
}
};
private IAction filterProjectAction = new Action(null, IAction.AS_CHECK_BOX) {
{
setToolTipText("Show only current project actions");
DartPluginImages.setLocalImageDescriptors(this, "search_filter_project.gif");
}
@Override
public void run() {
filterEnabledProject = isChecked();
getDialogSettings().put(FILTER_PROJECT_ID, filterEnabledProject);
refresh();
}
};
private final SearchView searchView;
private final String taskName;
private final Set<IResource> markerResources = Sets.newHashSet();
private TreeViewer viewer;
private IPreferenceStore preferences;
private IPropertyChangeListener propertyChangeListener = new IPropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent event) {
updateColors();
}
};
private ElementItem rootItem;
private ItemCursor itemCursor;
private PositionTracker positionTracker;
private boolean filterEnabledSdk = false;
private boolean filterEnabledPotential = false;
private boolean filterEnabledProject = false;
private int filteredCountSdk = 0;
private int filteredCountPotential = 0;
private int filteredCountProject = 0;
private static final Predicate<SearchMatch> FILTER_SDK = new Predicate<SearchMatch>() {
@Override
public boolean apply(SearchMatch input) {
Source source = input.getElement().getSource();
UriKind uriKind = source.getUriKind();
return uriKind == UriKind.DART_URI || uriKind == UriKind.PACKAGE_URI;
}
};
private static final Predicate<SearchMatch> FILTER_POTENTIAL = new Predicate<SearchMatch>() {
@Override
public boolean apply(SearchMatch input) {
return input.getKind() == MatchKind.NAME_REFERENCE_RESOLVED
|| input.getKind() == MatchKind.NAME_REFERENCE_UNRESOLVED;
}
};
private final Predicate<SearchMatch> FILTER_PROJECT = new Predicate<SearchMatch>() {
@Override
public boolean apply(SearchMatch input) {
IProject currentProject = getCurrentProject();
IFile resource = DartUI.getElementFile(input.getElement());
return resource != null && currentProject != null
&& currentProject.equals(resource.getProject());
}
};
private long lastQueryStartTime = 0;
private long lastQueryFinishTime = 0;
public SearchMatchPage(SearchView searchView, String taskName) {
this.searchView = searchView;
this.taskName = taskName;
}
@Override
public void createControl(Composite parent) {
initFilters();
viewer = new TreeViewer(parent, SWT.FULL_SELECTION);
viewer.setContentProvider(CONTENT_PROVIDER);
// NB(scheglov): don't attempt to share label provider - it is not allowed in JFace
viewer.setLabelProvider(new DelegatingStyledCellLabelProvider(new SearchLabelProvider()));
viewer.addDoubleClickListener(new IDoubleClickListener() {
@Override
public void doubleClick(DoubleClickEvent event) {
ISelection selection = event.getSelection();
openSelectedElement(selection);
}
});
// update colors
preferences = DartToolsPlugin.getDefault().getCombinedPreferenceStore();
preferences.addPropertyChangeListener(propertyChangeListener);
updateColors();
SWTUtil.bindJFaceResourcesFontToControl(viewer.getControl());
}
@Override
public void dispose() {
preferences.removePropertyChangeListener(propertyChangeListener);
removeMarkers();
disposePositionTracker();
super.dispose();
}
@Override
public Control getControl() {
return viewer.getControl();
}
@Override
public long getLastQueryFinishTime() {
return lastQueryFinishTime;
}
@Override
public long getLastQueryStartTime() {
return lastQueryStartTime;
}
@Override
public void makeContributions(IMenuManager menuManager, IToolBarManager toolBarManager,
IStatusLineManager statusLineManager) {
toolBarManager.add(filterProjectAction);
toolBarManager.add(filterSdkAction);
toolBarManager.add(filterPotentialAction);
toolBarManager.add(new Separator());
toolBarManager.add(nextAction);
toolBarManager.add(prevAction);
toolBarManager.add(new Separator());
toolBarManager.add(removeAction);
toolBarManager.add(removeAllAction);
toolBarManager.add(new Separator());
toolBarManager.add(expandAllAction);
toolBarManager.add(collapseAllAction);
toolBarManager.add(new Separator());
toolBarManager.add(refreshAction);
}
@Override
public void setFocus() {
viewer.getControl().setFocus();
}
@Override
public void show() {
refresh();
}
/**
* This is the first method called before performing refresh.
*/
protected void beforeRefresh() {
}
/**
* @return {@code true} if potential filter can be used.
*/
protected boolean canUseFilterPotential() {
return true;
}
/**
* Clients may implement this method to allow "Only current project" filter.
*/
protected IProject getCurrentProject() {
return null;
}
/**
* @return the description of the element we searched for.
*/
protected abstract String getQueryElementName();
/**
* @return the description of the query we executed.
*/
protected abstract String getQueryKindName();
/**
* Runs a {@link SearchEngine} request.
*
* @return the {@link SearchMatch}s to display.
*/
protected abstract List<SearchMatch> runQuery();
/**
* Closes this page and removes all search markers
*/
void close() {
searchView.showPage(null);
}
/**
* Adds markers for all {@link ElementItem}s starting from {@link #rootItem}.
*/
private void addMarkers() {
try {
ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {
@Override
public void run(IProgressMonitor monitor) throws CoreException {
removeMarkers();
markerResources.clear();
addMarkers(rootItem);
}
}, null);
} catch (Throwable e) {
DartToolsPlugin.log(e);
}
}
/**
* Adds markers for the given {@link ElementItem} and its children.
*/
private void addMarkers(ElementItem item) throws CoreException {
// add marker if leaf
if (!item.lines.isEmpty()) {
IFile resource = DartUI.getElementFile(item.element);
if (resource != null && resource.exists()) {
markerResources.add(resource);
try {
for (LineItem lineItem : item.lines) {
List<LinePosition> positions = lineItem.positions;
for (LinePosition linePosition : positions) {
Position position = linePosition.position;
IMarker marker = resource.createMarker(SearchView.SEARCH_MARKER);
marker.setAttribute(IMarker.CHAR_START, position.getOffset());
marker.setAttribute(IMarker.CHAR_END, position.getOffset() + position.getLength());
}
}
} catch (Throwable e) {
}
}
}
// process children
for (ElementItem child : item.children) {
addMarkers(child);
}
}
private List<SearchMatch> applyFilters(List<SearchMatch> matches) {
filteredCountSdk = 0;
filteredCountPotential = 0;
filteredCountProject = 0;
IProject currentProject = getCurrentProject();
List<SearchMatch> filtered = Lists.newArrayList();
for (SearchMatch match : matches) {
// SDK filter
if (FILTER_SDK.apply(match)) {
filteredCountSdk++;
if (filterEnabledSdk) {
continue;
}
}
// potential filter
if (canUseFilterPotential()) {
if (FILTER_POTENTIAL.apply(match)) {
filteredCountPotential++;
if (filterEnabledPotential) {
continue;
}
}
}
// project filter
if (currentProject != null) {
if (FILTER_PROJECT.apply(match)) {
filteredCountProject++;
} else if (filterEnabledProject) {
continue;
}
}
// OK
filtered.add(match);
}
return filtered;
}
/**
* Disposes {@link #positionTracker}.
*/
private void disposePositionTracker() {
if (positionTracker == null) {
return;
}
positionTracker.dispose();
positionTracker = null;
}
/**
* Worker method for {@link #expandTreeItemsTimeBoxed(List, long)}.
*/
private long expandTreeItemsTimeBoxed(List<ElementItem> items, int childrenLimit, long nanoBudget) {
for (ElementItem item : items) {
if (nanoBudget < 0) {
return -1;
}
if (item.children.size() <= childrenLimit) {
// expand single item
{
long startNano = System.nanoTime();
viewer.setExpandedState(item, true);
nanoBudget -= System.nanoTime() - startNano;
}
// expand children
nanoBudget = expandTreeItemsTimeBoxed(item.children, childrenLimit, nanoBudget);
if (nanoBudget < 0) {
return -1;
}
}
}
return nanoBudget;
}
/**
* Analyzes each {@link ElementItem} and expends it in {@link #viewer} only if it has not too much
* children. So, user will see enough information, but not too much.
*/
private void expandTreeItemsTimeBoxed(List<ElementItem> items, long nanoBudget) {
int numIterations = 10;
int childrenLimit = 10;
for (int i = 0; i < numIterations; i++) {
if (nanoBudget < 0) {
break;
}
nanoBudget = expandTreeItemsTimeBoxed(items, childrenLimit, nanoBudget);
childrenLimit *= 2;
}
}
/**
* Initializes filters from {@link IDialogSettings}.
*/
private void initFilters() {
IDialogSettings settings = getDialogSettings();
if (settings.getBoolean(FILTER_SDK_ID)) {
filterEnabledSdk = true;
filterSdkAction.setChecked(true);
}
if (settings.getBoolean(FILTER_POTENTIAL_ID)) {
filterEnabledPotential = true;
filterPotentialAction.setChecked(true);
}
if (settings.getBoolean(FILTER_PROJECT_ID)) {
filterEnabledProject = true;
filterProjectAction.setChecked(true);
}
if (!canUseFilterPotential()) {
filterPotentialAction.setEnabled(false);
filterPotentialAction.setChecked(false);
}
if (getCurrentProject() == null) {
filterProjectAction.setEnabled(false);
filterProjectAction.setChecked(false);
}
}
/**
* Opens {@link DartEditor} with the next {@link Position} in the same of the next
* {@link ElementItem}.
*/
private void openItemNext() {
boolean changed = itemCursor.next();
if (changed) {
showCursor();
}
}
/**
* Opens {@link DartEditor} with the previous {@link Position} in the same of the previous
* {@link ElementItem}.
*/
private void openItemPrev() {
boolean changed = itemCursor.prev();
if (changed) {
showCursor();
}
}
/**
* Opens selected {@link ElementItem} in the editor.
*/
private void openSelectedElement(ISelection selection) {
// need IStructuredSelection
if (!(selection instanceof IStructuredSelection)) {
return;
}
IStructuredSelection structuredSelection = (IStructuredSelection) selection;
// only single element
if (structuredSelection.size() != 1) {
return;
}
Object firstElement = structuredSelection.getFirstElement();
// line item
if (firstElement instanceof LineItem) {
LineItem lineItem = (LineItem) firstElement;
Position position = lineItem.positions.get(0).position;
openPositionInElement(lineItem.item.element, position);
}
// element item
if (firstElement instanceof ElementItem) {
ElementItem item = (ElementItem) firstElement;
// use ResultCursor to find first occurrence in the requested subtree
itemCursor = new ItemCursor(item);
boolean found = itemCursor.next();
if (!found) {
return;
}
Element element = itemCursor.item.element;
Position position = itemCursor.getPosition();
// open position
openPositionInElement(element, position);
}
}
/**
* Runs background {@link Job} to fetch {@link SearchMatch}s and then displays them in the
* {@link #viewer}.
*/
private void refresh() {
try {
lastQueryStartTime = System.currentTimeMillis();
new Job(taskName) {
@Override
protected IStatus run(IProgressMonitor monitor) {
beforeRefresh();
// do query
List<SearchMatch> matches = runQuery();
int totalCount = matches.size();
matches = applyFilters(matches);
// set description
String filtersDesc;
{
filtersDesc = "";
filtersDesc += ", SDK: " + filteredCountSdk;
if (filterEnabledSdk) {
filtersDesc += " (filtered)";
}
if (canUseFilterPotential()) {
filtersDesc += ", potential: " + filteredCountPotential;
if (filterEnabledPotential) {
filtersDesc += " (filtered)";
}
}
if (getCurrentProject() != null) {
filtersDesc += ", in project: " + filteredCountProject;
if (filterEnabledProject) {
filtersDesc += " (only)";
}
}
}
setContentDescription("'" + getQueryElementName() + "' - " + matches.size() + " "
+ getQueryKindName() + ", total: " + totalCount + filtersDesc);
// process query results
rootItem = buildElementItemTree(matches);
itemCursor = new ItemCursor(rootItem);
trackPositions();
// add markers
addMarkers();
// schedule UI update
new UIJob("Displaying search results...") {
@Override
public IStatus runInUIThread(IProgressMonitor monitor) {
// may be already disposed (e.g. new search was done)
if (viewer.getControl().isDisposed()) {
return Status.OK_STATUS;
}
// set new input
Object[] expandedElements = viewer.getExpandedElements();
viewer.setInput(rootItem);
viewer.setExpandedElements(expandedElements);
// expand
expandTreeItemsTimeBoxed(rootItem.children, 75L * 1000000L);
lastQueryFinishTime = System.currentTimeMillis();
return Status.OK_STATUS;
}
}.schedule();
// done
return Status.OK_STATUS;
}
}.schedule();
} catch (Throwable e) {
ExceptionHandler.handle(e, "Search", "Exception during search.");
}
}
/**
* Removes all search markers from {@link #markerResources}.
*/
private void removeMarkers() {
try {
ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {
@Override
public void run(IProgressMonitor monitor) throws CoreException {
for (IResource resource : markerResources) {
if (resource.exists()) {
try {
resource.deleteMarkers(SearchView.SEARCH_MARKER, false, IResource.DEPTH_ZERO);
} catch (Throwable e) {
}
}
}
}
}, null);
} catch (Throwable e) {
DartToolsPlugin.log(e);
}
}
/**
* Shows given text as description for {@link SearchView}.
*/
private void setContentDescription(final String description) {
ExecutionUtils.runRethrowUI(new RunnableEx() {
@Override
public void run() throws Exception {
searchView.setContentDescription(description);
}
});
}
/**
* Shows current {@link #itemCursor} state.
*/
private void showCursor() {
try {
ElementItem elementItem = itemCursor.item;
LineItem lineItem = elementItem.lines.get(itemCursor.lineIndex);
viewer.setSelection(new StructuredSelection(lineItem), true);
// open editor with Element
Element element = elementItem.element;
IEditorPart editor = DartUI.openInEditor(element, false, true);
// show Position
Position position = itemCursor.getPosition();
if (position != null) {
revealInEditor(editor, position);
}
} catch (Throwable e) {
ExceptionHandler.handle(e, "Search", "Exception during open.");
}
}
/**
* Starts tracking all search result positions in {@link #positionTracker}.
*/
private void trackPositions() {
disposePositionTracker();
positionTracker = new PositionTracker();
trackPositions(rootItem);
}
/**
* Recursively visits {@link ElementItem} and tracks all {@link Position}s.
*/
private void trackPositions(ElementItem item) {
// do track positions
if (item.element != null) {
IFile file = DartUI.getElementFile(item.element);
if (file != null) {
for (LineItem lineItem : item.lines) {
List<LinePosition> positions = lineItem.positions;
for (LinePosition linePosition : positions) {
Position position = linePosition.position;
positionTracker.trackPosition(file, position);
}
}
}
}
// process children
for (ElementItem child : item.children) {
trackPositions(child);
}
}
private void updateColors() {
if (viewer.getTree().isDisposed()) {
return;
}
SWTUtil.runUI(new Runnable() {
@Override
public void run() {
SWTUtil.setColors(viewer.getTree(), preferences);
viewer.refresh();
}
});
}
}