Java Swing 日期控件（转载）

package com.ryd.stocktrader.client.util;

import java.awt.Color;
import java.awt.GridLayout;
import java.awt.Label;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.SwingConstants;

public class CalendarPanel extends JPanel {

    /**
     *
     */
    private static final long serialVersionUID = 1L;

    private JLabel btn_lastYear = null;
    private JLabel btn_nextYear = null;
    private JLabel btn_lastMonth = null;
    private JLabel btn_nextMonth = null;
    private JLabel lb_datetime = null;
    private JPanel panel_maincalenderpanel = null;
    private JLabel lblNewLabel = null;
    private JLabel label = null;
    private JLabel label_1 = null;
    private JLabel label_2 = null;
    private JLabel label_3 = null;
    private JLabel label_4 = null;
    private JLabel label_5 = null;
    private JLabel btn_close = null;
    private JButton btn_today = null;
    private JButton btn_cancel = null;
    private Object component = null;       //日历控件的载体组件，如TextField
    private String returnDateStr = null;   //保存选中的日期
    private CallBack callBack = null;

    private String patern = "yyyy-MM-dd";     //日期格式
    private SimpleDateFormat sdf = null;
    private String nowDatetime = null ;    //当前系统日期字符串


    /**
     * 带参数的构造函数，该构造函数将构造一个设置了日历控件的载体组件的CalenderPanel对象实例
     * @param component  日历控件的载体组件，可以是TextField、JTextField、Label、JLabel
     * @param patern  日期格式 ，默认为yyyy-MM-dd
     */
    public CalendarPanel(Object component,String patern) {
        this(patern);
        this.component = component;
    }


    /**
     * 带参数的构造函数，该构造函数将构造一个CalenderPanel对象实例，该对象时候没有设置日历控件的载体组件
     * * @param patern  日期格式，默认为yyyy-MM-dd
     */
    public CalendarPanel(String patern) {
        super();

        //初始化日期格式化
        this.patern = patern;
        sdf = new SimpleDateFormat(patern);
        nowDatetime = sdf.format(new Date());

        setLayout(null);
        //设置日历控件的整体主面板边框为灰色
        this.setBorder(BorderFactory.createLineBorder(Color.gray));
        //初始化日历控件上的各个组件
        init();
        //创建日历控件的日期部分面板
        createCalendarPanel(nowDatetime);
    }

    /**
     * 无参数的构造函数，该构造函数将构造一个CalenderPanel对象实例，该对象时候没有设置日历控件的载体组件
     */
    public CalendarPanel() {
        super();

        //初始化日期格式化
        sdf = new SimpleDateFormat(patern);
        nowDatetime = sdf.format(new Date());

        setLayout(null);
        //设置日历控件的整体主面板边框为灰色
        this.setBorder(BorderFactory.createLineBorder(Color.gray));
        //初始化日历控件上的各个组件
        init();
        //创建日历控件的日期部分面板
        createCalendarPanel(nowDatetime);
    }

    /**
     * 获取日历控件的载体组件
     * @return  返回该日历控件中的载体组件，如果没有设置，则返回null;
     */
    public Object getComponent() {
        return component;
    }

    /**
     * 设置日历控件的载体组件
     * @param component
     */
    public void setComponent(Object component) {
        this.component = component;
    }

    /**
     * 获取选择日期时候的日期字符串
     * @return
     */
    public String getReturnDateStr() {
        return returnDateStr;
    }

    /**
     * 获取日历控件的回调接口对象
     * @return
     */
    public CallBack getCallBack() {
        return callBack;
    }

    /**
     * 设置日历控件的回调接口对象
     * @param callBack
     */
    public void setCallBack(CallBack callBack) {
        this.callBack = callBack;
    }


