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

   This class builds the metronome GUI.

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



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.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;



public class DigitalMetronomeGui extends JApplet
{
   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 = 420;
   
   private static final int FRAME_SIZE_Y = 555;


   //************************************** START INITIALISATION CODE **************************************//

   
   /**
    * Browser constructor.
    * ESCA-JAVA0166:
    */
   public void init()
   {
      if (!isApplication) 
      { 
         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 DigitalMetronomeGui()
   {
      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("Metronome Program"); 
         
         frame.add(contentPane);
         
         
         setVisibility(); 
      }
 
   }
   
   
   
   /**
    * GUI initializer.
    * ESCA-JAVA0076:
    */
   private void initialiser()
   {
      metronome = new DigitalMetronome(); 
      
      
      
      // Initialize content pane and layout.
      
      contentPane = getContentPane(); 
      
      contentPane.setLayout(new GridBagLayout());
      
      
      
      // Initialize text field GUI components.
      
      beatDisplay = new JTextField(); beatDisplay.setEnabled(false);
      
      beatDisplay.setFont(new Font("Times New Roman", Font.PLAIN, 105));
      
      beatDisplay.setBorder(BorderFactory.createEtchedBorder());
      
      beatDisplay.setHorizontalAlignment(JTextField.CENTER);
      
      beatDisplay.setText("0");
      
      
      cycleDisplay = new JTextField(); cycleDisplay.setEnabled(false);
      
      cycleDisplay.setFont(new Font("Times New Roman", Font.PLAIN, 105));
      
      cycleDisplay.setBorder(BorderFactory.createEtchedBorder());
      
      cycleDisplay.setHorizontalAlignment(JTextField.CENTER);
      
      cycleDisplay.setText("0");
      
      
      speedDisplay = new JTextField(); speedDisplay.setEnabled(false);
      
      speedDisplay.setFont(new Font("Dialog", Font.BOLD, 12));

      speedDisplay.setBorder(BorderFactory.createEtchedBorder());
      
      speedDisplay.setHorizontalAlignment(JTextField.CENTER);
      
      speedDisplay.setText("Andante");
      
      
      beatsMinuteDisplay = new JTextField(); beatsMinuteDisplay.setEnabled(false); 
      
      beatsMinuteDisplay.setFont(new Font("Dialog", Font.BOLD, 12));
      
      beatsMinuteDisplay.setBorder(BorderFactory.createEtchedBorder());
      
      beatsMinuteDisplay.setHorizontalAlignment(JTextField.CENTER);
      
      beatsMinuteDisplay.setText("95");
      
      
      beatsCycleDisplay = new JTextField(); beatsCycleDisplay.setEnabled(false);
      
      beatsCycleDisplay.setFont(new Font("Dialog", Font.BOLD, 12));

      beatsCycleDisplay.setBorder(BorderFactory.createEtchedBorder());
      
      beatsCycleDisplay.setHorizontalAlignment(JTextField.CENTER);
      
      beatsCycleDisplay.setText("50");
      
      
      
      // Initialize JPanel GUI components.
  
      buttonPanel = new JPanel(); 
      
      buttonPanel.setLayout (new FlowLayout(FlowLayout.LEADING));
      
      buttonPanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
      
      
      
      // Initialize slider GUI components.
      
      beatsMinuteSlider = new JSlider();
      
      beatsMinuteSlider.setMajorTickSpacing(5); beatsMinuteSlider.setPaintTicks(true);
      
      beatsMinuteSlider.setBorder(BorderFactory.createTitledBorder("Beats Per Minute"));
      
      beatsMinuteSlider.addChangeListener(new BeatsMinuteChangeListener());
      
      
      beatsCycleSlider = new JSlider();

      beatsCycleSlider.setMajorTickSpacing(5); beatsCycleSlider.setPaintTicks(true);
      
      beatsCycleSlider.setBorder(BorderFactory.createTitledBorder("Beats Per Cycle"));
      
      beatsCycleSlider.addChangeListener(new BeatsCycleChangeListener());
      
      
      
      // Initialize button GUI components.
      
      start = new JButton(new ImageIcon(this.getClass().getResource
      (
         "files/images/MetronomeStartNormal.png"))
      );
      
      
      start.setRolloverIcon(new ImageIcon(this.getClass().getResource
      (
         "files/images/MetronomeStartRollover.png"))
      );

      
      start.setPressedIcon(new ImageIcon(this.getClass().getResource
      (
         "files/images/MetronomeStartPressed.png"))
      );
      
      
      start.setBorder(BorderFactory.createEmptyBorder(0,0,0,0));

      start.addActionListener(new StartButtonListener());
      

      stop = new JButton(new ImageIcon(this.getClass().getResource
      (
         "files/images/MetronomeStopNormal.png"))
      );


      stop.setRolloverIcon(new ImageIcon(this.getClass().getResource
      (
         "files/images/MetronomeStopRollover.png"))
      );


      stop.setPressedIcon(new ImageIcon(this.getClass().getResource
      (
         "files/images/MetronomeStopPressed.png"))
      );


      stop.setBorder(BorderFactory.createEmptyBorder(0,0,0,0));

      stop.addActionListener(new StopButtonListener());
      
      
      
      // Add GUI components to JPanels.
      
      buttonPanel.add(start); buttonPanel.add(stop);
      
      

      // Method calls for GUI initialization.

      gridBagConstraints(); setColors();
   }
   
   
   
   /**
    * Sets the background color.
    */
   private void setColors()
   {
      contentPane.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      );
      
      buttonPanel.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      );
      
