/*
   COPYRIGHT (C) 2010 - 2013 by Alexander Wait. All Rights Reserved.

   This class displays the interest calculator GUI.

   @site http://www.javaika.com
   @author Alexander Wait
   @version 2012-09-15
*/



import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.*;
import java.text.DecimalFormat;
import javax.swing.*;



public class InterestCalculatorGui extends JApplet implements ComponentListener
{
   private static final String copyright = "Copyright (c) 2012 by Alexander Wait - All Rights Reserved";
   
   private static final long serialVersionUID = 1L;
   
   
   static boolean isApplication = false;
   
   static boolean isVisible = false;
   
   
   private static final int FRAME_SIZE_X = 450;
   
   private static final int FRAME_SIZE_Y = 555;
   
   private static final int OPTION_LENGTH = 5;
   
   
   //************************************** START INITIALISATION CODE **************************************//
   
   
   /**
    * Browser constructor.
    */
   public void init()
   {  
      String copyrightParam = getParameter("copyright");
       
      if ((copyrightParam == null) || !copyrightParam.equals(copyright)) 
      {
         Message.showMessage("Invalid Copyright", "WARNING", "warning"); 
      }       
       
      else if (!getDocumentBase().getHost().equals(Domain.getDomain())) 
      {
         Message.showMessage("Unauthorised Applet Use", "ERROR", "error");
      }
  
      else
      {     
         initialiser(); includeResizeEvent(); 
         
         setSize(FRAME_SIZE_X,FRAME_SIZE_Y);
      }
   }
   
   
   
   /**
    * Application constructor.
    */
   public InterestCalculatorGui() 
   {
      if (isApplication)
      {
         initialiser(); 
         
         
         frame = new JFrame(); 
         
         frame.setMinimumSize(new Dimension(FRAME_SIZE_X, FRAME_SIZE_Y));
         
         frame.setSize(FRAME_SIZE_X,FRAME_SIZE_Y); 
         
         frame.setLocationRelativeTo(null); 
         
         frame.setTitle("Interest Calculator Program"); 
         
         frame.add(contentPane); 
         
         
         setVisibility();
      }
      
   }
   
   
   
