jdatepanel.java

jdatepicker是一个swing开发的日期选择组件

package net.sourceforge.jdatepicker;

import java.awt.Color;
import java.awt.Component;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.text.DateFormat;
import java.text.DateFormatSymbols;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Iterator;
import java.util.Vector;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.SpinnerModel;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableColumn;
import javax.swing.table.TableModel;

/**
 * @author Juan Heyns
 * Created on 26-Mar-2004
 * Refactored on 21-Jun-2004
 * Refactored on 8-Jul-2004
 *
 */
public class JDatePanel extends JPanel {
	
	/**
	 * This inner class renders the table of the days
	 * TODO Refactor
	 */
	private class CalendarTableCellRenderer extends DefaultTableCellRenderer{


		public CalendarTableCellRenderer(){

		}

		public Component getTableCellRendererComponent(JTable arg0,
													   Object arg1,
													   boolean isSelected,
													   boolean hasFocus,
													   int row,
													   int col) {
			JLabel label = (JLabel)super.getTableCellRendererComponent(arg0,arg1,isSelected,hasFocus,row,col);
			label.setHorizontalAlignment(JLabel.CENTER);
			
			if (row == -1){
				String head = (String)arg1;
				label.setForeground(new Color(10,36,106));
				label.setBackground(Color.WHITE);
				label.setHorizontalAlignment(JLabel.CENTER);
				return label;
			}

			GregorianCalendar cal = (GregorianCalendar) calendarModel.getCalendarClone();
			Integer day = (Integer)arg1;
			Calendar today = new GregorianCalendar();
			int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);

			//Setting Foreground
			if (cal.get(Calendar.DATE) == day.intValue()){
				if (today.get(Calendar.DATE) == day.intValue() &&
			        today.get(Calendar.MONTH) == calendarModel.getCalendar(Calendar.MONTH) &&
			        today.get(Calendar.YEAR) == calendarModel.getCalendar(Calendar.YEAR)) 
				{
					label.setForeground(Color.RED);
				}
				else {
					label.setForeground(Color.WHITE);
				}
			} 
			else if (day.intValue()<1 || day.intValue()>lastDay){
				label.setForeground(Color.LIGHT_GRAY);
				if (day.intValue()>lastDay){
					label.setText(Integer.toString(day.intValue()-lastDay));
				}
				else{
					Calendar lastMonth = new GregorianCalendar();
					lastMonth.set(cal.get(Calendar.YEAR),cal.get(Calendar.MONTH)-1,1);
					int lastDayLastMonth = lastMonth.getActualMaximum(Calendar.DAY_OF_MONTH);
					label.setText(Integer.toString(lastDayLastMonth+day.intValue()));
				}
			} 
			else {
				if (today.get(Calendar.DATE) == day.intValue() &&
				        today.get(Calendar.MONTH) == calendarModel.getCalendar(Calendar.MONTH) &&
				        today.get(Calendar.YEAR) == calendarModel.getCalendar(Calendar.YEAR)) 
				{
					label.setForeground(Color.RED);
				}
				else {
					label.setForeground(Color.BLACK);
				}
			}
			
			//Setting background
			if (cal.get(Calendar.DATE) == day.intValue()){
				label.setBackground(new Color(10,36,106));
			} 
			else {
				label.setBackground(Color.WHITE);
			}
			
