/*
COPYRIGHT (C) 2010 - 2013 by Alexander Wait. All Rights Reserved.
This class builds the timer clock 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.*;
import java.util.Timer;
import java.util.TimerTask;
import javax.swing.*;
public class TimerClockGui extends JApplet implements ComponentListener
{
private static final String copyright = "Copyright (c) 2012 by Alexander Wait - All Rights Reserved";
private static final long serialVersionUID = 1L;
static boolean isApplication = false;
static boolean isVisible = false;
private static final int FRAME_SIZE_X = 485;
private static final int FRAME_SIZE_Y = 555;
private static final int REFRESH_RATE = 100;
private static final int ALARM_RATE = 1000;
//************************************** 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 TimerClockGui()
{
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("Timer Clock Program");
frame.add(contentPane);
setVisibility();
}
}
/**
* GUI initializer.
* ESCA-JAVA0076:
*/
private void initialiser()
{
player = new AudioPlayer();
// Initialize content pane and layout.
contentPane = getContentPane();
contentPane.setLayout(new GridBagLayout());
// Initialize text area GUI components.
recordDisplay = new JTextArea();
recordDisplay.setEditable(false);
// Initialize JLabel GUI components.
controlLabel = new JLabel("CONTROLS");
controlLabel.setHorizontalAlignment(SwingConstants.LEFT);
recordLabel = new JLabel("RECORDS");
recordLabel.setHorizontalAlignment(SwingConstants.LEFT);
// Initialize scroll pane GUI components.
scrollPane = new JScrollPane(recordDisplay,
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
scrollPane.setPreferredSize(new Dimension(390,100));
// Initialize combo box GUI components.
alarmHour = new JComboBox(DateAndTime.returnHourChoices());
alarmHour.insertItemAt("OFF", 0); alarmHour.setSelectedIndex(0);
alarmHour.setMaximumRowCount(2);
alarmMinute = new JComboBox(DateAndTime.returnMinuteChoices());
alarmMinute.insertItemAt("OFF", 0); alarmMinute.setSelectedIndex(0);
alarmMinute.setMaximumRowCount(2);
alarmSecond = new JComboBox(DateAndTime.returnMinuteChoices());
alarmSecond.insertItemAt("OFF", 0); alarmSecond.setSelectedIndex(0);
alarmSecond.setMaximumRowCount(2);
// Initialize JLabel GUI components.
counterLabel = new JLabel();
counterLabel.setForeground(initialiseCounterColor());
counterLabel.setHorizontalAlignment(SwingConstants.CENTER);
counterLabel.setFont(new Font("Times New Roman", Font.PLAIN, 70));
// Initialize button GUI components.
startCounter = new JButton(new ImageIcon(this.getClass().getResource
(
"files/images/TimerClockStartNormal.png"))
);
startCounter.setRolloverIcon(new ImageIcon(this.getClass().getResource
(
"files/images/TimerClockStartRollover.png"))
);
startCounter.setPressedIcon(new ImageIcon(this.getClass().getResource
(
"files/images/TimerClockStartPressed.png"))
);
startCounter.setBorder(BorderFactory.createEmptyBorder(0,0,0,0));
startCounter.addActionListener(new StartCounterListener());
stopCounter = new JButton(new ImageIcon(this.getClass().getResource
(
"files/images/TimerClockStopNormal.png"))
);
stopCounter.setRolloverIcon(new ImageIcon(this.getClass().getResource
(
"files/images/TimerClockStopRollover.png"))
);
stopCounter.setPressedIcon(new ImageIcon(this.getClass().getResource
(
"files/images/TimerClockStopPressed.png"))
);
stopCounter.setBorder(BorderFactory.createEmptyBorder(0,0,0,0));
stopCounter.addActionListener(new StopCounterListener());
refreshCounter = new JButton(new ImageIcon(this.getClass().getResource
(
"files/images/TimerClockRefreshNormal.png"))
);
refreshCounter.setRolloverIcon(new ImageIcon(this.getClass().getResource
(
"files/images/TimerClockRefreshRollover.png"))
);
refreshCounter.setPressedIcon(new ImageIcon(this.getClass().getResource
(
"files/images/TimerClockRefreshPressed.png"))
);
refreshCounter.setBorder(BorderFactory.createEmptyBorder(0,0,0,0));
refreshCounter.addActionListener(new RefreshCounterListener());
displayAdd = new JButton(" Record Time ");
displayAdd.setPreferredSize(new Dimension(100,25));
displayAdd.addActionListener(new DisplayAddListener());
displayAdd.setBorder(BorderFactory.createEmptyBorder(0,0,0,0));
displayClear = new JButton(" Clear Records ");
displayClear.setPreferredSize(new Dimension(100,25));
displayClear.addActionListener(new DisplayClearListener());
displayClear.setBorder(BorderFactory.createEmptyBorder(0,0,0,0));
alarmStop = new JButton(" Stop Alarm ");
alarmStop.setPreferredSize(new Dimension(100,25));
alarmStop.addActionListener(new AlarmStopListener());
alarmStop.setBorder(BorderFactory.createEmptyBorder(0,0,0,0));
// Initialize JPanel GUI components.
buttonPanelFirst = new JPanel();
buttonPanelFirst.setLayout (new FlowLayout(FlowLayout.LEADING));
buttonPanelFirst.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
buttonPanelSecond = new JPanel();
buttonPanelSecond.setLayout (new FlowLayout(FlowLayout.LEADING));
buttonPanelSecond.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
recordPanel = new JPanel();
recordPanel.setLayout (new FlowLayout(FlowLayout.LEADING));
recordPanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
hourPanel = new JPanel();
hourPanel.setLayout (new FlowLayout(FlowLayout.LEADING));
hourPanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
hourPanel.setBorder(BorderFactory.createTitledBorder("Alarm Hour"));
minutePanel = new JPanel();
minutePanel.setLayout (new FlowLayout(FlowLayout.LEADING));
minutePanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
minutePanel.setBorder(BorderFactory.createTitledBorder("Alarm Minute"));
secondPanel = new JPanel();
secondPanel.setLayout (new FlowLayout(FlowLayout.LEADING));
secondPanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
secondPanel.setBorder(BorderFactory.createTitledBorder("Alarm Second"));
// Add GUI components to JPanels.
buttonPanelFirst.add(startCounter);
buttonPanelFirst.add(stopCounter);
buttonPanelFirst.add(refreshCounter);
buttonPanelSecond.add(displayAdd);
buttonPanelSecond.add(displayClear);
buttonPanelSecond.add(alarmStop);
hourPanel.add(alarmHour);
minutePanel.add(alarmMinute);
secondPanel.add(alarmSecond);
recordPanel.add(scrollPane);
// Method calls for GUI initialization.
gridBagConstraints(); setColors(); initialiseDisplay();
}
/**
* Sets the background color.
*/
private void setColors()
{
contentPane.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
counterLabel.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
recordPanel.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
hourPanel.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
minutePanel.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
secondPanel.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
buttonPanelFirst.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
buttonPanelSecond.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
recordDisplay.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(0,0,50,0);
constraints.ipadx = 0;
constraints.ipady = 0;
constraints.gridwidth = 6;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 0;
contentPane.add(counterLabel, constraints);
// Grid bag constraints 2.
constraints.insets = new Insets(10,0,0,0);
constraints.ipadx = 0;
constraints.ipady = 0;
constraints.gridwidth = 6;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 1;
contentPane.add(controlLabel, constraints);
// Grid bag constraints 3.
constraints.insets = new Insets(10,0,0,0);
constraints.ipadx = 0;
constraints.ipady = 0;
constraints.gridwidth = 6;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 2;
contentPane.add(buttonPanelFirst, constraints);
// Grid bag constraints 4.
constraints.insets = new Insets(10,10,0,0);
constraints.ipadx = 60;
constraints.ipady = 0;
constraints.gridwidth = 1;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 3;
contentPane.add(hourPanel, constraints);
// Grid bag constraints 5.
constraints.insets = new Insets(10,10,0,0);
constraints.ipadx = 60;
constraints.ipady = 0;
constraints.gridwidth = 1;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 2;
constraints.gridy = 3;
contentPane.add(minutePanel, constraints);
// Grid bag constraints 6.
constraints.insets = new Insets(10,10,0,10);
constraints.ipadx = 60;
constraints.ipady = 0;
constraints.gridwidth = 1;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 4;
constraints.gridy = 3;
contentPane.add(secondPanel, constraints);
// Grid bag constraints 7.
constraints.insets = new Insets(40,0,0,0);
constraints.ipadx = 0;
constraints.ipady = 0;
constraints.gridwidth = 6;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 4;
contentPane.add(recordLabel, constraints);
// Grid bag constraints 8.
constraints.insets = new Insets(10,0,0,0);
constraints.ipadx = 0;
constraints.ipady = 0;
constraints.gridwidth = 6;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 5;
contentPane.add(buttonPanelSecond, constraints);
// Grid bag constraints 9.
constraints.insets = new Insets(10,10,0,10);
constraints.ipadx = 0;
constraints.ipady = 0;
constraints.gridwidth = 6;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 6;
contentPane.add(recordPanel, constraints);
}
//*************************************** END INITIALISATION CODE ***************************************//
//************************************* START INTERFACE EVENT CODE **************************************//
private class CheckSchedule extends TimerTask
{
/**
* Displays the output.
*/
public void run()
{
setTimerMillis(System.currentTimeMillis() - getInitialMillis() + getLapsedMillis());
counterLabel.setText(DateAndTime.returnCounterTime(getTimerMillis(), true));
if (triggerAlarm() && !alarmActive) {runAlarm();}
}
}
private class AlarmSchedule extends TimerTask
{
/**
* Displays the output.
* ESCA-JAVA0266:
* ESCA-JAVA0166:
*/
public void run()
{
try {player.reload();}
catch (Exception e)
{System.out.println(Tools.thisPathAndLine() + e);}
player.play();
}
}
private class StartCounterListener
implements ActionListener
{
/**
* Listener that starts the counter.
*/
public void actionPerformed(ActionEvent event)
{
if (!timerRunning)
{
runSchedule();
disableEnableDropdown(false);
}
}
}
private class StopCounterListener
implements ActionListener
{
/**
* Listener that starts the counter.
*/
public void actionPerformed(ActionEvent event)
{
if (timerRunning)
{
counterTimer.cancel(); timerRunning = false;
setLapsedMillis(getTimerMillis());
disableEnableDropdown(true);
}
}
}
private class RefreshCounterListener
implements ActionListener
{
/**
* Listener that starts the counter.
*/
public void actionPerformed(ActionEvent event)
{
if (timerRunning)
{
counterTimer.cancel();
timerRunning = false;
}
disableEnableDropdown(true);
setLapsedMillis(0); initialiseDisplay();
if (alarmActive) {stopAlarm();}
}
}
private class DisplayAddListener
implements ActionListener
{
/**
* Listener that starts the counter.
*/
public void actionPerformed(ActionEvent event)
{
recordDisplay.append
("\n" + " Lap - " + DateAndTime.returnCounterTime(getTimerMillis(), true) + "\n");
}
}
private class DisplayClearListener
implements ActionListener
{
/**
* Listener that starts the counter.
*/
public void actionPerformed(ActionEvent event)
{
recordDisplay.setText(null);
}
}
private class AlarmStopListener
implements ActionListener
{
/**
* Listener that starts the counter.
*/
public void actionPerformed(ActionEvent event)
{
stopAlarm();
}
}
/**
* Overrides ComponentListener.
*/
public void componentMoved(ComponentEvent e) {}
public void componentResized(ComponentEvent e) {}
public void componentShown(ComponentEvent e) {setContentDisplay(true);}
public void componentHidden(ComponentEvent e) {setContentDisplay(false);}
//************************************** END INTERFACE EVENT CODE ***************************************//
//**************************************** START PUBLIC METHODS *****************************************//
/**
* Sets the visibility of the frame.
*/
public void setVisibility()
{
if (isVisible) {frame.setVisible(true);}
else {frame.setVisible(false);}
}
/**
* Displays or Hides contents of GUI.
* @param shown
*/
public void setContentDisplay(boolean shown)
{
contentPane.setVisible(shown);
}
//***************************************** END PUBLIC METHODS ******************************************//
//**************************************** START PRIVATE METHODS ****************************************//
/**
* Tests if the alarm is to be triggered.
* @return
*/
private boolean triggerAlarm()
{
if
(
(
Long.toString(DateAndTime.getCounterHours()).
equals((String)alarmHour.getSelectedItem())
)
&&
(
Long.toString(DateAndTime.getCounterMinutes()).
equals((String)alarmMinute.getSelectedItem())
)
&&
(
Long.toString(DateAndTime.getCounterSeconds()).
equals((String)alarmSecond.getSelectedItem())
)
)
{return true;}
else {return false;}
}
/**
* Disables or enables the alarm drop down boxes.
* @param enabled
*/
private void disableEnableDropdown(boolean enabled)
{
alarmHour.setEnabled(enabled);
alarmMinute.setEnabled(enabled);
alarmSecond.setEnabled(enabled);
}
/**
* Runs the clock scheduler.
*/
private void runSchedule()
{
timerRunning = true; setInitialMillis(); counterTimer = new Timer();
counterTimer.schedule(new CheckSchedule(), 0, REFRESH_RATE);
}
/**
* Runs the clock scheduler.
*/
private void runAlarm()
{
alarmActive = true;
alarmTimer = new Timer();
counterLabel.setForeground(Color.RED);
alarmTimer.schedule(new AlarmSchedule(), 0, ALARM_RATE);
player.loadFile("files/audio/DigitalClockAlarm.wav");
}
/**
* Stops the alarm.
*/
private void stopAlarm()
{
if (alarmActive) {alarmTimer.cancel(); alarmActive = false;}
counterLabel.setForeground(initialiseCounterColor());
}
/**
* Returns the initialized counter color.
* ESCA-JAVA0076:
* @return
*/
private static Color initialiseCounterColor()
{
return (new Color(0,170,0));
}
/**
* Resets the counter display.
*/
private void initialiseDisplay()
{
counterLabel.setText("00:00:00:0");
}
/**
* 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);
}
}
/**
* Sets the initial time in milliseconds.
*/
private void setInitialMillis() {initialTimeMillis = System.currentTimeMillis();}
/**
* Sets the elapsed time in milliseconds.
* @param millis
*/
private void setLapsedMillis(long millis) {lapsedTimeMillis = millis;}
/**
* Sets the elapsed time in milliseconds.
* @param millis
*/
private void setTimerMillis(long millis) {timerMillis = millis;}
/**
* Returns the initial time in milliseconds.
* @return
*/
private long getInitialMillis() {return initialTimeMillis;}
/**
* Returns the lapsed milliseconds.
* @return
*/
private long getLapsedMillis() {return lapsedTimeMillis;}
/**
* Returns the timer milliseconds.
* @return
*/
private long getTimerMillis() {return timerMillis;}
//***************************************** END PRIVATE METHODS *****************************************//
//********************************************** START MAIN *********************************************//
/**
* Main
* @param a
*/
public static void main(String[] a)
{
isApplication = true;
isVisible = true;
new TimerClockGui();
}
//*********************************************** END MAIN **********************************************//
/**
* ESCA-JAVA0007:
*/
public JFrame frame;
private AudioPlayer player;
private JLabel counterLabel;
private Container contentPane;
private JScrollPane scrollPane;
private JTextArea recordDisplay;
private boolean zoomWarningShown;
private GridBagConstraints constraints;
private Timer counterTimer, alarmTimer;
private JLabel controlLabel, recordLabel;
private boolean timerRunning, alarmActive;
private long initialTimeMillis, lapsedTimeMillis, timerMillis;
private JComboBox alarmHour, alarmMinute, alarmSecond;
private JButton startCounter, stopCounter, refreshCounter, displayAdd, displayClear, alarmStop;
private JPanel buttonPanelFirst, buttonPanelSecond, recordPanel, hourPanel, minutePanel, secondPanel;
//********************************************** 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 **********************************************//
}