KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > jdt > internal > debug > ui > JavaStepFilterPreferencePage


1 /*******************************************************************************
2  * Copyright (c) 2000, 2007 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Eclipse Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/epl-v10.html
7  *
8  * Contributors:
9  * IBM Corporation - initial API and implementation
10  *******************************************************************************/

11 package org.eclipse.jdt.internal.debug.ui;
12
13 import java.util.ArrayList JavaDoc;
14
15 import org.eclipse.debug.ui.DebugUITools;
16 import org.eclipse.jdt.core.IJavaElement;
17 import org.eclipse.jdt.core.IType;
18 import org.eclipse.jdt.core.JavaModelException;
19 import org.eclipse.jdt.core.search.SearchEngine;
20 import org.eclipse.jdt.ui.IJavaElementSearchConstants;
21 import org.eclipse.jdt.ui.JavaUI;
22 import org.eclipse.jface.dialogs.IDialogConstants;
23 import org.eclipse.jface.preference.IPreferenceStore;
24 import org.eclipse.jface.preference.PreferencePage;
25 import org.eclipse.jface.viewers.CheckStateChangedEvent;
26 import org.eclipse.jface.viewers.CheckboxTableViewer;
27 import org.eclipse.jface.viewers.ICheckStateListener;
28 import org.eclipse.jface.viewers.ISelection;
29 import org.eclipse.jface.viewers.ISelectionChangedListener;
30 import org.eclipse.jface.viewers.IStructuredContentProvider;
31 import org.eclipse.jface.viewers.IStructuredSelection;
32 import org.eclipse.jface.viewers.SelectionChangedEvent;
33 import org.eclipse.jface.viewers.Viewer;
34 import org.eclipse.swt.SWT;
35 import org.eclipse.swt.events.KeyAdapter;
36 import org.eclipse.swt.events.KeyEvent;
37 import org.eclipse.swt.events.SelectionEvent;
38 import org.eclipse.swt.events.SelectionListener;
39 import org.eclipse.swt.layout.GridData;
40 import org.eclipse.swt.layout.GridLayout;
41 import org.eclipse.swt.widgets.Button;
42 import org.eclipse.swt.widgets.Composite;
43 import org.eclipse.swt.widgets.Control;
44 import org.eclipse.swt.widgets.Event;
45 import org.eclipse.swt.widgets.Label;
46 import org.eclipse.swt.widgets.Listener;
47 import org.eclipse.swt.widgets.TableItem;
48 import org.eclipse.ui.IWorkbench;
49 import org.eclipse.ui.IWorkbenchPreferencePage;
50 import org.eclipse.ui.PlatformUI;
51 import org.eclipse.ui.dialogs.ElementListSelectionDialog;
52 import org.eclipse.ui.dialogs.SelectionDialog;
53
54 /**
55  * The preference page for Java step filtering, located at the node Java > Debug > Step Filtering
56  *
57  * @since 3.0
58  */

