/*******************************************************************************
* Copyright (c) 2007, 2010 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.ui.internal.views.markers;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.mapping.ResourceMapping;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.WorkbenchException;
import org.eclipse.ui.XMLMemento;
import org.eclipse.ui.internal.ide.IDEInternalPreferences;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.statushandlers.StatusManager;
import org.eclipse.ui.views.markers.FilterConfigurationArea;
import org.eclipse.ui.views.markers.MarkerField;
import org.eclipse.ui.views.markers.internal.ContentGeneratorDescriptor;
import org.eclipse.ui.views.markers.internal.MarkerGroup;
import org.eclipse.ui.views.markers.internal.MarkerSupportRegistry;
import org.eclipse.ui.views.markers.internal.MarkerType;
import org.eclipse.ui.views.markers.internal.MarkerTypesModel;
import org.eclipse.ui.views.markers.internal.ProblemFilter;
import org.eclipse.ui.views.markers.internal.Util;
/**
* MarkerContentGenerator is the representation of the markerContentGenerator
* extension point.
*
* @since 3.4
*
*/
public class MarkerContentGenerator {
/**
* The IMemeto Tags
*/
private static final String TAG_COLUMN_VISIBILITY = "visible"; //$NON-NLS-1$
private static final String TAG_FILTERS_SECTION = "filterGroups"; //$NON-NLS-1$
private static final String TAG_GROUP_ENTRY = "filterGroup"; //$NON-NLS-1$
private static final String TAG_AND = "andFilters"; //$NON-NLS-1$
private static final String TAG_LEGACY_FILTER_ENTRY = "filter"; //$NON-NLS-1$
private static final String TAG_MARKER_LIMIT = "markerLimit"; //$NON-NLS-1$
private static final String TAG_MARKER_LIMIT_ENABLED = "markerLimitEnabled"; //$NON-NLS-1$
/*Use this to indicate filter change rather than a null*/
private final Collection FILTERS_CHANGED = Collections.EMPTY_SET;
//Carries the description for the generator, as coded in the given extension point
private ContentGeneratorDescriptor generatorDescriptor;
// fields
private MarkerField[] visibleFields;
// filters
private Collection enabledFilters;
private Collection filters;
private boolean andFilters = false;
private int markerLimits = 100;
private boolean markerLimitsEnabled = true;
/**
* focusResources
*
*/
private IResource[] selectedResources = MarkerSupportInternalUtilities.EMPTY_RESOURCE_ARRAY;
private Collection currentResources = Collections.EMPTY_SET;
private CachedMarkerBuilder builder;
private String viewId;
private IPropertyChangeListener filterPreferenceListener;
/**
* Create a new MarkerContentGenerator
*
* @param generatorDescriptor
* @param builder
* @param viewId
* needed for backward compatibility
*/
public MarkerContentGenerator(
ContentGeneratorDescriptor generatorDescriptor,
CachedMarkerBuilder builder, String viewId) {
this.generatorDescriptor = generatorDescriptor;
this.viewId = viewId;
setBuilder(builder);
}
/**
* Attach the generator to a builder
*
* @param builder
*/
void setBuilder(CachedMarkerBuilder builder) {
this.builder = builder;
initializePreferenceListener();
this.builder.setGenerator(this);
}
/**
* @return Returns the builder this attached to.
*/
CachedMarkerBuilder getBuilder() {
return builder;
}
/**
* If attached to a builder, request marker update.
*/
void requestMarkerUpdate() {
if (builder != null) {
builder.scheduleUpdate(0L);
}
}
/**
* Return whether or not all of {@link MarkerTypesModel} arein the
* selectedTypes.
*
* @param selectedTypes
* @return boolean
*/
boolean allTypesSelected(Collection selectedTypes) {
return generatorDescriptor.allTypesSelected(selectedTypes);
}
/**
* Get the all of the fields that this content generator is using.
*
* @return {@link MarkerField}[]
*/
MarkerField[] getAllFields() {
return generatorDescriptor.getAllFields();
}
/**
* Get the fields that this content generator is displaying.
*
* @return {@link MarkerField}[]
*/
MarkerField[] getVisibleFields() {
return visibleFields;
}
/**
* Set the visible fields.
*
* @param visible
*/
void setVisibleFields(Collection visible) {
MarkerField[] newFields = new MarkerField[visible.size()];
visible.toArray(newFields);
visibleFields = newFields;
}
/**
* Return the fields not being shown currently.
*
* @return Object[]
*/
Object[] getHiddenFields() {
MarkerField[] all = getAllFields();
MarkerField[] visible = getVisibleFields();
Collection hidden = new HashSet();
for (int i = 0; i < all.length; i++) {
hidden.add(all[i]);
}
for (int i = 0; i < visible.length; i++) {
hidden.remove(visible[i]);
}
return hidden.toArray();
}
void saveState(IMemento memento, MarkerField[] displayedFields) {
for (int i = 0; i < displayedFields.length; i++) {
memento.createChild(TAG_COLUMN_VISIBILITY, displayedFields[i]
.getConfigurationElement().getAttribute(
MarkerSupportInternalUtilities.ATTRIBUTE_ID));
}
}
void restoreState(IMemento memento) {
initDefaults();
if (memento == null) {
return;
}
Integer limits = memento.getInteger(TAG_MARKER_LIMIT);
if (limits != null) {
markerLimits = limits.intValue();
}
Boolean limitsEnabled = memento.getBoolean(TAG_MARKER_LIMIT_ENABLED);
if (limitsEnabled != null) {
markerLimitsEnabled = limitsEnabled.booleanValue();
}
if (memento.getChildren(TAG_COLUMN_VISIBILITY).length != 0) {
IMemento[] visible = memento.getChildren(TAG_COLUMN_VISIBILITY);
Collection newVisible = new ArrayList();
MarkerField[] all = getAllFields();
Hashtable allTable = new Hashtable();
for (int i = 0; i < all.length; i++) {
allTable.put(all[i].getConfigurationElement().getAttribute(
MarkerSupportInternalUtilities.ATTRIBUTE_ID), all[i]);
}
for (int i = 0; i < visible.length; i++) {
String key = visible[i].getID();
if (allTable.containsKey(key)) {
newVisible.add(allTable.get(key));
}
}
visibleFields = new MarkerField[newVisible.size()];
newVisible.toArray(visibleFields);
}
}
private void initDefaults() {
IPreferenceStore store = IDEWorkbenchPlugin.getDefault()
.getPreferenceStore();
markerLimitsEnabled = store
.getBoolean(IDEInternalPreferences.USE_MARKER_LIMITS);
markerLimits = store.getInt(IDEInternalPreferences.MARKER_LIMITS_VALUE);
MarkerField[] initialFields = getInitialVisible();
visibleFields = new MarkerField[initialFields.length];
System.arraycopy(initialFields, 0, visibleFields, 0,
initialFields.length);
}
/**
* Return a collection of all of the configuration fields for this generator
*
* @return Collection of {@link FilterConfigurationArea}
*/
Collection createFilterConfigurationFields() {
Collection result = new ArrayList();
for (int i = 0; i < visibleFields.length; i++) {
FilterConfigurationArea area = MarkerSupportInternalUtilities
.generateFilterArea(visibleFields[i]);
if (area != null)
result.add(area);
}
return result;
}
/**
* Get the category name from the receiver.
*/
String getCategoryName() {
return generatorDescriptor.getCategoryName();
}
/**
* Return all of the filters for the receiver.
*
* @return Collection of MarkerFieldFilterGroup
*/
Collection getAllFilters() {
if (filters == null || filters == FILTERS_CHANGED) {
filters = getDeclaredFilters();
// Apply the last settings
loadFiltersPreference();
}
return filters;
}
/**
* Return the currently enabled filters.
*
* @return Collection of MarkerFieldFilterGroup
*/
Collection getEnabledFilters() {
if (enabledFilters == null || enabledFilters == FILTERS_CHANGED) {
Collection enabled = new HashSet();
Iterator filtersIterator = getAllFilters().iterator();
while (filtersIterator.hasNext()) {
MarkerFieldFilterGroup next = (MarkerFieldFilterGroup) filtersIterator
.next();
if (next.isEnabled())
enabled.add(next);
}
enabledFilters = enabled;
}
return enabledFilters;
}
/**
* Rebuild the list of filters
*/
protected void rebuildFilters() {
filters = FILTERS_CHANGED;
enabledFilters = FILTERS_CHANGED;
requestMarkerUpdate();
}
/**
* Disable all of the filters in the receiver.
*/
void disableAllFilters() {
Collection allFilters = getEnabledFilters();
Iterator enabled = allFilters.iterator();
while (enabled.hasNext()) {
MarkerFieldFilterGroup group = (MarkerFieldFilterGroup) enabled
.next();
group.setEnabled(false);
}
allFilters.clear();
writeFiltersPreference();
requestMarkerUpdate();
}
/**
* Add group to the enabled filters.
*
* @param group
*/
void toggleFilter(MarkerFieldFilterGroup group) {
Collection enabled = getEnabledFilters();
if (enabled.remove(group)) // true if it was present
group.setEnabled(false);
else {
group.setEnabled(true);
enabled.add(group);
}
writeFiltersPreference();
requestMarkerUpdate();
}
/**
* Update the filters.
*
* @param filters
* @param andFilters
*/
void updateFilters(Collection filters, boolean andFilters) {
setAndFilters(andFilters);
this.filters = filters;
enabledFilters = FILTERS_CHANGED;
writeFiltersPreference();
requestMarkerUpdate();
}
/**
* Set whether the filters are being ANDed or ORed.
*
* @param and
*/
void setAndFilters(boolean and) {
andFilters = and;
}
/**
* Return whether the filters are being ANDed or ORed.
*
* @return boolean
*/
boolean andFilters() {
return andFilters;
}
/**
* @return Returns the markerLimits.
*/
public int getMarkerLimits() {
return markerLimits;
}
/**
* @param markerLimits The markerLimits to set.
*/
public void setMarkerLimits(int markerLimits) {
this.markerLimits = markerLimits;
}
/**
* @return Returns the markerLimitsEnabled.
*/
public boolean isMarkerLimitsEnabled() {
return markerLimitsEnabled;
}
/**
* @param markerLimitsEnabled The markerLimitsEnabled to set.
*/
public void setMarkerLimitsEnabled(boolean markerLimitsEnabled) {
this.markerLimitsEnabled = markerLimitsEnabled;
}
/**
* @return Collection of declared MarkerFieldFilterGroup(s)
*/
Collection getDeclaredFilters() {
List filters = new ArrayList();
IConfigurationElement[] filterReferences = generatorDescriptor.getFilterReferences();
for (int i = 0; i < filterReferences.length; i++) {
filters.add(new MarkerFieldFilterGroup(filterReferences[i], this));
}
// Honour the deprecated problemFilters
if (viewId != null && viewId.equals(IPageLayout.ID_PROBLEM_VIEW)) {
Iterator problemFilters = MarkerSupportRegistry.getInstance()
.getRegisteredFilters().iterator();
while (problemFilters.hasNext())
filters.add(new CompatibilityMarkerFieldFilterGroup(
(ProblemFilter) problemFilters.next(), this));
}
return filters;
}
/**
* Get the name of the filters preference for the receiver,
*
* @return String
*/
private String getLegacyFiltersPreferenceName() {
if (viewId != null && viewId.equals(IPageLayout.ID_BOOKMARKS))
return IDEInternalPreferences.BOOKMARKS_FILTERS;
if (viewId != null && viewId.equals(IPageLayout.ID_TASK_LIST))
return IDEInternalPreferences.TASKS_FILTERS;
return IDEInternalPreferences.PROBLEMS_FILTERS;
}
private void loadLimitSettings(IMemento memento) {
if (memento == null)
return;
Integer limits = memento.getInteger(TAG_MARKER_LIMIT);
if (limits != null) {
markerLimits = limits.intValue();
}
Boolean limitsEnabled = memento.getBoolean(TAG_MARKER_LIMIT_ENABLED);
if (limitsEnabled != null) {
markerLimitsEnabled = limitsEnabled.booleanValue();
}
}
/**
* Load the settings from the memento.
*
* @param memento
*/
private void loadFilterSettings(IMemento memento) {
if (memento == null)
return;
Boolean andValue = memento.getBoolean(TAG_AND);
if (andValue != null)
setAndFilters(andValue.booleanValue());
IMemento children[] = memento.getChildren(TAG_GROUP_ENTRY);
for (int i = 0; i < children.length; i++) {
IMemento child = children[i];
String id = child.getString(IMemento.TAG_ID);
if (id == null)
continue;
if (!loadGroupWithID(child, id))
// Did not find a match must have been added by the user
loadUserFilter(child);
}
}
/**
* Load the filters defined in memento string.
*
* @param mementoString
*/
private void loadFiltersFrom(String mementoString) {
if (mementoString.equals(IPreferenceStore.STRING_DEFAULT_DEFAULT))
return;
try {
XMLMemento root = XMLMemento.createReadRoot(new StringReader(
mementoString));
loadLimitSettings(root);
loadFilterSettings(root);
} catch (WorkbenchException e) {
StatusManager.getManager().handle(e.getStatus());
}
}
/**
* Load the filters preference.
*/
private void loadFiltersPreference() {
loadFiltersFrom(IDEWorkbenchPlugin.getDefault().getPreferenceStore()
.getString(getMementoPreferenceName()));
String legacyFilters = getLegacyFiltersPreferenceName();
String migrationPreference = legacyFilters
+ MarkerSupportInternalUtilities.MIGRATE_PREFERENCE_CONSTANT;
if (IDEWorkbenchPlugin.getDefault().getPreferenceStore().getBoolean(
migrationPreference))
return;// Already migrated
// Load any defined in a pre 3.4 workbench
loadLegacyFiltersFrom(IDEWorkbenchPlugin.getDefault()
.getPreferenceStore().getString(legacyFilters));
// Mark as migrated
IDEWorkbenchPlugin.getDefault().getPreferenceStore().setValue(
migrationPreference, true);
}
/**
* @return preferenceName
*/
private String getMementoPreferenceName() {
return CachedMarkerBuilder.getMementoPreferenceName(viewId);
}
/**
* Load the group with id from the child if there is a matching system group
* registered.
*
* @param child
* @param id
* @return <code>true</code> if a matching group was found
*/
private boolean loadGroupWithID(IMemento child, String id) {
Iterator groups = getAllFilters().iterator();
while (groups.hasNext()) {
MarkerFieldFilterGroup group = (MarkerFieldFilterGroup) groups
.next();
if (id.equals(group.getID())) {
group.loadSettings(child);
return true;
}
}
return false;
}
/**
* Load the legacy filter into the system.
*
* @param child
*/
private void loadLegacyFilter(IMemento child) {
MarkerFieldFilterGroup newGroup = new MarkerFieldFilterGroup(null, this);
newGroup.legacyLoadSettings(child);
getAllFilters().add(newGroup);
}
/**
* Load the pre-3.4 filters.
*
* @param mementoString
*/
private void loadLegacyFiltersFrom(String mementoString) {
if (mementoString.equals(IPreferenceStore.STRING_DEFAULT_DEFAULT))
return;
IMemento memento;
try {
memento = XMLMemento
.createReadRoot(new StringReader(mementoString));
restoreLegacyFilters(memento);
} catch (WorkbenchException e) {
StatusManager.getManager().handle(e.getStatus());
return;
}
}
/**
* Load the user supplied filter
*
* @param child
*/
private void loadUserFilter(IMemento child) {
MarkerFieldFilterGroup newGroup = new MarkerFieldFilterGroup(null, this);
newGroup.loadSettings(child);
getAllFilters().add(newGroup);
}
/**
* Restore the pre-3.4 filters.
*
* @param memento
*/
private void restoreLegacyFilters(IMemento memento) {
IMemento[] sections = null;
if (memento != null)
sections = memento.getChildren(TAG_LEGACY_FILTER_ENTRY);
for (int i = 0; i < sections.length; i++) {
IMemento child = sections[i];
String id = child.getString(IMemento.TAG_ID);
if (id == null)
continue;
loadLegacyFilter(child);
}
}
/**
*
*/
private void writeFiltersPreference() {
XMLMemento memento = XMLMemento.createWriteRoot(TAG_FILTERS_SECTION);
writeLimitSettings(memento);
writeFiltersSettings(memento);
StringWriter writer = new StringWriter();
try {
memento.save(writer);
} catch (IOException e) {
IDEWorkbenchPlugin.getDefault().getLog().log(Util.errorStatus(e));
}
// TODO: We need to migrate this the current class
IDEWorkbenchPlugin.getDefault().getPreferenceStore().putValue(
getMementoPreferenceName(),
writer.toString());
IDEWorkbenchPlugin.getDefault().savePluginPreferences();
}
/**
* Create a preference listener for any preference updates.
*/
private void initializePreferenceListener() {
if (filterPreferenceListener == null) {
filterPreferenceListener = new IPropertyChangeListener() {
public void propertyChange(PropertyChangeEvent event) {
if (event.getProperty().equals(getMementoPreferenceName())) {
rebuildFilters();
}
}
};
IDEWorkbenchPlugin.getDefault().getPreferenceStore()
.addPropertyChangeListener(filterPreferenceListener);
}
}
private void writeLimitSettings(XMLMemento memento) {
memento.putInteger(TAG_MARKER_LIMIT, markerLimits);
memento.putBoolean(TAG_MARKER_LIMIT_ENABLED, markerLimitsEnabled);
}
/**
* Write the settings for the filters to the memento.
*
* @param memento
*/
private void writeFiltersSettings(XMLMemento memento) {
memento.putBoolean(TAG_AND, andFilters());
Iterator groups = getAllFilters().iterator();
while (groups.hasNext()) {
MarkerFieldFilterGroup group = (MarkerFieldFilterGroup) groups
.next();
IMemento child = memento
.createChild(TAG_GROUP_ENTRY, group.getID());
group.saveFilterSettings(child);
}
}
/**
* Return the id of the receiver.
*
* @return String
*/
public String getId() {
return generatorDescriptor.getId();
}
/**
* @param viewId
* if attached to a view
*/
void setViewID(String viewId) {
this.viewId = viewId;
}
/**
* @return Returns the viewId of view it is attached to or null otherwise.
*/
public Object getViewId() {
return viewId;
}
/**
* Get the list of initially visible fields
*
* @return {@link MarkerField}[]
*/
MarkerField[] getInitialVisible() {
return generatorDescriptor.getInitialVisible();
}
/**
* Get the group called groupName from the receiver
*
* @param groupName
* @return MarkerGroup or <code>null</code>
*/
MarkerGroup getMarkerGroup(String groupName) {
Iterator groups = getMarkerGroups().iterator();
while (groups.hasNext()) {
MarkerGroup group = (MarkerGroup) groups.next();
if (group.getId().equals(groupName))
return group;
}
return null;
}
/**
* Get the markerGroups associated with the receiver.
*
* @return Collection of {@link MarkerGroup}
*/
Collection getMarkerGroups() {
return generatorDescriptor.getMarkerGroups();
}
/**
* Return the markerTypes for the receiver.
*
* @return Collection of {@link MarkerType}
*/
public Collection getMarkerTypes() {
return generatorDescriptor.getMarkerTypes();
}
/**
* Return the markerTypes for the receiver.
*
* @return Array of type Ids
*/
public String[] getTypes() {
Collection types = getMarkerTypes();
String[] ids = new String[types.size()];
Iterator iterator = types.iterator();
int i = 0;
while (iterator.hasNext()) {
ids[i++] = ((MarkerType) iterator.next()).getId();
}
return ids;
}
/**
* Return the name for the receiver.
*
* @return String
*/
String getName() {
return generatorDescriptor.getName();
}
/**
* Return the type for typeId.
*
* @param typeId
* @return {@link MarkerType} or <code>null</code> if it is not found.
*/
MarkerType getType(String typeId) {
return generatorDescriptor.getType(typeId);
}
/**
* Select the given MarkerEntry
* @return <code>true</code> if it matches all enabled filters
*/
boolean select(MarkerEntry entry) {
try {
return select(entry, getSelectedResources(), getEnabledFilters(), andFilters());
} finally {
entry.clearCache();
}
}
boolean select(MarkerEntry entry, IResource[] selResources,
Collection enabledFilters, boolean andFilters) {
if (enabledFilters.size() > 0) {
Iterator filtersIterator = enabledFilters.iterator();
if (andFilters) {
while (filtersIterator.hasNext()) {
MarkerFieldFilterGroup group = (MarkerFieldFilterGroup) filtersIterator
.next();
if (!group.selectByScope(entry, selResources)
|| !group.selectByFilters(entry)) {
return false;
}
}
return true;
}
while (filtersIterator.hasNext()) {
MarkerFieldFilterGroup group = (MarkerFieldFilterGroup) filtersIterator
.next();
if (group.selectByScope(entry, selResources)
&& group.selectByFilters(entry)) {
return true;
}
}
return false;
}
return true;
}
/**
* Update the focus resources from list. If there is an update required
* return <code>true</code>. This method assumes that there are filters on
* resources enabled.
*
* @param elements
*/
void internalUpdateSelectedElements(Object[] elements) {
Collection resourceCollection = new ArrayList();
for (int i = 0; i < elements.length; i++) {
if (elements[i] instanceof IResource) {
resourceCollection.add(elements[i]);
} else {
MarkerResourceUtil.addResources(resourceCollection,
((ResourceMapping) elements[i]));
}
}
IResource[] newSelection = new IResource[resourceCollection.size()];
resourceCollection.toArray(newSelection);
selectedResources = newSelection;
}
/**
* Update the receiver for a change in selection.
*
* @param newElements
*/
void updateSelectedResource(Object[] newElements) {
if (updateNeededForSelection(newElements)) {
internalUpdateSelectedElements(newElements);
// See comments below and Bug 296695
// if (contentChanged()) {
requestMarkerUpdate();
// }
}
}
/**
* Return whether or not the list contains a resource that will require
* update.
*
* @return boolean <code>true</code> if update is required.
*/
boolean updateNeededForSelection(Object[] newElements) {
Iterator filters = getEnabledFilters().iterator();
while (filters.hasNext()) {
MarkerFieldFilterGroup filter = (MarkerFieldFilterGroup) filters
.next();
int scope = filter.getScope();
if (scope == MarkerFieldFilterGroup.ON_ANY
|| scope == MarkerFieldFilterGroup.ON_WORKING_SET)
continue;
if (newElements == null || newElements.length < 1)
continue;
if (selectedResources.length == 0)
return true; // We had nothing now we have something
if (Arrays.equals(selectedResources, newElements))
continue;
if (scope == MarkerFieldFilterGroup.ON_ANY_IN_SAME_CONTAINER) {
Collection oldProjects = MarkerResourceUtil
.getProjectsAsCollection(selectedResources);
Collection newProjects = MarkerResourceUtil
.getProjectsAsCollection(newElements);
if (oldProjects.size() == newProjects.size()
&& newProjects.containsAll(oldProjects))
continue;
return true;// Something must be different
}
return true;
}
return false;
}
/**
* @return list of selected resources
*/
IResource[] getSelectedResources() {
IResource[] selected=selectedResources;
IResource[] resources = new IResource[selected.length];
System.arraycopy(selected, 0, resources, 0,
selected.length);
return resources;
}
/**
* Note:As opposed to the previous scheme, the reason we gather markers only
* for the "effective"(ored/anded) resource collection is because collecting
* for individual filters and then adding them to a Set to remove duplicates
* is a lot more time-consuming than collecting only once,filtering once and
* adding to a list once.As a pre-filtering step, the
* MarkerFieldFilterGroup#selectByScope uses IPath comparison for selection,
* which happens real quickly.Also when filters are Anded we get a chance to
* gather only on resources that actually matter.And we get a tool to check
* at various places.
*
* @return list of resource we want to collect markers for taking various
* enabled filters into account.
*
*/
Collection getResourcesForBuild() {
currentResources = MarkerResourceUtil.computeResources(
getSelectedResources(), getEnabledFilters(), andFilters());
return currentResources;
}
/*
* See Bug 296695: This method is trickier than it may seem/appears to be.If
* it is ever desired to use this, it would need to be *RE-IMPLEMENTED* and
* would need a good amount of testing with various combination of filters
* and scopes. The key here is to understand and getting it right how filter
* scope and our trimmed, optimized resources and selected resource elements
* interact.
* Another possible way to check if content has changed is by
* comparing the markers gathered freshly with the previously gathered
* markers(cache them when an update is not canceled), whether this up to a
* visible limit, or completely, or selected filters we have to see. I am
* assuming that this takes little time to do. If this is done prior to
* sorting a good amount of time can be saved; we still save the UI time if
* checked after sorting. In the sorted case we can use a Binary search as
* well.Anyhow if this does take up time, we should skip this method.
*/
// /**
// * Change in markers itself is taken care of by the IResourceChangeListener,
// * We can think about change in the resource content when filters have
// * changed or selections have changed and the particular update we perform
// * manually is not required at all since nothing had changed.This is
// * particularly useful when a filter is set to 'On Selected element scope'.A
// * change in a filter is a combination of both its scope and other settings.
// *
// *
// * @return true if the resource-content has changed due to change in filter
// * settings or selection. false if content has not change or an
// * update has cleared the changes.
// */
// boolean contentChanged() {
// if (enabledFilters == null || enabledFilters == FILTERS_CHANGED) {
// /*
// * TODO:Find a more narrowing way to check if active filters have
// * actually changed.Right now the update filter method set the
// * enabled filters to null. TODO: We should use a preference
// * listener for this We can 'optimally' use it for filter change
// * only on fixing the above.
// */
// return true;
// }
// Collection current = MarkerResourceUtil.computeResources(
// getSelectedResources(), getEnabledFilters(), andFilters());
// Collection activeResources = currentResources;
// if (current.size() != activeResources.size()) {
// // changed
// return true;
// }
// Iterator iterator = activeResources.iterator();
// boolean needsUpdate = false;
// while (!needsUpdate && iterator.hasNext()) {
// Object object = iterator.next();
// if (!current.contains(object)) {
// needsUpdate = true;
// }
// }
// return needsUpdate;
// }
/**
* Refresh gathered markers entries
*
* @param monitor
*/
Collection generateMarkerEntries(IProgressMonitor monitor) {
List result = new LinkedList();
String[] typeIds = getTypes();
boolean includeSubTypes = builder.includeMarkerSubTypes();
boolean cancelled = gatherMarkers(typeIds, includeSubTypes, result,
monitor);
if (cancelled) {
result.clear();
}
return result;
}
/**
* Refresh gathered markers entries
* @param result
* @param monitor
*/
boolean generateMarkerEntries(Collection result,IProgressMonitor monitor) {
String[] typeIds = getTypes();
boolean includeSubTypes = builder.includeMarkerSubTypes();
return gatherMarkers(typeIds, includeSubTypes, result, monitor);
}
/**
* Gather markers into result.
* @param typeIds
* @param includeSubTypes
* @param result
* @param monitor
*/
boolean gatherMarkers(String[] typeIds, boolean includeSubTypes,
Collection result, IProgressMonitor monitor) {
try {
Collection resources = getResourcesForBuild();
if (includeSubTypes) {
// Optimize and calculate super types
String[] superTypes = MarkerResourceUtil
.getMutuallyExclusiveSupersIds(typeIds);
if (monitor.isCanceled()) {
return false;
}
for (int i = 0; i < superTypes.length; i++) {
boolean success = internalGatherMarkers(resources,superTypes[i],
includeSubTypes, result, monitor);
if (!success || monitor.isCanceled()) {
return false;
}
}
} else {
for (int i = 0; i < typeIds.length; i++) {
boolean success = internalGatherMarkers(resources,typeIds[i],
includeSubTypes, result, monitor);
if (!success || monitor.isCanceled()) {
return false;
}
}
}
} catch (Exception e) {
//do not propagate but do show the error
MarkerSupportInternalUtilities.showViewError(e);
return false;
} finally {
}
return true;
}
/**
* A helper to the
* {@link #gatherMarkers(String[], boolean, Collection, IProgressMonitor)}
*
* @param resources
* @param typeId
* @param includeSubTypes
* @param result
* @param monitor
*/
private boolean internalGatherMarkers(Collection resources, String typeId,
boolean includeSubTypes, Collection result, IProgressMonitor monitor) {
if (monitor.isCanceled()) {
return false;
}
IResource[] selected = getSelectedResources();
Collection filters = getEnabledFilters();
boolean andFilters = andFilters();
Iterator iterator = resources.iterator();
while (iterator.hasNext()) {
IMarker[] markers = null;
try {
IResource resource = (IResource) iterator.next();
if (!resource.isAccessible()) {
continue;
}
markers = resource.findMarkers(typeId, includeSubTypes,
IResource.DEPTH_INFINITE);
} catch (CoreException e) {
MarkerSupportInternalUtilities.logViewError(e);
}
if (markers == null) {
continue;
}
if (monitor.isCanceled()) {
return false;
}
MarkerEntry entry = null;
int lenght = markers.length;
for (int i = 0; i < lenght; i++) {
entry = new MarkerEntry(markers[i]);
if (select(entry, selected, filters, andFilters)) {
result.add(entry);
}
entry.clearCache();
if (i % 500 == 0) {
if (monitor.isCanceled()) {
return false;
}
}
}
}
return true;
}
void dispose() {
if (filterPreferenceListener != null) {
IDEWorkbenchPlugin.getDefault().getPreferenceStore().removePropertyChangeListener(filterPreferenceListener);
filterPreferenceListener = null;
}
}
}