LBL_SETTINGCOMBO=FQN/Import settings: 

LBL_ADVANCED=Advanced

CHOICE_MINFQN=Low noise - Minimze FQNs

CHOICE_DEFFQN=Default

CHOICE_MAXFQN=High noise - Maximize FQNs

CHOICE_CUSTOM=Custom settings

TT_FQN=Max FQNs=

TT_SI= Single import threshold=

        <Property name="lineWrap" type="boolean" value="true"/>

        <Property name="wrapStyleWord" type="boolean" value="true"/>

        jTextArea1.setLineWrap(true);

        jTextArea1.setWrapStyleWord(true);

        SettingsPanel settingspanel = new SettingsPanel();

        add (settingspanel, BorderLayout.SOUTH);

        settingspanel.addActionListener (

            new java.awt.event.ActionListener () {

                public void actionPerformed (java.awt.event.ActionEvent event) {

                    initListTableView (dataSource.createRootImportNode());

                }

        });

/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2000 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

/*

 * SettingsPanel.java

 * 

 * Created on April 24, 2002, 5:40 PM

 */

package org.netbeans.modules.java.imptool;

import java.awt.BorderLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.beans.*;

import java.util.ArrayList;

import javax.swing.*;

import javax.swing.event.EventListenerList;

import org.openide.nodes.*;

import org.openide.TopManager;

import org.openide.ErrorManager;

import org.openide.options.SystemOption;

import org.openide.util.NbBundle;

import org.openide.util.SharedClassObject;

/** A panel that displays the settings for the import management tool.  Includes a combobox that

 *  contains some easy-to-use defaults (displays a "custom" item if the defaults have

 *  been changed in Tools | Options) and an Advanced button for manually setting the settings.

 *  <P>The defaults are more or less low-noise, default and high-noise, in terms of raising the

 *  amounts of single imports and fully qualified names to be used.

 * @author Tim Boudreau

 * @version 0.1

 */

public class SettingsPanel extends JPanel implements PropertyChangeListener {

        //defaults for minimal fqn

    private static final int MIN_FQN = 0;

    private static final int MIN_SI = 2;

        //defaults for default fqn - XXX nd to check actual defaults

    private static final int DEF_FQN = 4;

    private static final int DEF_SI = 4;

        //defaults for maximal fqn

    private static final int MAX_FQN = 100;

    private static final int MAX_SI = 100;

    /** Flag to stop ActionPerformed events from being fired. */    

    private boolean isSetting = true;

    private ImpToolSettings settingsOption;

    private JComboBox chooserCombo;

    private JButton advancedButton;

    private SettingData customItem = null;

    private SettingData[] modelData=null;

    /** Flag variable to indicate when to ignore propertyChangeEvents (e.g. when the

     * component is the initiator) */    

    private boolean isChanging;

    /** Utility field used by event firing mechanism. */

    private EventListenerList listenerList =  null;

    /** Creates a new instance of SettingsPanel */

    public SettingsPanel() {

        init();

    }

    /** Create the initial components. */    

    private void init() {

        setLayout(new BorderLayout());

        JTextArea jta = new JTextArea(NbBundle.getBundle(SettingsPanel.class).getString("LBL_SETTINGCOMBO")); //NOI18N

        jta.setEditable(false);

        jta.setFont(javax.swing.UIManager.getFont("Label.font"));

        jta.setDisabledTextColor(javax.swing.UIManager.getColor("Label.foreground"));

        jta.setEnabled(false);

        jta.setOpaque(false);

        add(jta, BorderLayout.WEST);  

        chooserCombo = new JComboBox();

        add(chooserCombo, BorderLayout.CENTER);

        advancedButton = new JButton(NbBundle.getMessage(SettingsPanel.class, "LBL_ADVANCED"));  //NOI18N

        add (advancedButton, BorderLayout.EAST);

        ActionListener acl = new ActionListener () {

            public void actionPerformed(ActionEvent ev) {

                if (ev.getSource()==chooserCombo) {

                    if (isSetting) return;

                    SettingsPanel.this.processChooserEvent();

                } else {

                    SettingsPanel.this.processButtonEvent();

                }

            }

        };

        chooserCombo.addActionListener (acl);

        advancedButton.addActionListener(acl);

        initializeChooser();

    }