59 public class JavaStepFilterPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {
60     
61     public static final String JavaDoc PAGE_ID = "org.eclipse.jdt.debug.ui.JavaStepFilterPreferencePage"; //$NON-NLS-1$
62

63     /**
64      * Content provider for the table. Content consists of instances of StepFilter.
65      * @since 3.2
66      */

67     class StepFilterContentProvider implements IStructuredContentProvider {
68         public StepFilterContentProvider() {
69             initTableState(false);
70         }
71         
72         public Object JavaDoc[] getElements(Object JavaDoc inputElement) {return getAllFiltersFromTable();}
73
74         public void inputChanged(Viewer viewer, Object JavaDoc oldInput, Object JavaDoc newInput) {}
75
76         public void dispose() {}
77     }
78     
79     //widgets
80
private CheckboxTableViewer fTableViewer;
81     private Button fUseStepFiltersButton;
82     private Button fAddPackageButton;
83     private Button fAddTypeButton;
84     private Button fRemoveFilterButton;
85     private Button fAddFilterButton;
86     private Button fFilterSyntheticButton;
87     private Button fFilterStaticButton;
88     private Button fFilterConstructorButton;
89     private Button fStepThruButton;
90     private Button fSelectAllButton;
91     private Button fDeselectAllButton;
92     
93     /**
94      * Constructor
95      */

96     public JavaStepFilterPreferencePage() {
97         super();
98         setPreferenceStore(JDIDebugUIPlugin.getDefault().getPreferenceStore());
99         setTitle(DebugUIMessages.JavaStepFilterPreferencePage_title);
100         setDescription(DebugUIMessages.JavaStepFilterPreferencePage_description);
101     }
102
103     /* (non-Javadoc)
104      * @see org.eclipse.jface.preference.PreferencePage#createContents(org.eclipse.swt.widgets.Composite)
105      */

106     protected Control createContents(Composite parent) {
107         PlatformUI.getWorkbench().getHelpSystem().setHelp(getControl(), IJavaDebugHelpContextIds.JAVA_STEP_FILTER_PREFERENCE_PAGE);
108     //The main composite
109
Composite composite = SWTFactory.createComposite(parent, parent.getFont(), 1, 1, GridData.FILL_BOTH, 0, 0);
110         createStepFilterPreferences(composite);
111         return composite;
112     }
113
114     /* (non-Javadoc)
115      * @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)
116      */

117     public void init(IWorkbench workbench) {}
118     
119     /**
120      * handles the filter button being clicked
121      * @param event the clicked event
122      */

123     private void handleFilterViewerKeyPress(KeyEvent event) {
124         if (event.character == SWT.DEL && event.stateMask == 0) {
125             removeFilters();
126         }
127     }
128     
129     /**
130      * Create a group to contain the step filter related widgetry
131      */

132     private void createStepFilterPreferences(Composite parent) {
133         Composite container = SWTFactory.createComposite(parent, parent.getFont(), 2, 1, GridData.FILL_BOTH, 0, 0);
134         fUseStepFiltersButton = SWTFactory.createCheckButton(container, DebugUIMessages.JavaStepFilterPreferencePage__Use_step_filters, null, DebugUITools.isUseStepFilters(), 2);
135         fUseStepFiltersButton.addSelectionListener(new SelectionListener() {
136                 public void widgetSelected(SelectionEvent e) {
137                     setPageEnablement(fUseStepFiltersButton.getSelection());
138                 }
139                 public void widgetDefaultSelected(SelectionEvent e) {}
140             }
141         );
142         SWTFactory.createLabel(container, DebugUIMessages.JavaStepFilterPreferencePage_Defined_step_fi_lters__8, 2);
143         fTableViewer = CheckboxTableViewer.newCheckList(container, SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER | SWT.MULTI | SWT.FULL_SELECTION);
144         fTableViewer.getTable().setFont(container.getFont());
145         fTableViewer.setLabelProvider(new FilterLabelProvider());
146         fTableViewer.setComparator(new FilterViewerComparator());
147         fTableViewer.setContentProvider(new StepFilterContentProvider());
148         fTableViewer.setInput(getAllStoredFilters(false));
149         fTableViewer.getTable().setLayoutData(new GridData(GridData.FILL_BOTH));
150         fTableViewer.addCheckStateListener(new ICheckStateListener() {
151             public void checkStateChanged(CheckStateChangedEvent event) {
152                 ((Filter)event.getElement()).setChecked(event.getChecked());
153             }
154         });
155         fTableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
156             public void selectionChanged(SelectionChangedEvent event) {
157                 ISelection selection = event.getSelection();
158                 if (selection.isEmpty()) {
159                     fRemoveFilterButton.setEnabled(false);
160                 } else {
161                     fRemoveFilterButton.setEnabled(true);
162                 }
163             }
164         });
165         fTableViewer.getControl().addKeyListener(new KeyAdapter() {
166             public void keyPressed(KeyEvent event) {
167                 handleFilterViewerKeyPress(event);
168             }
169         });
170         
171         createStepFilterButtons(container);
172         createStepFilterCheckboxes(container);
173
174         setPageEnablement(fUseStepFiltersButton.getSelection());
175     }
176     
177     /**
178      * initializes the checked state of the filters when the dialog opens
179      * @since 3.2
180      */