      beatDisplay.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      );
      
      cycleDisplay.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      );
      
      speedDisplay.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      );
      
      beatsMinuteSlider.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      );
      
      beatsCycleSlider.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      );
      
      beatsMinuteDisplay.setBackground
      (
         new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
      );
      
      beatsCycleDisplay.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 = 130; 
      
      constraints.ipady = 0;

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

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

      constraints.gridwidth = 2;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 0; 
      
      constraints.gridy = 1;
      
      
      contentPane.add(beatsMinuteDisplay, constraints);
      

      
      // Grid bag constraints 4.
      
      constraints.insets = new Insets(0,0,0,0);
      
      
      constraints.ipadx = 0; 
      
      constraints.ipady = 10;

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

      constraints.gridwidth = 4;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 0; 
      
      constraints.gridy = 2;
      
      
      contentPane.add(speedDisplay, constraints);
      

      
      // Grid bag constraints 6.
      
      constraints.insets = new Insets(0,0,20,0);
      
      
      constraints.ipadx = 0; 
      
      constraints.ipady = 0;

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

      constraints.gridwidth = 4;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 0; 
      
      constraints.gridx = 0; 
      
      constraints.gridy = 4;
      
      
      contentPane.add(beatsCycleSlider, constraints);
      
     
      
      // Grid bag constraints 8.
      
      constraints.anchor = GridBagConstraints.PAGE_END;
      
      constraints.insets = new Insets(0,10,10,0);
      
      
      constraints.ipadx = 0; 
      
      constraints.ipady = 0;

      constraints.gridwidth = 4;
      
      constraints.weightx = 0; 
      
      constraints.weighty = 1; 
      
      constraints.gridx = 0; 
      
      constraints.gridy = 5;
      
      
      contentPane.add(buttonPanel, constraints);   
   }
   
   
   //*************************************** END INITIALISATION CODE ***************************************//
   
   
   //************************************* START INTERFACE EVENT CODE **************************************//
   
   
   private class BeatsMinuteChangeListener implements ChangeListener 
   {
  
     /**
       * This is the slider listener.
       */
      public void stateChanged(ChangeEvent changeEvent) 
      {
        
         Object source = changeEvent.getSource();

         if (source instanceof JSlider) 
         {
            JSlider theJSlider = (JSlider) source;
      
            if (theJSlider.getValueIsAdjusting()) 
            {
               metronome.setBeatsPerMinute(theJSlider.getValue());
               
               speedDisplay.setText(metronome.getSpeedMode());
               
               beatsMinuteDisplay.setText(Integer.toString(metronome.getBeatsPerMinute()));
            }
            
            if (!theJSlider.getValueIsAdjusting()) 
            {
               stopMetronomeTimer(); startMetronomeTimer(); 
            }
         }     
      }
   }
   
   
   
   private class BeatsCycleChangeListener implements ChangeListener 
   {
  
     /**
       * This is the slider listener.
       */
      public void stateChanged(ChangeEvent changeEvent) 
      {
        
         Object source = changeEvent.getSource();

         if (source instanceof JSlider) 
         {
            JSlider theJSlider = (JSlider) source;
      
            if (theJSlider.getValueIsAdjusting()) 
            {
               metronome.setBeatsPerCycle(theJSlider.getValue());
               
               beatsCycleDisplay.setText(Integer.toString(metronome.getBeatsPerCycle()));
            }
         }     
      }
   }
   
   
   
   private class StartButtonListener
   implements ActionListener
   { 
      public void actionPerformed(ActionEvent event)
      {
         startMetronomeTimer();
      }
   }
   
   
   
   private class StopButtonListener
   implements ActionListener
   { 
      public void actionPerformed(ActionEvent event)
      {
         stopMetronomeTimer();
      }
   }
   

   //************************************** END INTERFACE EVENT CODE ***************************************//
   
   
   //**************************************** START PUBLIC METHODS *****************************************//
   
   
   /**
    * Updates the speed display.
    * @param value
    */
   public static void updateBeatDisplay(String value)
   {
      beatDisplay.setText(value);
   }
   
   
   
   /**
    * Updates the cycle display.
    * @param value
    */
   public static void updateCycleDisplay(String value)
   {
      cycleDisplay.setText(value);
   }
   
   
   
   /**
    * 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 ****************************************//
   
   
   /**
    * Starts the metronome timer.
    */
   private void startMetronomeTimer()
   { 
      if (!DigitalMetronome.isTimerRunning())
      {
         metronome.setMetronomeTimer
         (
            metronome.calculateTimerSpeed()
         ); 
      }   
   }
   
   
   
   /**
    * Stops the metronome timer.
    */
   private void stopMetronomeTimer()
   {
      if (DigitalMetronome.isTimerRunning())
      {
         metronome.stopTimer();
      }   
   }
   
   
   
   /**
    * 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 DigitalMetronomeGui();
   }
   
   
   //*********************************************** END MAIN **********************************************//

   
   /**
    * ESCA-JAVA0007:
    */
   public JFrame frame;
   
   private JPanel buttonPanel;
   private JButton start, stop;
   private Container contentPane;
   private boolean zoomWarningShown;
   private DigitalMetronome metronome;
   private GridBagConstraints constraints;
   private static JTextField beatDisplay, cycleDisplay;
   private JSlider beatsMinuteSlider, beatsCycleSlider;
   private JTextField speedDisplay, beatsMinuteDisplay, beatsCycleDisplay;
   
   
   //********************************************** END CLASS **********************************************//
  
}


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

   This class creates a basic metronome.

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



