/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans-Common.
    *
    * CosyBeans-Common is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
   *
   * CosyBeans-Common 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 CosyBeans-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.components;
  
  import java.awt.BorderLayout;
  import java.awt.Font;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Insets;
  import java.awt.event.ItemEvent;
  import java.awt.event.ItemListener;
  import java.text.DateFormatSymbols;
  import java.text.SimpleDateFormat;
  import java.util.Calendar;
  import java.util.Date;
  import java.util.GregorianCalendar;
  
  import javax.swing.DefaultComboBoxModel;
  import javax.swing.JComboBox;
  import javax.swing.JComponent;
  import javax.swing.JDialog;
  import javax.swing.JLabel;
  import javax.swing.border.CompoundBorder;
  import javax.swing.border.EmptyBorder;
  
  import com.cosylab.gui.components.util.CosyUIElements;
  import com.cosylab.gui.components.util.FontHelper;
  import com.cosylab.gui.property.editors.PropertyEditor;
  
  
  /**
   * This class provides user-friendly entry of dates. The component consists of
   * three combo boxes containing year, month and day values. All values are
   * validated and always display a valid date. This is then provided by getDate
   * and setDate methods. User can listen to PropertyChangeEvent to get notifications 
   * when a date was changed When setting or getting the date from or to
   * java.util.Date class, only YEAR, MONTH and DAY_OF_MONTH properties are set.
   * 
   *
   * @author <a href="mailto:ales.pucelj@cosylab.com">Ales Pucelj</a>
   * @version $id$
   *
   * @see java.util.Calendar GregorianCalendar class is used to calculate the
   *      dates. Since only the number of years is unlimited, it is set to 20 by
   *      default, allowing years 2000 through 2019 inclusively to be chosen.
   *      This can, however, be modified.
   */
  public class SimpleDateSelector extends JComponent implements PropertyEditor
  {
  	private static final long serialVersionUID = 1L;
  	private int numberOfYears = 20;
  	private JLabel dayLabel;
  	private JLabel monthLabel;
  	private JLabel yearLabel;
  	private final Calendar calendar = new GregorianCalendar();
  	int startingYear = 2000;
  	JComboBox daySelector;
  	JComboBox monthSelector;
  	JComboBox yearSelector;
  
  	/**
  	 * Listens for changes of combo boxes.
  	 */
  	private final class DateChangeListener implements ItemListener
  	{
  		/**
  		 * Updates selected values on changes in combo boxes.
  		 *
  		 * @param e ItemEvent
  		 *
  		 * @see java.awt.event.ItemListener#itemStateChanged(ItemEvent)
  		 */
  		public final void itemStateChanged(ItemEvent e)
  		{
  			if (e.getStateChange() != ItemEvent.SELECTED) {
  				return;
  			}
  
  			final SimpleDateSelector owner = SimpleDateSelector.this;
              Date old=owner.getDate();
  			if (e.getSource() == owner.daySelector) {
  				owner.setDay(owner.daySelector.getSelectedIndex() + 1);
                 firePropertyChange("date", old, owner.getDate());
 				return;
 			}
 
 			if (e.getSource() == owner.monthSelector) {
 				owner.setMonth(owner.monthSelector.getSelectedIndex());
                 firePropertyChange("date", old, owner.getDate());
 				return;
 			}
 
 			if (e.getSource() == owner.yearSelector) {
 				owner.setYear(owner.yearSelector.getSelectedIndex()
 				    + owner.startingYear);
                 firePropertyChange("date", old, owner.getDate());
 			}
 		}
 	}
 
 	/**
 	 * Default constructor for SimpleDateSelector.
 	 */
 	public SimpleDateSelector()
 	{
 		this(new Date());
 	}
 
 	/**
 	 * Constructor for SimpleDateSelector.
 	 *
 	 * @param date Date Initial date to set.
 	 */
 	public SimpleDateSelector(Date date)
 	{
 		this(date, new GregorianCalendar().get(Calendar.YEAR) - 10, 25);
 	}
 
 	/**
 	 * Constructor for SimpleDateSelector.
 	 *
 	 * @param date Date Initial date to set.
 	 * @param fromYear int Initial starting year.
 	 * @param yearRange int Number of years to allow.
 	 */
 	public SimpleDateSelector(Date date, int fromYear, int yearRange)
 	{
 		super();
 
 		createComponents();
 
 		setStartingYear(fromYear);
 		setYearRange(fromYear, yearRange);
 
 		setDate(date);
 	}
 
 	/**
 	 * Constructor for SimpleDateSelector.
 	 *
 	 * @param fromYear int Initial starting year.
 	 * @param yearRange int Number of years to allow.
 	 */
 	public SimpleDateSelector(int fromYear, int yearRange)
 	{
 		this(new Date(), fromYear, yearRange);
 	}
 
 	/**
 	 * Constructor for SimpleDateSelector.
 	 *
 	 * @param day int
 	 * @param month int
 	 * @param year int
 	 */
 	public SimpleDateSelector(int day, int month, int year)
 	{
 		this(new GregorianCalendar(year, month, day).getTime());
 	}
 
 	/**
 	 * Constructor for SimpleDateSelector.
 	 *
 	 * @param day int
 	 * @param month int
 	 * @param year int
 	 * @param fromYear int
 	 * @param yearRange int
 	 */
 	public SimpleDateSelector(int day, int month, int year, int fromYear,
 	    int yearRange)
 	{
 		this(new GregorianCalendar(year, month, day).getTime(), fromYear,
 		    yearRange);
 	}
 
 	/**
 	 * Internal helper routine to adjust the component font.
 	 *
 	 * @param c JComponent
 	 */
 	private final void setComponentFont(JComponent c)
 	{
 		c.setFont(FontHelper.getFontWithStyle(Font.PLAIN, c.getFont()));
 	}
 
 	/**
 	 * Creates and lays out the components that represent this panel.
 	 */
 	private final void createComponents()
 	{
 		setLayout(new GridBagLayout());
 
 		setBorder(new CompoundBorder(CosyUIElements.getPlainBorder(true),
 		        new EmptyBorder(3, 3, 3, 3)));
 
 		dayLabel = new JLabel("Day");
 		setComponentFont(dayLabel);
 		add(dayLabel, createConstraints(0, 0, 0.1,0, 1, 1, 4));
 
 		monthLabel = new JLabel("Month");
 		setComponentFont(monthLabel);
 		add(monthLabel, createConstraints(1, 0, 1.0,0, 1, 1, 4));
 
 		yearLabel = new JLabel("Year");
 		setComponentFont(yearLabel);
 		add(yearLabel, createConstraints(2, 0, 0.1,0, 1, 1, 4));
 
 		daySelector = new JComboBox();
 		
 		setComponentFont(daySelector);
 		add(daySelector, createConstraints(0, 1, 0.1,1, 1, 1, 4));
 
 		monthSelector = new JComboBox();
 		setComponentFont(monthSelector);
 		populateMonths();
 		add(monthSelector, createConstraints(1, 1, 1.0,1, 1, 1, 4));
 
 		yearSelector = new JComboBox();
 		setComponentFont(yearSelector);
 		add(yearSelector, createConstraints(2, 1, 0.1,1, 1, 1, 4));
 
 		DateChangeListener dcl = new DateChangeListener();
 
 		daySelector.addItemListener(dcl);
 		monthSelector.addItemListener(dcl);
 		yearSelector.addItemListener(dcl);
 	}
 
 	/**
 	 * Internal helper routine returns GridBagConstraints object.
 	 *
 	 * @param x int
 	 * @param y int
 	 * @param ratio double
 	 * @param top int
 	 * @param bottom int
 	 * @param right int
 	 *
 	 * @return java.awt.GridBagConstraints
 	 */
 	private final GridBagConstraints createConstraints(int x, int y,
 	    double ratio, double weightY, int top, int bottom, int right)
 	{
 		GridBagConstraints constraints = new GridBagConstraints();
 		constraints.gridx = x;
 		constraints.gridy = y;
 		constraints.weightx = ratio;
 		constraints.weighty = weightY;
 		constraints.fill = GridBagConstraints.BOTH;
 		constraints.insets = new Insets(top, 0, bottom, right);
 		constraints.anchor = GridBagConstraints.WEST;
 
 		return constraints;
 	}
 
 	/**
 	 * Returns the currently selected date as java.util.Date.  Creation date:
 	 *
 	 * @return java.util.Date
 	 */
 	public Date getDate()
 	{
 		return calendar.getTime();
 	}
 
 	/**
 	 * Returns number of the selected day in current month, starting with 1.
 	 *
 	 * @return int
 	 */
 	public int getDay()
 	{
 		return calendar.get(Calendar.DAY_OF_MONTH);
 	}
 
 	/**
 	 * Returns the index of the currently selected month starting with 1.
 	 *
 	 * @return int
 	 */
 	public int getMonth()
 	{
 		return calendar.get(Calendar.MONTH);
 	}
 
 	/**
 	 * Returns the currently selected year.
 	 *
 	 * @return int
 	 */
 	public int getYear()
 	{
 		return calendar.get(Calendar.YEAR);
 	}
 
 	/**
 	 * Returns the number of year to display in the year selector.
 	 *
 	 * @return int
 	 */
 	public int getNumberOfYears()
 	{
 		return numberOfYears;
 	}
 
 	/**
 	 * Returns the starting year to display in the year selector. No year lower
 	 * than this can be selected by the user or set using setDate method.
 	 *
 	 * @return int
 	 */
 	public int getStartingYear()
 	{
 		return startingYear;
 	}
 
 	/**
 	 * Sets the date to display.
 	 *
 	 * @param date java.util.Date
 	 */
 	public void setDate(Date date)
 	{
 		Date old = calendar.getTime();
 
 		calendar.setTime(date);
 		setYear(getYear());
 
 		updateComponents();
 
 		firePropertyChange("date", old, date);
 	}
 
 	/**
 	 * Sets the day to the specified index. To ensure compatibility with
 	 * <code>java.util.Calendar</code> class, first day of month is specified
 	 * as 1. If the day set is outside allowed range, the value will be set to
 	 * the nearest allowed value.
 	 *
 	 * @param day int
 	 */
 	public void setDay(int day)
 	{
 		if (day == getDay()) {
 			return;
 		}
 
 		day = Math.max(day, calendar.getActualMinimum(Calendar.DAY_OF_MONTH));
 		day = Math.min(day, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
 
 		int old = getDay();
 
 		calendar.set(Calendar.DAY_OF_MONTH, day);
 
 		//		daySelector.setSelectedIndex(getDay() - 1);
 		//		daySelector.repaint();
 		firePropertyChange("day", old, day);
 	}
 
 	/**
 	 * Shows / hides the Year/Month/Day labels
 	 *
 	 * @param visible the visibility value
 	 */
 	public void setLabelsVisible(boolean visible)
 	{
 		yearLabel.setVisible(visible);
 		monthLabel.setVisible(visible);
 		dayLabel.setVisible(visible);
 	}
 
 	/**
 	 * Sets the currently selected month. January has the index of 0.
 	 *
 	 * @param month int
 	 */
 	public void setMonth(int month)
 	{
 		if (month == getMonth()) {
 			return;
 		}
 
 		month = Math.max(month, calendar.getActualMinimum(Calendar.MONTH));
 		month = Math.min(month, calendar.getActualMaximum(Calendar.MONTH));
 
 		int old = getMonth();
 
 		calendar.set(Calendar.MONTH, month);
 
 		updateComponents();
 
 		firePropertyChange("month", old, month);
 	}
 
 	/**
 	 * Sets the currently selected year. Years are specified absolutely,
 	 * although only years between startingYear and numberOfYears will be
 	 * displayed. If the year is not within this range, the closest value will
 	 * be set.
 	 *
 	 * @param year int
 	 */
 	public void setYear(int year)
 	{
 		if (year == getYear()) {
 			return;
 		}
 
 		year = Math.max(year, startingYear);
 		year = Math.min(year, startingYear + numberOfYears);
 
 		int old = getYear();
 
 		calendar.set(Calendar.YEAR, year);
 
 		updateComponents();
 
 		firePropertyChange("year", old, year);
 	}
 
 	/**
 	 * Sets the enabled state of this component. If the component is disabled,
 	 * all the combo boxes are also disabled.
 	 *
 	 * @param how boolean
 	 */
 	public void setEnabled(boolean how)
 	{
 		super.setEnabled(how);
 		daySelector.setEnabled(how);
 		monthSelector.setEnabled(how);
 		yearSelector.setEnabled(how);
 	}
 
 	/**
 	 * Sets the starting year to be displayed in the year selector. Only the
 	 * years between startingYear and startingYear+numberOfYears inclusively
 	 * can be selected by the user or by calling the setDate method.
 	 *
 	 * @param from int
 	 */
 	public void setStartingYear(int from)
 	{
 		setYearRange(from, startingYear);
 	}
 
 	/**
 	 * Sets the number of years to display in the year selector. User can only
 	 * select the years shown in the year selector.
 	 *
 	 * @param range int
 	 */
 	public void setNumberOfYears(int range)
 	{
 		setYearRange(startingYear, range);
 	}
 
 	/**
 	 * Sets new available year range.
 	 *
 	 * @param from int
 	 * @param range int
 	 */
 	public void setYearRange(int from, int range)
 	{
 		int old = getYear();
 
 		startingYear = (from < 1) ? 1 : from;
 		numberOfYears = Math.max(1, range);
 
 		populateYearNames();
 
 		setYear(old);
 
 		updateComponents();
 	}
 
 	/**
 	 * Internal helper routine updates the correct number of days for the
 	 * selected month.
 	 */
 	private final void populateDays()
 	{
 		int min = calendar.getActualMinimum(Calendar.DAY_OF_MONTH);
 		int max = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
 
 		int nDays = max - min + 1;
 
 		int old = getDay();
 		String[] dayNumbers = new String[nDays];
 
 		for (int i = 0; i < nDays; i++) {
 			dayNumbers[i] = String.valueOf(i + min);
 		}
 
 		daySelector.setModel(new DefaultComboBoxModel(dayNumbers));
 		setDay(old);
 	}
 
 	/**
 	 * Internal helper method populates the monthSelector with month labels.
 	 */
 	private final void populateMonths()
 	{
 		final SimpleDateFormat sdf = new SimpleDateFormat("MMMM");
 		final DateFormatSymbols dfs = sdf.getDateFormatSymbols();
 
 		monthSelector.setModel(new DefaultComboBoxModel(dfs.getMonths()));
 
 		/* **** BUGFIX BEGIN
 		 * noticed in: jdk 1.4.0
 		 * DateFormatSymbols.getDateFormatSymbols().getMonths() returns 13
 		 * labels with last label being empty string. We remove all elements
 		 * above index 12.
 		 */
 		while (monthSelector.getModel().getSize() > 12) {
 			monthSelector.removeItemAt(12);
 		}
 
 		/* **** BUGFIX END */
 	}
 
 	/**
 	 * Internal helper method populates the yearSelector with year labels for
 	 * the specified range.
 	 */
 	private final void populateYearNames()
 	{
 		String[] yearNames = new String[numberOfYears];
 
 		for (int i = 0; i < yearNames.length; i++) {
 			yearNames[i] = String.valueOf(startingYear + i);
 		}
 
 		yearSelector.setModel(new DefaultComboBoxModel(yearNames));
 	}
 
 	/**
 	 * Updates the display after setting the value properties.
 	 */
 	private final void updateComponents()
 	{
 		populateDays();
 
 		daySelector.setSelectedIndex(getDay() - 1);
 		monthSelector.setSelectedIndex(getMonth());
 
 		if (getYear() < startingYear) {
 			setYear(startingYear);
 		}
 
 		yearSelector.setSelectedIndex(getYear() - startingYear);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.property.PropertyEditor#getPropertyValue()
 	 */
 	public Object getPropertyValue()
 	{
 		return getDate();
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.property.PropertyEditor#setPropertyValue(java.lang.Object)
 	 */
 	public boolean setPropertyValue(Object value)
 	{
 		if (value instanceof Date) {
 			setDate((Date)value);
 
 			return true;
 		}
 
 		return false;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.property.PropertyEditor#getDescription()
 	 */
 	public String getDescription()
 	{
 		return null;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.property.PropertyEditor#setDescription(java.lang.String)
 	 */
 	public void setDescription(String description)
 	{
 	}
 	
 	public void setCompactView(boolean compact) {
 		dayLabel.setVisible(!compact);
 		monthLabel.setVisible(!compact);
 		yearLabel.setVisible(!compact);
 	}
 	
 	/**
 	 * Run test applet.
 	 *
 	 * @param args command line parameters
 	 */
 	public static void main(String[] args)
 	{
 		JDialog dialog = new JDialog();
 		dialog.setModal(true);
 		dialog.setSize(300, 100);
 		dialog.getContentPane().setLayout(new BorderLayout());
 
 		SimpleDateSelector dc = new SimpleDateSelector(new Date(), 1995, 100);
 		
 		dialog.getContentPane().add(dc, BorderLayout.CENTER);
 		
 		//		dc.setDate((new Date(System.currentTimeMillis())));
 		//		dc.setStartingYear(1998);
 		//		dc.setNumberOfYears(500);
 		dialog.setVisible(true);
 
 		System.exit(0);
 	}
 }
 
 /* __oOo__ */