181     private void initTableState(boolean defaults) {
182         Filter[] filters = getAllStoredFilters(defaults);
183         for(int i = 0; i < filters.length; i++) {
184             fTableViewer.add(filters[i]);
185             fTableViewer.setChecked(filters[i], filters[i].isChecked());
186         }
187     }
188     
189     /**
190      * Enables or disables the widgets on the page, with the
191      * exception of <code>fUseStepFiltersButton</code> according
192      * to the passed boolean
193      * @param enabled the new enablement status of the page's widgets
194      * @since 3.2
195      */

196     protected void setPageEnablement(boolean enabled) {
197         fAddFilterButton.setEnabled(enabled);
198         fAddPackageButton.setEnabled(enabled);
199         fAddTypeButton.setEnabled(enabled);
200         fDeselectAllButton.setEnabled(enabled);
201         fSelectAllButton.setEnabled(enabled);
202         fFilterConstructorButton.setEnabled(enabled);
203         fStepThruButton.setEnabled(enabled);
204         fFilterStaticButton.setEnabled(enabled);
205         fFilterSyntheticButton.setEnabled(enabled);
206         fTableViewer.getTable().setEnabled(enabled);
207         fRemoveFilterButton.setEnabled(enabled & !fTableViewer.getSelection().isEmpty());
208     }
209
210     /**
211      * create the checked preferences for the page
212      * @param container the parent container
213      */

214     private void createStepFilterCheckboxes(Composite container) {
215         fFilterSyntheticButton = SWTFactory.createCheckButton(container,
216                 DebugUIMessages.JavaStepFilterPreferencePage_Filter_s_ynthetic_methods__requires_VM_support__17,
217                 null, getPreferenceStore().getBoolean(IJDIPreferencesConstants.PREF_FILTER_SYNTHETICS), 2);
218         fFilterStaticButton = SWTFactory.createCheckButton(container,
219                 DebugUIMessages.JavaStepFilterPreferencePage_Filter_static__initializers_18,
220                 null, getPreferenceStore().getBoolean(IJDIPreferencesConstants.PREF_FILTER_STATIC_INITIALIZERS), 2);
221         fFilterConstructorButton = SWTFactory.createCheckButton(container,
222                 DebugUIMessages.JavaStepFilterPreferencePage_Filter_co_nstructors_19,
223                 null, getPreferenceStore().getBoolean(IJDIPreferencesConstants.PREF_FILTER_CONSTRUCTORS), 2);
224         fStepThruButton = SWTFactory.createCheckButton(container,
225                 DebugUIMessages.JavaStepFilterPreferencePage_0,
226                 null, getPreferenceStore().getBoolean(IJDIPreferencesConstants.PREF_STEP_THRU_FILTERS), 2);
227     }
228     
229     /**
230      * Creates the button for the step filter options
231      * @param container the parent container
232      */