			return label;
		}

	}

	/**
	 * This inner class hides the public event handling methods from the outside
	 * TODO Refactor
	 */
	private class EventHandler implements ActionListener, MouseListener, ChangeListener{

		public void actionPerformed(ActionEvent arg0) {
			if (arg0.getSource() == nextMonthButton){
				GregorianCalendar cal = (GregorianCalendar)calendarModel.getCalendarClone();
				int day = cal.get(Calendar.DATE);
				cal.set(cal.get(Calendar.YEAR),cal.get(Calendar.MONTH)+1,1);
				if (day > cal.getActualMaximum(Calendar.DAY_OF_MONTH)){
					cal.set(Calendar.DATE,cal.getActualMaximum(Calendar.DAY_OF_MONTH));
				}
				else {
					cal.set(Calendar.DATE,day);
				}
				calendarModel.setCalendar(cal.getTime());
			}
			else if (arg0.getSource() == previousMonthButton){
				GregorianCalendar cal = (GregorianCalendar)calendarModel.getCalendarClone();
				int day = cal.get(Calendar.DATE);
				cal.set(cal.get(Calendar.YEAR),cal.get(Calendar.MONTH)-1,1);
				if (day > cal.getActualMaximum(Calendar.DAY_OF_MONTH)){
					cal.set(Calendar.DATE,cal.getActualMaximum(Calendar.DAY_OF_MONTH));
				}
				else {
					cal.set(Calendar.DATE,day);
				}
				calendarModel.setCalendar(cal.getTime());
			}
			else if (arg0.getSource() == nextYearButton) {
				GregorianCalendar cal = (GregorianCalendar)calendarModel.getCalendarClone();
				cal.set(cal.get(Calendar.YEAR) + 1, cal.get(Calendar.MONTH), cal.get(Calendar.DATE));
				calendarModel.setCalendar(cal.getTime());
			}
			else if (arg0.getSource() == previousYearButton) {
				GregorianCalendar cal = (GregorianCalendar)calendarModel.getCalendarClone();
				cal.set(cal.get(Calendar.YEAR) - 1, cal.get(Calendar.MONTH), cal.get(Calendar.DATE));
				calendarModel.setCalendar(cal.getTime());
			} else {
				for (int month=0; month<monthPopupMenuItems.length; month++) {
					if (arg0.getSource() == monthPopupMenuItems[month]){
						GregorianCalendar cal = (GregorianCalendar)calendarModel.getCalendarClone();
						int day = cal.get(Calendar.DATE);
						cal.set(cal.get(Calendar.YEAR),month,1);
						if (day > cal.getActualMaximum(Calendar.DAY_OF_MONTH)){
							cal.set(Calendar.DATE,cal.getActualMaximum(Calendar.DAY_OF_MONTH));
						}
						else {
							cal.set(Calendar.DATE,day);
						}
						calendarModel.setCalendar(cal.getTime());
					}
				}
			}
		}

		public void mouseClicked(MouseEvent arg0) {
			if (arg0.getSource() == monthLabel){
				getMonthPopupMenu().setLightWeightPopupEnabled(false);
				monthPopupMenu.show((Component) arg0.getSource(),arg0.getX(),arg0.getY());
			}
			else if (arg0.getSource() == todayLabel){
				calendarModel.setCalendar(new Date());
				fireActionPerformed();
			}
			else if (arg0.getSource() == dayTable){
				int row = dayTable.getSelectedRow();
				int col = dayTable.getSelectedColumn();
				if (row >= 0 && row <= 5) {
					Integer date = (Integer)calendarModel.getValueAt(row, col);
					calendarModel.setCalendar(Calendar.DAY_OF_MONTH,date.intValue());
					fireActionPerformed();
				}
			}
		}

		public void mouseEntered(MouseEvent arg0) {
		}

		public void mouseExited(MouseEvent arg0) {
		}

		public void mousePressed(MouseEvent arg0) {
		}

		public void mouseReleased(MouseEvent arg0) {
		}

		public void stateChanged(ChangeEvent arg0) {
			if (arg0.getSource()==calendarModel){
				Iterator i = getChangeListeners().iterator();
				while (i.hasNext()){
					ChangeListener cl = (ChangeListener) i.next();
					cl.stateChanged(new ChangeEvent(JDatePanel.this));
				}
			}
		}
	}

	/**
	 * This model represents the selected date, it is used by the table and year spinner
	 * TODO has to be refactored
	 */
	private class GregorianCalendarModel implements TableModel, SpinnerModel{

		private GregorianCalendar calendar;
		private Vector changeListeners;     // spinner
		private Vector monthLabels;         // label
		private Vector tableModelListeners; // table

		public GregorianCalendarModel(){
			calendar = new GregorianCalendar();
			changeListeners = new Vector();
			tableModelListeners = new Vector();
			monthLabels = new Vector();
		}

		public void addChangeListener(ChangeListener arg0) {
			changeListeners.add(arg0);
		}

		public void addMonthLabel(JLabel label){
			monthLabels.add(label);
			fireMonthTextFieldsUpdate();
		}

		public void addTableModelListener(TableModelListener arg0) {
			tableModelListeners.add(arg0);
		}

		public void addTodayLabel(JLabel label) {
			DateFormat df1 = DateFormat.getDateInstance(DateFormat.MEDIUM);
			label.setText("Today: " + df1.format(new Date()));
		}

		private void fireCalendarChanged(){
			//notify the spinner view of a change
			Iterator i = changeListeners.iterator();
			while (i.hasNext()){
				ChangeListener cl = (ChangeListener) i.next();
				cl.stateChanged(new ChangeEvent(this));
			}
		}

		public void fireCalendarInvalidated(){
			fireCalendarChanged();
			fireTableModelEvent();
			fireMonthTextFieldsUpdate();
		}

		private void fireMonthTextFieldsUpdate(){
			//change monthLabel text
			Iterator i = monthLabels.iterator();
			while (i.hasNext()){
				JLabel label = (JLabel) i.next();
				DateFormatSymbols df = new DateFormatSymbols();
				label.setText(df.getMonths()[calendar.get(Calendar.MONTH)]);
			}
		}

		private void fireTableModelEvent(){
			//notify the table view of a change
			Iterator i = tableModelListeners.iterator();
			while (i.hasNext()){
				TableModelListener tl = (TableModelListener) i.next();
				tl.tableChanged(new TableModelEvent(this));
			}
		}

		public int getCalendar(int field){
			return calendar.get(field);
		}

		public Calendar getCalendarClone(){
			return (Calendar) calendar.clone();
		}

		public Class getColumnClass(int arg0) {
			return Integer.class;
		}

		public int getColumnCount() {
			return 7;
		}

		public String getColumnName(int arg0) {
			String name = "";
			switch (arg0){
				case 0:
					name = "Sun";
					break;
				case 1:
					name = "Mon";
					break;
				case 2:
					name = "Tue";
					break;
				case 3:
					name = "Wed";
					break;
				case 4:
					name = "Thu";
					break;
				case 5:
					name = "Fri";
					break;
				case 6:
					name = "Sat";
					break;
			}
			return name;
		}

		public Object getNextValue() {
			return Integer.toString(getCalendar(Calendar.YEAR)+1);
		}

		public Object getPreviousValue() {
			return Integer.toString(getCalendar(Calendar.YEAR)-1);
		}

		public int getRowCount() {
			return 6;
		}

		public Object getValue() {
			return Integer.toString(getCalendar(Calendar.YEAR));
		}

		public Object getValueAt(int arg0, int arg1) {
			Calendar firstDayOfMonth = (Calendar) calendar.clone();
			firstDayOfMonth.set(Calendar.DATE,1);
			int DOW = firstDayOfMonth.get(Calendar.DAY_OF_WEEK);
			int value = arg1 - DOW + arg0*7 + 2;
			return new Integer(value);
		}

		public boolean isCellEditable(int arg0, int arg1) {
			return false;
		}

		public void removeChangeListener(ChangeListener arg0) {
			changeListeners.remove(arg0);
		}

		public void removeMonthLabel(JLabel label){
			monthLabels.remove(label);
		}

		public void removeTableModelListener(TableModelListener arg0) {
			tableModelListeners.remove(arg0);
		}

		public void setCalendar(Date date){
			calendar.setTime(date);
			fireCalendarInvalidated();
		}

		public void setCalendar(int field, int value){
			calendar.set(field, value);
			fireCalendarInvalidated();
		}

		public void setCalendar(int year,int month, int date){
			calendar.set(year, month, date);
			fireCalendarInvalidated();
		}

		public void setValue(Object arg0) {
			int year = Integer.parseInt((String)arg0);
			setCalendar(Calendar.YEAR,year);
		}

		public void setValueAt(Object arg0, int arg1, int arg2) {
		}
	}
	
	/**
	 * This tests the JDatePanel
	 * @param args
	 */
	public static void main(String[] args) {
		JFrame testFrame = new JFrame();
		JPanel content = new JPanel();
		//content.add(new JDatePanel());
		//testFrame.getContentPane().add(content);
		JDatePanel datePanel = new JDatePanel();
		datePanel.setShowYearButtons(true);
		testFrame.getContentPane().add(datePanel);
		datePanel.setShowYearButtons(false);
		datePanel.setShowYearButtons(true);

		testFrame.setSize(300,300);
		testFrame.addWindowFocusListener(new WindowAdapter(){
			public void windowClosing(WindowEvent arg0) {
				System.exit(0);
			}
		});
		testFrame.setVisible(true);
	}
	
	private Vector actionListeners = null;
	
	private GregorianCalendarModel calendarModel = null;
	
	private javax.swing.JPanel centerPanel = null;
	private Vector changeListeners = null;
	
	private javax.swing.JTable dayTable = null;
	
	private CalendarTableCellRenderer dayTableCellRenderer = null;
	private JTableHeader dayTableHeader = null;
	private EventHandler eventHandler = null;
	private javax.swing.JLabel monthLabel = null;
	private javax.swing.JPopupMenu monthPopupMenu = null;
	private JMenuItem[] monthPopupMenuItems = null;
	private javax.swing.JButton nextMonthButton = null;
	private javax.swing.JPanel northCenterPanel = null;
	
	private javax.swing.JPanel northPanel = null;
	private javax.swing.JButton previousMonthButton = null;
	private javax.swing.JPanel southPanel = null;
	private javax.swing.JLabel todayLabel = null;
	private javax.swing.JSpinner yearSpinner = null;
	private javax.swing.JButton previousYearButton = null;
	private javax.swing.JButton nextYearButton = null;
	private javax.swing.JPanel previousButtonPanel = null;
	private javax.swing.JPanel nextButtonPanel = null;

	private boolean showYearButtons = false;
	
	/**
	 * This is the default constructor
	 */
	public JDatePanel() {
		super();
		initialize();
	}
	
	public void setFontSize(int size) {
		Font font = new Font ("Arial", Font.PLAIN, size);
		getMonthLabel().setFont(font);
		getTodayLabel().setFont(font);
		getYearSpinner().setFont(font);
		dayTable.setFont(font);
		dayTable.setRowHeight(size*2);
		//getDayTable().
	}

	/**
	 * The actionListener is notified when a user clicks on a date
	 * @param arg
	 */
	public void addActionListener(ActionListener arg){
		getActionListeners().add(arg);
	}

	/**
	 * Change listeners will be notified when the selected date is changed
	 * @param arg
	 */
	public void addChangeListener(ChangeListener arg){
		getChangeListeners().add(arg);
	}

	/**
	 * called internally when actionListeners should be notified
	 *
	 */
	private void fireActionPerformed(){
		Iterator i = getActionListeners().iterator();
		while (i.hasNext()){
			ActionListener al = (ActionListener) i.next();
			al.actionPerformed(new ActionEvent(this,ActionEvent.ACTION_PERFORMED,"date selected"));
		}
	}
	
	private Vector getActionListeners(){
		if (actionListeners == null) {
			actionListeners = new Vector();