import java.util.Timer;
import java.util.TimerTask;



public class DigitalMetronome
{
   private static final int MAX_BEATS_PER_MINUTE = 190;
   
   private static final int DEFAULT_BEATS_FACTOR = 50;
   
   private static final int DEFAULT_BEATS_PER_CYCLE = 50;
   
   
   //************************************** START INITIALISATION CODE **************************************//
   

   /**
    * Application Constructor.
    */
   public DigitalMetronome()
   {
      player = new AudioPlayer();
      
      
      setBeatsPerCycle(DEFAULT_BEATS_PER_CYCLE);
      
      setBeatsPerMinute(DEFAULT_BEATS_FACTOR);
   }
   
   
   
   //*************************************** END INITIALISATION CODE ***************************************//
   
   
   //**************************************** START PUBLIC METHODS *****************************************//
   

   /**
    * Returns the speed mode.
    * ESCA-JAVA0076:
    * @return
    */
   public String getSpeedMode()
   {
      String mode = null;
      
      if ((getBeatsPerMinute() >= 1) && (getBeatsPerMinute() <= 20))
      {
         mode = "Larghissimo";
      }
      
      else if ((getBeatsPerMinute() >= 21) && (getBeatsPerMinute() <= 40))
      {
         mode = "Largamente";
      }
      
      else if ((getBeatsPerMinute() >= 41) && (getBeatsPerMinute() <= 60))
      {
         mode = "Largo";
      }
      
      else if ((getBeatsPerMinute() >= 61) && (getBeatsPerMinute() <= 66))
      {
         mode = "Larghetto";
      }
      
      else if ((getBeatsPerMinute() >= 67) && (getBeatsPerMinute() <= 76))
      {
         mode = "Adagio";
      }
      
      else if ((getBeatsPerMinute() >= 77) && (getBeatsPerMinute() <= 80))
      {
         mode = "Adagietto";
      }
      
      else if ((getBeatsPerMinute() >= 81) && (getBeatsPerMinute() <= 108))
      {
         mode = "Andante";
      }
      
      else if ((getBeatsPerMinute() >= 109) && (getBeatsPerMinute() <= 120))
      {
         mode = "Moderato";
      }
      
      else if ((getBeatsPerMinute() >= 121) && (getBeatsPerMinute() <= 168))
      {
         mode = "Allegro";
      } 
      
      else if ((getBeatsPerMinute() >= 169) && (getBeatsPerMinute() <= 190))
      {
         mode = "Presto";
      }

      return mode;
   
   }
   
   
   