    /**
     * 创建下拉选择日历控件的主体面板(即显示日期部分的面板)
     * @param date   需要显示的日期
     */
    private void createCalendarPanel(String date){
        //每次刷新日期显示，需要重新创建日期部分的面板
        //如果日期部分的面板不为null,可以先将其remove，然后再创建
        if(panel_maincalenderpanel!=null){
            panel_maincalenderpanel.setVisible(false);
            this.remove(panel_maincalenderpanel);
        }

        //创建新的日期部分的面板
        panel_maincalenderpanel = new JPanel();
        panel_maincalenderpanel.setBackground(Color.WHITE);
        panel_maincalenderpanel.setBounds(2, 47, 247, 156);
        panel_maincalenderpanel.setLayout(new GridLayout(6,7));
        add(panel_maincalenderpanel);

        Date today = null;
        try {
            today = sdf.parse(date);
        } catch (ParseException e1) {
            e1.printStackTrace();
            return;
        }

        Calendar c = new GregorianCalendar();
        //将给定日期设置为需要显示的日期
        c.setTime(today);
        //需要将日改成1号，因为我们需要获取给定日期的第一天是星期几
        c.set(c.get(Calendar.YEAR),c.get(Calendar.MONTH), 1);

        int firstDayInMonthOfWeek = c.get(Calendar.DAY_OF_WEEK);              //给定日期的第一天是星期几
        int daysOfMonth  = c.getActualMaximum(Calendar.DAY_OF_MONTH);         //给定日期对应月份的天数

        //首先生成给定日期第一天之前的空白部分
        //例如：2011-11的第一天就是星期二，那么星期二之前的（星期日，星期一）我们不显示内容，需要生成空白
        for(int i=1;i<firstDayInMonthOfWeek;i++){
            JLabel bnt = new JLabel("");
            bnt.setSize(27,23);
            bnt.setBackground(Color.WHITE);
            panel_maincalenderpanel.add(bnt);
        }

        //然后生成给定日期的日期部分，即输出1,2,3....31这样的日期
        for(int i=1;i<=daysOfMonth;i++){
            final JLabel bnt = new JLabel(String.valueOf(i));
            bnt.setHorizontalAlignment(SwingConstants.CENTER);
            bnt.setSize(27,23);
            bnt.setBackground(Color.WHITE);
            if(Calendar.getInstance().get(Calendar.DATE)==i){
                //将系统当期日期对应的组件的边框显示为绿色
                bnt.setBorder(BorderFactory.createLineBorder(Color.GREEN));
            }else{
                //其他的日期组件边框显示为白色
                bnt.setBorder(BorderFactory.createLineBorder(Color.WHITE));
            }

            //为定义的日期组件添加鼠标事件
            bnt.addMouseListener(new MouseAdapter() {
                @Override
                public void mouseEntered(MouseEvent e) {
                    //当鼠标经过对应的日期上面时候，该日期对应的组件边框显示成绿色
                    bnt.setBorder(BorderFactory.createLineBorder(Color.GREEN));
                }

                @Override
                public void mouseExited(MouseEvent e) {
                    if(Calendar.getInstance().get(Calendar.DATE)==Integer.parseInt(((JLabel)e.getSource()).getText().trim())){
                        //当鼠标离开对应日期组件时候，系统当期日期对应的组件的边框显示为绿色
                        bnt.setBorder(BorderFactory.createLineBorder(Color.GREEN));
                    }else{
                        //其他的日期对应的组件边框为白色
                        bnt.setBorder(BorderFactory.createLineBorder(Color.WHITE));
                    }
                }

                @Override
                public void mouseClicked(MouseEvent e) {

                    //鼠标单击事件，当鼠标选择某个日期时候，需要将对应的日期按照给定的日期格式填充到日历控件的载体组件上，即setText(..)
                    String dateStr = lb_datetime.getText().trim();
                    try {
                        dateStr = sdf.format(sdf.parse(dateStr));
                        dateStr = dateStr.substring(0,dateStr.length()-2);
                        if (component instanceof java.awt.TextField){
                            TextField txt = (TextField)component;
                            dateStr += ((JLabel)e.getSource()).getText().trim();
                            dateStr = sdf.format(sdf.parse(dateStr));
                            txt.setText(dateStr);
                        }
                        if (component instanceof java.awt.Label){
                            Label label = (Label)component;
                            dateStr += ((JLabel)e.getSource()).getText().trim();
                            dateStr = sdf.format(sdf.parse(dateStr));
                            label.setText(dateStr);

                        }
                        if (component instanceof javax.swing.JTextField){
                            JTextField txt = (JTextField)component;
                            dateStr += ((JLabel)e.getSource()).getText().trim();
                            dateStr = sdf.format(sdf.parse(dateStr));
                            txt.setText(dateStr);

                        }
                        if (component instanceof javax.swing.JLabel){
                            JLabel label = (JLabel)component;
                            dateStr += ((JLabel)e.getSource()).getText().trim();
                            dateStr = sdf.format(sdf.parse(dateStr));
                            label.setText(dateStr);
                        }

                    } catch (ParseException e2) {
                        e2.printStackTrace();
                    }



                    //为了能够让那个载体组件自用空，这里也需要设置returnDateStr并调用回调接口
                    returnDateStr = dateStr;
                    if(callBack!=null){
                        callBack.callback();
                    }

                    //选择日期后需要将日历控件隐藏
                    CalendarPanel.this.setVisible(false);

                }


            });
            panel_maincalenderpanel.add(bnt);
        }

        for(int i=1;i<6*7-(firstDayInMonthOfWeek-1)-daysOfMonth;i++){
            JLabel bnt = new JLabel("");
            bnt.setSize(27,23);
            bnt.setBackground(Color.WHITE);
            panel_maincalenderpanel.add(bnt);
        }

        panel_maincalenderpanel.validate();
    }



