Attachment #17581 for bug #60117

Lines 99-109 Link Here

(-)src/org/eclipse/ui/views/markers/internal/ActionDeleteCompleted.java (-4 / +4 lines)
99		99
100	for (int i = 0; i < markers.length; i++) {	100	for (int i = 0; i < markers.length; i++) {
101	ConcreteMarker marker = markers[i];	101	ConcreteMarker marker = markers[i];
102	if (marker instanceof TaskMarker) {	102	if (marker instanceof ConcreteMarker) {
103	TaskMarker taskMarker = (TaskMarker) marker;	103	ConcreteMarker ConcreteMarker = (ConcreteMarker) marker;
104		104
105	if (taskMarker.getDone() == 1) {	105	if (ConcreteMarker.getDone() == 1) {
106	completed.add(taskMarker.getMarker());	106	completed.add(ConcreteMarker.getMarker());
107	}	107	}
108	}	108	}
109	}	109	}




import org.eclipse.core.resources.IMarker;
import org.eclipse.jface.dialogs.IDialogSettings;

public class BookmarkFilter extends MarkerFilterCriteria {

    private final static String TAG_CONTAINS = "contains"; //$NON-NLS-1$


        super(new String[] { IMarker.BOOKMARK });
    }

    /**
     * Returns true iff the given marker is accepted by this filter
     */
    public boolean selectMarker(ConcreteMarker marker) {
        return !isEnabled()
                || (super.selectMarker(marker) && selectByDescription(marker));
    }

    private boolean selectByDescription(ConcreteMarker marker) {
        if (description == null || description.equals("")) //$NON-NLS-1$
            return true;

        String markerDescription = marker.getDescription();
        int index = markerDescription.indexOf(description);
        return contains ? (index >= 0) : (index < 0);
    }

    boolean getContains() {
        return contains;
    }

        description = DEFAULT_DESCRIPTION;
    }

    /* (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerFilterCriteria#getMarkerFilter()
	 */
	protected MarkerFilter getMarkerFilter() {
		MarkerFilter result = super.getMarkerFilter();
		
		result.setDescription(description, contains);
		
		return result;
	}
    
    public void restoreState(IDialogSettings dialogSettings) {
        super.restoreState(dialogSettings);
        IDialogSettings settings = dialogSettings




/*******************************************************************************
 * 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 org.eclipse.core.resources.IMarker;

/**
 * Represents a marker visible in the Bookmarks view. Currently, this adds no additional
 * fields to the ConcreteMarker class. However, if additional fields were added to the
 * bookmark view that are not general to all views, these fields would be added to this
 * class.
 */
public class BookmarkMarker extends ConcreteMarker {

    /**
     * @param toCopy
     */
    public BookmarkMarker(IMarker toCopy) {
        super(toCopy);
    }

}





import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.dialogs.ErrorDialog;

                Object data = item.getData();

                if (data instanceof ConcreteMarker) {
                    IMarker marker = ((ConcreteMarker) data).getMarker();

                    try {
                        IMarker marker = ((ConcreteMarker) data).getMarker();
                        if (!marker.getAttribute(property).equals(value)) {
                            if (IMarker.MESSAGE.equals(property))
                                marker.setAttribute(IMarker.MESSAGE, value);

        return ROOT_TYPES;
    }

    protected Object getViewerInput() {
        return ResourcesPlugin.getWorkspace().getRoot();
    }

    protected IField[] getVisibleFields() {
        return VISIBLE_FIELDS;
    }

        if (dialog.open() == Window.OK) {
            bookmarkFilter = (BookmarkFilter) dialog.getFilter();
            bookmarkFilter.saveState(getDialogSettings());
            setFilter(dialog.getFilter().getFilter());
            setLimit(getFilterCriteria().getMarkerLimit());
//            refresh();
        }
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.views.markers.internal.MarkerView#getFilter()
     */
    protected MarkerFilterCriteria getFilterCriteria() {
        return bookmarkFilter;
    }


Lines 42-56 Link Here

(-)src/org/eclipse/ui/views/markers/internal/ConcreteMarker.java (-14 / +77 lines)
42		42
43	private long creationTime;	43	private long creationTime;
44		44
		45	private int severity;
		46
45	private String type;	47	private String type;
46		48
47	private IMarker marker;	49	private boolean isBookmark;
48		50
		51	private int priority;
		52
		53	private int done;
		54
		55	private boolean isTask;
		56
		57	private boolean isProblem;
		58
		59	private IResource resource;
		60
		61	private long id;
		62
49	public ConcreteMarker(IMarker toCopy) {	63	public ConcreteMarker(IMarker toCopy) {
50	marker = toCopy;	64	this.id = toCopy.getId();
		65	this.resource = toCopy.getResource();
		66	this.type = ""; //$NON-NLS-1$
51	refresh();	67	refresh();
52	}	68	}
53		69
		70	public int getPriority() {
		71	return priority;
		72	}
		73
		74	public int getDone() {
		75	return done;
		76	}
		77
54	/**	78	/**
55	* Clears any cached information. This frees up some memory, but will slow down	79	* Clears any cached information. This frees up some memory, but will slow down
56	* the next comparison operation. It is a good idea to call this on a set of markers	80	* the next comparison operation. It is a good idea to call this on a set of markers
Lines 62-81 Link Here
62	inFolderKey = null;	86	inFolderKey = null;
63	}	87	}
64		88
		89	public int getSeverity() {
		90	return severity;
		91	}
		92
		93	public String getType() {
		94	return type;
		95	}
		96
65	/**	97	/**
66	* Refresh the properties of this marker from the underlying IMarker instance	98	* Refresh the properties of this marker from the underlying IMarker instance
67	*/	99	*/
68	public void refresh() {	100	public void refresh() {
69	clearCache();	101	clearCache();
70		102
		103	creationTime = 0;
		104	isBookmark = false;
		105	isTask = false;
		106	isProblem = false;
		107
		108	IMarker marker;
		109	try {
		110	marker = getMarker();
		111	} catch (CoreException e2) {
		112	return;
		113	}
		114
71	description = Util.getProperty(IMarker.MESSAGE, marker);	115	description = Util.getProperty(IMarker.MESSAGE, marker);
72	resourceName = marker.getResource().getName();	116	resourceName = marker.getResource().getName();
73	inFolder = Util.getContainerName(marker);	117	inFolder = Util.getContainerName(marker);
74	line = marker.getAttribute(IMarker.LINE_NUMBER, -1);	118	line = marker.getAttribute(IMarker.LINE_NUMBER, -1);
		119
75	try {	120	try {
76	creationTime = marker.getCreationTime();	121	isBookmark = marker.isSubtypeOf(IMarker.BOOKMARK);
		122	isTask = marker.isSubtypeOf(IMarker.TASK);
		123	isProblem = marker.isSubtypeOf(IMarker.PROBLEM);
		124	creationTime = marker.getCreationTime();
77	} catch (CoreException e) {	125	} catch (CoreException e) {
78	creationTime = 0;
79	}	126	}
80		127
81	try {	128	try {
Lines 83-96 Link Here
83	} catch (CoreException e1) {	130	} catch (CoreException e1) {
84	type = ""; //$NON-NLS-1$	131	type = ""; //$NON-NLS-1$
85	}	132	}
		133
		134	priority = marker.getAttribute(IMarker.PRIORITY,
		135	IMarker.PRIORITY_NORMAL);
		136	done = -1;
		137	if (marker.getAttribute(IMarker.USER_EDITABLE, true)) {
		138	done = 0;
		139	if (marker.getAttribute(IMarker.DONE, false)) {
		140	done = 1;
		141	}
		142	}
		143
		144	severity = marker.getAttribute(IMarker.SEVERITY, -1);
86	}	145	}
87		146
88	public IResource getResource() {	147	public IResource getResource() {
89	return marker.getResource();	148	return resource;
90	}
91
92	public String getType() {
93	return type;
94	}	149	}
95		150
96	public String getDescription() {	151	public String getDescription() {
Lines 137-146 Link Here
137	return creationTime;	192	return creationTime;
138	}	193	}
139		194
140	public IMarker getMarker() {	195	public String toString() {
141	return marker;	196	return description;
142	}	197	}
143		198
		199	public long getId() {
		200	return id;
		201	}
		202
		203	public IMarker getMarker() throws CoreException {
		204	return resource.getMarker(getId());
		205	}
		206
144	public boolean equals(Object object) {	207	public boolean equals(Object object) {
145	if (!(object instanceof ConcreteMarker)) {	208	if (!(object instanceof ConcreteMarker)) {
146	return false;	209	return false;
Lines 148-157 Link Here
148		211
149	ConcreteMarker other = (ConcreteMarker) object;	212	ConcreteMarker other = (ConcreteMarker) object;
150		213
151	return other.getMarker().equals(getMarker());	214	return other.getId() == getId() && other.getResource().equals(getResource());
152	}	215	}
153		216
154	public int hashCode() {	217	public int hashCode() {
155	return getMarker().hashCode();	218	return ((int)getId()) + getResource().hashCode();
156	}	219	}
157	}	220	}




        }
    }

    private MarkerFilterCriteria filter;

    private CheckboxTableViewer typesViewer;


    /**
     * Creates a new filters dialog.
     */
    DialogMarkerFilter(Shell parentShell, MarkerFilterCriteria filter) {
        super(parentShell);
        this.filter = filter;
    }

     */
    protected void resetPressed() {
        filterEnabledButton
                .setSelection(MarkerFilterCriteria.DEFAULT_ACTIVATION_STATUS);
        filterOnMarkerLimit
                .setSelection(MarkerFilterCriteria.DEFAULT_FILTER_ON_MARKER_LIMIT);
        markerLimit.setText(String.valueOf(MarkerFilterCriteria.DEFAULT_MARKER_LIMIT));
        typesViewer.setAllChecked(true);
        int onResource = MarkerFilterCriteria.DEFAULT_ON_RESOURCE;
        anyResourceButton
                .setSelection(onResource == MarkerFilterCriteria.ON_ANY_RESOURCE);
        anyResourceInSameProjectButton
                .setSelection(onResource == MarkerFilterCriteria.ON_ANY_RESOURCE_OF_SAME_PROJECT);
        selectedResourceButton
                .setSelection(onResource == MarkerFilterCriteria.ON_SELECTED_RESOURCE_ONLY);
        selectedResourceAndChildrenButton
                .setSelection(onResource == MarkerFilterCriteria.ON_SELECTED_RESOURCE_AND_CHILDREN);
        workingSetGroup.setSelection(onResource == MarkerFilterCriteria.ON_WORKING_SET);
        updateEnabledState();
    }


        filter.setSelectedTypes(getSelectedTypes());

        if (selectedResourceButton.getSelection())
            filter.setOnResource(MarkerFilterCriteria.ON_SELECTED_RESOURCE_ONLY);
        else if (selectedResourceAndChildrenButton.getSelection())
            filter
                    .setOnResource(MarkerFilterCriteria.ON_SELECTED_RESOURCE_AND_CHILDREN);
        else if (anyResourceInSameProjectButton.getSelection())
            filter.setOnResource(MarkerFilterCriteria.ON_ANY_RESOURCE_OF_SAME_PROJECT);
        else if (workingSetGroup.getSelection())
            filter.setOnResource(MarkerFilterCriteria.ON_WORKING_SET);
        else
            filter.setOnResource(MarkerFilterCriteria.ON_ANY_RESOURCE);

        filter.setWorkingSet(workingSetGroup.getWorkingSet());

        int markerLimit = MarkerFilterCriteria.DEFAULT_MARKER_LIMIT;

        try {
            markerLimit = Integer.parseInt(this.markerLimit.getText());

        setSelectedTypes(filter.getSelectedTypes());

        int on = filter.getOnResource();
        anyResourceButton.setSelection(on == MarkerFilterCriteria.ON_ANY_RESOURCE);
        anyResourceInSameProjectButton
                .setSelection(on == MarkerFilterCriteria.ON_ANY_RESOURCE_OF_SAME_PROJECT);
        selectedResourceButton
                .setSelection(on == MarkerFilterCriteria.ON_SELECTED_RESOURCE_ONLY);
        selectedResourceAndChildrenButton
                .setSelection(on == MarkerFilterCriteria.ON_SELECTED_RESOURCE_AND_CHILDREN);
        workingSetGroup.setSelection(on == MarkerFilterCriteria.ON_WORKING_SET);
        workingSetGroup.setWorkingSet(filter.getWorkingSet());

        markerLimit.setText("" + filter.getMarkerLimit()); //$NON-NLS-1$

        dirty = true;
    }

    public void setFilter(MarkerFilterCriteria newFilter) {
        filter = newFilter;
        updateUIFromFilter();
    }

    /**
     * @return the MarkerFilter associated with the dialog.
     */
    public MarkerFilterCriteria getFilter() {
        return filter;
    }





     * @see org.eclipse.ui.views.markers.internal.IField#getImage(java.lang.Object)
     */
    public Image getImage(Object obj) {
        if (obj == null || !(obj instanceof ConcreteMarker)) {
            return null;
        }
        ConcreteMarker marker = (ConcreteMarker) obj;
        int done = marker.getDone();
        if (done == -1) {
            return null;

     * @see org.eclipse.ui.views.markers.internal.IField#compare(java.lang.Object, java.lang.Object)
     */
    public int compare(Object obj1, Object obj2) {
        if (obj1 == null || obj2 == null || !(obj1 instanceof ConcreteMarker)
                || !(obj2 instanceof ConcreteMarker)) {
            return 0;
        }
        ConcreteMarker marker1 = (ConcreteMarker) obj1;
        ConcreteMarker marker2 = (ConcreteMarker) obj2;
        int value1 = marker1.getDone();
        int value2 = marker2.getDone();
        return value1 - value2;




     * @see org.eclipse.ui.views.markers.internal.IField#getImage(java.lang.Object)
     */
    public Image getImage(Object obj) {
        if (obj == null || !(obj instanceof ConcreteMarker)) {
            return null;
        }
        try {
            int priority = ((ConcreteMarker) obj).getPriority();
            if (priority == IMarker.PRIORITY_HIGH) {
                return ImageFactory.getImage(HIGH_PRIORITY_IMAGE_PATH);
            }

     * @see org.eclipse.ui.views.markers.internal.IField#compare(java.lang.Object, java.lang.Object)
     */
    public int compare(Object obj1, Object obj2) {
        if (obj1 == null || obj2 == null || !(obj1 instanceof ConcreteMarker)
                || !(obj2 instanceof ConcreteMarker)) {
            return 0;
        }
        int priority1 = ((ConcreteMarker) obj1).getPriority();
        int priority2 = ((ConcreteMarker) obj2).getPriority();
        return priority1 - priority2;
    }





     * @see org.eclipse.ui.views.markers.internal.IField#getValue(java.lang.Object)
     */
    public String getValue(Object obj) {
        return "" + ((ConcreteMarker) obj).getSeverity(); //$NON-NLS-1$
    }

    /*

     * @see org.eclipse.ui.views.markers.internal.IField#getImage(java.lang.Object)
     */
    public Image getImage(Object obj) {
        if (obj == null || !(obj instanceof ConcreteMarker)) {
            return null;
        }

        int severity = ((ConcreteMarker) obj).getSeverity();
        if (severity == IMarker.SEVERITY_ERROR) {
            return ImageFactory.getImage(IMAGE_ERROR_PATH);
        }

     * @see org.eclipse.ui.views.markers.internal.IField#compare(java.lang.Object, java.lang.Object)
     */
    public int compare(Object obj1, Object obj2) {
        if (obj1 == null || obj2 == null || !(obj1 instanceof ConcreteMarker)
                || !(obj2 instanceof ConcreteMarker)) {
            return 0;
        }

        int severity1 = ((ConcreteMarker) obj1).getSeverity();
        int severity2 = ((ConcreteMarker) obj2).getSeverity();
        return severity1 - severity2;
    }





/*******************************************************************************
 * 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;

/**
 * Generic filtering interface.
 */
public interface IFilter {

    /**
     * Filters the list of elements. Removes the elements that need to filtered out from the list.
     * 
     * @param elements
     */
    public Object[] filter(Object[] elements);

    /**
     * @param item
     * @return
     * <ul>
     * <li><code>true</code> if the item will make it through the filter.</li>
     * <li><code>false</code> if the item will not make it through the filter.</li>
     * </ul>
     */
    public boolean select(Object item);

}




/*******************************************************************************
 * 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;

public interface ITableViewContentProvider {

    public Object[] getElements();

    public IFilter getFilter();

    public void setFilter(IFilter filter);

    public void addItemsChangedListener(IItemsChangedListener listener);

    public void removeItemsChangedListener(IItemsChangedListener listener);

}





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.runtime.IPath;
import org.eclipse.jface.viewers.deferred.IFilter;
import org.eclipse.core.resources.ResourcesPlugin;
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.IWorkingSet;
import org.eclipse.ui.internal.WorkbenchPlugin;

public class MarkerFilter implements IFilter {

    final static int DEFAULT_SEVERITY = 0;
    final static int SEVERITY_ERROR = 1 << 2;
    final static int SEVERITY_WARNING = 1 << 1;
    final static int SEVERITY_INFO = 1 << 0;
    
    final static int PRIORITY_HIGH = 1 << 2;
    final static int PRIORITY_NORMAL = 1 << 1;
    final static int PRIORITY_LOW = 1 << 0;
	
    protected String[] requiredTypes;

    private String description = ""; //$NON-NLS-1$
    private boolean contains;
    
    private boolean selectBySeverity;
    private int severity;
    
    private boolean done;
    private int priority;
    private boolean selectByPriority;
    private boolean selectByDone;
    
    /**
     * Set of IPath containing workspace-relative paths to resources accepted
     * by this filter. null if the filter accepts any resource. 
     */
    private Set resourcePaths;
    private boolean includeChildResources = false;
    private Set requiredTypeSet;
    
    MarkerFilter(String[] requiredTypes) {
    	this.requiredTypes = requiredTypes;
    	this.resourcePaths = null;    	
    }
    
//    MarkerFilter(String[] requiredTypes, IResource[] exactResources) {
//    	this.requiredTypes = requiredTypes;
//    	this.requiredResources = exactResources;
//    }
    
    /**
     * @param resourcePathSet Set of IPath
     */
    MarkerFilter(String[] requiredTypes, Set resourcePathSet, boolean includeChildResources) {
    	this.requiredTypes = requiredTypes;
    	resourcePaths = resourcePathSet;
    	this.includeChildResources = includeChildResources;
    }
    
    /* (non-Javadoc)
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	public boolean equals(Object arg0) {
		if (!(arg0 instanceof MarkerFilter)) {
			return false;
		}

		MarkerFilter other = (MarkerFilter)arg0;
				
		if (!(other.contains == contains
				&& other.description.equals(description)
				&& other.selectBySeverity == selectBySeverity
				&& other.severity == severity
				&& other.done == done
				&& other.priority == priority
				&& other.includeChildResources == includeChildResources
				&& other.selectByPriority == selectByPriority
				&& other.selectBySeverity == selectBySeverity
				&& other.requiredTypes.length == requiredTypes.length)) return false;
		
		for (int i = 0; i < other.requiredTypes.length; i++) {
			String type = other.requiredTypes[i];
			
			if (!selectByType(type)) {
				return false;
			}
		}
		
		if (resourcePaths == null || other.resourcePaths == null) {
			// Unless they're both null, the filters aren't equal
			if (resourcePaths != other.resourcePaths) {
				return false;
			}
		} else {
			if (!includeChildResources) {
				if (!resourcePaths.equals(other.resourcePaths)) return false;
			} else {
				// Check for "resources + children" style matches
				for (Iterator iter = resourcePaths.iterator(); iter.hasNext();) {
					IPath next = (IPath) iter.next();
					
					if (!other.selectByResource(next)) {
						return false;
					}
				}
				for (Iterator iter = other.resourcePaths.iterator(); iter.hasNext();) {
					IPath next = (IPath) iter.next();
					
					if (!selectByResource(next)) {
						return false;
					}
				}
			}
		}
		
		return true;
	}
    
    /* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.deferred.IFilter#select(java.lang.Object)
	 */
	public boolean select(Object toTest) {
		if (!(toTest instanceof ConcreteMarker)) {
			return false;
		}
		ConcreteMarker m = (ConcreteMarker)toTest;
		
		if (selectByType(m.getType()) && selectByResource(m.getResource().getFullPath()) && selectByDescription(m) && selectBySeverity(m) 
				&& selectByDone(m) && selectByPriority(m)) {
			return true;
		}
		
		return false;
	}
	
	private boolean selectByResource(IPath resource) {
		
		if (resourcePaths == null) {
			return true;
		}
		
		if (includeChildResources) {
			if (resourcePaths.contains(resource)) {
				return true;
			}
			
			if (resource.segmentCount() == 0) {
				return false;
			}
			
			return selectByResource(resource.removeLastSegments(1));
		} else {
			return resourcePaths.contains(resource);
		}
	}
	
	private boolean selectByType(String type) {
		if (requiredTypeSet == null) {
			requiredTypeSet = new HashSet();
			for (int i = 0; i < requiredTypes.length; i++) {
				String next = requiredTypes[i];
				
				requiredTypeSet.add(next);
			}
		}
		
		return requiredTypeSet.contains(type);
	}
	
	public void setDescription(String description, boolean contains) {
		this.description = description;
		this.contains = contains;
	}
	
    private boolean selectByDescription(ConcreteMarker marker) {
        if (description == null || description.equals("")) //$NON-NLS-1$
            return true;

        String markerDescription = marker.getDescription();
        int index = markerDescription.indexOf(description);
        return contains ? (index >= 0) : (index < 0);
    }
	
    public void setSelectBySeverity(boolean selectBySeverity) {
        this.selectBySeverity = selectBySeverity;
            MarkerType rootType = (MarkerType) rootTypes.get(i);
            addAllSubTypes(rootType);
        }
    }

    public void setSeverity(int severity) {
        this.severity = severity;
            return;

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

        MarkerType[] subTypes = type.getSubtypes();

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

    private boolean selectBySeverity(ConcreteMarker item) {
        if (selectBySeverity) {
            int markerSeverity = item.getSeverity();
     * @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(
                        Messages.getString("MarkerFilter.searching"), typesToSearch.size() * resources.length); //$NON-NLS-1$

        // 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);
            }
        }

            if (markerSeverity == IMarker.SEVERITY_ERROR)
                return (severity & SEVERITY_ERROR) > 0;
            else if (markerSeverity == IMarker.SEVERITY_WARNING)
                return (severity & SEVERITY_WARNING) > 0;
            else if (markerSeverity == IMarker.SEVERITY_INFO)
                return (severity & SEVERITY_INFO) > 0;
            // 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;
                        } else {
                            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;
    }
    
    public void setDone(boolean done) {
        this.done = done;
     * 
     * @return
     */
    ConcreteMarker[] 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_RESOURCE: {
                unfiltered = findMarkers(new IResource[] { ResourcesPlugin
                        .getWorkspace().getRoot() }, IResource.DEPTH_INFINITE,
                        limit, mon, ignoreExceptions);
                break;
            }
            case ON_SELECTED_RESOURCE_ONLY: {
                unfiltered = findMarkers(focusResource, IResource.DEPTH_ZERO,
                        limit, mon, ignoreExceptions);
                break;
            }
            case ON_SELECTED_RESOURCE_AND_CHILDREN: {
                unfiltered = findMarkers(focusResource,
                        IResource.DEPTH_INFINITE, limit, mon, ignoreExceptions);
                break;
            }
            case ON_ANY_RESOURCE_OF_SAME_PROJECT: {
                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 (ConcreteMarker[]) unfiltered
                .toArray(new ConcreteMarker[unfiltered.size()]);
    }

    IResource[] getResourcesInWorkingSet() {
        if (workingSet == null) {
            return new IResource[0];
        }

        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()]);
    }

    public void setPriority(int priority) {
        this.priority = priority;
     * 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
     */
    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
     */
    static IProject[] getProjects(IResource[] resources) {
        if (resources == null) {
            return new IProject[0];
        }

        Collection projects = getProjectsAsCollection(resources);

        return (IProject[]) projects.toArray(new IProject[projects.size()]);
    }

    static Collection getProjectsAsCollection(IResource[] resources) {
        HashSet projects = new HashSet();

        for (int idx = 0; idx < resources.length; idx++) {
            projects.add(resources[idx].getProject());
        }

        return projects;
    }

    public void setSelectByDone(boolean selectByDone) {
        this.selectByDone = selectByDone;
            return true;
        }

        return selectByType(marker) && selectBySelection(marker)
                && selectMarker(marker);
    }

    public void setSelectByPriority(boolean selectByPriority) {
        this.selectByPriority = selectByPriority;
    }

    private boolean selectByDone(ConcreteMarker item) {
        if (selectByDone)
            return done == (item.getDone() == 1);
     * @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_RESOURCE || marker == null)
            return true;

        return true;
            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();

            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_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;
    }

    private boolean selectByPriority(ConcreteMarker marker) {
        if (priority != 0 && selectByPriority) {
            int markerPriority = marker.getPriority();

            if (markerPriority == IMarker.PRIORITY_HIGH)
                return (priority & PRIORITY_HIGH) > 0;
            else if (markerPriority == IMarker.PRIORITY_NORMAL)
                return (priority & PRIORITY_NORMAL) > 0;
            else if (markerPriority == IMarker.PRIORITY_LOW)
                return (priority & PRIORITY_LOW) > 0;
     */
    private boolean isEnclosed(IResource element) {
        if (workingSet == null) {
            return false;
        }
        Set workingSetPaths = getWorkingSetAsSetOfPaths();

        return workingSetPaths.contains(element.getFullPath().toString());
    }

    /**
     * @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.
     */
    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>
     */
    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 true;
     * @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;
        cachedWorkingSet = null;
    }

    void resetState() {
        enabled = DEFAULT_ACTIVATION_STATUS;
        filterOnMarkerLimit = DEFAULT_FILTER_ON_MARKER_LIMIT;
        markerLimit = DEFAULT_MARKER_LIMIT;
        onResource = DEFAULT_ON_RESOURCE;
        selectedTypes.clear();
        addAllSubTypes();
        setWorkingSet(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)
                setWorkingSet(WorkbenchPlugin.getDefault()
                        .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());
        }
    }
}




import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;


import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;

/**
 * Represents a list of ConcreteMarkers.

        markerTable = null;
    }

    public static ConcreteMarker createMarker(IMarker marker) {
        return new ConcreteMarker(marker);
     * 
     * @return a map of IMarker onto ConcreteMarker, containing all the ConcreteMarkers in the list
     */
    private Map getMarkerMap() {
        if (markerTable == null) {
            markerTable = new HashMap();

            for (int idx = 0; idx < markers.length; idx++) {
                ConcreteMarker marker = markers[idx];
                markerTable.put(marker.getMarker(), marker);
            }
        }

        return markerTable;
    }

    /**
     * Returns an existing marker from the list that is associated with
     * the given IMarker
     *  
     * @param toFind the IMarker to lookup in the list
     * @return the ConcreteMarker that corresponds to the given IMarker
     */
    public ConcreteMarker getMarker(IMarker toFind) {
        return (ConcreteMarker) getMarkerMap().get(toFind);
    }

    public static ConcreteMarker createMarker(IMarker marker)
            throws CoreException {
        if (marker.isSubtypeOf(IMarker.TASK)) {
            return new TaskMarker(marker);
        } else if (marker.isSubtypeOf(IMarker.BOOKMARK)) {
            return new BookmarkMarker(marker);
        } else if (marker.isSubtypeOf(IMarker.PROBLEM)) {
            return new ProblemMarker(marker);
        } else
            return new ConcreteMarker(marker);
    }

    public void refresh() {

        return Arrays.asList(markers);
    }

    public MarkerList findMarkers(Collection ofIMarker) {
        List result = new ArrayList(ofIMarker.size());

        Iterator iter = ofIMarker.iterator();
        while (iter.hasNext()) {
            IMarker next = (IMarker) iter.next();

            ConcreteMarker marker = getMarker(next);
            if (marker != null) {
                result.add(marker);
            }
        }

        return new MarkerList(result);
    }

    public static ConcreteMarker[] createMarkers(IMarker[] source)
            throws CoreException {
        ConcreteMarker[] result = new ConcreteMarker[source.length];

    }

    /**
     * Computes the set of markers that match the given filter
     * @param filter the filter to apply
     * @param mon the monitor to update
     * @param ignoreExceptions whether or not exception will be shown
     * @return MarkerList
     * @throws CoreException
     */
    public static MarkerList compute(MarkerFilter filter, IProgressMonitor mon,
            boolean ignoreExceptions) throws CoreException {
        return new MarkerList(filter.findMarkers(mon, ignoreExceptions));
    }

    /**
     * Returns a new MarkerList containing all markers in the workspace of the specified types
     * @param types
     * @return  IMarker[]

            for (int idx = 0; idx < markers.length; idx++) {
                ConcreteMarker marker = markers[idx];

                if (marker instanceof ConcreteMarker) {
                    int severity = ((ConcreteMarker) markers[idx]).getSeverity();
                    if (severity >= 0 && severity <= 2) {
                        markerCounts[severity]++;
                    }




/*******************************************************************************
 * Copyright (c) 2000, 2004 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.Arrays;
import java.util.List;

import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IMarkerDelta;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.util.ListenerList;

/**
 * Registry that tracks resource markers and maintains a sorted, filtered list of the markers. 
 * Notifies listeners of changes in these markers.
 */
public class MarkerRegistry implements IResourceChangeListener,
        ITableViewContentProvider {

    private IFilter filter;

    private IResource input;

    private String[] types = new String[0];

    private ListenerList listeners = new ListenerList();

    public MarkerRegistry() {
    }

    /** 
     * Disposes the registry, releasing all listeners 
     * and any other allocated resources.
     */
    public void dispose() {
        listeners.clear();
        setInput(null);
    }

    /**
     * @return a filtered, sorted list of markers.
     */
    public Object[] getElements() {
        Object[] elements = getUnfilteredElements();
        if (filter != null) {
            Object[] filteredItems = filter.filter(elements);
            return filteredItems;
        }
        return elements;
    }

    /**
     * @return an unfiltered list of elements
     */
    public Object[] getUnfilteredElements() {
        if (input == null) {
            return new Object[0];
        }
        List elements = new ArrayList();
        for (int i = 0; i < types.length; i++) {
            try {
                IMarker[] newMarkers = input.findMarkers(types[i], true,
                        IResource.DEPTH_INFINITE);
                elements.addAll(Arrays.asList(newMarkers));
            } catch (CoreException e) {
            }
        }
        return elements.toArray();
    }

    /**
     * @return the registry's filter or <code>null</code> if no filter has been assigned 
     * to the registry.
     */
    public IFilter getFilter() {
        return filter;
    }

    /**
     * @return the registry's input resource
     */
    public IResource getInput() {
        return input;
    }

    /**
     * Sets the registry's filter
     * 
     * @param filter 
     */
    public void setFilter(IFilter filter) {
        if (this.filter == null || !this.filter.equals(filter)) {
            this.filter = filter;
        }
    }

    /**
     * Sets the registry's input resource
     * 
     * @param resource
     */
    public void setInput(IResource resource) {
        if (input != null) {
            if (input.equals(resource))
                return;
            input.getWorkspace().removeResourceChangeListener(this);
        }
        input = resource;
        if (input != null)
            resource.getWorkspace().addResourceChangeListener(this);
    }

    /**
     * @return the base marker types that the registry is tracking
     */
    public String[] getTypes() {
        return types;
    }

    /**
     * Sets the base marker types to track. By default the registry will search for
     * all markers of these types and their subtypes.
     * 
     * @param types
     */
    public void setTypes(String[] types) {
        if (types == null)
            this.types = new String[0];
        else
            this.types = types;
    }

    /**
     * Convenience method used if only interested in one base marker type.
     * 
     * @param type
     */
    public void setType(String type) {
        setTypes(new String[] { type });
    }

    /* (non-Javadoc)
     * @see org.eclipse.core.resources.IResourceChangeListener#resourceChanged(org.eclipse.core.resources.IResourceChangeEvent)
     */
    public void resourceChanged(IResourceChangeEvent event) {

        // gather all marker changes from the delta.
        // be sure to do this in the calling thread, 
        // as the delta is destroyed when this method returns
        final List additions = new ArrayList();
        final List removals = new ArrayList();
        final List changes = new ArrayList();

        IResourceDelta delta = event.getDelta();
        if (delta == null)
            return;
        getMarkerDeltas(delta, additions, removals, changes);
        //filter additions and changes but not removals since they have already been deleted
        filterList(additions);
        filterList(changes);
        notifyListeners(additions, removals, changes);
    }

    /**
     * Recursively walks over the resource delta and gathers all marker deltas.  Marker
     * deltas are placed into one of the two given lists depending on the type of delta 
     * (add or remove).
     */
    private void getMarkerDeltas(IResourceDelta delta, List additions,
            List removals, List changes) {
        IMarkerDelta[] markerDeltas = delta.getMarkerDeltas();
        for (int i = 0; i < markerDeltas.length; i++) {
            IMarkerDelta markerDelta = markerDeltas[i];
            IMarker marker = markerDelta.getMarker();
            switch (markerDelta.getKind()) {
            case IResourceDelta.ADDED: {
                boolean added = false;
                for (int j = 0; j < types.length && !added; j++) {
                    if (markerDelta.isSubtypeOf(types[j])) {
                        additions.add(marker);
                        added = true;
                    }
                }
                break;
            }
            case IResourceDelta.REMOVED: {
                boolean added = false;
                for (int j = 0; j < types.length && !added; j++) {
                    if (markerDelta.isSubtypeOf(types[j])) {
                        removals.add(marker);
                        added = true;
                    }
                }
                break;
            }
            case IResourceDelta.CHANGED: {
                boolean added = false;
                for (int j = 0; j < types.length && !added; j++) {
                    if (markerDelta.isSubtypeOf(types[j])) {
                        changes.add(marker);
                        added = true;
                    }
                }
                break;
            }
            }
        }

        //recurse on child deltas
        IResourceDelta[] children = delta.getAffectedChildren();
        for (int i = 0; i < children.length; i++) {
            getMarkerDeltas(children[i], additions, removals, changes);
        }
    }

    private void notifyListeners(List additions, List removals, List changes) {
        Object[] listeners = this.listeners.getListeners();
        for (int i = 0; i < listeners.length; i++) {
            IItemsChangedListener listener = (IItemsChangedListener) listeners[i];
            listener.itemsChanged(additions, removals, changes);
        }
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.views.internal.tableview.ITableViewContentProvider#addItemsChangedListener(org.eclipse.ui.views.internal.tableview.IItemsChangedListener)
     */
    public void addItemsChangedListener(IItemsChangedListener listener) {
        listeners.add(listener);
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.views.internal.tableview.ITableViewContentProvider#removeItemsChangedListener(org.eclipse.ui.views.internal.tableview.IItemsChangedListener)
     */
    public void removeItemsChangedListener(IItemsChangedListener listener) {
        listeners.remove(listener);
    }

    /**
     * @return the number of items
     */
    public int getItemCount() {
        //TODO do this more efficiently
        return getElements().length;
    }

    public int getRawItemCount() {
        //TODO do this more efficiently
        return getUnfilteredElements().length;
    }

    private void filterList(List list) {
        if (filter == null || list == null) {
            return;
        }
        int i = 0;
        while (i < list.size()) {
            if (filter.select(list.get(i))) {
                i++;
            } else {
                list.remove(i);
            }
        }
    }

}





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

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IMarkerDelta;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.core.runtime.jobs.IJobManager;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.OpenEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.deferred.IConcurrentModel;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.Clipboard;
import org.eclipse.swt.dnd.DND;

import org.eclipse.ui.part.FileEditorInput;
import org.eclipse.ui.part.MarkerTransfer;
import org.eclipse.ui.progress.IWorkbenchSiteProgressService;
import org.eclipse.ui.progress.WorkbenchJob;
import org.eclipse.ui.views.navigator.ShowInNavigatorAction;
import org.eclipse.ui.views.tasklist.ITaskListResourceAdapter;

public abstract class MarkerView extends TableView {

    private static final String WAITING_FOR_WORKSPACE_CHANGES_TO_FINISH = Messages
            .getString("MarkerView.waiting_on_changes"); //$NON-NLS-1$

    private static final String SEARCHING_FOR_MARKERS = Messages
            .getString("MarkerView.searching_for_markers"); //$NON-NLS-1$

    private static final String REFRESHING_MARKER_COUNTS = Messages
            .getString("MarkerView.refreshing_counts"); //$NON-NLS-1$

    private static final String QUEUEING_VIEWER_UPDATES = Messages
            .getString("MarkerView.queueing_updates"); //$NON-NLS-1$

    private static final String FILTERING_ON_MARKER_LIMIT = Messages
            .getString("MarkerView.18"); //$NON-NLS-1$

    private static final String TAG_SELECTION = "selection"; //$NON-NLS-1$

    private static final String TAG_MARKER = "marker"; //$NON-NLS-1$


    protected IResource[] focusResources;

    private IConcurrentModel model;
    
    private Clipboard clipboard;

    IResourceChangeListener resourceListener = new IResourceChangeListener() {
        public void resourceChanged(IResourceChangeEvent event) {
            String[] markerTypes = getMarkerTypes();

            boolean refreshNeeded = false;

            for (int idx = 0; idx < markerTypes.length; idx++) {
                IMarkerDelta[] markerDeltas = event.findMarkerDeltas(
                        markerTypes[idx], true);
                List changes = new ArrayList(markerDeltas.length);

                examineDelta(markerDeltas, changes);

                if (markerDeltas.length != changes.size()) {
                    refreshNeeded = true;
                }

                MarkerList changed = currentMarkers.findMarkers(changes);
                changed.refresh();

                change(changed.asList());
            }

            // Refresh everything if markers were added or removed
            if (refreshNeeded) {
                markerCountDirty = true;
                refresh();
            }
        }
    };

    protected ActionCopyMarker copyAction;

    protected ActionPasteMarker pasteAction;

        }
    };

    private MarkerList currentMarkers = new MarkerList();

    private int totalMarkers = 0;

    private boolean markerCountDirty = true;

    WorkbenchJob uiJob;

    /**
     * This job is scheduled whenever a filter or resource change occurs. It computes the new
     * set of markers and schedules a UI Job to cause the changes to be reflected in the UI.
     */

    private RestartableJob refreshJob = null;

    private void internalRefresh(IProgressMonitor monitor)
            throws InvocationTargetException, InterruptedException {
        int markerLimit = getMarkerLimit();
        monitor
                .beginTask(
                        Messages.getString("MarkerView.19"), markerLimit == -1 ? 60 : 100); //$NON-NLS-1$

        haltTableUpdates();
        IJobManager jobMan = Platform.getJobManager();
        IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();

        try {
            monitor.subTask(WAITING_FOR_WORKSPACE_CHANGES_TO_FINISH);

            jobMan.beginRule(root, monitor);

            if (monitor.isCanceled()) {
                return;
            }

            monitor.subTask(SEARCHING_FOR_MARKERS);
            SubProgressMonitor subMonitor = new SubProgressMonitor(monitor, 10);
            MarkerList markerList = MarkerList.compute(getFilter(), subMonitor, true);

            if (monitor.isCanceled()) {
                return;
            }
            if (markerCountDirty) {
                monitor.subTask(REFRESHING_MARKER_COUNTS);
                totalMarkers = MarkerList.compute(getMarkerTypes()).length;
                markerCountDirty = false;
            }
            
            currentMarkers = markerList;

        } catch (CoreException e) {
            throw new InvocationTargetException(e);
        } finally {
            jobMan.endRule(root);
        }

        if (monitor.isCanceled()) {
            return;
        }

        // Exit immediately if the markers have changed in the meantime.

        Collection markers = Arrays.asList(currentMarkers.toArray());

        if (markerLimit != -1) {

            monitor.subTask(FILTERING_ON_MARKER_LIMIT);
            SubProgressMonitor mon = new SubProgressMonitor(monitor, 40);

            markers = SortUtil.getFirst(markers, getSorter(), markerLimit, mon);
            if (monitor.isCanceled())
                return;
            currentMarkers = new MarkerList(markers);
        }

        monitor.subTask(QUEUEING_VIEWER_UPDATES);

        SubProgressMonitor sub = new SubProgressMonitor(monitor, 50);
        setContents(markers, sub);
        if (monitor.isCanceled())
            return;

        uiJob.schedule();
        try {
            uiJob.join();
        } catch (InterruptedException e) {
            uiJob.cancel();
            monitor.done();
        } finally {
            if (monitor.isCanceled()) {
                uiJob.cancel();
            }
        }

        monitor.done();
    }

    /**
     * Causes the view to re-sync its contents with the workspace. Note that
     * changes will be scheduled in a background job, and may not take effect
     * immediately. 
     */
    protected void refresh() {

        if (uiJob == null)
            createUIJob();

        if (refreshJob == null) {

            refreshJob = new RestartableJob(Messages.format(
                    "MarkerView.refreshTitle", new Object[] { getTitle() }),//$NON-NLS-1$
                    new IRunnableWithProgress() {
                        public void run(IProgressMonitor monitor)
                                throws InvocationTargetException,
                                InterruptedException {
                            internalRefresh(monitor);
                        }
                    }, getProgressService());
        }

        refreshJob.restart();
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.views.internal.tableview.TableView#init(org.eclipse.ui.IViewSite, org.eclipse.ui.IMemento)
     */

    public void createPartControl(Composite parent) {
        clipboard = new Clipboard(parent.getDisplay());

        setFilter(getFilterCriteria().getFilter());
        setLimit(getFilterCriteria().getMarkerLimit());
        
        super.createPartControl(parent);

        
        initDragAndDrop();

        getSite().getPage().addSelectionListener(focusListener);
        focusSelectionChanged(getSite().getPage().getActivePart(), getSite()
                .getPage().getSelection());
        ResourcesPlugin.getWorkspace().addResourceChangeListener(
                resourceListener);
        refresh();

        // Set help on the view itself
        getViewer().getControl().addHelpListener(new HelpListener() {

                ConcreteMarker marker = (ConcreteMarker) ((IStructuredSelection) getViewer()
                        .getSelection()).getFirstElement();
                if (marker != null) {
                    try {
						contextId = IDE.getMarkerHelpRegistry().getHelp(
						        marker.getMarker());
					} catch (CoreException e1) {
						contextId = null;
					}
                }

                if (contextId == null) {


        Object[] rawSelection = selection.toArray();

        ArrayList markers = new ArrayList(rawSelection.length);
        
        for (int idx = 0; idx < rawSelection.length; idx++) {
        	IMarker next;
			try {
				next = ((ConcreteMarker) rawSelection[idx]).getMarker();
				markers.add(next);
			} catch (CoreException e) {
			}
        }

        setSelection(new StructuredSelection(markers.toArray()));

        updateStatusMessage(selection);
    }

     */
    public void dispose() {
        super.dispose();
        ResourcesPlugin.getWorkspace().removeResourceChangeListener(
                resourceListener);
        getSite().getPage().removeSelectionListener(focusListener);

        //dispose of selection provider actions

        showInNavigatorAction.dispose();
        propertiesAction.dispose();
        clipboard.dispose();
        
        if (model != null) {
        	MarkerProvider.releaseRef(model);
        	model = null;
        }
    }

    /* (non-Javadoc)

    /* (non-Javadoc)
     * @see org.eclipse.ui.views.internal.tableview.TableView#getFilter()
     */
    protected abstract MarkerFilterCriteria getFilterCriteria();

    /* (non-Javadoc)
     * @see org.eclipse.ui.views.internal.tableview.TableView#handleKeyPressed(org.eclipse.swt.events.KeyEvent)

        for (Iterator iterator = selection.iterator(); iterator.hasNext();) {
            ConcreteMarker marker = (ConcreteMarker) iterator.next();
            IMemento elementMem = selectionMem.createChild(TAG_MARKER);
            elementMem.putString(TAG_RESOURCE, marker.getResource()
                    .getFullPath().toString());
            elementMem.putString(TAG_ID, String.valueOf(marker.getId()));
                    .getId()));
        }
    }


        if (selectionMemento == null) {
            return new StructuredSelection();
        }
        
        ArrayList selectionList = new ArrayList();
        IMemento[] markerMems = selectionMemento.getChildren(TAG_MARKER);
        for (int i = 0; i < markerMems.length; i++) {

                        .getString(TAG_RESOURCE));
                if (resource != null) {
                    IMarker marker = resource.findMarker(id);
                    if (marker != null) {
                        selectionList.add(MarkerList.createMarker(marker));
                    }
                }
            } catch (CoreException e) {
            }

            }
        }


        IResource[] focus = new IResource[resources.size()];
        resources.toArray(focus);
        updateFocusResource(focus);

    protected abstract void updateFilterSelection(IResource[] resources);

    void updateFocusResource(IResource[] resources) {
    	if (resources.length > 0) {
	        updateFilterSelection(resources);
	        setFilter(getFilterCriteria().getFilter());
    	}
        
//        boolean updateNeeded = updateNeeded(focusResources, resources);
//        if (updateNeeded) {
//            focusResources = resources;
//            updateFilterSelection(resources);
//            setFilter(getFilterCriteria().getFilter());
//        }
    }

//    private boolean updateNeeded(IResource[] oldResources,
//            IResource[] newResources) {
//        //determine if an update if refiltering is required
//        MarkerFilterCriteria filter = getFilterCriteria();
//        if (!filter.isEnabled()) {
//            return false;
//        }
//
//        int onResource = filter.getOnResource();
//        if (onResource == MarkerFilterCriteria.ON_ANY_RESOURCE
//                || onResource == MarkerFilterCriteria.ON_WORKING_SET) {
//            return false;
//        }
//        if (newResources == null || newResources.length < 1) {
//            return false;
//        }
//        if (oldResources == null || oldResources.length < 1) {
//            return true;
//        }
//        if (Arrays.equals(oldResources, newResources)) {
//            return false;
//        }
//        if (onResource == MarkerFilterCriteria.ON_ANY_RESOURCE_OF_SAME_PROJECT) {
//            Collection oldProjects = MarkerFilterCriteria
//                    .getProjectsAsCollection(oldResources);
//            Collection newProjects = MarkerFilterCriteria
//                    .getProjectsAsCollection(newResources);
//
//            if (oldProjects.size() == newProjects.size()) {
//                return !newProjects.containsAll(oldProjects);
//            } else {
//                return true;
//            }
//        }
//
//        return true;
//    }

    /**
     * Returns the marker limit or -1 if unlimited

     * @return
     */
    private int getMarkerLimit() {
        MarkerFilterCriteria filter = getFilterCriteria();

        if (!filter.isEnabled() || !filter.getFilterOnMarkerLimit()) {
            return -1;

        return (limit == -1 || toTest <= limit);
    }

    // TODO: FIX ME
    void updateTitle() {
//        String currentTitle = getTitle();
//        String viewName = getConfigurationElement().getAttribute("name"); //$NON-NLS-1$
//        String status = ""; //$NON-NLS-1$
//        int filteredCount = currentMarkers.getItemCount();
//        int totalCount = getTotalMarkers();
//        if (filteredCount == totalCount) {
//            status = Messages
//                    .format(
//                            "filter.itemsMessage", new Object[] { new Integer(totalCount) }); //$NON-NLS-1$
//        } else {
//            status = Messages
//                    .format(
//                            "filter.matchedMessage", new Object[] { new Integer(filteredCount), new Integer(totalCount) }); //$NON-NLS-1$
//        }
//        setContentDescription(status);
    }

    /**

        for (Iterator i = structuredSelection.iterator(); i.hasNext();) {
            Object next = i.next();
            if (next instanceof IMarker) {
                ConcreteMarker marker = MarkerList.createMarker((IMarker) next);
                        .getMarker((IMarker) next);
                if (marker != null) {
                    newSelection.add(marker);
                }

            viewer.setSelection(new StructuredSelection(newSelection), reveal);
    }

//    protected MarkerList getVisibleMarkers() {
//        return currentMarkers;
//    }
//
//    /**
//     * Returns the total number of markers. Should not be called while the marker
//     * list is still updating.
//     * 
//     * @return the total number of markers in the workspace (including everything that doesn't pass the filters)
//     */
//    int getTotalMarkers() {
//        // The number of visible markers should never exceed the total number of markers in
//        // the workspace. If this assertation fails, it probably indicates some sort of concurrency problem
//        // (most likely, getTotalMarkers was called while we were still computing the marker lists)
//        //Assert.isTrue(totalMarkers >= currentMarkers.getItemCount());
//
//        return totalMarkers;
//    }

//    /* (non-Javadoc)
//     * @see org.eclipse.ui.views.markers.internal.TableView#sorterChanged()
//     */
//    protected void sorterChanged() {
//        refresh();
//    }
        //Assert.isTrue(totalMarkers >= currentMarkers.getItemCount());

        return totalMarkers;
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.views.markers.internal.TableView#sorterChanged()
     */
    protected void sorterChanged() {
        refresh();
    }

    private static void examineDelta(IMarkerDelta[] deltas, List changes) {
        for (int idx = 0; idx < deltas.length; idx++) {

        }
    }

//    /* (non-Javadoc)
//     * @see org.eclipse.ui.part.WorkbenchPart#showBusy(boolean)
//     */
//    public void showBusy(boolean busy) {
//        super.showBusy(busy);
//
//        if (busy) {
//            preBusyMarkers = totalMarkers;
//        } else {//Only bold if there has been a change in count
//            if (totalMarkers != preBusyMarkers)
//                getProgressService().warnOfContentChange();
//        }
//
//    }

    protected IConcurrentModel getViewerInput() {
    	if (model == null) {
    		model = MarkerProvider.getRef();
    	}
    	
    	return model;
    }
    
//    /**
//     * Create the UIJob used in the receiver for updates.
//     *
//     */
//    private void createUIJob() {
//        uiJob = new WorkbenchJob(Messages
//                .getString("MarkerView.refreshProgress")) { //$NON-NLS-1$
//
//            public IStatus runInUIThread(IProgressMonitor monitor) {
//                updateStatusMessage();
//                updateTitle();
//                return Status.OK_STATUS;
//            }
//        };
//        uiJob.setPriority(Job.INTERACTIVE);
//        uiJob.setSystem(true);
//    }

}




import org.eclipse.core.resources.IMarker;
import org.eclipse.jface.dialogs.IDialogSettings;

public class ProblemFilter extends MarkerFilterCriteria {

    private static final String TAG_CONTAINS = "contains"; //$NON-NLS-1$


        super(new String[] { IMarker.PROBLEM });
    }

    /* (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerFilterCriteria#getMarkerFilter()
	 */
	protected MarkerFilter getMarkerFilter() {
		MarkerFilter result = super.getMarkerFilter();
		
		result.setSeverity(severity);
		result.setSelectBySeverity(selectBySeverity);
		result.setDescription(description, contains);
		
		return result;
	}
    private boolean selectByDescription(ConcreteMarker item) {
        if (description == null || description.equals("")) //$NON-NLS-1$
            return true;

        String markerDescription = item.getDescription();
        int index = markerDescription.indexOf(description);
        return contains ? (index >= 0) : (index < 0);
    }

    private boolean selectBySeverity(ProblemMarker item) {
        if (selectBySeverity) {
            int markerSeverity = item.getSeverity();

            if (markerSeverity == IMarker.SEVERITY_ERROR)
                return (severity & SEVERITY_ERROR) > 0;
            else if (markerSeverity == IMarker.SEVERITY_WARNING)
                return (severity & SEVERITY_WARNING) > 0;
            else if (markerSeverity == IMarker.SEVERITY_INFO)
                return (severity & SEVERITY_INFO) > 0;
        }

        return true;
    }

    public boolean getContains() {
        return contains;




/*******************************************************************************
 * Copyright (c) 2000, 2004 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 org.eclipse.core.resources.IMarker;

/**
 * 
 */
public class ProblemMarker extends ConcreteMarker {

    private int severity;

    public ProblemMarker(IMarker toCopy) {
        super(toCopy);

    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.views.markers.internal.ConcreteMarker#refresh()
     */
    public void refresh() {
        super.refresh();
        severity = getMarker().getAttribute(IMarker.SEVERITY, -1);
    }

    public int getSeverity() {
        return severity;
    }
}





import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.Separator;

        return sorter;
    }

//    protected Object getViewerInput() {
//        return ResourcesPlugin.getWorkspace().getRoot();
//    }

    protected IField[] getVisibleFields() {
        return VISIBLE_FIELDS;

        super.initMenu(menu);
    }

//    void updateTitle() {
//        MarkerList visibleMarkers = getVisibleMarkers();
//        String breakdown = formatSummaryBreakDown(visibleMarkers);
//        int filteredCount = visibleMarkers.getItemCount();
//        int totalCount = getTotalMarkers();
//        if (filteredCount != totalCount)
//            breakdown = Messages.format("problem.filter.matchedMessage", //$NON-NLS-1$
//                    new Object[] { breakdown, new Integer(filteredCount),
//                            new Integer(totalCount) });
//        setContentDescription(breakdown);
//    }

    private String formatSummaryBreakDown(MarkerList visibleMarkers) {
        return Messages.format("problem.statusSummaryBreakdown", //$NON-NLS-1$

    /* (non-Javadoc)
     * @see org.eclipse.ui.views.markers.internal.MarkerView#getFilter()
     */
    protected MarkerFilterCriteria getFilterCriteria() {
        return problemFilter;
    }


        if (dialog.open() == Window.OK) {
            problemFilter = (ProblemFilter) dialog.getFilter();
            problemFilter.saveState(getDialogSettings());
            setFilter(dialog.getFilter().getFilter());
            setLimit(getFilterCriteria().getMarkerLimit());
        }
    }


Lines 12-22 Link Here

(-)src/org/eclipse/ui/views/markers/internal/TableView.java (-46 / +49 lines)
12	package org.eclipse.ui.views.markers.internal;	12	package org.eclipse.ui.views.markers.internal;
13		13
14	import java.util.Arrays;	14	import java.util.Arrays;
15	import java.util.Collection;
16	import java.util.HashMap;	15	import java.util.HashMap;
17	import java.util.Map;	16	import java.util.Map;
18		17
19	import org.eclipse.core.runtime.IProgressMonitor;
20	import org.eclipse.jface.action.IAction;	18	import org.eclipse.jface.action.IAction;
21	import org.eclipse.jface.action.IMenuListener;	19	import org.eclipse.jface.action.IMenuListener;
22	import org.eclipse.jface.action.IMenuManager;	20	import org.eclipse.jface.action.IMenuManager;
Lines 33-38 Link Here
33	import org.eclipse.jface.viewers.SelectionChangedEvent;	31	import org.eclipse.jface.viewers.SelectionChangedEvent;
34	import org.eclipse.jface.viewers.TableLayout;	32	import org.eclipse.jface.viewers.TableLayout;
35	import org.eclipse.jface.viewers.TableViewer;	33	import org.eclipse.jface.viewers.TableViewer;
		34	import org.eclipse.jface.viewers.deferred.AcceptAllFilter;
		35	import org.eclipse.jface.viewers.deferred.DeferredContentProvider;
		36	import org.eclipse.jface.viewers.deferred.IConcurrentModel;
		37	import org.eclipse.jface.viewers.deferred.IFilter;
36	import org.eclipse.swt.SWT;	38	import org.eclipse.swt.SWT;
37	import org.eclipse.swt.events.KeyAdapter;	39	import org.eclipse.swt.events.KeyAdapter;
38	import org.eclipse.swt.events.KeyEvent;	40	import org.eclipse.swt.events.KeyEvent;
Lines 55-61 Link Here
55		57
56	public abstract class TableView extends ViewPart {	58	public abstract class TableView extends ViewPart {
57		59
58	private TableContentProvider content;	60	private DeferredContentProvider content;
59		61
60	private static final String TAG_COLUMN_WIDTH = "columnWidth"; //$NON-NLS-1$	62	private static final String TAG_COLUMN_WIDTH = "columnWidth"; //$NON-NLS-1$
61		63
Lines 78-84 Link Here
78	private ISelectionProvider selectionProvider = new SelectionProviderAdapter();	80	private ISelectionProvider selectionProvider = new SelectionProviderAdapter();
79		81
80	private TableSorter sorter;	82	private TableSorter sorter;
81		83	private int limit = -1;
		84
		85	private IFilter filter = AcceptAllFilter.getInstance();
		86
82	/* (non-Javadoc)	87	/* (non-Javadoc)
83	* Method declared on IViewPart.	88	* Method declared on IViewPart.
84	*/	89	*/
Lines 87-114 Link Here
87	this.memento = memento;	92	this.memento = memento;
88	}	93	}
89		94
90	/**
91	*
92	*/
93	void haltTableUpdates() {
94	content.cancelPendingChanges();
95	}
96
97	void change(Collection toRefresh) {
98	content.change(toRefresh);
99	}
100
101	void setContents(Collection contents, IProgressMonitor mon) {
102	content.set(contents, mon);
103	}
104
105	protected ISelectionProvider getSelectionProvider() {	95	protected ISelectionProvider getSelectionProvider() {
106	return selectionProvider;	96	return selectionProvider;
107	}	97	}
108		98
109	abstract protected void viewerSelectionChanged(	99	abstract protected void viewerSelectionChanged(
110	IStructuredSelection selection);	100	IStructuredSelection selection);
111		101
		102	protected void setFilter(IFilter newFilter) {
		103	if (filter.equals(newFilter)) {
		104	return;
		105	}
		106	filter = newFilter;
		107	if (content != null) {
		108	content.setFilter(filter);
		109	}
		110	}
		111
		112	protected void setLimit(int newLimit) {
		113	limit = newLimit;
		114	if (content != null) {
		115	content.setLimit(newLimit);
		116	}
		117	}
		118
112	/* (non-Javadoc)	119	/* (non-Javadoc)
113	* @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite)	120	* @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite)
114	*/	121	*/
Lines 118-127 Link Here
118	viewer = new TableViewer(createTable(parent));	125	viewer = new TableViewer(createTable(parent));
119	restoreColumnWidths(memento);	126	restoreColumnWidths(memento);
120	createColumns(viewer.getTable());	127	createColumns(viewer.getTable());
121	content = new TableContentProvider(viewer, Messages.format(	128	content = new DeferredContentProvider(getSorter());
122	"TableView.populating", //$NON-NLS-1$	129	content.setFilter(filter);
123	new Object[] { getTitle() }), getProgressService());	130	content.setLimit(limit);
124
125	viewer.setContentProvider(content);	131	viewer.setContentProvider(content);
126		132
127	viewer.setLabelProvider(new TableViewLabelProvider(getVisibleFields()));	133	viewer.setLabelProvider(new TableViewLabelProvider(getVisibleFields()));
Lines 190-198 Link Here
190	TableSorter newSorter = new TableSorter(sorter2);	196	TableSorter newSorter = new TableSorter(sorter2);
191		197
192	sorter = newSorter;	198	sorter = newSorter;
193	content.setSorter(newSorter);
194	newSorter.saveState(getDialogSettings());	199	newSorter.saveState(getDialogSettings());
195	sorterChanged();	200	content.setSortOrder(newSorter);
196	}	201	}
197		202
198	/* (non-Javadoc)	203	/* (non-Javadoc)
Lines 205-213 Link Here
205	/**	210	/**
206	* Creates the table control.	211	* Creates the table control.
207	*/	212	*/
208	protected Table createTable(Composite parent) {	213	private Table createTable(Composite parent) {
209	Table table = new Table(parent, SWT.H_SCROLL \| SWT.V_SCROLL \| SWT.MULTI	214	Table table = new Table(parent, SWT.H_SCROLL \| SWT.V_SCROLL \| SWT.MULTI
210	\| SWT.FULL_SELECTION);	215	\| SWT.FULL_SELECTION \| SWT.VIRTUAL);
211	table.setLinesVisible(true);	216	table.setLinesVisible(true);
212	table.setFont(parent.getFont());	217	table.setFont(parent.getFont());
213	return table;	218	return table;
Lines 322-328 Link Here
322	return fields;	327	return fields;
323	}	328	}
324		329
325	protected abstract Object getViewerInput();	330	protected abstract IConcurrentModel getViewerInput();
326		331
327	protected abstract IField[] getVisibleFields();	332	protected abstract IField[] getVisibleFields();
328		333
Lines 363-385 Link Here
363	return null;	368	return null;
364	}	369	}
365		370
366	protected void sorterChanged() {	371	// protected void sorterChanged() {
367		372	//
368	viewer.setSorter(getSorter());	373	// final TableViewer viewer = getViewer();
369		374	// if (viewer == null) {
370	final TableViewer viewer = getViewer();	375	// return;
371	if (viewer == null) {	376	// }
372	return;	377	//
373	}	378	// getSite().getShell().getDisplay().asyncExec(new Runnable() {
374		379	// public void run() {
375	getSite().getShell().getDisplay().asyncExec(new Runnable() {	380	// viewer.getControl().setRedraw(false);
376	public void run() {	381	// viewer.refresh(false);
377	viewer.getControl().setRedraw(false);	382	// viewer.getControl().setRedraw(true);
378	viewer.refresh(false);	383	// }
379	viewer.getControl().setRedraw(true);	384	// });
380	}	385	// }
381	});
382	}
383		386
384	protected abstract void handleKeyPressed(KeyEvent event);	387	protected abstract void handleKeyPressed(KeyEvent event);
385		388




import org.eclipse.core.resources.IMarker;
import org.eclipse.jface.dialogs.IDialogSettings;

public class TaskFilter extends MarkerFilterCriteria {

    private static final String TAG_CONTAINS = "contains"; //$NON-NLS-1$


        super(new String[] { IMarker.TASK });
    }

    /* (non-Javadoc)
	 * @see org.eclipse.ui.views.markers.internal.MarkerFilterCriteria#getMarkerFilter()
	 */
	protected MarkerFilter getMarkerFilter() {
		MarkerFilter result = super.getMarkerFilter();
		
		result.setPriority(priority);
		result.setSelectByPriority(selectByPriority);
		result.setDone(done);
		result.setSelectByDone(selectByDone);
		result.setDescription(description, contains);
		
		return result;
	}
    
            return true;

        int index = marker.getDescription().indexOf(description);
        return contains ? (index >= 0) : (index < 0);
    }

    private boolean selectByDone(TaskMarker item) {
        if (selectByDone)
            return done == (item.getDone() == 1);

        return true;
    }

    private boolean selectByPriority(TaskMarker marker) {
        if (priority != 0 && selectByPriority) {
            int markerPriority = marker.getPriority();

            if (markerPriority == IMarker.PRIORITY_HIGH)
                return (priority & PRIORITY_HIGH) > 0;
            else if (markerPriority == IMarker.PRIORITY_NORMAL)
                return (priority & PRIORITY_NORMAL) > 0;
            else if (markerPriority == IMarker.PRIORITY_LOW)
                return (priority & PRIORITY_LOW) > 0;
        }

        return true;
    }

    public boolean getContains() {
        return contains;
    }




/*******************************************************************************
 * Copyright (c) 2000, 2004 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 org.eclipse.core.resources.IMarker;

/**
 * Represents a marker visible in the Tasks view. Additional members should be added
 * to this class if new fields are added to the Tasks view. Such members should be
 * initialized in the constructor, and accessed via get methods rather than accessing
 * the IMarker instance directly. This is necessary to support sorting in a reasonable
 * time bound.
 */
public class TaskMarker extends ConcreteMarker {

    private int priority;

    private int done;

    /**
     * @param toCopy
     */
    public TaskMarker(IMarker toCopy) {
        super(toCopy);
    }

    public void refresh() {
        super.refresh();
        priority = getMarker().getAttribute(IMarker.PRIORITY,
                IMarker.PRIORITY_NORMAL);
        done = -1;
        if (getMarker().getAttribute(IMarker.USER_EDITABLE, true)) {
            done = 0;
            if (getMarker().getAttribute(IMarker.DONE, false)) {
                done = 1;
            }
        }
    }

    public int getPriority() {
        return priority;
    }

    public int getDone() {
        return done;
    }
}

Lines 13-19 Link Here

(-)src/org/eclipse/ui/views/markers/internal/TaskView.java (-10 / +18 lines)
13		13
14	import org.eclipse.core.resources.IMarker;	14	import org.eclipse.core.resources.IMarker;
15	import org.eclipse.core.resources.IResource;	15	import org.eclipse.core.resources.IResource;
16	import org.eclipse.core.resources.ResourcesPlugin;
17	import org.eclipse.core.runtime.CoreException;	16	import org.eclipse.core.runtime.CoreException;
18	import org.eclipse.core.runtime.Platform;	17	import org.eclipse.core.runtime.Platform;
19	import org.eclipse.jface.action.IMenuManager;	18	import org.eclipse.jface.action.IMenuManager;
Lines 73-79 Link Here
73	private ICellModifier cellModifier = new ICellModifier() {	72	private ICellModifier cellModifier = new ICellModifier() {
74	public Object getValue(Object element, String property) {	73	public Object getValue(Object element, String property) {
75	if (element instanceof ConcreteMarker) {	74	if (element instanceof ConcreteMarker) {
76	IMarker marker = ((ConcreteMarker) element).getMarker();	75	IMarker marker;
		76	try {
		77	marker = ((ConcreteMarker) element).getMarker();
		78	} catch (CoreException e) {
		79	return null;
		80	}
77		81
78	if (COMPLETION.equals(property))	82	if (COMPLETION.equals(property))
79	return new Boolean(marker.getAttribute(IMarker.DONE, false));	83	return new Boolean(marker.getAttribute(IMarker.DONE, false));
Lines 91-97 Link Here
91	}	95	}
92		96
93	public boolean canModify(Object element, String property) {	97	public boolean canModify(Object element, String property) {
94	return Util.isEditable(((ConcreteMarker) element).getMarker());	98	try {
		99	return Util.isEditable(((ConcreteMarker) element).getMarker());
		100	} catch (CoreException e) {
		101	return false;
		102	}
95	}	103	}
96		104
97	public void modify(Object element, String property, Object value) {	105	public void modify(Object element, String property, Object value) {
Lines 102-110 Link Here
102	if (data instanceof ConcreteMarker) {	110	if (data instanceof ConcreteMarker) {
103	ConcreteMarker concreteMarker = (ConcreteMarker) data;	111	ConcreteMarker concreteMarker = (ConcreteMarker) data;
104		112
105	IMarker marker = concreteMarker.getMarker();
106
107	try {	113	try {
		114	IMarker marker = concreteMarker.getMarker();
108	Object oldValue = getValue(data, property);	115	Object oldValue = getValue(data, property);
109	if (oldValue != null && !oldValue.equals(value)) {	116	if (oldValue != null && !oldValue.equals(value)) {
110	if (COMPLETION.equals(property))	117	if (COMPLETION.equals(property))
Lines 265-273 Link Here
265	return ROOT_TYPES;	272	return ROOT_TYPES;
266	}	273	}
267		274
268	protected Object getViewerInput() {	275	// protected Object getViewerInput() {
269	return ResourcesPlugin.getWorkspace().getRoot();	276	// return ResourcesPlugin.getWorkspace().getRoot();
270	}	277	// }
271		278
272	protected IField[] getVisibleFields() {	279	protected IField[] getVisibleFields() {
273	return VISIBLE_FIELDS;	280	return VISIBLE_FIELDS;
Lines 294-300 Link Here
294	/* (non-Javadoc)	301	/* (non-Javadoc)
295	* @see org.eclipse.ui.views.markers.internal.MarkerView#getFilter()	302	* @see org.eclipse.ui.views.markers.internal.MarkerView#getFilter()
296	*/	303	*/
297	protected MarkerFilter getFilter() {	304	protected MarkerFilterCriteria getFilterCriteria() {
298	return taskFilter;	305	return taskFilter;
299	}	306	}
300		307
Lines 308-314 Link Here
308	if (dialog.open() == Window.OK) {	315	if (dialog.open() == Window.OK) {
309	taskFilter = (TaskFilter) dialog.getFilter();	316	taskFilter = (TaskFilter) dialog.getFilter();
310	taskFilter.saveState(getDialogSettings());	317	taskFilter.saveState(getDialogSettings());
311	refresh();	318	setFilter(dialog.getFilter().getFilter());
		319	setLimit(getFilterCriteria().getMarkerLimit());
312	}	320	}
313	}	321	}
314		322




/*******************************************************************************
 * Copyright (c) 2000, 2004 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.Collection;
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.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.jface.util.Assert;
import org.eclipse.jface.viewers.deferred.AcceptAllFilter;
import org.eclipse.jface.viewers.deferred.IFilter;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.internal.WorkbenchPlugin;

public class MarkerFilterCriteria {

    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 = 100;

    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 = new IResource[0];

    private Set cachedWorkingSet;

    MarkerFilterCriteria(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]);
    }

    IResource[] getResourcesInWorkingSet() {
        if (workingSet == null) {
            return new IResource[0];
        }

        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
     */
    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(Set result, IResource[] resources) {
        for (int idx = 0; idx < resources.length; idx++) {

            IResource currentResource = resources[idx];

            IPath next = currentResource.getFullPath();
            if (result.contains(next)) {
            	return;
            }
            result.add(next);

            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
     */
    static IProject[] getProjects(IResource[] resources) {
        if (resources == null) {
            return new IProject[0];
        }

        Collection projects = getProjectsAsCollection(resources);

        return (IProject[]) projects.toArray(new IProject[projects.size()]);
    }

    static Collection getProjectsAsCollection(IResource[] resources) {
        HashSet projects = new HashSet();

        for (int idx = 0; idx < resources.length; idx++) {
            projects.add(resources[idx].getProject());
        }

        return projects;
    }

    /**
     * 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;
        }
        Set workingSetPaths = getWorkingSetAsSetOfPaths();

        return workingSetPaths.contains(element.getFullPath().toString());
    }

    /**
     * @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.
     */
    public void setFocusResource(IResource[] resources) {
    	Assert.isNotNull(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;
        cachedWorkingSet = null;
    }

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

    protected MarkerFilter getMarkerFilter() {
    	
    	List typesList = new ArrayList();
    	
    	for (Iterator iter = selectedTypes.iterator(); iter.hasNext();) {
			MarkerType type = (MarkerType) iter.next();
			
			typesList.add(type.getId());
		}
    	String[] types = (String[]) typesList.toArray(new String[typesList.size()]);

    	Set resources;
    	
    	switch(onResource) {
    	case ON_ANY_RESOURCE_OF_SAME_PROJECT: {
    		resources = new HashSet();
    		
            for (int i = 0; i < focusResource.length; i++) {
                IProject selectedProject = focusResource[i].getProject();

                if (selectedProject == null) {
                    continue;
                }
                
                resources.add(selectedProject.getFullPath());
            }
    		return new MarkerFilter(types, resources, true);
    	}
    	case ON_SELECTED_RESOURCE_AND_CHILDREN: {
    		resources = new HashSet();
    	
    		for (int i = 0; i < focusResource.length; i++) {
				IResource res = focusResource[i];
				
				resources.add(res.getFullPath());
			}
    		return new MarkerFilter(types, resources, true);
    	}
    	case ON_SELECTED_RESOURCE_ONLY: {
    		resources = new HashSet();
    	
    		for (int i = 0; i < focusResource.length; i++) {
				IResource res = focusResource[i];
				
				resources.add(res.getFullPath());
			}
    		return new MarkerFilter(types, resources, false);
    	} 
    	case ON_WORKING_SET: {
    		return new MarkerFilter(types, getWorkingSetAsSetOfPaths(), false);
    	}
    	default:
    		return new MarkerFilter(types);
    	}
    	
    }
    
    public final IFilter getFilter() {
    	if (!isEnabled()) {
    		return AcceptAllFilter.getInstance();
    	}
    	
    	return getMarkerFilter();
    }
    
    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)
                setWorkingSet(WorkbenchPlugin.getDefault()
                        .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) 2004 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 org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IMarkerDelta;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.IJobManager;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.viewers.deferred.AbstractConcurrentModel;
import org.eclipse.jface.viewers.deferred.IConcurrentModel;
import org.eclipse.jface.viewers.deferred.IConcurrentModelListener;

/**
 * @since 3.1
 */
public class MarkerProvider extends AbstractConcurrentModel {

    private static final String WAITING_FOR_WORKSPACE_CHANGES_TO_FINISH = Messages
            .getString("MarkerView.waiting_on_changes"); //$NON-NLS-1$

    private static final String SEARCHING_FOR_MARKERS = Messages
            .getString("MarkerView.searching_for_markers"); //$NON-NLS-1$

    private static final String REFRESHING_MARKER_COUNTS = Messages
            .getString("MarkerView.refreshing_counts"); //$NON-NLS-1$
    
    private IWorkspaceRoot getWorkspaceRoot() {
        return ResourcesPlugin.getWorkspace().getRoot();
    }
    
    private Job searchJob = new Job(SEARCHING_FOR_MARKERS) {
	    /* (non-Javadoc)
	     * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
	     */
	    protected IStatus run(IProgressMonitor monitor) {
	        doRefresh(monitor);
	        return Status.OK_STATUS;
	    }  
    };

    private int totalMarkers = 0;
    private ArrayList awaitingRefresh = new ArrayList();
    private volatile boolean refreshScheduled = false;
    
    IResourceChangeListener resourceListener = new IResourceChangeListener() {
        public void resourceChanged(IResourceChangeEvent event) {
            MarkerProvider.this.resourceChanged(event);
        }
    };
    
    
    private static int refCount = 0;
    private static MarkerProvider singleton = null;
    
    public static IConcurrentModel getRef() {
    	if (singleton == null) {
    		singleton = new MarkerProvider();
    	}
    	
    	refCount++;
    	return singleton;
    }
    
    public static void releaseRef(IConcurrentModel toRelease) {
    	refCount--;
    	if (refCount == 0) {
    		singleton.dispose();
    		singleton = null;
    	}
    }
    
    
    private MarkerProvider() {
        ResourcesPlugin.getWorkspace().addResourceChangeListener(resourceListener);
        searchJob.setSystem(true);
    }

    public void resourceChanged(IResourceChangeEvent event) {
        String[] markerTypes = getMarkerTypes();

        boolean refreshNeeded = false;

        for (int idx = 0; idx < markerTypes.length; idx++) {
            IMarkerDelta[] markerDeltas = event.findMarkerDeltas(
                    markerTypes[idx], true);
            List changes = new ArrayList(markerDeltas.length / 3);
            List additions = new ArrayList(markerDeltas.length / 3);
            List removals = new ArrayList(markerDeltas.length / 3);

            examineDelta(markerDeltas, changes, additions, removals);

            fireRemove(removals.toArray());
            fireAdd(additions.toArray());
            fireUpdate(changes.toArray());            
        }
    }

    private void examineDelta(IMarkerDelta[] deltas, List changes, List additions, List removals) {
        for (int idx = 0; idx < deltas.length; idx++) {
            IMarkerDelta delta = deltas[idx];
            int kind = delta.getKind();

            if (kind == IResourceDelta.CHANGED) {
                changes.add(MarkerList.createMarker(deltas[idx].getMarker()));
            } else if (kind == IResourceDelta.ADDED) {
                additions.add(MarkerList.createMarker(deltas[idx].getMarker()));
            } else if (kind == IResourceDelta.REMOVED) {
                removals.add(MarkerList.createMarker(deltas[idx].getMarker()));
            }
        }
    }
    
    public void dispose() {
        ResourcesPlugin.getWorkspace().removeResourceChangeListener(resourceListener);
    }
        
    public int getTotalMarkers() {
        return totalMarkers;
    }
    
    private String[] getMarkerTypes() {
        return new String[] {IMarker.MARKER};
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.jface.viewers.deferred.IConcurrentContentProvider#getElements(org.eclipse.core.runtime.IProgressMonitor)
     */
    public void doRefresh(IProgressMonitor monitor) {
        IJobManager jobMan = Platform.getJobManager();
        IWorkspaceRoot root = getWorkspaceRoot();

        ArrayList result = new ArrayList();
        
        try {
            monitor.subTask(WAITING_FOR_WORKSPACE_CHANGES_TO_FINISH);

            jobMan.beginRule(root, monitor);

            if (monitor.isCanceled()) {
                throw new InterruptedException();
            }

            monitor.subTask(SEARCHING_FOR_MARKERS);
            IMarker[] markers = root.findMarkers(IMarker.MARKER,
                    true, IResource.DEPTH_INFINITE);
            
            for (int i = 0; i < markers.length; i++) {
                IMarker marker = markers[i];
                
                ConcreteMarker next = MarkerList.createMarker(marker);

                result.add(next);
            }
            
            IConcurrentModelListener[] listeners;
            synchronized(awaitingRefresh) {
            	listeners = (IConcurrentModelListener[]) awaitingRefresh.toArray(new IConcurrentModelListener[awaitingRefresh.size()]);
            	            
                awaitingRefresh.clear();
                refreshScheduled = false;
            }

            Object[] newContents = result.toArray();
            for (int i = 0; i < listeners.length; i++) {
    			IConcurrentModelListener listener = listeners[i];
    			
    			listener.setContents(newContents);
    		}
            
        } catch (CoreException e) {
            // TODO: SHOULD LOG THIS!!!!!!!!!!!!
        } catch (InterruptedException e) {
        } finally {
            jobMan.endRule(root);
        }
        
    }

    /* (non-Javadoc)
	 * @see org.eclipse.jface.viewers.deferred.AbstractConcurrentModel#removeListener(org.eclipse.jface.viewers.deferred.IConcurrentModelListener)
	 */
	public void removeListener(IConcurrentModelListener listener) {
		super.removeListener(listener);
		// If this listener is waiting for a refresh, cancel it
        synchronized(awaitingRefresh) {
            awaitingRefresh.remove(listener);
        }

	}
    
    /* (non-Javadoc)
     * @see org.eclipse.jface.viewers.deferred.IConcurrentContentProvider#requestUpdate(org.eclipse.jface.viewers.deferred.IConcurrentContentProviderListener)
     */
    public void requestUpdate(IConcurrentModelListener listener) {
        synchronized(awaitingRefresh) {
        	if (!awaitingRefresh.contains(listener)) {
	            awaitingRefresh.add(listener);
	            // Ensure we don't reschedule the refresh job if it's already running
	            if (!refreshScheduled) {
	            	refreshScheduled = true;
	                searchJob.schedule();	
	            }
        	}
        }
    }
}

Return to bug 60117

Lines 225-231 Link Here

(-)src/org/eclipse/ui/views/markers/internal/DialogMarkerFilter.java (-24 / +24 lines)
225	}	225	}
226	}	226	}
227		227
228	private MarkerFilter filter;	228	private MarkerFilterCriteria filter;
229		229
230	private CheckboxTableViewer typesViewer;	230	private CheckboxTableViewer typesViewer;
231		231
Lines 266-272 Link Here
266	/**	266	/**
267	* Creates a new filters dialog.	267	* Creates a new filters dialog.
268	*/	268	*/
269	DialogMarkerFilter(Shell parentShell, MarkerFilter filter) {	269	DialogMarkerFilter(Shell parentShell, MarkerFilterCriteria filter) {
270	super(parentShell);	270	super(parentShell);
271	this.filter = filter;	271	this.filter = filter;
272	}	272	}
Lines 642-662 Link Here
642	*/	642	*/
643	protected void resetPressed() {	643	protected void resetPressed() {
644	filterEnabledButton	644	filterEnabledButton
645	.setSelection(MarkerFilter.DEFAULT_ACTIVATION_STATUS);	645	.setSelection(MarkerFilterCriteria.DEFAULT_ACTIVATION_STATUS);
646	filterOnMarkerLimit	646	filterOnMarkerLimit
647	.setSelection(MarkerFilter.DEFAULT_FILTER_ON_MARKER_LIMIT);	647	.setSelection(MarkerFilterCriteria.DEFAULT_FILTER_ON_MARKER_LIMIT);
648	markerLimit.setText(String.valueOf(MarkerFilter.DEFAULT_MARKER_LIMIT));	648	markerLimit.setText(String.valueOf(MarkerFilterCriteria.DEFAULT_MARKER_LIMIT));
649	typesViewer.setAllChecked(true);	649	typesViewer.setAllChecked(true);
650	int onResource = MarkerFilter.DEFAULT_ON_RESOURCE;	650	int onResource = MarkerFilterCriteria.DEFAULT_ON_RESOURCE;
651	anyResourceButton	651	anyResourceButton
652	.setSelection(onResource == MarkerFilter.ON_ANY_RESOURCE);	652	.setSelection(onResource == MarkerFilterCriteria.ON_ANY_RESOURCE);
653	anyResourceInSameProjectButton	653	anyResourceInSameProjectButton
654	.setSelection(onResource == MarkerFilter.ON_ANY_RESOURCE_OF_SAME_PROJECT);	654	.setSelection(onResource == MarkerFilterCriteria.ON_ANY_RESOURCE_OF_SAME_PROJECT);
655	selectedResourceButton	655	selectedResourceButton
656	.setSelection(onResource == MarkerFilter.ON_SELECTED_RESOURCE_ONLY);	656	.setSelection(onResource == MarkerFilterCriteria.ON_SELECTED_RESOURCE_ONLY);
657	selectedResourceAndChildrenButton	657	selectedResourceAndChildrenButton
658	.setSelection(onResource == MarkerFilter.ON_SELECTED_RESOURCE_AND_CHILDREN);	658	.setSelection(onResource == MarkerFilterCriteria.ON_SELECTED_RESOURCE_AND_CHILDREN);
659	workingSetGroup.setSelection(onResource == MarkerFilter.ON_WORKING_SET);	659	workingSetGroup.setSelection(onResource == MarkerFilterCriteria.ON_WORKING_SET);
660	updateEnabledState();	660	updateEnabledState();
661	}	661	}
662		662
Lines 705-724 Link Here
705	filter.setSelectedTypes(getSelectedTypes());	705	filter.setSelectedTypes(getSelectedTypes());
706		706
707	if (selectedResourceButton.getSelection())	707	if (selectedResourceButton.getSelection())
708	filter.setOnResource(MarkerFilter.ON_SELECTED_RESOURCE_ONLY);	708	filter.setOnResource(MarkerFilterCriteria.ON_SELECTED_RESOURCE_ONLY);
709	else if (selectedResourceAndChildrenButton.getSelection())	709	else if (selectedResourceAndChildrenButton.getSelection())
710	filter	710	filter
711	.setOnResource(MarkerFilter.ON_SELECTED_RESOURCE_AND_CHILDREN);	711	.setOnResource(MarkerFilterCriteria.ON_SELECTED_RESOURCE_AND_CHILDREN);
712	else if (anyResourceInSameProjectButton.getSelection())	712	else if (anyResourceInSameProjectButton.getSelection())
713	filter.setOnResource(MarkerFilter.ON_ANY_RESOURCE_OF_SAME_PROJECT);	713	filter.setOnResource(MarkerFilterCriteria.ON_ANY_RESOURCE_OF_SAME_PROJECT);
714	else if (workingSetGroup.getSelection())	714	else if (workingSetGroup.getSelection())
715	filter.setOnResource(MarkerFilter.ON_WORKING_SET);	715	filter.setOnResource(MarkerFilterCriteria.ON_WORKING_SET);
716	else	716	else
717	filter.setOnResource(MarkerFilter.ON_ANY_RESOURCE);	717	filter.setOnResource(MarkerFilterCriteria.ON_ANY_RESOURCE);
718		718
719	filter.setWorkingSet(workingSetGroup.getWorkingSet());	719	filter.setWorkingSet(workingSetGroup.getWorkingSet());
720		720
721	int markerLimit = MarkerFilter.DEFAULT_MARKER_LIMIT;	721	int markerLimit = MarkerFilterCriteria.DEFAULT_MARKER_LIMIT;
722		722
723	try {	723	try {
724	markerLimit = Integer.parseInt(this.markerLimit.getText());	724	markerLimit = Integer.parseInt(this.markerLimit.getText());
Lines 738-751 Link Here
738	setSelectedTypes(filter.getSelectedTypes());	738	setSelectedTypes(filter.getSelectedTypes());
739		739
740	int on = filter.getOnResource();	740	int on = filter.getOnResource();
741	anyResourceButton.setSelection(on == MarkerFilter.ON_ANY_RESOURCE);	741	anyResourceButton.setSelection(on == MarkerFilterCriteria.ON_ANY_RESOURCE);
742	anyResourceInSameProjectButton	742	anyResourceInSameProjectButton
743	.setSelection(on == MarkerFilter.ON_ANY_RESOURCE_OF_SAME_PROJECT);	743	.setSelection(on == MarkerFilterCriteria.ON_ANY_RESOURCE_OF_SAME_PROJECT);
744	selectedResourceButton	744	selectedResourceButton
745	.setSelection(on == MarkerFilter.ON_SELECTED_RESOURCE_ONLY);	745	.setSelection(on == MarkerFilterCriteria.ON_SELECTED_RESOURCE_ONLY);
746	selectedResourceAndChildrenButton	746	selectedResourceAndChildrenButton
747	.setSelection(on == MarkerFilter.ON_SELECTED_RESOURCE_AND_CHILDREN);	747	.setSelection(on == MarkerFilterCriteria.ON_SELECTED_RESOURCE_AND_CHILDREN);
748	workingSetGroup.setSelection(on == MarkerFilter.ON_WORKING_SET);	748	workingSetGroup.setSelection(on == MarkerFilterCriteria.ON_WORKING_SET);
749	workingSetGroup.setWorkingSet(filter.getWorkingSet());	749	workingSetGroup.setWorkingSet(filter.getWorkingSet());
750		750
751	markerLimit.setText("" + filter.getMarkerLimit()); //$NON-NLS-1$	751	markerLimit.setText("" + filter.getMarkerLimit()); //$NON-NLS-1$
Lines 777-783 Link Here
777	dirty = true;	777	dirty = true;
778	}	778	}
779		779
780	public void setFilter(MarkerFilter newFilter) {	780	public void setFilter(MarkerFilterCriteria newFilter) {
781	filter = newFilter;	781	filter = newFilter;
782	updateUIFromFilter();	782	updateUIFromFilter();
783	}	783	}
Lines 785-791 Link Here
785	/**	785	/**
786	* @return the MarkerFilter associated with the dialog.	786	* @return the MarkerFilter associated with the dialog.
787	*/	787	*/
788	public MarkerFilter getFilter() {	788	public MarkerFilterCriteria getFilter() {
789	return filter;	789	return filter;
790	}	790	}
791		791

Removed Link Here

(-)src/org/eclipse/ui/views/markers/internal/BookmarkMarker.java (-30 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ui.views.markers.internal;
12
13	import org.eclipse.core.resources.IMarker;
14
15	/**
16	* Represents a marker visible in the Bookmarks view. Currently, this adds no additional
17	* fields to the ConcreteMarker class. However, if additional fields were added to the
18	* bookmark view that are not general to all views, these fields would be added to this
19	* class.
20	*/
21	public class BookmarkMarker extends ConcreteMarker {
22
23	/**
24	* @param toCopy
25	*/
26	public BookmarkMarker(IMarker toCopy) {
27	super(toCopy);
28	}
29
30	}

Lines 13-20 Link Here

(-)src/org/eclipse/ui/views/markers/internal/MarkerList.java (-73 / +4 lines)
13	import java.util.ArrayList;	13	import java.util.ArrayList;
14	import java.util.Arrays;	14	import java.util.Arrays;
15	import java.util.Collection;	15	import java.util.Collection;
16	import java.util.HashMap;
17	import java.util.Iterator;
18	import java.util.List;	16	import java.util.List;
19	import java.util.Map;	17	import java.util.Map;
20		18
Lines 22-28 Link Here
22	import org.eclipse.core.resources.IResource;	20	import org.eclipse.core.resources.IResource;
23	import org.eclipse.core.resources.ResourcesPlugin;	21	import org.eclipse.core.resources.ResourcesPlugin;
24	import org.eclipse.core.runtime.CoreException;	22	import org.eclipse.core.runtime.CoreException;
25	import org.eclipse.core.runtime.IProgressMonitor;
26		23
27	/**	24	/**
28	* Represents a list of ConcreteMarkers.	25	* Represents a list of ConcreteMarkers.
Lines 75-119 Link Here
75	markerTable = null;	72	markerTable = null;
76	}	73	}
77		74
78	/**	75	public static ConcreteMarker createMarker(IMarker marker) {
79	* Returns the marker table or lazily creates it if it doesn't exist yet	76	return new ConcreteMarker(marker);
80	*
81	* @return a map of IMarker onto ConcreteMarker, containing all the ConcreteMarkers in the list
82	*/
83	private Map getMarkerMap() {
84	if (markerTable == null) {
85	markerTable = new HashMap();
86
87	for (int idx = 0; idx < markers.length; idx++) {
88	ConcreteMarker marker = markers[idx];
89	markerTable.put(marker.getMarker(), marker);
90	}
91	}
92
93	return markerTable;
94	}
95
96	/**
97	* Returns an existing marker from the list that is associated with
98	* the given IMarker
99	*
100	* @param toFind the IMarker to lookup in the list
101	* @return the ConcreteMarker that corresponds to the given IMarker
102	*/
103	public ConcreteMarker getMarker(IMarker toFind) {
104	return (ConcreteMarker) getMarkerMap().get(toFind);
105	}
106
107	public static ConcreteMarker createMarker(IMarker marker)
108	throws CoreException {
109	if (marker.isSubtypeOf(IMarker.TASK)) {
110	return new TaskMarker(marker);
111	} else if (marker.isSubtypeOf(IMarker.BOOKMARK)) {
112	return new BookmarkMarker(marker);
113	} else if (marker.isSubtypeOf(IMarker.PROBLEM)) {
114	return new ProblemMarker(marker);
115	} else
116	return new ConcreteMarker(marker);
117	}	77	}
118		78
119	public void refresh() {	79	public void refresh() {
Lines 127-148 Link Here
127	return Arrays.asList(markers);	87	return Arrays.asList(markers);
128	}	88	}
129		89
130	public MarkerList findMarkers(Collection ofIMarker) {
131	List result = new ArrayList(ofIMarker.size());
132
133	Iterator iter = ofIMarker.iterator();
134	while (iter.hasNext()) {
135	IMarker next = (IMarker) iter.next();
136
137	ConcreteMarker marker = getMarker(next);
138	if (marker != null) {
139	result.add(marker);
140	}
141	}
142
143	return new MarkerList(result);
144	}
145
146	public static ConcreteMarker[] createMarkers(IMarker[] source)	90	public static ConcreteMarker[] createMarkers(IMarker[] source)
147	throws CoreException {	91	throws CoreException {
148	ConcreteMarker[] result = new ConcreteMarker[source.length];	92	ConcreteMarker[] result = new ConcreteMarker[source.length];
Lines 155-173 Link Here
155	}	99	}
156		100
157	/**	101	/**
158	* Computes the set of markers that match the given filter
159	* @param filter the filter to apply
160	* @param mon the monitor to update
161	* @param ignoreExceptions whether or not exception will be shown
162	* @return MarkerList
163	* @throws CoreException
164	*/
165	public static MarkerList compute(MarkerFilter filter, IProgressMonitor mon,
166	boolean ignoreExceptions) throws CoreException {
167	return new MarkerList(filter.findMarkers(mon, ignoreExceptions));
168	}
169
170	/**
171	* Returns a new MarkerList containing all markers in the workspace of the specified types	102	* Returns a new MarkerList containing all markers in the workspace of the specified types
172	* @param types	103	* @param types
173	* @return IMarker[]	104	* @return IMarker[]
Lines 253-260 Link Here
253	for (int idx = 0; idx < markers.length; idx++) {	184	for (int idx = 0; idx < markers.length; idx++) {
254	ConcreteMarker marker = markers[idx];	185	ConcreteMarker marker = markers[idx];
255		186
256	if (marker instanceof ProblemMarker) {	187	if (marker instanceof ConcreteMarker) {
257	int severity = ((ProblemMarker) markers[idx]).getSeverity();	188	int severity = ((ConcreteMarker) markers[idx]).getSeverity();
258	if (severity >= 0 && severity <= 2) {	189	if (severity >= 0 && severity <= 2) {
259	markerCounts[severity]++;	190	markerCounts[severity]++;
260	}	191	}

Removed Link Here

(-)src/org/eclipse/ui/views/markers/internal/MarkerRegistry.java (-279 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2004 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.ui.views.markers.internal;
13
14	import java.util.ArrayList;
15	import java.util.Arrays;
16	import java.util.List;
17
18	import org.eclipse.core.resources.IMarker;
19	import org.eclipse.core.resources.IMarkerDelta;
20	import org.eclipse.core.resources.IResource;
21	import org.eclipse.core.resources.IResourceChangeEvent;
22	import org.eclipse.core.resources.IResourceChangeListener;
23	import org.eclipse.core.resources.IResourceDelta;
24	import org.eclipse.core.runtime.CoreException;
25	import org.eclipse.jface.util.ListenerList;
26
27	/**
28	* Registry that tracks resource markers and maintains a sorted, filtered list of the markers.
29	* Notifies listeners of changes in these markers.
30	*/
31	public class MarkerRegistry implements IResourceChangeListener,
32	ITableViewContentProvider {
33
34	private IFilter filter;
35
36	private IResource input;
37
38	private String[] types = new String[0];
39
40	private ListenerList listeners = new ListenerList();
41
42	public MarkerRegistry() {
43	}
44
45	/**
46	* Disposes the registry, releasing all listeners
47	* and any other allocated resources.
48	*/
49	public void dispose() {
50	listeners.clear();
51	setInput(null);
52	}
53
54	/**
55	* @return a filtered, sorted list of markers.
56	*/
57	public Object[] getElements() {
58	Object[] elements = getUnfilteredElements();
59	if (filter != null) {
60	Object[] filteredItems = filter.filter(elements);
61	return filteredItems;
62	}
63	return elements;
64	}
65
66	/**
67	* @return an unfiltered list of elements
68	*/
69	public Object[] getUnfilteredElements() {
70	if (input == null) {
71	return new Object[0];
72	}
73	List elements = new ArrayList();
74	for (int i = 0; i < types.length; i++) {
75	try {
76	IMarker[] newMarkers = input.findMarkers(types[i], true,
77	IResource.DEPTH_INFINITE);
78	elements.addAll(Arrays.asList(newMarkers));
79	} catch (CoreException e) {
80	}
81	}
82	return elements.toArray();
83	}
84
85	/**
86	* @return the registry's filter or <code>null</code> if no filter has been assigned
87	* to the registry.
88	*/
89	public IFilter getFilter() {
90	return filter;
91	}
92
93	/**
94	* @return the registry's input resource
95	*/
96	public IResource getInput() {
97	return input;
98	}
99
100	/**
101	* Sets the registry's filter
102	*
103	* @param filter
104	*/
105	public void setFilter(IFilter filter) {
106	if (this.filter == null \|\| !this.filter.equals(filter)) {
107	this.filter = filter;
108	}
109	}
110
111	/**
112	* Sets the registry's input resource
113	*
114	* @param resource
115	*/
116	public void setInput(IResource resource) {
117	if (input != null) {
118	if (input.equals(resource))
119	return;
120	input.getWorkspace().removeResourceChangeListener(this);
121	}
122	input = resource;
123	if (input != null)
124	resource.getWorkspace().addResourceChangeListener(this);
125	}
126
127	/**
128	* @return the base marker types that the registry is tracking
129	*/
130	public String[] getTypes() {
131	return types;
132	}
133
134	/**
135	* Sets the base marker types to track. By default the registry will search for
136	* all markers of these types and their subtypes.
137	*
138	* @param types
139	*/
140	public void setTypes(String[] types) {
141	if (types == null)
142	this.types = new String[0];
143	else
144	this.types = types;
145	}
146
147	/**
148	* Convenience method used if only interested in one base marker type.
149	*
150	* @param type
151	*/
152	public void setType(String type) {
153	setTypes(new String[] { type });
154	}
155
156	/* (non-Javadoc)
157	* @see org.eclipse.core.resources.IResourceChangeListener#resourceChanged(org.eclipse.core.resources.IResourceChangeEvent)
158	*/
159	public void resourceChanged(IResourceChangeEvent event) {
160
161	// gather all marker changes from the delta.
162	// be sure to do this in the calling thread,
163	// as the delta is destroyed when this method returns
164	final List additions = new ArrayList();
165	final List removals = new ArrayList();
166	final List changes = new ArrayList();
167
168	IResourceDelta delta = event.getDelta();
169	if (delta == null)
170	return;
171	getMarkerDeltas(delta, additions, removals, changes);
172	//filter additions and changes but not removals since they have already been deleted
173	filterList(additions);
174	filterList(changes);
175	notifyListeners(additions, removals, changes);
176	}
177
178	/**
179	* Recursively walks over the resource delta and gathers all marker deltas. Marker
180	* deltas are placed into one of the two given lists depending on the type of delta
181	* (add or remove).
182	*/
183	private void getMarkerDeltas(IResourceDelta delta, List additions,
184	List removals, List changes) {
185	IMarkerDelta[] markerDeltas = delta.getMarkerDeltas();
186	for (int i = 0; i < markerDeltas.length; i++) {
187	IMarkerDelta markerDelta = markerDeltas[i];
188	IMarker marker = markerDelta.getMarker();
189	switch (markerDelta.getKind()) {
190	case IResourceDelta.ADDED: {
191	boolean added = false;
192	for (int j = 0; j < types.length && !added; j++) {
193	if (markerDelta.isSubtypeOf(types[j])) {
194	additions.add(marker);
195	added = true;
196	}
197	}
198	break;
199	}
200	case IResourceDelta.REMOVED: {
201	boolean added = false;
202	for (int j = 0; j < types.length && !added; j++) {
203	if (markerDelta.isSubtypeOf(types[j])) {
204	removals.add(marker);
205	added = true;
206	}
207	}
208	break;
209	}
210	case IResourceDelta.CHANGED: {
211	boolean added = false;
212	for (int j = 0; j < types.length && !added; j++) {
213	if (markerDelta.isSubtypeOf(types[j])) {
214	changes.add(marker);
215	added = true;
216	}
217	}
218	break;
219	}
220	}
221	}
222
223	//recurse on child deltas
224	IResourceDelta[] children = delta.getAffectedChildren();
225	for (int i = 0; i < children.length; i++) {
226	getMarkerDeltas(children[i], additions, removals, changes);
227	}
228	}
229
230	private void notifyListeners(List additions, List removals, List changes) {
231	Object[] listeners = this.listeners.getListeners();
232	for (int i = 0; i < listeners.length; i++) {
233	IItemsChangedListener listener = (IItemsChangedListener) listeners[i];
234	listener.itemsChanged(additions, removals, changes);
235	}
236	}
237
238	/* (non-Javadoc)
239	* @see org.eclipse.ui.views.internal.tableview.ITableViewContentProvider#addItemsChangedListener(org.eclipse.ui.views.internal.tableview.IItemsChangedListener)
240	*/
241	public void addItemsChangedListener(IItemsChangedListener listener) {
242	listeners.add(listener);
243	}
244
245	/* (non-Javadoc)
246	* @see org.eclipse.ui.views.internal.tableview.ITableViewContentProvider#removeItemsChangedListener(org.eclipse.ui.views.internal.tableview.IItemsChangedListener)
247	*/
248	public void removeItemsChangedListener(IItemsChangedListener listener) {
249	listeners.remove(listener);
250	}
251
252	/**
253	* @return the number of items
254	*/
255	public int getItemCount() {
256	//TODO do this more efficiently
257	return getElements().length;
258	}
259
260	public int getRawItemCount() {
261	//TODO do this more efficiently
262	return getUnfilteredElements().length;
263	}
264
265	private void filterList(List list) {
266	if (filter == null \|\| list == null) {
267	return;
268	}
269	int i = 0;
270	while (i < list.size()) {
271	if (filter.select(list.get(i))) {
272	i++;
273	} else {
274	list.remove(i);
275	}
276	}
277	}
278
279	}

Added Link Here

(-)src/org/eclipse/ui/views/markers/internal/MarkerProvider.java (+228 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ui.views.markers.internal;
12
13	import java.util.ArrayList;
14	import java.util.List;
15
16	import org.eclipse.core.resources.IMarker;
17	import org.eclipse.core.resources.IMarkerDelta;
18	import org.eclipse.core.resources.IResource;
19	import org.eclipse.core.resources.IResourceChangeEvent;
20	import org.eclipse.core.resources.IResourceChangeListener;
21	import org.eclipse.core.resources.IResourceDelta;
22	import org.eclipse.core.resources.IWorkspaceRoot;
23	import org.eclipse.core.resources.ResourcesPlugin;
24	import org.eclipse.core.runtime.CoreException;
25	import org.eclipse.core.runtime.IProgressMonitor;
26	import org.eclipse.core.runtime.IStatus;
27	import org.eclipse.core.runtime.Platform;
28	import org.eclipse.core.runtime.Status;
29	import org.eclipse.core.runtime.jobs.IJobManager;
30	import org.eclipse.core.runtime.jobs.Job;
31	import org.eclipse.jface.viewers.deferred.AbstractConcurrentModel;
32	import org.eclipse.jface.viewers.deferred.IConcurrentModel;
33	import org.eclipse.jface.viewers.deferred.IConcurrentModelListener;
34
35	/**
36	* @since 3.1
37	*/
38	public class MarkerProvider extends AbstractConcurrentModel {
39
40	private static final String WAITING_FOR_WORKSPACE_CHANGES_TO_FINISH = Messages
41	.getString("MarkerView.waiting_on_changes"); //$NON-NLS-1$
42
43	private static final String SEARCHING_FOR_MARKERS = Messages
44	.getString("MarkerView.searching_for_markers"); //$NON-NLS-1$
45
46	private static final String REFRESHING_MARKER_COUNTS = Messages
47	.getString("MarkerView.refreshing_counts"); //$NON-NLS-1$
48
49	private IWorkspaceRoot getWorkspaceRoot() {
50	return ResourcesPlugin.getWorkspace().getRoot();
51	}
52
53	private Job searchJob = new Job(SEARCHING_FOR_MARKERS) {
54	/* (non-Javadoc)
55	* @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
56	*/
57	protected IStatus run(IProgressMonitor monitor) {
58	doRefresh(monitor);
59	return Status.OK_STATUS;
60	}
61	};
62
63	private int totalMarkers = 0;
64	private ArrayList awaitingRefresh = new ArrayList();
65	private volatile boolean refreshScheduled = false;
66
67	IResourceChangeListener resourceListener = new IResourceChangeListener() {
68	public void resourceChanged(IResourceChangeEvent event) {
69	MarkerProvider.this.resourceChanged(event);
70	}
71	};
72
73
74	private static int refCount = 0;
75	private static MarkerProvider singleton = null;
76
77	public static IConcurrentModel getRef() {
78	if (singleton == null) {
79	singleton = new MarkerProvider();
80	}
81
82	refCount++;
83	return singleton;
84	}
85
86	public static void releaseRef(IConcurrentModel toRelease) {
87	refCount--;
88	if (refCount == 0) {
89	singleton.dispose();
90	singleton = null;
91	}
92	}
93
94
95	private MarkerProvider() {
96	ResourcesPlugin.getWorkspace().addResourceChangeListener(resourceListener);
97	searchJob.setSystem(true);
98	}
99
100	public void resourceChanged(IResourceChangeEvent event) {
101	String[] markerTypes = getMarkerTypes();
102
103	boolean refreshNeeded = false;
104
105	for (int idx = 0; idx < markerTypes.length; idx++) {
106	IMarkerDelta[] markerDeltas = event.findMarkerDeltas(
107	markerTypes[idx], true);
108	List changes = new ArrayList(markerDeltas.length / 3);
109	List additions = new ArrayList(markerDeltas.length / 3);
110	List removals = new ArrayList(markerDeltas.length / 3);
111
112	examineDelta(markerDeltas, changes, additions, removals);
113
114	fireRemove(removals.toArray());
115	fireAdd(additions.toArray());
116	fireUpdate(changes.toArray());
117	}
118	}
119
120	private void examineDelta(IMarkerDelta[] deltas, List changes, List additions, List removals) {
121	for (int idx = 0; idx < deltas.length; idx++) {
122	IMarkerDelta delta = deltas[idx];
123	int kind = delta.getKind();
124
125	if (kind == IResourceDelta.CHANGED) {
126	changes.add(MarkerList.createMarker(deltas[idx].getMarker()));
127	} else if (kind == IResourceDelta.ADDED) {
128	additions.add(MarkerList.createMarker(deltas[idx].getMarker()));
129	} else if (kind == IResourceDelta.REMOVED) {
130	removals.add(MarkerList.createMarker(deltas[idx].getMarker()));
131	}
132	}
133	}
134
135	public void dispose() {
136	ResourcesPlugin.getWorkspace().removeResourceChangeListener(resourceListener);
137	}
138
139	public int getTotalMarkers() {
140	return totalMarkers;
141	}
142
143	private String[] getMarkerTypes() {
144	return new String[] {IMarker.MARKER};
145	}
146
147	/* (non-Javadoc)
148	* @see org.eclipse.jface.viewers.deferred.IConcurrentContentProvider#getElements(org.eclipse.core.runtime.IProgressMonitor)
149	*/
150	public void doRefresh(IProgressMonitor monitor) {
151	IJobManager jobMan = Platform.getJobManager();
152	IWorkspaceRoot root = getWorkspaceRoot();
153
154	ArrayList result = new ArrayList();
155
156	try {
157	monitor.subTask(WAITING_FOR_WORKSPACE_CHANGES_TO_FINISH);
158
159	jobMan.beginRule(root, monitor);
160
161	if (monitor.isCanceled()) {
162	throw new InterruptedException();
163	}
164
165	monitor.subTask(SEARCHING_FOR_MARKERS);
166	IMarker[] markers = root.findMarkers(IMarker.MARKER,
167	true, IResource.DEPTH_INFINITE);
168
169	for (int i = 0; i < markers.length; i++) {
170	IMarker marker = markers[i];
171
172	ConcreteMarker next = MarkerList.createMarker(marker);
173
174	result.add(next);
175	}
176
177	IConcurrentModelListener[] listeners;
178	synchronized(awaitingRefresh) {
179	listeners = (IConcurrentModelListener[]) awaitingRefresh.toArray(new IConcurrentModelListener[awaitingRefresh.size()]);
180
181	awaitingRefresh.clear();
182	refreshScheduled = false;
183	}
184
185	Object[] newContents = result.toArray();
186	for (int i = 0; i < listeners.length; i++) {
187	IConcurrentModelListener listener = listeners[i];
188
189	listener.setContents(newContents);
190	}
191
192	} catch (CoreException e) {
193	// TODO: SHOULD LOG THIS!!!!!!!!!!!!
194	} catch (InterruptedException e) {
195	} finally {
196	jobMan.endRule(root);
197	}
198
199	}
200
201	/* (non-Javadoc)
202	* @see org.eclipse.jface.viewers.deferred.AbstractConcurrentModel#removeListener(org.eclipse.jface.viewers.deferred.IConcurrentModelListener)
203	*/
204	public void removeListener(IConcurrentModelListener listener) {
205	super.removeListener(listener);
206	// If this listener is waiting for a refresh, cancel it
207	synchronized(awaitingRefresh) {
208	awaitingRefresh.remove(listener);
209	}
210
211	}
212
213	/* (non-Javadoc)
214	* @see org.eclipse.jface.viewers.deferred.IConcurrentContentProvider#requestUpdate(org.eclipse.jface.viewers.deferred.IConcurrentContentProviderListener)
215	*/
216	public void requestUpdate(IConcurrentModelListener listener) {
217	synchronized(awaitingRefresh) {
218	if (!awaitingRefresh.contains(listener)) {
219	awaitingRefresh.add(listener);
220	// Ensure we don't reschedule the refresh job if it's already running
221	if (!refreshScheduled) {
222	refreshScheduled = true;
223	searchJob.schedule();
224	}
225	}
226	}
227	}
228	}