/*
    * @(#) DefaultEditor.java Apr 11, 2005
    * 
    * Copyright (c) 2003-2005 Delft University of Technology, Jaffalaan 5, 2628 BX
    * Delft, the Netherlands. All rights reserved.
    * 
    * See for project information <a href="http://www.simulation.tudelft.nl/">
    * www.simulation.tudelft.nl </a>.
    * 
   * The source code and binary code of this software are proprietary information
   * of Delft University of Technology.
   */
  package org.gscg.common.gui.components.interactivespinner;
  
  import java.awt.Component;
  import java.awt.Container;
  import java.awt.Dimension;
  import java.awt.Insets;
  import java.awt.LayoutManager;
  import java.awt.event.ActionEvent;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  
  import javax.swing.Action;
  import javax.swing.ActionMap;
  import javax.swing.JPanel;
  import javax.swing.event.ChangeEvent;
  import javax.swing.event.ChangeListener;
  
  
  /***
   * <p>
   * (c) copyright 2005 <a href="http://www.simulation.tudelft.nl">Delft
   * University of Technology </a>, the Netherlands. <br>
   * See for project information <a
   * href="http://www.simulation.tudelft.nl">www.simulation.tudelft.nl </a> <br>
   * 
   * Copyright (c) 2003-2005 Delft University of Technology, Jaffalaan 5, 2628 BX
   * Delft, the Netherlands. All rights reserved.
   * 
   * See for project information <a href="http://www.simulation.tudelft.nl/">
   * www.simulation.tudelft.nl </a>.
   * 
   * The source code and binary code of this software are proprietary information
   * of Delft University of Technology.
   * 
   * @author <a
   *         href="http://www.tbm.tudelft.nl/webstaf/stijnh/index.htm">Stijn-Pieter
   *         van Houten </a>
   * @version $Revision: 1.1 $ $Date: 2005/06/16 12:33:56 $
   * @since 1.1.3
   */
  /***
   * A simple base class for more specialized editors that displays a read-only
   * view of the model's current value with a
   * <code>JFormattedTextField<code>.  Subclasses
   * can configure the <code>JFormattedTextField<code> to create
   * an editor that's appropriate for the type of model they
   * support and they may want to override
   * the <code>stateChanged</code> and <code>propertyChanged</code>
   * methods, which keep the model and the text field in sync.
   * <p>
   * This class defines a <code>dismiss</code> method that removes the
   * editors <code>ChangeListener</code> from the <code>JSpinner</code>
   * that it's part of.   The <code>setEditor</code> method knows about
   * <code>DefaultEditor.dismiss</code>, so if the developer
   * replaces an editor that's derived from <code>JSpinner.DefaultEditor</code>
   * its <code>ChangeListener</code> connection back to the 
   * <code>JSpinner</code> will be removed.  However after that,
   * it's up to the developer to manage their editor listeners.
   * Similarly, if a subclass overrides <code>createEditor</code>,
   * it's up to the subclasser to deal with their editor
   * subsequently being replaced (with <code>setEditor</code>).
   * We expect that in most cases, and in editor installed
   * with <code>setEditor</code> or created by a <code>createEditor</code>
   * override, will not be replaced anyway.
   * <p>
   * This class is the <code>LayoutManager<code> for it's single
   * <code>JFormattedTextField</code> child.   By default the
   * child is just centered with the parents insets.
   */
  public class DefaultEditor extends JPanel implements ChangeListener,
  		PropertyChangeListener, LayoutManager
  {
  	/*** the default disable action for the ftf */
  	private static final Action DISABLED_ACTION = new DisabledAction();
  
  	/***
  	 * Constructs an editor component for the specified <code>JSpinner</code>.
  	 * This <code>DefaultEditor</code> is it's own layout manager and it is
  	 * added to the spinner's <code>ChangeListener</code> list. The
  	 * constructor creates a single <code>JFormattedTextField<code> child,
  	 * initializes it's value to be the spinner model's current value
  	 * and adds it to <code>this</code> <code>DefaultEditor</code>.  
  	 * 
  	 * @param spinner the spinner whose model <code>this</code> editor will monitor
  	 * @see #getTextField
  	 */
  	public DefaultEditor(final JInteractiveSpinner spinner)
 	{
 		super(null);
 
 		JFormattedTextField ftf = new JFormattedTextField();
 		ftf.setValue(spinner.getValue());
 		ftf.addPropertyChangeListener(this);
 
 		add(ftf);
 
 		setLayout(this);
 		spinner.addChangeListener(this);
 
 		// We want the spinner's increment/decrement actions to be
 		// active vs those of the JFormattedTextField. As such we
 		// put disabled actions in the JFormattedTextField's actionmap.
 		// A binding to a disabled action is treated as a nonexistant
 		// binding.
 		ActionMap ftfMap = ftf.getActionMap();
 
 		if (ftfMap != null)
 		{
 			ftfMap.put("increment", DISABLED_ACTION);
 			ftfMap.put("decrement", DISABLED_ACTION);
 		}
 	}
 
 	/***
 	 * Disconnect <code>this</code> editor from the specified
 	 * <code>JSpinner</code>. By default, this method removes itself from the
 	 * spinners <code>ChangeListener</code> list.
 	 * 
 	 * @param spinner the <code>JSpinner</code> to disconnect this editor
 	 *        from; the same spinner as was passed to the constructor.
 	 */
 	public void dismiss(final JInteractiveSpinner spinner)
 	{
 		spinner.removeChangeListener(this);
 	}
 
 
 	/***
 	 * Returns the <code>JSpinner</code> ancestor of this editor or null.
 	 * Typically the editor's parent is a <code>JSpinner</code> however
 	 * subclasses of <codeJSpinner</code> may override the the <code>
 	 * createEditor</code> method and insert one or more containers between the
 	 * <code>JSpinner</code> and it's editor.
 	 * 
 	 * @return <code>JSpinner</code> ancestor
 	 */
 	public JInteractiveSpinner getSpinner()
 	{
 		for (Component c = this; c != null; c = c.getParent())
 		{
 			if (c instanceof JInteractiveSpinner)
 			{
 				return (JInteractiveSpinner) c;
 			}
 		}
 		return null;
 	}
 
 
 	/***
 	 * Returns the <code>JFormattedTextField</code> child of this editor. By
 	 * default the text field is the first and only child of editor.
 	 * 
 	 * @return the <code>JFormattedTextField</code> that gives the user access
 	 *         to the <code>SpinnerDateModel's</code> value.
 	 * @see #getSpinner
 	 */
 	public JFormattedTextField getTextField()
 	{
 		return (JFormattedTextField) getComponent(0);
 	}
 
 
 	/***
 	 * This method is called when the spinner's model's state changes. It sets
 	 * the <code>value</code> of the text field to the current value of the
 	 * spinners model.
 	 * 
 	 * @param e not used
 	 * @see #getTextField
 	 */
 	public void stateChanged(final ChangeEvent e)
 	{
 		JInteractiveSpinner spinner = (JInteractiveSpinner) (e.getSource());
 		getTextField().setValue(spinner.getValue());
 	}
 
 
 	/***
 	 * Called by the <code>JFormattedTextField</code> 
 	 * <code>PropertyChangeListener</code>.
 	 * When the <code>"value"</code> property changes, which implies that the
 	 * user has typed a new number, we set the value of the spinners model.
 	 * <p>
 	 * This class ignores <code>PropertyChangeEvents</code> whose source is
 	 * not the <code>JFormattedTextField</code>, so subclasses may safely
 	 * make <code>this</code> <code>DefaultEditor</code> a
 	 * <code>PropertyChangeListener</code> on other objects.
 	 * 
 	 * @param e the <code>PropertyChangeEvent</code> whose source is the
 	 *        <code>JFormattedTextField</code> created by this class.
 	 * @see #getTextField
 	 */
 	public void propertyChange(final PropertyChangeEvent e)
 	{
 		JInteractiveSpinner spinner = getSpinner();
 		if (spinner == null)
 		{
 			// Indicates we aren't installed anywhere.
 			return;
 		}
 
 		Object source = e.getSource();
 		String name = e.getPropertyName();
 		if ((source instanceof JFormattedTextField) && "value".equals(name))
 		{
 			spinner.setValue(getTextField().getValue());
 		}
 	}
 
 
 	/***
 	 * This <code>LayoutManager</code> method does nothing. We're only
 	 * managing a single child and there's no support for layout constraints.
 	 * 
 	 * @param name ignored
 	 * @param child ignored
 	 */
 	public void addLayoutComponent(final String name, final Component child)
 	{
 		// nothing to do
 	}
 
 
 	/***
 	 * This <code>LayoutManager</code> method does nothing. There isn't any
 	 * per-child state.
 	 * 
 	 * @param child ignored
 	 */
 	public void removeLayoutComponent(final Component child)
 	{
 		// nothing to do
 	}
 
 
 	/***
 	 * Returns the size of the parents insets.
 	 * 
 	 * @param parent the parent
 	 * @return the size as a Dimension
 	 */
 	private Dimension insetSize(final Container parent)
 	{
 		Insets insets = parent.getInsets();
 		int w = insets.left + insets.right;
 		int h = insets.top + insets.bottom;
 		return new Dimension(w, h);
 	}
 
 
 	/***
 	 * Returns the preferred size of first (and only) child plus the size of the
 	 * parents insets.
 	 * 
 	 * @param parent the Container that's managing the layout
 	 * @return the preferred dimensions to lay out the subcomponents of the
 	 *         specified container.
 	 */
 	public Dimension preferredLayoutSize(final Container parent)
 	{
 		Dimension preferredSize = insetSize(parent);
 		if (parent.getComponentCount() > 0)
 		{
 			Dimension childSize = getComponent(0).getPreferredSize();
 			preferredSize.width += childSize.width;
 			preferredSize.height += childSize.height;
 		}
 		return preferredSize;
 	}
 
 
 	/***
 	 * Returns the minimum size of first (and only) child plus the size of the
 	 * parents insets.
 	 * 
 	 * @param parent the Container that's managing the layout
 	 * @return the minimum dimensions needed to lay out the subcomponents of the
 	 *         specified container.
 	 */
 	public Dimension minimumLayoutSize(final Container parent)
 	{
 		Dimension minimumSize = insetSize(parent);
 		if (parent.getComponentCount() > 0)
 		{
 			Dimension childSize = getComponent(0).getMinimumSize();
 			minimumSize.width += childSize.width;
 			minimumSize.height += childSize.height;
 		}
 		return minimumSize;
 	}
 
 
 	/***
 	 * @see java.awt.LayoutManager#layoutContainer(java.awt.Container)
 	 */
 	public void layoutContainer(final Container parent)
 	{
 		if (parent.getComponentCount() > 0)
 		{
 			Insets insets = parent.getInsets();
 			int w = parent.getWidth() - (insets.left + insets.right);
 			int h = parent.getHeight() - (insets.top + insets.bottom);
 			getComponent(0).setBounds(insets.left, insets.top, w, h);
 		}
 	}
 
 	/***
 	 * An Action implementation that is always disabled.
 	 */
 	private static class DisabledAction implements Action
 	{
 		/***
 		 * @see javax.swing.Action#getValue(java.lang.String)
 		 */
 		public Object getValue(final String key)
 		{
 			return null;
 		}
 
 		/***
 		 * @see javax.swing.Action#putValue(java.lang.String, java.lang.Object)
 		 */
 		public void putValue(final String key, final Object value)
 		{
 			// nothing to do
 		}
 
 		/***
 		 * @see javax.swing.Action#setEnabled(boolean)
 		 */
 		public void setEnabled(final boolean b)
 		{
 			// nothing to do
 		}
 
 		/***
 		 * @see javax.swing.Action#isEnabled()
 		 */
 		public boolean isEnabled()
 		{
 			return false;
 		}
 
 		/***
 		 * @see javax.swing.Action#addPropertyChangeListener(java.beans.PropertyChangeListener)
 		 */
 		public void addPropertyChangeListener(final PropertyChangeListener l)
 		{
 			// nothing to do
 		}
 
 		/***
 		 * @see javax.swing.Action#removePropertyChangeListener(java.beans.PropertyChangeListener)
 		 */
 		public void removePropertyChangeListener(final PropertyChangeListener l)
 		{
 			// nothing to do
 		}
 
 		/***
 		 * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
 		 */
 		public void actionPerformed(final ActionEvent ae)
 		{
 			// nothing to do
 		}
 	}
 }