/*******************************************************************************
* Copyright (c) 2000, 2006 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Cameron Bateman/Oracle - adapted for use in JSF validation tooling
*******************************************************************************/
package org.eclipse.jst.jsf.ui.internal.validation;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ProjectScope;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.preferences.DefaultScope;
import org.eclipse.core.runtime.preferences.IScopeContext;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.MessageDialogWithToggle;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jst.jsf.core.internal.IJSFPreferenceModel;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
import org.eclipse.jst.jsf.ui.internal.JSFUiPlugin;
import org.eclipse.jst.jsf.validation.internal.Severity;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Link;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.ui.forms.events.ExpansionAdapter;
import org.eclipse.ui.forms.events.ExpansionEvent;
import org.eclipse.ui.forms.widgets.ExpandableComposite;
import org.eclipse.ui.preferences.IWorkbenchPreferenceContainer;
import org.eclipse.ui.preferences.IWorkingCopyManager;
import org.eclipse.ui.preferences.WorkingCopyManager;
import org.osgi.service.prefs.BackingStoreException;
/**
* Abstract options configuration block providing a general implementation for setting up
* an options configuration page.
*
* @since 2.1
*/
abstract class OptionsConfigurationBlock
{
/**
* The preference model to be used
*/
protected final IJSFPreferenceModel _prefs;
static final class Key
{
private String fQualifier;
private String fKey;
Key(String qualifier, String key) {
fQualifier= qualifier;
fKey= key;
}
/**
* @return the key name
*/
public String getName() {
return fKey;
}
// private IEclipsePreferences getNode(IScopeContext context, IWorkingCopyManager manager) {
// IEclipsePreferences node= context.getNode(fQualifier);
// if (manager != null) {
// return manager.getWorkingCopy(node);
// }
// return node;
//
// }
/**
* @param prefModel
* @param context
* @param manager
* @return the value stored for the key
*/
public Object getStoredValue(IJSFPreferenceModel prefModel, IScopeContext context, IWorkingCopyManager manager)
{
return prefModel.getStoredValueByKey(context, fKey);
}
/**
* @param prefModel
* @param context
* @param manager
* @return the stored value in prefModel under context for
* this key
*/
public Object getCurValue(IJSFPreferenceModel prefModel, IScopeContext context, IWorkingCopyManager manager) {
//return getNode(context, manager).get(fKey, null);
return prefModel.getValueByKey(context, fKey);
}
/**
* @param prefModel
* @param lookupOrder
* @param ignoreTopScope
* @param manager
* @return the stored value in the prefModelunder context
* using the list of lookupOrder for precedence of scopes
* in which to look. Return first found based on order in lookupOrder
*/
public Object getCurValue(IJSFPreferenceModel prefModel, IScopeContext[] lookupOrder, boolean ignoreTopScope, IWorkingCopyManager manager) {
for (int i= ignoreTopScope ? 1 : 0; i < lookupOrder.length; i++) {
Object value= getCurValue(prefModel, lookupOrder[i], manager);
if (value != null) {
return value;
}
}
return null;
}
/**
* Set the stored value
* @param prefModel
* @param context
* @param value
* @param manager
* @return the old value or null if none
*/
public Object setCurValue(IJSFPreferenceModel prefModel, IScopeContext context, Object value, IWorkingCopyManager manager) {
return prefModel.setValueByKey(context, fKey, value);
// if (value != null) {
// getNode(context, manager).put(fKey, value);
// } else {
// getNode(context, manager).remove(fKey);
// }
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
public String toString() {
return fQualifier + '/' + fKey;
}
/**
* @return the plugin qualifier
*/
public String getQualifier() {
return fQualifier;
}
}
static class ControlData {
private Key fKey;
private String[] fValues;
ControlData(Key key, String[] values) {
fKey= key;
fValues= values;
}
Key getKey() {
return fKey;
}
String getValue(boolean selection) {
int index= selection ? 0 : 1;
return fValues[index];
}
String getValue(int index) {
return fValues[index];
}
int getSelection(String value) {
if (value != null) {
for (int i= 0; i < fValues.length; i++) {
if (value.equals(fValues[i])) {
return i;
}
}
}
return fValues.length -1; // assume the last option is the least severe
}
}
private static final String REBUILD_COUNT_KEY= "preferences_build_requested"; //$NON-NLS-1$
private static final String SETTINGS_EXPANDED= "expanded"; //$NON-NLS-1$
private final ArrayList fCheckBoxes;
private final ArrayList fComboBoxes;
private final ArrayList fTextBoxes;
private final HashMap fLabels;
private final ArrayList fExpandedComposites;
private SelectionListener fSelectionListener;
private ModifyListener fTextModifyListener;
// TODO: protected IStatusChangeListener fContext;
private final IProject fProject; // project or null
private final Key[] fAllKeys;
private IScopeContext[] fLookupOrder;
private Shell fShell;
private final IWorkingCopyManager fManager;
private IWorkbenchPreferenceContainer fContainer;
private Map fDisabledProjectSettings; // null when project specific settings are turned off
private int fRebuildCount; /// used to prevent multiple dialogs that ask for a rebuild
OptionsConfigurationBlock(/*IStatusChangeListener context,*/IJSFPreferenceModel prefs, IProject project, Key[] allKeys, IWorkbenchPreferenceContainer container) {
//fContext= context;
fProject= project;
fAllKeys= allKeys;
fContainer= container;
_prefs = prefs;
if (container == null) {
fManager= new WorkingCopyManager();
} else {
fManager= container.getWorkingCopyManager();
}
if (fProject != null) {
fLookupOrder= new IScopeContext[] {
new ProjectScope(fProject),
new InstanceScope(),
new DefaultScope()
};
} else {
fLookupOrder= new IScopeContext[] {
new InstanceScope(),
new DefaultScope()
};
}
testIfOptionsComplete(allKeys);
if (fProject == null || hasProjectSpecificOptions(fProject)) {
fDisabledProjectSettings= null;
} else {
fDisabledProjectSettings= new IdentityHashMap();
for (int i= 0; i < allKeys.length; i++) {
Key curr= allKeys[i];
fDisabledProjectSettings.put(curr, curr.getCurValue(_prefs, fLookupOrder, false, fManager));
}
}
fCheckBoxes= new ArrayList();
fComboBoxes= new ArrayList();
fTextBoxes= new ArrayList(2);
fLabels= new HashMap();
fExpandedComposites= new ArrayList();
fRebuildCount= getRebuildCount();
}
/**
* @return the preference container
*/
protected final IWorkbenchPreferenceContainer getPreferenceContainer() {
return fContainer;
}
/**
* @param plugin
* @param key
* @return construct a new Key based on the on the plugin id and
* preference key
*/
protected static Key getKey(String plugin, String key) {
return new Key(plugin, key);
}
/**
* @param key
* @return construct a new Key for a JSF core plugin preference
*/
protected final static Key getJSFCoreKey(String key) {
return getKey(JSFCorePlugin.PLUGIN_ID, key);
}
private void testIfOptionsComplete(Key[] allKeys) {
for (int i= 0; i < allKeys.length; i++) {
if (allKeys[i].getCurValue(_prefs, fLookupOrder, false, fManager) == null) {
JSFUiPlugin.log(IStatus.ERROR, "preference option missing: " + allKeys[i] + " (" + this.getClass().getName() +')'); //$NON-NLS-1$//$NON-NLS-2$
}
}
}
private int getRebuildCount() {
return fManager.getWorkingCopy(new DefaultScope().getNode(JavaUI.ID_PLUGIN)).getInt(REBUILD_COUNT_KEY, 0);
}
private void incrementRebuildCount() {
fRebuildCount++;
fManager.getWorkingCopy(new DefaultScope().getNode(JavaUI.ID_PLUGIN)).putInt(REBUILD_COUNT_KEY, fRebuildCount);
}
// public void selectOption(String key, String qualifier) {
// for (int i= 0; i < fAllKeys.length; i++) {
// Key curr= fAllKeys[i];
// if (curr.getName().equals(key) && curr.getQualifier().equals(qualifier)) {
// selectOption(curr);
// }
// }
// }
//
// public void selectOption(Key key) {
// Control control= findControl(key);
// if (control != null) {
// if (!fExpandedComposites.isEmpty()) {
// ExpandableComposite expandable= getParentExpandableComposite(control);
// if (expandable != null) {
// for (int i= 0; i < fExpandedComposites.size(); i++) {
// ExpandableComposite curr= (ExpandableComposite) fExpandedComposites.get(i);
// curr.setExpanded(curr == expandable);
// }
// expandedStateChanged(expandable);
// }
// }
// control.setFocus();
// }
// }
/**
* @param project
* @return true if there are project specific overrides in the
* preferences for 'project'
*/
public final boolean hasProjectSpecificOptions(IProject project) {
if (project != null) {
IScopeContext projectContext= new ProjectScope(project);
Key[] allKeys= fAllKeys;
for (int i= 0; i < allKeys.length; i++) {
if (allKeys[i].getCurValue(_prefs, projectContext, fManager) != null) {
return true;
}
}
}
return false;
}
/**
* @return the shell hosting the UI
*/
protected Shell getShell() {
return fShell;
}
/**
* Set the shell hosting the UI.
* @param shell
*/
protected void setShell(Shell shell) {
fShell= shell;
}
/**
* @param parent
* @return the parent of the UI control to be created
*/
protected abstract Control createContents(Composite parent);
// protected Button addCheckBox(Composite parent, String label, Key key, String[] values, int indent) {
// ControlData data= new ControlData(key, values);
//
// GridData gd= new GridData(GridData.HORIZONTAL_ALIGN_FILL);
// gd.horizontalSpan= 3;
// gd.horizontalIndent= indent;
//
// Button checkBox= new Button(parent, SWT.CHECK);
// checkBox.setFont(JFaceResources.getDialogFont());
// checkBox.setText(label);
// checkBox.setData(data);
// checkBox.setLayoutData(gd);
// checkBox.addSelectionListener(getSelectionListener());
//
// makeScrollableCompositeAware(checkBox);
//
// String currValue= getValue(key);
// checkBox.setSelection(data.getSelection(currValue) == 0);
//
// fCheckBoxes.add(checkBox);
//
// return checkBox;
// }
/**
* @param parent
* @param label
* @param key
* @param values
* @param indent
* @param widthHint
* @param listener
* @return a check box styled button with a related link
*/
protected Button addCheckBoxWithLink(Composite parent, String label, Key key, String[] values, int indent, int widthHint, SelectionListener listener) {
ControlData data= new ControlData(key, values);
GridData gd= new GridData(GridData.FILL, GridData.FILL, true, false);
gd.horizontalSpan= 3;
gd.horizontalIndent= indent;
Composite composite= new Composite(parent, SWT.NONE);
GridLayout layout= new GridLayout();
layout.marginHeight= 0;
layout.marginWidth= 0;
layout.numColumns= 2;
composite.setLayout(layout);
composite.setLayoutData(gd);
Button checkBox= new Button(composite, SWT.CHECK);
checkBox.setFont(JFaceResources.getDialogFont());
checkBox.setData(data);
checkBox.setLayoutData(new GridData(GridData.FILL, GridData.BEGINNING, false, false));
checkBox.addSelectionListener(getSelectionListener());
gd= new GridData(GridData.FILL, GridData.CENTER, true, false);
gd.widthHint= widthHint;
Link link= new Link(composite, SWT.NONE);
link.setText(label);
link.setLayoutData(gd);
if (listener != null) {
link.addSelectionListener(listener);
}
makeScrollableCompositeAware(link);
makeScrollableCompositeAware(checkBox);
String currValue= getValue(key);
checkBox.setSelection(data.getSelection(currValue) == 0);
fCheckBoxes.add(checkBox);
return checkBox;
}
/**
* @param parent
* @param label
* @param key
* @param values
* @param valueLabels
* @param indent
* @return a Combo box added to parent with the label and key
*/
protected Combo addComboBox(Composite parent, String label, Key key, String[] values, String[] valueLabels, int indent) {
GridData gd= new GridData(GridData.FILL, GridData.CENTER, true, false, 2, 1);
gd.horizontalIndent= indent;
Label labelControl= new Label(parent, SWT.LEFT);
labelControl.setFont(JFaceResources.getDialogFont());
labelControl.setText(label);
labelControl.setLayoutData(gd);
Combo comboBox= newComboControl(parent, key, values, valueLabels);
comboBox.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
fLabels.put(comboBox, labelControl);
return comboBox;
}
Combo addInversedComboBox(Composite parent, String label, Key key, String[] values, String[] valueLabels, int indent) {
GridData gd= new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
gd.horizontalIndent= indent;
gd.horizontalSpan= 3;
Composite composite= new Composite(parent, SWT.NONE);
GridLayout layout= new GridLayout();
layout.marginHeight= 0;
layout.marginWidth= 0;
layout.numColumns= 2;
composite.setLayout(layout);
composite.setLayoutData(gd);
Combo comboBox= newComboControl(composite, key, values, valueLabels);
comboBox.setFont(JFaceResources.getDialogFont());
comboBox.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));
Label labelControl= new Label(composite, SWT.LEFT | SWT.WRAP);
labelControl.setText(label);
labelControl.setLayoutData(new GridData());
fLabels.put(comboBox, labelControl);
return comboBox;
}
Combo newComboControl(Composite composite, Key key, String[] values, String[] valueLabels) {
ControlData data= new ControlData(key, values);
Combo comboBox= new Combo(composite, SWT.READ_ONLY);
comboBox.setItems(valueLabels);
comboBox.setData(data);
comboBox.addSelectionListener(getSelectionListener());
comboBox.setFont(JFaceResources.getDialogFont());
makeScrollableCompositeAware(comboBox);
String currValue= getValue(key);
comboBox.select(data.getSelection(currValue));
fComboBoxes.add(comboBox);
return comboBox;
}
Text addTextField(Composite parent, String label, Key key, int indent, int widthHint) {
Label labelControl= new Label(parent, SWT.WRAP);
labelControl.setText(label);
labelControl.setFont(JFaceResources.getDialogFont());
labelControl.setLayoutData(new GridData());
Text textBox= new Text(parent, SWT.BORDER | SWT.SINGLE);
textBox.setData(key);
textBox.setLayoutData(new GridData());
makeScrollableCompositeAware(textBox);
fLabels.put(textBox, labelControl);
String currValue= getValue(key);
if (currValue != null) {
textBox.setText(currValue);
}
textBox.addModifyListener(getTextModifyListener());
GridData data= new GridData(GridData.HORIZONTAL_ALIGN_FILL);
if (widthHint != 0) {
data.widthHint= widthHint;
}
data.horizontalIndent= indent;
data.horizontalSpan= 2;
textBox.setLayoutData(data);
fTextBoxes.add(textBox);
return textBox;
}
ScrolledPageContent getParentScrolledComposite(Control control) {
Control parent= control.getParent();
while (!(parent instanceof ScrolledPageContent) && parent != null) {
parent= parent.getParent();
}
if (parent instanceof ScrolledPageContent) {
return (ScrolledPageContent) parent;
}
return null;
}
ExpandableComposite getParentExpandableComposite(Control control) {
Control parent= control.getParent();
while (!(parent instanceof ExpandableComposite) && parent != null) {
parent= parent.getParent();
}
if (parent instanceof ExpandableComposite) {
return (ExpandableComposite) parent;
}
return null;
}
private void makeScrollableCompositeAware(Control control) {
ScrolledPageContent parentScrolledComposite= getParentScrolledComposite(control);
if (parentScrolledComposite != null) {
parentScrolledComposite.adaptChild(control);
}
}
ExpandableComposite createStyleSection(Composite parent, String label, int nColumns) {
ExpandableComposite excomposite= new ExpandableComposite(parent, SWT.NONE, ExpandableComposite.TWISTIE | ExpandableComposite.CLIENT_INDENT);
excomposite.setText(label);
excomposite.setExpanded(false);
excomposite.setFont(JFaceResources.getFontRegistry().getBold(JFaceResources.DIALOG_FONT));
excomposite.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, false, nColumns, 1));
excomposite.addExpansionListener(new ExpansionAdapter() {
public void expansionStateChanged(ExpansionEvent e) {
expandedStateChanged((ExpandableComposite) e.getSource());
}
});
fExpandedComposites.add(excomposite);
makeScrollableCompositeAware(excomposite);
return excomposite;
}
final void expandedStateChanged(ExpandableComposite expandable) {
ScrolledPageContent parentScrolledComposite= getParentScrolledComposite(expandable);
if (parentScrolledComposite != null) {
parentScrolledComposite.reflow(true);
}
}
void restoreSectionExpansionStates(IDialogSettings settings) {
for (int i= 0; i < fExpandedComposites.size(); i++) {
ExpandableComposite excomposite= (ExpandableComposite) fExpandedComposites.get(i);
if (settings == null) {
excomposite.setExpanded(i == 0); // only expand the first node by default
} else {
excomposite.setExpanded(settings.getBoolean(SETTINGS_EXPANDED + String.valueOf(i)));
}
}
}
void storeSectionExpansionStates(IDialogSettings settings) {
for (int i= 0; i < fExpandedComposites.size(); i++) {
ExpandableComposite curr= (ExpandableComposite) fExpandedComposites.get(i);
settings.put(SETTINGS_EXPANDED + String.valueOf(i), curr.isExpanded());
}
}
SelectionListener getSelectionListener() {
if (fSelectionListener == null) {
fSelectionListener= new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {/*do nothing*/}
public void widgetSelected(SelectionEvent e) {
controlChanged(e.widget);
}
};
}
return fSelectionListener;
}
ModifyListener getTextModifyListener() {
if (fTextModifyListener == null) {
fTextModifyListener= new ModifyListener() {
public void modifyText(ModifyEvent e) {
textChanged((Text) e.widget);
}
};
}
return fTextModifyListener;
}
void controlChanged(Widget widget) {
ControlData data= (ControlData) widget.getData();
String newValue= null;
if (widget instanceof Button) {
newValue= data.getValue(((Button)widget).getSelection());
} else if (widget instanceof Combo) {
newValue= data.getValue(((Combo)widget).getSelectionIndex());
} else {
return;
}
String oldValue= setValue(data.getKey(), newValue);
validateSettings(data.getKey(), oldValue, newValue);
}
void textChanged(Text textControl) {
Key key= (Key) textControl.getData();
String number= textControl.getText();
String oldValue= setValue(key, number);
validateSettings(key, oldValue, number);
}
boolean checkValue(Key key, String value) {
return value.equals(getValue(key));
}
String getValue(Key key) {
if (fDisabledProjectSettings != null) {
return (String) fDisabledProjectSettings.get(key);
}
return key.getCurValue(_prefs, fLookupOrder, false, fManager).toString();
}
boolean getBooleanValue(Key key) {
return Boolean.valueOf(getValue(key)).booleanValue();
}
String setValue(Key key, String value) {
if (fDisabledProjectSettings != null) {
return (String) fDisabledProjectSettings.put(key, value);
}
Object newValue = key.setCurValue(_prefs, fLookupOrder[0], Severity.valueOfString(value), fManager);
return newValue != null ? newValue.toString() : ""; //$NON-NLS-1$
}
String setValue(Key key, boolean value) {
return setValue(key, String.valueOf(value));
}
/**
* Returns the value as actually stored in the preference store.
* @param key
* @return the value as actually stored in the preference store.
*/
Object getStoredValue(Key key) {
return key.getCurValue(_prefs, fLookupOrder, false, fManager);
}
/**
* Update fields and validate.
* @param changedKey Key that changed, or null, if all changed.
* @param oldValue
* @param newValue
*/
protected abstract void validateSettings(Key changedKey, String oldValue, String newValue);
String[] getTokens(String text, String separator) {
StringTokenizer tok= new StringTokenizer(text, separator);
int nTokens= tok.countTokens();
String[] res= new String[nTokens];
for (int i= 0; i < res.length; i++) {
res[i]= tok.nextToken().trim();
}
return res;
}
private boolean getChanges(IScopeContext currContext, List changedSettings) {
boolean needsBuild= false;
for (int i= 0; i < fAllKeys.length; i++) {
Key key= fAllKeys[i];
Object oldVal= key.getStoredValue(_prefs, currContext, null);
Object val= key.getCurValue(_prefs, currContext, fManager);
if (val == null) {
if (oldVal != null) {
changedSettings.add(key);
needsBuild |= !oldVal.equals(key.getCurValue(_prefs, fLookupOrder, true, fManager));
}
} else if (!val.equals(oldVal)) {
changedSettings.add(key);
needsBuild |= oldVal != null || !val.equals(key.getCurValue(_prefs, fLookupOrder, true, fManager));
}
}
return needsBuild;
}
void useProjectSpecificSettings(boolean enable) {
boolean hasProjectSpecificOption= fDisabledProjectSettings == null;
if (enable != hasProjectSpecificOption && fProject != null) {
if (enable) {
for (int i= 0; i < fAllKeys.length; i++) {
Key curr= fAllKeys[i];
String val= (String) fDisabledProjectSettings.get(curr);
curr.setCurValue(_prefs, fLookupOrder[0], Severity.valueOfString(val), fManager);
}
fDisabledProjectSettings= null;
updateControls();
validateSettings(null, null, null);
} else {
fDisabledProjectSettings= new IdentityHashMap();
for (int i= 0; i < fAllKeys.length; i++) {
Key curr= fAllKeys[i];
Object oldSetting= curr.getCurValue(_prefs, fLookupOrder, false, fManager);
fDisabledProjectSettings.put(curr, oldSetting);
curr.setCurValue(_prefs, fLookupOrder[0], null, fManager); // clear project settings
}
}
}
}
boolean areSettingsEnabled() {
return fDisabledProjectSettings == null || fProject == null;
}
boolean performOk() {
return processChanges(fContainer);
}
// public boolean performApply() {
// return processChanges(null); // apply directly
// }
boolean processChanges(IWorkbenchPreferenceContainer container) {
IScopeContext currContext= fLookupOrder[0];
List /* <Key>*/ changedOptions= new ArrayList();
boolean needsBuild= getChanges(currContext, changedOptions);
if (changedOptions.isEmpty()) {
return true;
}
if (needsBuild) {
int count= getRebuildCount();
if (count > fRebuildCount) {
needsBuild= false; // build already requested
fRebuildCount= count;
}
}
boolean doBuild= false;
final String showBuildWarningKey = JSFCorePlugin.PLUGIN_ID + "." + "buildwarning_dont_show_again"; //$NON-NLS-1$ //$NON-NLS-2$
final IPreferenceStore prefStore = JSFCorePlugin.getDefault().getPreferenceStore();
final boolean showDialog = !MessageDialogWithToggle.ALWAYS.equals(prefStore.getString(showBuildWarningKey));
if (needsBuild && showDialog) {
String[] strings= getFullBuildDialogStrings(fProject == null);
if (strings != null) {
MessageDialogWithToggle.openInformation
(getShell(), strings[0], strings[1],
PreferencesMessages.ProblemSeveritiesConfigurationBlock_buildwarning_dont_show_again
, false, prefStore, showBuildWarningKey);
// int res= dialog.open();
// if (res == 0) {
// doBuild= true;
// } else if (res != 1) {
// return false; // cancel pressed
// }
}
}
if (container != null) {
// no need to apply the changes to the original store: will be done by the page container
if (doBuild) { // post build
incrementRebuildCount();
// TODO: container.registerUpdateJob(CoreUtility.getBuildJob(fProject));
}
} else {
// apply changes right away
try {
fManager.applyChanges();
} catch (BackingStoreException e) {
JSFUiPlugin.log(IStatus.ERROR, "Error applying changes", e); //$NON-NLS-1$
return false;
}
if (doBuild) {
//CoreUtility.getBuildJob(fProject).schedule();
}
}
return true;
}
abstract String[] getFullBuildDialogStrings(boolean workspaceSettings);
// public void performDefaults() {
// for (int i= 0; i < fAllKeys.length; i++) {
// Key curr= fAllKeys[i];
// String defValue= curr.getStoredValue(fLookupOrder, true, fManager);
// setValue(curr, defValue);
// }
//
// settingsUpdated();
// updateControls();
// validateSettings(null, null, null);
// }
/**
* @since 3.1
*/
void performRevert() {
for (int i= 0; i < fAllKeys.length; i++) {
Key curr= fAllKeys[i];
String origValue= curr.getCurValue(_prefs, fLookupOrder, false, null).toString();
setValue(curr, origValue);
}
updateControls();
validateSettings(null, null, null);
}
void dispose() {
// do nothing; sub-class should override
}
void updateControls() {
// update the UI
for (int i= fCheckBoxes.size() - 1; i >= 0; i--) {
updateCheckBox((Button) fCheckBoxes.get(i));
}
for (int i= fComboBoxes.size() - 1; i >= 0; i--) {
updateCombo((Combo) fComboBoxes.get(i));
}
for (int i= fTextBoxes.size() - 1; i >= 0; i--) {
updateText((Text) fTextBoxes.get(i));
}
}
void updateCombo(Combo curr) {
ControlData data= (ControlData) curr.getData();
String currValue= getValue(data.getKey());
curr.select(data.getSelection(currValue));
}
void updateCheckBox(Button curr) {
ControlData data= (ControlData) curr.getData();
String currValue= getValue(data.getKey());
curr.setSelection(data.getSelection(currValue) == 0);
}
void updateText(Text curr) {
Key key= (Key) curr.getData();
String currValue= getValue(key);
if (currValue != null) {
curr.setText(currValue);
}
}
Button getCheckBox(Key key) {
for (int i= fCheckBoxes.size() - 1; i >= 0; i--) {
Button curr= (Button) fCheckBoxes.get(i);
ControlData data= (ControlData) curr.getData();
if (key.equals(data.getKey())) {
return curr;
}
}
return null;
}
Combo getComboBox(Key key) {
for (int i= fComboBoxes.size() - 1; i >= 0; i--) {
Combo curr= (Combo) fComboBoxes.get(i);
ControlData data= (ControlData) curr.getData();
if (key.equals(data.getKey())) {
return curr;
}
}
return null;
}
Text getTextControl(Key key) {
for (int i= fTextBoxes.size() - 1; i >= 0; i--) {
Text curr= (Text) fTextBoxes.get(i);
ControlData data= (ControlData) curr.getData();
if (key.equals(data.getKey())) {
return curr;
}
}
return null;
}
Control findControl(Key key) {
Combo comboBox= getComboBox(key);
if (comboBox != null) {
return comboBox;
}
Button checkBox= getCheckBox(key);
if (checkBox != null) {
return checkBox;
}
Text text= getTextControl(key);
if (text != null) {
return text;
}
return null;
}
void setComboEnabled(Key key, boolean enabled) {
Combo combo= getComboBox(key);
Label label= (Label) fLabels.get(combo);
combo.setEnabled(enabled);
label.setEnabled(enabled);
}
}