   /**
    * GUI initializer.
    * ESCA-JAVA0076
    */
   private void initialiser()
   {     
      interestCalculator = new InterestCalculator(); 
      
      
      // Initialize content pane and layout.
      
      contentPane = getContentPane();
      
      contentPane.setLayout(new GridBagLayout());
      
      
      
      // Initialize JLabel GUI components.
      
      optionLabel = new JLabel("OPTION");
      
      optionLabel.setHorizontalAlignment(SwingConstants.LEFT);
      
      
      settingsLabel = new JLabel("SETTINGS");
      
      settingsLabel.setHorizontalAlignment(SwingConstants.LEFT);
      
      
      displayLabel = new JLabel("DISPLAY");
      
      displayLabel.setHorizontalAlignment(SwingConstants.LEFT);
      
      

      // Initialize text area GUI components.
      
      optionDisplay = new JTextArea(); optionDisplay.setEditable(false);
      
      optionDisplay.setFont(new Font("Dialog", Font.PLAIN, 11));
      
      optionDisplay.setText("Select an investment return option below"); 
      
      
      resultDisplay = new JTextArea(); resultDisplay.setEditable(false);
      
      resultDisplay.setPreferredSize(new Dimension(390,104));
      
      resultDisplay.setBorder(BorderFactory.createEtchedBorder());
      
      resultDisplay.setFont(new Font("Serif", Font.BOLD, 15));
      
      
      
      // Initialize text field GUI components.
      
      investAmount = new JTextField();
      
      investAmount.setBorder(BorderFactory.createTitledBorder("Invest Amount"));
      
      
      investTerm = new JTextField();
      
      investTerm.setBorder(BorderFactory.createTitledBorder("Invest Term"));
      
      
      depositAmount = new JTextField();
      
      depositAmount.setBorder(BorderFactory.createTitledBorder("Deposit Amount"));
      
      
      investGoal = new JTextField();
       
      investGoal.setBorder(BorderFactory.createTitledBorder("Invest Goal"));
      
      
      interestRate = new JTextField();
      
      interestRate.setBorder(BorderFactory.createTitledBorder("Interest Rate"));
      
      
      
      // Initialize combo box GUI components.
      
      frequencyBox = new JComboBox(frequencyChoices);
      
      frequencyBox.setMaximumRowCount(2); frequencyBox.setSelectedIndex(3);
      
      
      
      // Initialize button GUI components.
      
      calculate = new JButton(new ImageIcon(this.getClass().getResource
      (
         "files/images/FinanceToolCalculateNormal.png"))
      ); 
          
      
      calculate.setRolloverIcon(new ImageIcon(this.getClass().getResource
      (
         "files/images/FinanceToolCalculateRollover.png"))
      );

      
      calculate.setPressedIcon(new ImageIcon(this.getClass().getResource
      (
         "files/images/FinanceToolCalculatePressed.png"))
      );
      
      
      calculate.setBorder(BorderFactory.createEmptyBorder(0,0,0,0));
      
      calculate.addActionListener(new CalculateButtonListener());
      
      
      clear = new JButton(new ImageIcon(this.getClass().getResource
      (
         "files/images/FinanceToolClearNormal.png"))
      ); 
     
      
      clear.setRolloverIcon(new ImageIcon(this.getClass().getResource
      (
         "files/images/FinanceToolClearRollover.png"))
      );

      
      clear.setPressedIcon(new ImageIcon(this.getClass().getResource
      (
         "files/images/FinanceToolClearPressed.png"))
      );   
         
      
      clear.setBorder(BorderFactory.createEmptyBorder(0,0,0,0));
      
      clear.addActionListener(new ClearButtonListener());
      
      
      
      // Initialize JPanel GUI components.
      
      optionPanel = new JPanel(); 
      
      optionPanel.setLayout (new FlowLayout(FlowLayout.LEADING));
      
      optionPanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
      
      
      buttonPanel = new JPanel(); 
      
      buttonPanel.setLayout (new FlowLayout(FlowLayout.LEADING));
      
      buttonPanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));

      
      frequencyContainer = new JPanel();
      
      frequencyContainer.setBorder(BorderFactory.createTitledBorder("Payment"));
      
      
      
      // Add GUI components to JPanels.
      
      frequencyContainer.add(frequencyBox);
      
      buttonPanel.add(calculate); buttonPanel.add(clear);

      
      
      // Method calls for GUI initialization.
      
      gridBagConstraints(); setOptions(); setColors();
   }
   
   
   
   /**
    * Sets the background color.
    */
   private void setColors()
   {
      for (JRadioButton option : options) 
      {
         option.setBackground
         (
            new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
         ); 
      }
  
      contentPane.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      ); 
      
      frequencyContainer.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      ); 
      
      optionPanel.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      ); 
      
      buttonPanel.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      );

      optionDisplay.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      ); 
      
      resultDisplay.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      ); 
      
      investAmount.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      );
      
      investTerm.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      );
      
      depositAmount.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      );
      
      interestRate.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      );
      
      investGoal.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      );
      
   }
   
   
   
   /**
    * Sets the grid bag layout.
    * ESCA-JAVA0076:
    */
   private void gridBagConstraints()
   {
      // Initialize grid bag layout of GUI.
      
      constraints = new GridBagConstraints();
      
      constraints.fill = GridBagConstraints.HORIZONTAL;
      
      
      
      // Grid bag constraints 1.
      
      constraints.insets = new Insets(10,0,0,0);
      
      
      constraints.ipadx = 0; 
      
      constraints.ipady = 0;

      constraints.gridwidth = 3;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 0; 
      
      constraints.gridy = 0;
      
      
      contentPane.add(optionLabel, constraints);
      
      
      
      // Grid bag constraints 2.
      
      constraints.insets = new Insets(10,10,0,0);
      
      
      constraints.ipadx = 0; 
      
      constraints.ipady = 0;

      constraints.gridwidth = 3;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 0; 
      
      constraints.gridy = 1;
      
      
      contentPane.add(optionDisplay, constraints);
      
      
      
      // Grid bag constraints 3.
      
      constraints.insets = new Insets(10,10,0,0);
      
      
      constraints.ipadx = 0; 
      
      constraints.ipady = 0;

      constraints.gridwidth = 3;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 0; 
      
      constraints.gridy = 2;
      
      
      contentPane.add(optionPanel, constraints);
      
      
      
      // Grid bag constraints 4.
      
      constraints.insets = new Insets(20,0,0,0);
      
      
      constraints.ipadx = 0; 
      
      constraints.ipady = 0;

      constraints.gridwidth = 3;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 0; 
      
      constraints.gridy = 3;
      
      
      contentPane.add(settingsLabel, constraints);
      
      
      
      // Grid bag constraints 5.
      
      constraints.insets = new Insets(10,10,0,0);
      
      
      constraints.ipadx = 120; 
      
      constraints.ipady = 20;

      constraints.gridwidth = 1;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 0; 
      
      constraints.gridy = 4;
      
      
      contentPane.add(investAmount, constraints);
      
      
      
      // Grid bag constraints 6.
      
      constraints.insets = new Insets(10,0,0,0);
      
      
      constraints.ipadx = 120; 
      
      constraints.ipady = 20;

      constraints.gridwidth = 1;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 1; 
      
      constraints.gridy = 4;
      
      
      contentPane.add(investTerm, constraints);
      
      
      
      // Grid bag constraints 7.
      
      constraints.insets = new Insets(10,0,0,0);
      
      
      constraints.ipadx = 120; 
      
      constraints.ipady = 20;

      constraints.gridwidth = 1;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 2; 
      
      constraints.gridy = 4;
      
      
      contentPane.add(depositAmount, constraints);
      
      
      
      // Grid bag constraints 8.
      
      constraints.insets = new Insets(10,10,0,0);
      
      
      constraints.ipadx = 120; 
      
      constraints.ipady = 20;

      constraints.gridwidth = 1;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 0; 
      
      constraints.gridy = 5;
      
      
      contentPane.add(investGoal, constraints);
      
      
      
      // Grid bag constraints 9.
      
      constraints.insets = new Insets(10,0,0,0);
      
      
      constraints.ipadx = 120; 
      
      constraints.ipady = 20;

      constraints.gridwidth = 1;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 1; 
      
      constraints.gridy = 5;
      
      
      contentPane.add(interestRate, constraints);
      
      
      
      // Grid bag constraints 10.
      
      constraints.insets = new Insets(10,0,0,0);
      
      
      constraints.ipadx = 0; 
      
      constraints.ipady = 1;

      constraints.gridwidth = 1;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 2; 
      
      constraints.gridy = 5;
      
      
      contentPane.add(frequencyContainer, constraints);
      
      
      
      // Grid bag constraints 11.
      
      constraints.insets = new Insets(20,0,0,0);
      
      
      constraints.ipadx = 0; 
      
      constraints.ipady = 0;

      constraints.gridwidth = 3;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 0; 
      
      constraints.gridy = 6;
      
      
      contentPane.add(displayLabel, constraints);
      
      
      
      // Grid bag constraints 12.
      
      constraints.insets = new Insets(10,10,0,0);
      
      
      constraints.ipadx = 0; 
      
      constraints.ipady = 0;

      constraints.gridwidth = 3;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 0; 
      
      constraints.gridy = 7;
      
      
      contentPane.add(resultDisplay, constraints);
      
      
      
      // Grid bag constraints 13.
      
      constraints.anchor = GridBagConstraints.PAGE_END;
      
      constraints.insets = new Insets(10,10,10,0);
      
      
      constraints.ipadx = 0; 
      
      constraints.ipady = 0;

      constraints.gridwidth = 3;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 1; 
      
      constraints.gridx = 0; 
      
      constraints.gridy = 8;
      
      
      contentPane.add(buttonPanel, constraints);
   }
    
   
   //*************************************** END INITIALISATION CODE ***************************************//
   
   
   //************************************* START INTERFACE EVENT CODE **************************************//
   
   
   private class OptionLineListener
   implements ActionListener
   {

      /**
       * Listen to input line record selection.
       * @param args
       */
      private OptionLineListener(int args)
      {
         optionRadio = args;
      }

      public void actionPerformed(ActionEvent event)
      {
         clearSettings();
     
     
         switch (optionRadio)
         {
            case 0: 
            
               optionDisplay.setText(" Return the future value on an investment"); 
               
               investAmount.setEnabled(true); depositAmount.setEnabled(true);
               
               investGoal.setEnabled(false); investTerm.setEnabled(true);
                 
               break;
        
            case 1:
            
               optionDisplay.setText(" Return the required deposit amount to reach an investment goal");
               
               investAmount.setEnabled(true); investTerm.setEnabled(true);
               
               depositAmount.setEnabled(false); investGoal.setEnabled(true);
                   
               break;
        
            case 2:
           
               optionDisplay.setText(" Return the required investment term to reach an investment goal"); 
               
               investAmount.setEnabled(true); depositAmount.setEnabled(true);
               
               investTerm.setEnabled(false); investGoal.setEnabled(true);
                
               break;
        
            case 3:
            
               optionDisplay.setText(" Return the initial investment amount"); 
               
               depositAmount.setEnabled(true); investTerm.setEnabled(true);
               
               investGoal.setEnabled(true); investAmount.setEnabled(false);

               break;
            
            case 4:
                
                optionDisplay.setText(" Return the accumulated interest earned on an investment"); 
                
                depositAmount.setEnabled(false); investTerm.setEnabled(true);
                
                investGoal.setEnabled(false); investAmount.setEnabled(true);

                break;
               
            default:
            
               optionDisplay.setText(" Selection not valid");
    
               break;
         }
          
      }

      int optionRadio;
   }
   
   
   
   private class CalculateButtonListener
   implements ActionListener
   {
  
      private static final double CONVERSION = 0.01;
  
  
      /** 
       * Listener to calculate result.
       * ESCA-JAVA0266 
       */
      public void actionPerformed(ActionEvent event)
      {
         resultDisplay.setText("\n"); 
         
         DecimalFormat places = new DecimalFormat("#.##");
         
         
         try
         {
            double iRate = Double.parseDouble(interestRate.getText()) * CONVERSION;
         
            String dFrequency = (String)frequencyBox.getSelectedItem();
         
         
            if (options[0].isSelected())
            {
               int iTerm = Integer.parseInt(investTerm.getText()); 
        
               double dAmount = Double.parseDouble(depositAmount.getText());
             
               double iAmount = Double.parseDouble(investAmount.getText());    
                           
               
               interestCalculator.futureAmount(iAmount, iRate, dAmount, iTerm, dFrequency);
                  
               
               if (interestCalculator.getValue() > 0)
               {   
                  resultDisplay.append
                  (
                     " The future value on this investment is " + "\n\n" + 
                  
                     " $ " + Double.valueOf(places.format(interestCalculator.getValue())) + "\n"
                  );
               }
               
            }
         
            else if (options[1].isSelected())
            {
               int iTerm = Integer.parseInt(investTerm.getText());
            
               double iAmount = Double.parseDouble(investAmount.getText());
               
               double iGoal = Double.parseDouble(investGoal.getText());
               
               
               interestCalculator.depositAmount(iGoal, iAmount, iRate, iTerm, dFrequency);
               
               resultDisplay.append
               (
                  " The " + dFrequency.toLowerCase() + 
               
                  " deposit amount should be " + "\n\n" + " $ " + 
               
                  Double.valueOf(places.format(interestCalculator.getValue())) + "\n"
               );
            }
         
            else if (options[2].isSelected())
            {
               double iAmount = Double.parseDouble(investAmount.getText());
            
               double dAmount = Double.parseDouble(depositAmount.getText());
               
               double iGoal = Double.parseDouble(investGoal.getText());
               
               
               interestCalculator.investTerm(iGoal, iAmount, iRate, dAmount, dFrequency);
               
               if ((int)interestCalculator.getValue() != (int)interestCalculator.getTermination())
               { 
                  resultDisplay.append
                  (
                     " The total number of " + dFrequency.toLowerCase() + 
                  
                     " deposits required is " + "\n\n" + " " + 
                  
                     (int)(Math.ceil(interestCalculator.getValue())) + "\n"
                  );
               }
               
               else
               {
                  resultDisplay.append(" The calculated term of this investment is too long." + "\n");
               }
            }
         
            else if (options[3].isSelected())
            {
               int iTerm = Integer.parseInt(investTerm.getText());
               
               double dAmount = Double.parseDouble(depositAmount.getText());
               
               double iGoal = Double.parseDouble(investGoal.getText());
               
               
               interestCalculator.investAmount(iGoal, iRate, dAmount, iTerm, dFrequency);
               
               resultDisplay.append
               (
                  " The original investment amount deposited is " + "\n\n" +
               
                  " $ " + Double.valueOf(places.format(interestCalculator.getValue())) + "\n"
               );
            }
            
            else if (options[4].isSelected())
            {
               int iTerm = Integer.parseInt(investTerm.getText());
                
               double iAmount = Double.parseDouble(investAmount.getText());

               
               interestCalculator.interestAmount(iAmount, iRate, iTerm, dFrequency);
               
               resultDisplay.append
               (
                  " The interest earned on this investment is " + "\n\n" +
               
                  " $ " + Double.valueOf(places.format(interestCalculator.getValue())) + "\n"
               );
            }
            
         }
         
         catch (NumberFormatException e)
         {
            System.out.println(Tools.thisPathAndLine() + e + "\n");
            
            clearSettings();   
         }

      }
      
   }
   
   
   
   private class ClearButtonListener
   implements ActionListener
   {
  
      /** 
       * Listener to calculate result.
       * ESCA-JAVA0266 
       */
      public void actionPerformed(ActionEvent event)
      {
         clearSettings(); 
     
      }
   }
   
   
   
   /**
    * Overrides ComponentListener.
    */
   public void componentMoved(ComponentEvent e) {}
   
   
   public void componentResized(ComponentEvent e) {}
   
   
   public void componentShown(ComponentEvent e) {setContentDisplay(true);}
   
   
   public void componentHidden(ComponentEvent e) {setContentDisplay(false);}
   
    
   //************************************** END INTERFACE EVENT CODE ***************************************//
   
   
   //**************************************** START PUBLIC METHODS *****************************************//
   
   
   /**
    * Sets the visibility of the frame.
    */
   public void setVisibility()
   {
   
      if (isVisible)
      {
         frame.setVisible(true);
      }
      
      else
      {
         frame.setVisible(false);
      } 
   }
   

   
   /**
    * Displays or Hides contents of GUI.
    * @param shown
    */
   public void setContentDisplay(boolean shown)
   {
      contentPane.setVisible(shown);
   }
   
   
   //***************************************** END PUBLIC METHODS ******************************************//


   //**************************************** START PRIVATE METHODS ****************************************//


   /**
    * Sets the loan options.
    */
   private void setOptions()
   {
      ButtonGroup select = new ButtonGroup();
      
      options = new JRadioButton[OPTION_LENGTH];

      for (int i = 0; i < OPTION_LENGTH; i ++)
      {
         options[i] = new JRadioButton("Option " + (i + 1), false);
         
         
         options[i].setIcon(new ImageIcon(this.getClass().getResource
         (
            "files/images/RadioButtonNormalUnselected.png"))
         );
                     
         options[i].setSelectedIcon(new ImageIcon(this.getClass().getResource
         (
            "files/images/RadioButtonNormalSelected.png"))
         );

         options[i].setDisabledIcon(new ImageIcon(this.getClass().getResource
         (
            "files/images/RadioButtonDisabledUnselected.png"))
         );

         options[i].setDisabledSelectedIcon(new ImageIcon(this.getClass().getResource
         (
            "files/images/RadioButtonDisabledSelected.png"))
         );
         
         
         options[i].setFocusPainted(false);
         
         select.add(options[i]); optionPanel.add(options[i]);
         
         options[i].addActionListener(new OptionLineListener(i));  
      }
      
   }
   
   
   
   /**
    * Clears the input fields and display.
    */
   private void clearSettings()
   {
      investAmount.setText(""); investTerm.setText(""); depositAmount.setText("");
      
      interestRate.setText(""); investGoal.setText(""); resultDisplay.setText("");
      
   }
   
   
   
   /**
    * Window resize event.
    */
   private void includeResizeEvent()
   {
      this.addComponentListener 
      (
         new ComponentAdapter() 
         {
            public void componentResized(ComponentEvent e) 
            {
               appletDisplayHandler();
            }
          
         }
      ); 
   }
   
   
   
   /**
    * Controls the JApplet component visibility. 
    * ESCA-JAVA0266:
    */
   private void appletDisplayHandler()
   {
      final String ZOOM_WARNING = 
   
      "It appears that web pages in your browser are zoomed out. \n\n" +
      "In order to display the applet, your browser needs to be set \n" +
      "at its default zoom level of 100% or greater. \n\n" +
      "Sorry about that.";
   
   
      if ((getWidth() < FRAME_SIZE_X) || (getHeight() < FRAME_SIZE_Y))
      {
         contentPane.setVisible(false);  
      
         
         if (!zoomWarningShown) 
         {
            Message.showMessage(ZOOM_WARNING, "Browser zoom setting", "warning");
            
            zoomWarningShown = true;
         } 
      }
       
      else 
      {
         contentPane.setVisible(true);
      } 
   }
   
   
   //***************************************** END PRIVATE METHODS *****************************************//
   
   
   //********************************************** START MAIN *********************************************//
  
   
   /**
    * Main
    * @param a
    */
   public static void main(String[] a)
   {
      isApplication = true;
      
      isVisible = true;
     
      new InterestCalculatorGui();
   }
   
   
   //*********************************************** END MAIN **********************************************//
   
   
   /**
    * ESCA-JAVA0007:
    */
   public JFrame frame;
   
   private Container contentPane;
   private JRadioButton[] options;
   private boolean zoomWarningShown;
   private JButton calculate, clear;
   private JComboBox frequencyBox;
   private GridBagConstraints constraints;
   private InterestCalculator interestCalculator;
   private JTextArea optionDisplay, resultDisplay;
   private JLabel optionLabel, settingsLabel, displayLabel;
   private JPanel optionPanel, frequencyContainer, buttonPanel;
   
   private JTextField investAmount, investTerm, depositAmount, interestRate, investGoal;
   private String[] frequencyChoices = { "Daily", "Yearly", "Weekly", "Monthly", "Fortnightly"};
   
   
   //********************************************** END CLASS **********************************************//
   
}