    /** Initialize the chooser with data reflecting the defaults, and if the current

     * settings are not a default, a Custom setting item to reflect those settings,

     * which will be the selected item. */    

    private void initializeChooser() {

        chooserCombo.setModel(new DefaultComboBoxModel (createModelData()));

        updateComponent();

    }

    /** Create the model for the dataModel for the combo box. */    

    private SettingData[] createModelData () {

        customItem = new SettingData();

        SettingData min = 

            new SettingData (MIN_FQN, MIN_SI,

            NbBundle.getBundle(SettingsPanel.class).getString("CHOICE_MINFQN")

            ); //NOI18N

        boolean currIsPreset = customItem.equals (min);

        SettingData def = 

            new SettingData (DEF_FQN, DEF_SI,

            NbBundle.getBundle(SettingsPanel.class).getString("CHOICE_DEFFQN")

            ); //NOI18N

        currIsPreset |= customItem.equals (def);

        SettingData max = 

            new SettingData (MAX_FQN, MAX_SI,

            NbBundle.getBundle(SettingsPanel.class).getString("CHOICE_MAXFQN")

            ); //NOI18N

            //if there are some non-default settings in Options, use them and make default

        currIsPreset |= customItem.equals (max);

        if (currIsPreset) {

            modelData = new SettingData[] {

                min, def, max

            };

        } else {

            modelData = new SettingData[] {

                customItem, min, def, max

            };

        }

        return modelData;

    }

    /** Synchronize the combo-box and tooltip with the current settings.  If the

     * settings have changed, see if the setting is one of the defaults.  If not,

     * create (or select if already created) the Custom settings item and select it. */    

    public void updateComponent () {

        int itemIndex=-1;

        for (int i=0; i < modelData.length; i++) {

            if (modelData[i].isCurrent()) {

                itemIndex=i;

                break;

            }

        }

        isSetting = true;

        if (itemIndex >=0) {

            chooserCombo.setSelectedIndex(itemIndex);

        } else {

            if (modelData.length == 3) {

                addCustomItem();

            }

            chooserCombo.setSelectedIndex(0);

            customItem.update();

        }  

        isSetting = false;

    updateChooserTooltip();

    }

    /** Create the custom item and add it to the combo box. */    

    private void addCustomItem () {

        //regen the array w/ added CustomItem

        modelData = new SettingData[] {

            modelData[0], modelData[1], modelData[2], customItem

        };

        customItem.update();

        chooserCombo.setModel(new DefaultComboBoxModel (createModelData()));

    }

    /** Update the tooltip to reflect the current settings. */    

    private void updateChooserTooltip () {

        StringBuffer sb = new StringBuffer();

        sb.append (NbBundle.getBundle (SettingsPanel.class).getString ("TT_FQN")); //NOI18N

        sb.append (getSettings().getMaxFqn());

        sb.append (" "); //NOI18N

        sb.append (NbBundle.getBundle (SettingsPanel.class).getString ("TT_SI")); //NOI18N

        sb.append (getSettings().getSingleImports());

        chooserCombo.setToolTipText(sb.toString());

    }

    /** Is the current item one of the defaults? */    

    /** Called when the component gets a parent.  Adds a propertyChangeListener to

     * the settings node. */    

    public void addNotify() {

        getSettings().addPropertyChangeListener(this);

        super.addNotify();

    }

    /** Called when the component is removed from a window.  Remove listeners. */    

    public void removeNotify() {

        super.removeNotify();

        getSettings().removePropertyChangeListener(this);

    }

    /** Returns a SystemOption representing the settings for the import management tool. */    

