Java > Open Source Codes > org > eclipse > ui > views > markers > internal > DialogMarkerFilter


1 /*******************************************************************************
2  * Copyright (c) 2000, 2006 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
12 package org.eclipse.ui.views.markers.internal;
13
14 import java.util.ArrayList ;
15 import java.util.Collection ;
16 import java.util.HashMap ;
17 import java.util.List ;
18
19 import org.eclipse.jface.dialogs.ErrorDialog;
20 import org.eclipse.jface.dialogs.IDialogConstants;
21 import org.eclipse.jface.dialogs.IInputValidator;
22 import org.eclipse.jface.dialogs.InputDialog;
23 import org.eclipse.jface.dialogs.TrayDialog;
24 import org.eclipse.jface.viewers.CheckStateChangedEvent;
25 import org.eclipse.jface.viewers.CheckboxTableViewer;
26 import org.eclipse.jface.viewers.CheckboxTreeViewer;
27 import org.eclipse.jface.viewers.ColumnWeightData;
28 import org.eclipse.jface.viewers.ICheckStateListener;
29 import org.eclipse.jface.viewers.ILabelProvider;
30 import org.eclipse.jface.viewers.ISelection;
31 import org.eclipse.jface.viewers.ISelectionChangedListener;
32 import org.eclipse.jface.viewers.IStructuredContentProvider;
33 import org.eclipse.jface.viewers.IStructuredSelection;
34 import org.eclipse.jface.viewers.ITableLabelProvider;
35 import org.eclipse.jface.viewers.ITreeContentProvider;
36 import org.eclipse.jface.viewers.LabelProvider;
37 import org.eclipse.jface.viewers.SelectionChangedEvent;
38 import org.eclipse.jface.viewers.StructuredSelection;
39 import org.eclipse.jface.viewers.TableLayout;
40 import org.eclipse.jface.viewers.Viewer;
41 import org.eclipse.jface.viewers.ViewerComparator;
42 import org.eclipse.jface.window.Window;
43 import org.eclipse.osgi.util.NLS;
44 import org.eclipse.swt.SWT;
45 import org.eclipse.swt.events.SelectionAdapter;
46 import org.eclipse.swt.events.SelectionEvent;
47 import org.eclipse.swt.graphics.Image;
48 import org.eclipse.swt.graphics.Point;
49 import org.eclipse.swt.layout.GridData;
50 import org.eclipse.swt.layout.GridLayout;
51 import org.eclipse.swt.widgets.Button;
52 import org.eclipse.swt.widgets.Combo;
53 import org.eclipse.swt.widgets.Composite;
54 import org.eclipse.swt.widgets.Control;
55 import org.eclipse.swt.widgets.Label;
56 import org.eclipse.swt.widgets.Shell;
57 import org.eclipse.swt.widgets.Tree;
58 import org.eclipse.swt.widgets.TreeColumn;
59 import org.eclipse.ui.IWorkingSet;
60 import org.eclipse.ui.PlatformUI;
61 import org.eclipse.ui.dialogs.IWorkingSetSelectionDialog;
62
63 /**
64  * Dialog which allows user to modify all settings of an
65  * org.eclipse.ui.views.MarkerFilter object. Not intended to be subclassed or
66  * instantiated by clients.
67  */
68 public abstract class DialogMarkerFilter extends TrayDialog {
69
70     static final int SELECT_ALL_FILTERS_ID = IDialogConstants.CLIENT_ID + 4;
71
72     static final int DESELECT_ALL_FILTERS_ID = IDialogConstants.CLIENT_ID + 5;
73
74     /**
75      * button IDs
76      */
77     static final int RESET_ID = IDialogConstants.CLIENT_ID;
78
79     static final int SELECT_WORKING_SET_ID = IDialogConstants.CLIENT_ID + 1;
80
81     static final int SELECT_ALL_ID = IDialogConstants.CLIENT_ID + 2;
82
83     static final int DESELECT_ALL_ID = IDialogConstants.CLIENT_ID + 3;
84
85     private class TypesLabelProvider extends LabelProvider implements
86             ITableLabelProvider {
87
88         /*
89          * (non-Javadoc)
90          *
91          * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnImage(java.lang.Object,
92          * int)
93          */
94         public Image getColumnImage(Object element, int columnIndex) {
95             return null;
96         }
97
98         /*
99          * (non-Javadoc)
100          *
101          * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnText(java.lang.Object,
102          * int)
103          */
104         public String getColumnText(Object element, int columnIndex) {
105             return ((AbstractNode) element).getName();
106         }
107     }
108
109     /**
110      * Creates and manages a group of widgets for selecting a working set marker
111      * filter.
112      */
113     private class WorkingSetGroup {
114
115         private Button button;
116
117         private Button selectButton;
118
119         /**
120          * Creates the working set filter selection widgets.
121          *
122          * @param parent
123          * the parent composite of the working set widgets
124          */
125         WorkingSetGroup(Composite parent) {
126             // radio button has to be part of main radio button group
127 button = createRadioButton(parent,
128                     MarkerMessages.filtersDialog_noWorkingSet);
129             GridData data = new GridData(GridData.FILL_HORIZONTAL);
130             button.setLayoutData(data);
131
132             Composite composite = new Composite(parent, SWT.NONE);
133             composite.setFont(parent.getFont());
134             GridLayout layout = new GridLayout();
135             Button radio = new Button(parent, SWT.RADIO);
136             layout.marginWidth = radio.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
137             layout.marginHeight = 0;
138             radio.dispose();
139             composite.setLayout(layout);
140             selectButton = createButton(composite, SELECT_WORKING_SET_ID,
141                     MarkerMessages.filtersDialog_workingSetSelect, false);
142         }
143
144         /**
145          * Returns wether or not a working set filter should be used
146          *
147          * @return true=a working set filter should be used false=a working set
148          * filter should not be used
149          */
150         boolean getSelection() {
151             return button.getSelection();
152         }
153
154         /**
155          * Returns the selected working set filter or null if none is selected.
156          *
157          * @return the selected working set filter or null if none is selected.
158          */
159         IWorkingSet getWorkingSet() {
160             return (IWorkingSet) button.getData();
161         }
162
163         /**
164          * Sets the working set filter selection.
165          *
166          * @param selected
167          * true=a working set filter should be used false=no working
168          * set filter should be used
169          */
170         void setSelection(boolean selected) {
171             button.setSelection(selected);
172             if (selected) {
173                 anyResourceButton.setSelection(false);
174                 anyResourceInSameProjectButton.setSelection(false);
175                 selectedResourceButton.setSelection(false);
176                 selectedResourceAndChildrenButton.setSelection(false);
177             }
178         }
179
180         /**
181          * Opens the working set selection dialog.
182          */
183         void selectPressed() {
184             IWorkingSetSelectionDialog dialog = PlatformUI.getWorkbench()
185                     .getWorkingSetManager().createWorkingSetSelectionDialog(
186                             getShell(), false);
187             IWorkingSet workingSet = getWorkingSet();
188
189             if (workingSet != null) {
190                 dialog.setSelection(new IWorkingSet[] { workingSet });
191             }
192             if (dialog.open() == Window.OK) {
193                 markDirty();
194                 IWorkingSet[] result = dialog.getSelection();
195                 if (result != null && result.length > 0) {
196                     setWorkingSet(result[0]);
197                 } else {
198                     setWorkingSet(null);
199                 }
200                 if (getSelection() == false) {
201                     setSelection(true);
202                 }
203             }
204         }
205
206         /**
207          * Sets the specified working set.
208          *
209          * @param workingSet
210          * the working set
211          */
212         void setWorkingSet(IWorkingSet workingSet) {
213             button.setData(workingSet);
214             if (workingSet != null) {
215                 button.setText(NLS.bind(
216                         MarkerMessages.filtersDialog_workingSet, workingSet
217                                 .getLabel()));
218             } else {
219                 button.setText(MarkerMessages.filtersDialog_noWorkingSet);
220             }
221         }
222
223         void setEnabled(boolean enabled) {
224             button.setEnabled(enabled);
225             selectButton.setEnabled(enabled);
226         }
227     }
228
229     /**
230      * AbstractNode is the abstract superclass of the node elements for
231      * MarkerTypes.
232      *
233      */
234     private abstract class AbstractNode {
235
236         /**
237          * Get the parent element of the receiver.
238          *
239          * @return Object
240          */
241         public abstract Object getParent();
242
243         /**
244          * Get the name of the receiver.
245          *
246          * @return String
247          */
248         public abstract String getName();
249
250         /**
251          * Return whether or not the receiver has children.
252          *
253          * @return boolean
254          */
255         public abstract boolean hasChildren();
256
257         /**
258          * Get the children of the receiver.
259          *
260          * @return Object[]
261          */
262         public abstract Object [] getChildren();
263
264         /**
265          * Return whether or not this is a category node.
266          *
267          * @return boolean
268          */
269         public abstract boolean isCategory();
270
271     }
272
273     /**
274      * MarkerTypeNode is the wrapper for marker types.
275      *
276      */
277     private class MarkerTypeNode extends AbstractNode {
278
279         MarkerType type;
280
281         MarkerCategory category;
282
283         /**
284          * Create an instance of the receiver wrapping markerType.
285          *
286          * @param markerType
287          */
288         public MarkerTypeNode(MarkerType markerType) {
289             type = markerType;
290             nodeToTypeMapping.put(markerType.getId(), this);
291         }
292
293         /**
294          * Set the category of the receiver.
295          *
296          * @param category
297          */
298         public void setCategory(MarkerCategory category) {
299             this.category = category;
300         }
301
302         /**
303          * Get the category for the receiver.
304          *
305          * @return MarkerCategory
306          */
307         public MarkerCategory getCategory() {
308             return category;
309         }
310
311         /*
312          * (non-Javadoc)
313          *
314          * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter.AbstractNode#getChildren()
315          */
316         public Object [] getChildren() {
317             return new Object [0];
318         }
319
320         /*
321          * (non-Javadoc)
322          *
323          * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter.AbstractNode#getParent()
324          */
325         public Object getParent() {
326             return category;
327         }
328
329         /*
330          * (non-Javadoc)
331          *
332          * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter.AbstractNode#hasChildren()
333          */
334         public boolean hasChildren() {
335             return false;
336         }
337
338         /*
339          * (non-Javadoc)
340          *
341          * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter.AbstractNode#getName()
342          */
343         public String getName() {
344             return type.getLabel();
345         }
346
347         /*
348          * (non-Javadoc)
349          *
350          * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter.AbstractNode#isCategory()
351          */
352         public boolean isCategory() {
353             return false;
354         }
355
356         /**
357          * Return the marker type this is wrapping
358          *
359          * @return Object
360          */
361         public Object getMarkerType() {
362             return type;
363         }
364     }
365
366     /**
367      * The MarkerCategory is a data type to represent the categories in the tree
368      * view.
369      *
370      */
371     private class MarkerCategory extends AbstractNode {
372
373         String name;
374
375         Collection types = new ArrayList ();
376
377         /**
378          * Create a new instance of the receiver with name categoryName.
379          *
380          * @param categoryName
381          */
382         public MarkerCategory(String categoryName) {
383             name = categoryName;
384         }
385
386         /*
387          * (non-Javadoc)
388          *
389          * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter.AbstractNode#getName()
390          */
391         public String getName() {
392             return name;
393         }
394
395         /**
396          * Add markerType to the list of types.
397          *
398          * @param markerType
399          */
400         public void add(MarkerTypeNode markerType) {
401             types.add(markerType);
402             markerType.setCategory(this);
403         }
404
405         /**
406          * Return the marker types contained in the receiver.
407          *
408          * @return Object[]
409          */
410         public Object [] getMarkerTypes() {
411             return types.toArray();
412         }
413
414         /*
415          * (non-Javadoc)
416          *
417          * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter.AbstractNode#getChildren()
418          */
419         public Object [] getChildren() {
420             return getMarkerTypes();
421         }
422
423         /*
424          * (non-Javadoc)
425          *
426          * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter.AbstractNode#getParent()
427          */
428         public Object getParent() {
429             return null;
430         }
431
432         /*
433          * (non-Javadoc)
434          *
435          * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter.AbstractNode#hasChildren()
436          */
437         public boolean hasChildren() {
438             return true;
439         }
440
441         /*
442          * (non-Javadoc)
443          *
444          * @see org.eclipse.ui.views.markers.internal.DialogMarkerFilter.AbstractNode#isCategory()
445          */
446         public boolean isCategory() {
447             return true;
448         }
449
450     }
451
452     private MarkerFilter[] filters;
453
454     private CheckboxTreeViewer typesViewer;
455
456     private Button anyResourceButton;
457
458     private Button anyResourceInSameProjectButton;
459
460     private Button selectedResourceButton;
461
462     private Button selectedResourceAndChildrenButton;
463
464     private Button selectAllButton;
465
466     private Button deselectAllButton;
467
468     private WorkingSetGroup workingSetGroup;
469
470     private boolean dirty = false;
471
472     private CheckboxTableViewer filtersList;
473
474     private MarkerFilter[] selectedFilters;
475
476     private HashMap nodeToTypeMapping = new HashMap ();
477
478     private ITreeContentProvider typesContentProvider;
479
480     /**
481      * Create a new instance of the receiver.
482      *
483      * @param parentShell
484      * @param filtersList
485      */
486     DialogMarkerFilter(Shell parentShell, MarkerFilter[] filtersList) {
487         super(parentShell);
488         setFilters(filtersList);
489         setShellStyle(getShellStyle() | SWT.RESIZE);
490     }
491
492     /**
493      * Set the filters in the filtersList by copying them.
494      *
495      * @param initialFilters
496      */
497     private void setFilters(MarkerFilter[] initialFilters) {
498         MarkerFilter[] newMarkers = new MarkerFilter[initialFilters.length];
499         for (int i = 0; i < initialFilters.length; i++) {
500             MarkerFilter newFilter;
501             try {
502                 newFilter = initialFilters[i].makeClone();
503             } catch (CloneNotSupportedException exception) {
504                 ErrorDialog.openError(getShell(),
505                         MarkerMessages.MarkerFilterDialog_errorTitle,
506                         MarkerMessages.MarkerFilterDialog_failedFilterMessage,
507                         Util.errorStatus(exception));
508                 return;
509             }
510
511             newMarkers[i] = newFilter;
512
513         }
514         filters = newMarkers;
515
516     }
517
518     /*
519      * (non-Javadoc) Method declared on Dialog.
520      */
521     protected void buttonPressed(int buttonId) {
522
523         switch (buttonId) {
524         case RESET_ID:
525             resetPressed();
526             markDirty();
527             break;
528         case SELECT_WORKING_SET_ID:
529             workingSetGroup.selectPressed();
530             break;
531         case SELECT_ALL_ID:
532             typesViewer.setAllChecked(true);
533             break;
534         case DESELECT_ALL_ID:
535             typesViewer.setAllChecked(false);
536             break;
537         case SELECT_ALL_FILTERS_ID:
538             filtersList.setAllChecked(true);
539             break;
540         case DESELECT_ALL_FILTERS_ID:
541             filtersList.setAllChecked(false);
542             break;
543         default:
544             break;
545         }
546         super.buttonPressed(buttonId);
547     }
548
549     /**
550      * Method declared on Window.
551      */
552     protected void configureShell(Shell newShell) {
553         super.configureShell(newShell);
554         newShell.setText(MarkerMessages.filtersDialog_title);
555     }
556
557     protected void createResetArea(Composite parent) {
558
559         Button reset = new Button(parent, SWT.PUSH);
560         reset.setText(MarkerMessages.restoreDefaults_text);
561         reset.setData(new Integer (RESET_ID));
562
563         reset.addSelectionListener(new SelectionAdapter() {
564             public void widgetSelected(SelectionEvent event) {
565                 buttonPressed(((Integer ) event.widget.getData()).intValue());
566             }
567         });
568
569         GridData data = new GridData(GridData.HORIZONTAL_ALIGN_END);
570         int widthHint = convertHorizontalDLUsToPixels(IDialogConstants.BUTTON_WIDTH);
571         Point minSize = reset.computeSize(SWT.DEFAULT, SWT.DEFAULT, true);
572         data.widthHint = Math.max(widthHint, minSize.x);
573         data.horizontalSpan = 2;
574         reset.setLayoutData(data);
575     }
576
577     /**
578      * Creates a check box button with the given parent and text.
579      *
580      * @param parent
581      * the parent composite
582      * @param text
583      * the text for the check box
584      * @param grabRow
585      * <code>true</code>to grab the remaining horizontal space,
586      * <code>false</code> otherwise
587      * @return the check box button
588      */
589     protected Button createCheckbox(Composite parent, String text,
590             boolean grabRow) {
591         Button button = new Button(parent, SWT.CHECK);
592         if (grabRow) {
593             GridData gridData = new GridData(GridData.FILL_HORIZONTAL);
594             button.setLayoutData(gridData);
595         }
596         button.setText(text);
597         button.addSelectionListener(new SelectionAdapter() {
598             public void widgetSelected(SelectionEvent e) {
599                 updateForSelection();
600             }
601         });
602         button.setFont(parent.getFont());
603         return button;
604     }
605
606     /**
607      * Creates a combo box with the given parent, items, and selection
608      *
609      * @param parent
610      * the parent composite
611      * @param items
612      * the items for the combo box
613      * @param selectionIndex
614      * the index of the item to select
615      * @return the combo box
616      */
617     protected Combo createCombo(Composite parent, String [] items,
618             int selectionIndex) {
619         Combo combo = new Combo(parent, SWT.DROP_DOWN | SWT.READ_ONLY);
620         combo.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
621         combo.setFont(parent.getFont());
622         combo.setItems(items);
623         combo.select(selectionIndex);
624         combo.addSelectionListener(new SelectionAdapter() {
625             public void widgetSelected(SelectionEvent e) {
626                 updateForSelection();
627             }
628         });
629         return combo;
630     }
631
632     /**
633      * Method declared on Dialog.
634      */
635     protected Control createDialogArea(Composite parent) {
636         Composite dialogArea = (Composite) super.createDialogArea(parent);
637
638         dialogArea.setLayout(new GridLayout(2, false));
639
640         createFiltersArea(dialogArea);
641
642         Composite selectedComposite = createSelectedFilterArea(dialogArea);
643         selectedComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true,
644                 true));
645         updateUIFromFilter();
646
647         filtersList.setSelection(new StructuredSelection(filters[0]));
648
649         createResetArea(dialogArea);
650         createSeparatorLine(dialogArea);
651
652         applyDialogFont(dialogArea);
653         return dialogArea;
654     }
655
656     /**
657      * Create the list in the receiver.
658      *
659      * @param dialogArea
660      */
661     /**
662      * @param dialogArea
663      */
664     void createFiltersArea(Composite dialogArea) {
665
666         Composite listArea = new Composite(dialogArea, SWT.NONE);
667         listArea.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
668         listArea.setLayout(new GridLayout());
669
670         createUserFiltersArea(listArea);
671         createFilterSelectButtons(listArea);
672     }
673
674     /**
675      * Create the area for the user to select thier filters.
676      *
677      * @param listArea
678      */
679     void createUserFiltersArea(Composite listArea) {
680
681         Composite userComposite = new Composite(listArea, SWT.NONE);
682         userComposite.setLayout(new GridLayout(2, false));
683         userComposite
684                 .setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
685
686         Label title = new Label(userComposite, SWT.NONE);
687         title.setText(MarkerMessages.MarkerFilter_filtersTitle);
688         GridData titleData = new GridData();
689         titleData.horizontalSpan = 2;
690         title.setLayoutData(titleData);
691
692         filtersList = CheckboxTableViewer.newCheckList(userComposite,
693                 SWT.BORDER);
694         filtersList.setContentProvider(new IStructuredContentProvider() {
695             /*
696              * (non-Javadoc)
697              *
698              * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
699              */
700             public Object [] getElements(Object inputElement) {
701                 return filters;
702             }
703
704             /*
705              * (non-Javadoc)
706              *
707              * @see org.eclipse.jface.viewers.IContentProvider#dispose()
708              */
709             public void dispose() {
710                 // Do nothing
711 }
712
713             /*
714              * (non-Javadoc)
715              *
716              * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,
717              * java.lang.Object, java.lang.Object)
718              */
719             public void inputChanged(Viewer viewer, Object oldInput,
720                     Object newInput) {
721                 // Do nothing
722 }
723         });
724
725         filtersList.setLabelProvider(new LabelProvider() {
726             /*
727              * (non-Javadoc)
728              *
729              * @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object)
730              */
731             public String getText(Object element) {
732                 return ((MarkerFilter) element).getName();
733             }
734         });
735
736         selectedFilters = new MarkerFilter[] { filters[0] };
737         filtersList.setSelection(new StructuredSelection(selectedFilters));
738
739         filtersList
740                 .addSelectionChangedListener(new ISelectionChangedListener() {
741
742                     /*
743                      * (non-Javadoc)
744                      *
745                      * @see org.eclipse.jface.viewers.ISelectionChangedListener#selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent)
746                      */
747                     public void selectionChanged(SelectionChangedEvent event) {
748                         updateFilterFromUI();
749                         setSelectedFilter(event);
750
751                     }
752                 });
753
754         filtersList.setInput(this);
755         for (int i = 0; i < filters.length; i++) {
756             filtersList.setChecked(filters[i], filters[i].isEnabled());
757         }
758
759         GridData listData = new GridData(SWT.FILL, SWT.FILL, true, true);
760         listData.widthHint = convertHorizontalDLUsToPixels(100);
761         filtersList.getControl().setLayoutData(listData);
762
763         Composite buttons = new Composite(userComposite, SWT.NONE);
764         GridLayout buttonLayout = new GridLayout();
765         buttonLayout.marginWidth = 0;
766         buttons.setLayout(buttonLayout);
767         GridData buttonsData = new GridData();
768         buttonsData.verticalAlignment = GridData.BEGINNING;
769         buttons.setLayoutData(buttonsData);
770
771         Button addNew = new Button(buttons, SWT.PUSH);
772         addNew.setText(MarkerMessages.MarkerFilter_addFilterName);
773         addNew.addSelectionListener(new SelectionAdapter() {
774             public void widgetSelected(SelectionEvent e) {
775                 InputDialog newDialog = new InputDialog(getShell(),
776                         MarkerMessages.MarkerFilterDialog_title,
777                         MarkerMessages.MarkerFilterDialog_message,
778                         MarkerMessages.MarkerFilter_newFilterName,
779                         new IInputValidator() {
780                             /*
781                              * (non-Javadoc)
782                              *
783                              * @see org.eclipse.jface.dialogs.IInputValidator#isValid(java.lang.String)
784                              */
785                             public String isValid(String newText) {
786                                 if (newText.length() == 0)
787                                     return MarkerMessages.MarkerFilterDialog_emptyMessage;
788                                 for (int i = 0; i < filters.length; i++) {
789                                     if (filters[i].getName().equals(newText))
790                                         return NLS
791                                                 .bind(
792                                                         MarkerMessages.filtersDialog_conflictingName,
793                                                         newText);
794
795                                 }
796                                 return null;
797                             }
798                         });
799                 newDialog.open();
800                 String newName = newDialog.getValue();
801                 if (newName != null) {
802                     createNewFilter(newName);
803                 }
804             }
805         });
806         setButtonLayoutData(addNew);
807
808         Button remove = new Button(buttons, SWT.PUSH);
809         remove.setText(MarkerMessages.MarkerFilter_deleteSelectedName);
810         remove.addSelectionListener(new SelectionAdapter() {
811             public void widgetSelected(SelectionEvent e) {
812                 removeFilters(filtersList.getSelection());
813             }
814         });
815         setButtonLayoutData(remove);
816     }
817
818     /**
819      * Set the selected filter from event.
820      *
821      * @param event
822      */
823     protected void setSelectedFilter(SelectionChangedEvent event) {
824
825         ISelection selection = event.getSelection();
826         if (selection instanceof IStructuredSelection) {
827             Collection list = ((IStructuredSelection) selection).toList();
828             MarkerFilter[] selected = new MarkerFilter[list.size()];
829             list.toArray(selected);
830             selectedFilters = selected;
831
832         } else {
833             selectedFilters = new MarkerFilter[0];
834         }
835         updateUIFromFilter();
836
837     }
838
839     /**
840      * Remove the filters in selection.
841      *
842      * @param selection
843      */
844     protected void removeFilters(ISelection selection) {
845         if (selection instanceof IStructuredSelection) {
846             List toRemove = ((IStructuredSelection) selection).toList();
847             MarkerFilter[] newFilters = new MarkerFilter[filters.length
848                     - toRemove.size()];
849             int index = 0;
850             for (int i = 0; i < filters.length; i++) {
851                 if (toRemove.contains(filters[i])) {
852                     continue;
853                 }
854                 newFilters[index] = filters[i];
855                 index++;
856             }
857
858             filters = newFilters;
859             filtersList.refresh();
860             updateUIFromFilter();
861         }
862     }
863
864     /**
865      * Create a new filter called newName.
866      *
867      * @param newName
868      */
869     private void createNewFilter(String newName) {
870         MarkerFilter[] newFilters = new MarkerFilter[filters.length + 1];
871         System.arraycopy(filters, 0, newFilters, 0, filters.length);
872         MarkerFilter filter = newFilter(newName);
873         newFilters[filters.length] = filter;
874         filters = newFilters;
875         filtersList.refresh();
876         filtersList.setSelection(new StructuredSelection(filter), true);
877         filtersList.getControl().setFocus();
878     }
879
880     /**
881      * Crate a newFilter called newName
882      *
883      * @param newName
884      * @return MarkerFilter
885      */
886     protected abstract MarkerFilter newFilter(String newName);
887
888     /**
889      * Create the area for the selected filter.
890      *
891      * @param composite
892      */
893     Composite createSelectedFilterArea(Composite composite) {
894
895         Composite selectedComposite = new Composite(composite, SWT.NONE);
896         selectedComposite.setLayout(new GridLayout(2, false));
897
898         Composite leftComposite = new Composite(selectedComposite, SWT.NONE);
899         leftComposite.setLayout(new GridLayout());
900         leftComposite
901                 .setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
902         createResourceArea(leftComposite);
903         createAttributesArea(leftComposite);
904
905         Composite rightComposite = new Composite(selectedComposite, SWT.NONE);
906         createTypesArea(rightComposite);
907         rightComposite.setLayout(new GridLayout());
908         rightComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true,
909                 true));
910
911         return selectedComposite;
912     }
913
914     /**
915      * Creates a separator line above the OK/Cancel buttons bar
916      *
917      * @param parent
918      * the parent composite
919      */
920     protected void createSeparatorLine(Composite parent) {
921         // Build the separator line
922 Label separator = new Label(parent, SWT.HORIZONTAL | SWT.SEPARATOR);
923         GridData gd = new GridData(GridData.FILL_HORIZONTAL);
924         gd.horizontalSpan = 2;
925         separator.setLayoutData(gd);
926     }
927
928     /**
929      * Creates a radio button with the given parent and text.
930      *
931      * @param parent
932      * the parent composite
933      * @param text
934      * the text for the check box
935      * @return the radio box button
936      */
937     protected Button createRadioButton(Composite parent, String text) {
938         Button button = new Button(parent, SWT.RADIO);
939         button.setText(text);
940         button.setFont(parent.getFont());
941         button.addSelectionListener(new SelectionAdapter() {
942             /*
943              * (non-Javadoc)
944              *
945              * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
946              */
947             public void widgetSelected(SelectionEvent e) {
948                 updateForSelection();
949             }
950         });
951         return button;
952     }
953
954     /**
955      * Creates the area showing which resources should be considered.
956      *
957      * @param parent
958      * the parent composite
959      */
960     protected void createResourceArea(Composite parent) {
961         Composite group = new Composite(parent, SWT.NONE);
962         group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
963         group.setLayout(new GridLayout());
964         group.setFont(parent.getFont());
965         anyResourceButton = createRadioButton(group,
966                 MarkerMessages.filtersDialog_anyResource);
967         anyResourceInSameProjectButton = createRadioButton(group,
968                 MarkerMessages.filtersDialog_anyResourceInSameProject); // added
969 // by
970 // cagatayk@acm.org
971 selectedResourceButton = createRadioButton(group,
972                 MarkerMessages.filtersDialog_selectedResource);
973         selectedResourceAndChildrenButton = createRadioButton(group,
974                 MarkerMessages.filtersDialog_selectedAndChildren);
975         workingSetGroup = new WorkingSetGroup(group);
976     }
977
978     /**
979      * Creates the area showing which marker types should be included.
980      *
981      * @param parent
982      * the parent composite
983      */
984     protected void createTypesArea(Composite parent) {
985
986         Composite composite = new Composite(parent, SWT.NONE);
987         composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
988         GridLayout layout = new GridLayout();
989         composite.setLayout(layout);
990
991         Label label = new Label(composite, SWT.NONE);
992         label.setText(MarkerMessages.filtersDialog_showItemsOfType);
993
994         Tree tree = new Tree(composite, SWT.CHECK | SWT.H_SCROLL | SWT.V_SCROLL
995                 | SWT.MULTI | SWT.FULL_SELECTION | SWT.BORDER);
996         tree.setLinesVisible(true);
997         tree.setHeaderVisible(false);
998         TableLayout tableLayout = new TableLayout();
999         tree.setLayout(tableLayout);
1000        tableLayout.addColumnData(new ColumnWeightData(100, true));
1001        new TreeColumn(tree, SWT.NONE, 0);
1002
1003        typesViewer = new CheckboxTreeViewer(tree);
1004        GridData gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
1005        gridData.widthHint = convertVerticalDLUsToPixels(100);
1006        gridData.heightHint = convertVerticalDLUsToPixels(125);
1007
1008        typesContentProvider = getTypesContentProvider();
1009        typesViewer.getControl().setLayoutData(gridData);
1010        typesViewer.setContentProvider(typesContentProvider);
1011        typesViewer.setLabelProvider(getLabelProvider());
1012        typesViewer.setComparator(getComparator());
1013        typesViewer.addCheckStateListener(new ICheckStateListener() {
1014            public void checkStateChanged(CheckStateChangedEvent event) {
1015                markDirty();
1016                Object element = event.getElement();
1017                boolean checked = event.getChecked();
1018                setChildrenChecked(element, checked);
1019                setParentCheckState(element, checked);
1020            }
1021        });
1022        typesViewer.setInput(getSelectedFilter().getRootTypes().toArray());
1023
1024        Composite buttonComposite = new Composite(composite, SWT.NONE);
1025        GridLayout buttonLayout = new GridLayout();
1026        buttonLayout.marginWidth = 0;
1027        buttonComposite.setLayout(buttonLayout);
1028        selectAllButton = createButton(buttonComposite, SELECT_ALL_ID,
1029                MarkerMessages.filtersDialog_selectAllTypes, false);
1030        deselectAllButton = createButton(buttonComposite, DESELECT_ALL_ID,
1031                MarkerMessages.filtersDialog_deselectAllTypes, false);
1032    }
1033
1034    /**
1035     * Get the currently selected marker filter if there is only one selection.
1036     *
1037     * @return MarkerFilter or <code>null</code>.
1038     */
1039    protected MarkerFilter getSelectedFilter() {
1040
1041        if (selectedFilters.length == 1) {
1042            return selectedFilters[0];
1043        }
1044        return null;
1045    }
1046
1047    /**
1048     * Get the content provider for the receiver.
1049     *
1050     * @return ITreeContentProvider
1051     */
1052    private ITreeContentProvider getTypesContentProvider() {
1053        return new ITreeContentProvider() {
1054            /*
1055             * (non-Javadoc)
1056             *
1057             * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
1058             */
1059            public Object [] getElements(Object inputElement) {
1060                MarkerFilter selected = getSelectedFilter();
1061                if (selected == null) {
1062                    return new Object [0];
1063                }
1064
1065                return getRootEntries(selected);
1066            }
1067
1068            /*
1069             * (non-Javadoc)
1070             *
1071             * @see org.eclipse.jface.viewers.IContentProvider#dispose()
1072             */
1073            public void dispose() {
1074            }
1075
1076            /*
1077             * (non-Javadoc)
1078             *
1079             * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,
1080             * java.lang.Object, java.lang.Object)
1081             */
1082            public void inputChanged(Viewer viewer, Object oldInput,
1083                    Object newInput) {
1084            }
1085
1086            /*
1087             * (non-Javadoc)
1088             *
1089             * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object)
1090             */
1091            public Object [] getChildren(Object parentElement) {
1092                return ((AbstractNode) parentElement).getChildren();
1093            }
1094
1095            /*
1096             * (non-Javadoc)
1097             *
1098             * @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object)
1099             */
1100            public Object getParent(Object element) {
1101                return ((AbstractNode) element).getParent();
1102            }
1103
1104            /*
1105             * (non-Javadoc)
1106             *
1107             * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object)
1108             */
1109            public boolean hasChildren(Object element) {
1110                return ((AbstractNode) element).hasChildren();
1111            }
1112        };
1113    }
1114
1115    /**
1116     * This method is intended to be overridden by subclasses of FiltersDialog.
1117     * The attributes area will be created just above the Restore Defaults
1118     * button.
1119     *
1120     * @param parent
1121     * the parent Composite
1122     */
1123    abstract void createAttributesArea(Composite parent);
1124
1125    private ILabelProvider getLabelProvider() {
1126        return new TypesLabelProvider();
1127    }
1128
1129    /**
1130     * Returns the selected marker types.
1131     *
1132     * @return List the selected marker types
1133     */
1134    protected List getSelectedTypes() {
1135        Object [] checkElements = typesViewer.getCheckedElements();
1136        List selected = new ArrayList ();
1137        for (int i = 0; i < checkElements.length; i++) {
1138            AbstractNode node = (AbstractNode) checkElements[i];
1139            if (!node.isCategory()) {
1140                selected.add(((MarkerTypeNode) node).getMarkerType());
1141            }
1142
1143        }
1144        return selected;
1145    }
1146
1147    /**
1148     * Return the sorter for the receiver.
1149     *
1150     * @return ViewerSorter
1151     */
1152    protected ViewerComparator getComparator() {
1153        return new ViewerComparator() {
1154            /*
1155             * (non-Javadoc)
1156             *
1157             * @see org.eclipse.jface.viewers.ViewerComparator#compare(org.eclipse.jface.viewers.Viewer,
1158             * java.lang.Object, java.lang.Object)
1159             */
1160            public int compare(Viewer viewer, Object e1, Object e2) {
1161                return getComparator().compare(((AbstractNode) e1).getName(),
1162                        ((AbstractNode) e2).getName());
1163            }
1164        };
1165    }
1166
1167    /*
1168     * (non-Javadoc)
1169     *
1170     * @see org.eclipse.jface.dialogs.Dialog#okPressed()
1171     */
1172    protected void okPressed() {
1173        /**
1174         * Updates the filter from the UI state. Must be done here rather than
1175         * by extending open() because after super.open() is called, the
1176         * widgetry is disposed.
1177         */
1178        updateFilterFromUI();
1179
1180        for (int i = 0; i < filters.length; i++) {
1181            filters[i].setEnabled(filtersList.getChecked(filters[i]));
1182
1183        }
1184        super.okPressed();
1185    }
1186
1187    /**
1188     * Handles a press of the Reset button. Updates the UI state to correspond
1189     * to a reset filter, but doesn't actually reset our filter.
1190     */
1191    protected void resetPressed() {
1192        typesViewer.setAllChecked(true);
1193        int onResource = MarkerFilter.DEFAULT_ON_RESOURCE;
1194        anyResourceButton.setSelection(onResource == MarkerFilter.ON_ANY);
1195        anyResourceInSameProjectButton
1196                .setSelection(onResource == MarkerFilter.ON_ANY_IN_SAME_CONTAINER);
1197        selectedResourceButton
1198                .setSelection(onResource == MarkerFilter.ON_SELECTED_ONLY);
1199        selectedResourceAndChildrenButton
1200                .setSelection(onResource == MarkerFilter.ON_SELECTED_AND_CHILDREN);
1201        workingSetGroup.setSelection(onResource == MarkerFilter.ON_WORKING_SET);
1202        updateEnabledState(true);
1203    }
1204
1205    /**
1206     * Sets the selected marker types.
1207     *
1208     * @param markerTypes
1209     */
1210    void setSelectedTypes(List markerTypes) {
1211        typesViewer.setCheckedElements(new Object [0]);
1212        for (int i = 0; i < markerTypes.size(); i++) {
1213            Object obj = markerTypes.get(i);
1214            if (obj instanceof MarkerType) {
1215
1216                Object mapping = nodeToTypeMapping.get(((MarkerType) obj)
1217                        .getId());
1218                if (mapping != null) {
1219                    typesViewer.setChecked(mapping, true);
1220                    setParentCheckState(mapping, true);
1221                }
1222            }
1223        }
1224    }
1225
1226    /**
1227     * Updates the enabled state of the widgetry based on whether or not it is
1228     * enabled.
1229     */
1230    protected void updateEnabledState(boolean enabled) {
1231
1232        typesViewer.getTree().setEnabled(enabled);
1233        selectAllButton.setEnabled(enabled
1234                && typesViewer.getTree().getItemCount() > 0);
1235        deselectAllButton.setEnabled(enabled
1236                && typesViewer.getTree().getItemCount() > 0);
1237
1238        anyResourceButton.setEnabled(enabled);
1239        anyResourceInSameProjectButton.setEnabled(enabled);
1240        selectedResourceButton.setEnabled(enabled);
1241        selectedResourceAndChildrenButton.setEnabled(enabled);
1242        workingSetGroup.setEnabled(enabled);
1243    }
1244
1245    /**
1246     * Updates the given filter from the UI state.
1247     */
1248    protected final void updateFilterFromUI() {
1249
1250        MarkerFilter filter = getSelectedFilter();
1251
1252        if (filter == null) {
1253            updateEnabledState(false);
1254            return;
1255        }
1256
1257        updateFilterFromUI(filter);
1258    }
1259
1260    /**
1261     * Update the selected filter from the UI.
1262     *
1263     * @param filter
1264     */
1265    protected void updateFilterFromUI(MarkerFilter filter) {
1266
1267        filter.setSelectedTypes(getSelectedTypes());
1268
1269        if (selectedResourceButton.getSelection()) {
1270            filter.setOnResource(MarkerFilter.ON_SELECTED_ONLY);
1271        } else if (selectedResourceAndChildrenButton.getSelection()) {
1272            filter.setOnResource(MarkerFilter.ON_SELECTED_AND_CHILDREN);
1273        } else if (anyResourceInSameProjectButton.getSelection()) {
1274            filter.setOnResource(MarkerFilter.ON_ANY_IN_SAME_CONTAINER);
1275        } else if (workingSetGroup.getSelection()) {
1276            filter.setOnResource(MarkerFilter.ON_WORKING_SET);
1277        } else {
1278            filter.setOnResource(MarkerFilter.ON_ANY);
1279        }
1280
1281        filter.setWorkingSet(workingSetGroup.getWorkingSet());
1282    }
1283
1284    /**
1285     * Updates the UI state from the given filter.
1286     */
1287    protected final void updateUIFromFilter() {
1288
1289        MarkerFilter filter = getSelectedFilter();
1290
1291        if (filter == null) {
1292            updateEnabledState(false);
1293            return;
1294        }
1295
1296        updateUIWithFilter(filter);
1297    }
1298
1299    /**
1300     * Update the UI with the contents of filter.
1301     *
1302     * @param filter
1303     */
1304    protected void updateUIWithFilter(MarkerFilter filter) {
1305        setSelectedTypes(filter.getSelectedTypes());
1306
1307        int on = filter.getOnResource();
1308        anyResourceButton.setSelection(on == MarkerFilter.ON_ANY);
1309        anyResourceInSameProjectButton
1310                .setSelection(on == MarkerFilter.ON_ANY_IN_SAME_CONTAINER);
1311        selectedResourceButton
1312                .setSelection(on == MarkerFilter.ON_SELECTED_ONLY);
1313        selectedResourceAndChildrenButton
1314                .setSelection(on == MarkerFilter.ON_SELECTED_AND_CHILDREN);
1315        workingSetGroup.setSelection(on == MarkerFilter.ON_WORKING_SET);
1316        workingSetGroup.setWorkingSet(filter.getWorkingSet());
1317
1318        updateEnabledState(true);
1319    }
1320
1321    /**
1322     * @return <code>true</code> if the dirty flag has been set otherwise
1323     * <code>false</code>.
1324     */
1325    boolean isDirty() {
1326        return dirty;
1327    }
1328
1329    /**
1330     * Marks the dialog as dirty.
1331     */
1332    void markDirty() {
1333        dirty = true;
1334    }
1335
1336    /**
1337     * Set the marker filter.
1338     *
1339     * @param newFilter
1340     */
1341    public void setFilter(MarkerFilter newFilter) {
1342        setFilters(new MarkerFilter[] { newFilter });
1343        updateUIFromFilter();
1344    }
1345
1346    /**
1347     * @return the MarkerFilters associated with the dialog.
1348     */
1349    public MarkerFilter[] getFilters() {
1350        return filters;
1351    }
1352
1353    /**
1354     * A selection has occured on one of the checkboxes or combos. Update.
1355     *
1356     */
1357    protected void updateForSelection() {
1358        updateEnabledState(true);
1359        markDirty();
1360    }
1361
1362    /**
1363     * Get all of the marker types avilable for the filter
1364     *
1365     * @param selected
1366     * @return Object[]
1367     */
1368    Object [] getRootEntries(MarkerFilter selected) {
1369
1370        List roots = selected.getRootTypes();
1371        List markerNodes = new ArrayList ();
1372        HashMap categories = new HashMap ();
1373        for (int i = 0; i < roots.size(); i++) {
1374            Object obj = roots.get(i);
1375            buildTypeTree(markerNodes, obj, categories);
1376        }
1377        return markerNodes.toArray();
1378    }
1379
1380    /**
1381     * Build the list of types and categories from the supplied object
1382     *
1383     * @param elements
1384     * @param obj
1385     * @param categories
1386     */
1387    private void buildTypeTree(List elements, Object obj, HashMap categories) {
1388        if (obj instanceof MarkerType) {
1389
1390            MarkerType markerType = (MarkerType) obj;
1391
1392            String categoryName = MarkerSupportRegistry.getInstance()
1393                    .getCategory(markerType.getId());
1394
1395            if (categoryName == null) {
1396                elements.add(new MarkerTypeNode(markerType));
1397            } else {
1398                MarkerCategory category;
1399                if (categories.containsKey(categoryName)) {
1400                    category = (MarkerCategory) categories.get(categoryName);
1401                } else {
1402                    category = new MarkerCategory(categoryName);
1403                    categories.put(categoryName, category);
1404                    elements.add(category);
1405                }
1406                MarkerTypeNode node = new MarkerTypeNode(markerType);
1407                category.add(node);
1408            }
1409
1410            MarkerType[] subTypes = ((MarkerType) obj).getSubtypes();
1411            for (int j = 0; j < subTypes.length; j++) {
1412                buildTypeTree(elements, subTypes[j], categories);
1413            }
1414        }
1415    }
1416
1417    /**
1418     * Grey check the parent if required
1419     *
1420     * @param element
1421     * @param checked
1422     */
1423    private void setParentCheckState(Object element, boolean checked) {
1424        Object parent = typesContentProvider.getParent(element);
1425        if (parent == null) {
1426            return;
1427        }
1428        Object [] children = typesContentProvider.getChildren(parent);
1429        if (children.length == 0) {
1430            return;
1431        }
1432        if (checked) {// at least one is checked
1433 for (int i = 0; i < children.length; i++) {
1434                Object object = children[i];
1435                if (!typesViewer.getChecked(object)) {
1436                    typesViewer.setGrayChecked(parent, true);
1437                    return;
1438                }
1439            }
1440            // All checked - check the parent
1441 typesViewer.setChecked(parent, true);
1442        } else {
1443            for (int i = 0; i < children.length; i++) {
1444                Object object = children[i];
1445                if (typesViewer.getChecked(object)) {
1446                    typesViewer.setGrayChecked(parent, true);
1447                    return;
1448                }
1449            }
1450            // All checked - check the parent
1451 typesViewer.setChecked(parent, false);
1452        }
1453
1454    }
1455
1456    /**
1457     * Set the check state of the children of element to checked.
1458     *
1459     * @param element
1460     * @param checked
1461     */
1462    private void setChildrenChecked(Object element, boolean checked) {
1463        Object [] children = typesContentProvider.getChildren(element);
1464        if (children.length > 0) {
1465            for (int i = 0; i < children.length; i++) {
1466                typesViewer.setChecked(children[i], checked);
1467            }
1468        }
1469    }
1470
1471    /**
1472     * Create the buttons for selecting the filters.
1473     *
1474     * @param listArea
1475     */
1476    protected void createFilterSelectButtons(Composite listArea) {
1477        Composite buttons = new Composite(listArea, SWT.NONE);
1478        GridLayout buttonLayout = new GridLayout(2, false);
1479        buttonLayout.marginWidth = 0;
1480        buttons.setLayout(buttonLayout);
1481
1482        createButton(buttons, SELECT_ALL_FILTERS_ID,
1483                MarkerMessages.filtersDialog_selectAll, false);
1484        createButton(buttons, DESELECT_ALL_FILTERS_ID,
1485                MarkerMessages.filtersDialog_deselectAll, false);
1486    }
1487
1488}
1489

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags