/*******************************************************************************
    * JDateButton: JavaFX 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-javafx/src/main/java/net/sourceforge/jdatebutton/javafx/JDateDialog.java $
   * $Revision: 34 $
   * $Author: tonywasher $
   * $Date: 2015-12-01 16:21:13 +0000 (Tue, 01 Dec 2015) $
   ******************************************************************************/
  package net.sourceforge.jdatebutton.javafx;
  
  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 javafx.beans.value.ChangeListener;
  import javafx.beans.value.ObservableValue;
  import javafx.collections.ObservableList;
  import javafx.event.ActionEvent;
  import javafx.event.EventHandler;
  import javafx.scene.Node;
  import javafx.scene.Scene;
  import javafx.scene.control.Button;
  import javafx.scene.control.Label;
  import javafx.scene.control.Tooltip;
  import javafx.scene.input.KeyCode;
  import javafx.scene.input.KeyEvent;
  import javafx.scene.input.MouseEvent;
  import javafx.scene.layout.BorderPane;
  import javafx.scene.layout.GridPane;
  import javafx.scene.layout.HBox;
  import javafx.scene.layout.Priority;
  import javafx.scene.layout.Region;
  import javafx.stage.Modality;
  import javafx.stage.Stage;
  import javafx.stage.StageStyle;
  
  /**
   * 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 Stage {
      /**
       * StyleSheet.
       */
      private static final String CSS_STYLE = JDateDialog.class.getResource("JDateDialog.css").toExternalForm();
  
      /**
       * 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");
 
     /**
      * The month array.
      */
     private final PanelMonth theDaysPanel;
 
     /**
      * The navigation.
      */
     private final PanelNavigation theNavigation;
 
     /**
      * The Null Select.
      */
     private final Button theNullButton;
 
     /**
      * Is the Null button active.
      */
     private boolean isNullActive = false;
 
     /**
      * The Date Configuration.
      */
     private final JDateConfig theConfig;
 
     /**
      * Should we build names?
      */
     private boolean doBuildNames = true;
 
     /**
      * The container box.
      */
     private final BorderPane theContainer;
 
     /**
      * Have we selected a date?
      */
     private boolean haveSelected = false;
 
     /**
      * Constructor.
      * @param pConfig the configuration for the dialog
      */
     public JDateDialog(final JDateConfig pConfig) {
         /* Non-Modal and undecorated */
         super(StageStyle.UNDECORATED);
         initModality(Modality.NONE);
 
         /* Store the DateConfig */
         theConfig = pConfig;
 
         /* Build the panels */
         theDaysPanel = new PanelMonth(this);
         theNavigation = new PanelNavigation(this);
 
         /* Build the Null Select */
         theNullButton = new Button(NLS_NULLSELECT);
         theNullButton.setMaxWidth(Double.MAX_VALUE);
         theNullButton.addEventFilter(ActionEvent.ACTION, new ButtonHandler());
 
         /* Add listener to shut dialog on loss of focus */
         focusedProperty().addListener(new ChangeListener<Boolean>() {
             @Override
             public void changed(final ObservableValue<? extends Boolean> observable,
                                 final Boolean oldValue,
                                 final Boolean newValue) {
                 if (!newValue) {
                     closeNonModal();
                 }
             }
         });
 
         /* Create the scene */
         theContainer = new BorderPane();
         theContainer.setTop(theNavigation);
         theContainer.setCenter(theDaysPanel);
         Scene myScene = new Scene(theContainer);
         ObservableList<String> mySheets = myScene.getStylesheets();
         mySheets.add(CSS_STYLE);
         setScene(myScene);
 
         /* Initialise the month */
         initialiseMonth();
 
         theContainer.setOnKeyPressed(new EventHandler<KeyEvent>() {
             @Override
             public void handle(final KeyEvent t) {
                 if (t.getCode() == KeyCode.ESCAPE) {
                     closeNonModal();
                 }
             }
         });
     }
 
     /**
      * 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 */
         close();
     }
 
     /**
      * Resize the dialog.
      */
     private void reSizeDialog() {
         sizeToScene();
     }
 
     /**
      * 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.setBottom(theNullButton);
             } else {
                 theContainer.setBottom(null);
             }
 
             /* Record status and resize the dialog */
             isNullActive = theConfig.allowNullDateSelection();
             reSizeDialog();
         }
     }
 
     /**
      * Show the dialog.
      */
     public void showDialog() {
         /* Note that we have not selected */
         haveSelected = false;
 
         /* Initialise the current month and show the dialog */
         initialiseMonth();
         show();
     }
 
     /**
      * Close non-Modal.
      */
     private void closeNonModal() {
         close();
     }
 
     /**
      * ButtonHandler Handle button presses.
      */
     private class ButtonHandler
             implements EventHandler<ActionEvent> {
         @Override
         public void handle(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);
             }
         }
     }
 
     /**
      * Panel Navigation class allowing navigation between months.
      */
     private static final class PanelNavigation
             extends HBox {
         /**
          * The button style.
          */
         private static final String STYLE_BUTTON = "-jdd-button";
 
         /**
          * The title style.
          */
         private static final String STYLE_TITLE = "-jdd-title";
 
         /**
          * The owning dialog.
          */
         private final JDateDialog theDialog;
 
         /**
          * The Date Configuration.
          */
         private final JDateConfig theConfig;
 
         /**
          * The Date Label.
          */
         private final Label theDateLabel;
 
         /**
          * The Previous Month Button.
          */
         private final Button thePrevMonthButton;
 
         /**
          * The Next Month Button.
          */
         private final Button theNextMonthButton;
 
         /**
          * The Previous Year Button.
          */
         private final Button thePrevYearButton;
 
         /**
          * The Next Year Button.
          */
         private final Button theNextYearButton;
 
         /**
          * Constructor.
          * @param pDialog the owning dialog
          */
         private PanelNavigation(final JDateDialog pDialog) {
             /* Set single space */
             super(1.0);
 
             /* Record the dialog */
             theDialog = pDialog;
 
             /* Store the Date Configuration */
             theConfig = pDialog.getDateConfig();
 
             /* Create the label */
             theDateLabel = new Label();
             theDateLabel.getStyleClass().add(STYLE_TITLE);
 
             /* Create the buttons */
             thePrevMonthButton = new Button();
             theNextMonthButton = new Button();
             thePrevYearButton = new Button();
             theNextYearButton = new Button();
 
             /* Set the icons */
             thePrevMonthButton.setGraphic(ArrowIcon.LEFT.getArrow());
             theNextMonthButton.setGraphic(ArrowIcon.RIGHT.getArrow());
             thePrevYearButton.setGraphic(ArrowIcon.DOUBLELEFT.getArrow());
             theNextYearButton.setGraphic(ArrowIcon.DOUBLERIGHT.getArrow());
 
             /* Add ToopTips */
             theNextMonthButton.setTooltip(new Tooltip(NLS_NEXTMONTH));
             thePrevMonthButton.setTooltip(new Tooltip(NLS_PREVMONTH));
             theNextYearButton.setTooltip(new Tooltip(NLS_NEXTYEAR));
             thePrevYearButton.setTooltip(new Tooltip(NLS_PREVYEAR));
 
             /* Listen for button events */
             NavigateListener myListener = new NavigateListener();
             thePrevMonthButton.addEventFilter(ActionEvent.ACTION, myListener);
             theNextMonthButton.addEventFilter(ActionEvent.ACTION, myListener);
             thePrevYearButton.addEventFilter(ActionEvent.ACTION, myListener);
             theNextYearButton.addEventFilter(ActionEvent.ACTION, myListener);
 
             /* Restrict the margins */
             thePrevMonthButton.getStyleClass().add(STYLE_BUTTON);
             theNextMonthButton.getStyleClass().add(STYLE_BUTTON);
             thePrevYearButton.getStyleClass().add(STYLE_BUTTON);
             theNextYearButton.getStyleClass().add(STYLE_BUTTON);
 
             /* Create the struts */
             Region myStrut1 = new Region();
             Region myStrut2 = new Region();
             setHgrow(myStrut1, Priority.ALWAYS);
             setHgrow(myStrut2, Priority.ALWAYS);
 
             /* Add these elements into the HBox */
             ObservableList<Node> myChildren = getChildren();
             myChildren.add(thePrevYearButton);
             myChildren.add(thePrevMonthButton);
             myChildren.add(myStrut1);
             myChildren.add(theDateLabel);
             myChildren.add(myStrut2);
             myChildren.add(theNextMonthButton);
             myChildren.add(theNextYearButton);
         }
 
         /**
          * Build month details.
          */
         private void buildMonth() {
             /* Obtain 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());
 
             /* Set the label */
             theDateLabel.setText(myMonth
                                  + ", "
                                  + myYear);
 
             /* Access boundary dates */
             LocalDate myEarliest = theConfig.getEarliestDate();
             LocalDate myLatest = theConfig.getLatestDate();
 
             /* Enable/Disable buttons as required */
             thePrevMonthButton.setDisable(JDateConfig.isSameMonth(myEarliest, myBase));
             thePrevYearButton.setDisable(JDateConfig.isSameYear(myEarliest, myBase));
             theNextMonthButton.setDisable(JDateConfig.isSameMonth(myLatest, myBase));
             theNextYearButton.setDisable(JDateConfig.isSameYear(myLatest, myBase));
         }
 
         /**
          * Action Listener for buttons.
          */
         private class NavigateListener
                 implements EventHandler<ActionEvent> {
             @Override
             public void handle(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();
                 }
             }
         }
     }
 
     /**
      * Month Panel.
      */
     private static final class PanelMonth
             extends GridPane {
         /**
          * The panel style.
          */
         private static final String STYLE_PANEL = "-jdd-month";
 
         /**
          * The header style.
          */
         private static final String STYLE_HEADER = "-jdd-hdr";
 
         /**
          * 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;
 
         /**
          * Tile Width.
          */
         private static final int WIDTH_TILE = 22;
 
         /**
          * The Dialog.
          */
         private final JDateDialog theDialog;
 
         /**
          * The Date Configuration.
          */
         private final JDateConfig theConfig;
 
         /**
          * The Array of Days.
          */
         private final DayOfWeek[] theDaysOfWk = new DayOfWeek[DAYS_IN_WEEK];
 
         /**
          * The Array of Day Names.
          */
         private final Label[] theHdrs = new Label[DAYS_IN_WEEK];
 
         /**
          * The Array of Day Labels.
          */
         private final PanelDay[][] theDays = new PanelDay[MAX_WEEKS_IN_MONTH][DAYS_IN_WEEK];
 
         /**
          * The Active number of rows.
          */
         private int theNumRows = MAX_WEEKS_IN_MONTH;
 
         /**
          * Constructor.
          * @param pDialog the owning dialog
          */
         private PanelMonth(final JDateDialog pDialog) {
             /* Store parameters */
             theDialog = pDialog;
 
             /* Store the Date Configuration */
             theConfig = pDialog.getDateConfig();
 
             /* Define style of GridPane */
             getStyleClass().add(STYLE_PANEL);
 
             /* Add the Names to the layout */
             for (int iCol = 0; iCol < DAYS_IN_WEEK; iCol++) {
                 Label myDay = new Label();
                 myDay.setPrefWidth(WIDTH_TILE);
                 theHdrs[iCol] = myDay;
                 add(myDay, iCol, 0);
             }
 
             /* 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(theDialog);
                     theDays[iRow][iCol] = myDay;
                     add(myDay, iCol, iRow + 1);
                 }
             }
 
             /* Build the Day Names */
             buildDayNames();
         }
 
         /**
          * 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.
          */
         private void buildMonth() {
             /* Obtain the active month */
             LocalDate myCurr = theConfig.getCurrentMonth();
 
             /* Access the interesting days of the month */
             int iCurrent = theConfig.getCurrentDay();
             int iSelected = theConfig.getSelectedDay();
             int iEarliest = theConfig.getEarliestDay();
             int iLatest = theConfig.getLatestDay();
 
             /* Move to the start of the week */
             DayOfWeek myWeekDay = myCurr.getDayOfWeek();
             int iStart = getDayColumn(myWeekDay);
             if (iStart > 0) {
                 myCurr = myCurr.minusDays(iStart);
             }
 
             /* Loop through initial columns */
             int iCol = 0;
             for (int iDay = myCurr.getDayOfMonth(); iCol < iStart; 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 */
             int iRow = 0;
             int iMonth = myCurr.getMonthValue();
             for (int iDay = 1; iMonth == myCurr.getMonthValue(); iCol++, iDay++, myCurr = myCurr.plusDays(1)) {
                 /* Reset column if necessary */
                 if (iCol >= DAYS_IN_WEEK) {
                     iRow++;
                     iCol = 0;
                 }
 
                 /* Access the label */
                 PanelDay myLabel = theDays[iRow][iCol];
 
                 /* Reset the day */
                 myLabel.resetDay(true);
 
                 if (iSelected == iDay) {
                     myLabel.setSelected();
                 } else if (iCurrent == iDay) {
                     myLabel.setCurrent();
                 } else if (isWeekend(myCurr.getDayOfWeek())) {
                     myLabel.setWeekend();
                 }
 
                 /* 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 text */
                 myLabel.setDay(iDay, isSelectable);
             }
 
             /* Loop through remaining columns in row */
             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);
             }
 
             /* Resize to the number of rows */
             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 */
                 Label myLabel = theHdrs[iCol];
 
                 /* Reset classes */
                 ObservableList<String> myStyles = myLabel.getStyleClass();
                 myStyles.clear();
                 myStyles.add(STYLE_HEADER);
 
                 /* Access the required name */
                 myDoW = theDaysOfWk[iCol];
                 TextStyle myStyle = theConfig.showNarrowDays()
                                                                ? TextStyle.NARROW
                                                                : TextStyle.SHORT;
                 String myName = myDoW.getDisplayName(myStyle, myLocale);
 
                 /* Set the name */
                 myLabel.setText(myName);
 
                 /* Set weekend if required */
                 if (isWeekend(myDoW)) {
                     myStyles.add(PanelDay.STYLE_WEEKEND);
                 }
             }
         }
 
         /**
          * ReSize the number of visible rows.
          * @param iNumRows number of visible rows
          */
         private void reSizeRows(final int iNumRows) {
             /* Access the children */
             ObservableList<Node> myNodes = getChildren();
 
             /* Hide any visible rows that should now be hidden */
             while (iNumRows < theNumRows) {
                 /* Decrement number of rows */
                 theNumRows--;
 
                 /* Loop through remaining rows */
                 for (PanelDay myDay : theDays[theNumRows]) {
                     /* Remove from panel */
                     myNodes.remove(myDay);
                 }
             }
 
             /* Show any hidden rows that should now be visible */
             while (iNumRows > theNumRows) {
                 /* Increment number of rows */
                 theNumRows++;
 
                 /* Loop through remaining rows */
                 int iCol = 0;
                 for (PanelDay myDay : theDays[theNumRows - 1]) {
                     /* Add to panel */
                     add(myDay, iCol++, theNumRows);
                 }
             }
 
             /* RePack the Dialog */
             theDialog.sizeToScene();
         }
     }
 
     /**
      * Panel class representing a single day in the panel.
      */
     private static final class PanelDay
             extends Label {
         /**
          * The panel style.
          */
         private static final String STYLE_PANEL = "-jdd-day";
 
         /**
          * The inactive style.
          */
         private static final String STYLE_INACTIVE = "-jdd-inactive";
 
         /**
          * The selected style.
          */
         private static final String STYLE_SELECTED = "-jdd-selected";
 
         /**
          * The current style.
          */
         private static final String STYLE_CURRENT = "-jdd-current";
 
         /**
          * The weekend style.
          */
         private static final String STYLE_WEEKEND = "-jdd-weekend";
 
         /**
          * The Dialog.
          */
         private final JDateDialog theDialog;
 
         /**
          * The day of the month.
          */
         private int theDay = -1;
 
         /**
          * Is the item Select-able?
          */
         private boolean isSelectable = false;
 
         /**
          * Constructor.
          * @param pDialog the owning dialog
          */
         protected PanelDay(final JDateDialog pDialog) {
             /* Store parameters */
             theDialog = pDialog;
 
             /* Set width */
             setPrefWidth(PanelMonth.WIDTH_TILE);
             addEventFilter(MouseEvent.MOUSE_CLICKED, new MouseEventHandler());
         }
 
         /**
          * Reset a Day Label.
          * @param isActive true/false
          */
         private void resetDay(final boolean isActive) {
             setTooltip(null);
             getStyleClass().clear();
             getStyleClass().add(STYLE_PANEL);
             if (!isActive) {
                 getStyleClass().add(STYLE_INACTIVE);
             }
         }
 
         /**
          * 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("");
             }
 
             /* Enable/Disable the label */
             setDisable(!isSelectable);
         }
 
         /**
          * Set weekend.
          */
         private void setWeekend() {
             getStyleClass().add(STYLE_WEEKEND);
         }
 
         /**
          * Set selected day.
          */
         private void setSelected() {
             getStyleClass().add(STYLE_SELECTED);
             setTooltip(new Tooltip(NLS_SELECTEDDAY));
         }
 
         /**
          * Set current day.
          */
         private void setCurrent() {
             getStyleClass().add(STYLE_CURRENT);
             setTooltip(new Tooltip(NLS_CURRENTDAY));
         }
 
         /**
          * Mouse event handler.
          */
         private class MouseEventHandler
                 implements EventHandler<MouseEvent> {
             @Override
             public void handle(final MouseEvent event) {
                 theDialog.setSelected(theDay);
             }
         }
     }
 }