    private ImpToolSettings getSettings() {

        if (settingsOption == null) {

            settingsOption = (ImpToolSettings) SharedClassObject.findObject (ImpToolSettings.class, true);

        }

        return settingsOption;

    }

    /** Handle a selection being made in the combo-box. */    

    private final void processChooserEvent() {

        SettingData selectedChoice = (SettingData) chooserCombo.getSelectedItem();

        ImpToolSettings its = getSettings();

        isChanging = true;

        its.setMaxFqn (selectedChoice.maxfqn);

        its.setSingleImports (selectedChoice.singleimports);

        isChanging = false;

        updateComponent();

        fireActionPerformed();

    }

    /** Handle the button being clicked by bringing up a property sheet. */    

    private synchronized final void processButtonEvent() {

        //display advanced dialog here

        Node n=null;

        try {

            n = new BeanNode (getSettings());

        } catch (IntrospectionException e) {

            ErrorManager errMan=TopManager.getDefault().getErrorManager();

            if (errMan!=null) {

                errMan.annotate(e, e.getMessage());

            }

        }

    TopManager.getDefault().getNodeOperation().showProperties(n);

    }

    /** Registers ActionListener to receive events.

     * @param listener The listener to register.

     */

    public synchronized void addActionListener(ActionListener listener) {

        if (listenerList == null ) {

            listenerList = new EventListenerList();

        }

        listenerList.add(ActionListener.class, listener);

    }    

    /** Removes ActionListener from the list of listeners.

     * @param listener The listener to remove.

     */

    public synchronized void removeActionListener(ActionListener listener) {

        listenerList.remove(ActionListener.class, listener);

    }

    /** Notifies all registered listeners about the event.

     *

     * @param event The event to be fired

     */

    private void fireActionPerformed() {

        if (isSetting) return;

        if (listenerList == null) return;

        ActionEvent event = new ActionEvent(this, 0, null);

        Object[] listeners = listenerList.getListenerList();

        for (int i = listeners.length-2; i>=0; i-=2) {

            if (listeners[i]==ActionListener.class) {

                ((ActionListener)listeners[i+1]).actionPerformed(event);

            }

        }

    }

    /** Called when a property change is fired on the settings object.  Since any change

     * we perform will result in two propertyChangeEvents, we must be careful not to

     * prematurely update the components and fire ActionPerformed events.

     * @param propertyChangeEvent The event in question */    

    public void propertyChange(PropertyChangeEvent propertyChangeEvent) {

        //don't update from here during property change because changing

        //presets creates two property change events.

        if (!isChanging) {

            updateComponent(); 

            fireActionPerformed();

        }

    }

    /** Wrapper class for the defaults. */    

    private class SettingData extends Object {

        private String name;

        int maxfqn = 0;

        int singleimports = 0;

        /** Create a new SettingData object which will initialize itself from the current

         * settings for the IDE. */        

        private SettingData () {

            update();

            name = NbBundle.getBundle (SettingsPanel.class).getString("CHOICE_CUSTOM"); //NOI18N

        }

        private void update () {

            ImpToolSettings its = getSettings();

            this.maxfqn = its.getMaxFqn();

            this.singleimports = its.getSingleImports();

        }

        /** Create a SettingData object and initialize it with explicit values. */        

        private SettingData (int maxfqn, int singleimports, String name) {

            this.maxfqn = maxfqn;

            this.singleimports = singleimports;

            this.name = name;

        }

        /** See if this item matches the current settings for the IDE. */        

        public boolean isCurrent () {

            ImpToolSettings its = getSettings();

            return (its.getMaxFqn() == maxfqn) && 

                   (its.getSingleImports() == singleimports);

        }

        public String toString () {

            return name;

        }

        /** See if the values represented by this item match another (does not compare the

         * name property). */        

        public boolean equals (Object o) {

            if (o.getClass() != SettingData.class) return false;

            boolean result = 

              ((((SettingData) o).maxfqn == maxfqn) &&

              (((SettingData) o).singleimports == singleimports));

            return result;

        }

    }

}