Attachment 2706 Details for Bug 9525 – fix

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

[patch] fix

9525.txt (text/plain), 47.90 KB, created by Sebastian Davids

on 2002-12-08 10:15:45 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Sebastian Davids

Created: 2002-12-08 10:15:45 EST

Size: 47.90 KB

patch

obsolete

>Index: FailureTraceView.java
>===================================================================
>RCS file: /home/eclipse/org.eclipse.jdt.junit/src/org/eclipse/jdt/internal/junit/ui/FailureTraceView.java,v
>retrieving revision 1.7
>diff -u -r1.7 FailureTraceView.java
>--- FailureTraceView.java	25 Nov 2002 13:12:30 -0000	1.7
>+++ FailureTraceView.java	8 Dec 2002 15:05:29 -0000
>@@ -224,8 +224,25 @@
> 	}
> 	
> 	private boolean filterLine(String[] patterns, String line) {
>-		for (int i= 0; i < patterns.length; i++) {
>-			if (line.indexOf(patterns[i]) > 0)
>+		String pattern;
>+		int len;
>+		for (int i= (patterns.length - 1); i >= 0; --i) {
>+			pattern= patterns[i];
>+			len= pattern.length() - 1;
>+			if (pattern.charAt(len) == '*') {
>+				//strip trailing * from a package filter
>+				pattern= pattern.substring(0, len);
>+			} else if (Character.isUpperCase(pattern.charAt(0))) {
>+				//class in the default package
>+				pattern= FRAME_PREFIX + pattern + '.';
>+			} else {
>+				//class names start w/ an uppercase letter after the .
>+				final int lastDotIndex= pattern.lastIndexOf('.');
>+				if ((lastDotIndex != -1) && (lastDotIndex != len) && Character.isUpperCase(pattern.charAt(lastDotIndex + 1)))
>+					pattern += '.'; //append . to a class filter
>+			}
>+
>+			if (line.indexOf(pattern) > 0)
> 				return true;
> 		}		
> 		return false;
>Index: IJUnitPreferencesConstants.java
>===================================================================
>RCS file: IJUnitPreferencesConstants.java
>diff -N IJUnitPreferencesConstants.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ IJUnitPreferencesConstants.java	8 Dec 2002 15:05:30 -0000
>@@ -0,0 +1,31 @@
>+package org.eclipse.jdt.internal.junit.ui;
>+
>+/**
>+ * Defines constants which are used to refer to values in the plugin's preference store.
>+ */
>+public interface IJUnitPreferencesConstants {
>+	/**
>+	 * Boolean preference controlling whether the failure stack should be
>+	 * filtered.
>+	 */	
>+	public static String DO_FILTER_STACK= JUnitPlugin.PLUGIN_ID + ".do_filter_stack"; //$NON-NLS-1$
>+
>+	/**
>+	 * Boolean preference controlling whether the JUnit view should be shown on
>+	 * errors only.
>+	 */	
>+	public static String SHOW_ON_ERROR_ONLY= JUnitPlugin.PLUGIN_ID + ".show_on_error"; //$NON-NLS-1$
>+	
>+	/**
>+	 * List of active stack filters. A String containing a comma separated list
>+	 * of fully qualified type names/patterns.
>+	 */			
>+	public static final String PREF_ACTIVE_FILTERS_LIST = JUnitPlugin.PLUGIN_ID + ".active_filters"; //$NON-NLS-1$
>+	
>+	/**
>+	 * List of inactive stack filters. A String containing a comma separated
>+	 * list of fully qualified type names/patterns.
>+	 */				
>+	public static final String PREF_INACTIVE_FILTERS_LIST = JUnitPlugin.PLUGIN_ID + ".inactive_filters"; //$NON-NLS-1$	
>+
>+}
>Index: JUnitMessages.properties
>===================================================================
>RCS file: /home/eclipse/org.eclipse.jdt.junit/src/org/eclipse/jdt/internal/junit/ui/JUnitMessages.properties,v
>retrieving revision 1.8
>diff -u -r1.8 JUnitMessages.properties
>--- JUnitMessages.properties	30 Sep 2002 10:21:11 -0000	1.8
>+++ JUnitMessages.properties	8 Dec 2002 15:05:29 -0000
>@@ -18,13 +18,31 @@
> HierarchyRunView.tab.title=Hierarchy
> 
> JUnitPlugin.error.cannotshow=Could not show JUnit Result View
>+JUnitPlugin.searching=Searching
> 
>-JUnitPreferencePage.addbutton.label=&Add...
>-JUnitPreferencePage.removebutton.label=&Remove
>+JUnitPreferencePage.addfilterbutton.label=Add &Filter
>+JUnitPreferencePage.addfilterbutton.tooltip=Key in the Name of a New Stack Filter
>+JUnitPreferencePage.addtypebutton.label=Add &Class...
>+JUnitPreferencePage.addtypebutton.tooltip=Choose a Java Type and Add It to Stack Filters
>+JUnitPreferencePage.addpackagebutton.label=Add &Packages...
>+JUnitPreferencePage.addpackagebutton.tooltip=Choose Package(s) to Add to Stack Filters
>+JUnitPreferencePage.removefilterbutton.label=&Remove
>+JUnitPreferencePage.removefilterbutton.tooltip=Remove All Selected Stack Filters
>+JUnitPreferencePage.enableallbutton.label=&Enable All
>+JUnitPreferencePage.enableallbutton.tooltip=Enables All Stack Filters
>+JUnitPreferencePage.disableallbutton.label=Disa&ble All
>+JUnitPreferencePage.disableallbutton.tooltip=Disables All Stack Filters
> JUnitPreferencePage.filter.label=&Stack filter patterns:
> JUnitPreferencePage.adddialog.title=Add Stack Filter Pattern
> JUnitPreferencePage.addialog.prompt=Enter Filter Pattern:
> JUnitPreferencePage.showcheck.label=Show the JUnit results &view only when an error or failure occurs
>+JUnitPreferencePage.invalidstepfilterreturnescape=\ Invalid stack filter. Return to continue; escape to exit.
>+JUnitPreferencePage.addtypedialog.title=Add Class to Stack Filters
>+JUnitPreferencePage.addtypedialog.message=&Select a class to filter in the failure stack trace.
>+JUnitPreferencePage.addtypedialog.error.message=Could not open type selection dialog for stack filters.
>+JUnitPreferencePage.addpackagedialog.title=Add Packages to Stack Filters
>+JUnitPreferencePage.addpackagedialog.message=&Select a package to filter in the failure stack trace.
>+JUnitPreferencePage.addpackagedialog.error.message=Could not open package selection dialog for stack filters.
> 
> OpenEditorAction.action.label=&Goto File
> OpenEditorAction.error.cannotopen.title=Cannot Open Editor
>@@ -69,6 +87,7 @@
> JUnitMainTab.error.projectnotexists=Project does not exist
> JUnitMainTab.error.testnotdefined=Test not specified
> JUnitMainTab.tab.label=Test
>+JUnitMainTab.label.defaultpackage=(default package)
> 
> RemoteTestRunner.error.classnotfound= Class not found {0}
> RemoteTestRunner.error.exception= "Error:  " {0}
>Index: JUnitPlugin.java
>===================================================================
>RCS file: /home/eclipse/org.eclipse.jdt.junit/src/org/eclipse/jdt/internal/junit/ui/JUnitPlugin.java,v
>retrieving revision 1.13
>diff -u -r1.13 JUnitPlugin.java
>--- JUnitPlugin.java	7 Aug 2002 09:43:58 -0000	1.13
>+++ JUnitPlugin.java	8 Dec 2002 15:05:29 -0000
>@@ -4,13 +4,20 @@
>  */
> package org.eclipse.jdt.internal.junit.ui;
> 
>+import java.lang.reflect.InvocationTargetException;
> import java.net.MalformedURLException;
> import java.net.URL;
> import java.util.AbstractSet;
>+import java.util.ArrayList;
> import java.util.HashSet;
>+import java.util.List;
>+import java.util.Set;
> 
>+import org.eclipse.core.resources.IWorkspaceRoot;
>+import org.eclipse.core.resources.ResourcesPlugin;
> import org.eclipse.core.runtime.CoreException;
> import org.eclipse.core.runtime.IPluginDescriptor;
>+import org.eclipse.core.runtime.IProgressMonitor;
> import org.eclipse.core.runtime.IStatus;
> import org.eclipse.core.runtime.Status;
> import org.eclipse.debug.core.DebugPlugin;
>@@ -19,9 +26,16 @@
> import org.eclipse.debug.core.ILaunchListener;
> import org.eclipse.debug.core.ILaunchManager;
> import org.eclipse.jdt.core.IJavaElement;
>+import org.eclipse.jdt.core.IJavaModel;
>+import org.eclipse.jdt.core.IJavaProject;
>+import org.eclipse.jdt.core.IPackageFragment;
> import org.eclipse.jdt.core.IType;
> import org.eclipse.jdt.core.JavaCore;
>+import org.eclipse.jdt.core.JavaModelException;
> import org.eclipse.jdt.internal.junit.launcher.JUnitBaseLaunchConfiguration;
>+import org.eclipse.jdt.ui.JavaElementLabelProvider;
>+import org.eclipse.jface.dialogs.ProgressMonitorDialog;
>+import org.eclipse.jface.operation.IRunnableWithProgress;
> import org.eclipse.jface.preference.IPreferenceStore;
> import org.eclipse.jface.resource.ImageDescriptor;
> import org.eclipse.swt.widgets.Display;
>@@ -31,6 +45,7 @@
> import org.eclipse.ui.IWorkbenchPart;
> import org.eclipse.ui.IWorkbenchWindow;
> import org.eclipse.ui.PartInitException;
>+import org.eclipse.ui.dialogs.ElementListSelectionDialog;
> import org.eclipse.ui.plugin.AbstractUIPlugin;
> 
> /**
>@@ -232,5 +247,65 @@
> 		}
> 		return display;
> 	}		
>-	
>+
>+	/**
>+	 * Utility method to create and return a selection dialog that allows
>+	 * selection of a specific Java package.  Empty packages are not returned.
>+	 * If Java Projects are provided, only packages found within those projects
>+	 * are included.  If no Java projects are provided, all Java projects in the
>+	 * workspace are considered.
>+	 */
>+	public static ElementListSelectionDialog createAllPackagesDialog(Shell shell,	IJavaProject[] originals, final boolean includeDefaultPackage) throws JavaModelException {
>+		final List packageList= new ArrayList();
>+		if (originals == null) {
>+			IWorkspaceRoot wsroot= ResourcesPlugin.getWorkspace().getRoot();
>+			IJavaModel model= JavaCore.create(wsroot);
>+			originals= model.getJavaProjects();
>+		}
>+		final IJavaProject[] projects= originals;
>+		final JavaModelException[] exception= new JavaModelException[1];
>+		ProgressMonitorDialog monitor= new ProgressMonitorDialog(shell);
>+		IRunnableWithProgress r= new IRunnableWithProgress() {
>+			public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
>+				try {
>+					Set packageNameSet= new HashSet();
>+					monitor.beginTask(JUnitMessages.getString("JUnitPlugin.searching"), projects.length); //$NON-NLS-1$
>+					for (int i= 0; i < projects.length; i++) {
>+						IPackageFragment[] pkgs= projects[i].getPackageFragments();
>+						for (int j= 0; j < pkgs.length; j++) {
>+							IPackageFragment pkg= pkgs[j];
>+							if (!pkg.hasChildren() && (pkg.getNonJavaResources().length > 0))
>+								continue;
>+
>+							String pkgName= pkg.getElementName();
>+							if (!includeDefaultPackage && pkgName.length() == 0)
>+								continue;
>+
>+							if (packageNameSet.add(pkgName))
>+								packageList.add(pkg);
>+						}
>+						monitor.worked(1);
>+					}
>+					monitor.done();
>+				} catch (JavaModelException jme) {
>+					exception[0]= jme;
>+				}
>+			}
>+		};
>+		try {
>+			monitor.run(false, false, r);
>+		} catch (InvocationTargetException e) {
>+			JUnitPlugin.log(e);
>+		} catch (InterruptedException e) {
>+			JUnitPlugin.log(e);
>+		}
>+		if (exception[0] != null)
>+			throw exception[0];
>+
>+		int flags= JavaElementLabelProvider.SHOW_DEFAULT;
>+		ElementListSelectionDialog dialog= new ElementListSelectionDialog(shell, new JavaElementLabelProvider(flags));
>+		dialog.setIgnoreCase(false);
>+		dialog.setElements(packageList.toArray()); // XXX inefficient
>+		return dialog;
>+	}
> }
>Index: JUnitPreferencePage.java
>===================================================================
>RCS file: /home/eclipse/org.eclipse.jdt.junit/src/org/eclipse/jdt/internal/junit/ui/JUnitPreferencePage.java,v
>retrieving revision 1.7
>diff -u -r1.7 JUnitPreferencePage.java
>--- JUnitPreferencePage.java	11 Jun 2002 23:03:28 -0000	1.7
>+++ JUnitPreferencePage.java	8 Dec 2002 15:05:30 -0000
>@@ -4,106 +4,345 @@
>  */
> package org.eclipse.jdt.internal.junit.ui;
> 
>+import java.util.ArrayList;
>+import java.util.Arrays;
>+import java.util.Iterator;
>+import java.util.List;
>+import java.util.StringTokenizer;
>+
>+import org.eclipse.jdt.core.IJavaElement;
>+import org.eclipse.jdt.core.IType;
>+import org.eclipse.jdt.core.JavaModelException;
>+import org.eclipse.jdt.core.search.SearchEngine;
>+import org.eclipse.jdt.internal.junit.util.ExceptionHandler;
>+import org.eclipse.jdt.internal.junit.util.SWTUtil;
>+import org.eclipse.jdt.ui.IJavaElementSearchConstants;
>+import org.eclipse.jdt.ui.ISharedImages;
>+import org.eclipse.jdt.ui.JavaUI;
> import org.eclipse.jface.dialogs.IDialogConstants;
>-import org.eclipse.jface.preference.*;
>+import org.eclipse.jface.dialogs.ProgressMonitorDialog;
>+import org.eclipse.jface.preference.IPreferenceStore;
>+import org.eclipse.jface.preference.PreferencePage;
>+import org.eclipse.jface.viewers.CheckStateChangedEvent;
>+import org.eclipse.jface.viewers.CheckboxTableViewer;
>+import org.eclipse.jface.viewers.ColumnLayoutData;
>+import org.eclipse.jface.viewers.ColumnWeightData;
>+import org.eclipse.jface.viewers.ContentViewer;
>+import org.eclipse.jface.viewers.ICheckStateListener;
>+import org.eclipse.jface.viewers.ILabelProvider;
>+import org.eclipse.jface.viewers.ISelection;
>+import org.eclipse.jface.viewers.ISelectionChangedListener;
>+import org.eclipse.jface.viewers.IStructuredContentProvider;
>+import org.eclipse.jface.viewers.IStructuredSelection;
>+import org.eclipse.jface.viewers.ITableLabelProvider;
>+import org.eclipse.jface.viewers.LabelProvider;
>+import org.eclipse.jface.viewers.SelectionChangedEvent;
>+import org.eclipse.jface.viewers.TableLayout;
>+import org.eclipse.jface.viewers.Viewer;
> import org.eclipse.swt.SWT;
>-import org.eclipse.swt.events.*;
>-import org.eclipse.swt.layout.*;
>-import org.eclipse.swt.widgets.*;
>-import org.eclipse.ui.*;
>+import org.eclipse.swt.custom.TableEditor;
>+import org.eclipse.swt.events.FocusAdapter;
>+import org.eclipse.swt.events.FocusEvent;
>+import org.eclipse.swt.events.KeyAdapter;
>+import org.eclipse.swt.events.KeyEvent;
>+import org.eclipse.swt.graphics.Image;
>+import org.eclipse.swt.layout.GridData;
>+import org.eclipse.swt.layout.GridLayout;
>+import org.eclipse.swt.widgets.Button;
>+import org.eclipse.swt.widgets.Composite;
>+import org.eclipse.swt.widgets.Control;
>+import org.eclipse.swt.widgets.Event;
>+import org.eclipse.swt.widgets.Label;
>+import org.eclipse.swt.widgets.Listener;
>+import org.eclipse.swt.widgets.Shell;
>+import org.eclipse.swt.widgets.Table;
>+import org.eclipse.swt.widgets.TableColumn;
>+import org.eclipse.swt.widgets.TableItem;
>+import org.eclipse.swt.widgets.Text;
>+import org.eclipse.ui.IWorkbench;
>+import org.eclipse.ui.IWorkbenchPreferencePage;
>+import org.eclipse.ui.dialogs.ElementListSelectionDialog;
>+import org.eclipse.ui.dialogs.SelectionDialog;
> import org.eclipse.ui.help.WorkbenchHelp;
>+import org.eclipse.ui.model.WorkbenchViewerSorter;
> 
> /**
>  * Preference page for JUnit settings. Supports to define the failure
>  * stack filter patterns.
>  */
>-public class JUnitPreferencePage extends PreferencePage 
>-		implements IWorkbenchPreferencePage, SelectionListener {
>-					
>-	private String fFilterString;
>-	private Table fTable;
>-	private Button fAddButton;
>-	private Button fRemoveButton;
>-	private Button fShowOnErrorCheck;
>-	
>-	public static String STACK_FILTER_ENTRIES_COUNT= "NOF_STACK_FILTER_ENTRIES"; //$NON-NLS-1$
>-	public static String STACK_FILTER_ENTRY_= "STACK_FILTER_ENTRY_"; //$NON-NLS-1$
>-	public static String DO_FILTER_STACK= "DO_FILTER_STACK"; //$NON-NLS-1$
>-	public static String SHOW_ON_ERROR_ONLY= "SHOW_ON_ERROR"; //$NON-NLS-1$
>+public class JUnitPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {
>+
>+	private static final String DEFAULT_NEW_FILTER_TEXT= ""; //$NON-NLS-1$
>+	private static final Image IMG_CUNIT= JavaUI.getSharedImages().getImage(ISharedImages.IMG_OBJS_CLASS);
>+	private static final Image IMG_PKG= JavaUI.getSharedImages().getImage(ISharedImages.IMG_OBJS_PACKAGE);
> 	
>-	private static String[] fgDefaultFilterPatterns= new String[] {
>-		"org.eclipse.jdt.internal.junit.runner", //$NON-NLS-1$
>-		"org.eclipse.jdt.internal.junit.ui", //$NON-NLS-1$
>+	private static String[] fgDefaultFilterPatterns= new String[] { "org.eclipse.jdt.internal.junit.runner.*", //$NON-NLS-1$
>+		"org.eclipse.jdt.internal.junit.ui.*", //$NON-NLS-1$
> 		"junit.framework.TestCase", //$NON-NLS-1$
> 		"junit.framework.TestResult", //$NON-NLS-1$
> 		"junit.framework.TestSuite", //$NON-NLS-1$
>-		"junit.framework.Assert.", // don't filter AssertionFailure //$NON-NLS-1$
>+		"junit.framework.Assert", //$NON-NLS-1$
> 		"java.lang.reflect.Method.invoke" //$NON-NLS-1$
> 	};
> 
>-	public JUnitPreferencePage() {
>-		super();
>-		setPreferenceStore(JUnitPlugin.getDefault().getPreferenceStore());
>-	}
>+	// Step filter widgets
>+	private CheckboxTableViewer fFilterViewer;
>+	private Table fFilterTable;
> 
>-	public static String[] getFilterPatterns() {
>-		IPreferenceStore store= JUnitPlugin.getDefault().getPreferenceStore();
>-		int count= store.getInt(STACK_FILTER_ENTRIES_COUNT);
>-		String[] result= new String[count];
>-		for (int i= 0; i < count; i++) {
>-			result[i]= store.getString(STACK_FILTER_ENTRY_ + i);
>+	private Button fShowOnErrorCheck;
>+	private Button fAddPackageButton;
>+	private Button fAddTypeButton;
>+	private Button fRemoveFilterButton;
>+	private Button fAddFilterButton;
>+
>+	private Button fEnableAllButton;
>+	private Button fDisableAllButton;
>+
>+	private Text fEditorText;
>+	private String fInvalidEditorText= null;
>+	private TableEditor fTableEditor;
>+	private TableItem fNewTableItem;
>+	private Filter fNewStackFilter;
>+	private Label fTableLabel;
>+
>+	private StackFilterContentProvider fStackFilterContentProvider;
>+
>+	/**
>+	 * Model object that represents a single entry in the filter table.
>+	 */
>+	private class Filter {
>+
>+		private String fName;
>+		private boolean fChecked;
>+
>+		public Filter(String name, boolean checked) {
>+			setName(name);
>+			setChecked(checked);
>+		}
>+
>+		public String getName() {
>+			return fName;
>+		}
>+		
>+		public void setName(String name) {
>+			fName= name;
>+		}
>+				
>+		public boolean isChecked() {
>+			return fChecked;
>+		}
>+
>+		public void setChecked(boolean checked) {
>+			fChecked= checked;
>+		}
>+
>+		public boolean equals(Object o) {
>+			if (!(o instanceof Filter))
>+				return false;
>+
>+			Filter other= (Filter) o;
>+			return (getName().equals(other.getName()));
>+		}
>+
>+		public int hashCode() {
>+			return fName.hashCode();
> 		}
>-		return result;
>-	}
>-	
>-	public static boolean getFilterStack() {
>-		IPreferenceStore store= JUnitPlugin.getDefault().getPreferenceStore();
>-		return store.getBoolean(DO_FILTER_STACK);
> 	}
>-	
>-	public static void setFilterStack(boolean filter) {
>-		IPreferenceStore store= JUnitPlugin.getDefault().getPreferenceStore();
>-		store.setValue(DO_FILTER_STACK, filter);
>+
>+	/**
>+	 * Sorter for the filter table; sorts alphabetically ascending.
>+	 */
>+	private class FilterViewerSorter extends WorkbenchViewerSorter {
>+		public int compare(Viewer viewer, Object e1, Object e2) {
>+			ILabelProvider lprov= (ILabelProvider) ((ContentViewer) viewer).getLabelProvider();
>+			String name1= lprov.getText(e1);
>+			String name2= lprov.getText(e2);
>+			if (name1 == null)
>+				name1= ""; //$NON-NLS-1$
>+
>+			if (name2 == null)
>+				name2= ""; //$NON-NLS-1$
>+
>+			if (name1.length() > 0 && name2.length() > 0) {
>+				char char1= name1.charAt(name1.length() - 1);
>+				char char2= name2.charAt(name2.length() - 1);
>+				if (char1 == '*' && char1 != char2)
>+					return -1;
>+
>+				if (char2 == '*' && char2 != char1)
>+					return 1;
>+			}
>+			return name1.compareTo(name2);
>+		}
> 	}
>-	
>-	public static void initializeDefaults(IPreferenceStore store) {
>-		store.setDefault(JUnitPreferencePage.DO_FILTER_STACK, true); 
>-		store.setDefault(JUnitPreferencePage.SHOW_ON_ERROR_ONLY, false); 
>-		int count= store.getInt(STACK_FILTER_ENTRIES_COUNT);
>-		if (count == 0) {
>-			store.setValue(STACK_FILTER_ENTRIES_COUNT, fgDefaultFilterPatterns.length);
>-			for (int i= 0; i < fgDefaultFilterPatterns.length; i++) {
>-				store.setValue(STACK_FILTER_ENTRY_ + i, fgDefaultFilterPatterns[i]);
>+
>+	/**
>+	 * Label provider for Filter model objects
>+	 */
>+	private class FilterLabelProvider extends LabelProvider implements ITableLabelProvider {
>+
>+		public String getColumnText(Object object, int column) {
>+			return (column == 0) ? ((Filter) object).getName() : ""; //$NON-NLS-1$
>+		}
>+
>+		public String getText(Object element) {
>+			return ((Filter) element).getName();
>+		}
>+
>+		public Image getColumnImage(Object object, int column) {
>+			String name= ((Filter) object).getName();
>+			if (name.endsWith(".*") || name.equals(JUnitMessages.getString("JUnitMainTab.label.defaultpackage"))) { //$NON-NLS-1$ //$NON-NLS-2$
>+				//package
>+				return IMG_PKG;
>+			} else if ("".equals(name)) { //$NON-NLS-1$
>+				//needed for the in-place editor
>+				return null;
>+			} else if ((Character.isUpperCase(name.charAt(0))) && (name.indexOf('.') < 0)) {
>+				//class in default package
>+				return IMG_CUNIT;
>+			} else {
>+				//fully-qualified class or other filter
>+				final int lastDotIndex= name.lastIndexOf('.');
>+				if ((-1 != lastDotIndex) && ((name.length() - 1) != lastDotIndex) && Character.isUpperCase(name.charAt(lastDotIndex + 1)))
>+					return IMG_CUNIT;
> 			}
>+			//other filter
>+			return null;
> 		}
> 	}
>-	
>-	/*
>-	 * @see PreferencePage#createContents(Composite)
>+
>+	/**
>+	 * Content provider for the filter table.  Content consists of instances of
>+	 * Filter.
> 	 */
>-	protected Control createContents(Composite parent) {
>-		noDefaultAndApplyButton();
>+	private class StackFilterContentProvider implements IStructuredContentProvider {
>+
>+		private List fFilters;
>+
>+		public StackFilterContentProvider() {
>+			List active= createActiveStackFiltersList();
>+			List inactive= createInactiveStackFiltersList();
>+			populateFilters(active, inactive);
>+		}
>+
>+		public void setDefaults() {
>+			fFilterViewer.remove(fFilters.toArray());
>+			List active= createDefaultStackFiltersList();
>+			List inactive= new ArrayList();
>+			populateFilters(active, inactive);
>+		}
>+
>+		protected void populateFilters(List activeList, List inactiveList) {
>+			fFilters= new ArrayList(activeList.size() + inactiveList.size());
>+			populateList(activeList, true);
>+			if (inactiveList.size() != 0)
>+				populateList(inactiveList, false);
>+		}
>+
>+		protected void populateList(List list, boolean checked) {
>+			Iterator iterator= list.iterator();
>+
>+			while (iterator.hasNext()) {
>+				String name= (String) iterator.next();
>+				addFilter(name, checked);
>+			}
>+		}
>+
>+		public Filter addFilter(String name, boolean checked) {
>+			Filter filter= new Filter(name, checked);
>+			if (!fFilters.contains(filter)) {
>+				fFilters.add(filter);
>+				fFilterViewer.add(filter);
>+				fFilterViewer.setChecked(filter, checked);
>+			}
>+			updateActions();
>+			return filter;
>+		}
>+
>+		public void saveFilters() {
>+			List active= new ArrayList(fFilters.size());
>+			List inactive= new ArrayList(fFilters.size());
>+			Iterator iterator= fFilters.iterator();
>+			while (iterator.hasNext()) {
>+				Filter filter= (Filter) iterator.next();
>+				String name= filter.getName();
>+				if (filter.isChecked())
>+					active.add(name);
>+				else
>+					inactive.add(name);
>+			}
>+			String pref= JUnitPreferencePage.serializeList((String[]) active.toArray(new String[active.size()]));
>+			getPreferenceStore().setValue(IJUnitPreferencesConstants.PREF_ACTIVE_FILTERS_LIST, pref);
>+			pref= JUnitPreferencePage.serializeList((String[]) inactive.toArray(new String[inactive.size()]));
>+			getPreferenceStore().setValue(IJUnitPreferencesConstants.PREF_INACTIVE_FILTERS_LIST, pref);
>+		}
>+
>+		public void removeFilters(Object[] filters) {
>+			for (int i= (filters.length - 1); i >= 0; --i) {
>+				Filter filter= (Filter) filters[i];
>+				fFilters.remove(filter);
>+			}
>+			fFilterViewer.remove(filters);
>+			updateActions();
>+		}
>+
>+		public void toggleFilter(Filter filter) {
>+			boolean newState= !filter.isChecked();
>+			filter.setChecked(newState);
>+			fFilterViewer.setChecked(filter, newState);
>+		}
>+
>+		public Object[] getElements(Object inputElement) {
>+			return fFilters.toArray();
>+		}
> 		
>+		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {}
>+		public void dispose() {}
>+
>+	}
>+		
>+	public JUnitPreferencePage() {
>+		super();
>+		setPreferenceStore(JUnitPlugin.getDefault().getPreferenceStore());
>+	}
>+
>+	protected Control createContents(Composite parent) {
>+		WorkbenchHelp.setHelp(parent, IJUnitHelpContextIds.JUNIT_PREFERENCE_PAGE);
>+
> 		Composite composite= new Composite(parent, SWT.NULL);
> 		GridLayout layout= new GridLayout();
>-		layout.numColumns= 2;
>-		layout.marginWidth= 0;
>+		layout.numColumns= 1;
> 		layout.marginHeight= 0;
>+		layout.marginWidth= 0;
> 		composite.setLayout(layout);
> 		GridData data= new GridData();
> 		data.verticalAlignment= GridData.FILL;
> 		data.horizontalAlignment= GridData.FILL;
>-		
> 		composite.setLayoutData(data);
>-		
>-		createShowCheck(composite);
>-		createFilterTable(composite);
>-		createListButtons(composite);
>-		WorkbenchHelp.setHelp(composite, IJUnitHelpContextIds.JUNIT_PREFERENCE_PAGE);
>+
>+		createStackFilterPreferences(composite);
> 
> 		return composite;
> 	}
> 
>+	/**
>+	 * Create a group to contain the step filter related widgetry
>+	 */
>+	private void createStackFilterPreferences(Composite composite) {
>+		Composite container= new Composite(composite, SWT.NONE);
>+		GridLayout layout= new GridLayout();
>+		layout.numColumns= 2;
>+		layout.marginHeight= 0;
>+		layout.marginWidth= 0;
>+		container.setLayout(layout);
>+		GridData gd= new GridData(GridData.FILL_BOTH);
>+		container.setLayoutData(gd);
>+
>+		createShowCheck(container);
>+		createFilterTable(container);
>+		createStepFilterButtons(container);
>+	}
>+
> 	private void createShowCheck(Composite composite) {
> 		GridData data;
> 		fShowOnErrorCheck= new Button(composite, SWT.CHECK);
>@@ -111,131 +350,493 @@
> 		data= new GridData();
> 		data.horizontalAlignment= GridData.FILL;
> 		data.horizontalSpan= 2;
>-		fShowOnErrorCheck.setLayoutData(data);		
>+		fShowOnErrorCheck.setLayoutData(data);
> 		fShowOnErrorCheck.setSelection(getShowOnErrorOnly());
> 	}
> 
>-	/**
>-	 * @return boolean
>-	 */
>-	public static boolean getShowOnErrorOnly() {
>-		IPreferenceStore store= JUnitPlugin.getDefault().getPreferenceStore();
>-		return store.getBoolean(SHOW_ON_ERROR_ONLY);
>+	private void createFilterTable(Composite container) {
>+		fTableLabel= new Label(container, SWT.NONE);
>+		fTableLabel.setText(JUnitMessages.getString("JUnitPreferencePage.filter.label")); //$NON-NLS-1$
>+		GridData gd= new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
>+		gd.horizontalSpan= 2;
>+		fTableLabel.setLayoutData(gd);
>+
>+		fFilterTable= new Table(container, SWT.CHECK | SWT.BORDER | SWT.MULTI | SWT.FULL_SELECTION);
>+
>+		gd= new GridData(GridData.FILL_HORIZONTAL);
>+		fFilterTable.setLayoutData(gd);
>+
>+		TableLayout tableLayout= new TableLayout();
>+		ColumnLayoutData[] columnLayoutData= new ColumnLayoutData[1];
>+		columnLayoutData[0]= new ColumnWeightData(100);
>+		tableLayout.addColumnData(columnLayoutData[0]);
>+		fFilterTable.setLayout(tableLayout);
>+		new TableColumn(fFilterTable, SWT.NONE);
>+		fFilterViewer= new CheckboxTableViewer(fFilterTable);
>+		fTableEditor= new TableEditor(fFilterTable);
>+		fFilterViewer.setLabelProvider(new FilterLabelProvider());
>+		fFilterViewer.setSorter(new FilterViewerSorter());
>+		fStackFilterContentProvider= new StackFilterContentProvider();
>+		fFilterViewer.setContentProvider(fStackFilterContentProvider);
>+		// input just needs to be non-null
>+		fFilterViewer.setInput(this);
>+		gd= new GridData(GridData.FILL_BOTH | GridData.GRAB_HORIZONTAL | GridData.GRAB_VERTICAL);
>+		fFilterViewer.getTable().setLayoutData(gd);
>+		fFilterViewer.addCheckStateListener(new ICheckStateListener() {
>+			public void checkStateChanged(CheckStateChangedEvent event) {
>+				Filter filter= (Filter) event.getElement();
>+				fStackFilterContentProvider.toggleFilter(filter);
>+			}
>+		});
>+		fFilterViewer.addSelectionChangedListener(new ISelectionChangedListener() {
>+			public void selectionChanged(SelectionChangedEvent event) {
>+				ISelection selection= event.getSelection();
>+				fRemoveFilterButton.setEnabled(!selection.isEmpty());
>+			}
>+		});
> 	}
>-		
>-	protected void createListButtons(Composite composite) {
>-		Composite buttonComposite= new Composite(composite, SWT.NONE);
>-		GridLayout layout= new GridLayout();
>-		layout.marginHeight= 0;
>-		buttonComposite.setLayout(layout);	
>-		GridData gridData= new GridData();
>-		gridData.verticalAlignment= GridData.FILL;
>-		gridData.horizontalAlignment= GridData.FILL;
>-		buttonComposite.setLayoutData(gridData);
>-		
>-		fAddButton= new Button(buttonComposite, SWT.CENTER | SWT.PUSH);
>-		fAddButton.setText(JUnitMessages.getString("JUnitPreferencePage.addbutton.label")); //$NON-NLS-1$
>-		setButtonGridData(fAddButton);
>-		fAddButton.addSelectionListener(this);
>-
>-		fRemoveButton= new Button(buttonComposite, SWT.CENTER | SWT.PUSH);
>-		fRemoveButton.setText(JUnitMessages.getString("JUnitPreferencePage.removebutton.label")); //$NON-NLS-1$
>-		setButtonGridData(fRemoveButton);
>-		fRemoveButton.addSelectionListener(this);
>+
>+	private void createStepFilterButtons(Composite container) {
>+		Composite buttonContainer= new Composite(container, SWT.NONE);
>+		GridData gd= new GridData(GridData.FILL_VERTICAL);
>+		buttonContainer.setLayoutData(gd);
>+		GridLayout buttonLayout= new GridLayout();
>+		buttonLayout.numColumns= 1;
>+		buttonLayout.marginHeight= 0;
>+		buttonLayout.marginWidth= 0;
>+		buttonContainer.setLayout(buttonLayout);
>+
>+		fAddFilterButton= new Button(buttonContainer, SWT.PUSH);
>+		fAddFilterButton.setText(JUnitMessages.getString("JUnitPreferencePage.addfilterbutton.label")); //$NON-NLS-1$
>+		fAddFilterButton.setToolTipText(JUnitMessages.getString("JUnitPreferencePage.addfilterbutton.tooltip")); //$NON-NLS-1$
>+		gd= new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_BEGINNING);
>+		fAddFilterButton.setLayoutData(gd);
>+		SWTUtil.setButtonDimensionHint(fAddFilterButton);
>+		fAddFilterButton.addListener(SWT.Selection, new Listener() {
>+			public void handleEvent(Event e) {
>+				editFilter();
>+			}
>+		});
>+
>+		fAddTypeButton= new Button(buttonContainer, SWT.PUSH);
>+		fAddTypeButton.setText(JUnitMessages.getString("JUnitPreferencePage.addtypebutton.label")); //$NON-NLS-1$
>+		fAddTypeButton.setToolTipText(JUnitMessages.getString("JUnitPreferencePage.addtypebutton.tooltip")); //$NON-NLS-1$
>+		gd= getButtonGridData(fAddTypeButton);
>+		fAddTypeButton.setLayoutData(gd);
>+		SWTUtil.setButtonDimensionHint(fAddTypeButton);
>+		fAddTypeButton.addListener(SWT.Selection, new Listener() {
>+			public void handleEvent(Event e) {
>+				addType();
>+			}
>+		});
>+
>+		fAddPackageButton= new Button(buttonContainer, SWT.PUSH);
>+		fAddPackageButton.setText(JUnitMessages.getString("JUnitPreferencePage.addpackagebutton.label")); //$NON-NLS-1$
>+		fAddPackageButton.setToolTipText(JUnitMessages.getString("JUnitPreferencePage.addpackagebutton.tooltip")); //$NON-NLS-1$
>+		gd= getButtonGridData(fAddPackageButton);
>+		fAddPackageButton.setLayoutData(gd);
>+		SWTUtil.setButtonDimensionHint(fAddPackageButton);
>+		fAddPackageButton.addListener(SWT.Selection, new Listener() {
>+			public void handleEvent(Event e) {
>+				addPackage();
>+			}
>+		});
>+
>+		fRemoveFilterButton= new Button(buttonContainer, SWT.PUSH);
>+		fRemoveFilterButton.setText(JUnitMessages.getString("JUnitPreferencePage.removefilterbutton.label")); //$NON-NLS-1$
>+		fRemoveFilterButton.setToolTipText(JUnitMessages.getString("JUnitPreferencePage.removefilterbutton.tooltip")); //$NON-NLS-1$
>+		gd= getButtonGridData(fRemoveFilterButton);
>+		fRemoveFilterButton.setLayoutData(gd);
>+		SWTUtil.setButtonDimensionHint(fRemoveFilterButton);
>+		fRemoveFilterButton.addListener(SWT.Selection, new Listener() {
>+			public void handleEvent(Event e) {
>+				removeFilters();
>+			}
>+		});
>+		fRemoveFilterButton.setEnabled(false);
>+
>+		fEnableAllButton= new Button(buttonContainer, SWT.PUSH);
>+		fEnableAllButton.setText(JUnitMessages.getString("JUnitPreferencePage.enableallbutton.label")); //$NON-NLS-1$
>+		fEnableAllButton.setToolTipText(JUnitMessages.getString("JUnitPreferencePage.enableallbutton.tooltip")); //$NON-NLS-1$
>+		gd= getButtonGridData(fEnableAllButton);
>+		fEnableAllButton.setLayoutData(gd);
>+		SWTUtil.setButtonDimensionHint(fEnableAllButton);
>+		fEnableAllButton.addListener(SWT.Selection, new Listener() {
>+			public void handleEvent(Event e) {
>+				checkAllFilters(true);
>+			}
>+		});
>+
>+		fDisableAllButton= new Button(buttonContainer, SWT.PUSH);
>+		fDisableAllButton.setText(JUnitMessages.getString("JUnitPreferencePage.disableallbutton.label")); //$NON-NLS-1$
>+		fDisableAllButton.setToolTipText(JUnitMessages.getString("JUnitPreferencePage.disableallbutton.tooltip")); //$NON-NLS-1$
>+		gd= getButtonGridData(fDisableAllButton);
>+		fDisableAllButton.setLayoutData(gd);
>+		SWTUtil.setButtonDimensionHint(fDisableAllButton);
>+		fDisableAllButton.addListener(SWT.Selection, new Listener() {
>+			public void handleEvent(Event e) {
>+				checkAllFilters(false);
>+			}
>+		});
>+
> 	}
>-	
>-	private void setButtonGridData(Button button) {
>-		GridData data = new GridData();
>-		data.horizontalAlignment = GridData.FILL;
>-		data.grabExcessHorizontalSpace = true;
>-		data.heightHint= convertVerticalDLUsToPixels(IDialogConstants.BUTTON_HEIGHT);
>+
>+	private GridData getButtonGridData(Button button) {
>+		GridData gd= new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_BEGINNING);
> 		int widthHint= convertHorizontalDLUsToPixels(IDialogConstants.BUTTON_WIDTH);
>-		data.widthHint= Math.max(widthHint, button.computeSize(SWT.DEFAULT, SWT.DEFAULT, true).x);
>-		button.setLayoutData(data);
>+		gd.widthHint= Math.max(widthHint, button.computeSize(SWT.DEFAULT, SWT.DEFAULT, true).x);
>+		gd.heightHint= convertVerticalDLUsToPixels(IDialogConstants.BUTTON_HEIGHT);
>+		return gd;
> 	}
> 
>-	protected void createFilterTable(Composite composite) {
>-		Label label= new Label(composite, SWT.NONE);
>-		label.setText(JUnitMessages.getString("JUnitPreferencePage.filter.label")); //$NON-NLS-1$
>-		GridData gridData= new GridData();
>-		gridData.horizontalAlignment= GridData.FILL;
>-		gridData.horizontalSpan= 2;
>-		label.setLayoutData(gridData);
>-		
>-		fTable= new Table(composite, SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
>-		GridData data= new GridData();
>-		//Set heightHint with a small value so the list size will be defined by 
>-		//the space available in the dialog instead of resizing the dialog to
>-		//fit all the items in the list.
>-		data.heightHint= fTable.getItemHeight();
>-		data.verticalAlignment= GridData.FILL;
>-		data.horizontalAlignment= GridData.FILL;
>-		data.grabExcessHorizontalSpace= true;
>-		data.grabExcessVerticalSpace= true;
>+	public void init(IWorkbench workbench) {}
>+	
>+	/**
>+	 * Create a new filter in the table (with the default 'new filter' value),
>+	 * then open up an in-place editor on it.
>+	 */
>+	private void editFilter() {
>+		// if a previous edit is still in progress, finish it
>+		if (fEditorText != null)
>+			validateChangeAndCleanup();
>+
>+		fNewStackFilter= fStackFilterContentProvider.addFilter(DEFAULT_NEW_FILTER_TEXT, true);
>+		fNewTableItem= fFilterTable.getItem(0);
>+
>+		// create & configure Text widget for editor
>+		// Fix for bug 1766.  Border behavior on for text fields varies per platform.
>+		// On Motif, you always get a border, on other platforms,
>+		// you don't.  Specifying a border on Motif results in the characters
>+		// getting pushed down so that only there very tops are visible.  Thus,
>+		// we have to specify different style constants for the different platforms.
>+		int textStyles= SWT.SINGLE | SWT.LEFT;
>+		if (!SWT.getPlatform().equals("motif")) //$NON-NLS-1$
>+			textStyles |= SWT.BORDER;
>+
>+		fEditorText= new Text(fFilterTable, textStyles);
>+		GridData gd= new GridData(GridData.FILL_BOTH);
>+		fEditorText.setLayoutData(gd);
>+
>+		// set the editor
>+		fTableEditor.horizontalAlignment= SWT.LEFT;
>+		fTableEditor.grabHorizontal= true;
>+		fTableEditor.setEditor(fEditorText, fNewTableItem, 0);
>+
>+		// get the editor ready to use
>+		fEditorText.setText(fNewStackFilter.getName());
>+		fEditorText.selectAll();
>+		setEditorListeners(fEditorText);
>+		fEditorText.setFocus();
>+	}
>+
>+	private void setEditorListeners(Text text) {
>+		// CR means commit the changes, ESC means abort and don't commit
>+		text.addKeyListener(new KeyAdapter() {
>+			public void keyReleased(KeyEvent event) {
>+				if (event.character == SWT.CR) {
>+					if (fInvalidEditorText != null) {
>+						fEditorText.setText(fInvalidEditorText);
>+						fInvalidEditorText= null;
>+					} else
>+						validateChangeAndCleanup();
>+				} else if (event.character == SWT.ESC) {
>+					removeNewFilter();
>+					cleanupEditor();
>+				}
>+			}
>+		});
>+		// Consider loss of focus on the editor to mean the same as CR
>+		text.addFocusListener(new FocusAdapter() {
>+			public void focusLost(FocusEvent event) {
>+				if (fInvalidEditorText != null) {
>+					fEditorText.setText(fInvalidEditorText);
>+					fInvalidEditorText= null;
>+				} else
>+					validateChangeAndCleanup();
>+			}
>+		});
>+		// Consume traversal events from the text widget so that CR doesn't 
>+		// traverse away to dialog's default button.  Without this, hitting
>+		// CR in the text field closes the entire dialog.
>+		text.addListener(SWT.Traverse, new Listener() {
>+			public void handleEvent(Event event) {
>+				event.doit= false;
>+			}
>+		});
>+	}
> 
>-		fTable.setLayoutData(data);
>-		fTable.addSelectionListener(this);
>-		fillList();
>-		if (fTable.getItemCount() > 0)
>-			fTable.setSelection(0);
>+	private void validateChangeAndCleanup() {
>+		String trimmedValue= fEditorText.getText().trim();
>+		// if the new value is blank, remove the filter
>+		if (trimmedValue.length() < 1)
>+			removeNewFilter();
>+
>+		// if it's invalid, beep and leave sitting in the editor
>+		else if (!validateEditorInput(trimmedValue)) {
>+			fInvalidEditorText= trimmedValue;
>+			fEditorText.setText(JUnitMessages.getString("JUnitPreferencePage.invalidstepfilterreturnescape")); //$NON-NLS-1$
>+			getShell().getDisplay().beep();
>+			return;
>+			// otherwise, commit the new value if not a duplicate
>+		} else {
>+			Object[] filters= fStackFilterContentProvider.getElements(null);
>+			for (int i= 0; i < filters.length; i++) {
>+				Filter filter= (Filter) filters[i];
>+				if (filter.getName().equals(trimmedValue)) {
>+					removeNewFilter();
>+					cleanupEditor();
>+					return;
>+				}
>+			}
>+			fNewTableItem.setText(trimmedValue);
>+			fNewStackFilter.setName(trimmedValue);
>+			fFilterViewer.refresh();
>+		}
>+		cleanupEditor();
> 	}
>-	
>-	/*
>-	 * @see IWorkbenchPreferencePage#init(IWorkbench)
>+
>+	/**
>+	 * Cleanup all widgetry & resources used by the in-place editing
> 	 */
>-	public void init(IWorkbench workbench) {
>+	private void cleanupEditor() {
>+		if (fEditorText == null)
>+			return;
>+
>+		fNewStackFilter= null;
>+		fNewTableItem= null;
>+		fTableEditor.setEditor(null, null, 0);
>+		fEditorText.dispose();
>+		fEditorText= null;
> 	}
>-	
>-	/*
>-	 * @see SelectionListener#widgetDefaultSelected(SelectionEvent)
>+
>+	private void removeNewFilter() {
>+		fStackFilterContentProvider.removeFilters(new Object[] { fNewStackFilter });
>+	}
>+
>+	/**
>+	 * A valid step filter is simply one that is a valid Java identifier.
>+	 * and, as defined in the JDI spec, the regular expressions used for
>+	 * step filtering must be limited to exact matches or patterns that
>+	 * begin with '*' or end with '*'. Beyond this, a string cannot be validated
>+	 * as corresponding to an existing type or package (and this is probably not
>+	 * even desirable).  
> 	 */
>-	public void widgetDefaultSelected(SelectionEvent selectionEvent) {
>-		widgetSelected(selectionEvent);
>+	private boolean validateEditorInput(String trimmedValue) {
>+		char firstChar= trimmedValue.charAt(0);
>+		if ((!(Character.isJavaIdentifierStart(firstChar)) || (firstChar == '*')))
>+			return false;
>+
>+		int length= trimmedValue.length();
>+		for (int i= 1; i < length; i++) {
>+			char c= trimmedValue.charAt(i);
>+			if (!Character.isJavaIdentifierPart(c)) {
>+				if (c == '.' && i != (length - 1))
>+					continue;
>+				if (c == '*' && i == (length - 1))
>+					continue;
>+
>+				return false;
>+			}
>+		}
>+		return true;
> 	}
> 
>+	private void addType() {
>+		Shell shell= getShell();
>+		SelectionDialog dialog= null;
>+		try {
>+			dialog=
>+				JavaUI.createTypeDialog(
>+					shell,
>+					new ProgressMonitorDialog(shell),
>+					SearchEngine.createWorkspaceScope(),
>+					IJavaElementSearchConstants.CONSIDER_CLASSES,
>+					false);
>+		} catch (JavaModelException jme) {
>+			String title= JUnitMessages.getString("JUnitPreferencePage.addtypedialog.title"); //$NON-NLS-1$
>+			String message= JUnitMessages.getString("JUnitPreferencePage.addtypedialog.error.message"); //$NON-NLS-1$
>+			ExceptionHandler.handle(jme, shell, title, message);
>+			return;
>+		}
> 
>-	protected void addFilterString(String filterEntry) {
>-		if (filterEntry != null) {
>-			TableItem tableItem= new TableItem(fTable, SWT.NONE);
>-			tableItem.setText(filterEntry);
>+		dialog.setTitle(JUnitMessages.getString("JUnitPreferencePage.addtypedialog.title")); //$NON-NLS-1$
>+		dialog.setMessage(JUnitMessages.getString("JUnitPreferencePage.addtypedialog.message")); //$NON-NLS-1$
>+		if (dialog.open() == IDialogConstants.CANCEL_ID)
>+			return;
>+
>+		Object[] types= dialog.getResult();
>+		if (types != null && types.length > 0) {
>+			IType type= (IType) types[0];
>+			fStackFilterContentProvider.addFilter(type.getFullyQualifiedName(), true);
> 		}
> 	}
>-			
>-	/*
>-	 * @see SelectionListener#widgetSelected(SelectionEvent)
>-	 */
>-	public void widgetSelected(SelectionEvent selectionEvent) {
>-		if (selectionEvent.getSource().equals(fAddButton)) {
>-			FilterPatternsDialog dialog= new FilterPatternsDialog(getControl().getShell(), JUnitMessages.getString("JUnitPreferencePage.adddialog.title"), JUnitMessages.getString("JUnitPreferencePage.addialog.prompt")); //$NON-NLS-1$ //$NON-NLS-2$
>-			dialog.open();
>-			String pattern= dialog.getValue();
>-			addFilterString(pattern);
>-			fTable.deselectAll();
>-			fTable.select(fTable.getItemCount()-1);
>+
>+	private void addPackage() {
>+		Shell shell= getShell();
>+		ElementListSelectionDialog dialog= null;
>+		try {
>+			dialog= JUnitPlugin.createAllPackagesDialog(shell, null, true);
>+		} catch (JavaModelException jme) {
>+			String title= JUnitMessages.getString("JUnitPreferencePage.addpackagedialog.title"); //$NON-NLS-1$
>+			String message= JUnitMessages.getString("JUnitPreferencePage.addpackagedialog.error.message"); //$NON-NLS-1$
>+			ExceptionHandler.handle(jme, shell, title, message);
>+			return;
>+		}
>+
>+		dialog.setTitle(JUnitMessages.getString("JUnitPreferencePage.addpackagedialog.title")); //$NON-NLS-1$
>+		dialog.setMessage(JUnitMessages.getString("JUnitPreferencePage.addpackagedialog.message")); //$NON-NLS-1$
>+		dialog.setMultipleSelection(true);
>+		if (dialog.open() == IDialogConstants.CANCEL_ID)
>+			return;
>+
>+		Object[] packages= dialog.getResult();
>+		if (packages == null)
>+			return;
>+
>+		for (int i= 0; i < packages.length; i++) {
>+			IJavaElement pkg= (IJavaElement) packages[i];
>+
>+			String filter= pkg.getElementName();
>+			if (filter.length() < 1)
>+				filter= JUnitMessages.getString("JUnitMainTab.label.defaultpackage"); //$NON-NLS-1$
>+			else
>+				filter += ".*"; //$NON-NLS-1$
>+
>+			fStackFilterContentProvider.addFilter(filter, true);
> 		}
>-		else if (selectionEvent.getSource().equals(fRemoveButton)) {
>-			fTable.remove(fTable.getSelectionIndices());
>-		}	
>-	    fRemoveButton.setEnabled(fTable.getSelectionIndex() != -1);
>+	}
>+	private void removeFilters() {
>+		IStructuredSelection selection= (IStructuredSelection) fFilterViewer.getSelection();
>+		fStackFilterContentProvider.removeFilters(selection.toArray());
>+	}
>+
>+	private void checkAllFilters(boolean check) {
>+		Object[] filters= fStackFilterContentProvider.getElements(null);
>+		for (int i= (filters.length - 1); i >= 0; --i)
>+			 ((Filter) filters[i]).setChecked(check);
>+
>+		fFilterViewer.setAllChecked(check);
> 	}
> 	
> 	public boolean performOk() {
> 		IPreferenceStore store= getPreferenceStore();
>-		int filterEntriesCount= fTable.getItemCount();
>-		
>-		store.setValue(STACK_FILTER_ENTRIES_COUNT, filterEntriesCount);
>-		for (int i= 0; i < filterEntriesCount; i++) {
>-			store.setValue(STACK_FILTER_ENTRY_ + i, fTable.getItem(i).getText());
>+		store.setValue(IJUnitPreferencesConstants.SHOW_ON_ERROR_ONLY, fShowOnErrorCheck.getSelection());
>+		fStackFilterContentProvider.saveFilters();
>+		return true;
>+	}
>+
>+	protected void performDefaults() {
>+		setDefaultValues();
>+		super.performDefaults();
>+	}
>+
>+	private void setDefaultValues() {
>+		fStackFilterContentProvider.setDefaults();
>+	}
>+
>+	/**
>+	 * Returns the default list of active stack filters.
>+	 * 
>+	 * @return list
>+	 */
>+	protected List createDefaultStackFiltersList() {
>+		return Arrays.asList(fgDefaultFilterPatterns);
>+	}
>+
>+	/**
>+	 * Returns a list of active stack filters.
>+	 * 
>+	 * @return list
>+	 */
>+	protected List createActiveStackFiltersList() {
>+		return Arrays.asList(getFilterPatterns());
>+	}
>+
>+	/**
>+	 * Returns a list of active stack filters.
>+	 * 
>+	 * @return list
>+	 */
>+	protected List createInactiveStackFiltersList() {
>+		String[] strings=
>+			JUnitPreferencePage.parseList(getPreferenceStore().getString(IJUnitPreferencesConstants.PREF_INACTIVE_FILTERS_LIST));
>+		return Arrays.asList(strings);
>+	}
>+
>+	protected void updateActions() {
>+		if (fEnableAllButton == null)
>+			return;
>+
>+		boolean enabled= fFilterViewer.getTable().getItemCount() > 0;
>+		fEnableAllButton.setEnabled(enabled);
>+		fDisableAllButton.setEnabled(enabled);
>+	}
>+
>+	public static String[] getFilterPatterns() {
>+		IPreferenceStore store= JUnitPlugin.getDefault().getPreferenceStore();
>+		return JUnitPreferencePage.parseList(store.getString(IJUnitPreferencesConstants.PREF_ACTIVE_FILTERS_LIST));
>+	}
>+
>+	public static boolean getFilterStack() {
>+		IPreferenceStore store= JUnitPlugin.getDefault().getPreferenceStore();
>+		return store.getBoolean(IJUnitPreferencesConstants.DO_FILTER_STACK);
>+	}
>+
>+	public static void setFilterStack(boolean filter) {
>+		IPreferenceStore store= JUnitPlugin.getDefault().getPreferenceStore();
>+		store.setValue(IJUnitPreferencesConstants.DO_FILTER_STACK, filter);
>+	}
>+
>+	public static void initializeDefaults(IPreferenceStore store) {
>+		store.setDefault(IJUnitPreferencesConstants.DO_FILTER_STACK, true);
>+		store.setDefault(IJUnitPreferencesConstants.SHOW_ON_ERROR_ONLY, false);
>+
>+		String list= store.getString(IJUnitPreferencesConstants.PREF_ACTIVE_FILTERS_LIST);
>+
>+		if ("".equals(list)) { //$NON-NLS-1$
>+			String pref= JUnitPreferencePage.serializeList(fgDefaultFilterPatterns);
>+			store.setValue(IJUnitPreferencesConstants.PREF_ACTIVE_FILTERS_LIST, pref);
> 		}
>-		store.setValue(SHOW_ON_ERROR_ONLY, fShowOnErrorCheck.getSelection());
>-		return true;			
>+
>+		store.setValue(IJUnitPreferencesConstants.PREF_INACTIVE_FILTERS_LIST, ""); //$NON-NLS-1$
>+	}
>+
>+	public static boolean getShowOnErrorOnly() {
>+		IPreferenceStore store= JUnitPlugin.getDefault().getPreferenceStore();
>+		return store.getBoolean(IJUnitPreferencesConstants.SHOW_ON_ERROR_ONLY);
> 	}
> 	
>-	private void fillList() {
>-		String[] patterns= getFilterPatterns();		
>-		for (int i= 0; i < patterns.length; i++) {
>-			TableItem tableItem= new TableItem(fTable, SWT.NONE);
>-			tableItem.setText(patterns[i]);
>+	/**
>+	 * Parses the comma separated string into an array of strings
>+	 * 
>+	 * @return list
>+	 */
>+	private static String[] parseList(String listString) {
>+		List list= new ArrayList(10);
>+		StringTokenizer tokenizer= new StringTokenizer(listString, ","); //$NON-NLS-1$
>+		while (tokenizer.hasMoreTokens())
>+			list.add(tokenizer.nextToken());
>+		return (String[]) list.toArray(new String[list.size()]);
>+	}
>+
>+	/**
>+	 * Serializes the array of strings into one comma
>+	 * separated string.
>+	 * 
>+	 * @param list array of strings
>+	 * @return a single string composed of the given list
>+	 */
>+	private static String serializeList(String[] list) {
>+		if (list == null)
>+			return ""; //$NON-NLS-1$
>+
>+		StringBuffer buffer= new StringBuffer();
>+		for (int i= 0; i < list.length; i++) {
>+			if (i > 0)
>+				buffer.append(',');
>+
>+			buffer.append(list[i]);
> 		}
>+		return buffer.toString();
> 	}
> }
>Index: TestRunnerViewPart.java
>===================================================================
>RCS file: /home/eclipse/org.eclipse.jdt.junit/src/org/eclipse/jdt/internal/junit/ui/TestRunnerViewPart.java,v
>retrieving revision 1.20
>diff -u -r1.20 TestRunnerViewPart.java
>--- TestRunnerViewPart.java	8 Oct 2002 12:41:29 -0000	1.20
>+++ TestRunnerViewPart.java	8 Dec 2002 15:05:29 -0000
>@@ -851,7 +851,7 @@
> 		if (isDisposed())
> 			return;
> 
>-		if (JUnitPreferencePage.SHOW_ON_ERROR_ONLY.equals(event.getProperty())) {
>+		if (IJUnitPreferencesConstants.SHOW_ON_ERROR_ONLY.equals(event.getProperty())) {
> 			if (!JUnitPreferencePage.getShowOnErrorOnly()) {
> 				fViewImage= fOriginalViewImage;
> 				firePropertyChange(IWorkbenchPart.PROP_TITLE);

Actions: View | Diff

Attachments on bug 9525: 2706 | 2707