/*
   COPYRIGHT (C) 2010 - 2013 by Alexander Wait. All Rights Reserved.

   This class calculates interest queries given a starting amount, 
   installments, frequency, term and yearly interest rate.

   @site http://www.javaika.com
   @author Alexander Wait
   @version 2012-09-15
*/



public class InterestCalculator 
{

   private static final double TERMINATE = 50000;
   
   
   /**
    * ESCA-JAVA0057:
    */
   public InterestCalculator() {}
   
  
   //**************************************** START PUBLIC METHODS *****************************************//


   /**
    * Returns the final amount after the investment.
    * @param investAmount
    * @param interestRate
    * @param depositAmount
    * @param investTerm
    * @param deposits
    */
   public void futureAmount(double investAmount, 
   double interestRate, double depositAmount, int investTerm, String deposits)
   {
      if (interestRate <= 0)
      {
         value = investAmount + (depositAmount * investTerm);
      }
      
      else
      {
         double formulaFactor = Math.pow(1 + getCorrectedRate(interestRate, deposits), investTerm);  
      
      
         value = (investAmount * formulaFactor) +
     
         ((depositAmount / getCorrectedRate(interestRate, deposits)) * (formulaFactor - 1));
      
      }

   }
   
   
   
   /**
    * Returns the investment deposit amount.
    * @param futureAmount
    * @param investAmount
    * @param interestRate
    * @param investTerm
    * @param deposits
    */
   public void depositAmount(double futureAmount, 
   double investAmount, double interestRate, int investTerm, String deposits)
   {
      if (interestRate <= 0)
      {
         value = (futureAmount - investAmount) / investTerm;
      }

      else
      {
       
         double formulaFactor = Math.pow(1 + getCorrectedRate(interestRate, deposits), investTerm);
     

         value = ((futureAmount - investAmount * formulaFactor) * 
       
         getCorrectedRate(interestRate, deposits)) / (formulaFactor - 1);
      
      }
      
   }
   
   
   
   /**
    * Returns the investment duration to meet a target.
    * @param futureAmount
    * @param investAmount
    * @param interestRate
    * @param depositAmount
    * @param deposits
    */
   public void investTerm(double futureAmount, 
   double investAmount, double interestRate, double depositAmount, String deposits)
   {
  
      if (interestRate <= 0)
      {
         value = (futureAmount - investAmount) / depositAmount;     
      }
      
      else
      {
         value = 0; 
      
         
         while(value < TERMINATE)
         {
            double formulaFactor = Math.pow(1 + getCorrectedRate(interestRate, deposits), value);  
             
             
            double current = (investAmount * formulaFactor) + 
         
            ((depositAmount / getCorrectedRate(interestRate, deposits)) * (formulaFactor - 1));
            
            
            if (current > futureAmount) {break;}
            
            else {value ++;}
         }
      
      }
      
   }
   
   
   
   /**
    * Returns the original investment amount.
    * @param futureAmount
    * @param interestRate
    * @param depositAmount
    * @param investTerm
    * @param deposits
    */
   public void investAmount(double futureAmount, 
   double interestRate, double depositAmount, int investTerm, String deposits)
   {
      if (interestRate <= 0)
      {
         value = futureAmount - (depositAmount * investTerm);
      }
 
      else
      {
      
         double formulaFactor = Math.pow(1 + getCorrectedRate(interestRate, deposits), investTerm);
      

         value = (futureAmount - (depositAmount / getCorrectedRate(interestRate, deposits)) *
    
         (formulaFactor - 1)) / formulaFactor;
         
      }
      
   }
   
   
   
   /**
    * Returns the interest amount.
    * @param investAmount
    * @param interestRate
    * @param investTerm
    * @param deposits
    */
   public void interestAmount(double investAmount, 
   double interestRate, int investTerm, String deposits)
   {
      if (interestRate <= 0)
      {
         value = 0;
     
      }
   
      else
      {
      
         value = investTerm * (getCorrectedRate(interestRate, deposits) * investAmount) /

         (1 - Math.pow(1 + getCorrectedRate(interestRate, deposits), -investTerm)) - investAmount;
      
      }
      
   }
   
   
   
   /**
    * Returns the loan query value.
    * @return
    */
   public double getValue() {return value;}
   
   
   
   /**
    * Returns the termination cycles.
    * @return
    */
   public double getTermination()
   {
      return TERMINATE;
   }
   
   
   //***************************************** END PUBLIC METHODS ******************************************//
   
   
   //**************************************** START PRIVATE METHODS ****************************************//

   
   /**
    * Corrects the interest rate value depending on repay frequency.
    * @param rate
    * @param repayments
    * @return
    */
   private static double getCorrectedRate(double rate, String repayments)
   {
      double interest = 0;
      
      if (repayments.equals("Yearly")) {interest = rate;}
   
      if (repayments.equals("Daily")) {interest = (rate / DateAndTime.getDaysNormalYear());}
      
      if (repayments.equals("Weekly")) {interest = (rate / DateAndTime.getWeeksInYear());}
          
      if (repayments.equals("Monthly")) {interest = (rate / DateAndTime.getMonthsInYear());}
     
      if (repayments.equals("Fortnightly")) {interest = (rate / DateAndTime.getFortnightsInYear());}
      
      return interest;
   }
   
   
   //***************************************** END PRIVATE METHODS *****************************************//
   
  
   private double value;
   
   
   //********************************************** END CLASS **********************************************//
   
}


/*
   COPYRIGHT (C) 2010 -2013 by Alexander Wait. All Rights Reserved.

   This class defines colors and color methods.

   @site http://www.javaika.com
   @author Alexander Wait
   @version 2012-05-18
*/



public class ColorFunctions
{

   private static final int HEXADECIMAL_BASE = 16;
   
   private static final int COLOR_COMPONENT_RED = 250;
   
   private static final int COLOR_COMPONENT_GREEN = 250;
   
   private static final int COLOR_COMPONENT_BLUE = 250;
   
   
   
   private ColorFunctions() {}
   
   
   //**************************************** START PUBLIC METHODS *****************************************//

   
   /**
    * Returns the color in hexadecimal format.
    * @param sliderValue
    * @return
    */
   public static String returnHexadecimalColor(int sliderValue)
   {
      String compFirst = ""; String compSecond = ""; int counter = -1;
 
      for (int i = 0; i < HEXADECIMAL_BASE; i ++)
      {
         compFirst = returnComponent(i);

          for (int j = 0; j < HEXADECIMAL_BASE; j ++)
          {
             compSecond = returnComponent(j); counter ++; 
  
             if (counter == sliderValue)
             {
                break;
             }
             
          }
  
          if (counter == sliderValue)
          {
             break;
          }
  
       }
   
       return 
       (
          "#" + compFirst + compSecond + compFirst + 
          
          compSecond + compFirst + compSecond
       );
   
   }
   
   
   
   /**
    * Return the set red color component 
    * for setting the programs background color. 
    * @return
    */
   public static int red()
   {
      return COLOR_COMPONENT_RED;
   }
   
   
   
   /**
    * Return the set green color component 
    * for setting the programs background color. 
    * @return
    */
   public static int green()
   {
      return COLOR_COMPONENT_GREEN;
   }
   
   
   
   /**
    * Return the set blue color component 
    * for setting the programs background color. 
    * @return
    */
   public static int blue()
   {
      return COLOR_COMPONENT_BLUE;
   }
   
   
   //***************************************** END PUBLIC METHODS ******************************************//


   //**************************************** START PRIVATE METHODS ****************************************//
   
   
   /**
    * Returns the hexadecimal component.
    * ESCA-JAVA0076:
    * @param index
    * @return
    */
   private static String returnComponent(int index)
   {
      String component = "";
  
      switch (index)
      {
         case 10: component = "A"; break; case 11: component = "B"; break;  
         
         case 12: component = "C"; break; case 13: component = "D"; break; 
         
         case 14: component = "E"; break; case 15: component = "F"; break;
   
         default: component = Integer.toString(index); break;
      }
   
      return component;   
   }
   
 
   //***************************************** END PRIVATE METHODS *****************************************//

   
   //********************************************** END CLASS **********************************************//
   
}


/*
   COPYRIGHT (C) 2010 -2013 by Alexander Wait. All Rights Reserved.

   This class returns date and time and provides functions relating to time.

   @site http://www.javaika.com
   @author Alexander Wait
   @version 2012-04-18
*/



import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.GregorianCalendar;



public class DateAndTime 
{

   private static final int DAY_INDEX = 2; 
   private static final int MONTH_INDEX = 1; 
   private static final int YEAR_INDEX = 0; 
   
   private static final int MILLISECONDS_PER_SECOND = 1000;
   private static final int SECONDS_PER_MINUTE = 60;
   private static final int MINUTES_PER_HOUR = 60;
   private static final int HOURS_PER_DAY = 24;
   
   private static final int DAYS_IN_WEEK = 7;
   private static final int DAYS_IN_YEAR = 365;
   private static final int WEEKS_IN_YEAR = 52;   
   private static final int MONTHS_IN_YEAR = 12;
   private static final int FORTNIGHTS_IN_YEAR = 26;
   
   private static Calendar now = Calendar.getInstance();
   
   public static enum Elements {YEAR, MONTH, DAY}
   

   private DateAndTime() {}
   
   
   //**************************************** START PUBLIC METHODS *****************************************//
   
   
   /**
    * Tests and compares two dates.
    * @param dateFirst
    * @param dateSecond
    * @return
    */
   public static boolean dateComparison(String dateFirst, String dateSecond) 
   {
      String[] first = dateFirst.split("[-]", 0); 
      
      String[] second = dateSecond.split("[-]", 0);

      int firstDayInt = Integer.parseInt(first[DAY_INDEX]); 
      
      int firstMonthInt = Integer.parseInt(first[MONTH_INDEX]); 
      
      int firstYearInt = Integer.parseInt(first[YEAR_INDEX]); 
      
      int secondDayInt = Integer.parseInt(second[DAY_INDEX]); 
      
      int secondMonthInt = Integer.parseInt(second[MONTH_INDEX]); 
      
      int secondYearInt = Integer.parseInt(second[YEAR_INDEX]);

      return 
      
        compareDates(firstDayInt, firstMonthInt, 
        firstYearInt, secondDayInt, secondMonthInt, secondYearInt);
   }



   /**
    * Compares two dates to test if one date is more current than the other. 
    * @param fstDay
    * @param fstMonth
    * @param fstYear
    * @param sndDay
    * @param sndMonth
    * @param sndYear
    * @return
    */
   public static boolean compareDates(int fstDay, int fstMonth, 
   int fstYear, int sndDay, int sndMonth, int sndYear)
   {
      if (sndYear > fstYear) {return true;}

      else if (sndYear < fstYear) {return false;}

      else
      {
         if (sndMonth > fstMonth) {return true;}

         else if (sndMonth < fstMonth) {return false;}

         else 
         {
            if (sndDay >= fstDay) {return true;}

            else {return false;}
         }
      }
   }
   
   
   
   /**
    * Returns true if the time given is before current time.
    * @param hour
    * @param minute
    * @param second
    * @return
    */
   public static boolean isBeforeCurrentTime(int hour, int minute, int second)
   {
      
      if (returnHour() > hour) {return true;}
     
      else if (returnHour() < hour) {return false;}
  
      else 
      {
         if (returnMinute() > minute) {return true;}
         
         else if (returnMinute() < minute) {return false;}
       
         else 
         {
            if (returnSecond() > second) {return true;}
        
            else {return false;}
         }
      } 
  
   }
   
   
   
   /**
    * Returns true if the time to be tested is after the reference.
    * @param hour
    * @param minute
    * @param second
    * @param testHour
    * @param testMinute
    * @param testSecond
    * @return
    */
   public static boolean isAfterReferenceTime(int hour, int minute, 
   int second, int testHour, int testMinute, int testSecond)
   {
  
      if (hour < testHour) {return true;}
      
      else if (hour > testHour) {return false;}
   
      else 
      {
    
         if (minute < testMinute) {return true;}
         
         else if (minute > testMinute) {return false;}
         
         else 
         {
      
            if (second < testSecond) {return true;}
        
            else {return false;}
         }
      } 
  
   }
   
   
   
   /**
    * Finds the difference between two times in hours.
    * @param startHour
    * @param startMinute
    * @param endHour
    * @param endMinute
    * @return
    */
   public static double timeDifferenceHours(int startHour, 
   int startMinute, int endHour, int endMinute)
   {
      double endMinutes = endHour * MINUTES_PER_HOUR + endMinute;
      
      double startMinutes = startHour * MINUTES_PER_HOUR + startMinute;
   
      return ((endMinutes - startMinutes) / MINUTES_PER_HOUR);
   }

   
   
   /**
    * Returns true if a specified time is within one of a list of ranges.
    * @param startHour
    * @param startMinute
    * @param startSecond
    * @param finishHour
    * @param finishMinute
    * @param finishSecond
    * @param hour
    * @param minute
    * @param second
    * @param length
    * @return
    */
   public static boolean isOverlapped(ArrayList startHour, 
   ArrayList startMinute, ArrayList startSecond, 
   ArrayList finishHour, ArrayList finishMinute, 
   ArrayList finishSecond, int hour, int minute, 
   int second, int length)
   {

      boolean overlapped = false; 
   
      for (int i = 0; i < length; i ++)
      {
         if (isAfterReferenceTime
         (startHour.get(i), startMinute.get(i), 
         startSecond.get(i), hour, minute, second)
         
         && (!isAfterReferenceTime
         (finishHour.get(i), finishMinute.get(i), 
         finishSecond.get(i), hour, minute, second)))
         {
            overlapped = true;
            
         }
               
      }
      
     return overlapped;
     
   }
   
   
   
   /**
    * Tests if a year is a leap year.
    * @param year
    * @return
    */
   public static boolean isLeapYear(int year)
   {
      boolean leapYear = false;
      
      final int LEAP_DIVISOR_SHORT = 4;
      
      final int LEAP_DIVISOR_MIDDLE = 100;
      
      final int LEAP_DIVISOR_LONG = 400;
      
      
      if ((year % LEAP_DIVISOR_SHORT) == 0)
      {
         if ((year % LEAP_DIVISOR_MIDDLE) != 0)
         {
            leapYear = true;
         }
         
         if (((year % LEAP_DIVISOR_MIDDLE) == 0) 
         && ((year % LEAP_DIVISOR_LONG) == 0))
         {
            leapYear = true;
         }
         
      }
      
     
      return leapYear;

   }
   
   
   
   /**
    * Returns todays date.
    * @param includeTimeMask
    * @return
    */
   public static String returnTodaysDate(boolean includeTimeMask)
   {
      refreshCalendar(); now.getTime();
   
      
      String todaysDate = ""; String timeMask = "00:00:00";
      
      SimpleDateFormat date = new SimpleDateFormat("YYYY-MM-dd");
      
     
      if (includeTimeMask)
      {
         todaysDate = date.format(now.getTime()) + " " + timeMask;
      }
      
      else
      {
         todaysDate = date.format(now.getTime());
      }
      
      
      return todaysDate; 
   }
   
   
   
   /**
    * Returns a specific element of a date string.
    * @param date
    * @param component
    * @return
    */
   public static String returnSplitDate(String date, Elements component)
   {
      String element = null;
      
      
      String[] elementArray = date.split("-");
      
      
      if (component.equals(Elements.YEAR))
      {
         element = elementArray[0];
      }
      
      if (component.equals(Elements.MONTH))
      {
         element = elementArray[1];
      }
      
      if (component.equals(Elements.DAY))
      {
         element = elementArray[2];
      }

      
      return element;
      
   }
   

   
   /**
    * Returns the name of a month expressed as an integer.
    * ESCA-JAVA0076:
    * @param month
    * @return
    */
   public static String returnMonthName(int month)
   {
      String monthName = null;

      
      switch (month)
      {
         case 1: monthName = "January"; break;
         
         case 2: monthName = "February"; break;
         
         case 3: monthName = "March"; break;
         
         case 4: monthName = "April"; break;
         
         case 5: monthName = "May"; break;
           
         case 6: monthName = "June"; break;
         
         case 7: monthName = "July"; break;
         
         case 8: monthName = "August"; break;
         
         case 9: monthName = "September"; break;
         
         case 10: monthName = "October"; break;
         
         case 11: monthName = "November"; break;
         
         case 12: monthName = "December"; break;
      
         default: monthName = "Invalid Input"; break;
      }
      
      
      return monthName;
   }
   
   
   
   /**
    * Returns a list of dates.
    * @param year
    * @param heading
    * @return
    */
   public static String[] returnDateList(int year, String heading)
   {
   
      ArrayList list = new ArrayList();
     
      
      if (heading != null) {list.add(heading);}
      
      
      for (int i = 1; i <= MONTHS_IN_YEAR; i ++)
      {
         int bound = returndaysInMonth(i);
         
         
         if (isLeapYear(year) && (i == 2)) {bound ++;}
         
         
         for (int j = 1; j <= bound; j ++)
         {
            list.add(year + "-" + returnDigitMask(i, 2) + "-" + returnDigitMask(j, 2)); 
         }
        
      }
  
      
      String[] dates = new String[list.size()];
      
      list.toArray(dates);
      
      return dates;
   }
   
   
   
   /**
    * Returns the days of a specified month.
    * ESCA-JAVA0076:
    * @param month
    * @return
    */
   public static int returndaysInMonth(int month)
   {
      int days = -1; final int SHORT = 28; 
   
      final int MIDDLE = 30; final int LONG = 31;
  
      switch (month)
      {
         case 1: days = (LONG); break; case 2: days = (SHORT); break;
         
         case 3: days = (LONG); break; case 4: days = (MIDDLE); break;
         
         case 5: days = (LONG); break; case 6: days = (MIDDLE); break;
         
         case 7: days = (LONG); break; case 8: days = (LONG); break;
         
         case 9: days = (MIDDLE); break; case 10: days = (LONG); break;
         
         case 11: days = (MIDDLE); break; case 12: days = (LONG); break;  
      
         default: return days;         
      }
   
      return days;  
   }
   
   
   
   /**
    * Converts an integer to a mask.
    * ESCA-JAVA0076:
    * @param value
    * @param maxValueLength
    * @return
    */
   public static String returnDigitMask(int value, int maxValueLength)
   {     
      String digit = Integer.toString(value); String trailing = "";
      
      if (digit.length() == maxValueLength)
      {
         return digit;
      }
   
      else
      {
         for (int i = digit.length(); i < maxValueLength; i ++)
         {
            trailing += "0";
         }
     
         return (trailing + digit); 
      } 
   }
   
   
   
   /**
    * Returns the seconds elapsed in counter format (HH:MM:SS).
    * @param counter
    * @param millisecondCount
    * @return
    */
   public static String returnCounterTime(long counter, boolean millisecondCount)
   {
      String counterTime = ""; 
  
  
      setCounterHours((short)0); setCounterMinutes((short)0);
      
      setCounterSeconds((short)0); setCounterMilliseconds((short)0);
  
      
      final int DIGIT_LENGTH = 2; final double MILLIS_DIVISOR = 100;
      
   
      for (int i = 0; i < counter; i ++)
      {
         if (millisecondCount) {counterMilliseconds ++;} 
         
         else {counterSeconds ++;}
         
         
         if (counterMilliseconds == MILLISECONDS_PER_SECOND) 
         
         {setCounterMilliseconds((short)0); counterSeconds ++;}
         
         
         if (counterSeconds == SECONDS_PER_MINUTE) 
         
         {setCounterSeconds((short)0); counterMinutes ++;}
         
         if (counterMinutes == MINUTES_PER_HOUR) 
         
         {setCounterMinutes((short)0); counterHours ++;}
      }
      
      
      if (millisecondCount) 
      {
         counterTime = ":" + (int)Math.floor(getCounterMilliseconds() / MILLIS_DIVISOR);
      }
      
      
      counterTime = 
      (
         returnDigitMask(getCounterHours(), DIGIT_LENGTH) + ":" +
             
         returnDigitMask(getCounterMinutes(), DIGIT_LENGTH) + ":" +
     
         returnDigitMask(getCounterSeconds(), DIGIT_LENGTH) + counterTime
      );
      
      
      return counterTime;
      
   }
   
   
   
   /**
    * Returns the formatted time (24 hour or standard)
    * @param twentyFourHour
    * @return
    */
   public static String returnFormattedTime(boolean twentyFourHour)
   {
      refreshCalendar(); String time = ""; 
      
      
      DateFormat full = new SimpleDateFormat("HH:mm:ss");
      
      DateFormat standard = new SimpleDateFormat("h:mm:ss");
      
      
      if (twentyFourHour) {time = full.format(now.getTime());}
      
      else {time = standard.format(now.getTime());}
  
        
      return time;   
   }
   
   
   