   /**
    * Sets the allowed beats per minute.
    * @param value
    */
   public void setBeatsPerMinute(int value) 
   {
      double corrected = (value / 100.00) * MAX_BEATS_PER_MINUTE;
      
      beatsPerMinute = (int)corrected;
   }
   
   
   
   /**
    * Cancels the timer.
    */
   public void stopTimer()
   {
      cycle = 0; beat = 0;
   
      timer.cancel(); timerRunning = false;
      
      
      DigitalMetronomeGui.updateBeatDisplay(Integer.toString(beat));
      
      DigitalMetronomeGui.updateCycleDisplay(Integer.toString(cycle));
   }
   
   
   
   /**
    * Initializes the metronome timer.
    * @param speed
    */
   public void setMetronomeTimer(int speed)
   {    
      timer = new Timer(); 
      
      timerRunning = true;
      
      player.loadFile("files/audio/MetronomeTicker.wav");
      
      timer.schedule(new RunPlayer(), 500, speed);
      
   }
   
   
   
   /**
    * Calculates the timer speed.
    * @return
    */
   public int calculateTimerSpeed()
   {   
      double ratio = (double)DateAndTime.getSecondsPerMinute() 
      
      / (double)getBeatsPerMinute();
    
      
      return (int)(ratio * 1000);
   }
   
   
   
   /**
    * Tests if timer already running.
    * @return
    */
   public static boolean isTimerRunning()
   {
      return timerRunning;
   }
   
   
   
   /**
    * Sets the beats per cycle.
    * @param beats
    */
   public void setBeatsPerCycle(int beats) {beatsPerCycle = beats;}
   
   
   
   /**
    * Get the beats per cycle.
    * @return
    */
   public int getBeatsPerCycle() {return beatsPerCycle;}
   
   
   
   /**
    * Get the beats per minute.
    * @return
    */
   public int getBeatsPerMinute() {return beatsPerMinute;}
   
   
   
   /**
    * Get the beat.
    * @return
    */
   public int getBeat() {return beat;}
   
   
   
   /**
    * Get the cycle.
    * @return
    */
   public int getCycle() {return cycle;}
   
   
   
