bundles/org.eclipse.ui.ide/src/org/eclipse/ui/views/markers/internal/MarkerFilter.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2003 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Common Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/cpl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/

 package org.eclipse.ui.views.markers.internal;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.StringTokenizer;

 import org.eclipse.core.resources.IMarker;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.jface.dialogs.IDialogSettings;
 import org.eclipse.ui.IContainmentAdapter;
 import org.eclipse.ui.IWorkingSet;
 import org.eclipse.ui.PlatformUI;

 class MarkerFilter implements IFilter {

 	private static final String TAG_DIALOG_SECTION = "filter"; //$NON-NLS-1$
 	private static final String TAG_ENABLED = "enabled"; //$NON-NLS-1$
 	private static final String TAG_FILTER_ON_MARKER_LIMIT = "filterOnMarkerLimit"; //$NON-NLS-1$
 	private static final String TAG_MARKER_LIMIT = "markerLimit"; //$NON-NLS-1$
 	private static final String TAG_ON_RESOURCE = "onResource"; //$NON-NLS-1$
 	private static final String TAG_SELECTED_TYPES = "selectedType"; //$NON-NLS-1$
 	private static final String TAG_WORKING_SET = "workingSet"; //$NON-NLS-1$
 	private static final String TAG_TYPES_DELIMITER = ":"; //$NON-NLS-1$

 	static final int ON_ANY_RESOURCE = 0;
 	static final int ON_SELECTED_RESOURCE_ONLY = 1;
 	static final int ON_SELECTED_RESOURCE_AND_CHILDREN = 2;
 	static final int ON_ANY_RESOURCE_OF_SAME_PROJECT = 3;
 	static final int ON_WORKING_SET = 4;

 	static final int DEFAULT_MARKER_LIMIT = 2000;
 	static final boolean DEFAULT_FILTER_ON_MARKER_LIMIT = true;
 	static final int DEFAULT_ON_RESOURCE = ON_ANY_RESOURCE;
 	static final boolean DEFAULT_ACTIVATION_STATUS = true;

 	protected List rootTypes = new ArrayList();
 	protected List selectedTypes = new ArrayList();
 	protected IWorkingSet workingSet;
 	protected int onResource;
 	protected boolean filterOnMarkerLimit;
 	protected boolean enabled;
 	protected int markerLimit;

 	private MarkerTypesModel typesModel;

 	private IResource[] focusResource;

 	MarkerFilter(String[] rootTypes) {
 		typesModel = new MarkerTypesModel();

 		for (int i = 0; i < rootTypes.length; i++) {
 			MarkerType type = typesModel.getType(rootTypes[i]);

 			if (!this.rootTypes.contains(type))
 				this.rootTypes.add(type);
 		}
 	}

 	private void addAllSubTypes() {
 		for (int i = 0; i < rootTypes.size(); i++) {
 			MarkerType rootType = (MarkerType) rootTypes.get(i);
 			addAllSubTypes(rootType);
 		}
 	}

 	private void addAllSubTypes(MarkerType type) {
 		if (type == null)
 			return;

 		if (!selectedTypes.contains(type))
 			selectedTypes.add(type);

 		MarkerType[] subTypes = type.getSubtypes();

 		for (int i = 0; i < subTypes.length; i++)
 			addAllSubTypes(subTypes[i]);
 	}

 	public Object[] filter(Object[] elements) {
 		if (elements == null)
 			return new Object[0];

 		List filteredElements = new ArrayList();

 		for (int i = 0; i < elements.length; i++) {
 			Object element = elements[i];

 			if (select(element))
 				filteredElements.add(element);
 		}

 		return filteredElements.toArray();
 	}

 	public boolean select(Object item) {
 		if (!isEnabled()) {
 			return true;
 		}

 		if (!(item instanceof IMarker))
 			return false;

 		IMarker marker = (IMarker) item;
 		return selectByType(marker) && selectBySelection(marker);
 	}

 	private boolean selectByType(IMarker marker) {
 		String type;

 		try {
 			type = marker.getType();
 		}
 		catch (CoreException e) {
 			return false;
 		}

 		return selectedTypes.contains(typesModel.getType(type));
 	}

 	/**
 	 * Returns whether the specified marker should be filter out or not.
 	 *
 	 * @param marker the marker to test
 	 * @return
 	 * 	true=the marker should not be filtered out
 	 * 	false=the marker should be filtered out
 	 */
 	private boolean selectBySelection(IMarker marker) {
 		if (onResource == ON_ANY_RESOURCE || marker == null)
 			return true;

 		if (focusResource == null)
 			return true;

 		IResource resource = marker.getResource();

 		if (onResource == ON_WORKING_SET) {
 			if (workingSet == null)
 				return true;

 			if (resource != null)
 				return isEnclosed(resource);

 		} else if (onResource == ON_ANY_RESOURCE_OF_SAME_PROJECT) {
 			IProject project = resource.getProject();

 			for (int i = 0; i < focusResource.length; i++) {
 				IProject selectedProject = focusResource[i].getProject();

 				if (project.equals(selectedProject))
 					return true;
 			}
 		} else if (onResource == ON_SELECTED_RESOURCE_ONLY) {
 			for (int i = 0; i < focusResource.length; i++) {
 				if (resource.equals(focusResource[i]))
 					return true;
 			}
 		} else if (onResource == ON_SELECTED_RESOURCE_AND_CHILDREN) {
 			for (int i = 0; i < focusResource.length; i++) {
 				IResource parentResource = resource;

 				while (parentResource != null) {
 					if (parentResource.equals(focusResource[i]))
 						return true;

 					parentResource = parentResource.getParent();
 				}
 			}
 		}

 		return false;
 	}

 	/**
 	 * Returns if the given resource is enclosed by a working set element.
 	 * The IContainmentAdapter of each working set element is used for the
 	 * containment test. If there is no IContainmentAdapter for a working
 	 * set element, a simple resource based test is used.
 	 *
 	 * @param element resource to test for enclosure by a working set
 	 * 	element
 	 * @return true if element is enclosed by a working set element and
 	 * 	false otherwise.
 	 */
 	private boolean isEnclosed(IResource element) {
 		IPath elementPath = element.getFullPath();
 		IAdaptable[] workingSetElements = workingSet.getElements();

 		if (elementPath.isEmpty() || elementPath.isRoot())
 			return false;

 		for (int i = 0; i < workingSetElements.length; i++) {
 			IAdaptable workingSetElement = workingSetElements[i];
 			IContainmentAdapter containmentAdapter = (IContainmentAdapter) workingSetElement.getAdapter(IContainmentAdapter.class);

 			// if there is no IContainmentAdapter defined for the working
 			// set element type fall back to using resource based
 			// containment check
 			if (containmentAdapter != null) {
 				if (containmentAdapter.contains(workingSetElement, element, IContainmentAdapter.CHECK_CONTEXT | IContainmentAdapter.CHECK_IF_CHILD | IContainmentAdapter.CHECK_IF_DESCENDANT))
 					return true;
 			} else if (isEnclosedResource(element, elementPath, workingSetElement)) {
 				return true;
 			}
 		}

 		return false;
 	}

 	/**
 	 * Returns if the given resource is enclosed by a working set element.
 	 * A resource is enclosed if it is either a parent of a working set
 	 * element, a child of a working set element or a working set element
 	 * itself.
 	 * Simple path comparison is used. This is only guaranteed to return
 	 * correct results for resource working set elements.
 	 *
 	 * @param element resource to test for enclosure by a working set
 	 * 	element
 	 * @param elementPath full, absolute path of the element to test
 	 * @return true if element is enclosed by a working set element and
 	 * 	false otherwise.
 	 */
 	private boolean isEnclosedResource(IResource element, IPath elementPath, IAdaptable workingSetElement) {
 		IResource workingSetResource = null;

 		if (workingSetElement.equals(element))
 			return true;

 		if (workingSetElement instanceof IResource)
 			workingSetResource = (IResource) workingSetElement;
 		else
 			workingSetResource = (IResource) workingSetElement.getAdapter(IResource.class);

 		if (workingSetResource != null) {
 			IPath resourcePath = workingSetResource.getFullPath();

 			if (resourcePath.isPrefixOf(elementPath))
 				return true;
 		}

 		return false;
 	}

 	/**
 	 * @return the defined limit on the number of markers to be displayed.
 	 */
 	int getMarkerLimit() {
 		return markerLimit;
 	}

 	/**
 	 * Sets the limit on the number of markers to be displayed.
 	 *
 	 * @param the new limit
 	 */
 	void setMarkerLimit(int markerLimit) {
 		this.markerLimit = markerLimit;
 	}

 	/**
 	 * @return <ul>
 	 * <li><code>MarkerFilter.ON_ANY_RESOURCE</code> if showing items associated with any resource.</li>
 	 * <li><code>MarkerFilter.ON_SELECTED_RESOURCE_ONLY</code> if showing items associated with
 	 * the selected resource within the workbench.</li>
 	 * <li><code>MarkerFilter.ON_SELECTED_RESOURCE_AND_CHILDREN</code> if showing items associated with
 	 * the selected resource within the workbench and its children.</li>
 	 * <li><code>MarkerFilter.ON_ANY_RESOURCE_OF_SAME_PROJECT</code> if showing items in the same project
 	 * as the selected resource within the workbench.</li>
 	 * <li><code>MarkerFilter.ON_WORKING_SET</code> if showing items in some working set.</li>
 	 * </ul>
 	 */
 	int getOnResource() {
 		return onResource;
 	}

 	/**
 	 * Sets the type of filtering by selection.
 	 *
 	 * @param onResource must be one of:
 	 * <ul>
 	 * <li><code>MarkerFilter.ON_ANY_RESOURCE</code></li>
 	 * <li><code>MarkerFilter.ON_SELECTED_RESOURCE_ONLY</code></li>
 	 * <li><code>MarkerFilter.ON_SELECTED_RESOURCE_AND_CHILDREN</code></li>
 	 * <li><code>MarkerFilter.ON_ANY_RESOURCE_OF_SAME_PROJECT</code></li>
 	 * <li><code>MarkerFilter.ON_WORKING_SET</code></li>
 	 * </ul>
 	 */
 	void setOnResource(int onResource) {
 		if (onResource >= ON_ANY_RESOURCE && onResource <= ON_WORKING_SET)
 			this.onResource = onResource;
 	}

 	/**
 	 * @return the selected resource(s) withing the workbench.
 	 */
 	IResource[] getFocusResource() {
 		return focusResource;
 	}

 	/**
 	 * Sets the focused resources.
 	 */
 	void setFocusResource(IResource[] resources) {
 		focusResource = resources;
 	}

 	/**
 	 * @return
 	 * <ul>
 	 * <li><code>true</code> if the filter is enabled.</li>
 	 * <li><code>false</code> if the filter is not enabled.</li>
 	 * </ul>
 	 */
 	boolean isEnabled() {
 		return enabled;
 	}

 	/**
 	 * @return
 	 * <ul>
 	 * <li><code>true</code> if filtering by marker limit is enabled.</li>
 	 * <li><code>false</code> if filtering by marker limit is not enabled.</li>
 	 * </ul>
 	 */
 	boolean getFilterOnMarkerLimit() {
 		return filterOnMarkerLimit;
 	}

 	/**
 	 * @return the root marker types.
 	 */
 	List getRootTypes() {
 		return rootTypes;
 	}

 	/**
 	 * @return the selected marker types to be displayed.
 	 */
 	List getSelectedTypes() {
 		return selectedTypes;
 	}

 	/**
 	 * @return the current working set or <code>null</code> if no working set is defined.
 	 */
 	IWorkingSet getWorkingSet() {
 		return workingSet;
 	}

 	/**
 	 * Sets the enablement state of the filter.
 	 */
 	void setEnabled(boolean enabled) {
 		this.enabled = enabled;
 	}

 	/**
 	 * Sets the enablement state of filtering by marker limit.
 	 */
 	void setFilterOnMarkerLimit(boolean filterOnMarkerLimit) {
 		this.filterOnMarkerLimit = filterOnMarkerLimit;
 	}

 	/**
 	 * Sets the selected marker types to be displayed. The List <b>MUST ONLY</b> contain
 	 * <code>MarkerType</code> objects.
 	 */
 	void setSelectedTypes(List selectedTypes) {
 		this.selectedTypes = selectedTypes;
 	}

 	/**
 	 * Sets the current working set.
 	 */
 	void setWorkingSet(IWorkingSet workingSet) {
 		this.workingSet = workingSet;
 	}

 	void resetState() {
 		enabled = DEFAULT_ACTIVATION_STATUS;
 		filterOnMarkerLimit = DEFAULT_FILTER_ON_MARKER_LIMIT;
 		markerLimit = DEFAULT_MARKER_LIMIT;
 		onResource = DEFAULT_ON_RESOURCE;
 		selectedTypes.clear();
 		addAllSubTypes();
 		workingSet = null;
 	}

 	public void restoreState(IDialogSettings dialogSettings) {
 		resetState();
 		IDialogSettings settings = dialogSettings.getSection(TAG_DIALOG_SECTION);

 		if (settings != null) {
 			String setting = settings.get(TAG_ENABLED);

 			if (setting != null)
 				enabled = Boolean.valueOf(setting).booleanValue();

 			setting = settings.get(TAG_FILTER_ON_MARKER_LIMIT);

 			if (setting != null)
 				filterOnMarkerLimit = Boolean.valueOf(setting).booleanValue();

 			setting = settings.get(TAG_MARKER_LIMIT);

 			if (setting != null)
 				try {
 					markerLimit = Integer.parseInt(setting);
 				}
 				catch (NumberFormatException eNumberFormat) {
 				}

 			setting = settings.get(TAG_ON_RESOURCE);

 			if (setting != null)
 				try {
 					onResource = Integer.parseInt(setting);
 				}
 				catch (NumberFormatException eNumberFormat) {
 				}

 			setting = settings.get(TAG_SELECTED_TYPES);

 			if (setting != null) {
 				selectedTypes.clear();
 				StringTokenizer stringTokenizer = new StringTokenizer(setting);

 				while (stringTokenizer.hasMoreTokens()) {
 					MarkerType markerType = typesModel.getType(stringTokenizer.nextToken(TAG_TYPES_DELIMITER));

 					if (markerType != null && !selectedTypes.contains(markerType))
 						selectedTypes.add(markerType);
 				}
 			}

 			setting = settings.get(TAG_WORKING_SET);

 			if (setting != null)
 				workingSet = PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSet(setting);
 		}
 	}

 	public void saveState(IDialogSettings dialogSettings) {
 		if (dialogSettings != null) {
 			IDialogSettings settings = dialogSettings.getSection(TAG_DIALOG_SECTION);

 			if (settings == null)
 				settings = dialogSettings.addNewSection(TAG_DIALOG_SECTION);

 			settings.put(TAG_ENABLED, enabled);
 			settings.put(TAG_FILTER_ON_MARKER_LIMIT, filterOnMarkerLimit);
 			settings.put(TAG_MARKER_LIMIT, markerLimit);
 			settings.put(TAG_ON_RESOURCE, onResource);

 			String markerTypeIds = ""; //$NON-NLS-1$

 			for (int i = 0; i < selectedTypes.size(); i++) {
 				MarkerType markerType = (MarkerType) selectedTypes.get(i);
 				markerTypeIds += markerType.getId() + TAG_TYPES_DELIMITER;
 			}

 			settings.put(TAG_SELECTED_TYPES, markerTypeIds);

 			if (workingSet != null)
 				settings.put(TAG_WORKING_SET, workingSet.getName());
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2003 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Common Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/cpl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/

	package org.eclipse.ui.views.markers.internal;

	import java.util.ArrayList;
	import java.util.List;
	import java.util.StringTokenizer;

	import org.eclipse.core.resources.IMarker;
	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.jface.dialogs.IDialogSettings;
	import org.eclipse.ui.IContainmentAdapter;
	import org.eclipse.ui.IWorkingSet;
	import org.eclipse.ui.PlatformUI;

	class MarkerFilter implements IFilter {

	private static final String TAG_DIALOG_SECTION = "filter"; //$NON-NLS-1$
	private static final String TAG_ENABLED = "enabled"; //$NON-NLS-1$
	private static final String TAG_FILTER_ON_MARKER_LIMIT = "filterOnMarkerLimit"; //$NON-NLS-1$
	private static final String TAG_MARKER_LIMIT = "markerLimit"; //$NON-NLS-1$
	private static final String TAG_ON_RESOURCE = "onResource"; //$NON-NLS-1$
	private static final String TAG_SELECTED_TYPES = "selectedType"; //$NON-NLS-1$
	private static final String TAG_WORKING_SET = "workingSet"; //$NON-NLS-1$
	private static final String TAG_TYPES_DELIMITER = ":"; //$NON-NLS-1$

	static final int ON_ANY_RESOURCE = 0;
	static final int ON_SELECTED_RESOURCE_ONLY = 1;
	static final int ON_SELECTED_RESOURCE_AND_CHILDREN = 2;
	static final int ON_ANY_RESOURCE_OF_SAME_PROJECT = 3;
	static final int ON_WORKING_SET = 4;

	static final int DEFAULT_MARKER_LIMIT = 2000;
	static final boolean DEFAULT_FILTER_ON_MARKER_LIMIT = true;
	static final int DEFAULT_ON_RESOURCE = ON_ANY_RESOURCE;
	static final boolean DEFAULT_ACTIVATION_STATUS = true;

	protected List rootTypes = new ArrayList();
	protected List selectedTypes = new ArrayList();
	protected IWorkingSet workingSet;
	protected int onResource;
	protected boolean filterOnMarkerLimit;
	protected boolean enabled;
	protected int markerLimit;

	private MarkerTypesModel typesModel;

	private IResource[] focusResource;

	MarkerFilter(String[] rootTypes) {
	typesModel = new MarkerTypesModel();

	for (int i = 0; i < rootTypes.length; i++) {
	MarkerType type = typesModel.getType(rootTypes[i]);

	if (!this.rootTypes.contains(type))
	this.rootTypes.add(type);
	}
	}

	private void addAllSubTypes() {
	for (int i = 0; i < rootTypes.size(); i++) {
	MarkerType rootType = (MarkerType) rootTypes.get(i);
	addAllSubTypes(rootType);
	}
	}

	private void addAllSubTypes(MarkerType type) {
	if (type == null)
	return;

	if (!selectedTypes.contains(type))
	selectedTypes.add(type);

	MarkerType[] subTypes = type.getSubtypes();

	for (int i = 0; i < subTypes.length; i++)
	addAllSubTypes(subTypes[i]);
	}

	public Object[] filter(Object[] elements) {
	if (elements == null)
	return new Object[0];

	List filteredElements = new ArrayList();

	for (int i = 0; i < elements.length; i++) {
	Object element = elements[i];

	if (select(element))
	filteredElements.add(element);
	}

	return filteredElements.toArray();
	}

	public boolean select(Object item) {
	if (!isEnabled()) {
	return true;
	}

	if (!(item instanceof IMarker))
	return false;

	IMarker marker = (IMarker) item;
	return selectByType(marker) && selectBySelection(marker);
	}

	private boolean selectByType(IMarker marker) {
	String type;

	try {
	type = marker.getType();
	}
	catch (CoreException e) {
	return false;
	}

	return selectedTypes.contains(typesModel.getType(type));
	}

	/**
	* Returns whether the specified marker should be filter out or not.
	*
	* @param marker the marker to test
	* @return
	* true=the marker should not be filtered out
	* false=the marker should be filtered out
	*/
	private boolean selectBySelection(IMarker marker) {
	if (onResource == ON_ANY_RESOURCE \|\| marker == null)
	return true;

	if (focusResource == null)
	return true;

	IResource resource = marker.getResource();

	if (onResource == ON_WORKING_SET) {
	if (workingSet == null)
	return true;

	if (resource != null)
	return isEnclosed(resource);

	} else if (onResource == ON_ANY_RESOURCE_OF_SAME_PROJECT) {
	IProject project = resource.getProject();

	for (int i = 0; i < focusResource.length; i++) {
	IProject selectedProject = focusResource[i].getProject();

	if (project.equals(selectedProject))
	return true;
	}
	} else if (onResource == ON_SELECTED_RESOURCE_ONLY) {
	for (int i = 0; i < focusResource.length; i++) {
	if (resource.equals(focusResource[i]))
	return true;
	}
	} else if (onResource == ON_SELECTED_RESOURCE_AND_CHILDREN) {
	for (int i = 0; i < focusResource.length; i++) {
	IResource parentResource = resource;

	while (parentResource != null) {
	if (parentResource.equals(focusResource[i]))
	return true;

	parentResource = parentResource.getParent();
	}
	}
	}

	return false;
	}

	/**
	* Returns if the given resource is enclosed by a working set element.
	* The IContainmentAdapter of each working set element is used for the
	* containment test. If there is no IContainmentAdapter for a working
	* set element, a simple resource based test is used.
	*
	* @param element resource to test for enclosure by a working set
	* element
	* @return true if element is enclosed by a working set element and
	* false otherwise.
	*/
	private boolean isEnclosed(IResource element) {
	IPath elementPath = element.getFullPath();
	IAdaptable[] workingSetElements = workingSet.getElements();

	if (elementPath.isEmpty() \|\| elementPath.isRoot())
	return false;

	for (int i = 0; i < workingSetElements.length; i++) {
	IAdaptable workingSetElement = workingSetElements[i];
	IContainmentAdapter containmentAdapter = (IContainmentAdapter) workingSetElement.getAdapter(IContainmentAdapter.class);

	// if there is no IContainmentAdapter defined for the working
	// set element type fall back to using resource based
	// containment check
	if (containmentAdapter != null) {
	if (containmentAdapter.contains(workingSetElement, element, IContainmentAdapter.CHECK_CONTEXT \| IContainmentAdapter.CHECK_IF_CHILD \| IContainmentAdapter.CHECK_IF_DESCENDANT))
	return true;
	} else if (isEnclosedResource(element, elementPath, workingSetElement)) {
	return true;
	}
	}

	return false;
	}

	/**
	* Returns if the given resource is enclosed by a working set element.
	* A resource is enclosed if it is either a parent of a working set
	* element, a child of a working set element or a working set element
	* itself.
	* Simple path comparison is used. This is only guaranteed to return
	* correct results for resource working set elements.
	*
	* @param element resource to test for enclosure by a working set
	* element
	* @param elementPath full, absolute path of the element to test
	* @return true if element is enclosed by a working set element and
	* false otherwise.
	*/
	private boolean isEnclosedResource(IResource element, IPath elementPath, IAdaptable workingSetElement) {
	IResource workingSetResource = null;

	if (workingSetElement.equals(element))
	return true;

	if (workingSetElement instanceof IResource)
	workingSetResource = (IResource) workingSetElement;
	else
	workingSetResource = (IResource) workingSetElement.getAdapter(IResource.class);

	if (workingSetResource != null) {
	IPath resourcePath = workingSetResource.getFullPath();

	if (resourcePath.isPrefixOf(elementPath))
	return true;
	}

	return false;
	}

	/**
	* @return the defined limit on the number of markers to be displayed.
	*/
	int getMarkerLimit() {
	return markerLimit;
	}

	/**
	* Sets the limit on the number of markers to be displayed.
	*
	* @param the new limit
	*/
	void setMarkerLimit(int markerLimit) {
	this.markerLimit = markerLimit;
	}

	/**
	* @return <ul>
	* <li><code>MarkerFilter.ON_ANY_RESOURCE</code> if showing items associated with any resource.</li>
	* <li><code>MarkerFilter.ON_SELECTED_RESOURCE_ONLY</code> if showing items associated with
	* the selected resource within the workbench.</li>
	* <li><code>MarkerFilter.ON_SELECTED_RESOURCE_AND_CHILDREN</code> if showing items associated with
	* the selected resource within the workbench and its children.</li>
	* <li><code>MarkerFilter.ON_ANY_RESOURCE_OF_SAME_PROJECT</code> if showing items in the same project
	* as the selected resource within the workbench.</li>
	* <li><code>MarkerFilter.ON_WORKING_SET</code> if showing items in some working set.</li>
	* </ul>
	*/
	int getOnResource() {
	return onResource;
	}

	/**
	* Sets the type of filtering by selection.
	*
	* @param onResource must be one of:
	* <ul>
	* <li><code>MarkerFilter.ON_ANY_RESOURCE</code></li>
	* <li><code>MarkerFilter.ON_SELECTED_RESOURCE_ONLY</code></li>
	* <li><code>MarkerFilter.ON_SELECTED_RESOURCE_AND_CHILDREN</code></li>
	* <li><code>MarkerFilter.ON_ANY_RESOURCE_OF_SAME_PROJECT</code></li>
	* <li><code>MarkerFilter.ON_WORKING_SET</code></li>
	* </ul>
	*/
	void setOnResource(int onResource) {
	if (onResource >= ON_ANY_RESOURCE && onResource <= ON_WORKING_SET)
	this.onResource = onResource;
	}

	/**
	* @return the selected resource(s) withing the workbench.
	*/
	IResource[] getFocusResource() {
	return focusResource;
	}

	/**
	* Sets the focused resources.
	*/
	void setFocusResource(IResource[] resources) {
	focusResource = resources;
	}

	/**
	* @return
	* <ul>
	* <li><code>true</code> if the filter is enabled.</li>
	* <li><code>false</code> if the filter is not enabled.</li>
	* </ul>
	*/
	boolean isEnabled() {
	return enabled;
	}

	/**
	* @return
	* <ul>
	* <li><code>true</code> if filtering by marker limit is enabled.</li>
	* <li><code>false</code> if filtering by marker limit is not enabled.</li>
	* </ul>
	*/
	boolean getFilterOnMarkerLimit() {
	return filterOnMarkerLimit;
	}

	/**
	* @return the root marker types.
	*/
	List getRootTypes() {
	return rootTypes;
	}

	/**
	* @return the selected marker types to be displayed.
	*/
	List getSelectedTypes() {
	return selectedTypes;
	}

	/**
	* @return the current working set or <code>null</code> if no working set is defined.
	*/
	IWorkingSet getWorkingSet() {
	return workingSet;
	}

	/**
	* Sets the enablement state of the filter.
	*/
	void setEnabled(boolean enabled) {
	this.enabled = enabled;
	}

	/**
	* Sets the enablement state of filtering by marker limit.
	*/
	void setFilterOnMarkerLimit(boolean filterOnMarkerLimit) {
	this.filterOnMarkerLimit = filterOnMarkerLimit;
	}

	/**
	* Sets the selected marker types to be displayed. The List <b>MUST ONLY</b> contain
	* <code>MarkerType</code> objects.
	*/
	void setSelectedTypes(List selectedTypes) {
	this.selectedTypes = selectedTypes;
	}

	/**
	* Sets the current working set.
	*/
	void setWorkingSet(IWorkingSet workingSet) {
	this.workingSet = workingSet;
	}

	void resetState() {
	enabled = DEFAULT_ACTIVATION_STATUS;
	filterOnMarkerLimit = DEFAULT_FILTER_ON_MARKER_LIMIT;
	markerLimit = DEFAULT_MARKER_LIMIT;
	onResource = DEFAULT_ON_RESOURCE;
	selectedTypes.clear();
	addAllSubTypes();
	workingSet = null;
	}

	public void restoreState(IDialogSettings dialogSettings) {
	resetState();
	IDialogSettings settings = dialogSettings.getSection(TAG_DIALOG_SECTION);

	if (settings != null) {
	String setting = settings.get(TAG_ENABLED);

	if (setting != null)
	enabled = Boolean.valueOf(setting).booleanValue();

	setting = settings.get(TAG_FILTER_ON_MARKER_LIMIT);

	if (setting != null)
	filterOnMarkerLimit = Boolean.valueOf(setting).booleanValue();

	setting = settings.get(TAG_MARKER_LIMIT);

	if (setting != null)
	try {
	markerLimit = Integer.parseInt(setting);
	}
	catch (NumberFormatException eNumberFormat) {
	}

	setting = settings.get(TAG_ON_RESOURCE);

	if (setting != null)
	try {
	onResource = Integer.parseInt(setting);
	}
	catch (NumberFormatException eNumberFormat) {
	}

	setting = settings.get(TAG_SELECTED_TYPES);

	if (setting != null) {
	selectedTypes.clear();
	StringTokenizer stringTokenizer = new StringTokenizer(setting);

	while (stringTokenizer.hasMoreTokens()) {
	MarkerType markerType = typesModel.getType(stringTokenizer.nextToken(TAG_TYPES_DELIMITER));

	if (markerType != null && !selectedTypes.contains(markerType))
	selectedTypes.add(markerType);
	}
	}

	setting = settings.get(TAG_WORKING_SET);

	if (setting != null)
	workingSet = PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSet(setting);
	}
	}

	public void saveState(IDialogSettings dialogSettings) {
	if (dialogSettings != null) {
	IDialogSettings settings = dialogSettings.getSection(TAG_DIALOG_SECTION);

	if (settings == null)
	settings = dialogSettings.addNewSection(TAG_DIALOG_SECTION);

	settings.put(TAG_ENABLED, enabled);
	settings.put(TAG_FILTER_ON_MARKER_LIMIT, filterOnMarkerLimit);
	settings.put(TAG_MARKER_LIMIT, markerLimit);
	settings.put(TAG_ON_RESOURCE, onResource);

	String markerTypeIds = ""; //$NON-NLS-1$

	for (int i = 0; i < selectedTypes.size(); i++) {
	MarkerType markerType = (MarkerType) selectedTypes.get(i);
	markerTypeIds += markerType.getId() + TAG_TYPES_DELIMITER;
	}

	settings.put(TAG_SELECTED_TYPES, markerTypeIds);

	if (workingSet != null)
	settings.put(TAG_WORKING_SET, workingSet.getName());
	}
	}
	}