    /**
     * 初始化所有控件
     */
    private void init(){
        //上一年操作组件，这里使用一个JLabel
        btn_lastYear = new JLabel("<<");
        btn_lastYear.setBounds(10, 0, 27, 23);
        add(btn_lastYear);
        btn_lastYear.addMouseListener(new MouseAdapter() {

            @Override
            public void mouseClicked(MouseEvent e) {
                //改变日历控件面板的显示日期
                changTheDate(Calendar.YEAR,false);
            }

        });

        //下一年操作组件，这里使用一个JLabel
        btn_nextYear = new JLabel(">>");
        btn_nextYear.setBounds(179, 0, 27, 23);
        add(btn_nextYear);
        btn_nextYear.addMouseListener(new MouseAdapter() {

            @Override
            public void mouseClicked(MouseEvent e) {
                //改变日历控件面板的显示日期
                changTheDate(Calendar.YEAR,true);
            }

        });

        //上一月操作组件，这里使用一个JLabel
        btn_lastMonth = new JLabel("<");
        btn_lastMonth.setBounds(39, 0, 27, 23);
        add(btn_lastMonth);
        btn_lastMonth.addMouseListener(new MouseAdapter() {

            @Override
            public void mouseClicked(MouseEvent e) {
                //改变日历控件面板的显示日期
                changTheDate(Calendar.MONTH,false);
            }

        });

        //下一月操作组件，这里使用一个JLabel
        btn_nextMonth = new JLabel(">");
        btn_nextMonth.setBounds(150, 0, 27, 23);
        add(btn_nextMonth);
        btn_nextMonth.addMouseListener(new MouseAdapter() {

            @Override
            public void mouseClicked(MouseEvent e) {
                //改变日历控件面板的显示日期
                changTheDate(Calendar.MONTH,true);
            }

        });

        //显示日期的lable对象
        lb_datetime = new JLabel("");
        lb_datetime.setBounds(58, 2, 86, 19);
        lb_datetime.setHorizontalAlignment(SwingConstants.CENTER);
        add(lb_datetime);
        lb_datetime.setText(nowDatetime);

        lblNewLabel = new JLabel("日");
        lblNewLabel.setForeground(Color.RED);
        lblNewLabel.setHorizontalAlignment(SwingConstants.CENTER);
        lblNewLabel.setBounds(2, 22, 27, 23);
        add(lblNewLabel);

        label = new JLabel("一");
        label.setHorizontalAlignment(SwingConstants.CENTER);
        label.setBounds(39, 22, 27, 23);
        add(label);

        label_1 = new JLabel("二");
        label_1.setHorizontalAlignment(SwingConstants.CENTER);
        label_1.setBounds(76, 22, 27, 23);
        add(label_1);

        label_2 = new JLabel("三");
        label_2.setHorizontalAlignment(SwingConstants.CENTER);
        label_2.setBounds(113, 22, 27, 23);
        add(label_2);

        label_3 = new JLabel("四");
        label_3.setHorizontalAlignment(SwingConstants.CENTER);
        label_3.setBounds(147, 22, 27, 23);
        add(label_3);

        label_4 = new JLabel("五");
        label_4.setHorizontalAlignment(SwingConstants.CENTER);
        label_4.setBounds(184, 22, 27, 23);
        add(label_4);

        label_5 = new JLabel("六");
        label_5.setForeground(Color.GREEN);
        label_5.setHorizontalAlignment(SwingConstants.CENTER);
        label_5.setBounds(221, 22, 27, 23);
        add(label_5);

        btn_close = new JLabel("[X]");
        btn_close.setBounds(222, 0, 27, 23);
        btn_close.setForeground(Color.RED);
        add(btn_close);
        btn_close.addMouseListener(new MouseAdapter() {

            @Override
            public void mouseClicked(MouseEvent e) {
                CalendarPanel.this.setVisible(false);
            }

        });


        //用于快速显示今天日期的按钮
        btn_today = new JButton("今天");
        btn_today.setBounds(10, 213, 60, 23);
        btn_today.setContentAreaFilled(false);
        btn_today.setBorder(BorderFactory.createLineBorder(Color.GRAY));
        add(btn_today);
        btn_today.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                createCalendarPanel(nowDatetime);
                lb_datetime.setText(nowDatetime);
            }
        });


        //用于取消日期选择的按钮
        btn_cancel = new JButton("取消");
        btn_cancel.setBounds(179, 213, 60, 23);
        btn_cancel.setContentAreaFilled(false);
        btn_cancel.setBorder(BorderFactory.createLineBorder(Color.GRAY));
        add(btn_cancel);
        btn_cancel.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                CalendarPanel.this.setVisible(false);
            }
        });
    }

    /**
     * 重新设置日历面板显示为系统当前日期
     */
    public void reset(){
        createCalendarPanel(nowDatetime);
        lb_datetime.setText(nowDatetime);
    }



    /**
     * 改变当前日历控件面板的日期显示
     * @param YEAR_OR_MONTH  是对YEAR还是MONTH操作，这里需要传入Calendar类对应的常量值：Calendar.YEAR,Calendar.MONTH
     * @param flag  对YEAR_OR_MONTH属性是进行加法操作还是减法操作，如果flag为true则是加法操作，否则为减法操作
     */
    public void changTheDate(int YEAR_OR_MONTH,boolean flag){
        String dateStr = lb_datetime.getText().trim();
        Date date = null;
        try {
            date = sdf.parse(dateStr);
        } catch (ParseException e1) {
            e1.printStackTrace();
            return;
        }
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        if(flag){
            //将对应的日期属性进行加法操作
            c.set(YEAR_OR_MONTH,c.get(YEAR_OR_MONTH)+1 );
        }else{
            //将对应的日期属性进行减法操作
            c.set(YEAR_OR_MONTH,c.get(YEAR_OR_MONTH)-1 );
        }

        date = c.getTime();
        lb_datetime.setText(sdf.format(date));
        createCalendarPanel(sdf.format(date));
    }



    public static void main(String[] args) {
        Calendar c = new GregorianCalendar(2011,11,1);
        System.out.println( c.get(Calendar.DAY_OF_WEEK));
    }


    public void initCalendarPanel(){
        if(component instanceof javax.swing.JComponent){
            JComponent j = (JComponent)component;
            int w = j.getWidth();
            int h = j.getHeight();
            int x = j.getX();
            int y = j.getY();
            System.out.println("with:"+w +"height:"+h+"x:"+x+"y:"+y);
            this.setComponent(component);
            this.setBounds((x), y+h, 251, 245);
            this.setVisible(false);
            j.addMouseListener(new MouseAdapter() {
                @Override
                public void mouseClicked(MouseEvent e) {
                    if (CalendarPanel.this.isVisible()){
                        CalendarPanel.this.setVisible(false);
                    }else{
                        CalendarPanel.this.setVisible(true);
                        CalendarPanel.this.reset();
                    }
                }
            });
        }
    }



}