   /**
    * Returns the day at the start of the given year.
    * ESCA-JAVA0076:
    * @param year
    * @return
    */
   public static int returnStartDayAsInt(int year)
   {
      Calendar cal = new GregorianCalendar(year, Calendar.JANUARY, 1);
  
      return (cal.get(Calendar.DAY_OF_WEEK));
   }
   
   
   
   /**
    * Returns the day at the start of the given year.
    * ESCA-JAVA0076:
    * @param year
    * @return
    */
   public static int returnEndDayAsInt(int year)
   {
      Calendar cal = new GregorianCalendar(year, Calendar.DECEMBER, 31);
  
      return (cal.get(Calendar.DAY_OF_WEEK));
   }
   
   
   
   /**
    * Returns the specific day of week as an integer.
    * 1 = Sunday, 2 = Monday, 3 = Tuesday ...
    * ESCA-JAVA0076:
    * @param year
    * @param month
    * @param day
    * @return
    */
   public static int returnDayOfWeekAsInt(int year, int month, int day)
   {
      Calendar cal = null; 

      
      switch (month)
      {
         case 1: cal = new GregorianCalendar(year, Calendar.JANUARY, day); break;
         
         case 2: cal = new GregorianCalendar(year, Calendar.FEBRUARY, day); break;
         
         case 3: cal = new GregorianCalendar(year, Calendar.MARCH, day); break;
         
         case 4: cal = new GregorianCalendar(year, Calendar.APRIL, day); break;
         
         case 5: cal = new GregorianCalendar(year, Calendar.MAY, day); break;  
        
         case 6: cal = new GregorianCalendar(year, Calendar.JUNE, day); break;
         
         case 7: cal = new GregorianCalendar(year, Calendar.JULY, day); break;
         
         case 8: cal = new GregorianCalendar(year, Calendar.AUGUST, day); break;
         
         case 9: cal = new GregorianCalendar(year, Calendar.SEPTEMBER, day); break;
         
         case 10: cal = new GregorianCalendar(year, Calendar.OCTOBER, day); break;
         
         case 11: cal = new GregorianCalendar(year, Calendar.NOVEMBER, day); break;
         
         case 12: cal = new GregorianCalendar(year, Calendar.DECEMBER, day); break;
         
         
         default: return (-1);
      
      }
      
  
      return (cal.get(Calendar.DAY_OF_WEEK));
   }
   
  
   
   /**
    * Returns a list of years between the given 
    * parameter and the current year.
    * @param year
    * @return
    */
   public static String[] returnYearChoices(int year)
   {
     
      int difference = Math.abs(returnYear() - year);
      
      String[] choices = new String[difference +1];
 
  
      if (year < returnYear())
      {
         for (int i = 0; i <= difference; i ++)
         {
            choices[i] = Integer.toString(year + i);
         }
      }
      
      if (year > returnYear())
      {
         for (int i = 0; i <= difference; i ++)
         {
            choices[i] = Integer.toString(returnYear() + i); 
         }
      }
      
      return choices;
      
   }
   

   
   /**
    * Returns a list for seconds.
    * @return
    */
   public static String[] returnSecondChoices()
   {
      
     
      String[] secondList = new String[SECONDS_PER_MINUTE];
   
      for (int i = 0; i < SECONDS_PER_MINUTE; i ++)  
      {
         secondList[i] = Integer.toString(i);
      
      }
      
      return secondList;
   }
   
   
   
   /**
    * Returns a list for minutes.
    * @return
    */
   public static String[] returnMinuteChoices()
   {
      
     
      String[] minuteList = new String[MINUTES_PER_HOUR];
   
      for (int i = 0; i < MINUTES_PER_HOUR; i ++)  
      {
         minuteList[i] = Integer.toString(i);
      
      }
      
      return minuteList;
   }
   
   
   
   /**
    * Returns a list for hours.
    * @return
    */
   public static String[] returnHourChoices()
   {
      String[] hourList = new String[HOURS_PER_DAY];
   
      for (int i = 0; i < HOURS_PER_DAY; i ++)  
      {
         hourList[i] = Integer.toString(i);
      
      }
      
      return hourList;
   }
   
   
   
   /**
    * Returns the current year.
    * @return
    */
   public static int returnYear()
   {
      refreshCalendar(); 

      return (now.get(Calendar.YEAR));
   }
   
   
   
   /**
    * Returns the current year.
    * @return
    */
   public static int returnMonth()
   {
      refreshCalendar(); 
 
      return (now.get(Calendar.MONTH) + 1);
   }
    
   
   
   /**
    * Returns the current year.
    * @return
    */
   public static int returnDay()
   { 
      refreshCalendar(); 
   
      return (now.get(Calendar.DATE));
   }
   
   
   
   /**
    * Returns the hour in double digits.
    * @return
    */
   public static String returnHourDouble()
   {
      return returnDigitMask(returnHour(), 2);
   }
   
   
   
   /**
    * Returns the minute in double digits.
    * @return
    */
   public static String returnMinuteDouble()
   {
      return returnDigitMask(returnMinute(), 2);
   }
   
   
   
   /**
    * Returns the second in double digits.
    * @return
    */
   public static String returnSecondDouble()
   {
      return returnDigitMask(returnSecond(), 2);
   }
   
   
 
   /**
    * Returns the hour.
    * @return
    */
   public static int returnHour()
   {
      refreshCalendar(); 
   
      DateFormat hours = new SimpleDateFormat("HH");
      
      return (Integer.parseInt(hours.format(now.getTime())));
   }

   
   
   /**
    * Returns the minutes.
    * @return
    */
   public static int returnMinute()
   {
      refreshCalendar(); 
   
      DateFormat minutes = new SimpleDateFormat("mm");
      
      return (Integer.parseInt(minutes.format(now.getTime())));
   }
   
   
   
   /**
    * Returns the seconds.
    * @return
    */
   public static int returnSecond()
   {
      refreshCalendar();  
   
      DateFormat seconds = new SimpleDateFormat("ss");
      
      return (Integer.parseInt(seconds.format(now.getTime())));
   }
   
   
   
   /**
    * Returns the current stage of the day as AM or PM.
    * @return
    */
   public static String returnAmOrPm()
   {
      refreshCalendar(); 
     
      DateFormat ampm = new SimpleDateFormat("a");
        
      return (ampm.format(now.getTime()));   
   }
   
   
   
   /**
    * Returns the days in a year.
    * @param year
    * @return
    */
   public static int returnDays(int year)
   {
      if (DateAndTime.isLeapYear(year))
      {
         return getDaysLeapYear();
      }
      
      else
      {
         return DateAndTime.getDaysNormalYear();
      }   
   }
   
   
   
   /**
    * Refreshes the calendar.
    */
   public static void refreshCalendar()
   {
      now = Calendar.getInstance();
   }
   
  
   
   /**
    * Sets the counter hours.
    * @param value
    */
   public static void setCounterHours(short value) {counterHours = value;}
   
   
   
   /**
    * Sets the counter minutes.
    * @param value
    */
   public static void setCounterMinutes(short value) {counterMinutes = value;}
   
   
   