233     private void createStepFilterButtons(Composite container) {
234         initializeDialogUnits(container);
235         // button container
236
Composite buttonContainer = new Composite(container, SWT.NONE);
237         GridData gd = new GridData(GridData.FILL_VERTICAL);
238         buttonContainer.setLayoutData(gd);
239         GridLayout buttonLayout = new GridLayout();
240         buttonLayout.numColumns = 1;
241         buttonLayout.marginHeight = 0;
242         buttonLayout.marginWidth = 0;
243         buttonContainer.setLayout(buttonLayout);
244     //Add filter button
245
fAddFilterButton = SWTFactory.createPushButton(buttonContainer,
246                 DebugUIMessages.JavaStepFilterPreferencePage_Add__Filter_9,
247                 DebugUIMessages.JavaStepFilterPreferencePage_Key_in_the_name_of_a_new_step_filter_10, null);
248         fAddFilterButton.addListener(SWT.Selection, new Listener() {
249             public void handleEvent(Event e) {
250                 addFilter();
251             }
252         });
253     //Add type button
254
fAddTypeButton = SWTFactory.createPushButton(buttonContainer,
255                 DebugUIMessages.JavaStepFilterPreferencePage_Add__Type____11,
256                 DebugUIMessages.JavaStepFilterPreferencePage_Choose_a_Java_type_and_add_it_to_step_filters_12, null);
257         fAddTypeButton.addListener(SWT.Selection, new Listener() {
258             public void handleEvent(Event e) {
259                 addType();
260             }
261         });
262     //Add package button
263
fAddPackageButton = SWTFactory.createPushButton(buttonContainer,
264                 DebugUIMessages.JavaStepFilterPreferencePage_Add__Package____13,
265                 DebugUIMessages.JavaStepFilterPreferencePage_Choose_a_package_and_add_it_to_step_filters_14, null);
266         fAddPackageButton.addListener(SWT.Selection, new Listener() {
267             public void handleEvent(Event e) {
268                 addPackage();
269             }
270         });
271     //Remove button
272
fRemoveFilterButton = SWTFactory.createPushButton(buttonContainer,
273                 DebugUIMessages.JavaStepFilterPreferencePage__Remove_15,
274                 DebugUIMessages.JavaStepFilterPreferencePage_Remove_all_selected_step_filters_16,
275                 null);
276         fRemoveFilterButton.addListener(SWT.Selection, new Listener() {
277             public void handleEvent(Event e) {
278                 removeFilters();
279             }
280         });
281         fRemoveFilterButton.setEnabled(false);
282         
283         Label separator= new Label(buttonContainer, SWT.NONE);
284         separator.setVisible(false);
285         gd = new GridData();
286         gd.horizontalAlignment= GridData.FILL;
287         gd.verticalAlignment= GridData.BEGINNING;
288         gd.heightHint= 4;
289         separator.setLayoutData(gd);
290     //Select All button
291
fSelectAllButton = SWTFactory.createPushButton(buttonContainer,
292                 DebugUIMessages.JavaStepFilterPreferencePage__Select_All_1,
293                 DebugUIMessages.JavaStepFilterPreferencePage_Selects_all_step_filters_2, null);
294         fSelectAllButton.addListener(SWT.Selection, new Listener() {
295             public void handleEvent(Event e) {
296                 fTableViewer.setAllChecked(true);
297             }
298         });
299     //De-Select All button
300
fDeselectAllButton = SWTFactory.createPushButton(buttonContainer,
301                 DebugUIMessages.JavaStepFilterPreferencePage_Deselect_All_3,
302                 DebugUIMessages.JavaStepFilterPreferencePage_Deselects_all_step_filters_4, null);
303         fDeselectAllButton.addListener(SWT.Selection, new Listener() {
304             public void handleEvent(Event e) {
305                 fTableViewer.setAllChecked(false);
306             }
307         });
308         
309     }
310         
311     /**
312      * Allows a new filter to be added to the listing
313      */

314     private void addFilter() {
315         Filter newfilter = CreateStepFilterDialog.showCreateStepFilterDialog(getShell(), getAllFiltersFromTable());
316         if (newfilter != null) {
317             fTableViewer.add(newfilter);
318             fTableViewer.setChecked(newfilter, true);
319             fTableViewer.refresh(newfilter);
320         }
321     }
322     
323     /**
324      * add a new type to the listing of available filters
325      */

