for (int i= 0; i < patterns.length; i++) {

		String pattern;

			if (line.indexOf(patterns[i]) > 0)

		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)

JUnitPreferencePage.addbutton.label=&Add...

JUnitPreferencePage.addfilterbutton.label=Add &Filter

JUnitPreferencePage.removebutton.label=&Remove

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

	/**

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

	}

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.events.*;

import org.eclipse.swt.custom.TableEditor;

import org.eclipse.swt.layout.*;

import org.eclipse.swt.events.FocusAdapter;

import org.eclipse.swt.widgets.*;

import org.eclipse.swt.events.FocusEvent;

import org.eclipse.ui.*;

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;

public class JUnitPreferencePage extends PreferencePage 

public class JUnitPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {

		implements IWorkbenchPreferencePage, SelectionListener {

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

	private String fFilterString;

	private static final Image IMG_CUNIT= JavaUI.getSharedImages().getImage(ISharedImages.IMG_OBJS_CLASS);

	private Table fTable;

	private static final Image IMG_PKG= JavaUI.getSharedImages().getImage(ISharedImages.IMG_OBJS_PACKAGE);

	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$

	private static String[] fgDefaultFilterPatterns= new String[] {

	private static String[] fgDefaultFilterPatterns= new String[] { "org.eclipse.jdt.internal.junit.runner.*", //$NON-NLS-1$

		"org.eclipse.jdt.internal.junit.runner", //$NON-NLS-1$

		"org.eclipse.jdt.internal.junit.ui.*", //$NON-NLS-1$

		"org.eclipse.jdt.internal.junit.ui", //$NON-NLS-1$

		"junit.framework.Assert.", // don't filter AssertionFailure //$NON-NLS-1$

		"junit.framework.Assert", //$NON-NLS-1$

	public JUnitPreferencePage() {

	// Step filter widgets

		super();

	private CheckboxTableViewer fFilterViewer;

		setPreferenceStore(JUnitPlugin.getDefault().getPreferenceStore());

	private Table fFilterTable;

	}

	public static String[] getFilterPatterns() {

	private Button fShowOnErrorCheck;

		IPreferenceStore store= JUnitPlugin.getDefault().getPreferenceStore();

	private Button fAddPackageButton;

		int count= store.getInt(STACK_FILTER_ENTRIES_COUNT);

	private Button fAddTypeButton;

		String[] result= new String[count];

	private Button fRemoveFilterButton;

		for (int i= 0; i < count; i++) {

	private Button fAddFilterButton;

			result[i]= store.getString(STACK_FILTER_ENTRY_ + i);

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

	public static void setFilterStack(boolean filter) {

	/**

		IPreferenceStore store= JUnitPlugin.getDefault().getPreferenceStore();

	 * Sorter for the filter table; sorts alphabetically ascending.

		store.setValue(DO_FILTER_STACK, filter);

	 */

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

	 * Label provider for Filter model objects

		store.setDefault(JUnitPreferencePage.SHOW_ON_ERROR_ONLY, false); 

	 */

		int count= store.getInt(STACK_FILTER_ENTRIES_COUNT);

	private class FilterLabelProvider extends LabelProvider implements ITableLabelProvider {

		if (count == 0) {

			store.setValue(STACK_FILTER_ENTRIES_COUNT, fgDefaultFilterPatterns.length);

		public String getColumnText(Object object, int column) {

			for (int i= 0; i < fgDefaultFilterPatterns.length; i++) {

			return (column == 0) ? ((Filter) object).getName() : ""; //$NON-NLS-1$

				store.setValue(STACK_FILTER_ENTRY_ + i, fgDefaultFilterPatterns[i]);

		}

		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;

	/*

	/**

	 * @see PreferencePage#createContents(Composite)

	 * Content provider for the filter table.  Content consists of instances of

	 * Filter.

	protected Control createContents(Composite parent) {

	private class StackFilterContentProvider implements IStructuredContentProvider {

		noDefaultAndApplyButton();

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

		}

		layout.numColumns= 2;

		layout.numColumns= 1;

		layout.marginWidth= 0;

		createShowCheck(composite);

		createStackFilterPreferences(composite);

		createFilterTable(composite);

		createListButtons(composite);

		WorkbenchHelp.setHelp(composite, IJUnitHelpContextIds.JUNIT_PREFERENCE_PAGE);

		fShowOnErrorCheck.setLayoutData(data);		

		fShowOnErrorCheck.setLayoutData(data);

	/**

	private void createFilterTable(Composite container) {

	 * @return boolean

		fTableLabel= new Label(container, SWT.NONE);

	 */

		fTableLabel.setText(JUnitMessages.getString("JUnitPreferencePage.filter.label")); //$NON-NLS-1$

	public static boolean getShowOnErrorOnly() {

		GridData gd= new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);

		IPreferenceStore store= JUnitPlugin.getDefault().getPreferenceStore();

		gd.horizontalSpan= 2;

		return store.getBoolean(SHOW_ON_ERROR_ONLY);

		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) {

	private void createStepFilterButtons(Composite container) {

		Composite buttonComposite= new Composite(composite, SWT.NONE);

		Composite buttonContainer= new Composite(container, SWT.NONE);

		GridLayout layout= new GridLayout();

		GridData gd= new GridData(GridData.FILL_VERTICAL);

		layout.marginHeight= 0;

		buttonContainer.setLayoutData(gd);

		buttonComposite.setLayout(layout);	

		GridLayout buttonLayout= new GridLayout();

		GridData gridData= new GridData();

		buttonLayout.numColumns= 1;

		gridData.verticalAlignment= GridData.FILL;

		buttonLayout.marginHeight= 0;

		gridData.horizontalAlignment= GridData.FILL;

		buttonLayout.marginWidth= 0;

		buttonComposite.setLayoutData(gridData);

		buttonContainer.setLayout(buttonLayout);

		fAddButton= new Button(buttonComposite, SWT.CENTER | SWT.PUSH);

		fAddFilterButton= new Button(buttonContainer, SWT.PUSH);

		fAddButton.setText(JUnitMessages.getString("JUnitPreferencePage.addbutton.label")); //$NON-NLS-1$

		fAddFilterButton.setText(JUnitMessages.getString("JUnitPreferencePage.addfilterbutton.label")); //$NON-NLS-1$

		setButtonGridData(fAddButton);

		fAddFilterButton.setToolTipText(JUnitMessages.getString("JUnitPreferencePage.addfilterbutton.tooltip")); //$NON-NLS-1$

		fAddButton.addSelectionListener(this);

		gd= new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_BEGINNING);

		fAddFilterButton.setLayoutData(gd);

		fRemoveButton= new Button(buttonComposite, SWT.CENTER | SWT.PUSH);

		SWTUtil.setButtonDimensionHint(fAddFilterButton);

		fRemoveButton.setText(JUnitMessages.getString("JUnitPreferencePage.removebutton.label")); //$NON-NLS-1$

		fAddFilterButton.addListener(SWT.Selection, new Listener() {

		setButtonGridData(fRemoveButton);

			public void handleEvent(Event e) {

		fRemoveButton.addSelectionListener(this);

				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) {

	private GridData getButtonGridData(Button button) {

		GridData data = new GridData();

		GridData gd= new GridData(GridData.FILL_HORIZONTAL | GridData.VERTICAL_ALIGN_BEGINNING);

		data.horizontalAlignment = GridData.FILL;

		data.grabExcessHorizontalSpace = true;

		data.heightHint= convertVerticalDLUsToPixels(IDialogConstants.BUTTON_HEIGHT);

		data.widthHint= Math.max(widthHint, button.computeSize(SWT.DEFAULT, SWT.DEFAULT, true).x);

		gd.widthHint= Math.max(widthHint, button.computeSize(SWT.DEFAULT, SWT.DEFAULT, true).x);

		button.setLayoutData(data);

		gd.heightHint= convertVerticalDLUsToPixels(IDialogConstants.BUTTON_HEIGHT);

		return gd;

	protected void createFilterTable(Composite composite) {

	public void init(IWorkbench workbench) {}

		Label label= new Label(composite, SWT.NONE);

		label.setText(JUnitMessages.getString("JUnitPreferencePage.filter.label")); //$NON-NLS-1$

	/**

		GridData gridData= new GridData();

	 * Create a new filter in the table (with the default 'new filter' value),

		gridData.horizontalAlignment= GridData.FILL;

	 * then open up an in-place editor on it.

		gridData.horizontalSpan= 2;

	 */

		label.setLayoutData(gridData);

	private void editFilter() {

		// if a previous edit is still in progress, finish it

		fTable= new Table(composite, SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);

		if (fEditorText != null)

		GridData data= new GridData();

			validateChangeAndCleanup();

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

		fNewStackFilter= fStackFilterContentProvider.addFilter(DEFAULT_NEW_FILTER_TEXT, true);

		//fit all the items in the list.

		fNewTableItem= fFilterTable.getItem(0);

		data.heightHint= fTable.getItemHeight();

		data.verticalAlignment= GridData.FILL;

		// create & configure Text widget for editor

		data.horizontalAlignment= GridData.FILL;

		// Fix for bug 1766.  Border behavior on for text fields varies per platform.

		data.grabExcessHorizontalSpace= true;

		// On Motif, you always get a border, on other platforms,

		data.grabExcessVerticalSpace= true;

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

	private void validateChangeAndCleanup() {

		fTable.addSelectionListener(this);

		String trimmedValue= fEditorText.getText().trim();

		fillList();

		// if the new value is blank, remove the filter

		if (fTable.getItemCount() > 0)

		if (trimmedValue.length() < 1)

			fTable.setSelection(0);

			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;

	/*

	private void removeNewFilter() {

	 * @see SelectionListener#widgetDefaultSelected(SelectionEvent)

		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) {

	private boolean validateEditorInput(String trimmedValue) {

		widgetSelected(selectionEvent);

		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;

	protected void addFilterString(String filterEntry) {

		dialog.setTitle(JUnitMessages.getString("JUnitPreferencePage.addtypedialog.title")); //$NON-NLS-1$

		if (filterEntry != null) {

		dialog.setMessage(JUnitMessages.getString("JUnitPreferencePage.addtypedialog.message")); //$NON-NLS-1$

			TableItem tableItem= new TableItem(fTable, SWT.NONE);

		if (dialog.open() == IDialogConstants.CANCEL_ID)

			tableItem.setText(filterEntry);

			return;

		Object[] types= dialog.getResult();

		if (types != null && types.length > 0) {

			IType type= (IType) types[0];

			fStackFilterContentProvider.addFilter(type.getFullyQualifiedName(), true);

	/*

	private void addPackage() {

	 * @see SelectionListener#widgetSelected(SelectionEvent)

		Shell shell= getShell();

	 */

		ElementListSelectionDialog dialog= null;

	public void widgetSelected(SelectionEvent selectionEvent) {

		try {

		if (selectionEvent.getSource().equals(fAddButton)) {

			dialog= JUnitPlugin.createAllPackagesDialog(shell, null, true);

			FilterPatternsDialog dialog= new FilterPatternsDialog(getControl().getShell(), JUnitMessages.getString("JUnitPreferencePage.adddialog.title"), JUnitMessages.getString("JUnitPreferencePage.addialog.prompt")); //$NON-NLS-1$ //$NON-NLS-2$

		} catch (JavaModelException jme) {

			dialog.open();

			String title= JUnitMessages.getString("JUnitPreferencePage.addpackagedialog.title"); //$NON-NLS-1$

			String pattern= dialog.getValue();

			String message= JUnitMessages.getString("JUnitPreferencePage.addpackagedialog.error.message"); //$NON-NLS-1$

			addFilterString(pattern);

			ExceptionHandler.handle(jme, shell, title, message);

			fTable.deselectAll();

			return;

			fTable.select(fTable.getItemCount()-1);

		}

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

	private void removeFilters() {

		}	

		IStructuredSelection selection= (IStructuredSelection) fFilterViewer.getSelection();

	    fRemoveButton.setEnabled(fTable.getSelectionIndex() != -1);

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

		int filterEntriesCount= fTable.getItemCount();

		store.setValue(IJUnitPreferencesConstants.SHOW_ON_ERROR_ONLY, fShowOnErrorCheck.getSelection());

		fStackFilterContentProvider.saveFilters();

		store.setValue(STACK_FILTER_ENTRIES_COUNT, filterEntriesCount);

		return true;

		for (int i= 0; i < filterEntriesCount; i++) {

	}

			store.setValue(STACK_FILTER_ENTRY_ + i, fTable.getItem(i).getText());

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

	 * Parses the comma separated string into an array of strings

		for (int i= 0; i < patterns.length; i++) {

	 * 

			TableItem tableItem= new TableItem(fTable, SWT.NONE);

	 * @return list

			tableItem.setText(patterns[i]);

	 */

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

		if (JUnitPreferencePage.SHOW_ON_ERROR_ONLY.equals(event.getProperty())) {

		if (IJUnitPreferencesConstants.SHOW_ON_ERROR_ONLY.equals(event.getProperty())) {