/*******************************************************************************
    * JDateButton: Java Swing Date Button
    * Copyright 2012,2014 Tony Washer
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * ------------------------------------------------------------
   * SubVersion Revision Information:
   * $URL: https://svn.code.sf.net/p/jdatebutton/code/tags/v2.1.0-b3/jdatebutton-swing/src/main/java/net/sourceforge/jdatebutton/swing/JDateDialog.java $
   * $Revision: 34 $
   * $Author: tonywasher $
   * $Date: 2015-12-01 16:21:13 +0000 (Tue, 01 Dec 2015) $
   ******************************************************************************/
  package net.sourceforge.jdatebutton.swing;
  
  import java.awt.BorderLayout;
  import java.awt.Color;
  import java.awt.Component;
  import java.awt.Font;
  import java.awt.GridLayout;
  import java.awt.Insets;
  import java.awt.Window;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.KeyEvent;
  import java.awt.event.MouseAdapter;
  import java.awt.event.MouseEvent;
  import java.awt.event.WindowAdapter;
  import java.awt.event.WindowEvent;
  import java.time.DayOfWeek;
  import java.time.LocalDate;
  import java.time.format.TextStyle;
  import java.util.Calendar;
  import java.util.Locale;
  import java.util.ResourceBundle;
  
  import javax.swing.AbstractAction;
  import javax.swing.ActionMap;
  import javax.swing.BorderFactory;
  import javax.swing.Box;
  import javax.swing.BoxLayout;
  import javax.swing.InputMap;
  import javax.swing.JButton;
  import javax.swing.JComponent;
  import javax.swing.JDialog;
  import javax.swing.JLabel;
  import javax.swing.JOptionPane;
  import javax.swing.JPanel;
  import javax.swing.KeyStroke;
  import javax.swing.SwingConstants;
  import javax.swing.border.Border;
  
  /**
   * Dialog class providing a dialog allowing selection of a date.
   * <p>
   * It will rebuild the dialog according to the currently set locale and date format whenever it is
   * made visible
   */
  public class JDateDialog
          extends JDialog {
      /**
       * Serial Id.
       */
      private static final long serialVersionUID = 2518033527621472786L;
  
      /**
       * Standard font name.
       */
      private static final String FONT_NAME = "Courier";
  
      /**
       * Standard font size.
       */
      private static final int FONT_SIZE = 10;
  
      /**
       * Standard font.
       */
      private static final Font FONT_STANDARD = new Font(FONT_NAME, Font.PLAIN, FONT_SIZE);
  
      /**
       * Inactive font.
       */
      private static final Font FONT_INACTIVE = new Font(FONT_NAME, Font.ITALIC, FONT_SIZE);
  
      /**
       * Selected font.
       */
      private static final Font FONT_SELECTED = new Font(FONT_NAME, Font.BOLD, FONT_SIZE);
  
     /**
      * Resource Bundle.
      */
     private static final ResourceBundle NLS_BUNDLE = ResourceBundle.getBundle(JDateDialog.class.getName());
 
     /**
      * ToolTip for Current Day.
      */
     public static final String NLS_CURRENTDAY = NLS_BUNDLE.getString("CurrentDay");
 
     /**
      * ToolTip for Selected Day.
      */
     public static final String NLS_SELECTEDDAY = NLS_BUNDLE.getString("SelectedDay");
 
     /**
      * ToolTip for Next Month.
      */
     public static final String NLS_NEXTMONTH = NLS_BUNDLE.getString("NextMonth");
 
     /**
      * ToolTip for Previous Month.
      */
     public static final String NLS_PREVMONTH = NLS_BUNDLE.getString("PreviousMonth");
 
     /**
      * ToolTip for Next Year.
      */
     public static final String NLS_NEXTYEAR = NLS_BUNDLE.getString("NextYear");
 
     /**
      * ToolTip for Previous Year.
      */
     public static final String NLS_PREVYEAR = NLS_BUNDLE.getString("PreviousYear");
 
     /**
      * Null Date selection text.
      */
     public static final String NLS_NULLSELECT = NLS_BUNDLE.getString("NullSelect");
 
     /**
      * Escape action text.
      */
     private static final String ACTION_ESCAPE = "Escape";
 
     /**
      * The month array.
      */
     private final PanelMonth theDaysPanel;
 
     /**
      * The navigation.
      */
     private final PanelNavigation theNavigation;
 
     /**
      * The Null Select.
      */
     private final JButton theNullButton;
 
     /**
      * Is the Null button active.
      */
     private boolean isNullActive = false;
 
     /**
      * The Date Configuration.
      */
     private final transient JDateConfig theConfig;
 
     /**
      * Should we build names?
      */
     private boolean doBuildNames = true;
 
     /**
      * The container panel.
      */
     private final JPanel theContainer;
 
     /**
      * Have we selected a date?
      */
     private boolean haveSelected = false;
 
     /**
      * Constructor.
      * @param pParent the parent component to which this dialog is attached
      * @param pConfig the configuration for the dialog
      */
     protected JDateDialog(final Component pParent,
                           final JDateConfig pConfig) {
         /* Initialise the dialog */
         super(JOptionPane.getFrameForComponent(pParent), false);
 
         /* Set as undecorated */
         setUndecorated(true);
 
         /* Store the DateConfig */
         theConfig = pConfig;
 
         /* Build the panels */
         theDaysPanel = new PanelMonth(this);
         theNavigation = new PanelNavigation(this);
 
         /* Build the Null Select */
         theNullButton = new JButton(NLS_NULLSELECT);
         theNullButton.addActionListener(new ButtonHandler());
 
         /* Set this to be the main panel */
         theContainer = new JPanel(new BorderLayout());
         theContainer.setBorder(BorderFactory.createLineBorder(Color.black));
         theContainer.add(theNavigation, BorderLayout.NORTH);
         theContainer.add(theDaysPanel, BorderLayout.CENTER);
         setContentPane(theContainer);
         pack();
 
         /* Initialise the month */
         initialiseMonth();
 
         /* Handle Escape Key */
         handleEscapeKey(theContainer);
 
         /* Create focus listener */
         addWindowFocusListener(new CalendarFocus());
 
         /* Set the relative location */
         setLocationRelativeTo(pParent);
     }
 
     /**
      * Request a rebuild of panel names.
      */
     protected void doBuildNames() {
         doBuildNames = true;
     }
 
     /**
      * Have we selected a date?
      * @return true/false
      */
     public boolean haveSelected() {
         return haveSelected;
     }
 
     /**
      * Obtain Date Configuration.
      * @return the date configuration
      */
     public JDateConfig getDateConfig() {
         return theConfig;
     }
 
     /**
      * Build the month.
      */
     private void buildMonth() {
         /* Build the month */
         theNavigation.buildMonth();
         theDaysPanel.buildMonth();
     }
 
     /**
      * Set Selected Date.
      * @param pDay the Selected day
      */
     private void setSelected(final int pDay) {
         /* Set the selected day */
         theConfig.setSelectedDay(pDay);
 
         /* Note that we have selected */
         haveSelected = true;
 
         /* Close the dialog */
         setVisible(false);
     }
 
     /**
      * Resize the dialog.
      */
     private void reSizeDialog() {
         pack();
     }
 
     /**
      * InitialiseMonth.
      */
     private void initialiseMonth() {
         /* Initialise the current month */
         theConfig.initialiseCurrent();
 
         /* Build the day names if required */
         if (doBuildNames) {
             theDaysPanel.buildDayNames();
         }
         doBuildNames = false;
 
         /* Build detail */
         buildMonth();
 
         /* If we need to change the visibility of the null button */
         if (isNullActive != theConfig.allowNullDateSelection()) {
             /* Add/Remove the button */
             if (!isNullActive) {
                 theContainer.add(theNullButton, BorderLayout.SOUTH);
             } else {
                 theContainer.remove(theNullButton);
             }
 
             /* Record status and resize the dialog */
             isNullActive = theConfig.allowNullDateSelection();
             reSizeDialog();
         }
     }
 
     @Override
     public void setVisible(final boolean bVisible) {
         /* If we are becoming visible */
         if (bVisible) {
             /* Note that we have not selected */
             haveSelected = false;
 
             /* Initialise the current month */
             initialiseMonth();
 
             /* Set visibility and focus */
             super.setVisible(true);
             requestFocus();
 
             /* Pass the call on */
         } else {
             super.setVisible(bVisible);
         }
     }
 
     /**
      * Handle Escape to close dialog.
      * @param pPane the panel to handle keys for
      */
     private void handleEscapeKey(final JPanel pPane) {
         /* Access Maps */
         ActionMap myAction = pPane.getActionMap();
         InputMap myInput = pPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
 
         /* Build the maps */
         myInput.put(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), ACTION_ESCAPE);
         myAction.put(ACTION_ESCAPE, new CalendarAction());
     }
 
     /**
      * Close non-Modal.
      */
     private void closeNonModal() {
         setVisible(false);
     }
 
     /**
      * CalendarAction Handle escape action.
      */
     private class CalendarAction
             extends AbstractAction {
         /**
          * SerialId.
          */
         private static final long serialVersionUID = 5464442251457102478L;
 
         @Override
         public void actionPerformed(final ActionEvent e) {
             closeNonModal();
         }
     }
 
     /**
      * CalendarFocus Handle loss of focus.
      */
     private class CalendarFocus
             extends WindowAdapter {
         @Override
         public void windowLostFocus(final WindowEvent e) {
             Window myOppo = e.getOppositeWindow();
 
             /*
              * Ignore loss of focus to unidentified window. This is to bypass a problem in browser
              * applets where a temporary loss of focus occurs immediately upon display of a dialog.
              */
             if (myOppo != null) {
                 closeNonModal();
             }
         }
     }
 
     /**
      * ButtonHandler Handle button presses.
      */
     private class ButtonHandler
             implements ActionListener {
         @Override
         public void actionPerformed(final ActionEvent e) {
             /* Access the event source */
             Object src = e.getSource();
 
             /* If the button is the Null button */
             if (theNullButton.equals(src)) {
                 /* Set the null date */
                 setSelected(-1);
             }
         }
     }
 
     /**
      * PanelNavigation class allowing navigation between months.
      */
     private static final class PanelNavigation
             extends JPanel {
         /**
          * Serial Id.
          */
         private static final long serialVersionUID = 4399207012690467687L;
 
         /**
          * The owning dialog.
          */
         private final JDateDialog theDialog;
 
         /**
          * The Date Configuration.
          */
         private final transient JDateConfig theConfig;
 
         /**
          * The Date Label.
          */
         private final JLabel theDateLabel;
 
         /**
          * The Previous Month Button.
          */
         private final JButton thePrevMonthButton;
 
         /**
          * The Next Month Button.
          */
         private final JButton theNextMonthButton;
 
         /**
          * The Previous Year Button.
          */
         private final JButton thePrevYearButton;
 
         /**
          * The Next Year Button.
          */
         private final JButton theNextYearButton;
 
         /**
          * Constructor.
          * @param pDialog the owning dialog
          */
         private PanelNavigation(final JDateDialog pDialog) {
             /* Record the dialog */
             theDialog = pDialog;
 
             /* Store the Date Configuration */
             theConfig = pDialog.getDateConfig();
 
             /* Create the label */
             theDateLabel = new JLabel();
 
             /* Create the buttons */
             thePrevMonthButton = new JButton(ArrowIcon.LEFT);
             theNextMonthButton = new JButton(ArrowIcon.RIGHT);
             thePrevYearButton = new JButton(ArrowIcon.DOUBLELEFT);
             theNextYearButton = new JButton(ArrowIcon.DOUBLERIGHT);
 
             /* Add ToopTips */
             theNextMonthButton.setToolTipText(NLS_NEXTMONTH);
             thePrevMonthButton.setToolTipText(NLS_PREVMONTH);
             theNextYearButton.setToolTipText(NLS_NEXTYEAR);
             thePrevYearButton.setToolTipText(NLS_PREVYEAR);
 
             /* Listen for button events */
             NavigateListener myListener = new NavigateListener();
             thePrevMonthButton.addActionListener(myListener);
             theNextMonthButton.addActionListener(myListener);
             thePrevYearButton.addActionListener(myListener);
             theNextYearButton.addActionListener(myListener);
 
             /* Restrict the margins */
             thePrevMonthButton.setMargin(new Insets(1, 1, 1, 1));
             theNextMonthButton.setMargin(new Insets(1, 1, 1, 1));
             thePrevYearButton.setMargin(new Insets(1, 1, 1, 1));
             theNextYearButton.setMargin(new Insets(1, 1, 1, 1));
 
             /* Add these elements into a box */
             setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
             add(thePrevYearButton);
             add(Box.createHorizontalStrut(1));
             add(thePrevMonthButton);
             add(Box.createHorizontalGlue());
             add(theDateLabel);
             add(Box.createHorizontalGlue());
             add(theNextMonthButton);
             add(Box.createHorizontalStrut(1));
             add(theNextYearButton);
         }
 
         /**
          * Build month details.
          */
         private void buildMonth() {
             /* Store the active month */
             LocalDate myBase = theConfig.getCurrentMonth();
             Locale myLocale = theConfig.getLocale();
 
             /* Determine the display for the label */
             String myMonth = myBase.getMonth().getDisplayName(TextStyle.FULL, myLocale);
             String myYear = Integer.toString(myBase.getYear());
 
             /* If we are showing pretty month capitalise the name */
             if (theConfig.doPretty()) {
                 /* UpperCase the first character */
                 myMonth = theConfig.capitaliseString(myMonth);
             }
 
             /* Set the label */
             theDateLabel.setText(myMonth
                                  + ", "
                                  + myYear);
 
             /* Access boundary dates */
             LocalDate myEarliest = theConfig.getEarliestDate();
             LocalDate myLatest = theConfig.getLatestDate();
 
             /* Enable/Disable buttons as required */
             thePrevMonthButton.setEnabled(!JDateConfig.isSameMonth(myEarliest, myBase));
             thePrevYearButton.setEnabled(!JDateConfig.isSameYear(myEarliest, myBase));
             theNextMonthButton.setEnabled(!JDateConfig.isSameMonth(myLatest, myBase));
             theNextYearButton.setEnabled(!JDateConfig.isSameYear(myLatest, myBase));
         }
 
         /**
          * Action Listener for buttons.
          */
         private class NavigateListener
                 implements ActionListener {
             @Override
             public void actionPerformed(final ActionEvent e) {
                 /* Access the event source */
                 Object src = e.getSource();
 
                 /* If the button is previous month */
                 if (thePrevMonthButton.equals(src)) {
                     /* Adjust the month */
                     theConfig.previousMonth();
                     theDialog.buildMonth();
                 } else if (theNextMonthButton.equals(src)) {
                     /* Adjust the month */
                     theConfig.nextMonth();
                     theDialog.buildMonth();
                 } else if (thePrevYearButton.equals(src)) {
                     /* Adjust the month */
                     theConfig.previousYear();
                     theDialog.buildMonth();
                 } else if (theNextYearButton.equals(src)) {
                     /* Adjust the month */
                     theConfig.nextYear();
                     theDialog.buildMonth();
                 }
             }
         }
     }
 
     /**
      * PanelMonth class representing the set of PanelDay labels in a month.
      */
     private static final class PanelMonth
             extends JPanel {
         /**
          * Serial Id.
          */
         private static final long serialVersionUID = 4003892701953050327L;
 
         /**
          * Number of days in week.
          */
         private static final int DAYS_IN_WEEK = 7;
 
         /**
          * Maximum # of weeks in month.
          */
         private static final int MAX_WEEKS_IN_MONTH = 6;
 
         /**
          * The array of days of week (in column order).
          */
         private final DayOfWeek[] theDaysOfWk = new DayOfWeek[DAYS_IN_WEEK];
 
         /**
          * The Array of Day Names.
          */
         private final JLabel[] theHdrs = new JLabel[DAYS_IN_WEEK];
 
         /**
          * The Array of Day Labels.
          */
         private final PanelDay[][] theDays = new PanelDay[MAX_WEEKS_IN_MONTH][DAYS_IN_WEEK];
 
         /**
          * The Dialog.
          */
         private final JDateDialog theDialog;
 
         /**
          * The Date Configuration.
          */
         private final transient JDateConfig theConfig;
 
         /**
          * The number of currently visible rows.
          */
         private int theNumRows = MAX_WEEKS_IN_MONTH;
 
         /**
          * Constructor.
          * @param pDialog the owning dialog
          */
         private PanelMonth(final JDateDialog pDialog) {
             /* Store the dialog */
             theDialog = pDialog;
 
             /* Store the Date Configuration */
             theConfig = pDialog.getDateConfig();
 
             /* Set this as a 7x7 GridLayout */
             GridLayout myLayout = new GridLayout();
             myLayout.setColumns(DAYS_IN_WEEK);
             myLayout.setRows(0);
             setLayout(myLayout);
 
             /* Loop through the labels */
             for (int iCol = 0; iCol < DAYS_IN_WEEK; iCol++) {
                 /* Access the label */
                 JLabel myLabel = new JLabel();
                 theHdrs[iCol] = myLabel;
 
                 /* Set colour */
                 myLabel.setHorizontalAlignment(SwingConstants.CENTER);
                 myLabel.setBackground(Color.lightGray);
                 myLabel.setOpaque(true);
 
                 /* Add to the grid */
                 add(myLabel);
             }
 
             /* Add the Days to the layout */
             for (int iRow = 0; iRow < MAX_WEEKS_IN_MONTH; iRow++) {
                 for (int iCol = 0; iCol < DAYS_IN_WEEK; iCol++) {
                     PanelDay myDay = new PanelDay(pDialog);
                     theDays[iRow][iCol] = myDay;
                     add(myDay);
                 }
             }
         }
 
         /**
          * ReSize the number of visible rows.
          * @param iNumRows number of visible rows
          */
         private void reSizeRows(final int iNumRows) {
             /* Hide any visible rows that should now be hidden */
             while (iNumRows < theNumRows) {
                 /* Decrement number of rows */
                 theNumRows--;
 
                 /* Loop through remaining rows */
                 for (PanelDay day : theDays[theNumRows]) {
                     /* Remove from panel */
                     remove(day);
                 }
             }
 
             /* Show any hidden rows that should now be visible */
             while (iNumRows > theNumRows) {
                 /* Loop through remaining rows */
                 for (PanelDay day : theDays[theNumRows]) {
                     /* Add to panel */
                     add(day);
                 }
 
                 /* Increment number of rows */
                 theNumRows++;
             }
 
             /* RePack the Dialog */
             theDialog.reSizeDialog();
         }
 
         /**
          * Is the DayOfWeek a Weekend day.
          * @param pDoW the day of the week
          * @return true/false
          */
         private static boolean isWeekend(final DayOfWeek pDoW) {
             switch (pDoW) {
                 case SATURDAY:
                 case SUNDAY:
                     return true;
                 default:
                     return false;
             }
         }
 
         /**
          * obtain column number for DayOfWeek.
          * @param pDoW the day of the week
          * @return the column number
          */
         private int getDayColumn(final DayOfWeek pDoW) {
             for (int i = 0; i < DAYS_IN_WEEK; i++) {
                 if (theDaysOfWk[i] == pDoW) {
                     return i;
                 }
             }
             return -1;
         }
 
         /**
          * build the month display for the requested month.
          */
         private void buildMonth() {
             int iRow = 0;
             int iCol = 0;
 
             /* Access the current month */
             LocalDate myCurr = theConfig.getCurrentMonth();
             int iMonth = myCurr.getMonthValue();
 
             /* Access the Weekday of the 1st of the month */
             DayOfWeek myWeekDay = myCurr.getDayOfWeek();
             int iFirstCol = getDayColumn(myWeekDay);
 
             /* Access the interesting days of the month */
             int iCurrent = theConfig.getCurrentDay();
             int iSelected = theConfig.getSelectedDay();
             int iEarliest = theConfig.getEarliestDay();
             int iLatest = theConfig.getLatestDay();
 
             /* Adjust the day to beginning of week if required */
             if (iFirstCol > 0) {
                 myCurr = myCurr.minusDays(iFirstCol);
             }
 
             /* Loop through initial columns */
             for (int iDay = myCurr.getDayOfMonth(); iCol < iFirstCol; iCol++, iDay++, myCurr = myCurr.plusDays(1)) {
                 /* Access the label */
                 PanelDay myLabel = theDays[0][iCol];
 
                 /* Reset the day and set no day */
                 myLabel.resetDay(false);
                 myLabel.setDay(iDay, false);
             }
 
             /* Loop through the days of the month */
             for (int iDay = 1; iMonth == myCurr.getMonthValue(); iCol++, iDay++, myCurr = myCurr.plusDays(1)) {
                 /* Reset column if necessary */
                 if (iCol > MAX_WEEKS_IN_MONTH) {
                     iRow++;
                     iCol = 0;
                 }
 
                 /* Access the label */
                 PanelDay myLabel = theDays[iRow][iCol];
 
                 /* Set initial parts of the day */
                 myLabel.resetDay(true);
                 if (isWeekend(myCurr.getDayOfWeek())) {
                     myLabel.setWeekend();
                 }
                 if (iCurrent == iDay) {
                     myLabel.setCurrent();
                 }
                 if (iSelected == iDay) {
                     myLabel.setSelected();
                 }
 
                 /* Determine whether the day is select-able */
                 boolean isSelectable = true;
                 if ((iEarliest > 0)
                     && (iDay < iEarliest)) {
                     isSelectable = false;
                 } else if ((iLatest > 0)
                            && (iDay > iLatest)) {
                     isSelectable = false;
                 }
 
                 /* Set the day */
                 myLabel.setDay(iDay, isSelectable);
             }
 
             /* Loop through remaining columns */
             for (int iDay = 1; iCol < DAYS_IN_WEEK; iCol++, iDay++) {
                 /* Access the label */
                 PanelDay myLabel = theDays[iRow][iCol];
 
                 /* Reset the day and set no day */
                 myLabel.resetDay(false);
                 myLabel.setDay(iDay, false);
             }
 
             /* Ensure correct number of rows are visible */
             reSizeRows(iRow + 1);
         }
 
         /**
          * build Day names.
          */
         private void buildDayNames() {
             /* Get todays date */
             Locale myLocale = theConfig.getLocale();
             Calendar myDate = Calendar.getInstance(myLocale);
             int myStart = myDate.getFirstDayOfWeek();
             if (myStart == Calendar.SUNDAY) {
                 myStart += DAYS_IN_WEEK;
             }
 
             /* Build the array of the days of the week */
             DayOfWeek myDoW = DayOfWeek.of(myStart - 1);
             for (int iDay = 0; iDay < DAYS_IN_WEEK; iDay++, myDoW = myDoW.plus(1)) {
                 /* Store the day into the array */
                 theDaysOfWk[iDay] = myDoW;
             }
 
             /* Loop through the labels */
             for (int iCol = 0; iCol < DAYS_IN_WEEK; iCol++) {
                 /* Access the label */
                 JLabel myLabel = theHdrs[iCol];
 
                 /* Access the required name */
                 myDoW = theDaysOfWk[iCol];
                 String myName = myDoW.getDisplayName(TextStyle.SHORT, myLocale);
 
                 /* If the name is too long */
                 int iMaxDayLen = theConfig.getMaxDayLen();
                 if (myName.length() > iMaxDayLen) {
                     /* Shrink the name */
                     myName = theConfig.doShrinkFromRight()
                                                            ? myName.substring(0, iMaxDayLen)
                                                            : myName.substring(myName.length()
                                                                               - iMaxDayLen);
                 }
 
                 /* If we are showing pretty weekdays capitalise the character */
                 if (theConfig.doPretty()) {
                     /* UpperCase the first character */
                     myName = theConfig.capitaliseString(myName);
                 }
 
                 /* Set the name */
                 myLabel.setText(myName);
 
                 /* Set colour */
                 myLabel.setForeground(isWeekend(myDoW)
                                                        ? Color.red
                                                        : Color.black);
             }
         }
     }
 
     /**
      * Panel class representing a single day in the panel.
      */
     private static final class PanelDay
             extends JLabel {
         /**
          * Serial Id.
          */
         private static final long serialVersionUID = -5636278095729007866L;
 
         /**
          * Owning dialog.
          */
         private final JDateDialog theDialog;
 
         /**
          * The standard border.
          */
         private static final Border BORDER_STD = BorderFactory.createEmptyBorder();
 
         /**
          * The selected border.
          */
         private static final Border BORDER_SEL = BorderFactory.createLineBorder(Color.green.darker());
 
         /**
          * The highlighted border.
          */
         private static final Border BORDER_HLT = BorderFactory.createLineBorder(Color.orange);
 
         /**
          * The Day that this Label represents.
          */
         private int theDay = -1;
 
         /**
          * Is the day select-able.
          */
         private boolean isSelectable = false;
 
         /**
          * The font.
          */
         private Font theFont = null;
 
         /**
          * The foreground colour.
          */
         private Color theForeGround = null;
 
         /**
          * The background colour.
          */
         private Color theBackGround = null;
 
         /**
          * The border.
          */
         private Border theBorder = null;
 
         /**
          * The toolTip.
          */
         private String theToolTip = null;
 
         /**
          * Constructor.
          * @param pDialog the owning dialog
          */
         private PanelDay(final JDateDialog pDialog) {
             /* Store the parameter */
             theDialog = pDialog;
 
             /* Initialise values */
             setHorizontalAlignment(SwingConstants.CENTER);
             setOpaque(true);
             addMouseListener(new CalendarMouse(this));
         }
 
         /**
          * Set day for label.
          * @param pDay the Day number
          * @param pSelectable is the day select-able
          */
         private void setDay(final int pDay,
                             final boolean pSelectable) {
             /* Record the day */
             theDay = pDay;
             isSelectable = pSelectable;
 
             /* Set the text for the item */
             if (pDay > 0) {
                 setText(Integer.toString(theDay));
             } else {
                 setText("");
             }
 
             /* Set Characteristics */
             setFont(theFont);
             setForeground(theForeGround);
             setBackground(theBackGround);
             setBorder(theBorder);
             setToolTipText(theToolTip);
 
             /* Enable/Disable the label */
             setEnabled(isSelectable);
         }
 
         /**
          * Reset a Day Label.
          * @param isActive true/false
          */
         private void resetDay(final boolean isActive) {
             /* Record detail */
             theFont = isActive
                                ? FONT_STANDARD
                                : FONT_INACTIVE;
             theForeGround = Color.black;
             theBackGround = Color.white;
             theBorder = BORDER_STD;
             theToolTip = null;
             isSelectable = isActive;
         }
 
         /**
          * Set a day as a Weekend.
          */
         private void setWeekend() {
             /* Record detail */
             theForeGround = Color.red;
         }
 
         /**
          * Set a day as Current Day.
          */
         private void setCurrent() {
             /* Record detail */
             theForeGround = Color.blue;
             theBackGround = Color.gray;
             theToolTip = NLS_CURRENTDAY;
         }
 
         /**
          * Set a day as Selected Day.
          */
         private void setSelected() {
             /* Record detail */
             theFont = FONT_SELECTED;
             theForeGround = Color.green.darker();
             theBackGround = Color.green.brighter();
             theBorder = BORDER_SEL;
             theToolTip = NLS_SELECTEDDAY;
         }
 
         /**
          * CalendarMouse.
          */
         private final class CalendarMouse
                 extends MouseAdapter {
             /**
              * The Day Panel.
              */
             private final PanelDay theOwner;
 
             /**
              * Constructor.
              * @param pOwner the owning panel
              */
             private CalendarMouse(final PanelDay pOwner) {
                 /* Store parameters */
                 theOwner = pOwner;
             }
 
             @Override
             public void mouseClicked(final MouseEvent e) {
                 /* If item is select-able */
                 if (isSelectable) {
                     theDialog.setSelected(theDay);
                 }
             }
 
             @Override
             public void mouseEntered(final MouseEvent e) {
                 /* Highlight the border of a select-able item */
                 if (isSelectable) {
                     theOwner.setBorder(BORDER_HLT);
                 }
             }
 
             @Override
             public void mouseExited(final MouseEvent e) {
                 /* Reset border to standard for label that has changed */
                 if (isSelectable) {
                     theOwner.setBorder(theBorder);
                 }
             }
         }
     }
 }