| /* |
| * 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.preferences; |
| |
| import static com.android.tools.lint.detector.api.TextFormat.RAW; |
| import static com.android.tools.lint.detector.api.TextFormat.TEXT; |
| |
| import com.android.annotations.NonNull; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.AdtUtils; |
| import com.android.ide.eclipse.adt.internal.lint.EclipseLintClient; |
| import com.android.ide.eclipse.adt.internal.lint.EclipseLintRunner; |
| import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper; |
| import com.android.tools.lint.client.api.Configuration; |
| import com.android.tools.lint.client.api.IssueRegistry; |
| import com.android.tools.lint.detector.api.Category; |
| import com.android.tools.lint.detector.api.Issue; |
| import com.android.tools.lint.detector.api.Project; |
| import com.android.tools.lint.detector.api.Severity; |
| import com.android.tools.lint.detector.api.TextFormat; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.viewers.IColorProvider; |
| import org.eclipse.jface.viewers.ILabelProviderListener; |
| import org.eclipse.jface.viewers.ITableLabelProvider; |
| 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.window.Window; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.ControlEvent; |
| import org.eclipse.swt.events.ControlListener; |
| import org.eclipse.swt.events.ModifyEvent; |
| import org.eclipse.swt.events.ModifyListener; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.SelectionListener; |
| import org.eclipse.swt.events.TraverseEvent; |
| import org.eclipse.swt.events.TraverseListener; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Combo; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Link; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.swt.widgets.Tree; |
| import org.eclipse.swt.widgets.TreeColumn; |
| import org.eclipse.swt.widgets.TreeItem; |
| import org.eclipse.ui.ISharedImages; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchPreferencePage; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.dialogs.PreferencesUtil; |
| import org.eclipse.ui.dialogs.PropertyPage; |
| |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| |
| /** Preference page for configuring Lint preferences */ |
| public class LintPreferencePage extends PropertyPage implements IWorkbenchPreferencePage, |
| SelectionListener, ControlListener, ModifyListener { |
| private static final String ID = |
| "com.android.ide.eclipse.common.preferences.LintPreferencePage"; //$NON-NLS-1$ |
| private static final int ID_COLUMN_WIDTH = 150; |
| |
| private EclipseLintClient mClient; |
| private IssueRegistry mRegistry; |
| private Configuration mConfiguration; |
| private IProject mProject; |
| private Map<Issue, Severity> mSeverities = new HashMap<Issue, Severity>(); |
| private Map<Issue, Severity> mInitialSeverities = Collections.<Issue, Severity>emptyMap(); |
| private boolean mIgnoreEvent; |
| |
| private Tree mTree; |
| private TreeViewer mTreeViewer; |
| private Text mDetailsText; |
| private Button mCheckFileCheckbox; |
| private Button mCheckExportCheckbox; |
| private Link mWorkspaceLink; |
| private TreeColumn mNameColumn; |
| private TreeColumn mIdColumn; |
| private Combo mSeverityCombo; |
| private Button mIncludeAll; |
| private Button mIgnoreAll; |
| private Text mSearch; |
| |
| /** |
| * Create the preference page. |
| */ |
| public LintPreferencePage() { |
| setPreferenceStore(AdtPlugin.getDefault().getPreferenceStore()); |
| } |
| |
| @Override |
| public Control createContents(Composite parent) { |
| IAdaptable resource = getElement(); |
| if (resource != null) { |
| mProject = (IProject) resource.getAdapter(IProject.class); |
| } |
| |
| Composite container = new Composite(parent, SWT.NULL); |
| container.setLayout(new GridLayout(2, false)); |
| |
| if (mProject != null) { |
| Label projectLabel = new Label(container, SWT.CHECK); |
| projectLabel.setLayoutData(new GridData(SWT.LEFT, SWT.BOTTOM, false, false, 1, |
| 1)); |
| projectLabel.setText("Project-specific configuration:"); |
| |
| mWorkspaceLink = new Link(container, SWT.NONE); |
| mWorkspaceLink.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1)); |
| mWorkspaceLink.setText("<a>Configure Workspace Settings...</a>"); |
| mWorkspaceLink.addSelectionListener(this); |
| } else { |
| mCheckFileCheckbox = new Button(container, SWT.CHECK); |
| mCheckFileCheckbox.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, false, false, |
| 2, 1)); |
| mCheckFileCheckbox.setSelection(true); |
| mCheckFileCheckbox.setText("When saving files, check for errors"); |
| |
| mCheckExportCheckbox = new Button(container, SWT.CHECK); |
| mCheckExportCheckbox.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, false, false, |
| 2, 1)); |
| mCheckExportCheckbox.setSelection(true); |
| mCheckExportCheckbox.setText("Run full error check when exporting app and abort if fatal errors are found"); |
| |
| Label separator = new Label(container, SWT.SEPARATOR | SWT.HORIZONTAL); |
| separator.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 2, 1)); |
| |
| Label checkListLabel = new Label(container, SWT.NONE); |
| checkListLabel.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, false, false, 2, 1)); |
| checkListLabel.setText("Issues:"); |
| } |
| |
| mRegistry = EclipseLintClient.getRegistry(); |
| mClient = new EclipseLintClient(mRegistry, |
| mProject != null ? Collections.singletonList(mProject) : null, null, false); |
| Project project = null; |
| if (mProject != null) { |
| File dir = AdtUtils.getAbsolutePath(mProject).toFile(); |
| project = mClient.getProject(dir, dir); |
| } |
| mConfiguration = mClient.getConfigurationFor(project); |
| |
| mSearch = new Text(container, SWT.SEARCH | SWT.ICON_CANCEL | SWT.ICON_SEARCH); |
| mSearch.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1)); |
| mSearch.addSelectionListener(this); |
| mSearch.addModifyListener(this); |
| // Grab the Enter key such that pressing return in the search box filters (instead |
| // of closing the options dialog) |
| mSearch.setMessage("type filter text (use ~ to filter by severity, e.g. ~ignore)"); |
| mSearch.addTraverseListener(new TraverseListener() { |
| @Override |
| public void keyTraversed(TraverseEvent e) { |
| if (e.keyCode == SWT.CR) { |
| updateFilter(); |
| e.doit = false; |
| } else if (e.keyCode == SWT.ARROW_DOWN) { |
| // Allow moving from the search into the table |
| if (mTree.getItemCount() > 0) { |
| TreeItem firstCategory = mTree.getItem(0); |
| if (firstCategory.getItemCount() > 0) { |
| TreeItem first = firstCategory.getItem(0); |
| mTree.setFocus(); |
| mTree.select(first); |
| } |
| } |
| } |
| } |
| }); |
| |
| mTreeViewer = new TreeViewer(container, SWT.BORDER | SWT.FULL_SELECTION); |
| mTree = mTreeViewer.getTree(); |
| GridData gdTable = new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1); |
| gdTable.widthHint = 500; |
| gdTable.heightHint = 160; |
| mTree.setLayoutData(gdTable); |
| mTree.setLinesVisible(true); |
| mTree.setHeaderVisible(true); |
| |
| TreeViewerColumn column1 = new TreeViewerColumn(mTreeViewer, SWT.NONE); |
| mIdColumn = column1.getColumn(); |
| mIdColumn.setWidth(100); |
| mIdColumn.setText("Id"); |
| |
| TreeViewerColumn column2 = new TreeViewerColumn(mTreeViewer, SWT.FILL); |
| mNameColumn = column2.getColumn(); |
| mNameColumn.setWidth(100); |
| mNameColumn.setText("Name"); |
| |
| mTreeViewer.setContentProvider(new ContentProvider()); |
| mTreeViewer.setLabelProvider(new LabelProvider()); |
| |
| mDetailsText = new Text(container, SWT.BORDER | SWT.READ_ONLY | SWT.WRAP |SWT.V_SCROLL |
| | SWT.MULTI); |
| GridData gdText = new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 2); |
| gdText.heightHint = 80; |
| mDetailsText.setLayoutData(gdText); |
| |
| Label severityLabel = new Label(container, SWT.NONE); |
| severityLabel.setText("Severity:"); |
| |
| mSeverityCombo = new Combo(container, SWT.READ_ONLY); |
| mSeverityCombo.setItems(new String[] { |
| "(Default)", "Fatal", "Error", "Warning", "Information", "Ignore" |
| }); |
| GridData gdSeverityCombo = new GridData(SWT.FILL, SWT.TOP, false, false, 1, 1); |
| gdSeverityCombo.widthHint = 90; |
| mSeverityCombo.setLayoutData(gdSeverityCombo); |
| mSeverityCombo.setText(""); |
| mSeverityCombo.addSelectionListener(this); |
| |
| List<Issue> issues = mRegistry.getIssues(); |
| for (Issue issue : issues) { |
| Severity severity = mConfiguration.getSeverity(issue); |
| mSeverities.put(issue, severity); |
| } |
| mInitialSeverities = new HashMap<Issue, Severity>(mSeverities); |
| |
| mTreeViewer.setInput(mRegistry); |
| |
| mTree.addSelectionListener(this); |
| // Add a listener to resize the column to the full width of the table |
| mTree.addControlListener(this); |
| |
| loadSettings(false); |
| |
| mTreeViewer.expandAll(); |
| |
| return container; |
| } |
| |
| /** |
| * Initialize the preference page. |
| */ |
| @Override |
| public void init(IWorkbench workbench) { |
| // Initialize the preference page |
| } |
| |
| @Override |
| protected void contributeButtons(Composite parent) { |
| super.contributeButtons(parent); |
| |
| // Add "Include All" button for quickly enabling all the detectors, including |
| // those disabled by default |
| mIncludeAll = new Button(parent, SWT.PUSH); |
| mIncludeAll.setText("Include All"); |
| mIncludeAll.addSelectionListener(this); |
| |
| // Add "Ignore All" button for quickly disabling all the detectors |
| mIgnoreAll = new Button(parent, SWT.PUSH); |
| mIgnoreAll.setText("Ignore All"); |
| mIgnoreAll.addSelectionListener(this); |
| |
| // As per the contributeButton javadoc: increase parent's column count for each |
| // added button |
| ((GridLayout) parent.getLayout()).numColumns += 2; |
| } |
| |
| @Override |
| public void dispose() { |
| super.dispose(); |
| cancelPendingSearch(); |
| } |
| |
| @Override |
| protected void performDefaults() { |
| super.performDefaults(); |
| |
| mConfiguration.startBulkEditing(); |
| |
| List<Issue> issues = mRegistry.getIssues(); |
| for (Issue issue : issues) { |
| mConfiguration.setSeverity(issue, null); |
| } |
| |
| mConfiguration.finishBulkEditing(); |
| |
| loadSettings(true); |
| } |
| |
| @Override |
| public boolean performOk() { |
| storeSettings(); |
| return true; |
| } |
| |
| private void loadSettings(boolean refresh) { |
| if (mCheckExportCheckbox != null) { |
| AdtPrefs prefs = AdtPrefs.getPrefs(); |
| mCheckFileCheckbox.setSelection(prefs.isLintOnSave()); |
| mCheckExportCheckbox.setSelection(prefs.isLintOnExport()); |
| } |
| |
| mSeverities.clear(); |
| List<Issue> issues = mRegistry.getIssues(); |
| for (Issue issue : issues) { |
| Severity severity = mConfiguration.getSeverity(issue); |
| mSeverities.put(issue, severity); |
| } |
| |
| if (refresh) { |
| mTreeViewer.refresh(); |
| } |
| } |
| |
| private void storeSettings() { |
| // Lint on Save, Lint on Export |
| if (mCheckExportCheckbox != null) { |
| AdtPrefs prefs = AdtPrefs.getPrefs(); |
| prefs.setLintOnExport(mCheckExportCheckbox.getSelection()); |
| prefs.setLintOnSave(mCheckFileCheckbox.getSelection()); |
| } |
| |
| if (mConfiguration == null) { |
| return; |
| } |
| |
| mConfiguration.startBulkEditing(); |
| try { |
| // Severities |
| for (Map.Entry<Issue, Severity> entry : mSeverities.entrySet()) { |
| Issue issue = entry.getKey(); |
| Severity severity = entry.getValue(); |
| if (mConfiguration.getSeverity(issue) != severity) { |
| if ((severity == issue.getDefaultSeverity()) && issue.isEnabledByDefault()) { |
| severity = null; |
| } |
| mConfiguration.setSeverity(issue, severity); |
| } |
| } |
| } finally { |
| mConfiguration.finishBulkEditing(); |
| } |
| |
| if (!mInitialSeverities.equals(mSeverities)) { |
| // Ask user whether we should re-run the rules. |
| MessageDialog dialog = new MessageDialog( |
| null, "Lint Settings Have Changed", null, |
| "The list of enabled checks has changed. Would you like to run lint now " + |
| "to update the results?", |
| MessageDialog.QUESTION, |
| new String[] { |
| "Yes", "No" |
| }, |
| 0); // yes is the default |
| int result = dialog.open(); |
| if (result == 0) { |
| // Run lint on all the open Android projects |
| IWorkspace workspace = ResourcesPlugin.getWorkspace(); |
| IProject[] projects = workspace.getRoot().getProjects(); |
| List<IProject> androidProjects = new ArrayList<IProject>(projects.length); |
| for (IProject project : projects) { |
| if (project.isOpen() && BaseProjectHelper.isAndroidProject(project)) { |
| androidProjects.add(project); |
| } |
| } |
| |
| EclipseLintRunner.startLint(androidProjects, null, null, false /*fatalOnly*/, |
| true /*show*/); |
| } |
| } |
| } |
| |
| private void updateFilter() { |
| cancelPendingSearch(); |
| if (!mSearch.isDisposed()) { |
| // Clear selection before refiltering since otherwise it might be showing |
| // items no longer available in the list. |
| mTree.setSelection(new TreeItem[0]); |
| mDetailsText.setText(""); |
| try { |
| mIgnoreEvent = true; |
| mSeverityCombo.setText(""); |
| mSeverityCombo.setEnabled(false); |
| } finally { |
| mIgnoreEvent = false; |
| } |
| |
| mTreeViewer.getContentProvider().inputChanged(mTreeViewer, null, mRegistry); |
| mTreeViewer.refresh(); |
| mTreeViewer.expandAll(); |
| } |
| } |
| |
| private void cancelPendingSearch() { |
| if (mPendingUpdate != null) { |
| Shell shell = getShell(); |
| if (!shell.isDisposed()) { |
| getShell().getDisplay().timerExec(-1, mPendingUpdate); |
| } |
| mPendingUpdate = null; |
| } |
| } |
| |
| private Runnable mPendingUpdate; |
| |
| private void scheduleSearch() { |
| if (mPendingUpdate == null) { |
| mPendingUpdate = new Runnable() { |
| @Override |
| public void run() { |
| mPendingUpdate = null; |
| updateFilter(); |
| } |
| }; |
| } |
| getShell().getDisplay().timerExec(250 /*ms*/, mPendingUpdate); |
| } |
| |
| // ---- Implements SelectionListener ---- |
| |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| if (mIgnoreEvent) { |
| return; |
| } |
| |
| Object source = e.getSource(); |
| if (source == mTree) { |
| TreeItem item = (TreeItem) e.item; |
| Object data = item != null ? item.getData() : null; |
| if (data instanceof Issue) { |
| Issue issue = (Issue) data; |
| String summary = issue.getBriefDescription(TextFormat.TEXT); |
| String explanation = issue.getExplanation(TextFormat.TEXT); |
| |
| StringBuilder sb = new StringBuilder(summary.length() + explanation.length() + 20); |
| sb.append(summary); |
| sb.append('\n').append('\n'); |
| sb.append(explanation); |
| mDetailsText.setText(sb.toString()); |
| try { |
| mIgnoreEvent = true; |
| Severity severity = getSeverity(issue); |
| mSeverityCombo.select(severity.ordinal() + 1); // Skip the default option |
| mSeverityCombo.setEnabled(true); |
| } finally { |
| mIgnoreEvent = false; |
| } |
| } else { |
| mDetailsText.setText(""); |
| try { |
| mIgnoreEvent = true; |
| mSeverityCombo.setText(""); |
| mSeverityCombo.setEnabled(false); |
| } finally { |
| mIgnoreEvent = false; |
| } |
| } |
| } else if (source == mWorkspaceLink) { |
| int result = PreferencesUtil.createPreferenceDialogOn(getShell(), ID, |
| new String[] { ID }, null).open(); |
| if (result == Window.OK) { |
| loadSettings(true); |
| } |
| } else if (source == mSeverityCombo) { |
| int index = mSeverityCombo.getSelectionIndex(); |
| Issue issue = (Issue) mTree.getSelection()[0].getData(); |
| Severity severity; |
| if (index == -1 || index == 0) { |
| // "(Default)" |
| severity = issue.getDefaultSeverity(); |
| } else { |
| // -1: Skip the "(Default)" |
| severity = Severity.values()[index - 1]; |
| } |
| mSeverities.put(issue, severity); |
| mTreeViewer.refresh(); |
| } else if (source == mIncludeAll) { |
| List<Issue> issues = mRegistry.getIssues(); |
| for (Issue issue : issues) { |
| // The default severity is never ignore; for disabled-by-default |
| // issues the {@link Issue#isEnabledByDefault()} method is false instead |
| mSeverities.put(issue, issue.getDefaultSeverity()); |
| } |
| mTreeViewer.refresh(); |
| } else if (source == mIgnoreAll) { |
| List<Issue> issues = mRegistry.getIssues(); |
| for (Issue issue : issues) { |
| mSeverities.put(issue, Severity.IGNORE); |
| } |
| mTreeViewer.refresh(); |
| } else if (source == mSearch) { |
| updateFilter(); |
| } |
| } |
| |
| private Severity getSeverity(Issue issue) { |
| Severity severity = mSeverities.get(issue); |
| if (severity != null) { |
| return severity; |
| } |
| |
| return mConfiguration.getSeverity(issue); |
| } |
| |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| Object source = e.getSource(); |
| if (source == mTree) { |
| widgetSelected(e); |
| } else if (source == mSearch) { |
| if (e.detail == SWT.CANCEL) { |
| // Cancel the search |
| mSearch.setText(""); |
| } |
| updateFilter(); |
| } |
| } |
| |
| // ---- Implements ModifyListener ---- |
| @Override |
| public void modifyText(ModifyEvent e) { |
| if (e.getSource() == mSearch) { |
| scheduleSearch(); |
| } |
| } |
| |
| // ---- Implements ControlListener ---- |
| |
| @Override |
| public void controlMoved(ControlEvent e) { |
| } |
| |
| @Override |
| public void controlResized(ControlEvent e) { |
| Rectangle r = mTree.getClientArea(); |
| int availableWidth = r.width; |
| |
| mIdColumn.setWidth(ID_COLUMN_WIDTH); |
| availableWidth -= ID_COLUMN_WIDTH; |
| |
| // Name absorbs everything else |
| mNameColumn.setWidth(availableWidth); |
| } |
| |
| private boolean filterMatches(@NonNull String filter, @NonNull Issue issue) { |
| return (filter.startsWith("~") //$NON-NLS-1$ |
| && mConfiguration.getSeverity(issue).getDescription() |
| .toLowerCase(Locale.US).startsWith(filter.substring(1))) |
| || issue.getCategory().getName().toLowerCase(Locale.US).startsWith(filter) |
| || issue.getCategory().getFullName().toLowerCase(Locale.US).startsWith(filter) |
| || issue.getId().toLowerCase(Locale.US).contains(filter) |
| || issue.getBriefDescription(RAW).toLowerCase(Locale.US).contains(filter); |
| } |
| |
| private class ContentProvider extends TreeNodeContentProvider { |
| private Map<Category, List<Issue>> mCategoryToIssues; |
| private Object[] mElements; |
| |
| @Override |
| public Object[] getElements(Object inputElement) { |
| return mElements; |
| } |
| |
| @Override |
| public boolean hasChildren(Object element) { |
| return element instanceof Category; |
| } |
| |
| @Override |
| public Object[] getChildren(Object parentElement) { |
| assert mCategoryToIssues != null; |
| List<Issue> list = mCategoryToIssues.get(parentElement); |
| if (list == null) { |
| return new Object[0]; |
| } else { |
| return list.toArray(); |
| } |
| } |
| |
| @Override |
| public Object getParent(Object element) { |
| return null; |
| } |
| |
| @Override |
| public void inputChanged(final Viewer viewer, final Object oldInput, |
| final Object newInput) { |
| mCategoryToIssues = null; |
| |
| String filter = mSearch.isDisposed() ? "" : mSearch.getText().trim(); |
| if (filter.length() == 0) { |
| filter = null; |
| } else { |
| filter = filter.toLowerCase(Locale.US); |
| } |
| |
| mCategoryToIssues = new HashMap<Category, List<Issue>>(); |
| List<Issue> issues = mRegistry.getIssues(); |
| for (Issue issue : issues) { |
| if (filter == null || filterMatches(filter, issue)) { |
| List<Issue> list = mCategoryToIssues.get(issue.getCategory()); |
| if (list == null) { |
| list = new ArrayList<Issue>(); |
| mCategoryToIssues.put(issue.getCategory(), list); |
| } |
| list.add(issue); |
| } |
| } |
| |
| if (filter == null) { |
| // Not filtering: show all categories |
| mElements = mRegistry.getCategories().toArray(); |
| } else { |
| // Filtering: only include categories that contain matches |
| if (mCategoryToIssues == null) { |
| getChildren(null); |
| } |
| |
| // Preserve the current category order, so instead of |
| // just creating a list of the mCategoryToIssues keyset, add them |
| // in the order they appear in in the registry |
| List<Category> categories = new ArrayList<Category>(mCategoryToIssues.size()); |
| for (Category category : mRegistry.getCategories()) { |
| if (mCategoryToIssues.containsKey(category)) { |
| categories.add(category); |
| } |
| } |
| mElements = categories.toArray(); |
| } |
| } |
| } |
| |
| private class LabelProvider implements ITableLabelProvider, IColorProvider { |
| |
| @Override |
| public void addListener(ILabelProviderListener listener) { |
| } |
| |
| @Override |
| public void dispose() { |
| } |
| |
| @Override |
| public boolean isLabelProperty(Object element, String property) { |
| return true; |
| } |
| |
| @Override |
| public void removeListener(ILabelProviderListener listener) { |
| } |
| |
| @Override |
| public Image getColumnImage(Object element, int columnIndex) { |
| if (element instanceof Category) { |
| return null; |
| } |
| |
| if (columnIndex == 1) { |
| Issue issue = (Issue) element; |
| Severity severity = mSeverities.get(issue); |
| if (severity == null) { |
| return null; |
| } |
| |
| ISharedImages sharedImages = PlatformUI.getWorkbench().getSharedImages(); |
| switch (severity) { |
| case FATAL: |
| case ERROR: |
| return sharedImages.getImage(ISharedImages.IMG_OBJS_ERROR_TSK); |
| case WARNING: |
| return sharedImages.getImage(ISharedImages.IMG_OBJS_WARN_TSK); |
| case INFORMATIONAL: |
| return sharedImages.getImage(ISharedImages.IMG_OBJS_INFO_TSK); |
| case IGNORE: |
| return sharedImages.getImage(ISharedImages.IMG_ELCL_REMOVE_DISABLED); |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public String getColumnText(Object element, int columnIndex) { |
| if (element instanceof Category) { |
| if (columnIndex == 0) { |
| return ((Category) element).getFullName(); |
| } else { |
| return null; |
| } |
| } |
| |
| Issue issue = (Issue) element; |
| switch (columnIndex) { |
| case 0: |
| return issue.getId(); |
| case 1: |
| return issue.getBriefDescription(TEXT); |
| } |
| |
| return null; |
| } |
| |
| // ---- IColorProvider ---- |
| |
| @Override |
| public Color getForeground(Object element) { |
| if (element instanceof Category) { |
| return mTree.getDisplay().getSystemColor(SWT.COLOR_INFO_FOREGROUND); |
| } |
| |
| if (element instanceof Issue) { |
| Issue issue = (Issue) element; |
| Severity severity = mSeverities.get(issue); |
| if (severity == Severity.IGNORE) { |
| return mTree.getDisplay().getSystemColor(SWT.COLOR_DARK_GRAY); |
| } |
| } |
| |
| return null; |
| } |
| |
| @Override |
| public Color getBackground(Object element) { |
| if (element instanceof Category) { |
| return mTree.getDisplay().getSystemColor(SWT.COLOR_INFO_BACKGROUND); |
| } |
| return null; |
| } |
| } |
| } |