326     private void addType() {
327         try {
328             SelectionDialog dialog = JavaUI.createTypeDialog(getShell(),
329                 PlatformUI.getWorkbench().getProgressService(),
330                 SearchEngine.createWorkspaceScope(),
331                 IJavaElementSearchConstants.CONSIDER_CLASSES,
332                 false);
333             dialog.setTitle(DebugUIMessages.JavaStepFilterPreferencePage_Add_type_to_step_filters_20);
334             dialog.setMessage(DebugUIMessages.JavaStepFilterPreferencePage_Select_a_type_to_filter_when_stepping_23);
335             if (dialog.open() == IDialogConstants.OK_ID) {
336                 Object JavaDoc[] types = dialog.getResult();
337                 if (types != null && types.length > 0) {
338                     IType type = (IType)types[0];
339                     addFilter(type.getFullyQualifiedName(), true);
340                 }
341             }
342         }
343         catch (JavaModelException jme) {
344             ExceptionHandler.handle(jme,
345                     DebugUIMessages.JavaStepFilterPreferencePage_Add_type_to_step_filters_20,
346                     DebugUIMessages.JavaStepFilterPreferencePage_Could_not_open_type_selection_dialog_for_step_filters_21);
347         }
348     }
349     
350     /**
351      * add a new package to the list of all available package filters
352      */

353     private void addPackage() {
354         try {
355             ElementListSelectionDialog dialog = JDIDebugUIPlugin.createAllPackagesDialog(getShell(), null, false);
356             dialog.setTitle(DebugUIMessages.JavaStepFilterPreferencePage_Add_package_to_step_filters_24);
357             dialog.setMessage(DebugUIMessages.JavaStepFilterPreferencePage_Select_a_package_to_filter_when_stepping_27);
358             dialog.setMultipleSelection(true);
359             if (dialog.open() == IDialogConstants.OK_ID) {
360                 Object JavaDoc[] packages = dialog.getResult();
361                 if (packages != null) {
362                     IJavaElement pkg = null;
363                     for (int i = 0; i < packages.length; i++) {
364                         pkg = (IJavaElement)packages[i];
365                         String JavaDoc filter = pkg.getElementName() + ".*"; //$NON-NLS-1$
366
addFilter(filter, true);
367                     }
368                 }
369             }
370             
371         }
372         catch (JavaModelException jme) {
373             ExceptionHandler.handle(jme,
374                     DebugUIMessages.JavaStepFilterPreferencePage_Add_package_to_step_filters_24,
375                     DebugUIMessages.JavaStepFilterPreferencePage_Could_not_open_package_selection_dialog_for_step_filters_25);
376         }
377     }
378     
379     /**
380      * Removes the currently selected filters.
381      */

382     protected void removeFilters() {
383         fTableViewer.remove(((IStructuredSelection)fTableViewer.getSelection()).toArray());
384     }
385     
386     /* (non-Javadoc)
387      * @see org.eclipse.jface.preference.PreferencePage#performOk()
388      */

389     public boolean performOk() {
390         DebugUITools.setUseStepFilters(fUseStepFiltersButton.getSelection());
391         IPreferenceStore store = getPreferenceStore();
392         ArrayList JavaDoc active = new ArrayList JavaDoc();
393         ArrayList JavaDoc inactive = new ArrayList JavaDoc();
394         String JavaDoc name = ""; //$NON-NLS-1$
395
Filter[] filters = getAllFiltersFromTable();
396         for(int i = 0; i < filters.length; i++) {
397             name = filters[i].getName();
398             if(filters[i].isChecked()) {
399                 active.add(name);
400             }
401             else {
402                 inactive.add(name);
403             }
404         }
405         String JavaDoc pref = JavaDebugOptionsManager.serializeList((String JavaDoc[])active.toArray(new String JavaDoc[active.size()]));
406         store.setValue(IJDIPreferencesConstants.PREF_ACTIVE_FILTERS_LIST, pref);
407         pref = JavaDebugOptionsManager.serializeList((String JavaDoc[])inactive.toArray(new String JavaDoc[inactive.size()]));
408         store.setValue(IJDIPreferencesConstants.PREF_INACTIVE_FILTERS_LIST, pref);
409         store.setValue(IJDIPreferencesConstants.PREF_FILTER_CONSTRUCTORS, fFilterConstructorButton.getSelection());
410         store.setValue(IJDIPreferencesConstants.PREF_FILTER_STATIC_INITIALIZERS, fFilterStaticButton.getSelection());
411         store.setValue(IJDIPreferencesConstants.PREF_FILTER_SYNTHETICS, fFilterSyntheticButton.getSelection());
412         store.setValue(IJDIPreferencesConstants.PREF_STEP_THRU_FILTERS, fStepThruButton.getSelection());
413         return super.performOk();
414     }
415     
416     /* (non-Javadoc)
417      * @see org.eclipse.jface.preference.PreferencePage#performDefaults()
418      */

