/*
COPYRIGHT (C) 2010 -2013 by Alexander Wait. All Rights Reserved.
This class displays a digital clock.
@site http://www.javaika.com
@author Alexander Wait
@version 2012-05-18
*/
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.*;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Timer;
import java.util.TimerTask;
import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
public class AlarmClockGui 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 runRestricted = false;
static boolean isVisible = false;
private static final int SQL_TABLE_COLUMN_A = 0;
private static final int SQL_TABLE_COLUMN_B = 1;
private static final int SQL_TABLE_COLUMN_C = 2;
private static final int SQL_TABLE_COLUMN_D = 3;
private static final int SQL_TABLE_COLUMN_E = 4;
Dimension appletSize = this.getSize();
private static final int BLACK_SHADE = 50;
private static final int FRAME_SIZE_X = 500;
private static final int FRAME_SIZE_Y = 350;
private static final int REFRESH_RATE = 1000;
private static final int MAXIMUM_SIZE_APPLET_X = 800;
private static final int MAXIMUM_SIZE_APPLET_Y = 530;
private static final int MAXIMUM_SIZE_APPLICATION_X = 900;
private static final int MAXIMUM_SIZE_APPLICATION_Y = 800;
private static final double SHADE_FACTOR = 2.55;
private static final double RESIZE_FACTOR_APPLET = 0.00033;
private static final double RESIZE_FACTOR_APPLICATION = 0.00030;
private static final String CLEAR_ADDRESS = "http://" + Domain.getDomain()
+ "/bridge/alarm-clock-table-clear.php" + Domain.getPort(); // Port:80
private static final String WRITE_ADDRESS = "http://" + Domain.getDomain()
+ "/bridge/alarm-clock-table-write.php" + Domain.getPort(); // Port:80
private static final String READ_ADDRESS = "http://" + Domain.getDomain()
+ "/bridge/alarm-clock-table-read.php" + Domain.getPort(); // Port:80
//************************************** START INITIALISATION CODE **************************************//
/**
* Browser constructor.
*/
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
{
try {getToolkit().getSystemClipboard();}
catch (java.security.AccessControlException e) {runRestricted = true;}
userId = getParameter("id"); userPw = getParameter("pw");
initialiser(); includeResizeEvent(); changeWindowBrightness();
setJMenuBar(menuBar); setSize(FRAME_SIZE_X, FRAME_SIZE_Y);
setFontSize(); runSchedule();
}
}
}
/**
* Application constructor.
*/
public AlarmClockGui()
{
if (isApplication)
{
userId = "NON_MEMBER"; 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("Digital Clock Program");
frame.addComponentListener(this);
frame.setJMenuBar(menuBar);
frame.add(contentPane);
setVisibility(); setFontSize(); runSchedule();
}
}
/**
* GUI initializer.
* ESCA-JAVA0076:
*/
private void initialiser()
{
player = new AudioPlayer();
// Initialize content pane and layout.
contentPane = getContentPane(); contentPane.setLayout(new GridLayout(2,1));
// Initialize combo box GUI components.
displayColor = new JComboBox(choices);
displayColor.setPreferredSize(new Dimension(93, 60));
displayColor.setBorder(BorderFactory.createTitledBorder("Display Color"));
displayColor.setMaximumRowCount(2); displayColor.setSelectedIndex(4);
displayColor.addActionListener(new TextColorListener());
alarmHour = new JComboBox(DateAndTime.returnHourChoices());
alarmHour.setPreferredSize(new Dimension(93, 60));
alarmHour.setBorder(BorderFactory.createTitledBorder("Alarm Hour"));
alarmHour.setMaximumRowCount(2); alarmHour.insertItemAt("OFF", 0);
alarmHour.setSelectedIndex(0);
alarmMinute = new JComboBox(DateAndTime.returnMinuteChoices());
alarmMinute.setPreferredSize(new Dimension(93, 60));
alarmMinute.setBorder(BorderFactory.createTitledBorder("Alarm Minute"));
alarmMinute.setMaximumRowCount(2); alarmMinute.insertItemAt("OFF", 0);
alarmMinute.setSelectedIndex(0);
// Initialize check box GUI components.
timeDisplay = new JCheckBox();
timeDisplay.setFocusPainted(false);
timeDisplay.addItemListener(new DisplayTypeClass());
// Initialize slider GUI components.
brightnessSlider = new JSlider();
brightnessSlider.setPreferredSize(new Dimension(80, 60));
brightnessSlider.setBorder(BorderFactory.createTitledBorder("Brightness"));
brightnessSlider.setMajorTickSpacing(25); brightnessSlider.setMinorTickSpacing(5);
brightnessSlider.setValue(100); brightnessSlider.setPaintTicks(true);
brightnessSlider.addChangeListener(new BackgroundChangeListener());
// Initialize button GUI components.
stopAlarm = new JButton(new ImageIcon(this.getClass().getResource
(
"files/images/DigitalClockAlarmNormal.png"))
);
stopAlarm.setRolloverIcon(new ImageIcon(this.getClass().getResource
(
"files/images/DigitalClockAlarmRollover.png"))
);
stopAlarm.setPressedIcon(new ImageIcon(this.getClass().getResource
(
"files/images/DigitalClockAlarmPressed.png"))
);
stopAlarm.setBorder(BorderFactory.createEmptyBorder(0,0,0,0));
stopAlarm.setPreferredSize(new Dimension(119, 59));
stopAlarm.addActionListener(new StopAlarmListener());
stopAlarm.setVisible(false);
// Initialize menu bar GUI components.
menuBar = new JMenuBar(); menuBar.add(createFileMenu());
saveMenuItem.setEnabled(false); clearMenuItem.setEnabled(false);
// Initialize JLabel GUI components.
timeLabel = new JLabel(); stageLabel = new JLabel();
// Initialize JPanel GUI components.
timePanel = new JPanel(); timePanel.add(timeDisplay);
timePanel.setPreferredSize(new Dimension(93, 60));
timePanel.setBorder(BorderFactory.createTitledBorder("Display 24 Hr"));
displayContent = new JPanel(); displayContent.setLayout(new FlowLayout());
settingsPanel = new JPanel(); settingsPanel.setLayout(new FlowLayout());
stopAlarmPanel = new JPanel(); stopAlarmPanel.setLayout(new FlowLayout());
settingsContainer = new JPanel(); settingsContainer.setLayout(new GridLayout(2,1));
// Add GUI components to JPanels.
stopAlarmPanel.add(stopAlarm); settingsPanel.add(brightnessSlider);
settingsPanel.add(displayColor); settingsPanel.add(alarmHour);
settingsPanel.add(alarmMinute); settingsPanel.add(timePanel);
settingsContainer.add(stopAlarmPanel); settingsContainer.add(settingsPanel);
displayContent.add(timeLabel); displayContent.add(stageLabel);
contentPane.add(displayContent); contentPane.add(settingsContainer);
// Read settings from database if user logged in.
if ((!(userId == null)) && (!userId.equals("NON_MEMBER")) && (!runRestricted))
{saveMenuItem.setEnabled(true); clearMenuItem.setEnabled(true); readFromDatabase();}
// Method calls for GUI initialization.
setGraphicIcons(); setBackgroundHelper();
}
/**
* Sets icons for graphical elements.
*/
private void setGraphicIcons()
{
timeDisplay.setIcon(new ImageIcon
(this.getClass().getResource("files/images/CheckBoxNormalUnselected.png")));
timeDisplay.setSelectedIcon(new ImageIcon
(this.getClass().getResource("files/images/CheckBoxNormalSelected.png")));
timeDisplay.setDisabledIcon(new ImageIcon
(this.getClass().getResource("files/images/CheckBoxDisabledUnselected.png")));
timeDisplay.setDisabledSelectedIcon(new ImageIcon
(this.getClass().getResource("files/images/CheckBoxDisabledSelected.png")));
}
//*************************************** END INITIALISATION CODE ***************************************//
//************************************* START INTERFACE EVENT CODE **************************************//
private class CheckSchedule extends TimerTask
{
/**
* Displays the output and triggers the alarm.
* ESCA-JAVA0266:
* ESCA-JAVA0166:
*/
public void run()
{
if (triggerAlarm())
{
triggerAlarm = true;
stopAlarm.setVisible(true);
}
if (triggerAlarm)
{
try {player.reload();}
catch (Exception e)
{System.out.println(Tools.thisPathAndLine() + e);}
player.play();
}
timeLabel.setText(DateAndTime.returnFormattedTime(isTwentyFourHour));
if (!isTwentyFourHour)
{
stageLabel.setText(DateAndTime.returnAmOrPm());
}
else {stageLabel.setText(null);}
setFontSize();
}
}
public class TextColorListener implements ActionListener
{
/**
* Listener for display color.
*/
public void actionPerformed(ActionEvent event)
{
String color = (String)displayColor.getSelectedItem();
if (color.equals("RED"))
{timeLabel.setForeground(Color.red); stageLabel.setForeground(Color.red);}
if (color.equals("BLUE"))
{timeLabel.setForeground(Color.blue); stageLabel.setForeground(Color.blue);}
if (color.equals("GREEN"))
{timeLabel.setForeground(Color.green); stageLabel.setForeground(Color.green);}
if (color.equals("BLACK"))
{
timeLabel.setForeground(new Color(BLACK_SHADE,BLACK_SHADE,BLACK_SHADE));
stageLabel.setForeground(new Color(BLACK_SHADE,BLACK_SHADE,BLACK_SHADE));
}
if (color.equals("WHITE"))
{timeLabel.setForeground(Color.white); stageLabel.setForeground(Color.white);}
if (color.equals("ORANGE"))
{timeLabel.setForeground(Color.orange); stageLabel.setForeground(Color.orange);}
if (color.equals("YELLOW"))
{timeLabel.setForeground(Color.yellow); stageLabel.setForeground(Color.yellow);}
}
}
private class StopAlarmListener
implements ActionListener
{
/**
* Listener that stops the alarm.
*/
public void actionPerformed(ActionEvent event)
{
triggerAlarm = false;
stopAlarm.setVisible(false);
}
}
private class DisplayTypeClass implements ItemListener
{
public void itemStateChanged(ItemEvent event)
{
if (timeDisplay.isSelected())
{
isTwentyFourHour = true;
}
else
{
isTwentyFourHour = false;
}
}
}
private class BackgroundChangeListener implements ChangeListener
{
/**
* This is the slider listener.
*/
public void stateChanged(ChangeEvent changeEvent)
{
Object source = changeEvent.getSource();
if (source instanceof JSlider)
{
if (!brightnessSlider.getValueIsAdjusting())
{
setBackgroundHelper();
changeWindowBrightness();
}
}
}
}
/**
* 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 font size.
*/
public void setFontSize()
{
double size = 0;
if (!isApplication)
{
if ((getSize().width > MAXIMUM_SIZE_APPLET_X)
&& (getSize().height > MAXIMUM_SIZE_APPLET_Y))
{
size = MAXIMUM_SIZE_APPLET_X * MAXIMUM_SIZE_APPLET_Y * RESIZE_FACTOR_APPLET;
}
else if ((getSize().width > MAXIMUM_SIZE_APPLET_X)
&& (getSize().height <= MAXIMUM_SIZE_APPLET_Y))
{
size = MAXIMUM_SIZE_APPLET_X * getSize().height * RESIZE_FACTOR_APPLET;
}
else if ((getSize().width <= MAXIMUM_SIZE_APPLET_X)
&& (getSize().height > MAXIMUM_SIZE_APPLET_Y))
{
size = getSize().width * MAXIMUM_SIZE_APPLET_Y * RESIZE_FACTOR_APPLET;
}
else
{
size = getSize().width * getSize().height * RESIZE_FACTOR_APPLET;
}
}
if (isApplication)
{
if ((frame.getWidth() > MAXIMUM_SIZE_APPLICATION_X)
&& (frame.getHeight() > MAXIMUM_SIZE_APPLICATION_Y))
{
size = MAXIMUM_SIZE_APPLICATION_X * MAXIMUM_SIZE_APPLICATION_Y * RESIZE_FACTOR_APPLICATION;
}
else if ((frame.getWidth() > MAXIMUM_SIZE_APPLICATION_X)
&& (frame.getHeight() <= MAXIMUM_SIZE_APPLICATION_Y))
{
size = MAXIMUM_SIZE_APPLICATION_X * frame.getHeight() * RESIZE_FACTOR_APPLICATION;
}
else if ((frame.getWidth() <= MAXIMUM_SIZE_APPLICATION_X)
&& (frame.getHeight() > MAXIMUM_SIZE_APPLICATION_Y))
{
size = frame.getWidth() * MAXIMUM_SIZE_APPLICATION_Y * RESIZE_FACTOR_APPLICATION;
}
else
{
size = frame.getWidth() * frame.getHeight() * RESIZE_FACTOR_APPLICATION;
}
}
timeLabel.setFont(new Font("Times New Roman", Font.PLAIN, (int)size));
stageLabel.setFont(new Font("Times New Roman", Font.PLAIN, (int)size/4));
}
/**
* 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)
{
menuBar.setVisible(shown);
contentPane.setVisible(shown);
}
//***************************************** END PUBLIC METHODS ******************************************//
//**************************************** START PRIVATE METHODS ****************************************//
/**
* Sets the brightness of the web page.
* ESCA-JAVA0266:
*/
private void changeWindowBrightness()
{
if (!isApplication)
{
try
{
getAppletContext().showDocument
(
new URL
(
"javascript:changeBrightness(\"" +
ColorFunctions.returnHexadecimalColor
(
(int)(brightnessSlider.getValue() * SHADE_FACTOR)
)
+ "\")"
)
);
}
catch (MalformedURLException e) {System.out.println(Tools.thisPathAndLine() + e + "\n");}
}
}
/**
* Runs the clock scheduler.
*/
private void runSchedule()
{
timer = new Timer();
player.loadFile("files/audio/DigitalClockAlarm.wav");
timer.schedule(new CheckSchedule(), 0, REFRESH_RATE);
}
/**
* Tests if the alarm is to be triggered.
* @return
*/
private boolean triggerAlarm()
{
if
(
(
Integer.toString(DateAndTime.returnHour()).
equals((String)alarmHour.getSelectedItem())
)
&&
(
Integer.toString(DateAndTime.returnMinute()).
equals((String)alarmMinute.getSelectedItem())
)
&&
(
Integer.toString(DateAndTime.returnSecond()).equals("0")
)
)
{return true;}
else {return false;}
}
/**
* Reads settings from the database.
*/
private void readFromDatabase()
{
readSettings = new ArrayList();
readSettings = Portal.phpToJavaGate(READ_ADDRESS, userId, userPw, null);
if (readSettings.size() != 0)
{
setBrightness(readSettings.get(SQL_TABLE_COLUMN_A));
setDisplayColor(readSettings.get(SQL_TABLE_COLUMN_B));
setAlarmHour(readSettings.get(SQL_TABLE_COLUMN_C));
setAlarmMinute(readSettings.get(SQL_TABLE_COLUMN_D));
setDisplayType(readSettings.get(SQL_TABLE_COLUMN_E));
}
}
/**
* Writes settings to the database.
*/
private void transferToDatabase()
{
writeSettings = new ArrayList();
writeSettings.add(getBrightness());
writeSettings.add(getDisplayColor());
writeSettings.add(getAlarmHour());
writeSettings.add(getAlarmMinute());
writeSettings.add(getDisplayType());
Portal.javaToPhpGate(WRITE_ADDRESS, userId, userPw, writeSettings);
}
/**
* Clears the settings from the database.
*/
private void clearDatabase()
{
Portal.clearFromDatabase(CLEAR_ADDRESS, userId, userPw, null);
}
/**
* Adds save mode menu item and listener that responds appropriately.
* @return menuItem
*/
private JMenuItem saveMode()
{
saveMenuItem = new JMenuItem("Save Settings");
class MenuItemListener implements ActionListener
{
public void actionPerformed(ActionEvent event)
{
transferToDatabase();
}
}
ActionListener listener = new MenuItemListener();
saveMenuItem.addActionListener(listener);
return saveMenuItem;
}
/**
* Adds clear mode menu item and listener that responds appropriately.
* @return menuItem
*/
private JMenuItem clearMode()
{
clearMenuItem = new JMenuItem("Clear Settings");
class MenuItemListener implements ActionListener
{
public void actionPerformed(ActionEvent event)
{
clearDatabase();
}
}
ActionListener listener = new MenuItemListener();
clearMenuItem.addActionListener(listener);
return clearMenuItem;
}
/**
* Adds a file menu.
* @return menu
*/
private JMenu createFileMenu()
{
JMenu menu = new JMenu("File");
menu.add(saveMode()); menu.add(clearMode());
return menu;
}
private void setBackgroundHelper()
{
setBackgroundColor
(
(int)(brightnessSlider.getValue() * SHADE_FACTOR),
(int)(brightnessSlider.getValue() * SHADE_FACTOR),
(int)(brightnessSlider.getValue() * SHADE_FACTOR)
);
}
/**
* Sets the background.
* @param x
* @param y
* @param z
*/
private void setBackgroundColor(int x, int y, int z)
{
displayContent.setBackground(new Color(x, y, z));
contentPane.setBackground(new Color(x, y, z));
brightnessSlider.setBackground(new Color(x, y, z));
displayColor.setBackground(new Color(x, y, z));
alarmHour.setBackground(new Color(x, y, z));
alarmMinute.setBackground(new Color(x, y, z));
timeDisplay.setBackground(new Color(x, y, z));
timePanel.setBackground(new Color(x, y, z));
stopAlarmPanel.setBackground(new Color(x, y, z));
settingsPanel.setBackground(new Color(x, y, z));
settingsContainer.setBackground(new Color(x, y, z));
}
/**
* Sets the background brightness.
* @param value
*/
private void setBrightness(String value)
{
brightnessSlider.setValue(Integer.parseInt(value));
setBackgroundHelper();
try
{
getAppletContext().showDocument
(
new URL
(
"javascript:changeBrightness(\"" +
ColorFunctions.returnHexadecimalColor
(
(int)(brightnessSlider.getValue() * SHADE_FACTOR)
)
+ "\")"
)
);
}
// ESCA-JAVA0266:
catch (MalformedURLException e) {System.out.println(Tools.thisPathAndLine() + e + "\n");}
}
/**
* Sets the display color.
* @param value
*/
private void setDisplayColor(String value)
{
if (value.equals("RED"))
{
displayColor.setSelectedIndex(0);
timeLabel.setForeground(Color.red); stageLabel.setForeground(Color.red);
}
if (value.equals("BLUE"))
{
displayColor.setSelectedIndex(1);
timeLabel.setForeground(Color.blue); stageLabel.setForeground(Color.blue);
}
if (value.equals("GREEN"))
{
displayColor.setSelectedIndex(2);
timeLabel.setForeground(Color.green); stageLabel.setForeground(Color.green);
}
if (value.equals("WHITE"))
{
displayColor.setSelectedIndex(3);
timeLabel.setForeground(Color.white); stageLabel.setForeground(Color.white);
}
if (value.equals("BLACK"))
{
displayColor.setSelectedIndex(4);
timeLabel.setForeground(new Color(BLACK_SHADE,BLACK_SHADE,BLACK_SHADE));
stageLabel.setForeground(new Color(BLACK_SHADE,BLACK_SHADE,BLACK_SHADE));
}
if (value.equals("ORANGE"))
{
displayColor.setSelectedIndex(5);
timeLabel.setForeground(Color.orange); stageLabel.setForeground(Color.orange);
}
if (value.equals("YELLOW"))
{
displayColor.setSelectedIndex(6);
timeLabel.setForeground(Color.yellow); stageLabel.setForeground(Color.yellow);
}
}
/**
* Sets the alarm hour.
* @param value
*/
private void setAlarmHour(String value)
{
if (value.equals("OFF")) {alarmHour.setSelectedIndex(0);}
else {alarmHour.setSelectedIndex(Integer.parseInt(value) + 1);}
}
/**
* Sets the alarm hour.
* @param value
*/
private void setAlarmMinute(String value)
{
if (value.equals("OFF")) {alarmMinute.setSelectedIndex(0);}
else {alarmMinute.setSelectedIndex(Integer.parseInt(value) + 1);}
}
/**
* Sets the display format.
* @param type
*/
private void setDisplayType(String type)
{
if (type.equals("24H"))
{
timeDisplay.setSelected(true);
}
else
{
timeDisplay.setSelected(false);
}
}
/**
* Returns the brightness setting.
* @return
*/
private String getBrightness()
{
String brightness = "";
brightness = Integer.toString(brightnessSlider.getValue());
return brightness;
}
/**
* Returns the display color.
* @return
*/
private String getDisplayColor()
{
String color = "";
color = (String)displayColor.getSelectedItem();
return color;
}
/**
* Returns the alarm hour.
* @return
*/
private String getAlarmHour()
{
String hour = "";
hour = (String)alarmHour.getSelectedItem();
return hour;
}
/**
* Returns the alarm hour.
* @return
*/
private String getAlarmMinute()
{
String minute = "";
minute = (String)alarmMinute.getSelectedItem();
return minute;
}
/**
* Returns the display type (24 hour or standard)
* @return
*/
private String getDisplayType()
{
String type = "";
if (timeDisplay.isSelected())
{
type = "24H";
}
else
{
type = "STD";
}
return type;
}
/**
* 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); menuBar.setVisible(false);
if (!zoomWarningShown)
{
Message.showMessage(ZOOM_WARNING, "Browser zoom setting", "warning");
zoomWarningShown = true; menuBar.setVisible(true);
}
}
else
{
contentPane.setVisible(true); menuBar.setVisible(true);
}
}
//***************************************** END PRIVATE METHODS *****************************************//
//********************************************** START MAIN *********************************************//
/**
* Main
* @param a
*/
public static void main(String[] a)
{
isApplication = true;
isVisible = true;
new AlarmClockGui();
}
//*********************************************** END MAIN **********************************************//
/**
* ESCA-JAVA0007:
*/
public JFrame frame;
private Timer timer;
private JMenuBar menuBar;
private JButton stopAlarm;
private AudioPlayer player;
private JCheckBox timeDisplay;
private Container contentPane;
private String userId, userPw;
private JSlider brightnessSlider;
private boolean zoomWarningShown;
private JLabel timeLabel, stageLabel;
private JMenuItem saveMenuItem, clearMenuItem;
private boolean triggerAlarm, isTwentyFourHour;
private ArrayList readSettings, writeSettings;
private JComboBox alarmHour, alarmMinute, displayColor;
private String[] choices = {"RED", "BLUE", "GREEN", "WHITE", "BLACK", "ORANGE", "YELLOW"};
private JPanel settingsPanel, stopAlarmPanel, settingsContainer, timePanel, displayContent;
//********************************************** 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 a bridge that connects java with PHP
scripts on the server for writing information from the
java application to a remote database on the server.
The class also receives data from PHP server scripts
upon request for this information.
@site http://www.javaika.com
@author Alexander Wait
@version 2012-03-18
*/
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.util.ArrayList;
public class Portal
{
private Portal(){}
//**************************************** START PUBLIC METHODS *****************************************//
/**
* Sends data to a specified PHP script address.
* ESCA-JAVA0266:
* @param address
* @param userId
* @param userPw
* @param data
*/
public static void javaToPhpGate(String address, String userId, String userPw, ArrayList data)
{
scriptAddress = address;
try
{
url = new URL(scriptAddress); conn = url.openConnection(); conn.setDoOutput(true);
dataSend = URLEncoder.encode("userId", "UTF-8") + "=" + URLEncoder.encode(userId, "UTF-8")
+ "&" + URLEncoder.encode("userPw", "UTF-8") + "=" + URLEncoder.encode(userPw, "UTF-8");
if (data != null) {setVariableValues(data);} sendData();
reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
while ((dataRecieve = reader.readLine()) != null)
{
System.out.println(dataRecieve);
}
reader.close();
}
catch (IOException e) {System.out.println(Tools.thisPathAndLine() + e + "\n");}
}
/**
* Receives data from a specified PHP script address.
* ESCA-JAVA0266:
* @param address
* @param userId
* @param userPw
* @param data
* @return
*/
public static ArrayList phpToJavaGate(String address, String userId, String userPw, ArrayList data)
{
scriptAddress = address;
ArrayList output = new ArrayList();
try
{
url = new URL(scriptAddress); conn = url.openConnection(); conn.setDoOutput(true);
dataSend = URLEncoder.encode("userId", "UTF-8") + "=" + URLEncoder.encode(userId, "UTF-8")
+ "&" + URLEncoder.encode("userPw", "UTF-8") + "=" + URLEncoder.encode(userPw, "UTF-8");
if (data != null) {setVariableValues(data);} sendData();
reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
while ((dataRecieve = reader.readLine()) != null)
{
output.add(dataRecieve);
}
reader.close();
}
catch (IOException e) {System.out.println(Tools.thisPathAndLine() + e + "\n");}
return output;
}
/**
* Clears database records using a specified PHP script address.
* ESCA-JAVA0266:
* @param address
* @param userId
* @param userPw
* @param data
*/
public static void clearFromDatabase(String address, String userId, String userPw, ArrayList data)
{
scriptAddress = address;
try
{
url = new URL(scriptAddress); conn = url.openConnection(); conn.setDoOutput(true);
dataSend = URLEncoder.encode("userId", "UTF-8") + "=" + URLEncoder.encode(userId, "UTF-8")
+ "&" + URLEncoder.encode("userPw", "UTF-8") + "=" + URLEncoder.encode(userPw, "UTF-8");
if (data != null) {setVariableValues(data);} sendData();
reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
while ((dataRecieve = reader.readLine()) != null)
{
System.out.println(dataRecieve);
}
reader.close();
}
catch (IOException e) {System.out.println(Tools.thisPathAndLine() + e + "\n");}
}
//***************************************** END PUBLIC METHODS ******************************************//
//**************************************** START PRIVATE METHODS ****************************************//
/**
* Sets the PHP variable values.
* ESCA-JAVA0266:
* @param data
*/
private static void setVariableValues(ArrayList data)
{
try
{
for (int i = 0; i < data.size(); i ++)
{
String variableName = "variable_" + Integer.toString(i+1);
dataSend += "&" + URLEncoder.encode(variableName, "UTF-8") +
"=" + URLEncoder.encode(data.get(i), "UTF-8");
}
}
catch (UnsupportedEncodingException e) {System.out.println(Tools.thisPathAndLine() + e + "\n");}
}
/**
* Sends data to the appropriate PHP script.
* ESCA-JAVA0266:
*/
private static void sendData()
{
try
{
writer = new BufferedWriter(new OutputStreamWriter(conn.getOutputStream()));
writer.write(dataSend); writer.flush(); writer.close();
}
catch (MalformedURLException e) {System.out.println(Tools.thisPathAndLine() + e + "\n");}
catch (IOException e) {System.out.println(Tools.thisPathAndLine() + e + "\n");}
}
//***************************************** END PRIVATE METHODS *****************************************//
private static URL url;
private static String dataSend;
private static URLConnection conn;
private static String dataRecieve;
private static String scriptAddress;
private static BufferedReader reader;
private static BufferedWriter writer;
//********************************************** 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 **********************************************//
}