接口：

package com.ryd.stocktrader.client.util;

/**
 * Created by Administrator on 2016/7/28.
 */
public interface CallBack {
    public void callback();
}

测试类：

import java.awt.Color;
import java.awt.Point;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

//测试类
public class DateChooser extends JPanel {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    //private static Point startp = null;
    //private Point endp = null;

    public static void main(String[] args) {

        JFrame f = new JFrame();
        f.setLayout(null);
        JTextField txt1 = new JTextField();
        JTextField txt2 = new JTextField();
        txt1.setBounds(20, 50, 300, 30);
        txt2.setBounds(20, 80, 300, 30);

        // 定义日历控件面板类
        CalendarPanel p = new CalendarPanel(txt1, "yyyy/MM/dd");
        p.initCalendarPanel();

        JLabel l = new JLabel("日历面板");
        p.add(l);
        f.getContentPane().add(p);
        f.getContentPane().add(txt1);
        f.getContentPane().add(txt2);
        f.setSize(500, 400);
        f.setBackground(Color.WHITE);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setVisible(true);
    }
}

方式二：

package com.ryd.stocktrader.client.util;

import java.awt.BasicStroke;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Component;

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.GridLayout;

import java.awt.Point;

import java.awt.Polygon;

import java.awt.Stroke;

import java.awt.Toolkit;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.awt.event.MouseMotionListener;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Comparator;

import java.util.Date;

import java.util.List;



import javax.swing.BorderFactory;

import javax.swing.JComponent;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JTextField;

import javax.swing.Popup;

import javax.swing.PopupFactory;

import javax.swing.SwingUtilities;

import javax.swing.event.AncestorEvent;

import javax.swing.event.AncestorListener;

public class DateChooser extends JPanel {
    private static final long serialVersionUID = 4529266044762990227L;



    private Date initDate;

    private Calendar now = Calendar.getInstance();

    private Calendar select;

    private JPanel monthPanel;//月历

    private JP1 jp1;//四块面板,组成

    private JP2 jp2;

    private JP3 jp3;

    private JP4 jp4;

    private Font font = new Font("宋体", Font.PLAIN, 12);

    private final LabelManager lm = new LabelManager();

    private SimpleDateFormat sdf;

    private boolean isShow = false;

    private Popup pop;



    private JComponent showDate;



    public static DateChooser getInstance() {

        return new DateChooser();

    }