   //***************************************** END PUBLIC METHODS ******************************************//


   //**************************************** START PRIVATE METHODS ****************************************//
   
   
   private class RunPlayer extends TimerTask
   {

      /**
       * Runs the metronome player.
       * ESCA-JAVA0266:
       * ESCA-JAVA0166:
       */
      public void run()
      {
         try {player.reload();}
         
         
         catch (Exception e)
         {System.out.println(Tools.thisPathAndLine() + e);}
         
        
         if (getBeat() > getBeatsPerCycle()) {cycle ++; beat = 1;}
         
         
         DigitalMetronomeGui.updateBeatDisplay(Integer.toString(beat));
         
         DigitalMetronomeGui.updateCycleDisplay(Integer.toString(cycle));
         
         
         player.play(); 
         
         beat ++;
      }
   }
   
   
   //***************************************** END PRIVATE METHODS *****************************************//
   
   
   private Timer timer;
   private AudioPlayer player;
   private static boolean timerRunning;
   private int beat, cycle, beatsPerCycle, beatsPerMinute;
   
   
   //********************************************** END CLASS **********************************************//
   
}


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

   This class reads and plays audio files.

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



import java.io.IOException;
import java.net.URL;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.UnsupportedAudioFileException;



public class AudioPlayer 
{

   private static final int BUFFER_SIZE = 128000;
    
    
    
   /**
    * ESCA-JAVA0057:
    */
   public AudioPlayer() {}
   
   
   //**************************************** START PUBLIC METHODS *****************************************//
    
    
   /**
    * Loads the audio file.
    * ESCA-JAVA0166:
    * ESCA-JAVA0266:
    * @param filename
    */
   public void loadFile(String filename)
   {   
      try 
      {  
         defaultSound = getClass().getResource(filename); 
      
         info = new DataLine.Info(SourceDataLine.class, audioFormat);

         sourceLine = (SourceDataLine) AudioSystem.getLine(info); 
      } 
        
      catch (Exception e) 
      {System.out.println(Tools.thisPathAndLine() + e + "\n");}
      
   }
   
   
   
   /**
    * Reloads the sound file.
    * @throws LineUnavailableException
    * @throws UnsupportedAudioFileException
    * @throws IOException
    */
   public void reload() throws LineUnavailableException, UnsupportedAudioFileException, IOException
   {
      audioStream = AudioSystem.getAudioInputStream(defaultSound);
       
      audioFormat = audioStream.getFormat();
        
      sourceLine.open(audioFormat);
   
      sourceLine.start();   
   }
   
  
   
   /**
    * Plays the audio file.
    * ESCA-JAVA0166:
    * ESCA-JAVA0266:
    */
   public void play() {readBytes();}
   
   
   //***************************************** END PUBLIC METHODS ******************************************//
   
   
   //**************************************** START PRIVATE METHODS ****************************************//
   
   
   /**
    * Reads the bytes from the audio file.
    * ESCA-JAVA0166:
    * ESCA-JAVA0266:
    */
   private void readBytes()
   {
      int nBytesRead = 0;
       
      byte[] abData = new byte[BUFFER_SIZE];
         
        
      try 
      {
         while (nBytesRead != -1) 
         {
            nBytesRead = audioStream.read(abData, 0, abData.length);
            
            
            if (nBytesRead >= 0) 
            {
               sourceLine.write(abData, 0, nBytesRead);
            } 
         }
         
         if (nBytesRead == -1) {sourceLine.drain(); sourceLine.close();}      
      }
    
      catch (Exception e) 
      {System.out.println(Tools.thisPathAndLine() + e + "\n");} 
   
   }
   
   
   //***************************************** END PRIVATE METHODS *****************************************//
    
   
   private URL defaultSound;
   private DataLine.Info info;
   private AudioFormat audioFormat;
   private SourceDataLine sourceLine;
   private AudioInputStream audioStream;
   
   
   //********************************************** 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 **********************************************//
   
}