419     protected void performDefaults() {
420         boolean stepenabled = DebugUITools.isUseStepFilters();
421         fUseStepFiltersButton.setSelection(stepenabled);
422         setPageEnablement(stepenabled);
423         fFilterSyntheticButton.setSelection(getPreferenceStore().getDefaultBoolean(IJDIPreferencesConstants.PREF_FILTER_SYNTHETICS));
424         fFilterStaticButton.setSelection(getPreferenceStore().getDefaultBoolean(IJDIPreferencesConstants.PREF_FILTER_STATIC_INITIALIZERS));
425         fFilterConstructorButton.setSelection(getPreferenceStore().getDefaultBoolean(IJDIPreferencesConstants.PREF_FILTER_CONSTRUCTORS));
426         fStepThruButton.setSelection(getPreferenceStore().getDefaultBoolean(IJDIPreferencesConstants.PREF_STEP_THRU_FILTERS));
427         fTableViewer.getTable().removeAll();
428         initTableState(true);
429         super.performDefaults();
430     }
431     
432     /**
433      * adds a single filter to the viewer
434      * @param filter the new filter to add
435      * @param checked the checked state of the new filter
436      * @since 3.2
437      */

438     protected void addFilter(String JavaDoc filter, boolean checked) {
439         if(filter != null) {
440             Filter f = new Filter(filter, checked);
441             fTableViewer.add(f);
442             fTableViewer.setChecked(f, checked);
443         }
444     }
445     
446     /**
447      * returns all of the filters from the table, this includes ones that have not yet been saved
448      * @return a possibly empty lits of filters fron the table
449      * @since 3.2
450      */

451     protected Filter[] getAllFiltersFromTable() {
452         TableItem[] items = fTableViewer.getTable().getItems();
453         Filter[] filters = new Filter[items.length];
454         for(int i = 0; i < items.length; i++) {
455             filters[i] = (Filter)items[i].getData();
456             filters[i].setChecked(items[i].getChecked());
457         }
458         return filters;
459     }
460     
461     /**
462      * Returns all of the committed filters
463      * @return an array of committed filters
464      * @since 3.2
465      */

466     protected Filter[] getAllStoredFilters(boolean defaults) {
467         Filter[] filters = null;
468         String JavaDoc[] activefilters, inactivefilters;
469         IPreferenceStore store = getPreferenceStore();
470         if(defaults) {
471             activefilters = JavaDebugOptionsManager.parseList(store.getDefaultString(IJDIPreferencesConstants.PREF_ACTIVE_FILTERS_LIST));
472             inactivefilters = JavaDebugOptionsManager.parseList(store.getDefaultString(IJDIPreferencesConstants.PREF_INACTIVE_FILTERS_LIST));
473         }
474         else {
475             activefilters = JavaDebugOptionsManager.parseList(store.getString(IJDIPreferencesConstants.PREF_ACTIVE_FILTERS_LIST));
476             inactivefilters = JavaDebugOptionsManager.parseList(store.getString(IJDIPreferencesConstants.PREF_INACTIVE_FILTERS_LIST));
477         }
478         filters = new Filter[activefilters.length + inactivefilters.length];
479         for(int i = 0; i < activefilters.length; i++) {
480             filters[i] = new Filter(activefilters[i], true);
481         }
482         for(int i = 0; i < inactivefilters.length; i++) {
483             filters[i+activefilters.length] = new Filter(inactivefilters[i], false);
484         }
485         return filters;
486     }
487 }
488
Popular Tags