    public static DateChooser getInstance(Date date) {

        return new DateChooser(date);

    }



    public static DateChooser getInstance(String format) {

        return new DateChooser(format);

    }



    public static DateChooser getInstance(Date date, String format) {

        return new DateChooser(date, format);

    }



    /**

     * Creates a new instance of DateChooser

     */

    private DateChooser() {

        this(new Date());

    }



    private DateChooser(Date date) {

        this(date, "yyyy年MM月dd日");

    }



    private DateChooser(String format) {

        this(new Date(), format);

    }



    private DateChooser(Date date, String format) {

        initDate = date;

        sdf = new SimpleDateFormat(format);

        select = Calendar.getInstance();

        select.setTime(initDate);

        initPanel();

    }



    /**

     * 是否允许用户选择

     */

    public void setEnabled(boolean b) {

        super.setEnabled(b);

        showDate.setEnabled(b);

    }



    /**

     *得到当前选择框的日期

     */

    public Date getDate() {

        return select.getTime();

    }



    public String getStrDate() {

        return sdf.format(select.getTime());

    }



    public String getStrDate(String format) {

        sdf = new SimpleDateFormat(format);

        return sdf.format(select.getTime());

    }



    //根据初始化的日期,初始化面板

    private void initPanel() {

        monthPanel = new JPanel(new BorderLayout());

        monthPanel.setBorder(BorderFactory.createLineBorder(Color.BLUE));

        JPanel up = new JPanel(new BorderLayout());

        up.add(jp1 = new JP1(), BorderLayout.NORTH);

        up.add(jp2 = new JP2(), BorderLayout.CENTER);

        monthPanel.add(jp3 = new JP3(), BorderLayout.CENTER);

        monthPanel.add(up, BorderLayout.NORTH);

        monthPanel.add(jp4 = new JP4(), BorderLayout.SOUTH);

        this.addAncestorListener(new AncestorListener() {

            public void ancestorAdded(AncestorEvent event) {



            }



            public void ancestorRemoved(AncestorEvent event) {



            }



            //只要祖先组件一移动,马上就让popup消失

            public void ancestorMoved(AncestorEvent event) {

                hidePanel();

            }

        });

    }



    public void register(final JComponent showDate) {

        this.showDate = showDate;



        showDate.setRequestFocusEnabled(true);

        showDate.addMouseListener(new MouseAdapter() {

            public void mousePressed(MouseEvent me) {

                showDate.requestFocusInWindow();

            }

        });

        this.setBackground(Color.WHITE);

        this.add(showDate, BorderLayout.CENTER);

        this.setPreferredSize(new Dimension(90, 25));

        this.setBorder(BorderFactory.createLineBorder(Color.GRAY));

        showDate.addMouseListener(new MouseAdapter() {

            public void mouseEntered(MouseEvent me) {

                if (showDate.isEnabled()) {

                    showDate.setCursor(new Cursor(Cursor.HAND_CURSOR));

                    showDate.setForeground(Color.white);

                }

            }



            public void mouseExited(MouseEvent me) {

                if (showDate.isEnabled()) {

                    showDate.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

                    showDate.setForeground(Color.white);

                }

            }



            public void mousePressed(MouseEvent me) {

                if (showDate.isEnabled()) {

                    showDate.setForeground(Color.CYAN);

                    if (isShow) {

                        hidePanel();

                    } else {

                        showPanel(showDate);

                    }

                }

            }



            public void mouseReleased(MouseEvent me) {

                if (showDate.isEnabled()) {

                    showDate.setForeground(Color.BLACK);

                }

            }

        });

        showDate.addFocusListener(new FocusListener() {

            public void focusLost(FocusEvent e) {

                hidePanel();

            }



            public void focusGained(FocusEvent e) {



            }

        });

    }



    //根据新的日期刷新

    private void refresh() {

        jp1.updateDate();

        jp2.updateDate();

        jp3.updateDate();

        jp4.updateDate();

        SwingUtilities.updateComponentTreeUI(this);

    }



    //提交日期

    private void commit() {

        //TODO add other components here

        if (showDate instanceof JTextField) {

            ((JTextField) showDate).setText(sdf.format(select.getTime()));

        }else if (showDate instanceof JLabel) {

            ((JLabel) showDate).setText(sdf.format(select.getTime()));

        }



        hidePanel();

    }



    //隐藏日期选择面板

    private void hidePanel() {

        if (pop != null) {

            isShow = false;

            pop.hide();

            pop = null;

        }

    }



    //显示日期选择面板

