/*
   Copyright (C) 2000 - 2007 Grid Systems, S.A.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
  
  /*
   * Project: KernelConfigurator
   * Created on 26-feb-2004
   *
   * Copyright (c)2003 Grid Systems
   */
  package com.gridsystems.config.tools.swing;
  
  import java.awt.LayoutManager;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.FocusEvent;
  import java.awt.event.FocusListener;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.text.MessageFormat;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Locale;
  import java.util.MissingResourceException;
  import java.util.ResourceBundle;
  import java.util.Set;
  import java.util.Stack;
  
  import javax.swing.AbstractButton;
  import javax.swing.Icon;
  import javax.swing.InputVerifier;
  import javax.swing.JComboBox;
  import javax.swing.JComponent;
  import javax.swing.JPanel;
  import javax.swing.JTextField;
  import javax.swing.event.ChangeEvent;
  import javax.swing.event.ChangeListener;
  
  import com.gridsystems.config.Configurator;
  import com.gridsystems.config.ConfiguratorModel;
  import com.gridsystems.config.SwingConfiguratorView;
  import com.gridsystems.config.tools.TextVerifier;
  
  /**
   * Panel Extension for Swing Configuration Views. It adds some common functionalities,
   * like:
   * <ul>
   *   <li>isModified() implementation, supported through focus events on fields
   *   <li>Field group enabling through "guarding" buttons
   *   <li>I18N support through internal bundle
   * </ul>
   *
   * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
   * @version 1.0
   */
  public class BasePanel extends JPanel implements ActionListener, FocusListener,
                                                   PropertyChangeListener,
                                                   SwingConfiguratorView {
  
    /**
     * The set of listeners for this panel.
     */
    private Set<ChangeListener> listeners = new HashSet<ChangeListener>();
  
    /**
     * "Field value modified" flag.
     */
    private boolean modified = false;
  
    /**
     * I18N resource bundle.
     */
    private ResourceBundle bundle;
  
    /**
     * Icon attribute.
     */
    private Icon icon;
  
    /**
     * Small icon attribute.
     */
    private Icon smallIcon;
  
    /**
     * The configurator this view is associated to.
    */
   private Configurator config;
 
   /**
    * Creates a new instance.
    *
    * @param config The configurator this view is associated to
    */
   public BasePanel(Configurator config) {
     super();
     this.config = config;
   }
 
   /**
    * Creates a new instance with the specified layout.
    *
    * @param layout The layout for this instance
    * @param config The configurator this view is associated to
    */
   public BasePanel(LayoutManager layout, Configurator config) {
     super(layout);
     this.config = config;
   }
 
   /**
    * Sets the name of the bundle to be used by this instance.
    *
    * @param name The name of the resource bundle
    */
   public void setBundle(String name) {
     Locale locale = Locale.getDefault();
     this.bundle = ResourceBundle.getBundle(name, locale);
   }
 
   /**
    * Sets the bundle to be used by this instance.
    *
    * @param bundle The resource bundle
    */
   public void setBundle(ResourceBundle bundle) {
     this.bundle = bundle;
   }
 
   /**
    * Sets the bundle used by this instance.
    *
    * @return the ResourceBundle used to get the internationalizated messages.
    */
   public ResourceBundle getBundle() {
     return this.bundle;
   }
 
   /**
    * Gets the configurator this view is associated to.
    *
    * @return  The configurator
    */
   public Configurator getConfigurator() {
     return this.config;
   }
 
   /**
    * {@inheritDoc}
    */
   public Icon getIcon() {
     return icon;
   }
 
   /**
    * Sets the icon.
    *
    * @param icon The icon
    */
   public void setIcon(Icon icon) {
     this.icon = icon;
   }
 
   /**
    * {@inheritDoc}
    */
   public Icon getSmallIcon() {
     return smallIcon;
   }
 
   /**
    * Sets the small icon.
    *
    * @param icon The small icon
    */
   public void setSmallIcon(Icon icon) {
     this.smallIcon = icon;
   }
 
   /**
    * {@inheritDoc}
    */
   public JComponent getComponent() {
     return this;
   }
 
   /**
    * {@inheritDoc}
    */
   public String getTitle() {
     return getString("config.name");
   }
 
   /**
    * {@inheritDoc}
    */
   public String getSubtitle() {
     return getString("config.description");
   }
 
   /**
    * {@inheritDoc}
    */
   public void getValues(ConfiguratorModel model) {
     throw new UnsupportedOperationException("Not implemented");
   }
 
   /**
    * {@inheritDoc}
    */
   public void setValues(ConfiguratorModel model) {
     throw new UnsupportedOperationException("Not implemented");
   }
 
   /**
    * Gets a localized string.
    *
    * @param key The i18n key
    * @return    The localized string, or null if none found for key
    * @throws NullPointerException if the bundle is not set
    */
   public String getString(String key) {
     if (bundle == null) {
       throw new NullPointerException("Bundle not set");
     }
 
     try {
       return bundle.getString(key);
     } catch (MissingResourceException e) {
       return null;
     }
   }
 
   /**
    * Gets a localized string, using the found string as a pattern to be used
    * by a MessageFormat instance.
    *
    * @param key    The key for the localized pattern
    * @param params The parameters for pattern substitution
    * @return       The localized / formatter string
    * @throws NullPointerException if the bundle is not set
    */
   public String getString(String key, Object[] params) {
     if (bundle == null) {
       throw new NullPointerException("Bundle not set");
     }
 
     try {
       String pattern = bundle.getString(key);
       return MessageFormat.format(pattern, params);
     } catch (MissingResourceException e) {
       return key + "#not found";
     }
   }
 
   /**
    * Gets if a change has been detected on the view.
    *
    * @return true if a change has been detected on this view, false otherwise
    */
   public boolean isModified() {
     return modified;
   }
 
   /**
    * Adds a change listener to the listener list of this panel.
    *
    * @param listener The listener to add
    */
   public void addChangeListener(ChangeListener listener) {
     synchronized (listeners) {
       listeners.add(listener);
     }
   }
 
   /**
    * Sets the "isModified" flag, and notifies all registered change listeners.
    *
    * @param src  The event source, for listeners notification
    * @param flag The new value of the flag
    */
   protected void setModified(Object src, boolean flag) {
     this.modified = flag;
 
     ChangeEvent event = new ChangeEvent(src);
     synchronized (listeners) {
       for (Iterator<ChangeListener> it = listeners.iterator(); it.hasNext();) {
         ChangeListener l = it.next();
         l.stateChanged(event);
       }
     }
   }
 
   /**
    * Registers itself as interested in changes in the specified text field.
    *
    * @param field The text field to listen
    */
   protected void watch(JTextField field) {
     field.addFocusListener(this);
   }
 
   /**
    * Registers itself as interested in changes in the specified text field.
    *
    * @param field The text field to listen
    */
   protected void watch(PopupTextField field) {
     field.addPropertyChangeListener(this);
   }
 
   /**
    * Registers itself as interested in changes in the specified combo box.
    *
    * @param field the combo box field to listen
    */
   protected void watch(JComboBox field) {
     field.addActionListener(this);
   }
 
   /**
    * Registers btn as a "enabled" guard for the components in "guarded".
    * The state of guarded components will be synchronized with the
    * selection state of btn.
    *
    * @param btn     The guarding button
    * @param guarded The list of components
    */
   protected void setGuarded(AbstractButton btn, JComponent[] guarded) {
     btn.putClientProperty("guarded", guarded);
     btn.addActionListener(this);
   }
 
   /**
    * If the event source is a button that is "guarding" a component set,
    * it synchronizes the "enabled" state of the component set with the
    * "selected" state of the source button.
    *
    * @param event The event containing the event source
    */
   public void actionPerformed(ActionEvent event) {
     Object src = event == null ? this : event.getSource();
     if (src instanceof AbstractButton) {
       AbstractButton btn = (AbstractButton)src;
       boolean selected = btn.isSelected();
 
       JComponent[] guarded = (JComponent[])btn.getClientProperty("guarded");
       int count = (guarded == null) ? 0 : guarded.length;
       for (int i = 0; i < count; i++) {
         guarded[i].setEnabled(selected);
       }
     }
     setModified(src, true);
   }
 
   /**
    * {@inheritDoc}
    */
   public void focusGained(FocusEvent e) {
     Object src = e.getSource();
     if (src instanceof JTextField) {
       JTextField field = (JTextField)src;
       field.putClientProperty("originalText", field.getText());
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void focusLost(FocusEvent e) {
     Object src = e.getSource();
     if (src instanceof JTextField) {
       JTextField field = (JTextField)src;
       String text = field.getText();
       String original = (String)field.getClientProperty("originalText");
 
       InputVerifier verifier = field.getInputVerifier();
       if (verifier != null) {
         boolean valid = verifier.verify(field);
         if (!valid) {
           //field.setText(original);
           return;
         }
       }
 
       if (!original.equals(text)) {
         setModified(field, true);
       }
     }
   }
 
   /**
    * Manages a PropertyChangeEvent.
    *
    * Manages a PropertyChangeEvent. It uses the input verifier (if any) from
    * the source object to check the new value. If it is not valid, the old
    * value is set again to the component.
    *
    * @param propertyChangeEvent a propertyChangeEvent with the information of
    * the event.
    *
    * @warning current implementation only reacts to events from PopupTextField
    * objects. If the verifier is a text verifier, the verification is done
    * with the result of calling the toString() to the value returned from
    * getValue() from the source object. If the verifier is not a text verifier,
    * then the verification uses the entire source object.
    */
   public void propertyChange(PropertyChangeEvent propertyChangeEvent) {
     Object source = propertyChangeEvent.getSource();
     if (source == null) {
       return;
     }
     if (source instanceof PopupTextField) {
       PopupTextField popupTextField = (PopupTextField) source;
       // SJM: If the new value received from the event is not the value
       // currently managed by the component, this is not the event that we want
       // to check.
       if (!popupTextField.getPropertyName().equals(
         propertyChangeEvent.getPropertyName())) {
         return;
       }
 
       InputVerifier verifier = popupTextField.getInputVerifier();
       if (verifier != null) {
         if (verifier instanceof TextVerifier) {
           TextVerifier textVerifier = (TextVerifier) verifier;
           String newValueText = popupTextField.getValue() == null
                               ? null : popupTextField.getValue().toString();
           if (!textVerifier.verify(newValueText)) {
             popupTextField.discard();
             return;
           }
         } else {
           if (!verifier.verify(popupTextField)) {
             popupTextField.setValue(propertyChangeEvent.getOldValue());
             return;
           }
         }
       }
     }
     this.setModified(source, true);
   }
 
   /**
    * {@inheritDoc}
    */
   public boolean hasErrors() {
     Stack stack = (Stack)this.getClientProperty("error.messages");
     return stack != null && stack.size() > 0;
   }
 }