   /**
    * Sets the counter seconds.
    * @param value
    */
   public static void setCounterSeconds(short value) {counterSeconds = value;}
   
   
   
   /**
    * Sets the counter milliseconds.
    * @param value
    */
   public static void setCounterMilliseconds(short value) {counterMilliseconds = value;}
   
   
   
   /**
    * Returns the counter hours.
    * @return
    */
   public static short getCounterHours() {return counterHours;}
   
   
   
   /**
    * Returns the counter minutes.
    * @return
    */
   public static short getCounterMinutes() {return counterMinutes;}
   
   
   
   /**
    * Returns the counter seconds.
    * @return
    */
   public static short getCounterSeconds() {return counterSeconds;}
   
   
   
   /**
    * Returns the counter milliseconds.
    * @return
    */
   public static short getCounterMilliseconds() {return counterMilliseconds;}
   
   
   
   /**
    * Returns the days in a week.
    * @return
    */
   public static int getDaysInWeek() {return DAYS_IN_WEEK;}

   
   /**
    * Returns the days in a year.
    * @return
    */
   public static int getDaysNormalYear() {return DAYS_IN_YEAR;}
   
   
   /**
    * Returns the days in a year.
    * @return
    */
   public static int getDaysLeapYear() {return (DAYS_IN_YEAR + 1);}
   
   
   /**
    * Returns the weeks in a year.
    * @return
    */
   public static int getWeeksInYear() {return WEEKS_IN_YEAR;}
   
   
   /**
    * Returns the fort-nights in a year.
    * @return
    */
   public static int getFortnightsInYear() {return FORTNIGHTS_IN_YEAR;}
   
   
   /**
    * Returns the months in a year.
    * @return
    */
   public static int getMonthsInYear() {return MONTHS_IN_YEAR;}
   
   
   /**
    * Returns the seconds per minute.
    * @return
    */
   public static int getSecondsPerMinute() {return SECONDS_PER_MINUTE;}
   
   
   /**
    * Returns the seconds per minute.
    * @return
    */
   public static int getHoursPerWeek() {return HOURS_PER_DAY * DAYS_IN_WEEK;}
   
   
   //***************************************** END PUBLIC METHODS ******************************************//
   
   
   
   private static short counterHours, counterMinutes, counterSeconds, counterMilliseconds;
   
   
   //********************************************** END CLASS **********************************************//
 
}


/*
   COPYRIGHT (C) 2010 - 2013 by Alexander Wait. All Rights Reserved.

   This class returns the domain attributes.

   @site http://www.javaika.com
   @author Alexander Wait
   @version 2012-07-06
*/



public class Domain 
{
  
   private static final String DOMAIN = "javaika.com";

   private static final boolean RUN_LOCAL = false; 
   
   private static final boolean prefix = true;
   
   private static final String PORT = "80";
   
   
   private Domain() {}
   
   
   //**************************************** START PUBLIC METHODS *****************************************//
   
   
   /**
    * Returns the domain name.
    * @return
    */
   public static final String getDomain()
   {
      if (prefix)
      {
         return ("www." + DOMAIN);
      }
      
      else
      {
         return (DOMAIN);
      }
   }
   
   
   
   /**
    * Returns the port number.
    * @return
    */
   public static final String getPort()
   {
      if (RUN_LOCAL)
      {
         return (":" + PORT);
         
      }
      
      else {return ("");} 
   }
   
   
   //***************************************** END PUBLIC METHODS ******************************************//
   
   
   //********************************************** END CLASS **********************************************//

}


/*
   COPYRIGHT (C) 2010 - 2013 by Alexander Wait. All Rights Reserved.

   This class displays message dialogs.

   @site http://www.javaika.com
   @author Alexander Wait
   @version 2011-07-18
*/



import javax.swing.*;



public class Message
{

   private Message(){}
   
   
   //**************************************** START PUBLIC METHODS *****************************************//


   /**
    * Displays a message dialog.
    * @param text
    * @param heading
    * @param type 
    */
   public static void showMessage(String text, String heading, String type)
   {
      new JOptionPane(); Object[] options = {}; 

      if (type.equals("error"))
      {
         JOptionPane.showOptionDialog(null, text, heading,  
         JOptionPane.YES_OPTION, JOptionPane.ERROR_MESSAGE, null, options, null);
      }

      if (type.equals("information"))
      {
         JOptionPane.showOptionDialog(null, text, heading, 
         JOptionPane.YES_OPTION, JOptionPane.INFORMATION_MESSAGE, null, options, null);
      }

      if (type.equals("warning"))
      {
         JOptionPane.showOptionDialog(null, text, heading, 
         JOptionPane.YES_OPTION, JOptionPane.WARNING_MESSAGE, null, options, null);
      }

      if (type.equals("question"))
      {
         JOptionPane.showOptionDialog(null, text, heading, 
         JOptionPane.YES_OPTION, JOptionPane.QUESTION_MESSAGE, null, options, null);
      }
   }
   
   
   //***************************************** END PUBLIC METHODS ******************************************//
   
   
   //********************************************** END CLASS **********************************************//
   
}


/*
   COPYRIGHT (C) 2010 - 2013 by Alexander Wait. All Rights Reserved.

   This class provides handy tools.

   @site http://www.javaika.com
   @author Alexander Wait
   @version 2012-02-01
*/



public class Tools 
{

   private static final int EXCEPTION_LINE_BEAK = 2;
   
   
   private Tools() {}
   
   
   //**************************************** START PUBLIC METHODS *****************************************//


   /**
    * This method returns the line number and path where it's called.
    * The syntax new Exception().getStackTrace()[0].getLineNumber() 
    * will only give the current line number of the source file.
    * @return
    */
   public static String thisPathAndLine()
   {
   
      String lineAndPath = ""; String stackTrace = "";
 
      stackTrace = new Exception().getStackTrace()[1].toString();
      
      
      for (int i = stackTrace.length()-1; i >= 0; i --)
      {
         if (stackTrace.charAt(i) == ')') {continue;} 
        
         else if (stackTrace.charAt(i) == '(') {break;}
        
         else {lineAndPath = (stackTrace.charAt(i) + lineAndPath);}
      }
         
      return lineAndPath + returnNewline(EXCEPTION_LINE_BEAK);
      
   }
   
   
   
   /**
    * Delays execution.
    * @param length
    */
   public static void delay(long length) 
   {
      for (long i = 0; i < length; i ++) {}
   }
   
  
 
   /**
    * This method returns a space.
    * @param length
    * @return
    */
   public static String returnSpace(int length)
   {
      String space = "";
      
      
      for (int i = 0; i < length; i ++)
      {
         space += " ";
      }
      
      return space;
   }
   
   
   
   /**
    * Assigns newlines to a string.
    * @param lines
    * @return
    */
   public static String returnNewline(int lines)
   {
      String newline = "";
      
      
      for (int i = 0; i < lines; i++)
      {
         newline += "\n";
      }
      
      
      return newline;
   
   }
   
   
   
   /**
    * Returns the users desktop path.
    * @return
    */
   public static String returnDesktopPath()
   {
      return (System.getProperty("user.home") + "/Desktop").replace("\\", "/") + "/"; 
   }
   

   //***************************************** END PUBLIC METHODS ******************************************//

   
   //********************************************** END CLASS **********************************************//
   
}