    private void showPanel(Component owner) {

        if (pop != null) {

            pop.hide();

        }

        Point show = new Point(0, showDate.getHeight());

        SwingUtilities.convertPointToScreen(show, showDate);

        Dimension size = Toolkit.getDefaultToolkit().getScreenSize();

        int x = show.x;

        int y = show.y;

        if (x < 0) {

            x = 0;

        }

        if (x > size.width - 295) {

            x = size.width - 295;

        }

        if (y < size.height - 170) {

        } else {

            y -= 188;

        }

        pop = PopupFactory.getSharedInstance().getPopup(owner, monthPanel, x, y);

        pop.show();

        isShow = true;

    }



    /**

     * 最上面的面板用来显示月份的增减

     */

    private class JP1 extends JPanel {

        private static final long serialVersionUID = -5638853772805561174L;

        JLabel yearleft, yearright, monthleft, monthright, center, centercontainer;



        public JP1() {

            super(new BorderLayout());

            this.setBackground(new Color(160, 185, 215));

            initJP1();

        }



        private void initJP1() {

            yearleft = new JLabel("  <<", JLabel.CENTER);

            yearleft.setToolTipText("上一年");

            yearright = new JLabel(">>  ", JLabel.CENTER);

            yearright.setToolTipText("下一年");

            yearleft.setBorder(BorderFactory.createEmptyBorder(2, 0, 0, 0));

            yearright.setBorder(BorderFactory.createEmptyBorder(2, 0, 0, 0));



            monthleft = new JLabel("  <", JLabel.RIGHT);

            monthleft.setToolTipText("上一月");

            monthright = new JLabel(">  ", JLabel.LEFT);

            monthright.setToolTipText("下一月");

            monthleft.setBorder(BorderFactory.createEmptyBorder(2, 30, 0, 0));

            monthright.setBorder(BorderFactory.createEmptyBorder(2, 0, 0, 30));



            centercontainer = new JLabel("", JLabel.CENTER);

            centercontainer.setLayout(new BorderLayout());

            center = new JLabel("", JLabel.CENTER);



            centercontainer.add(monthleft, BorderLayout.WEST);

            centercontainer.add(center, BorderLayout.CENTER);

            centercontainer.add(monthright, BorderLayout.EAST);



            this.add(yearleft, BorderLayout.WEST);

            this.add(centercontainer, BorderLayout.CENTER);

            this.add(yearright, BorderLayout.EAST);

            this.setPreferredSize(new Dimension(295, 25));



            updateDate();



            yearleft.addMouseListener(new MouseAdapter() {

                public void mouseEntered(MouseEvent me) {

                    yearleft.setCursor(new Cursor(Cursor.HAND_CURSOR));

                    yearleft.setForeground(Color.RED);

                }



                public void mouseExited(MouseEvent me) {

                    yearleft.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

                    yearleft.setForeground(Color.BLACK);

                }



                public void mousePressed(MouseEvent me) {

                    select.add(Calendar.YEAR, -1);

                    yearleft.setForeground(Color.WHITE);

                    refresh();

                }



                public void mouseReleased(MouseEvent me) {

                    yearleft.setForeground(Color.BLACK);

                }

            });

            yearright.addMouseListener(new MouseAdapter() {

                public void mouseEntered(MouseEvent me) {

                    yearright.setCursor(new Cursor(Cursor.HAND_CURSOR));

                    yearright.setForeground(Color.RED);

                }



                public void mouseExited(MouseEvent me) {

                    yearright.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

                    yearright.setForeground(Color.BLACK);

                }



                public void mousePressed(MouseEvent me) {

                    select.add(Calendar.YEAR, 1);

                    yearright.setForeground(Color.WHITE);

                    refresh();

                }



                public void mouseReleased(MouseEvent me) {

                    yearright.setForeground(Color.BLACK);

                }

            });

            monthleft.addMouseListener(new MouseAdapter() {

                public void mouseEntered(MouseEvent me) {

                    monthleft.setCursor(new Cursor(Cursor.HAND_CURSOR));

                    monthleft.setForeground(Color.RED);

                }



                public void mouseExited(MouseEvent me) {

                    monthleft.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

                    monthleft.setForeground(Color.BLACK);

                }



                public void mousePressed(MouseEvent me) {

                    select.add(Calendar.MONTH, -1);

                    monthleft.setForeground(Color.WHITE);

                    refresh();

                }



                public void mouseReleased(MouseEvent me) {

                    monthleft.setForeground(Color.BLACK);

                }

            });

            monthright.addMouseListener(new MouseAdapter() {

                public void mouseEntered(MouseEvent me) {

                    monthright.setCursor(new Cursor(Cursor.HAND_CURSOR));

                    monthright.setForeground(Color.RED);

                }



                public void mouseExited(MouseEvent me) {

                    monthright.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

                    monthright.setForeground(Color.BLACK);

                }



                public void mousePressed(MouseEvent me) {

                    select.add(Calendar.MONTH, 1);

                    monthright.setForeground(Color.WHITE);

                    refresh();

                }



                public void mouseReleased(MouseEvent me) {

                    monthright.setForeground(Color.BLACK);

                }

            });

        }



