/*
COPYRIGHT (C) 2010 - 2013 by Alexander Wait. All Rights Reserved.
This class displays the interest calculator GUI.
@site http://www.javaika.com
@author Alexander Wait
@version 2012-09-15
*/
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.*;
import java.text.DecimalFormat;
import javax.swing.*;
public class InterestCalculatorGui extends JApplet implements ComponentListener
{
private static final String copyright = "Copyright (c) 2012 by Alexander Wait - All Rights Reserved";
private static final long serialVersionUID = 1L;
static boolean isApplication = false;
static boolean isVisible = false;
private static final int FRAME_SIZE_X = 450;
private static final int FRAME_SIZE_Y = 555;
private static final int OPTION_LENGTH = 5;
//************************************** START INITIALISATION CODE **************************************//
/**
* Browser constructor.
*/
public void init()
{
String copyrightParam = getParameter("copyright");
if ((copyrightParam == null) || !copyrightParam.equals(copyright))
{
Message.showMessage("Invalid Copyright", "WARNING", "warning");
}
else if (!getDocumentBase().getHost().equals(Domain.getDomain()))
{
Message.showMessage("Unauthorised Applet Use", "ERROR", "error");
}
else
{
initialiser(); includeResizeEvent();
setSize(FRAME_SIZE_X,FRAME_SIZE_Y);
}
}
/**
* Application constructor.
*/
public InterestCalculatorGui()
{
if (isApplication)
{
initialiser();
frame = new JFrame();
frame.setMinimumSize(new Dimension(FRAME_SIZE_X, FRAME_SIZE_Y));
frame.setSize(FRAME_SIZE_X,FRAME_SIZE_Y);
frame.setLocationRelativeTo(null);
frame.setTitle("Interest Calculator Program");
frame.add(contentPane);
setVisibility();
}
}
/**
* GUI initializer.
* ESCA-JAVA0076
*/
private void initialiser()
{
interestCalculator = new InterestCalculator();
// Initialize content pane and layout.
contentPane = getContentPane();
contentPane.setLayout(new GridBagLayout());
// Initialize JLabel GUI components.
optionLabel = new JLabel("OPTION");
optionLabel.setHorizontalAlignment(SwingConstants.LEFT);
settingsLabel = new JLabel("SETTINGS");
settingsLabel.setHorizontalAlignment(SwingConstants.LEFT);
displayLabel = new JLabel("DISPLAY");
displayLabel.setHorizontalAlignment(SwingConstants.LEFT);
// Initialize text area GUI components.
optionDisplay = new JTextArea(); optionDisplay.setEditable(false);
optionDisplay.setFont(new Font("Dialog", Font.PLAIN, 11));
optionDisplay.setText("Select an investment return option below");
resultDisplay = new JTextArea(); resultDisplay.setEditable(false);
resultDisplay.setPreferredSize(new Dimension(390,104));
resultDisplay.setBorder(BorderFactory.createEtchedBorder());
resultDisplay.setFont(new Font("Serif", Font.BOLD, 15));
// Initialize text field GUI components.
investAmount = new JTextField();
investAmount.setBorder(BorderFactory.createTitledBorder("Invest Amount"));
investTerm = new JTextField();
investTerm.setBorder(BorderFactory.createTitledBorder("Invest Term"));
depositAmount = new JTextField();
depositAmount.setBorder(BorderFactory.createTitledBorder("Deposit Amount"));
investGoal = new JTextField();
investGoal.setBorder(BorderFactory.createTitledBorder("Invest Goal"));
interestRate = new JTextField();
interestRate.setBorder(BorderFactory.createTitledBorder("Interest Rate"));
// Initialize combo box GUI components.
frequencyBox = new JComboBox(frequencyChoices);
frequencyBox.setMaximumRowCount(2); frequencyBox.setSelectedIndex(3);
// Initialize button GUI components.
calculate = new JButton(new ImageIcon(this.getClass().getResource
(
"files/images/FinanceToolCalculateNormal.png"))
);
calculate.setRolloverIcon(new ImageIcon(this.getClass().getResource
(
"files/images/FinanceToolCalculateRollover.png"))
);
calculate.setPressedIcon(new ImageIcon(this.getClass().getResource
(
"files/images/FinanceToolCalculatePressed.png"))
);
calculate.setBorder(BorderFactory.createEmptyBorder(0,0,0,0));
calculate.addActionListener(new CalculateButtonListener());
clear = new JButton(new ImageIcon(this.getClass().getResource
(
"files/images/FinanceToolClearNormal.png"))
);
clear.setRolloverIcon(new ImageIcon(this.getClass().getResource
(
"files/images/FinanceToolClearRollover.png"))
);
clear.setPressedIcon(new ImageIcon(this.getClass().getResource
(
"files/images/FinanceToolClearPressed.png"))
);
clear.setBorder(BorderFactory.createEmptyBorder(0,0,0,0));
clear.addActionListener(new ClearButtonListener());
// Initialize JPanel GUI components.
optionPanel = new JPanel();
optionPanel.setLayout (new FlowLayout(FlowLayout.LEADING));
optionPanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
buttonPanel = new JPanel();
buttonPanel.setLayout (new FlowLayout(FlowLayout.LEADING));
buttonPanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
frequencyContainer = new JPanel();
frequencyContainer.setBorder(BorderFactory.createTitledBorder("Payment"));
// Add GUI components to JPanels.
frequencyContainer.add(frequencyBox);
buttonPanel.add(calculate); buttonPanel.add(clear);
// Method calls for GUI initialization.
gridBagConstraints(); setOptions(); setColors();
}
/**
* Sets the background color.
*/
private void setColors()
{
for (JRadioButton option : options)
{
option.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
}
contentPane.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
frequencyContainer.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
optionPanel.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
buttonPanel.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
optionDisplay.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
resultDisplay.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
investAmount.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
investTerm.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
depositAmount.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
interestRate.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
investGoal.setBackground
(
new Color (ColorFunctions.red(), ColorFunctions.green(), ColorFunctions.blue())
);
}
/**
* Sets the grid bag layout.
* ESCA-JAVA0076:
*/
private void gridBagConstraints()
{
// Initialize grid bag layout of GUI.
constraints = new GridBagConstraints();
constraints.fill = GridBagConstraints.HORIZONTAL;
// Grid bag constraints 1.
constraints.insets = new Insets(10,0,0,0);
constraints.ipadx = 0;
constraints.ipady = 0;
constraints.gridwidth = 3;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 0;
contentPane.add(optionLabel, constraints);
// Grid bag constraints 2.
constraints.insets = new Insets(10,10,0,0);
constraints.ipadx = 0;
constraints.ipady = 0;
constraints.gridwidth = 3;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 1;
contentPane.add(optionDisplay, constraints);
// Grid bag constraints 3.
constraints.insets = new Insets(10,10,0,0);
constraints.ipadx = 0;
constraints.ipady = 0;
constraints.gridwidth = 3;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 2;
contentPane.add(optionPanel, constraints);
// Grid bag constraints 4.
constraints.insets = new Insets(20,0,0,0);
constraints.ipadx = 0;
constraints.ipady = 0;
constraints.gridwidth = 3;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 3;
contentPane.add(settingsLabel, constraints);
// Grid bag constraints 5.
constraints.insets = new Insets(10,10,0,0);
constraints.ipadx = 120;
constraints.ipady = 20;
constraints.gridwidth = 1;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 4;
contentPane.add(investAmount, constraints);
// Grid bag constraints 6.
constraints.insets = new Insets(10,0,0,0);
constraints.ipadx = 120;
constraints.ipady = 20;
constraints.gridwidth = 1;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 1;
constraints.gridy = 4;
contentPane.add(investTerm, constraints);
// Grid bag constraints 7.
constraints.insets = new Insets(10,0,0,0);
constraints.ipadx = 120;
constraints.ipady = 20;
constraints.gridwidth = 1;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 2;
constraints.gridy = 4;
contentPane.add(depositAmount, constraints);
// Grid bag constraints 8.
constraints.insets = new Insets(10,10,0,0);
constraints.ipadx = 120;
constraints.ipady = 20;
constraints.gridwidth = 1;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 5;
contentPane.add(investGoal, constraints);
// Grid bag constraints 9.
constraints.insets = new Insets(10,0,0,0);
constraints.ipadx = 120;
constraints.ipady = 20;
constraints.gridwidth = 1;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 1;
constraints.gridy = 5;
contentPane.add(interestRate, constraints);
// Grid bag constraints 10.
constraints.insets = new Insets(10,0,0,0);
constraints.ipadx = 0;
constraints.ipady = 1;
constraints.gridwidth = 1;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 2;
constraints.gridy = 5;
contentPane.add(frequencyContainer, constraints);
// Grid bag constraints 11.
constraints.insets = new Insets(20,0,0,0);
constraints.ipadx = 0;
constraints.ipady = 0;
constraints.gridwidth = 3;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 6;
contentPane.add(displayLabel, constraints);
// Grid bag constraints 12.
constraints.insets = new Insets(10,10,0,0);
constraints.ipadx = 0;
constraints.ipady = 0;
constraints.gridwidth = 3;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridx = 0;
constraints.gridy = 7;
contentPane.add(resultDisplay, constraints);
// Grid bag constraints 13.
constraints.anchor = GridBagConstraints.PAGE_END;
constraints.insets = new Insets(10,10,10,0);
constraints.ipadx = 0;
constraints.ipady = 0;
constraints.gridwidth = 3;
constraints.weightx = 0;
constraints.weighty = 1;
constraints.gridx = 0;
constraints.gridy = 8;
contentPane.add(buttonPanel, constraints);
}
//*************************************** END INITIALISATION CODE ***************************************//
//************************************* START INTERFACE EVENT CODE **************************************//
private class OptionLineListener
implements ActionListener
{
/**
* Listen to input line record selection.
* @param args
*/
private OptionLineListener(int args)
{
optionRadio = args;
}
public void actionPerformed(ActionEvent event)
{
clearSettings();
switch (optionRadio)
{
case 0:
optionDisplay.setText(" Return the future value on an investment");
investAmount.setEnabled(true); depositAmount.setEnabled(true);
investGoal.setEnabled(false); investTerm.setEnabled(true);
break;
case 1:
optionDisplay.setText(" Return the required deposit amount to reach an investment goal");
investAmount.setEnabled(true); investTerm.setEnabled(true);
depositAmount.setEnabled(false); investGoal.setEnabled(true);
break;
case 2:
optionDisplay.setText(" Return the required investment term to reach an investment goal");
investAmount.setEnabled(true); depositAmount.setEnabled(true);
investTerm.setEnabled(false); investGoal.setEnabled(true);
break;
case 3:
optionDisplay.setText(" Return the initial investment amount");
depositAmount.setEnabled(true); investTerm.setEnabled(true);
investGoal.setEnabled(true); investAmount.setEnabled(false);
break;
case 4:
optionDisplay.setText(" Return the accumulated interest earned on an investment");
depositAmount.setEnabled(false); investTerm.setEnabled(true);
investGoal.setEnabled(false); investAmount.setEnabled(true);
break;
default:
optionDisplay.setText(" Selection not valid");
break;
}
}
int optionRadio;
}
private class CalculateButtonListener
implements ActionListener
{
private static final double CONVERSION = 0.01;
/**
* Listener to calculate result.
* ESCA-JAVA0266
*/
public void actionPerformed(ActionEvent event)
{
resultDisplay.setText("\n");
DecimalFormat places = new DecimalFormat("#.##");
try
{
double iRate = Double.parseDouble(interestRate.getText()) * CONVERSION;
String dFrequency = (String)frequencyBox.getSelectedItem();
if (options[0].isSelected())
{
int iTerm = Integer.parseInt(investTerm.getText());
double dAmount = Double.parseDouble(depositAmount.getText());
double iAmount = Double.parseDouble(investAmount.getText());
interestCalculator.futureAmount(iAmount, iRate, dAmount, iTerm, dFrequency);
if (interestCalculator.getValue() > 0)
{
resultDisplay.append
(
" The future value on this investment is " + "\n\n" +
" $ " + Double.valueOf(places.format(interestCalculator.getValue())) + "\n"
);
}
}
else if (options[1].isSelected())
{
int iTerm = Integer.parseInt(investTerm.getText());
double iAmount = Double.parseDouble(investAmount.getText());
double iGoal = Double.parseDouble(investGoal.getText());
interestCalculator.depositAmount(iGoal, iAmount, iRate, iTerm, dFrequency);
resultDisplay.append
(
" The " + dFrequency.toLowerCase() +
" deposit amount should be " + "\n\n" + " $ " +
Double.valueOf(places.format(interestCalculator.getValue())) + "\n"
);
}
else if (options[2].isSelected())
{
double iAmount = Double.parseDouble(investAmount.getText());
double dAmount = Double.parseDouble(depositAmount.getText());
double iGoal = Double.parseDouble(investGoal.getText());
interestCalculator.investTerm(iGoal, iAmount, iRate, dAmount, dFrequency);
if ((int)interestCalculator.getValue() != (int)interestCalculator.getTermination())
{
resultDisplay.append
(
" The total number of " + dFrequency.toLowerCase() +
" deposits required is " + "\n\n" + " " +
(int)(Math.ceil(interestCalculator.getValue())) + "\n"
);
}
else
{
resultDisplay.append(" The calculated term of this investment is too long." + "\n");
}
}
else if (options[3].isSelected())
{
int iTerm = Integer.parseInt(investTerm.getText());
double dAmount = Double.parseDouble(depositAmount.getText());
double iGoal = Double.parseDouble(investGoal.getText());
interestCalculator.investAmount(iGoal, iRate, dAmount, iTerm, dFrequency);
resultDisplay.append
(
" The original investment amount deposited is " + "\n\n" +
" $ " + Double.valueOf(places.format(interestCalculator.getValue())) + "\n"
);
}
else if (options[4].isSelected())
{
int iTerm = Integer.parseInt(investTerm.getText());
double iAmount = Double.parseDouble(investAmount.getText());
interestCalculator.interestAmount(iAmount, iRate, iTerm, dFrequency);
resultDisplay.append
(
" The interest earned on this investment is " + "\n\n" +
" $ " + Double.valueOf(places.format(interestCalculator.getValue())) + "\n"
);
}
}
catch (NumberFormatException e)
{
System.out.println(Tools.thisPathAndLine() + e + "\n");
clearSettings();
}
}
}
private class ClearButtonListener
implements ActionListener
{
/**
* Listener to calculate result.
* ESCA-JAVA0266
*/
public void actionPerformed(ActionEvent event)
{
clearSettings();
}
}
/**
* Overrides ComponentListener.
*/
public void componentMoved(ComponentEvent e) {}
public void componentResized(ComponentEvent e) {}
public void componentShown(ComponentEvent e) {setContentDisplay(true);}
public void componentHidden(ComponentEvent e) {setContentDisplay(false);}
//************************************** END INTERFACE EVENT CODE ***************************************//
//**************************************** START PUBLIC METHODS *****************************************//
/**
* Sets the visibility of the frame.
*/
public void setVisibility()
{
if (isVisible)
{
frame.setVisible(true);
}
else
{
frame.setVisible(false);
}
}
/**
* Displays or Hides contents of GUI.
* @param shown
*/
public void setContentDisplay(boolean shown)
{
contentPane.setVisible(shown);
}
//***************************************** END PUBLIC METHODS ******************************************//
//**************************************** START PRIVATE METHODS ****************************************//
/**
* Sets the loan options.
*/
private void setOptions()
{
ButtonGroup select = new ButtonGroup();
options = new JRadioButton[OPTION_LENGTH];
for (int i = 0; i < OPTION_LENGTH; i ++)
{
options[i] = new JRadioButton("Option " + (i + 1), false);
options[i].setIcon(new ImageIcon(this.getClass().getResource
(
"files/images/RadioButtonNormalUnselected.png"))
);
options[i].setSelectedIcon(new ImageIcon(this.getClass().getResource
(
"files/images/RadioButtonNormalSelected.png"))
);
options[i].setDisabledIcon(new ImageIcon(this.getClass().getResource
(
"files/images/RadioButtonDisabledUnselected.png"))
);
options[i].setDisabledSelectedIcon(new ImageIcon(this.getClass().getResource
(
"files/images/RadioButtonDisabledSelected.png"))
);
options[i].setFocusPainted(false);
select.add(options[i]); optionPanel.add(options[i]);
options[i].addActionListener(new OptionLineListener(i));
}
}
/**
* Clears the input fields and display.
*/
private void clearSettings()
{
investAmount.setText(""); investTerm.setText(""); depositAmount.setText("");
interestRate.setText(""); investGoal.setText(""); resultDisplay.setText("");
}
/**
* Window resize event.
*/
private void includeResizeEvent()
{
this.addComponentListener
(
new ComponentAdapter()
{
public void componentResized(ComponentEvent e)
{
appletDisplayHandler();
}
}
);
}
/**
* Controls the JApplet component visibility.
* ESCA-JAVA0266:
*/
private void appletDisplayHandler()
{
final String ZOOM_WARNING =
"It appears that web pages in your browser are zoomed out. \n\n" +
"In order to display the applet, your browser needs to be set \n" +
"at its default zoom level of 100% or greater. \n\n" +
"Sorry about that.";
if ((getWidth() < FRAME_SIZE_X) || (getHeight() < FRAME_SIZE_Y))
{
contentPane.setVisible(false);
if (!zoomWarningShown)
{
Message.showMessage(ZOOM_WARNING, "Browser zoom setting", "warning");
zoomWarningShown = true;
}
}
else
{
contentPane.setVisible(true);
}
}
//***************************************** END PRIVATE METHODS *****************************************//
//********************************************** START MAIN *********************************************//
/**
* Main
* @param a
*/
public static void main(String[] a)
{
isApplication = true;
isVisible = true;
new InterestCalculatorGui();
}
//*********************************************** END MAIN **********************************************//
/**
* ESCA-JAVA0007:
*/
public JFrame frame;
private Container contentPane;
private JRadioButton[] options;
private boolean zoomWarningShown;
private JButton calculate, clear;
private JComboBox frequencyBox;
private GridBagConstraints constraints;
private InterestCalculator interestCalculator;
private JTextArea optionDisplay, resultDisplay;
private JLabel optionLabel, settingsLabel, displayLabel;
private JPanel optionPanel, frequencyContainer, buttonPanel;
private JTextField investAmount, investTerm, depositAmount, interestRate, investGoal;
private String[] frequencyChoices = { "Daily", "Yearly", "Weekly", "Monthly", "Fortnightly"};
//********************************************** END CLASS **********************************************//
}
/*
COPYRIGHT (C) 2010 - 2013 by Alexander Wait. All Rights Reserved.
This class calculates interest queries given a starting amount,
installments, frequency, term and yearly interest rate.
@site http://www.javaika.com
@author Alexander Wait
@version 2012-09-15
*/
public class InterestCalculator
{
private static final double TERMINATE = 50000;
/**
* ESCA-JAVA0057:
*/
public InterestCalculator() {}
//**************************************** START PUBLIC METHODS *****************************************//
/**
* Returns the final amount after the investment.
* @param investAmount
* @param interestRate
* @param depositAmount
* @param investTerm
* @param deposits
*/
public void futureAmount(double investAmount,
double interestRate, double depositAmount, int investTerm, String deposits)
{
if (interestRate <= 0)
{
value = investAmount + (depositAmount * investTerm);
}
else
{
double formulaFactor = Math.pow(1 + getCorrectedRate(interestRate, deposits), investTerm);
value = (investAmount * formulaFactor) +
((depositAmount / getCorrectedRate(interestRate, deposits)) * (formulaFactor - 1));
}
}
/**
* Returns the investment deposit amount.
* @param futureAmount
* @param investAmount
* @param interestRate
* @param investTerm
* @param deposits
*/
public void depositAmount(double futureAmount,
double investAmount, double interestRate, int investTerm, String deposits)
{
if (interestRate <= 0)
{
value = (futureAmount - investAmount) / investTerm;
}
else
{
double formulaFactor = Math.pow(1 + getCorrectedRate(interestRate, deposits), investTerm);
value = ((futureAmount - investAmount * formulaFactor) *
getCorrectedRate(interestRate, deposits)) / (formulaFactor - 1);
}
}
/**
* Returns the investment duration to meet a target.
* @param futureAmount
* @param investAmount
* @param interestRate
* @param depositAmount
* @param deposits
*/
public void investTerm(double futureAmount,
double investAmount, double interestRate, double depositAmount, String deposits)
{
if (interestRate <= 0)
{
value = (futureAmount - investAmount) / depositAmount;
}
else
{
value = 0;
while(value < TERMINATE)
{
double formulaFactor = Math.pow(1 + getCorrectedRate(interestRate, deposits), value);
double current = (investAmount * formulaFactor) +
((depositAmount / getCorrectedRate(interestRate, deposits)) * (formulaFactor - 1));
if (current > futureAmount) {break;}
else {value ++;}
}
}
}
/**
* Returns the original investment amount.
* @param futureAmount
* @param interestRate
* @param depositAmount
* @param investTerm
* @param deposits
*/
public void investAmount(double futureAmount,
double interestRate, double depositAmount, int investTerm, String deposits)
{
if (interestRate <= 0)
{
value = futureAmount - (depositAmount * investTerm);
}
else
{
double formulaFactor = Math.pow(1 + getCorrectedRate(interestRate, deposits), investTerm);
value = (futureAmount - (depositAmount / getCorrectedRate(interestRate, deposits)) *
(formulaFactor - 1)) / formulaFactor;
}
}
/**
* Returns the interest amount.
* @param investAmount
* @param interestRate
* @param investTerm
* @param deposits
*/
public void interestAmount(double investAmount,
double interestRate, int investTerm, String deposits)
{
if (interestRate <= 0)
{
value = 0;
}
else
{
value = investTerm * (getCorrectedRate(interestRate, deposits) * investAmount) /
(1 - Math.pow(1 + getCorrectedRate(interestRate, deposits), -investTerm)) - investAmount;
}
}
/**
* Returns the loan query value.
* @return
*/
public double getValue() {return value;}
/**
* Returns the termination cycles.
* @return
*/
public double getTermination()
{
return TERMINATE;
}
//***************************************** END PUBLIC METHODS ******************************************//
//**************************************** START PRIVATE METHODS ****************************************//
/**
* Corrects the interest rate value depending on repay frequency.
* @param rate
* @param repayments
* @return
*/
private static double getCorrectedRate(double rate, String repayments)
{
double interest = 0;
if (repayments.equals("Yearly")) {interest = rate;}
if (repayments.equals("Daily")) {interest = (rate / DateAndTime.getDaysNormalYear());}
if (repayments.equals("Weekly")) {interest = (rate / DateAndTime.getWeeksInYear());}
if (repayments.equals("Monthly")) {interest = (rate / DateAndTime.getMonthsInYear());}
if (repayments.equals("Fortnightly")) {interest = (rate / DateAndTime.getFortnightsInYear());}
return interest;
}
//***************************************** END PRIVATE METHODS *****************************************//
private double value;
//********************************************** END CLASS **********************************************//
}
/*
COPYRIGHT (C) 2010 -2013 by Alexander Wait. All Rights Reserved.
This class defines colors and color methods.
@site http://www.javaika.com
@author Alexander Wait
@version 2012-05-18
*/
public class ColorFunctions
{
private static final int HEXADECIMAL_BASE = 16;
private static final int COLOR_COMPONENT_RED = 250;
private static final int COLOR_COMPONENT_GREEN = 250;
private static final int COLOR_COMPONENT_BLUE = 250;
private ColorFunctions() {}
//**************************************** START PUBLIC METHODS *****************************************//
/**
* Returns the color in hexadecimal format.
* @param sliderValue
* @return
*/
public static String returnHexadecimalColor(int sliderValue)
{
String compFirst = ""; String compSecond = ""; int counter = -1;
for (int i = 0; i < HEXADECIMAL_BASE; i ++)
{
compFirst = returnComponent(i);
for (int j = 0; j < HEXADECIMAL_BASE; j ++)
{
compSecond = returnComponent(j); counter ++;
if (counter == sliderValue)
{
break;
}
}
if (counter == sliderValue)
{
break;
}
}
return
(
"#" + compFirst + compSecond + compFirst +
compSecond + compFirst + compSecond
);
}
/**
* Return the set red color component
* for setting the programs background color.
* @return
*/
public static int red()
{
return COLOR_COMPONENT_RED;
}
/**
* Return the set green color component
* for setting the programs background color.
* @return
*/
public static int green()
{
return COLOR_COMPONENT_GREEN;
}
/**
* Return the set blue color component
* for setting the programs background color.
* @return
*/
public static int blue()
{
return COLOR_COMPONENT_BLUE;
}
//***************************************** END PUBLIC METHODS ******************************************//
//**************************************** START PRIVATE METHODS ****************************************//
/**
* Returns the hexadecimal component.
* ESCA-JAVA0076:
* @param index
* @return
*/
private static String returnComponent(int index)
{
String component = "";
switch (index)
{
case 10: component = "A"; break; case 11: component = "B"; break;
case 12: component = "C"; break; case 13: component = "D"; break;
case 14: component = "E"; break; case 15: component = "F"; break;
default: component = Integer.toString(index); break;
}
return component;
}
//***************************************** END PRIVATE METHODS *****************************************//
//********************************************** END CLASS **********************************************//
}
/*
COPYRIGHT (C) 2010 -2013 by Alexander Wait. All Rights Reserved.
This class returns date and time and provides functions relating to time.
@site http://www.javaika.com
@author Alexander Wait
@version 2012-04-18
*/
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.GregorianCalendar;
public class DateAndTime
{
private static final int DAY_INDEX = 2;
private static final int MONTH_INDEX = 1;
private static final int YEAR_INDEX = 0;
private static final int MILLISECONDS_PER_SECOND = 1000;
private static final int SECONDS_PER_MINUTE = 60;
private static final int MINUTES_PER_HOUR = 60;
private static final int HOURS_PER_DAY = 24;
private static final int DAYS_IN_WEEK = 7;
private static final int DAYS_IN_YEAR = 365;
private static final int WEEKS_IN_YEAR = 52;
private static final int MONTHS_IN_YEAR = 12;
private static final int FORTNIGHTS_IN_YEAR = 26;
private static Calendar now = Calendar.getInstance();
public static enum Elements {YEAR, MONTH, DAY}
private DateAndTime() {}
//**************************************** START PUBLIC METHODS *****************************************//
/**
* Tests and compares two dates.
* @param dateFirst
* @param dateSecond
* @return
*/
public static boolean dateComparison(String dateFirst, String dateSecond)
{
String[] first = dateFirst.split("[-]", 0);
String[] second = dateSecond.split("[-]", 0);
int firstDayInt = Integer.parseInt(first[DAY_INDEX]);
int firstMonthInt = Integer.parseInt(first[MONTH_INDEX]);
int firstYearInt = Integer.parseInt(first[YEAR_INDEX]);
int secondDayInt = Integer.parseInt(second[DAY_INDEX]);
int secondMonthInt = Integer.parseInt(second[MONTH_INDEX]);
int secondYearInt = Integer.parseInt(second[YEAR_INDEX]);
return
compareDates(firstDayInt, firstMonthInt,
firstYearInt, secondDayInt, secondMonthInt, secondYearInt);
}
/**
* Compares two dates to test if one date is more current than the other.
* @param fstDay
* @param fstMonth
* @param fstYear
* @param sndDay
* @param sndMonth
* @param sndYear
* @return
*/
public static boolean compareDates(int fstDay, int fstMonth,
int fstYear, int sndDay, int sndMonth, int sndYear)
{
if (sndYear > fstYear) {return true;}
else if (sndYear < fstYear) {return false;}
else
{
if (sndMonth > fstMonth) {return true;}
else if (sndMonth < fstMonth) {return false;}
else
{
if (sndDay >= fstDay) {return true;}
else {return false;}
}
}
}
/**
* Returns true if the time given is before current time.
* @param hour
* @param minute
* @param second
* @return
*/
public static boolean isBeforeCurrentTime(int hour, int minute, int second)
{
if (returnHour() > hour) {return true;}
else if (returnHour() < hour) {return false;}
else
{
if (returnMinute() > minute) {return true;}
else if (returnMinute() < minute) {return false;}
else
{
if (returnSecond() > second) {return true;}
else {return false;}
}
}
}
/**
* Returns true if the time to be tested is after the reference.
* @param hour
* @param minute
* @param second
* @param testHour
* @param testMinute
* @param testSecond
* @return
*/
public static boolean isAfterReferenceTime(int hour, int minute,
int second, int testHour, int testMinute, int testSecond)
{
if (hour < testHour) {return true;}
else if (hour > testHour) {return false;}
else
{
if (minute < testMinute) {return true;}
else if (minute > testMinute) {return false;}
else
{
if (second < testSecond) {return true;}
else {return false;}
}
}
}
/**
* Finds the difference between two times in hours.
* @param startHour
* @param startMinute
* @param endHour
* @param endMinute
* @return
*/
public static double timeDifferenceHours(int startHour,
int startMinute, int endHour, int endMinute)
{
double endMinutes = endHour * MINUTES_PER_HOUR + endMinute;
double startMinutes = startHour * MINUTES_PER_HOUR + startMinute;
return ((endMinutes - startMinutes) / MINUTES_PER_HOUR);
}
/**
* Returns true if a specified time is within one of a list of ranges.
* @param startHour
* @param startMinute
* @param startSecond
* @param finishHour
* @param finishMinute
* @param finishSecond
* @param hour
* @param minute
* @param second
* @param length
* @return
*/
public static boolean isOverlapped(ArrayList startHour,
ArrayList startMinute, ArrayList startSecond,
ArrayList finishHour, ArrayList finishMinute,
ArrayList finishSecond, int hour, int minute,
int second, int length)
{
boolean overlapped = false;
for (int i = 0; i < length; i ++)
{
if (isAfterReferenceTime
(startHour.get(i), startMinute.get(i),
startSecond.get(i), hour, minute, second)
&& (!isAfterReferenceTime
(finishHour.get(i), finishMinute.get(i),
finishSecond.get(i), hour, minute, second)))
{
overlapped = true;
}
}
return overlapped;
}
/**
* Tests if a year is a leap year.
* @param year
* @return
*/
public static boolean isLeapYear(int year)
{
boolean leapYear = false;
final int LEAP_DIVISOR_SHORT = 4;
final int LEAP_DIVISOR_MIDDLE = 100;
final int LEAP_DIVISOR_LONG = 400;
if ((year % LEAP_DIVISOR_SHORT) == 0)
{
if ((year % LEAP_DIVISOR_MIDDLE) != 0)
{
leapYear = true;
}
if (((year % LEAP_DIVISOR_MIDDLE) == 0)
&& ((year % LEAP_DIVISOR_LONG) == 0))
{
leapYear = true;
}
}
return leapYear;
}
/**
* Returns todays date.
* @param includeTimeMask
* @return
*/
public static String returnTodaysDate(boolean includeTimeMask)
{
refreshCalendar(); now.getTime();
String todaysDate = ""; String timeMask = "00:00:00";
SimpleDateFormat date = new SimpleDateFormat("YYYY-MM-dd");
if (includeTimeMask)
{
todaysDate = date.format(now.getTime()) + " " + timeMask;
}
else
{
todaysDate = date.format(now.getTime());
}
return todaysDate;
}
/**
* Returns a specific element of a date string.
* @param date
* @param component
* @return
*/
public static String returnSplitDate(String date, Elements component)
{
String element = null;
String[] elementArray = date.split("-");
if (component.equals(Elements.YEAR))
{
element = elementArray[0];
}
if (component.equals(Elements.MONTH))
{
element = elementArray[1];
}
if (component.equals(Elements.DAY))
{
element = elementArray[2];
}
return element;
}
/**
* Returns the name of a month expressed as an integer.
* ESCA-JAVA0076:
* @param month
* @return
*/
public static String returnMonthName(int month)
{
String monthName = null;
switch (month)
{
case 1: monthName = "January"; break;
case 2: monthName = "February"; break;
case 3: monthName = "March"; break;
case 4: monthName = "April"; break;
case 5: monthName = "May"; break;
case 6: monthName = "June"; break;
case 7: monthName = "July"; break;
case 8: monthName = "August"; break;
case 9: monthName = "September"; break;
case 10: monthName = "October"; break;
case 11: monthName = "November"; break;
case 12: monthName = "December"; break;
default: monthName = "Invalid Input"; break;
}
return monthName;
}
/**
* Returns a list of dates.
* @param year
* @param heading
* @return
*/
public static String[] returnDateList(int year, String heading)
{
ArrayList list = new ArrayList();
if (heading != null) {list.add(heading);}
for (int i = 1; i <= MONTHS_IN_YEAR; i ++)
{
int bound = returndaysInMonth(i);
if (isLeapYear(year) && (i == 2)) {bound ++;}
for (int j = 1; j <= bound; j ++)
{
list.add(year + "-" + returnDigitMask(i, 2) + "-" + returnDigitMask(j, 2));
}
}
String[] dates = new String[list.size()];
list.toArray(dates);
return dates;
}
/**
* Returns the days of a specified month.
* ESCA-JAVA0076:
* @param month
* @return
*/
public static int returndaysInMonth(int month)
{
int days = -1; final int SHORT = 28;
final int MIDDLE = 30; final int LONG = 31;
switch (month)
{
case 1: days = (LONG); break; case 2: days = (SHORT); break;
case 3: days = (LONG); break; case 4: days = (MIDDLE); break;
case 5: days = (LONG); break; case 6: days = (MIDDLE); break;
case 7: days = (LONG); break; case 8: days = (LONG); break;
case 9: days = (MIDDLE); break; case 10: days = (LONG); break;
case 11: days = (MIDDLE); break; case 12: days = (LONG); break;
default: return days;
}
return days;
}
/**
* Converts an integer to a mask.
* ESCA-JAVA0076:
* @param value
* @param maxValueLength
* @return
*/
public static String returnDigitMask(int value, int maxValueLength)
{
String digit = Integer.toString(value); String trailing = "";
if (digit.length() == maxValueLength)
{
return digit;
}
else
{
for (int i = digit.length(); i < maxValueLength; i ++)
{
trailing += "0";
}
return (trailing + digit);
}
}
/**
* Returns the seconds elapsed in counter format (HH:MM:SS).
* @param counter
* @param millisecondCount
* @return
*/
public static String returnCounterTime(long counter, boolean millisecondCount)
{
String counterTime = "";
setCounterHours((short)0); setCounterMinutes((short)0);
setCounterSeconds((short)0); setCounterMilliseconds((short)0);
final int DIGIT_LENGTH = 2; final double MILLIS_DIVISOR = 100;
for (int i = 0; i < counter; i ++)
{
if (millisecondCount) {counterMilliseconds ++;}
else {counterSeconds ++;}
if (counterMilliseconds == MILLISECONDS_PER_SECOND)
{setCounterMilliseconds((short)0); counterSeconds ++;}
if (counterSeconds == SECONDS_PER_MINUTE)
{setCounterSeconds((short)0); counterMinutes ++;}
if (counterMinutes == MINUTES_PER_HOUR)
{setCounterMinutes((short)0); counterHours ++;}
}
if (millisecondCount)
{
counterTime = ":" + (int)Math.floor(getCounterMilliseconds() / MILLIS_DIVISOR);
}
counterTime =
(
returnDigitMask(getCounterHours(), DIGIT_LENGTH) + ":" +
returnDigitMask(getCounterMinutes(), DIGIT_LENGTH) + ":" +
returnDigitMask(getCounterSeconds(), DIGIT_LENGTH) + counterTime
);
return counterTime;
}
/**
* Returns the formatted time (24 hour or standard)
* @param twentyFourHour
* @return
*/
public static String returnFormattedTime(boolean twentyFourHour)
{
refreshCalendar(); String time = "";
DateFormat full = new SimpleDateFormat("HH:mm:ss");
DateFormat standard = new SimpleDateFormat("h:mm:ss");
if (twentyFourHour) {time = full.format(now.getTime());}
else {time = standard.format(now.getTime());}
return time;
}
/**
* Returns the day at the start of the given year.
* ESCA-JAVA0076:
* @param year
* @return
*/
public static int returnStartDayAsInt(int year)
{
Calendar cal = new GregorianCalendar(year, Calendar.JANUARY, 1);
return (cal.get(Calendar.DAY_OF_WEEK));
}
/**
* Returns the day at the start of the given year.
* ESCA-JAVA0076:
* @param year
* @return
*/
public static int returnEndDayAsInt(int year)
{
Calendar cal = new GregorianCalendar(year, Calendar.DECEMBER, 31);
return (cal.get(Calendar.DAY_OF_WEEK));
}
/**
* Returns the specific day of week as an integer.
* 1 = Sunday, 2 = Monday, 3 = Tuesday ...
* ESCA-JAVA0076:
* @param year
* @param month
* @param day
* @return
*/
public static int returnDayOfWeekAsInt(int year, int month, int day)
{
Calendar cal = null;
switch (month)
{
case 1: cal = new GregorianCalendar(year, Calendar.JANUARY, day); break;
case 2: cal = new GregorianCalendar(year, Calendar.FEBRUARY, day); break;
case 3: cal = new GregorianCalendar(year, Calendar.MARCH, day); break;
case 4: cal = new GregorianCalendar(year, Calendar.APRIL, day); break;
case 5: cal = new GregorianCalendar(year, Calendar.MAY, day); break;
case 6: cal = new GregorianCalendar(year, Calendar.JUNE, day); break;
case 7: cal = new GregorianCalendar(year, Calendar.JULY, day); break;
case 8: cal = new GregorianCalendar(year, Calendar.AUGUST, day); break;
case 9: cal = new GregorianCalendar(year, Calendar.SEPTEMBER, day); break;
case 10: cal = new GregorianCalendar(year, Calendar.OCTOBER, day); break;
case 11: cal = new GregorianCalendar(year, Calendar.NOVEMBER, day); break;
case 12: cal = new GregorianCalendar(year, Calendar.DECEMBER, day); break;
default: return (-1);
}
return (cal.get(Calendar.DAY_OF_WEEK));
}
/**
* Returns a list of years between the given
* parameter and the current year.
* @param year
* @return
*/
public static String[] returnYearChoices(int year)
{
int difference = Math.abs(returnYear() - year);
String[] choices = new String[difference +1];
if (year < returnYear())
{
for (int i = 0; i <= difference; i ++)
{
choices[i] = Integer.toString(year + i);
}
}
if (year > returnYear())
{
for (int i = 0; i <= difference; i ++)
{
choices[i] = Integer.toString(returnYear() + i);
}
}
return choices;
}
/**
* Returns a list for seconds.
* @return
*/
public static String[] returnSecondChoices()
{
String[] secondList = new String[SECONDS_PER_MINUTE];
for (int i = 0; i < SECONDS_PER_MINUTE; i ++)
{
secondList[i] = Integer.toString(i);
}
return secondList;
}
/**
* Returns a list for minutes.
* @return
*/
public static String[] returnMinuteChoices()
{
String[] minuteList = new String[MINUTES_PER_HOUR];
for (int i = 0; i < MINUTES_PER_HOUR; i ++)
{
minuteList[i] = Integer.toString(i);
}
return minuteList;
}
/**
* Returns a list for hours.
* @return
*/
public static String[] returnHourChoices()
{
String[] hourList = new String[HOURS_PER_DAY];
for (int i = 0; i < HOURS_PER_DAY; i ++)
{
hourList[i] = Integer.toString(i);
}
return hourList;
}
/**
* Returns the current year.
* @return
*/
public static int returnYear()
{
refreshCalendar();
return (now.get(Calendar.YEAR));
}
/**
* Returns the current year.
* @return
*/
public static int returnMonth()
{
refreshCalendar();
return (now.get(Calendar.MONTH) + 1);
}
/**
* Returns the current year.
* @return
*/
public static int returnDay()
{
refreshCalendar();
return (now.get(Calendar.DATE));
}
/**
* Returns the hour in double digits.
* @return
*/
public static String returnHourDouble()
{
return returnDigitMask(returnHour(), 2);
}
/**
* Returns the minute in double digits.
* @return
*/
public static String returnMinuteDouble()
{
return returnDigitMask(returnMinute(), 2);
}
/**
* Returns the second in double digits.
* @return
*/
public static String returnSecondDouble()
{
return returnDigitMask(returnSecond(), 2);
}
/**
* Returns the hour.
* @return
*/
public static int returnHour()
{
refreshCalendar();
DateFormat hours = new SimpleDateFormat("HH");
return (Integer.parseInt(hours.format(now.getTime())));
}
/**
* Returns the minutes.
* @return
*/
public static int returnMinute()
{
refreshCalendar();
DateFormat minutes = new SimpleDateFormat("mm");
return (Integer.parseInt(minutes.format(now.getTime())));
}
/**
* Returns the seconds.
* @return
*/
public static int returnSecond()
{
refreshCalendar();
DateFormat seconds = new SimpleDateFormat("ss");
return (Integer.parseInt(seconds.format(now.getTime())));
}
/**
* Returns the current stage of the day as AM or PM.
* @return
*/
public static String returnAmOrPm()
{
refreshCalendar();
DateFormat ampm = new SimpleDateFormat("a");
return (ampm.format(now.getTime()));
}
/**
* Returns the days in a year.
* @param year
* @return
*/
public static int returnDays(int year)
{
if (DateAndTime.isLeapYear(year))
{
return getDaysLeapYear();
}
else
{
return DateAndTime.getDaysNormalYear();
}
}
/**
* Refreshes the calendar.
*/
public static void refreshCalendar()
{
now = Calendar.getInstance();
}
/**
* Sets the counter hours.
* @param value
*/
public static void setCounterHours(short value) {counterHours = value;}
/**
* Sets the counter minutes.
* @param value
*/
public static void setCounterMinutes(short value) {counterMinutes = value;}
/**
* Sets the counter seconds.
* @param value
*/
public static void setCounterSeconds(short value) {counterSeconds = value;}
/**
* Sets the counter milliseconds.
* @param value
*/
public static void setCounterMilliseconds(short value) {counterMilliseconds = value;}
/**
* Returns the counter hours.
* @return
*/
public static short getCounterHours() {return counterHours;}
/**
* Returns the counter minutes.
* @return
*/
public static short getCounterMinutes() {return counterMinutes;}
/**
* Returns the counter seconds.
* @return
*/
public static short getCounterSeconds() {return counterSeconds;}
/**
* Returns the counter milliseconds.
* @return
*/
public static short getCounterMilliseconds() {return counterMilliseconds;}
/**
* Returns the days in a week.
* @return
*/
public static int getDaysInWeek() {return DAYS_IN_WEEK;}
/**
* Returns the days in a year.
* @return
*/
public static int getDaysNormalYear() {return DAYS_IN_YEAR;}
/**
* Returns the days in a year.
* @return
*/
public static int getDaysLeapYear() {return (DAYS_IN_YEAR + 1);}
/**
* Returns the weeks in a year.
* @return
*/
public static int getWeeksInYear() {return WEEKS_IN_YEAR;}
/**
* Returns the fort-nights in a year.
* @return
*/
public static int getFortnightsInYear() {return FORTNIGHTS_IN_YEAR;}
/**
* Returns the months in a year.
* @return
*/
public static int getMonthsInYear() {return MONTHS_IN_YEAR;}
/**
* Returns the seconds per minute.
* @return
*/
public static int getSecondsPerMinute() {return SECONDS_PER_MINUTE;}
/**
* Returns the seconds per minute.
* @return
*/
public static int getHoursPerWeek() {return HOURS_PER_DAY * DAYS_IN_WEEK;}
//***************************************** END PUBLIC METHODS ******************************************//
private static short counterHours, counterMinutes, counterSeconds, counterMilliseconds;
//********************************************** END CLASS **********************************************//
}
/*
COPYRIGHT (C) 2010 - 2013 by Alexander Wait. All Rights Reserved.
This class returns the domain attributes.
@site http://www.javaika.com
@author Alexander Wait
@version 2012-07-06
*/
public class Domain
{
private static final String DOMAIN = "javaika.com";
private static final boolean RUN_LOCAL = false;
private static final boolean prefix = true;
private static final String PORT = "80";
private Domain() {}
//**************************************** START PUBLIC METHODS *****************************************//
/**
* Returns the domain name.
* @return
*/
public static final String getDomain()
{
if (prefix)
{
return ("www." + DOMAIN);
}
else
{
return (DOMAIN);
}
}
/**
* Returns the port number.
* @return
*/
public static final String getPort()
{
if (RUN_LOCAL)
{
return (":" + PORT);
}
else {return ("");}
}
//***************************************** END PUBLIC METHODS ******************************************//
//********************************************** END CLASS **********************************************//
}
/*
COPYRIGHT (C) 2010 - 2013 by Alexander Wait. All Rights Reserved.
This class displays message dialogs.
@site http://www.javaika.com
@author Alexander Wait
@version 2011-07-18
*/
import javax.swing.*;
public class Message
{
private Message(){}
//**************************************** START PUBLIC METHODS *****************************************//
/**
* Displays a message dialog.
* @param text
* @param heading
* @param type
*/
public static void showMessage(String text, String heading, String type)
{
new JOptionPane(); Object[] options = {};
if (type.equals("error"))
{
JOptionPane.showOptionDialog(null, text, heading,
JOptionPane.YES_OPTION, JOptionPane.ERROR_MESSAGE, null, options, null);
}
if (type.equals("information"))
{
JOptionPane.showOptionDialog(null, text, heading,
JOptionPane.YES_OPTION, JOptionPane.INFORMATION_MESSAGE, null, options, null);
}
if (type.equals("warning"))
{
JOptionPane.showOptionDialog(null, text, heading,
JOptionPane.YES_OPTION, JOptionPane.WARNING_MESSAGE, null, options, null);
}
if (type.equals("question"))
{
JOptionPane.showOptionDialog(null, text, heading,
JOptionPane.YES_OPTION, JOptionPane.QUESTION_MESSAGE, null, options, null);
}
}
//***************************************** END PUBLIC METHODS ******************************************//
//********************************************** END CLASS **********************************************//
}
/*
COPYRIGHT (C) 2010 - 2013 by Alexander Wait. All Rights Reserved.
This class provides handy tools.
@site http://www.javaika.com
@author Alexander Wait
@version 2012-02-01
*/
public class Tools
{
private static final int EXCEPTION_LINE_BEAK = 2;
private Tools() {}
//**************************************** START PUBLIC METHODS *****************************************//
/**
* This method returns the line number and path where it's called.
* The syntax new Exception().getStackTrace()[0].getLineNumber()
* will only give the current line number of the source file.
* @return
*/
public static String thisPathAndLine()
{
String lineAndPath = ""; String stackTrace = "";
stackTrace = new Exception().getStackTrace()[1].toString();
for (int i = stackTrace.length()-1; i >= 0; i --)
{
if (stackTrace.charAt(i) == ')') {continue;}
else if (stackTrace.charAt(i) == '(') {break;}
else {lineAndPath = (stackTrace.charAt(i) + lineAndPath);}
}
return lineAndPath + returnNewline(EXCEPTION_LINE_BEAK);
}
/**
* Delays execution.
* @param length
*/
public static void delay(long length)
{
for (long i = 0; i < length; i ++) {}
}
/**
* This method returns a space.
* @param length
* @return
*/
public static String returnSpace(int length)
{
String space = "";
for (int i = 0; i < length; i ++)
{
space += " ";
}
return space;
}
/**
* Assigns newlines to a string.
* @param lines
* @return
*/
public static String returnNewline(int lines)
{
String newline = "";
for (int i = 0; i < lines; i++)
{
newline += "\n";
}
return newline;
}
/**
* Returns the users desktop path.
* @return
*/
public static String returnDesktopPath()
{
return (System.getProperty("user.home") + "/Desktop").replace("\\", "/") + "/";
}
//***************************************** END PUBLIC METHODS ******************************************//
//********************************************** END CLASS **********************************************//
}