| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.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/org/documents/epl-v10.php |
| * |
| * 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.android.ide.eclipse.adt.internal.lint; |
| |
| import com.android.ide.eclipse.adt.AdtConstants; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.AdtUtils; |
| import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditorDelegate; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.GraphicalEditorPart; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.LayoutActionBar; |
| import com.android.tools.lint.client.api.Configuration; |
| import com.android.tools.lint.client.api.IssueRegistry; |
| import com.android.tools.lint.client.api.LintClient; |
| import com.android.tools.lint.detector.api.Issue; |
| import com.android.tools.lint.detector.api.Severity; |
| import com.google.common.collect.ArrayListMultimap; |
| import com.google.common.collect.Multimap; |
| |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IMarkerDelta; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IResourceChangeEvent; |
| import org.eclipse.core.resources.IResourceChangeListener; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| import org.eclipse.jface.viewers.ColumnPixelData; |
| import org.eclipse.jface.viewers.ColumnWeightData; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.StyledCellLabelProvider; |
| import org.eclipse.jface.viewers.StyledString; |
| import org.eclipse.jface.viewers.TableLayout; |
| import org.eclipse.jface.viewers.TreeNodeContentProvider; |
| import org.eclipse.jface.viewers.TreeViewer; |
| import org.eclipse.jface.viewers.TreeViewerColumn; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.jface.viewers.ViewerCell; |
| import org.eclipse.jface.viewers.ViewerComparator; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.BusyIndicator; |
| import org.eclipse.swt.events.ControlEvent; |
| import org.eclipse.swt.events.ControlListener; |
| import org.eclipse.swt.events.PaintEvent; |
| import org.eclipse.swt.events.PaintListener; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.SelectionListener; |
| import org.eclipse.swt.events.TreeEvent; |
| import org.eclipse.swt.events.TreeListener; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Tree; |
| import org.eclipse.swt.widgets.TreeColumn; |
| import org.eclipse.swt.widgets.TreeItem; |
| import org.eclipse.ui.IMemento; |
| import org.eclipse.ui.IWorkbenchPartSite; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.progress.IWorkbenchSiteProgressService; |
| import org.eclipse.ui.progress.WorkbenchJob; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * A tree-table widget which shows a list of lint warnings for an underlying |
| * {@link IResource} such as a file, a project, or a list of projects. |
| */ |
| class LintList extends Composite implements IResourceChangeListener, ControlListener { |
| private static final Object UPDATE_MARKERS_FAMILY = new Object(); |
| |
| // For persistence: |
| private static final String KEY_WIDTHS = "lintColWidth"; //$NON-NLS-1$ |
| private static final String KEY_VISIBLE = "lintColVisible"; //$NON-NLS-1$ |
| // Mapping SWT TreeColumns to LintColumns |
| private static final String KEY_COLUMN = "lintColumn"; //$NON-NLS-1$ |
| |
| private final IWorkbenchPartSite mSite; |
| private final TreeViewer mTreeViewer; |
| private final Tree mTree; |
| private Set<String> mExpandedIds; |
| private ContentProvider mContentProvider; |
| private String mSelectedId; |
| private List<? extends IResource> mResources; |
| private Configuration mConfiguration; |
| private final boolean mSingleFile; |
| private int mErrorCount; |
| private int mWarningCount; |
| private final UpdateMarkersJob mUpdateMarkersJob = new UpdateMarkersJob(); |
| private final IssueRegistry mRegistry; |
| private final IMemento mMemento; |
| private final LintColumn mMessageColumn = new LintColumn.MessageColumn(this); |
| private final LintColumn mLineColumn = new LintColumn.LineColumn(this); |
| private final LintColumn[] mColumns = new LintColumn[] { |
| mMessageColumn, |
| new LintColumn.PriorityColumn(this), |
| new LintColumn.CategoryColumn(this), |
| new LintColumn.LocationColumn(this), |
| new LintColumn.FileColumn(this), |
| new LintColumn.PathColumn(this), |
| mLineColumn |
| }; |
| private LintColumn[] mVisibleColumns; |
| |
| LintList(IWorkbenchPartSite site, Composite parent, IMemento memento, boolean singleFile) { |
| super(parent, SWT.NONE); |
| mSingleFile = singleFile; |
| mMemento = memento; |
| mSite = site; |
| mRegistry = EclipseLintClient.getRegistry(); |
| |
| GridLayout gridLayout = new GridLayout(1, false); |
| gridLayout.marginWidth = 0; |
| gridLayout.marginHeight = 0; |
| setLayout(gridLayout); |
| |
| mTreeViewer = new TreeViewer(this, SWT.BORDER | SWT.FULL_SELECTION | SWT.MULTI); |
| mTree = mTreeViewer.getTree(); |
| mTree.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1)); |
| |
| createColumns(); |
| mTreeViewer.setComparator(new TableComparator()); |
| setSortIndicators(); |
| |
| mContentProvider = new ContentProvider(); |
| mTreeViewer.setContentProvider(mContentProvider); |
| |
| mTree.setLinesVisible(true); |
| mTree.setHeaderVisible(true); |
| mTree.addControlListener(this); |
| |
| ResourcesPlugin.getWorkspace().addResourceChangeListener( |
| this, |
| IResourceChangeEvent.POST_CHANGE |
| | IResourceChangeEvent.PRE_BUILD |
| | IResourceChangeEvent.POST_BUILD); |
| |
| // Workaround for https://bugs.eclipse.org/341865 |
| mTree.addPaintListener(new PaintListener() { |
| @Override |
| public void paintControl(PaintEvent e) { |
| mTreePainted = true; |
| mTreeViewer.getTree().removePaintListener(this); |
| } |
| }); |
| |
| // Remember the most recently selected id category such that we can |
| // attempt to reselect it after a refresh |
| mTree.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| List<IMarker> markers = getSelectedMarkers(); |
| if (markers.size() > 0) { |
| mSelectedId = EclipseLintClient.getId(markers.get(0)); |
| } |
| } |
| }); |
| mTree.addTreeListener(new TreeListener() { |
| @Override |
| public void treeExpanded(TreeEvent e) { |
| Object data = e.item.getData(); |
| if (data instanceof IMarker) { |
| String id = EclipseLintClient.getId((IMarker) data); |
| if (id != null) { |
| if (mExpandedIds == null) { |
| mExpandedIds = new HashSet<String>(); |
| } |
| mExpandedIds.add(id); |
| } |
| } |
| } |
| |
| @Override |
| public void treeCollapsed(TreeEvent e) { |
| if (mExpandedIds != null) { |
| Object data = e.item.getData(); |
| if (data instanceof IMarker) { |
| String id = EclipseLintClient.getId((IMarker) data); |
| if (id != null) { |
| mExpandedIds.remove(id); |
| } |
| } |
| } |
| } |
| }); |
| } |
| |
| private boolean mTreePainted; |
| |
| private void updateColumnWidths() { |
| Rectangle r = mTree.getClientArea(); |
| int availableWidth = r.width; |
| // Add all available size to the first column |
| for (int i = 1; i < mTree.getColumnCount(); i++) { |
| TreeColumn column = mTree.getColumn(i); |
| availableWidth -= column.getWidth(); |
| } |
| if (availableWidth > 100) { |
| mTree.getColumn(0).setWidth(availableWidth); |
| } |
| } |
| |
| public void setResources(List<? extends IResource> resources) { |
| mResources = resources; |
| |
| mConfiguration = null; |
| for (IResource resource : mResources) { |
| IProject project = resource.getProject(); |
| if (project != null) { |
| // For logging only |
| LintClient client = new EclipseLintClient(null, null, null, false); |
| mConfiguration = ProjectLintConfiguration.get(client, project, false); |
| break; |
| } |
| } |
| if (mConfiguration == null) { |
| mConfiguration = GlobalLintConfiguration.get(); |
| } |
| |
| List<IMarker> markerList = getMarkers(); |
| mTreeViewer.setInput(markerList); |
| if (mSingleFile) { |
| expandAll(); |
| } |
| |
| // Selecting the first item isn't a good idea since it may not be the first |
| // item shown in the table (since it does its own sorting), and furthermore we |
| // may not have all the data yet; this is called when scanning begins, not when |
| // it's done: |
| //if (mTree.getItemCount() > 0) { |
| // mTree.select(mTree.getItem(0)); |
| //} |
| |
| updateColumnWidths(); // in case mSingleFile changed |
| } |
| |
| /** Select the first item */ |
| public void selectFirst() { |
| if (mTree.getItemCount() > 0) { |
| mTree.select(mTree.getItem(0)); |
| } |
| } |
| |
| private List<IMarker> getMarkers() { |
| mErrorCount = mWarningCount = 0; |
| List<IMarker> markerList = new ArrayList<IMarker>(); |
| if (mResources != null) { |
| for (IResource resource : mResources) { |
| IMarker[] markers = EclipseLintClient.getMarkers(resource); |
| for (IMarker marker : markers) { |
| markerList.add(marker); |
| int severity = marker.getAttribute(IMarker.SEVERITY, 0); |
| if (severity == IMarker.SEVERITY_ERROR) { |
| mErrorCount++; |
| } else if (severity == IMarker.SEVERITY_WARNING) { |
| mWarningCount++; |
| } |
| } |
| } |
| |
| // No need to sort the marker list here; it will be sorted by the tree table model |
| } |
| return markerList; |
| } |
| |
| public int getErrorCount() { |
| return mErrorCount; |
| } |
| |
| public int getWarningCount() { |
| return mWarningCount; |
| } |
| |
| @Override |
| protected void checkSubclass() { |
| // Disable the check that prevents subclassing of SWT components |
| } |
| |
| public void addSelectionListener(SelectionListener listener) { |
| mTree.addSelectionListener(listener); |
| } |
| |
| public void refresh() { |
| mTreeViewer.refresh(); |
| } |
| |
| public List<IMarker> getSelectedMarkers() { |
| TreeItem[] selection = mTree.getSelection(); |
| List<IMarker> markers = new ArrayList<IMarker>(selection.length); |
| for (TreeItem item : selection) { |
| Object data = item.getData(); |
| if (data instanceof IMarker) { |
| markers.add((IMarker) data); |
| } |
| } |
| |
| return markers; |
| } |
| |
| @Override |
| public void dispose() { |
| cancelJobs(); |
| ResourcesPlugin.getWorkspace().removeResourceChangeListener(this); |
| super.dispose(); |
| } |
| |
| private class ContentProvider extends TreeNodeContentProvider { |
| private Map<Object, Object[]> mChildren; |
| private Map<IMarker, Integer> mTypeCount; |
| private IMarker[] mTopLevels; |
| |
| @Override |
| public Object[] getElements(Object inputElement) { |
| if (inputElement == null) { |
| mTypeCount = null; |
| return new IMarker[0]; |
| } |
| |
| @SuppressWarnings("unchecked") |
| List<IMarker> list = (List<IMarker>) inputElement; |
| |
| // Partition the children such that at the top level we have one |
| // marker of each type, and below we have all the duplicates of |
| // each one of those errors. And for errors with multiple locations, |
| // there is a third level. |
| Multimap<String, IMarker> types = ArrayListMultimap.<String, IMarker>create(100, 20); |
| for (IMarker marker : list) { |
| String id = EclipseLintClient.getId(marker); |
| types.put(id, marker); |
| } |
| |
| Set<String> ids = types.keySet(); |
| |
| mChildren = new HashMap<Object, Object[]>(ids.size()); |
| mTypeCount = new HashMap<IMarker, Integer>(ids.size()); |
| |
| List<IMarker> topLevel = new ArrayList<IMarker>(ids.size()); |
| for (String id : ids) { |
| Collection<IMarker> markers = types.get(id); |
| int childCount = markers.size(); |
| |
| // Must sort the list items in order to have a stable first item |
| // (otherwise preserving expanded paths etc won't work) |
| TableComparator sorter = getTableSorter(); |
| IMarker[] array = markers.toArray(new IMarker[markers.size()]); |
| sorter.sort(mTreeViewer, array); |
| |
| IMarker topMarker = array[0]; |
| mTypeCount.put(topMarker, childCount); |
| topLevel.add(topMarker); |
| |
| IMarker[] children = Arrays.copyOfRange(array, 1, array.length); |
| mChildren.put(topMarker, children); |
| } |
| |
| mTopLevels = topLevel.toArray(new IMarker[topLevel.size()]); |
| return mTopLevels; |
| } |
| |
| @Override |
| public boolean hasChildren(Object element) { |
| Object[] children = mChildren != null ? mChildren.get(element) : null; |
| return children != null && children.length > 0; |
| } |
| |
| @Override |
| public Object[] getChildren(Object parentElement) { |
| Object[] children = mChildren.get(parentElement); |
| if (children != null) { |
| return children; |
| } |
| |
| return new Object[0]; |
| } |
| |
| @Override |
| public Object getParent(Object element) { |
| return null; |
| } |
| |
| public int getCount(IMarker marker) { |
| if (mTypeCount != null) { |
| Integer count = mTypeCount.get(marker); |
| if (count != null) { |
| return count.intValue(); |
| } |
| } |
| |
| return -1; |
| } |
| |
| IMarker[] getTopMarkers() { |
| return mTopLevels; |
| } |
| } |
| |
| private class LintColumnLabelProvider extends StyledCellLabelProvider { |
| private LintColumn mColumn; |
| |
| LintColumnLabelProvider(LintColumn column) { |
| mColumn = column; |
| } |
| |
| @Override |
| public void update(ViewerCell cell) { |
| Object element = cell.getElement(); |
| cell.setImage(mColumn.getImage((IMarker) element)); |
| StyledString styledString = mColumn.getStyledValue((IMarker) element); |
| if (styledString == null) { |
| cell.setText(mColumn.getValue((IMarker) element)); |
| cell.setStyleRanges(null); |
| } else { |
| cell.setText(styledString.toString()); |
| cell.setStyleRanges(styledString.getStyleRanges()); |
| } |
| super.update(cell); |
| } |
| } |
| |
| TreeViewer getTreeViewer() { |
| return mTreeViewer; |
| } |
| |
| Tree getTree() { |
| return mTree; |
| } |
| |
| // ---- Implements IResourceChangeListener ---- |
| |
| @Override |
| public void resourceChanged(IResourceChangeEvent event) { |
| if (mResources == null) { |
| return; |
| } |
| IMarkerDelta[] deltas = event.findMarkerDeltas(AdtConstants.MARKER_LINT, true); |
| if (deltas.length > 0) { |
| // Update immediately for POST_BUILD events, otherwise do an unconditional |
| // update after 30 seconds. This matches the logic in Eclipse's ProblemView |
| // (see the MarkerView class). |
| if (event.getType() == IResourceChangeEvent.POST_BUILD) { |
| cancelJobs(); |
| getProgressService().schedule(mUpdateMarkersJob, 100); |
| } else { |
| IWorkbenchSiteProgressService progressService = getProgressService(); |
| if (progressService == null) { |
| mUpdateMarkersJob.schedule(30000); |
| } else { |
| getProgressService().schedule(mUpdateMarkersJob, 30000); |
| } |
| } |
| } |
| } |
| |
| // ---- Implements ControlListener ---- |
| |
| @Override |
| public void controlMoved(ControlEvent e) { |
| } |
| |
| @Override |
| public void controlResized(ControlEvent e) { |
| updateColumnWidths(); |
| } |
| |
| // ---- Updating Markers ---- |
| |
| private void cancelJobs() { |
| mUpdateMarkersJob.cancel(); |
| } |
| |
| protected IWorkbenchSiteProgressService getProgressService() { |
| if (mSite != null) { |
| Object siteService = mSite.getAdapter(IWorkbenchSiteProgressService.class); |
| if (siteService != null) { |
| return (IWorkbenchSiteProgressService) siteService; |
| } |
| } |
| return null; |
| } |
| |
| private class UpdateMarkersJob extends WorkbenchJob { |
| UpdateMarkersJob() { |
| super("Updating Lint Markers"); |
| setSystem(true); |
| } |
| |
| @Override |
| public IStatus runInUIThread(IProgressMonitor monitor) { |
| if (mTree.isDisposed()) { |
| return Status.CANCEL_STATUS; |
| } |
| |
| mTreeViewer.setInput(null); |
| List<IMarker> markerList = getMarkers(); |
| if (markerList.size() == 0) { |
| LayoutEditorDelegate delegate = |
| LayoutEditorDelegate.fromEditor(AdtUtils.getActiveEditor()); |
| if (delegate != null) { |
| GraphicalEditorPart g = delegate.getGraphicalEditor(); |
| assert g != null; |
| LayoutActionBar bar = g == null ? null : g.getLayoutActionBar(); |
| assert bar != null; |
| if (bar != null) { |
| bar.updateErrorIndicator(); |
| } |
| } |
| } |
| // Trigger selection update |
| Event updateEvent = new Event(); |
| updateEvent.widget = mTree; |
| mTree.notifyListeners(SWT.Selection, updateEvent); |
| mTreeViewer.setInput(markerList); |
| mTreeViewer.refresh(); |
| |
| if (mExpandedIds != null) { |
| List<IMarker> expanded = new ArrayList<IMarker>(mExpandedIds.size()); |
| IMarker[] topMarkers = mContentProvider.getTopMarkers(); |
| if (topMarkers != null) { |
| for (IMarker marker : topMarkers) { |
| String id = EclipseLintClient.getId(marker); |
| if (id != null && mExpandedIds.contains(id)) { |
| expanded.add(marker); |
| } |
| } |
| } |
| if (!expanded.isEmpty()) { |
| mTreeViewer.setExpandedElements(expanded.toArray()); |
| } |
| } |
| |
| if (mSelectedId != null) { |
| IMarker[] topMarkers = mContentProvider.getTopMarkers(); |
| for (IMarker marker : topMarkers) { |
| if (mSelectedId.equals(EclipseLintClient.getId(marker))) { |
| mTreeViewer.setSelection(new StructuredSelection(marker), true /*reveal*/); |
| break; |
| } |
| } |
| } |
| |
| return Status.OK_STATUS; |
| } |
| |
| @Override |
| public boolean shouldRun() { |
| // Do not run if the change came in before there is a viewer |
| return PlatformUI.isWorkbenchRunning(); |
| } |
| |
| @Override |
| public boolean belongsTo(Object family) { |
| return UPDATE_MARKERS_FAMILY == family; |
| } |
| } |
| |
| /** |
| * Returns the list of resources being shown in the list |
| * |
| * @return the list of resources being shown in this composite |
| */ |
| public List<? extends IResource> getResources() { |
| return mResources; |
| } |
| |
| /** Expands all nodes */ |
| public void expandAll() { |
| mTreeViewer.expandAll(); |
| |
| if (mExpandedIds == null) { |
| mExpandedIds = new HashSet<String>(); |
| } |
| IMarker[] topMarkers = mContentProvider.getTopMarkers(); |
| if (topMarkers != null) { |
| for (IMarker marker : topMarkers) { |
| String id = EclipseLintClient.getId(marker); |
| if (id != null) { |
| mExpandedIds.add(id); |
| } |
| } |
| } |
| } |
| |
| /** Collapses all nodes */ |
| public void collapseAll() { |
| mTreeViewer.collapseAll(); |
| mExpandedIds = null; |
| } |
| |
| // ---- Column Persistence ---- |
| |
| public void saveState(IMemento memento) { |
| if (mSingleFile) { |
| // Don't use persistence for single-file lists: this is a special mode of the |
| // window where we show a hardcoded set of columns for a single file, deliberately |
| // omitting the location column etc |
| return; |
| } |
| |
| IMemento columnEntry = memento.createChild(KEY_WIDTHS); |
| LintColumn[] columns = new LintColumn[mTree.getColumnCount()]; |
| int[] positions = mTree.getColumnOrder(); |
| for (int i = 0; i < columns.length; i++) { |
| TreeColumn treeColumn = mTree.getColumn(i); |
| LintColumn column = (LintColumn) treeColumn.getData(KEY_COLUMN); |
| // Workaround for TeeColumn.getWidth() returning 0 in some cases, |
| // see https://bugs.eclipse.org/341865 for details. |
| int width = getColumnWidth(column, mTreePainted); |
| columnEntry.putInteger(getKey(treeColumn), width); |
| columns[positions[i]] = column; |
| } |
| |
| if (getVisibleColumns() != null) { |
| IMemento visibleEntry = memento.createChild(KEY_VISIBLE); |
| for (LintColumn column : getVisibleColumns()) { |
| visibleEntry.putBoolean(getKey(column), true); |
| } |
| } |
| } |
| |
| private void createColumns() { |
| LintColumn[] columns = getVisibleColumns(); |
| TableLayout layout = new TableLayout(); |
| |
| for (int i = 0; i < columns.length; i++) { |
| LintColumn column = columns[i]; |
| TreeViewerColumn viewerColumn = null; |
| TreeColumn treeColumn; |
| viewerColumn = new TreeViewerColumn(mTreeViewer, SWT.NONE); |
| treeColumn = viewerColumn.getColumn(); |
| treeColumn.setData(KEY_COLUMN, column); |
| treeColumn.setResizable(true); |
| treeColumn.addSelectionListener(getHeaderListener()); |
| if (!column.isLeftAligned()) { |
| treeColumn.setAlignment(SWT.RIGHT); |
| } |
| viewerColumn.setLabelProvider(new LintColumnLabelProvider(column)); |
| treeColumn.setText(column.getColumnHeaderText()); |
| treeColumn.setImage(column.getColumnHeaderImage()); |
| IMemento columnWidths = null; |
| if (mMemento != null && !mSingleFile) { |
| columnWidths = mMemento.getChild(KEY_WIDTHS); |
| } |
| int columnWidth = getColumnWidth(column, false); |
| if (columnWidths != null) { |
| columnWidths.putInteger(getKey(column), columnWidth); |
| } |
| if (i == 0) { |
| // The first column should use layout -weights- to get all the |
| // remaining room |
| layout.addColumnData(new ColumnWeightData(1, true)); |
| } else if (columnWidth < 0) { |
| int defaultColumnWidth = column.getPreferredWidth(); |
| layout.addColumnData(new ColumnPixelData(defaultColumnWidth, true, true)); |
| } else { |
| layout.addColumnData(new ColumnPixelData(columnWidth, true)); |
| } |
| } |
| mTreeViewer.getTree().setLayout(layout); |
| mTree.layout(true); |
| } |
| |
| private int getColumnWidth(LintColumn column, boolean getFromUi) { |
| Tree tree = mTreeViewer.getTree(); |
| if (getFromUi) { |
| TreeColumn[] columns = tree.getColumns(); |
| for (int i = 0; i < columns.length; i++) { |
| if (column.equals(columns[i].getData(KEY_COLUMN))) { |
| return columns[i].getWidth(); |
| } |
| } |
| } |
| int preferredWidth = -1; |
| if (mMemento != null && !mSingleFile) { |
| IMemento columnWidths = mMemento.getChild(KEY_WIDTHS); |
| if (columnWidths != null) { |
| Integer value = columnWidths.getInteger(getKey(column)); |
| // Make sure we get a useful value |
| if (value != null && value.intValue() >= 0) |
| preferredWidth = value.intValue(); |
| } |
| } |
| if (preferredWidth <= 0) { |
| preferredWidth = Math.max(column.getPreferredWidth(), 30); |
| } |
| return preferredWidth; |
| } |
| |
| private static String getKey(TreeColumn treeColumn) { |
| return getKey((LintColumn) treeColumn.getData(KEY_COLUMN)); |
| } |
| |
| private static String getKey(LintColumn column) { |
| return column.getClass().getSimpleName(); |
| } |
| |
| private LintColumn[] getVisibleColumns() { |
| if (mVisibleColumns == null) { |
| if (mSingleFile) { |
| // Special mode where we show just lint warnings for a single file: |
| // use a hardcoded list of columns, not including path/location etc but |
| // including line numbers (which are normally not shown by default). |
| mVisibleColumns = new LintColumn[] { |
| mMessageColumn, mLineColumn |
| }; |
| } else { |
| // Generate visible columns based on (a) previously saved window state, |
| // and (b) default window visible states provided by the columns themselves |
| List<LintColumn> list = new ArrayList<LintColumn>(); |
| IMemento visibleColumns = null; |
| if (mMemento != null) { |
| visibleColumns = mMemento.getChild(KEY_VISIBLE); |
| } |
| for (LintColumn column : mColumns) { |
| if (visibleColumns != null) { |
| Boolean b = visibleColumns.getBoolean(getKey(column)); |
| if (b != null && b.booleanValue()) { |
| list.add(column); |
| } |
| } else if (column.visibleByDefault()) { |
| list.add(column); |
| } |
| } |
| if (!list.contains(mMessageColumn)) { |
| list.add(0, mMessageColumn); |
| } |
| mVisibleColumns = list.toArray(new LintColumn[list.size()]); |
| } |
| } |
| |
| return mVisibleColumns; |
| } |
| |
| int getCount(IMarker marker) { |
| return mContentProvider.getCount(marker); |
| } |
| |
| Issue getIssue(String id) { |
| return mRegistry.getIssue(id); |
| } |
| |
| Issue getIssue(IMarker marker) { |
| String id = EclipseLintClient.getId(marker); |
| return mRegistry.getIssue(id); |
| } |
| |
| Severity getSeverity(Issue issue) { |
| return mConfiguration.getSeverity(issue); |
| } |
| |
| // ---- Choosing visible columns ---- |
| |
| public void configureColumns() { |
| ColumnDialog dialog = new ColumnDialog(getShell(), mColumns, getVisibleColumns()); |
| if (dialog.open() == Window.OK) { |
| mVisibleColumns = dialog.getSelectedColumns(); |
| // Clear out columns: Must recreate to set the right label provider etc |
| for (TreeColumn column : mTree.getColumns()) { |
| column.dispose(); |
| } |
| createColumns(); |
| mTreeViewer.setComparator(new TableComparator()); |
| setSortIndicators(); |
| mTreeViewer.refresh(); |
| } |
| } |
| |
| // ---- Table Sorting ---- |
| |
| private SelectionListener getHeaderListener() { |
| return new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| final TreeColumn treeColumn = (TreeColumn) e.widget; |
| final LintColumn column = (LintColumn) treeColumn.getData(KEY_COLUMN); |
| |
| try { |
| IWorkbenchSiteProgressService progressService = getProgressService(); |
| if (progressService == null) { |
| BusyIndicator.showWhile(getShell().getDisplay(), new Runnable() { |
| @Override |
| public void run() { |
| resortTable(treeColumn, column, |
| new NullProgressMonitor()); |
| } |
| }); |
| } else { |
| getProgressService().busyCursorWhile(new IRunnableWithProgress() { |
| @Override |
| public void run(IProgressMonitor monitor) { |
| resortTable(treeColumn, column, monitor); |
| } |
| }); |
| } |
| } catch (InvocationTargetException e1) { |
| AdtPlugin.log(e1, null); |
| } catch (InterruptedException e1) { |
| return; |
| } |
| } |
| |
| private void resortTable(final TreeColumn treeColumn, LintColumn column, |
| IProgressMonitor monitor) { |
| TableComparator sorter = getTableSorter(); |
| monitor.beginTask("Sorting", 100); |
| monitor.worked(10); |
| if (column.equals(sorter.getTopColumn())) { |
| sorter.reverseTopPriority(); |
| } else { |
| sorter.setTopPriority(column); |
| } |
| monitor.worked(15); |
| PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| mTreeViewer.refresh(); |
| updateDirectionIndicator(treeColumn); |
| } |
| }); |
| monitor.done(); |
| } |
| }; |
| } |
| |
| private void setSortIndicators() { |
| LintColumn top = getTableSorter().getTopColumn(); |
| TreeColumn[] columns = mTreeViewer.getTree().getColumns(); |
| for (int i = 0; i < columns.length; i++) { |
| TreeColumn column = columns[i]; |
| if (column.getData(KEY_COLUMN).equals(top)) { |
| updateDirectionIndicator(column); |
| return; |
| } |
| } |
| } |
| |
| private void updateDirectionIndicator(TreeColumn column) { |
| Tree tree = mTreeViewer.getTree(); |
| tree.setSortColumn(column); |
| if (getTableSorter().isAscending()) { |
| tree.setSortDirection(SWT.UP); |
| } else { |
| tree.setSortDirection(SWT.DOWN); |
| } |
| } |
| |
| private TableComparator getTableSorter() { |
| return (TableComparator) mTreeViewer.getComparator(); |
| } |
| |
| /** Comparator used to sort the {@link LintList} tree. |
| * <p> |
| * This code is simplified from similar code in |
| * org.eclipse.ui.views.markers.internal.TableComparator |
| */ |
| private class TableComparator extends ViewerComparator { |
| private int[] mPriorities; |
| private boolean[] mDirections; |
| private int[] mDefaultPriorities; |
| private boolean[] mDefaultDirections; |
| |
| private TableComparator() { |
| int[] defaultPriorities = new int[mColumns.length]; |
| for (int i = 0; i < defaultPriorities.length; i++) { |
| defaultPriorities[i] = i; |
| } |
| mPriorities = defaultPriorities; |
| |
| boolean[] directions = new boolean[mColumns.length]; |
| for (int i = 0; i < directions.length; i++) { |
| directions[i] = mColumns[i].isAscending(); |
| } |
| mDirections = directions; |
| |
| mDefaultPriorities = new int[defaultPriorities.length]; |
| System.arraycopy(defaultPriorities, 0, this.mDefaultPriorities, 0, |
| defaultPriorities.length); |
| mDefaultDirections = new boolean[directions.length]; |
| System.arraycopy(directions, 0, this.mDefaultDirections, 0, directions.length); |
| } |
| |
| private void resetState() { |
| System.arraycopy(mDefaultPriorities, 0, mPriorities, 0, mPriorities.length); |
| System.arraycopy(mDefaultDirections, 0, mDirections, 0, mDirections.length); |
| } |
| |
| private void reverseTopPriority() { |
| mDirections[mPriorities[0]] = !mDirections[mPriorities[0]]; |
| } |
| |
| private void setTopPriority(LintColumn property) { |
| for (int i = 0; i < mColumns.length; i++) { |
| if (mColumns[i].equals(property)) { |
| setTopPriority(i); |
| return; |
| } |
| } |
| } |
| |
| private void setTopPriority(int priority) { |
| if (priority < 0 || priority >= mPriorities.length) { |
| return; |
| } |
| int index = -1; |
| for (int i = 0; i < mPriorities.length; i++) { |
| if (mPriorities[i] == priority) { |
| index = i; |
| } |
| } |
| if (index == -1) { |
| resetState(); |
| return; |
| } |
| // shift the array |
| for (int i = index; i > 0; i--) { |
| mPriorities[i] = mPriorities[i - 1]; |
| } |
| mPriorities[0] = priority; |
| mDirections[priority] = mDefaultDirections[priority]; |
| } |
| |
| private boolean isAscending() { |
| return mDirections[mPriorities[0]]; |
| } |
| |
| private int getTopPriority() { |
| return mPriorities[0]; |
| } |
| |
| private LintColumn getTopColumn() { |
| return mColumns[getTopPriority()]; |
| } |
| |
| @Override |
| public int compare(Viewer viewer, Object e1, Object e2) { |
| return compare((IMarker) e1, (IMarker) e2, 0, true); |
| } |
| |
| private int compare(IMarker marker1, IMarker marker2, int depth, |
| boolean continueSearching) { |
| if (depth >= mPriorities.length) { |
| return 0; |
| } |
| int column = mPriorities[depth]; |
| LintColumn property = mColumns[column]; |
| int result = property.compare(marker1, marker2); |
| if (result == 0 && continueSearching) { |
| return compare(marker1, marker2, depth + 1, continueSearching); |
| } |
| return result * (mDirections[column] ? 1 : -1); |
| } |
| } |
| } |