        private void updateDate() {

            center.setText(select.get(Calendar.YEAR) + "年" + (select.get(Calendar.MONTH) + 1) + "月");

        }

    }



    private class JP2 extends JPanel {

        private static final long serialVersionUID = -8176264838786175724L;



        public JP2() {

            this.setPreferredSize(new Dimension(295, 20));

        }



        protected void paintComponent(Graphics g) {

            g.setFont(font);

            g.drawString("星期日 星期一 星期二 星期三 星期四 星期五 星期六", 5, 10);

            g.drawLine(0, 15, getWidth(), 15);

        }



        private void updateDate() {



        }

    }



    private class JP3 extends JPanel {

        private static final long serialVersionUID = 43157272447522985L;



        public JP3() {

            super(new GridLayout(6, 7));

            this.setPreferredSize(new Dimension(295, 100));

            initJP3();

        }



        private void initJP3() {

            updateDate();

        }



        public void updateDate() {

            this.removeAll();

            lm.clear();

            Date temp = select.getTime();

            Calendar select = Calendar.getInstance();

            select.setTime(temp);

            select.set(Calendar.DAY_OF_MONTH, 1);

            int index = select.get(Calendar.DAY_OF_WEEK);

            int sum = (index == 1 ? 8 : index);

            select.add(Calendar.DAY_OF_MONTH, 0 - sum);

            for (int i = 0; i < 42; i++) {

                select.add(Calendar.DAY_OF_MONTH, 1);

                lm.addLabel(new MyLabel(select.get(Calendar.YEAR), select.get(Calendar.MONTH), select.get(Calendar.DAY_OF_MONTH)));

            }

            for (MyLabel my : lm.getLabels()) {

                this.add(my);

            }

            select.setTime(temp);

        }

    }



    private class MyLabel extends JLabel implements Comparator<MyLabel>, MouseListener, MouseMotionListener {

        private static final long serialVersionUID = 3668734399227577214L;

        private int year, month, day;

        private boolean isSelected;



        public MyLabel(int year, int month, int day) {

            super("" + day, JLabel.CENTER);

            this.year = year;

            this.day = day;

            this.month = month;

            this.addMouseListener(this);

            this.addMouseMotionListener(this);

            this.setFont(font);

            if (month == select.get(Calendar.MONTH)) {

                this.setForeground(Color.BLACK);

            } else {

                this.setForeground(Color.LIGHT_GRAY);

            }

            if (day == select.get(Calendar.DAY_OF_MONTH)) {

                this.setBackground(new Color(160, 185, 215));

            } else {

                this.setBackground(Color.WHITE);

            }

        }



        public boolean getIsSelected() {

            return isSelected;

        }



        public void setSelected(boolean b, boolean isDrag) {

            isSelected = b;

            if (b && !isDrag) {

                int temp = select.get(Calendar.MONTH);

                select.set(year, month, day);

                if (temp == month) {

                    SwingUtilities.updateComponentTreeUI(jp3);

                } else {

                    refresh();

                }

            }

            this.repaint();

        }



        protected void paintComponent(Graphics g) {

            if (day == select.get(Calendar.DAY_OF_MONTH) && month == select.get(Calendar.MONTH)) {

                //如果当前日期是选择日期,则高亮显示

                g.setColor(new Color(160, 185, 215));

                g.fillRect(0, 0, getWidth(), getHeight());

            }

            if (year == now.get(Calendar.YEAR) && month == now.get(Calendar.MONTH) && day == now.get(Calendar.DAY_OF_MONTH)) {

                //如果日期和当前日期一样,则用红框

                Graphics2D gd = (Graphics2D) g;

                gd.setColor(Color.RED);

                Polygon p = new Polygon();

                p.addPoint(0, 0);

                p.addPoint(getWidth() - 1, 0);

                p.addPoint(getWidth() - 1, getHeight() - 1);

                p.addPoint(0, getHeight() - 1);

                gd.drawPolygon(p);

            }

            if (isSelected) {//如果被选中了就画出一个虚线框出来

                Stroke s = new BasicStroke(1.0f, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_BEVEL, 1.0f, new float[] { 2.0f, 2.0f }, 1.0f);

                Graphics2D gd = (Graphics2D) g;

                gd.setStroke(s);

                gd.setColor(Color.BLACK);

                Polygon p = new Polygon();

                p.addPoint(0, 0);

                p.addPoint(getWidth() - 1, 0);

                p.addPoint(getWidth() - 1, getHeight() - 1);

                p.addPoint(0, getHeight() - 1);

                gd.drawPolygon(p);

            }

            super.paintComponent(g);

        }



