path: root/jsf/plugins/org.eclipse.jst.jsf.ui/src/org/eclipse/jst/jsf/ui/internal/validation/OptionsConfigurationBlock.java

/*******************************************************************************
 * 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);
    }
}