a378264d777cb00b105de027f83d3f8327338ae7
[phpeclipse.git] /
1 package net.sourceforge.phpdt.internal.ui.dialog;
2
3 import net.sourceforge.phpdt.internal.ui.util.FilteredList;
4
5 import org.eclipse.core.runtime.IStatus;
6 import org.eclipse.jface.dialogs.IDialogConstants;
7 import org.eclipse.jface.util.Assert;
8 import org.eclipse.jface.viewers.ILabelProvider;
9 import org.eclipse.swt.SWT;
10 import org.eclipse.swt.custom.BusyIndicator;
11 import org.eclipse.swt.events.KeyEvent;
12 import org.eclipse.swt.events.KeyListener;
13 import org.eclipse.swt.events.SelectionEvent;
14 import org.eclipse.swt.events.SelectionListener;
15 import org.eclipse.swt.layout.GridData;
16 import org.eclipse.swt.widgets.Composite;
17 import org.eclipse.swt.widgets.Event;
18 import org.eclipse.swt.widgets.Label;
19 import org.eclipse.swt.widgets.Listener;
20 import org.eclipse.swt.widgets.Shell;
21 import org.eclipse.swt.widgets.Text;
22
23 /**
24  * An abstract class to select elements out of a list of elements.
25  */
26 public abstract class AbstractElementListSelectionDialog extends SelectionStatusDialog {
27         
28         private ILabelProvider fRenderer;
29         private boolean fIgnoreCase= true;
30         private boolean fIsMultipleSelection= false;
31         private boolean fMatchEmptyString= true;
32         private boolean fAllowDuplicates= true;
33         
34         private Label fMessage;
35
36         protected FilteredList fFilteredList;
37         private Text fFilterText;
38         
39         private ISelectionValidator fValidator; 
40         private String fFilter= null;
41         
42         private String fEmptyListMessage= ""; //$NON-NLS-1$
43         private String fEmptySelectionMessage= ""; //$NON-NLS-1$
44                 
45         private int fWidth= 60;
46         private int fHeight= 18;
47         
48         private Object[] fSelection= new Object[0];
49         
50         /**
51          * Constructs a list selection dialog.
52          * @param renderer The label renderer used
53          * @param ignoreCase Decides if the match string ignores lower/upppr case
54          * @param multipleSelection Allow multiple selection     
55          */
56         protected AbstractElementListSelectionDialog(Shell parent, ILabelProvider renderer)
57         {
58                 super(parent);          
59                 fRenderer= renderer;
60                 
61                 int shellStyle= getShellStyle();
62                 setShellStyle(shellStyle | SWT.MAX | SWT.RESIZE);
63         }
64
65         /**
66          * Handles default selection (double click).
67          * By default, the OK button is pressed.
68          */     
69         protected void handleDefaultSelected() {
70                 if (validateCurrentSelection())
71                         buttonPressed(IDialogConstants.OK_ID);
72         }
73         
74         /**
75          * Specifies if sorting, filtering and folding is case sensitive.
76          */
77         public void setIgnoreCase(boolean ignoreCase) {
78                 fIgnoreCase= ignoreCase;
79         }
80         
81         /**
82          * Returns if sorting, filtering and folding is case sensitive.
83          */
84         public boolean isCaseIgnored() {
85                 return fIgnoreCase;
86         }
87         
88         /**
89          * Specifies whether everything or nothing should be filtered on
90          * empty filter string.
91          */
92         public void setMatchEmptyString(boolean matchEmptyString) {
93                 fMatchEmptyString= matchEmptyString;
94         }
95         
96         /**
97          * Specifies if multiple selection is allowed.
98          */
99         public void setMultipleSelection(boolean multipleSelection) {
100                 fIsMultipleSelection= multipleSelection;
101         }
102
103         /**
104          * Specifies whether duplicate entries are displayed or not.
105          */
106         public void setAllowDuplicates(boolean allowDuplicates) {
107                 fAllowDuplicates= allowDuplicates;
108         }
109         
110         /**
111          * Sets the list size in unit of characters.
112          * @param width  the width of the list.
113          * @param height the height of the list.
114          */
115         public void setSize(int width, int height) {
116                 fWidth= width;
117                 fHeight= height;
118         }
119         
120         /**
121          * Sets the message to be displayed if the list is empty.
122          * @param message the message to be displayed.
123          */
124         public void setEmptyListMessage(String message) {
125                 fEmptyListMessage= message;
126         }
127
128         /**
129          * Sets the message to be displayed if the selection is empty.
130          * @param message the message to be displayed.
131          */
132         public void setEmptySelectionMessage(String message) {
133                 fEmptySelectionMessage= message;
134         }
135         
136         /**
137          * Sets an optional validator to check if the selection is valid.
138          * The validator is invoked whenever the selection changes.
139          * @param validator the validator to validate the selection.
140          */
141         public void setValidator(ISelectionValidator validator) {
142                 fValidator= validator;
143         }       
144         
145         /**
146          * Sets the elements of the list (widget).
147          * To be called within open().
148          * @param elements the elements of the list.
149          */
150         protected void setListElements(Object[] elements) {
151                 Assert.isNotNull(fFilteredList);
152                 fFilteredList.setElements(elements);
153         }
154
155         /**
156          * Sets the filter pattern.
157          * @param filter the filter pattern.
158          */
159         public void setFilter(String filter) {
160                 if (fFilterText == null)
161                         fFilter= filter;
162                 else
163                         fFilterText.setText(filter);
164         } 
165         
166         /**
167          * Returns the current filter pattern.
168          * @return returns the current filter pattern or <code>null<code> if filter was not set.
169          */
170         public String getFilter() {
171                 if (fFilteredList == null)
172                         return fFilter;
173                 else
174                         return fFilteredList.getFilter();
175         }
176
177         /**
178          * Returns the indices referring the current selection.
179          * To be called within open().
180          * @return returns the indices of the current selection.
181          */
182         protected int[] getSelectionIndices() {
183                 Assert.isNotNull(fFilteredList);
184                 return fFilteredList.getSelectionIndices();
185         }
186
187         /**
188          * Returns an index referring the first current selection.
189          * To be called within open().
190          * @return returns the indices of the current selection.
191          */
192         protected int getSelectionIndex() {
193                 Assert.isNotNull(fFilteredList);
194                 return fFilteredList.getSelectionIndex();
195         }
196         
197         /**
198          * Sets the selection referenced by an array of elements.
199          * To be called within open().
200          * @param selection the indices of the selection.
201          */
202         protected void setSelection(Object[] selection) {
203                 Assert.isNotNull(fFilteredList);
204                 fFilteredList.setSelection(selection);
205         }
206         
207         /**
208          * Returns an array of the currently selected elements.
209          * To be called within or after open().
210          * @return returns an array of the currently selected elements.
211          */     
212         protected Object[] getSelectedElements() {
213                 Assert.isNotNull(fFilteredList);
214                 return fFilteredList.getSelection();
215         }
216
217         /**
218          * Returns all elements which are folded together to one entry in the list.
219          * @param  index the index selecting the entry in the list.
220          * @return returns an array of elements folded together.
221          */
222         public Object[] getFoldedElements(int index) {
223                 Assert.isNotNull(fFilteredList);
224                 return fFilteredList.getFoldedElements(index);
225         }
226                  
227         /**
228          * Creates the message text widget and sets layout data.
229          * @param composite the parent composite of the message area.
230          */
231         protected Label createMessageArea(Composite composite) {
232                 Label label= super.createMessageArea(composite);
233
234                 GridData data= new GridData();
235                 data.grabExcessVerticalSpace= false;
236                 data.grabExcessHorizontalSpace= true;
237                 data.horizontalAlignment= GridData.FILL;
238                 data.verticalAlignment= GridData.BEGINNING;
239                 label.setLayoutData(data);
240                 
241                 fMessage= label;
242                 
243                 return label;
244         }       
245
246         /**
247          * Handles a selection changed event.
248          * By default, the current selection is validated.
249          */
250         protected void handleSelectionChanged() {
251                 validateCurrentSelection();
252         }
253         
254         /**
255          * Validates the current selection and updates the status line
256          * accordingly.
257          */
258         protected boolean validateCurrentSelection() {
259                 Assert.isNotNull(fFilteredList);
260
261                 IStatus status;
262                 Object[] elements= getSelectedElements();
263
264                 if (elements.length > 0) {
265                         if (fValidator != null) {
266                                 status= fValidator.validate(elements);
267                         } else {
268                                 status= new StatusInfo();
269                         }
270                 } else {                        
271                         if (fFilteredList.isEmpty()) {
272                                 status= new StatusInfo(IStatus.ERROR, fEmptyListMessage);
273                         } else {
274                                 status= new StatusInfo(IStatus.ERROR, fEmptySelectionMessage);
275                         }
276                 }
277
278                 updateStatus(status);
279                 
280                 return status.isOK();
281         }
282
283         /*
284          * @see Dialog#cancelPressed
285          */
286         protected void cancelPressed() {
287                 setResult(null);
288                 super.cancelPressed();
289         }       
290
291         /**
292          * Creates a filtered list.
293          * @param parent the parent composite.
294          * @return returns the filtered list widget.
295          */
296         protected FilteredList createFilteredList(Composite parent) {
297                 int flags= SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL |
298                         (fIsMultipleSelection ? SWT.MULTI : SWT.SINGLE);
299                         
300                 FilteredList list= new FilteredList(parent, flags, fRenderer,
301                         fIgnoreCase, fAllowDuplicates, fMatchEmptyString);
302
303                 GridData data= new GridData();
304                 data.widthHint= convertWidthInCharsToPixels(fWidth);
305                 data.heightHint= convertHeightInCharsToPixels(fHeight);
306                 data.grabExcessVerticalSpace= true;
307                 data.grabExcessHorizontalSpace= true;
308                 data.horizontalAlignment= GridData.FILL;
309                 data.verticalAlignment= GridData.FILL;
310                 list.setLayoutData(data);
311                 
312                 list.setFilter((fFilter == null ? "" : fFilter)); //$NON-NLS-1$         
313
314                 list.addSelectionListener(new SelectionListener() {
315                         public void widgetDefaultSelected(SelectionEvent e) {
316                                 handleDefaultSelected();
317                         }
318                         public void widgetSelected(SelectionEvent e) {
319                                 handleWidgetSelected();
320                         }
321                 });
322
323                 fFilteredList= list;            
324
325                 return list;            
326         }
327
328         // 3515 
329         private void handleWidgetSelected() {
330                 Object[] newSelection= fFilteredList.getSelection();
331                 
332                 if (newSelection.length != fSelection.length) {
333                         fSelection= newSelection;
334                         handleSelectionChanged();
335                 } else {
336                         for (int i= 0; i != newSelection.length; i++) {
337                                 if (!newSelection[i].equals(fSelection[i])) {
338                                         fSelection= newSelection;
339                                         handleSelectionChanged();
340                                         break;
341                                 }
342                         }
343                 }               
344         }
345
346         protected Text createFilterText(Composite parent) {
347                 Text text= new Text(parent, SWT.BORDER);
348
349                 GridData data= new GridData();
350                 data.grabExcessVerticalSpace= false;
351                 data.grabExcessHorizontalSpace= true;
352                 data.horizontalAlignment= GridData.FILL;
353                 data.verticalAlignment= GridData.BEGINNING;
354                 text.setLayoutData(data);
355
356                 text.setText((fFilter == null ? "" : fFilter)); //$NON-NLS-1$
357                 
358                 Listener listener= new Listener() {
359                         public void handleEvent(Event e) {
360                                 fFilteredList.setFilter(fFilterText.getText());
361                         }
362                 };              
363                 text.addListener(SWT.Modify, listener);
364
365                 text.addKeyListener(new KeyListener() {
366                         public void keyPressed(KeyEvent e) {
367                                 if (e.keyCode == SWT.ARROW_DOWN)
368                                         fFilteredList.setFocus();
369                         }
370                         
371                         public void keyReleased(KeyEvent e) {}
372                 });
373
374                 fFilterText= text;
375                                 
376                 return text;
377         }
378
379         /*
380          * @see Window#open()
381          */
382         public int open() {
383                 BusyIndicator.showWhile(null, new Runnable() {
384                         public void run() {
385                                 access$superOpen();
386                         }
387                 });
388                 return getReturnCode();
389         }
390         
391         private void access$superOpen() {
392                 super.open();
393         } 
394         
395         /*
396          * @see Window#create(Shell)
397          */
398         public void create() {
399                 super.create();
400
401                 Assert.isNotNull(fFilteredList);
402
403         if (fFilteredList.isEmpty()) {
404                 handleEmptyList();
405         } else {
406                 validateCurrentSelection();
407                         fFilterText.selectAll();
408                         fFilterText.setFocus();
409         }
410         }
411         
412         /**
413          * Handles empty list by disabling widgets.
414          */
415         protected void handleEmptyList() {
416         fMessage.setEnabled(false);
417         fFilterText.setEnabled(false);
418         fFilteredList.setEnabled(false);                
419         }
420         
421 }