/*
    * AmountSpinnerPanel.java Created @ Jun 22, 2004
    * 
    * 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 is proprietary information
   * of Delft University of Technology.
   * 
   */
  package org.gscg.common.gui.components;
  
  import info.clearthought.layout.TableLayout;
  
  import java.awt.Color;
  import java.awt.Component;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseListener;
  
  import javax.swing.BoxLayout;
  import javax.swing.JButton;
  import javax.swing.JOptionPane;
  import javax.swing.JPanel;
  import javax.swing.SpinnerModel;
  import javax.swing.SwingConstants;
  import javax.swing.event.ChangeListener;
  
  import nl.tudelft.simulation.logger.Logger;
  
  import org.gscg.common.gui.components.interactivespinner.JFormattedTextField;
  import org.gscg.common.gui.components.interactivespinner.JInteractiveSpinner;
  import org.gscg.common.gui.components.interactivespinner.SpinnerNumberModel;
  
  
  /***
   * The AmountSpinnerModel is a spinner model to indicate the amount for a
   * product. <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 is 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:53 $
   * @since 1.0.0 <br>
   */
  public class AmountSpinnerPanel extends JPanel implements MouseListener
  {
  	/*** the serial version uid */
  	private static final long serialVersionUID = 11L;
  
  	/*** the name of the spinner */
  	public static final String AMOUNT_SPINNER_NAME = "AMOUNT_SPINNER";
  
  	/*** the day spinner */
  	private JInteractiveSpinner spinner = null;
  
  	/*** the minimum */
  	private double minimum = 1.0;
  
  	/*** the maximum */
  	private double maximum = 1000;
  
  	/*** the step size */
  	private int stepSize = 1;
  
  	/*** the initial value */
  	private int initialvalue = 0;
  
  	/*** indicates whether the spinner is being changed */
  	private boolean pressed = false;
  
  	/*** the thread for increasing the stepsize */
  	private IncreaseStepSizeThread increaseThread = null;
  
  	/*** the formatted text field */
  	private JFormattedTextField ftf = null;
  
  	/***
  	 * constructs a new AmountSpinnerPanel, initializes the spinner with a
  	 * minimum of 1, a maximum of 1000 and a stepsize of 1
  	 * 
  	 * @param editable indicates whether the spinner is editable
  	 * @param initialvalue the initial value of the spinner
  	 */
  	public AmountSpinnerPanel(final boolean editable, final int initialvalue)
  	{
  		this(editable, 1.0, 1000.0, 1, initialvalue);
  	}
 
 	/***
 	 * 
 	 * constructs a new AmountSpinnerPanel
 	 * 
 	 * @param editable indicates whether the spinner is editable
 	 * @param minimum the minimum value
 	 * @param maximum the maximum value
 	 * @param stepsize the step size
 	 * @param initialvalue the initial value of the spinner
 	 */
 	public AmountSpinnerPanel(final boolean editable, final double minimum,
 			final double maximum, final int stepsize, final int initialvalue)
 	{
 		this(editable, minimum, maximum, stepsize, initialvalue, null);
 	}
 
 
 	/***
 	 * constructs a new AmountSpinnerPanel
 	 * 
 	 * @param editable indicates whether the spinner is editable
 	 * @param minimum the minimum value
 	 * @param maximum the maximum value
 	 * @param stepsize the step size
 	 * @param initialvalue the initial value of the spinner
 	 * @param changeListener the changelistener, may be null
 	 */
 	public AmountSpinnerPanel(final boolean editable, final double minimum,
 			final double maximum, final int stepsize, final int initialvalue,
 			final ChangeListener[] changeListener)
 	{
 		super();
 
 		try
 		{
 			this.minimum = minimum;
 			this.maximum = maximum;
 			this.stepSize = stepsize;
 			this.initialvalue = initialvalue;
 
 			double[][] layout = {{250}, {20}};
 			this.setLayout(new TableLayout(layout));
 			this.setOpaque(false);
 
 			JPanel amountParametersPanel = new JPanel();
 			amountParametersPanel.setLayout(new BoxLayout(
 					amountParametersPanel, BoxLayout.X_AXIS));
 			amountParametersPanel.setOpaque(false);
 
 			this.add(amountParametersPanel, "0,0,L,C");
 			String[] labels = {""};
 
 			// add the abel-spinner pair
 			SpinnerModel amountModel = new SpinnerNumberModel(
 					this.initialvalue, // initial
 					// value
 					this.minimum, // min
 					this.maximum, // max
 					this.stepSize); // step
 
 			this.spinner = SpinnerUtilities.addLabeledInteractiveSpinner(
 					amountParametersPanel, labels[0], amountModel);
 			this.spinner.setEnabled(editable);
 			this.spinner.setName(AmountSpinnerPanel.AMOUNT_SPINNER_NAME);
 
 			// we add the changelistener, if not null
 			if (changeListener != null)
 			{
 				for (int i = 0; i < changeListener.length; i++)
 				{
 					this.spinner.addChangeListener(changeListener[i]);
 				}
 			}
 
 			// we implement a mouse listener to play with increased stepsize as
 			// the spinner has been pressed
 			Object[] keys = this.spinner.getComponents();
 			for (int i = 0; i < keys.length; i++)
 			{
 				Object obj = this.spinner.getComponents()[i];
 				if (JButton.class.isAssignableFrom(obj.getClass()))
 				{
 					((JButton) obj).addMouseListener(this);
 				}
 			}
 
 			// tweak the spinner's formatted text field.
 			this.ftf = null;
 
 			this.ftf = SpinnerUtilities.getTextField(this.spinner);
 			if (this.ftf != null)
 			{
 				this.ftf.setColumns(5); // specify more width than we need
 				this.ftf.setHorizontalAlignment(SwingConstants.RIGHT);
 				this.ftf.setEditable(true); // set the textfield editable
 				this.ftf.setSelectionColor(Color.BLUE);
 				this.ftf.setSelectedTextColor(Color.WHITE);
 			}
 		} catch (Exception exception)
 		{
 			exception.printStackTrace();
 		}
 	}
 
 	/***
 	 * @return Returns the spinner.
 	 */
 	public JInteractiveSpinner getSpinner()
 	{
 		return this.spinner;
 	}
 
 	/***
 	 * @return returns the amount of the spinner
 	 */
 	public double getAmount()
 	{
 		double amount = Double.NaN;
 		try
 		{
 			amount = new Double(this.ftf.getText()).doubleValue();
 
 			if (!this.ftf.isEditValid())
 			{
 				JOptionPane
 						.showConfirmDialog(
 								(Component) null,
 								"The value you entered for the amount is either too large or too small, please adjust the value.",
 								"Warning", JOptionPane.DEFAULT_OPTION,
 								JOptionPane.WARNING_MESSAGE);
 				return -Double.MAX_VALUE;
 			}
 		} catch (Exception exception)
 		{
 			return -Double.MAX_VALUE;
 		}
 		return amount;
 	}
 
 	/***
 	 * @see java.awt.event.MouseListener#mouseClicked(java.awt.event.MouseEvent)
 	 */
 	public void mouseClicked(final MouseEvent e)
 	{
 		// nothing to do
 	}
 
 	/***
 	 * @see java.awt.event.MouseListener#mouseEntered(java.awt.event.MouseEvent)
 	 */
 	public void mouseEntered(final MouseEvent e)
 	{
 		// nothing to do
 	}
 
 	/***
 	 * @see java.awt.event.MouseListener#mouseExited(java.awt.event.MouseEvent)
 	 */
 	public void mouseExited(final MouseEvent e)
 	{
 		// nothing to do
 	}
 
 	/***
 	 * @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)
 	 */
 	public void mousePressed(final MouseEvent e)
 	{
 		this.pressed = true;
 		this.increaseThread = new IncreaseStepSizeThread(this);
 		this.increaseThread.start();
 	}
 
 	/***
 	 * @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent)
 	 */
 	public void mouseReleased(final MouseEvent e)
 	{
 		this.pressed = false;
 		try
 		{
 			this.increaseThread = null;
 			// reset the spinner model
 			SpinnerModel model = new SpinnerNumberModel(((Double) this.spinner
 					.getValue()).doubleValue(), // initial
 					// value
 					this.minimum, // min
 					this.maximum, // max
 					this.stepSize); // step
 			this.spinner.setModel(model);
 		} catch (Exception exception)
 		{
 			Logger.severe(this, "mouseReleased", exception);
 		}
 	}
 
 	/***
 	 * A thread used to increase the stepsize while the mouse button (either
 	 * increase or decrease) is being pressed.
 	 * <p>
 	 * 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 is 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:53 $
 	 * @since 1.0.6
 	 */
 	private class IncreaseStepSizeThread extends Thread
 	{
 		/*** the owner */
 		private AmountSpinnerPanel owner = null;
 
 		/***
 		 * constructs a new increaseStepSizeThread
 		 * 
 		 * @param owner the owner
 		 */
 		public IncreaseStepSizeThread(final AmountSpinnerPanel owner)
 		{
 			this.owner = owner;
 		}
 
 		/***
 		 * @see java.lang.Runnable#run()
 		 */
 		public void run()
 		{
 			super.run();
 
 			// if only cicked once, we must sleep a little
 			// while and than check whether we should run
 			try
 			{
 				Thread.sleep(500);
 				int count = 0;
 				while (this.owner.pressed)
 				{
 					count++;
 					double stepSize = this.owner.stepSize * count;
 					if (stepSize > (this.owner.maximum - ((Double) this.owner.spinner
 							.getValue()).doubleValue()))
 					{
 						stepSize = this.owner.maximum
 								- ((Double) this.owner.spinner.getValue())
 										.doubleValue();
 					}
 					if (stepSize > (((Double) this.owner.spinner.getValue())
 							.doubleValue() - this.owner.minimum))
 					{
 						stepSize = ((Double) this.owner.spinner.getValue())
 								.doubleValue()
 								- this.owner.minimum;
 					}
 					SpinnerModel model = new SpinnerNumberModel(
 							((Double) this.owner.spinner.getValue())
 									.doubleValue(),
 							// current value
 							this.owner.minimum, // min
 							this.owner.maximum, // max
 							stepSize); // step
 					this.owner.spinner.setModel(model);
 
 					// we sleep before increasing the time step
 					Thread.sleep(100);
 				}
 			} catch (Exception exception)
 			{
 				Logger.severe(this, "run", exception);
 			}
 		}
 	}
 }