| /******************************************************************************* |
| * Copyright (c) 2000, 2008 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.views.markers.internal; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.StringTokenizer; |
| |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.resources.mapping.ResourceMapping; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.jface.dialogs.IDialogSettings; |
| import org.eclipse.ui.IMemento; |
| import org.eclipse.ui.IWorkingSet; |
| import org.eclipse.ui.PlatformUI; |
| |
| /** |
| * MarkerFilter is the class that defines a filter on markers in a |
| * MarkerView. |
| * |
| */ |
| public class MarkerFilter implements Cloneable { |
| |
| static final String TAG_ENABLED = "enabled"; //$NON-NLS-1$ |
| |
| |
| /** |
| * The tag for the scope. |
| */ |
| public 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$ |
| |
| /** |
| * New attribute to handle the selection status of marker types. |
| */ |
| public static final String TAG_SELECTION_STATUS = "selectionStatus"; //$NON-NLS-1$ |
| |
| /** |
| * Attribute status true. |
| */ |
| public static final String SELECTED_FALSE = "false"; //$NON-NLS-1$ |
| |
| /** |
| * Attribute status false. |
| */ |
| private static final String SELECTED_TRUE = "true"; //$NON-NLS-1$ |
| |
| /** |
| * Constant for any element. |
| */ |
| public static final int ON_ANY = 0; |
| |
| /** |
| * Constant for any selected element only. |
| */ |
| public static final int ON_SELECTED_ONLY = 1; |
| |
| /** |
| * Constant for selected element and children. |
| */ |
| public static final int ON_SELECTED_AND_CHILDREN = 2; |
| |
| /** |
| * Constant for any element in same container. |
| */ |
| public static final int ON_ANY_IN_SAME_CONTAINER = 3; |
| |
| /** |
| * Constant for on working set. |
| */ |
| public static final int ON_WORKING_SET = 4; |
| |
| static final int DEFAULT_ON_RESOURCE = ON_ANY; |
| |
| 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 enabled; |
| |
| private IResource[] focusResource; |
| |
| private Set cachedWorkingSet; |
| |
| // The human readable name for the filter |
| private String name; |
| |
| /** |
| * Create a new instance of the receiver. |
| * |
| * @param filterName |
| * The human readable name for the filter |
| * @param rootTypes |
| * The types this filter will be applied to |
| */ |
| MarkerFilter(String filterName, String[] rootTypes) { |
| |
| name = filterName; |
| |
| for (int i = 0; i < rootTypes.length; i++) { |
| MarkerType type = MarkerTypesModel.getInstance().getType( |
| rootTypes[i]); |
| |
| if (!this.rootTypes.contains(type)) { |
| this.rootTypes.add(type); |
| } |
| } |
| resetState(); |
| } |
| |
| /** |
| * List all types known to this MarkerFilter. |
| * |
| * @param types |
| * list to be filled in with types |
| */ |
| public void addAllSubTypes(List types) { |
| for (int i = 0; i < rootTypes.size(); i++) { |
| MarkerType rootType = (MarkerType) rootTypes.get(i); |
| addAllSubTypes(types, rootType); |
| } |
| } |
| |
| private void addAllSubTypes(List types, MarkerType type) { |
| if (type == null) { |
| return; |
| } |
| |
| if (!types.contains(type)) { |
| types.add(type); |
| } |
| |
| MarkerType[] subTypes = type.getSubtypes(); |
| |
| for (int i = 0; i < subTypes.length; i++) { |
| addAllSubTypes(types, subTypes[i]); |
| } |
| } |
| |
| /** |
| * Adds all markers in the given set of resources to the given list |
| * |
| * @param resultList |
| * @param resources |
| * @param markerTypeId |
| * @param depth |
| * @throws CoreException |
| */ |
| private List findMarkers(IResource[] resources, int depth, int limit, |
| IProgressMonitor mon, boolean ignoreExceptions) |
| throws CoreException { |
| if (resources == null) { |
| return Collections.EMPTY_LIST; |
| } |
| |
| List resultList = new ArrayList(resources.length * 2); |
| |
| // Optimization: if a type appears in the selectedTypes list along with |
| // all of its |
| // subtypes, then combine these in a single search. |
| |
| // List of types that haven't been replaced by one of their supertypes |
| HashSet typesToSearch = new HashSet(selectedTypes.size()); |
| |
| // List of types that appeared in selectedTypes along with all of their |
| // subtypes |
| HashSet includeAllSubtypes = new HashSet(selectedTypes.size()); |
| |
| typesToSearch.addAll(selectedTypes); |
| |
| Iterator iter = selectedTypes.iterator(); |
| |
| while (iter.hasNext()) { |
| MarkerType type = (MarkerType) iter.next(); |
| |
| Collection subtypes = Arrays.asList(type.getAllSubTypes()); |
| |
| if (selectedTypes.containsAll(subtypes)) { |
| typesToSearch.removeAll(subtypes); |
| |
| includeAllSubtypes.add(type); |
| } |
| } |
| |
| mon.beginTask(MarkerMessages.MarkerFilter_searching, typesToSearch |
| .size() |
| * resources.length); |
| |
| // Use this hash set to determine if there are any resources in the |
| // list that appear along with their parent. |
| HashSet resourcesToSearch = new HashSet(); |
| |
| // Insert all the resources into the hashset |
| for (int idx = 0; idx < resources.length; idx++) { |
| IResource next = resources[idx]; |
| |
| if (!next.exists()) { |
| continue; |
| } |
| |
| if (resourcesToSearch.contains(next)) { |
| mon.worked(typesToSearch.size()); |
| } else { |
| resourcesToSearch.add(next); |
| } |
| } |
| |
| // Iterate through all the selected resources |
| for (int resourceIdx = 0; resourceIdx < resources.length; resourceIdx++) { |
| iter = typesToSearch.iterator(); |
| |
| IResource resource = resources[resourceIdx]; |
| |
| // Skip resources that don't exist |
| if (!resource.isAccessible()) { |
| continue; |
| } |
| |
| if (depth == IResource.DEPTH_INFINITE) { |
| // Determine if any parent of this resource is also in our |
| // filter |
| IResource parent = resource.getParent(); |
| boolean found = false; |
| while (parent != null) { |
| if (resourcesToSearch.contains(parent)) { |
| found = true; |
| } |
| |
| parent = parent.getParent(); |
| } |
| |
| // If a parent of this resource is also in the filter, we can |
| // skip it |
| // because we'll pick up its markers when we search the parent. |
| if (found) { |
| continue; |
| } |
| } |
| |
| // Iterate through all the marker types |
| while (iter.hasNext()) { |
| MarkerType markerType = (MarkerType) iter.next(); |
| |
| // Only search for subtypes of the marker if we found all of its |
| // subtypes in the filter criteria. |
| IMarker[] markers = resource.findMarkers(markerType.getId(), |
| includeAllSubtypes.contains(markerType), depth); |
| |
| mon.worked(1); |
| |
| for (int idx = 0; idx < markers.length; idx++) { |
| ConcreteMarker marker; |
| try { |
| marker = MarkerList.createMarker(markers[idx]); |
| } catch (CoreException e) { |
| if (ignoreExceptions) { |
| continue; |
| } |
| throw e; |
| |
| } |
| |
| if (limit != -1 && resultList.size() >= limit) { |
| return resultList; |
| } |
| |
| if (selectMarker(marker)) { |
| resultList.add(marker); |
| } |
| } |
| } |
| } |
| |
| mon.done(); |
| |
| return resultList; |
| } |
| |
| /** |
| * Subclasses should override to determine if the given marker passes the |
| * filter. |
| * |
| * @param marker |
| * @return <code>true</code> if the marker passes the filter and |
| * <code>false</code> otherwise |
| */ |
| protected boolean selectMarker(ConcreteMarker marker) { |
| return true; |
| } |
| |
| /** |
| * Searches the workspace for markers that pass this filter. |
| * |
| * @return Collection of markers. |
| */ |
| Collection findMarkers(IProgressMonitor mon, boolean ignoreExceptions) |
| throws CoreException { |
| |
| List unfiltered = Collections.EMPTY_LIST; |
| |
| if (!isEnabled()) { |
| unfiltered = findMarkers(new IResource[] { ResourcesPlugin |
| .getWorkspace().getRoot() }, IResource.DEPTH_INFINITE, -1, |
| mon, ignoreExceptions); |
| } else { |
| // int limit = getFilterOnMarkerLimit() ? getMarkerLimit() + 1 : -1; |
| int limit = -1; |
| |
| switch (getOnResource()) { |
| case ON_ANY: { |
| unfiltered = findMarkers(new IResource[] { ResourcesPlugin |
| .getWorkspace().getRoot() }, IResource.DEPTH_INFINITE, |
| limit, mon, ignoreExceptions); |
| break; |
| } |
| case ON_SELECTED_ONLY: { |
| unfiltered = findMarkers(focusResource, IResource.DEPTH_ZERO, |
| limit, mon, ignoreExceptions); |
| break; |
| } |
| case ON_SELECTED_AND_CHILDREN: { |
| unfiltered = findMarkers(focusResource, |
| IResource.DEPTH_INFINITE, limit, mon, ignoreExceptions); |
| break; |
| } |
| case ON_ANY_IN_SAME_CONTAINER: { |
| unfiltered = findMarkers(getProjects(focusResource), |
| IResource.DEPTH_INFINITE, limit, mon, ignoreExceptions); |
| break; |
| } |
| case ON_WORKING_SET: { |
| unfiltered = findMarkers(getResourcesInWorkingSet(), |
| IResource.DEPTH_INFINITE, limit, mon, ignoreExceptions); |
| } |
| } |
| } |
| |
| if (unfiltered == null) { |
| unfiltered = Collections.EMPTY_LIST; |
| } |
| |
| return unfiltered; |
| } |
| |
| /** |
| * Return the resources in the working set. If it is empty then return the |
| * workspace root. |
| * |
| * @return IResource[] |
| */ |
| IResource[] getResourcesInWorkingSet() { |
| if (workingSet == null) { |
| return new IResource[0]; |
| } |
| |
| if (workingSet.isEmpty()) { |
| return new IResource[] { ResourcesPlugin.getWorkspace().getRoot() }; |
| } |
| |
| IAdaptable[] elements = workingSet.getElements(); |
| List result = new ArrayList(elements.length); |
| |
| for (int idx = 0; idx < elements.length; idx++) { |
| IResource next = (IResource) elements[idx] |
| .getAdapter(IResource.class); |
| |
| if (next != null) { |
| result.add(next); |
| } |
| } |
| |
| return (IResource[]) result.toArray(new IResource[result.size()]); |
| } |
| |
| /** |
| * Returns a set of strings representing the full pathnames to every |
| * resource directly or indirectly contained in the working set. A resource |
| * is in the working set iff its path name can be found in this set. |
| * |
| * @return Set |
| */ |
| private Set getWorkingSetAsSetOfPaths() { |
| if (cachedWorkingSet == null) { |
| HashSet result = new HashSet(); |
| |
| addResourcesAndChildren(result, getResourcesInWorkingSet()); |
| |
| cachedWorkingSet = result; |
| } |
| |
| return cachedWorkingSet; |
| } |
| |
| /*************************************************************************** |
| * Adds the paths of all resources in the given array to the given set. |
| */ |
| private void addResourcesAndChildren(HashSet result, IResource[] resources) { |
| for (int idx = 0; idx < resources.length; idx++) { |
| |
| IResource currentResource = resources[idx]; |
| |
| result.add(currentResource.getFullPath().toString()); |
| |
| if (currentResource instanceof IContainer) { |
| IContainer cont = (IContainer) currentResource; |
| |
| try { |
| addResourcesAndChildren(result, cont.members()); |
| } catch (CoreException e) { |
| // Ignore errors |
| } |
| } |
| |
| } |
| } |
| |
| /** |
| * Returns the set of projects that contain the given set of resources. |
| * |
| * @param resources |
| * @return IProject[] |
| */ |
| static IProject[] getProjects(IResource[] resources) { |
| if (resources == null) { |
| return new IProject[0]; |
| } |
| |
| Collection projects = getProjectsAsCollection(resources); |
| |
| return (IProject[]) projects.toArray(new IProject[projects.size()]); |
| } |
| |
| /** |
| * Return the projects for the elements. |
| * |
| * @param elements |
| * collection of IResource or IResourceMapping |
| * @return Collection of IProject |
| */ |
| static Collection getProjectsAsCollection(Object[] elements) { |
| HashSet projects = new HashSet(); |
| |
| for (int idx = 0; idx < elements.length; idx++) { |
| if (elements[idx] instanceof IResource) { |
| projects.add(((IResource) elements[idx]).getProject()); |
| } else { |
| IProject[] mappingProjects = (((ResourceMapping) elements[idx]) |
| .getProjects()); |
| for (int i = 0; i < mappingProjects.length; i++) { |
| projects.add(mappingProjects[i]); |
| } |
| } |
| |
| } |
| |
| return projects; |
| } |
| |
| /** |
| * Return whether or not the receiver would select the marker. |
| * |
| * @param marker |
| * @return boolean |
| */ |
| public boolean select(ConcreteMarker marker) { |
| if (!isEnabled()) { |
| return true; |
| } |
| |
| return selectByType(marker) && selectBySelection(marker) |
| && selectMarker(marker); |
| } |
| |
| private boolean selectByType(ConcreteMarker marker) { |
| return selectedTypes.contains(MarkerTypesModel.getInstance().getType( |
| marker.getType())); |
| } |
| |
| /** |
| * 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(ConcreteMarker marker) { |
| if (onResource == ON_ANY || marker == null) { |
| return true; |
| } |
| |
| if (focusResource == null) { |
| return true; |
| } |
| |
| IResource resource = marker.getResource(); |
| |
| if (onResource == ON_WORKING_SET) { |
| |
| if (resource != null) { |
| return isEnclosed(resource); |
| } |
| |
| } else if (onResource == ON_ANY_IN_SAME_CONTAINER) { |
| IProject project = resource.getProject(); |
| |
| if (project == null) { |
| return false; |
| } |
| |
| for (int i = 0; i < focusResource.length; i++) { |
| IProject selectedProject = focusResource[i].getProject(); |
| |
| if (selectedProject == null) { |
| continue; |
| } |
| |
| if (project.equals(selectedProject)) { |
| return true; |
| } |
| } |
| } else if (onResource == ON_SELECTED_ONLY) { |
| for (int i = 0; i < focusResource.length; i++) { |
| if (resource.equals(focusResource[i])) { |
| return true; |
| } |
| } |
| } else if (onResource == ON_SELECTED_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. |
| * Previous versions of this method used IContainmentAdapter for containment |
| * tests. For performance reasons, this is no longer possible. Code that |
| * relies on this behavior should be updated appropriately. |
| * |
| * @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) { |
| if (workingSet == null) { |
| return false; |
| } |
| |
| if (workingSet.isEmpty()) { |
| return true; // Everything is in an empty working set |
| } |
| Set workingSetPaths = getWorkingSetAsSetOfPaths(); |
| |
| return workingSetPaths.contains(element.getFullPath().toString()); |
| } |
| |
| /** |
| * <ul> |
| * <li><code>MarkerFilter.ON_ANY</code> if showing items associated with |
| * any resource.</li> |
| * <li><code>MarkerFilter.ON_SELECTED_ONLY</code> if showing items |
| * associated with the selected resource within the workbench.</li> |
| * <li><code>MarkerFilter.ON_SELECTED_AND_CHILDREN</code> if showing |
| * items associated with the selected resource within the workbench and its |
| * children.</li> |
| * <li><code>MarkerFilter.ON_ANY_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> |
| * |
| * @return int |
| */ |
| public 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 && onResource <= ON_WORKING_SET) { |
| this.onResource = onResource; |
| } |
| } |
| |
| /** |
| * @return the selected resource(s) withing the workbench. |
| */ |
| IResource[] getFocusResource() { |
| return focusResource; |
| } |
| |
| /** |
| * Sets the focused resources. |
| * |
| * @param resources |
| */ |
| public 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> |
| */ |
| public boolean isEnabled() { |
| return enabled; |
| } |
| |
| /** |
| * <b>Warning:</b> for internal package use only. Return the root marker |
| * types. |
| * |
| * @return the root marker types. |
| */ |
| public List getRootTypes() { |
| return rootTypes; |
| } |
| |
| /** |
| * <b>Warning:</b> for internal package use only. Return the selected |
| * types. |
| * |
| * @return the selected marker types to be displayed. |
| */ |
| public List getSelectedTypes() { |
| return selectedTypes; |
| } |
| |
| /** |
| * Find the typeModel entry that matches id. |
| * |
| * @param id |
| * the ID for a marker type |
| * @return MarkerType or <code>null</code> if it is not found. |
| */ |
| public MarkerType getMarkerType(String id) { |
| return MarkerTypesModel.getInstance().getType(id); |
| } |
| |
| /** |
| * @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 current working set. |
| */ |
| void setWorkingSet(IWorkingSet workingSet) { |
| this.workingSet = workingSet; |
| cachedWorkingSet = null; |
| } |
| |
| /** |
| * Reset to the default state. |
| */ |
| void resetState() { |
| enabled = DEFAULT_ACTIVATION_STATUS; |
| onResource = DEFAULT_ON_RESOURCE; |
| selectedTypes.clear(); |
| addAllSubTypes(selectedTypes); |
| setWorkingSet(null); |
| } |
| |
| /** |
| * Restore the state in the memento. |
| * |
| * @param memento |
| */ |
| public final void restoreState(IMemento memento) { |
| resetState(); |
| restoreFilterSettings(memento); |
| |
| } |
| |
| /** |
| * Restore the state of the receiver in the supplied settings. This is kept |
| * for backwards compatibility with 3.1 dialog settings. |
| * |
| * @param settings |
| */ |
| public void restoreFilterSettings(IDialogSettings settings) { |
| |
| resetState(); |
| |
| String setting = settings.get(TAG_ENABLED); |
| |
| if (setting != null) { |
| enabled = Boolean.valueOf(setting).booleanValue(); |
| } |
| |
| setting = settings.get(TAG_ON_RESOURCE); |
| |
| if (setting != null) { |
| try { |
| onResource = Integer.parseInt(setting); |
| } catch (NumberFormatException eNumberFormat) { |
| } |
| } |
| |
| // new selection list attribute |
| // format is "id:(true|false):" |
| setting = settings.get(TAG_SELECTION_STATUS); |
| |
| if (setting != null) { |
| selectedTypes.clear(); |
| |
| // get the complete list of types |
| List newTypes = new ArrayList(); |
| addAllSubTypes(newTypes); |
| |
| StringTokenizer stringTokenizer = new StringTokenizer(setting); |
| |
| while (stringTokenizer.hasMoreTokens()) { |
| String id = stringTokenizer.nextToken(TAG_TYPES_DELIMITER); |
| String status = null; |
| if (stringTokenizer.hasMoreTokens()) { |
| status = stringTokenizer.nextToken(TAG_TYPES_DELIMITER); |
| } |
| |
| MarkerType markerType = MarkerTypesModel.getInstance().getType( |
| id); |
| if (markerType != null) { |
| newTypes.remove(markerType); |
| |
| // add the type to the selected list |
| if (!SELECTED_FALSE.equals(status) |
| && !selectedTypes.contains(markerType)) { |
| selectedTypes.add(markerType); |
| } |
| } |
| } |
| |
| // any types we know about that weren't either true or |
| // false in the selection attribute are new. By default, |
| // new marker types will be selected=true |
| for (int i = 0; i < newTypes.size(); ++i) { |
| selectedTypes.add(newTypes.get(i)); |
| } |
| } else { |
| // the settings didn't contain the new selection attribute |
| // so check for the old selection attribute. |
| // format is just "id:" |
| setting = settings.get(TAG_SELECTED_TYPES); |
| |
| if (setting != null) { |
| generateSelectedTypes(setting); |
| } |
| |
| } |
| |
| setting = settings.get(TAG_WORKING_SET); |
| |
| if (setting != null) { |
| setWorkingSet(PlatformUI.getWorkbench().getWorkingSetManager() |
| .getWorkingSet(setting)); |
| } |
| } |
| |
| /** |
| * Set the selected types based on the value. |
| * |
| * @param selectedTypesValue |
| */ |
| void generateSelectedTypes(String selectedTypesValue) { |
| selectedTypes.clear(); |
| StringTokenizer stringTokenizer = new StringTokenizer( |
| selectedTypesValue); |
| |
| while (stringTokenizer.hasMoreTokens()) { |
| MarkerType markerType = getMarkerType(stringTokenizer |
| .nextToken(TAG_TYPES_DELIMITER)); |
| |
| if (markerType != null && !selectedTypes.contains(markerType)) { |
| selectedTypes.add(markerType); |
| } |
| } |
| } |
| |
| /** |
| * Find the markerType matching typeName |
| * |
| * @param typeName |
| * @return MarkerType |
| */ |
| MarkerType findMarkerType(String typeName) { |
| return MarkerTypesModel.getInstance().getType(typeName); |
| } |
| |
| /** |
| * Restore the state of the receiver in the supplied settings. |
| * |
| * @param memento |
| */ |
| protected void restoreFilterSettings(IMemento memento) { |
| String setting = memento.getString(TAG_ENABLED); |
| |
| if (setting != null) { |
| enabled = Boolean.valueOf(setting).booleanValue(); |
| } |
| |
| Integer resourceSetting = memento.getInteger(TAG_ON_RESOURCE); |
| |
| if (resourceSetting != null) { |
| onResource = resourceSetting.intValue(); |
| } |
| |
| // new selection list attribute |
| // format is "id:(true|false):" |
| setting = memento.getString(TAG_SELECTION_STATUS); |
| |
| if (setting != null) { |
| selectedTypes.clear(); |
| |
| // get the complete list of types |
| List newTypes = new ArrayList(); |
| addAllSubTypes(newTypes); |
| |
| StringTokenizer stringTokenizer = new StringTokenizer(setting); |
| |
| while (stringTokenizer.hasMoreTokens()) { |
| String id = stringTokenizer.nextToken(TAG_TYPES_DELIMITER); |
| String status = null; |
| if (stringTokenizer.hasMoreTokens()) { |
| status = stringTokenizer.nextToken(TAG_TYPES_DELIMITER); |
| } |
| |
| MarkerType markerType = MarkerTypesModel.getInstance().getType( |
| id); |
| if (markerType != null) { |
| newTypes.remove(markerType); |
| |
| // add the type to the selected list |
| if (!SELECTED_FALSE.equals(status) |
| && !selectedTypes.contains(markerType)) { |
| selectedTypes.add(markerType); |
| } |
| } |
| } |
| |
| // any types we know about that weren't either true or |
| // false in the selection attribute are new. By default, |
| // new marker types will be selected=true |
| for (int i = 0; i < newTypes.size(); ++i) { |
| selectedTypes.add(newTypes.get(i)); |
| } |
| } else { |
| // the settings didn't contain the new selection attribute |
| // so check for the old selection attribute. |
| // format is just "id:" |
| setting = memento.getString(TAG_SELECTED_TYPES); |
| |
| if (setting != null) { |
| generateSelectedTypes(setting); |
| } |
| |
| } |
| |
| setting = memento.getString(TAG_WORKING_SET); |
| |
| if (setting != null) { |
| setWorkingSet(PlatformUI.getWorkbench().getWorkingSetManager() |
| .getWorkingSet(setting)); |
| } |
| } |
| |
| /** |
| * Save the filter settings for the receiver. |
| * |
| * @param settings |
| */ |
| public void saveFilterSettings(IMemento settings) { |
| |
| settings.putString(TAG_ENABLED, String.valueOf(enabled)); |
| settings.putInteger(TAG_ON_RESOURCE, onResource); |
| |
| String markerTypeIds = ""; //$NON-NLS-1$ |
| |
| List includedTypes = new ArrayList(); |
| addAllSubTypes(includedTypes); |
| for (int i = 0; i < includedTypes.size(); i++) { |
| MarkerType markerType = (MarkerType) includedTypes.get(i); |
| markerTypeIds += markerType.getId() + TAG_TYPES_DELIMITER; |
| if (selectedTypes.contains(markerType)) { |
| markerTypeIds += SELECTED_TRUE + TAG_TYPES_DELIMITER; |
| } else { |
| markerTypeIds += SELECTED_FALSE + TAG_TYPES_DELIMITER; |
| } |
| } |
| |
| settings.putString(TAG_SELECTION_STATUS, markerTypeIds); |
| |
| if (workingSet != null) { |
| settings.putString(TAG_WORKING_SET, workingSet.getName()); |
| } |
| } |
| |
| /** |
| * Get the name of the receiver |
| * |
| * @return String |
| */ |
| public String getName() { |
| return name; |
| } |
| |
| /** |
| * Make a clone of the receiver. |
| * |
| * @return MarkerFilter |
| * @throws CloneNotSupportedException |
| */ |
| public MarkerFilter makeClone() throws CloneNotSupportedException { |
| return (MarkerFilter) this.clone(); |
| } |
| |
| /** |
| * Set the selected types. |
| * |
| * @param selectedTypes |
| * List of MarkerType. |
| */ |
| public void setSelectedTypes(List selectedTypes) { |
| this.selectedTypes = selectedTypes; |
| } |
| |
| } |