updated build.xml
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / ui / preferences / OptionsConfigurationBlock.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpdt.internal.ui.preferences;
12
13 import java.util.ArrayList;
14 import java.util.HashMap;
15 import java.util.Hashtable;
16 import java.util.Iterator;
17 import java.util.Map;
18 import java.util.StringTokenizer;
19 import java.util.Map.Entry;
20
21 import net.sourceforge.phpdt.core.IJavaProject;
22 import net.sourceforge.phpdt.core.JavaCore;
23 import net.sourceforge.phpdt.internal.ui.wizards.IStatusChangeListener;
24 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
25
26 import org.eclipse.core.resources.IncrementalProjectBuilder;
27 import org.eclipse.core.resources.ResourcesPlugin;
28 import org.eclipse.core.runtime.CoreException;
29 import org.eclipse.core.runtime.IProgressMonitor;
30 import org.eclipse.core.runtime.IStatus;
31 import org.eclipse.core.runtime.OperationCanceledException;
32 import org.eclipse.core.runtime.Status;
33 import org.eclipse.core.runtime.SubProgressMonitor;
34 import org.eclipse.core.runtime.jobs.Job;
35 import org.eclipse.jface.dialogs.IDialogConstants;
36 import org.eclipse.jface.dialogs.MessageDialog;
37 import org.eclipse.swt.SWT;
38 import org.eclipse.swt.events.ModifyEvent;
39 import org.eclipse.swt.events.ModifyListener;
40 import org.eclipse.swt.events.SelectionEvent;
41 import org.eclipse.swt.events.SelectionListener;
42 import org.eclipse.swt.layout.GridData;
43 import org.eclipse.swt.layout.GridLayout;
44 import org.eclipse.swt.widgets.Button;
45 import org.eclipse.swt.widgets.Combo;
46 import org.eclipse.swt.widgets.Composite;
47 import org.eclipse.swt.widgets.Control;
48 import org.eclipse.swt.widgets.Label;
49 import org.eclipse.swt.widgets.Shell;
50 import org.eclipse.swt.widgets.Text;
51 import org.eclipse.swt.widgets.Widget;
52
53 /**
54  * Abstract options configuration block providing a general implementation for setting up
55  * an options configuration page.
56  * 
57  * @since 2.1
58  */
59 public abstract class OptionsConfigurationBlock {
60
61         protected static class ControlData {
62                 private String fKey;
63                 private String[] fValues;
64                 
65                 public ControlData(String key, String[] values) {
66                         fKey= key;
67                         fValues= values;
68                 }
69                 
70                 public String getKey() {
71                         return fKey;
72                 }
73                 
74                 public String getValue(boolean selection) {
75                         int index= selection ? 0 : 1;
76                         return fValues[index];
77                 }
78                 
79                 public String getValue(int index) {
80                         return fValues[index];
81                 }               
82                 
83                 public int getSelection(String value) {
84                         if (value != null) {
85                                 for (int i= 0; i < fValues.length; i++) {
86                                         if (value.equals(fValues[i])) {
87                                                 return i;
88                                         }
89                                 }
90                         }
91                         return fValues.length -1; // assume the last option is the least severe
92                 }
93         }
94         
95         
96         protected Map fWorkingValues;
97
98         protected ArrayList fCheckBoxes;
99         protected ArrayList fComboBoxes;
100         protected ArrayList fTextBoxes;
101         protected HashMap fLabels;
102         
103         private SelectionListener fSelectionListener;
104         private ModifyListener fTextModifyListener;
105
106         protected IStatusChangeListener fContext;
107         protected IJavaProject fProject; // project or null
108         protected String[] fAllKeys;
109         
110         private Shell fShell;
111
112         public OptionsConfigurationBlock(IStatusChangeListener context, IJavaProject project, String[] allKeys) {
113                 fContext= context;
114                 fProject= project;
115                 fAllKeys= allKeys;
116                 
117                 fWorkingValues= getOptions(true);
118                 testIfOptionsComplete(fWorkingValues, allKeys);
119                 
120                 fCheckBoxes= new ArrayList();
121                 fComboBoxes= new ArrayList();
122                 fTextBoxes= new ArrayList(2);
123                 fLabels= new HashMap();
124         }
125         
126         private void testIfOptionsComplete(Map workingValues, String[] allKeys) {
127                 for (int i= 0; i < allKeys.length; i++) {
128                         if (workingValues.get(allKeys[i]) == null) {
129                                 PHPeclipsePlugin.logErrorMessage("preference option missing: " + allKeys[i] + " (" + this.getClass().getName() +')');  //$NON-NLS-1$//$NON-NLS-2$
130                         }
131                 }
132         }
133
134         protected Map getOptions(boolean inheritJavaCoreOptions) {
135                 if (fProject != null) {
136                         return fProject.getOptions(inheritJavaCoreOptions);
137                 } else {
138                         return JavaCore.getOptions();
139                 }       
140         }
141         
142         protected Map getDefaultOptions() {
143                 return JavaCore.getDefaultOptions();
144         }       
145         
146         public final boolean hasProjectSpecificOptions() {
147                 if (fProject != null) {
148                         Map settings= fProject.getOptions(false);
149                         String[] allKeys= fAllKeys;
150                         for (int i= 0; i < allKeys.length; i++) {
151                                 if (settings.get(allKeys[i]) != null) {
152                                         return true;
153                                 }
154                         }
155                 }
156                 return false;
157         }       
158                 
159         protected void setOptions(Map map) {
160                 if (fProject != null) {
161                         Map oldOptions= fProject.getOptions(false);
162                         fProject.setOptions(map);
163                         firePropertyChangeEvents(oldOptions, map);
164                 } else {
165                         JavaCore.setOptions((Hashtable) map);
166                 }       
167         } 
168         
169         /**
170          * Computes the differences between the given old and new options and fires corresponding
171          * property change events on the Java plugin's mockup preference store.
172          * @param oldOptions The old options
173          * @param newOptions The new options
174          */
175         private void firePropertyChangeEvents(Map oldOptions, Map newOptions) {
176                 oldOptions= new HashMap(oldOptions);
177                 Object source= fProject.getProject();
178                 MockupPreferenceStore store= PHPeclipsePlugin.getDefault().getMockupPreferenceStore();
179                 Iterator iter= newOptions.entrySet().iterator();
180                 while (iter.hasNext()) {
181                         Entry entry= (Entry) iter.next();
182                 
183                         String name= (String) entry.getKey();
184                         Object oldValue= oldOptions.get(name);
185                         Object newValue= entry.getValue();
186                         
187                         if ((oldValue != null && !oldValue.equals(newValue)) || (oldValue == null && newValue != null))
188                                 store.firePropertyChangeEvent(source, name, oldValue, newValue);
189                         oldOptions.remove(name);
190                 }
191                 
192                 iter= oldOptions.entrySet().iterator();
193                 while (iter.hasNext()) {
194                         Entry entry= (Entry) iter.next();
195                         store.firePropertyChangeEvent(source, (String) entry.getKey(), entry.getValue(), null);
196                 }
197         }
198
199         protected Shell getShell() {
200                 return fShell;
201         }
202         
203         protected void setShell(Shell shell) {
204                 fShell= shell;
205         }       
206         
207         protected abstract Control createContents(Composite parent);
208         
209         protected Button addCheckBox(Composite parent, String label, String key, String[] values, int indent) {
210                 ControlData data= new ControlData(key, values);
211                 
212                 GridData gd= new GridData(GridData.HORIZONTAL_ALIGN_FILL);
213                 gd.horizontalSpan= 3;
214                 gd.horizontalIndent= indent;
215                 
216                 Button checkBox= new Button(parent, SWT.CHECK);
217                 checkBox.setText(label);
218                 checkBox.setData(data);
219                 checkBox.setLayoutData(gd);
220                 checkBox.addSelectionListener(getSelectionListener());
221                 
222                 String currValue= (String)fWorkingValues.get(key);
223                 checkBox.setSelection(data.getSelection(currValue) == 0);
224                 
225                 fCheckBoxes.add(checkBox);
226                 
227                 return checkBox;
228         }
229         
230         protected Combo addComboBox(Composite parent, String label, String key, String[] values, String[] valueLabels, int indent) {
231                 ControlData data= new ControlData(key, values);
232                 
233                 GridData gd= new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
234                 gd.horizontalIndent= indent;
235                                 
236                 Label labelControl= new Label(parent, SWT.LEFT | SWT.WRAP);
237                 labelControl.setText(label);
238                 labelControl.setLayoutData(gd);
239                 
240                 Combo comboBox= new Combo(parent, SWT.READ_ONLY);
241                 comboBox.setItems(valueLabels);
242                 comboBox.setData(data);
243                 comboBox.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
244                 comboBox.addSelectionListener(getSelectionListener());
245                 
246                 fLabels.put(comboBox, labelControl);
247                 
248                 Label placeHolder= new Label(parent, SWT.NONE);
249                 placeHolder.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
250                 
251                 String currValue= (String)fWorkingValues.get(key);      
252                 comboBox.select(data.getSelection(currValue));
253                 
254                 fComboBoxes.add(comboBox);
255                 return comboBox;
256         }
257         
258         protected void addInversedComboBox(Composite parent, String label, String key, String[] values, String[] valueLabels, int indent) {
259                 ControlData data= new ControlData(key, values);
260                 
261                 GridData gd= new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
262                 gd.horizontalIndent= indent;
263                 gd.horizontalSpan= 3;
264                 
265                 Composite composite= new Composite(parent, SWT.NONE);
266                 GridLayout layout= new GridLayout();
267                 layout.marginHeight= 0;
268                 layout.marginWidth= 0;
269                 layout.numColumns= 2;
270                 composite.setLayout(layout);
271                 composite.setLayoutData(gd);
272                 
273                 Combo comboBox= new Combo(composite, SWT.READ_ONLY);
274                 comboBox.setItems(valueLabels);
275                 comboBox.setData(data);
276                 comboBox.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
277                 comboBox.addSelectionListener(getSelectionListener());
278                 
279                 Label labelControl= new Label(composite, SWT.LEFT | SWT.WRAP);
280                 labelControl.setText(label);
281                 labelControl.setLayoutData(new GridData());
282                 
283                 fLabels.put(comboBox, labelControl);
284                 
285                 String currValue= (String)fWorkingValues.get(key);      
286                 comboBox.select(data.getSelection(currValue));
287                 
288                 fComboBoxes.add(comboBox);
289         }
290         
291         protected Text addTextField(Composite parent, String label, String key, int indent, int widthHint) {    
292                 Label labelControl= new Label(parent, SWT.NONE);
293                 labelControl.setText(label);
294                 labelControl.setLayoutData(new GridData());
295                                 
296                 Text textBox= new Text(parent, SWT.BORDER | SWT.SINGLE);
297                 textBox.setData(key);
298                 textBox.setLayoutData(new GridData());
299                 
300                 fLabels.put(textBox, labelControl);
301                 
302                 String currValue= (String) fWorkingValues.get(key);     
303                 if (currValue != null) {
304                         textBox.setText(currValue);
305                 }
306                 textBox.addModifyListener(getTextModifyListener());
307
308                 GridData data= new GridData(GridData.HORIZONTAL_ALIGN_FILL);
309                 if (widthHint != 0) {
310                         data.widthHint= widthHint;
311                 }
312                 data.horizontalIndent= indent;
313                 data.horizontalSpan= 2;
314                 textBox.setLayoutData(data);
315
316                 fTextBoxes.add(textBox);
317                 return textBox;
318         }       
319
320         protected SelectionListener getSelectionListener() {
321                 if (fSelectionListener == null) {
322                         fSelectionListener= new SelectionListener() {
323                                 public void widgetDefaultSelected(SelectionEvent e) {}
324         
325                                 public void widgetSelected(SelectionEvent e) {
326                                         controlChanged(e.widget);
327                                 }
328                         };
329                 }
330                 return fSelectionListener;
331         }
332         
333         protected ModifyListener getTextModifyListener() {
334                 if (fTextModifyListener == null) {
335                         fTextModifyListener= new ModifyListener() {
336                                 public void modifyText(ModifyEvent e) {
337                                         textChanged((Text) e.widget);
338                                 }
339                         };
340                 }
341                 return fTextModifyListener;
342         }               
343         
344         protected void controlChanged(Widget widget) {
345                 ControlData data= (ControlData) widget.getData();
346                 String newValue= null;
347                 if (widget instanceof Button) {
348                         newValue= data.getValue(((Button)widget).getSelection());                       
349                 } else if (widget instanceof Combo) {
350                         newValue= data.getValue(((Combo)widget).getSelectionIndex());
351                 } else {
352                         return;
353                 }
354                 fWorkingValues.put(data.getKey(), newValue);
355                 
356                 validateSettings(data.getKey(), newValue);
357         }
358         
359         protected void textChanged(Text textControl) {
360                 String key= (String) textControl.getData();
361                 String number= textControl.getText();
362                 fWorkingValues.put(key, number);
363                 validateSettings(key, number);
364         }       
365
366         protected boolean checkValue(String key, String value) {
367                 return value.equals(fWorkingValues.get(key));
368         }
369         
370         /* (non-javadoc)
371          * Update fields and validate.
372          * @param changedKey Key that changed, or null, if all changed.
373          */     
374         protected abstract void validateSettings(String changedKey, String newValue);
375         
376         
377         protected String[] getTokens(String text, String separator) {
378                 StringTokenizer tok= new StringTokenizer(text, separator); //$NON-NLS-1$
379                 int nTokens= tok.countTokens();
380                 String[] res= new String[nTokens];
381                 for (int i= 0; i < res.length; i++) {
382                         res[i]= tok.nextToken().trim();
383                 }
384                 return res;
385         }       
386
387         
388         public boolean performOk(boolean enabled) {
389                 String[] allKeys= fAllKeys;
390                 Map actualOptions= getOptions(false);
391                 
392                 // preserve other options
393                 boolean hasChanges= false;
394                 for (int i= 0; i < allKeys.length; i++) {
395                         String key= allKeys[i];
396                         String oldVal= (String) actualOptions.get(key);
397                         String val= null;
398                         if (enabled) {
399                                 val= (String) fWorkingValues.get(key);
400                                 if (val != null && !val.equals(oldVal)) {
401                                         hasChanges= true;
402                                         actualOptions.put(key, val);
403                                 }
404                         } else {
405                                 if (oldVal != null) {
406                                         actualOptions.remove(key);
407                                         hasChanges= true;
408                                 }
409                         }
410                 }
411                 
412                 
413                 if (hasChanges) {
414                         boolean doBuild= false;
415                         String[] strings= getFullBuildDialogStrings(fProject == null);
416                         if (strings != null) {
417                                 MessageDialog dialog= new MessageDialog(getShell(), strings[0], null, strings[1], MessageDialog.QUESTION, new String[] { IDialogConstants.YES_LABEL, IDialogConstants.NO_LABEL, IDialogConstants.CANCEL_LABEL }, 2);
418                                 int res= dialog.open();
419                                 if (res == 0) {
420                                         doBuild= true;
421                                 } else if (res != 1) {
422                                         return false; // cancel pressed
423                                 }
424                         }
425                         setOptions(actualOptions);
426                         if (doBuild) {
427                                 boolean res= doFullBuild();
428                                 if (!res) {
429                                         return false;
430                                 }
431                         }
432                 }
433                 return true;
434         }
435         
436         protected abstract String[] getFullBuildDialogStrings(boolean workspaceSettings);
437                 
438         protected boolean doFullBuild() {
439                 
440                 Job buildJob = new Job(PreferencesMessages.getString("OptionsConfigurationBlock.job.title")){  //$NON-NLS-1$
441                         /* (non-Javadoc)
442                          * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
443                          */
444                         protected IStatus run(IProgressMonitor monitor) {
445                                 try {
446                                         if (fProject != null) {
447                                                 monitor.setTaskName(PreferencesMessages.getFormattedString("OptionsConfigurationBlock.buildproject.taskname", fProject.getElementName())); //$NON-NLS-1$
448                                                 fProject.getProject().build(IncrementalProjectBuilder.FULL_BUILD, new SubProgressMonitor(monitor,1));
449                                                 PHPeclipsePlugin.getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, new SubProgressMonitor(monitor,1));
450                                         } else {
451                                                 monitor.setTaskName(PreferencesMessages.getString("OptionsConfigurationBlock.buildall.taskname")); //$NON-NLS-1$
452                                                 PHPeclipsePlugin.getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, new SubProgressMonitor(monitor, 2));
453                                         }
454                                 } catch (CoreException e) {
455                                         return e.getStatus();
456                                 } catch (OperationCanceledException e) {
457                                         return Status.CANCEL_STATUS;
458                                 }
459                                 finally {
460                                         monitor.done();
461                                 }
462                                 return Status.OK_STATUS;
463                         }
464                         public boolean belongsTo(Object family) {
465                                 return ResourcesPlugin.FAMILY_MANUAL_BUILD == family;
466                         }
467                 };
468                 
469                 buildJob.setRule(ResourcesPlugin.getWorkspace().getRuleFactory().buildRule());
470                 buildJob.setUser(true); 
471                 buildJob.schedule();
472                 return true;
473         }               
474         
475         public void performDefaults() {
476                 fWorkingValues= getDefaultOptions();
477                 updateControls();
478                 validateSettings(null, null);
479         }
480         
481         protected void updateControls() {
482                 // update the UI
483                 for (int i= fCheckBoxes.size() - 1; i >= 0; i--) {
484                         updateCheckBox((Button) fCheckBoxes.get(i));
485                 }
486                 for (int i= fComboBoxes.size() - 1; i >= 0; i--) {
487                         updateCombo((Combo) fComboBoxes.get(i));
488                 }
489                 for (int i= fTextBoxes.size() - 1; i >= 0; i--) {
490                         updateText((Text) fTextBoxes.get(i));
491                 }
492         }
493         
494         protected void updateCombo(Combo curr) {
495                 ControlData data= (ControlData) curr.getData();
496                 
497                 String currValue= (String) fWorkingValues.get(data.getKey());   
498                 curr.select(data.getSelection(currValue));                                      
499         }
500         
501         protected void updateCheckBox(Button curr) {
502                 ControlData data= (ControlData) curr.getData();
503                 
504                 String currValue= (String) fWorkingValues.get(data.getKey());   
505                 curr.setSelection(data.getSelection(currValue) == 0);                                           
506         }
507         
508         protected void updateText(Text curr) {
509                 String key= (String) curr.getData();
510                 
511                 String currValue= (String) fWorkingValues.get(key);
512                 if (currValue != null) {
513                         curr.setText(currValue);
514                 }
515         }
516         
517         protected Button getCheckBox(String key) {
518                 for (int i= fCheckBoxes.size() - 1; i >= 0; i--) {
519                         Button curr= (Button) fCheckBoxes.get(i);
520                         ControlData data= (ControlData) curr.getData();
521                         if (key.equals(data.getKey())) {
522                                 return curr;
523                         }
524                 }
525                 return null;            
526         }
527         
528         protected Combo getComboBox(String key) {
529                 for (int i= fComboBoxes.size() - 1; i >= 0; i--) {
530                         Combo curr= (Combo) fComboBoxes.get(i);
531                         ControlData data= (ControlData) curr.getData();
532                         if (key.equals(data.getKey())) {
533                                 return curr;
534                         }
535                 }
536                 return null;            
537         }
538         
539         protected void setComboEnabled(String key, boolean enabled) {
540                 Combo combo= getComboBox(key);
541                 Label label= (Label) fLabels.get(combo);
542                 combo.setEnabled(enabled);
543                 label.setEnabled(enabled);
544         }
545         
546         
547         
548 }