        public boolean contains(Point p) {

            return this.getBounds().contains(p);

        }



        private void update() {

            repaint();

        }



        public void mouseClicked(MouseEvent e) {

        }



        public void mousePressed(MouseEvent e) {

            isSelected = true;

            update();

        }



        public void mouseReleased(MouseEvent e) {

            Point p = SwingUtilities.convertPoint(this, e.getPoint(), jp3);

            lm.setSelect(p, false);

            commit();

        }



        public void mouseEntered(MouseEvent e) {

        }



        public void mouseExited(MouseEvent e) {

        }



        public void mouseDragged(MouseEvent e) {

            Point p = SwingUtilities.convertPoint(this, e.getPoint(), jp3);

            lm.setSelect(p, true);

        }



        public void mouseMoved(MouseEvent e) {

        }



        public int compare(MyLabel o1, MyLabel o2) {

            Calendar c1 = Calendar.getInstance();

            c1.set(o1.year, o2.month, o1.day);

            Calendar c2 = Calendar.getInstance();

            c2.set(o2.year, o2.month, o2.day);

            return c1.compareTo(c2);

        }

    }



    private class LabelManager {

        private List<MyLabel> list;



        public LabelManager() {

            list = new ArrayList<MyLabel>();

        }



        public List<MyLabel> getLabels() {

            return list;

        }



        public void addLabel(MyLabel my) {

            list.add(my);

        }



        public void clear() {

            list.clear();

        }



        @SuppressWarnings("unused")

        public void setSelect(MyLabel my, boolean b) {

            for (MyLabel m : list) {

                if (m.equals(my)) {

                    m.setSelected(true, b);

                } else {

                    m.setSelected(false, b);

                }

            }

        }



        public void setSelect(Point p, boolean b) {

            //如果是拖动,则要优化一下,以提高效率

            if (b) {

                //表示是否能返回,不用比较完所有的标签,能返回的标志就是把上一个标签和

                //将要显示的标签找到了就可以了

                boolean findPrevious = false, findNext = false;

                for (MyLabel m : list) {

                    if (m.contains(p)) {

                        findNext = true;

                        if (m.getIsSelected()) {

                            findPrevious = true;

                        } else {

                            m.setSelected(true, b);

                        }

                    } else if (m.getIsSelected()) {

                        findPrevious = true;

                        m.setSelected(false, b);

                    }

                    if (findPrevious && findNext) {

                        return;

                    }

                }

            } else {

                MyLabel temp = null;

                for (MyLabel m : list) {

                    if (m.contains(p)) {

                        temp = m;

                    } else if (m.getIsSelected()) {

                        m.setSelected(false, b);

                    }

                }

                if (temp != null) {

                    temp.setSelected(true, b);

                }

            }

        }



    }



    private class JP4 extends JPanel {

        private static final long serialVersionUID = -6391305687575714469L;



        public JP4() {

            super(new BorderLayout());

            this.setPreferredSize(new Dimension(295, 20));

            this.setBackground(new Color(160, 185, 215));

            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");

            final JLabel jl = new JLabel("今天: " + sdf.format(new Date()));

            jl.setToolTipText("点击选择今天日期");

            this.add(jl, BorderLayout.CENTER);

            jl.addMouseListener(new MouseAdapter() {

                public void mouseEntered(MouseEvent me) {

                    jl.setCursor(new Cursor(Cursor.HAND_CURSOR));

                    jl.setForeground(Color.RED);

                }



                public void mouseExited(MouseEvent me) {

                    jl.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

                    jl.setForeground(Color.BLACK);

                }



                public void mousePressed(MouseEvent me) {

                    jl.setForeground(Color.WHITE);

                    select.setTime(new Date());

                    refresh();

                    commit();

                }



                public void mouseReleased(MouseEvent me) {

                    jl.setForeground(Color.BLACK);

                }

            });

        }



        private void updateDate() {



        }

    }



    public static void main(String[] args) {

        DateChooser dateChooser1 = DateChooser.getInstance("yyyy-MM-dd");

        DateChooser dateChooser2 = DateChooser.getInstance("yyyy-MM-dd");

        JTextField showDate1 = new JTextField("单击选择日期");

        JLabel showDate2 = new JLabel("单击选择日期");



        dateChooser1.register(showDate1);

        dateChooser2.register(showDate2);



        JFrame jf = new JFrame("测试日期选择器");

        jf.add(showDate1, BorderLayout.NORTH);

        jf.add(showDate2, BorderLayout.SOUTH);

        jf.pack();

        jf.setLocationRelativeTo(null);

        jf.setVisible(true);

        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    }
}