/*
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 **********************************************//
}