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