Java/SWT JFace Eclipse/Calculator
Calculator by Michael Schmidt
/**
* Instances of this object class open a dialog with a simple calculator.
* The calculator includes a memory register, Tooltips for the keys, and error
* checking. It performs double precision calculations and includes square
* root and inverse functions. Other computations can be added easily.
* The code contains extensive comments.
* This class can be called via an Action from the menu or toolbar.
* Feel free to use this in your application!
*
* @author Michael Schmidt, 2006.
*/
//package mschmidt.komo;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.ruposite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
public class CalculatorMichaelSchmidt extends Dialog {
/*
* Initialize variables needed for this class.
*/
private Text displayText;
// The three calculator registers.
private String displayString = "0.";
private String memoryString = new String();
private String operatorString = new String();
// A variable to store the pending calculation
private char calcChar = " ";
// Error strings
private final String ERROR_STRING = "Error: ";
private final String NAN_STRING = "Not a Number";
private final String LONG_STRING = "Number too long";
private final String INFINITY_STRING = "Infinity";
// A flag to check if display should be cleared on the next keystroke
private boolean clearDisplay = true;
// An ID constant for the copy to clipboard key
private static final int CLIPBOARD_ID = IDialogConstants.NO_TO_ALL_ID + 1;
public static void main(String[] a){
new CalculatorMichaelSchmidt(new Shell(new Display()));
}
/*
* Standard constructor to create the dialog.
* @param parentShell the Dialog shell
*/
public CalculatorMichaelSchmidt(final Shell parentShell) {
super(parentShell);
}
/*
* Create contents of the dialog, a display at the top and the various
* buttons. The Tooltip for each button explains its function.
* @param parent the composite
* @return Control the controls
*/
@Override
protected Control createDialogArea(final Composite parent) {
Composite container = (Composite) super.createDialogArea(parent);
final GridLayout calculatorGridLayout = new GridLayout();
calculatorGridLayout.marginRight = 5;
calculatorGridLayout.marginLeft = 5;
calculatorGridLayout.marginBottom = 5;
calculatorGridLayout.marginTop = 5;
calculatorGridLayout.marginWidth = 10;
calculatorGridLayout.marginHeight = 2;
calculatorGridLayout.numColumns = 4;
calculatorGridLayout.verticalSpacing = 2;
calculatorGridLayout.makeColumnsEqualWidth = true;
calculatorGridLayout.horizontalSpacing = 2;
container.setLayout(calculatorGridLayout);
// The display. Note that it has a limit of 30 characters,
// much greater than the length of a double-precision number.
displayText = new Text(container, SWT.RIGHT | SWT.BORDER);
displayText.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_WHITE));
displayText.setEditable(false);
displayText.setDoubleClickEnabled(false);
displayText.setTextLimit(30);
displayText.setText(displayString);
displayText.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false, 4, 1));
final Button msButton = new Button(container, SWT.NONE);
msButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateMemory("S");
}
});
msButton.setToolTipText("Save value to Memory");
msButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
msButton.setText("MS");
final Button mcButton = new Button(container, SWT.NONE);
mcButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("D");
}
});
mcButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
mcButton.setToolTipText("Clear Memory");
mcButton.setText("MC");
final Button clearButton = new Button(container, SWT.NONE);
clearButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("C");
}
});
clearButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
clearButton.setToolTipText("Clear all Calculator Registers");
clearButton.setText("C");
final Button ceButton = new Button(container, SWT.NONE);
ceButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("E");
}
});
ceButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
ceButton.setToolTipText("Clear Entry");
ceButton.setText("CE");
final Button memAddButton = new Button(container, SWT.NONE);
memAddButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateMemory("+");
}
});
memAddButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
memAddButton.setToolTipText("Add value to Memory");
memAddButton.setText("M+");
final Button mrButton = new Button(container, SWT.NONE);
mrButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("R");
}
});
mrButton.setToolTipText("Recall value in Memory");
mrButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
mrButton.setText("MR");
final Button backButton = new Button(container, SWT.NONE);
backButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("B");
}
});
backButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
backButton.setToolTipText("Backspace");
backButton.setText("BACK");
final Button divideButton = new Button(container, SWT.NONE);
divideButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateCalc("/");
}
});
divideButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
divideButton.setToolTipText("Divide");
divideButton.setText("/");
final Button memSubtractButton = new Button(container, SWT.NONE);
memSubtractButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateMemory("-");
}
});
memSubtractButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
memSubtractButton.setToolTipText("Subtract value from Memory");
memSubtractButton.setText("M-");
final Button inverseButton = new Button(container, SWT.NONE);
inverseButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("I");
}
});
inverseButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
inverseButton.setToolTipText("Inverse of value");
inverseButton.setText("1/X");
final Button sqrtButton = new Button(container, SWT.NONE);
sqrtButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("Q");
}
});
sqrtButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
sqrtButton.setToolTipText("Square Root of value");
sqrtButton.setText("SQRT");
final Button multiplyButton = new Button(container, SWT.NONE);
multiplyButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateCalc("*");
}
});
multiplyButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
multiplyButton.setToolTipText("Multiply");
multiplyButton.setText("*");
final Button num7Button = new Button(container, SWT.NONE);
num7Button.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("7");
}
});
num7Button.setToolTipText("Numeric Pad");
num7Button.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
num7Button.setText("7");
final Button num8Button = new Button(container, SWT.NONE);
num8Button.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("8");
}
});
num8Button.setToolTipText("Numeric Pad");
num8Button.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
num8Button.setText("8");
final Button num9Button = new Button(container, SWT.NONE);
num9Button.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("9");
}
});
num9Button.setToolTipText("Numeric Pad");
num9Button.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
num9Button.setText("9");
final Button SubtractButton = new Button(container, SWT.NONE);
SubtractButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateCalc("-");
}
});
SubtractButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
SubtractButton.setToolTipText("Subtract");
SubtractButton.setText("-");
final Button num4Button = new Button(container, SWT.NONE);
num4Button.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("4");
}
});
num4Button.setToolTipText("Numeric Pad");
num4Button.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
num4Button.setText("4");
final Button num5Button = new Button(container, SWT.NONE);
num5Button.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("5");
}
});
num5Button.setToolTipText("Numeric Pad");
num5Button.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
num5Button.setText("5");
final Button num6Button = new Button(container, SWT.NONE);
num6Button.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("6");
}
});
num6Button.setToolTipText("Numeric Pad");
num6Button.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
num6Button.setText("6");
final Button AdditionButton = new Button(container, SWT.NONE);
AdditionButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateCalc("+");
}
});
AdditionButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
AdditionButton.setToolTipText("Add");
AdditionButton.setText("+");
final Button num1Button = new Button(container, SWT.NONE);
num1Button.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("1");
}
});
num1Button.setCapture(true);
num1Button.setToolTipText("Numeric Pad");
num1Button.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
num1Button.setText("1");
final Button num2Button = new Button(container, SWT.NONE);
num2Button.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("2");
}
});
num2Button.setToolTipText("Numeric Pad");
num2Button.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
num2Button.setText("2");
final Button num3Button = new Button(container, SWT.NONE);
num3Button.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("3");
}
});
num3Button.setToolTipText("Numeric Pad");
num3Button.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
num3Button.setText("3");
final Button equalsButton = new Button(container, SWT.NONE);
equalsButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateCalc("=");
}
});
equalsButton.setToolTipText("Equals (get result)");
equalsButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 1, 2));
equalsButton.setText("=");
final Button num0Button = new Button(container, SWT.NONE);
num0Button.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("0");
}
});
num0Button.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
num0Button.setToolTipText("Numeric Pad");
num0Button.setText("0");
final Button decimalButton = new Button(container, SWT.NONE);
decimalButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay(".");
}
});
decimalButton.setToolTipText("Numeric Pad");
decimalButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
decimalButton.setText(".");
final Button signButton = new Button(container, SWT.NONE);
signButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(final SelectionEvent e) {
updateDisplay("-");
}
});
signButton.setToolTipText("Change sign of value");
signButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
signButton.setText("+/-");
new Label(container, SWT.NONE);
//
return container;
}
/*
* Create contents of the button bar, including a button to copy the
* display to the system clipboard and a close button.
* @param parent
*/
@Override
protected void createButtonsForButtonBar(final Composite parent) {
createButton(parent, CLIPBOARD_ID, "Copy to Clipboard", false);
createButton(parent, IDialogConstants.CANCEL_ID,
IDialogConstants.CLOSE_LABEL, true);
}
/*
* Set the initial size of the dialog.
*/
@Override
protected Point getInitialSize() {
return new Point(260, 350);
}
/*
* Standard method to configure the shell.
*/
protected void configureShell(final Shell newShell) {
super.configureShell(newShell);
newShell.setText("Calculator");
// Include code here to set the window icon. The line here is a sample using the
// Eclipse plugin getImageDescriptor convenience method.
// newShell.setImage(KomoPlugin.getImageDescriptor(ApplicationImages.CALCULATOR_ICON).createImage());
}
/*
* (non-Javadoc)
* Method that copies contents of the display window to the clipboard when
* the Copy to Clipboard button is clicked.
* @see org.eclipse.jface.dialogs.Dialog#buttonPressed(int)
*/
@Override
protected void buttonPressed(final int buttonID) {
if (buttonID == CLIPBOARD_ID) {
displayText.selectAll();
displayText.copy();
displayText.clearSelection();
} else {
super.buttonPressed(buttonID);
}
}
/*
* This method updates the display text based on user input.
*/
private void updateDisplay(final char keyPressed) {
char keyVal = keyPressed;
String tempString = new String();
boolean doClear = false;
if (!clearDisplay) {
tempString = displayString;
}
switch (keyVal) {
case "B": // Backspace
if (tempString.length() < 2) {
tempString = "";
} else {
tempString = tempString.substring(0, tempString.length() - 1);
}
break;
case "C": // Clear
tempString = "0.";
operatorString = "";
calcChar = " ";
doClear = true;
break;
case "D": // Clear Memory
memoryString = "";
break;
case "E": // Clear Entry
tempString = "0.";
doClear = true;
break;
case "I": // Inverse
tempString = doCalc(displayString, "", keyVal);
doClear = true;
break;
case "Q": // Square Root
tempString = doCalc(displayString, "", keyVal);
doClear = true;
break;
case "R": // Recall Memory to Display
tempString = memoryString;
doClear = true;
break;
case "-": // Change Sign
if (tempString.startsWith("-")) {
tempString = tempString.substring(1, tempString.length());
} else {
tempString = keyVal + tempString;
}
break;
case ".": // Can"t have two decimal points.
if (tempString.indexOf(".") == -1 && tempString.length() < 29) {
tempString = tempString + keyVal;
}
break;
case "0": // Don"t want 00 to be entered.
if (!tempString.equals("0") && tempString.length() < 29) {
tempString = tempString + keyVal;
}
break;
default: // Default case is for the digits 1 through 9.
if (tempString.length() < 29) {
tempString = tempString + keyVal;
}
break;
}
clearDisplay = doClear;
if (!displayString.equals(tempString)) {
displayString = tempString;
displayText.setText(displayString);
}
}
/*
* This method updates the value stored in memory.
* The value is cleared in the updateDisplay method.
*/
private void updateMemory(final char keyPressed) {
char keyVal = keyPressed;
String tempString = new String();
switch (keyVal) {
case "S": // Save to Memory
tempString = trimString(displayString);
break;
case "+": // Add to Memory
if (memoryString.length() == 0) {
tempString = trimString(displayString);
} else {
tempString = doCalc(memoryString, displayString, "+");
}
break;
case "-": // Subtract from Memory
if (memoryString.length() == 0) {
if (displayString.startsWith("-")) {
tempString = displayString.substring(1, displayString.length());
tempString = trimString(tempString);
} else if (displayString.equals("0.0")
|| displayString.equals("0")
|| displayString.equals("0.")
|| displayString.equals("-0.0")) {
tempString = "0";
} else {
tempString = keyVal + displayString;
tempString = trimString(displayString);
}
} else {
tempString = doCalc(memoryString, displayString, "-");
}
break;
default: // Do nothing - this should never happen.
break;
}
// Do not save invalid entries to memory.
if (tempString.startsWith(ERROR_STRING)) {
if (!displayString.equals(tempString)) {
displayString = tempString;
displayText.setText(displayString);
}
} else {
memoryString = tempString;
}
clearDisplay = true;
}
/*
* This method converts the operator and display strings to double values
* and performs the calculation.
*/
private String doCalc(final String valAString, final String valBString,
final char opChar) {
String resultString = ERROR_STRING + NAN_STRING;
Double valA = 0.0;
Double valB = 0.0;
Double valAnswer = 0.0;
// Make sure register strings are numbers
if (valAString.length() > 0) {
try {
valA = Double.parseDouble(valAString);
} catch (NumberFormatException e) {
return resultString;
}
} else {
return resultString;
}
if (opChar != "Q" && opChar != "I") {
if (valBString.length() > 0) {
try {
valB = Double.parseDouble(valBString);
} catch (NumberFormatException e) {
return resultString;
}
} else {
return resultString;
}
}
switch (opChar) {
case "Q": // Square Root
valAnswer = Math.sqrt(valA);
break;
case "I": // Inverse
valB = 1.0;
valAnswer = valB/valA;
break;
case "+": // Addition
valAnswer = valA + valB;
break;
case "-": // Subtraction
valAnswer = valA - valB;
break;
case "/": // Division
valAnswer = valA/valB;
break;
case "*": // Multiplication
valAnswer = valA*valB;
break;
default: // Do nothing - this should never happen
break;
}
// Convert answer to string and format it before return.
resultString = valAnswer.toString();
resultString = trimString(resultString);
return resultString;
}
/*
* This method updates the operator and display strings, and the
* pending calculation flag.
*/
private void updateCalc(char keyPressed) {
char keyVal = keyPressed;
String tempString = displayString;
/*
* If there is no display value, the keystroke is deemed invalid and
* nothing is done.
*/
if (tempString.length() == 0) {
return;
}
/*
* If there is no operator value, only calculation key presses are
* considered valid. Check that the display value is valid and
* if so, move the display value to the operator. No calculation is done.
*/
if (operatorString.length() == 0) {
if (keyVal != "=") {
tempString = trimString(tempString);
if (tempString.startsWith(ERROR_STRING)) {
clearDisplay = true;
operatorString = "";
calcChar = " ";
} else {
operatorString = tempString;
calcChar = keyVal;
clearDisplay = true;
}
}
return;
}
// There is an operator and a display value, so do the calculation.
displayString = doCalc(operatorString, tempString, calcChar);
/*
* If "=" was pressed or result was invalid, reset pending calculation
* flag and operator value. Otherwise, set new calculation flag so
* calculations can be chained.
*/
if (keyVal == "=" || displayString.startsWith(ERROR_STRING)) {
calcChar = " ";
operatorString = "";
} else {
calcChar = keyVal;
operatorString = displayString;
}
// Set the clear display flag and show the result.
clearDisplay = true;
displayText.setText(displayString);
}
/*
* This method formats a string.
*/
private String trimString(final String newString) {
String tempString = newString;
// Value is not a number
if (tempString.equals("NaN")) {
tempString = ERROR_STRING + NAN_STRING;
return tempString;
}
// Value is infinity
if (tempString.equals("Infinity") || tempString.equals("-Infinity")) {
tempString = ERROR_STRING + INFINITY_STRING;
return tempString;
}
// Value is -0
if (tempString.equals(-0.0)) {
tempString = "0";
return tempString;
}
// Trim unnecessary trailing .0
if (tempString.endsWith(".0")) {
tempString = tempString.substring(0, tempString.length() - 2);
}
// String is too long to display
if (tempString.length() > 28) {
tempString = ERROR_STRING + LONG_STRING;
}
return tempString;
}
}
Engine for Calculator by Michael Schmidt
/**
The following code is from Michael Schmidt(MichaelMSchmidt (at) msn.ru).
The code is published under BSD license.
Thanks for the input from Michael Schmidt.
*/
package us.mschmidt.komo;
/**
* This is a generic calculator engine that includes a memory register, some
* numeric conversions (square root, inverse), and the ability to chain
* calculations. To use it, create a GUI shell with a display and some means
* of entering keystrokes (Buttons work well). Invoke this engine from the GUI
* shell using the constructor method, which requires that the display size
* (String length) be set. Obtain the initial display, if desired, with the
* getDisplayString() method. Subsequently, the display string is returned by
* the setInput() method when an operation (character) is passed to the engine.
* <p>
* The constructor requires a display size to be set. The minimum is three
* characters, with at least 22 characters recommended and recommended size
* being 30 characters.
*
* @author Michael Schmidt
* @version 1.1
*/
class CalcEngine {
// Instantiatee constants
private final String calcChars;
private final String convChars;
private final String dispChars;
private final String memChars;
private final String errChars;
// Instantiate variables
// The error messages
private String nanErr = new String();
private String tooLongErr = new String();
private String infinityErr = new String();
private int displaySize;
// The calculator "registers"
private String displayString = new String();
private String memoryString = new String();
private String operatorString = new String();
// A boolean to indicate if display will be cleared on the next key entry
private boolean clearDisplay;
// A character to store the pending calculation
private char calcChar;
/**
* Constructor to create the calculator engine object.
*
* @param displaySizeVal The GUI display size, minimum of 3 and
* recommended size of 30
*/
CalcEngine(final int displaySizeVal) {
final int minSize = 3;
// Initialize operation characters
calcChars = "+-/*=";
convChars = "IQ";
dispChars = "BCERS.0123456789";
memChars = "DLMP";
errChars = "EINO*";
// Set initial display and internal variables
displayString = "0.";
clearDisplay = true;
calcChar = " ";
// Set the display size
displaySize = minSize;
if (displaySizeVal > minSize) {
displaySize = displaySizeVal;
}
// Customize the error strings based on the display size
setErrorStrings();
}
/**
* Customizes the error messages based on the display size.
*/
private void setErrorStrings() {
// Initialize constants for display size thresholds
final int infLength = 8;
final int nanLength = 12;
final int tooLongLength = 15;
final int fullLength = 22;
// Set default strings for optimal display size
nanErr = "Not a Number";
tooLongErr = "Number too long";
infinityErr = "Infinity";
if (displaySize < infLength) {
nanErr = "NaN";
tooLongErr = "***";
infinityErr = "Inf";
} else if (displaySize < nanLength) {
nanErr = "NaN";
tooLongErr = "Overflow";
} else if (displaySize < tooLongLength) {
tooLongErr = "Overflow";
} else if (displaySize >= fullLength) {
nanErr = "ERROR: " + nanErr;
tooLongErr = "ERROR: " + tooLongErr;
infinityErr = "ERROR: " + infinityErr;
}
}
/**
* Provides the display string to the calling class. Used after the
* engine is instantiated. Subsequently, the display string is returned by
* the setInput() method.
*
* @return the display String
*/
public String getDisplayString() {
return displayString;
}
/**
* Allows entry of keystrokes from the calling class.
*
* @param keyVal A designation of the key pressed by the user using the
* code.
* Display codes: B backspace, C clear, E clear entry,
* R recall memory to display, S change sign, . decimal,
* 0-9 numeric entries.
* Memory codes: D clear memory, M subtract from memory,
* L store in memory, P add to memory.
* Calculate codes: I inverse, Q square root, S subtract.
* @return boolean true if the display has changed, false if not
*/
public String setInput(final char keyVal) {
final char keyChar = keyVal;
if (dispChars.indexOf(keyChar) != -1) {
doDisplayOp(keyChar);
} else if (convChars.indexOf(keyChar) != -1) {
doConvertOp(keyChar);
} else if (memChars.indexOf(keyChar) != -1) {
doMemoryOp(keyChar);
} else if (calcChars.indexOf(keyChar) != -1) {
doCalcOp(keyChar);
}
return displayString;
}
/**
* Clears the display when 1) the clearDisplay flag had previously been set
* to "true" and 2) a new character or calculation operation is entered.
*/
private void doDisplayClear() {
if (clearDisplay) {
displayString = "";
clearDisplay = false;
}
}
/**
* Performs number conversion operations: inverse (1/X) and square root.
*
* @param keyVal a designation of the key pressed by the user
*/
private void doConvertOp(final char keyVal) {
final char opChar = keyVal;
String tempString = doConvert(displayString, opChar);
clearDisplay = true;
if (tempString.length() > 0) {
displayString = tempString;
}
}
/**
* Performs display operations. Simple assignment operations are performed
* in this method while more complex operations are performed in sub-methods.
*
* @param keyVal a designation of which key was pressed by the user
*/
private void doDisplayOp(final char keyVal) {
final char opChar = keyVal;
switch (opChar) {
case "B": // Backspace
doBackspace();
break;
case "C": // Clear. Note use of dropthrough
operatorString = "";
calcChar = " ";
case "E": // Clear Entry
displayString = "0.";
clearDisplay = true;
break;
case "R": // Recall Memory to Display
displayString = memoryString;
break;
case "S": // Change Sign
doChangeSign();
break;
case ".": // Can"t have two decimal points.
doDecimal(opChar);
break;
case "0": // Don"t want 00 to be entered.
doZero(opChar);
break;
default: // Default case is for the digits 1 through 9.
doAddChar(opChar);
break;
}
}
/**
* Performs backspace operation.
*/
private void doBackspace() {
if (isError(displayString)) {
return;
}
if (displayString.length() > 0) {
displayString = displayString.substring(
0, displayString.length() - 1);
}
}
/**
* Performs operation to add a character to the display.
*
* @param c the character to add
*/
private void doAddChar(final char c) {
if (isError(displayString)) {
return;
}
if (displayString.length() < displaySize) {
doDisplayClear();
displayString += c;
}
}
/**
* Performs sign change operation.
*/
private void doChangeSign() {
if (isError(displayString)) {
return;
}
if ("-" == displayString.charAt(0)) {
displayString = displayString.substring(
1, displayString.length());
} else if (displayString.length() < displaySize) {
displayString = "-" + displayString;
}
}
/**
* Performs operation when decimal is pressed.
*
* @param c the decimal character
*/
private void doDecimal(final char c) {
if (isError(displayString)) {
return;
}
if (displayString.indexOf(".") == -1
&& displayString.length() < displaySize) {
doDisplayClear();
displayString += c;
}
}
/**
* Performs operation when "0" is pressed.
*
* @param c the zero operation character
*/
private void doZero(final char c) {
if (isError(displayString)) {
return;
}
if (!displayString.equals("0") && displayString.length() < displaySize) {
doDisplayClear();
displayString += c;
}
}
/**
* Updates the value stored in the memory register. Simple assignment
* operations are performed here while more complex operations are performed
* in sub-methods.
*
* @param keyVal a designation of which key was pressed by the user
*/
private void doMemoryOp(final char keyVal) {
final char opChar = keyVal;
switch (opChar) {
case "D": // Clear Memory
memoryString = "";
break;
case "L": // Save to Memory
assignMemoryString(trimString(displayString));
break;
case "M": // Subtract from Memory
subtractFromMemory();
break;
case "P": // Add to Memory
addToMemory();
break;
default: // Do nothing - this should never happen.
break;
}
clearDisplay = true;
}
/**
* Performs the operation to add a display entry to the number in the
* memory register.
*/
private void addToMemory() {
String tempString = new String();
if (0 == memoryString.length()) {
tempString = trimString(displayString);
} else {
tempString = doComputation(memoryString, displayString, "+");
}
assignMemoryString(tempString);
}
/**
* Performs the operation to subtract a display entry from the number in the
* memory register.
*/
private void subtractFromMemory() {
String tempString = new String();
if (0 == memoryString.length()) {
tempString = doComputation("0", displayString, "-");
} else {
tempString = doComputation(memoryString, displayString, "-");
}
assignMemoryString(tempString);
}
/**
* Checks if String is valid and, if so, assigns it to the memory register.
*
* @param s the String to assign
*/
private void assignMemoryString(final String s) {
if (isError(s)) {
displayString = s;
} else {
memoryString = s;
}
}
/**
* Guides 2-number calculations. Updates the operator string, display
* string, and the pending calculation flag. Performs calculation if
* possible.
*
* @param keyVal a designation of which key was pressed byt he user
*/
private void doCalcOp(final char keyVal) {
final char opChar = keyVal;
// If there is no display value, the keystroke is deemed invalid and
// nothing is done.
if (0 == displayString.length()) {
return;
}
// If there is no operator value, "=" key presses are considered
// invalid. If a calculation key is pressed, check that the display
// value is valid and if so, copy the display value to the operator.
// No calculation is done.
if (0 == operatorString.length()) {
if ("=" != opChar) {
if (isError(displayString)) {
calcChar = " ";
} else {
operatorString = displayString;
calcChar = opChar;
}
clearDisplay = true;
}
return;
}
// There are operator and display values, so do the pending calculation.
displayString = doComputation(operatorString, displayString, calcChar);
// If "=" was pressed or result was invalid, reset pending calculation
// flag and operator value. Otherwise, set new calculation flag so
// calculations can be chained.
if (("=" == opChar) || isError(displayString)) {
calcChar = " ";
operatorString = "";
} else {
calcChar = opChar;
operatorString = displayString;
}
// Set the clear display flag
clearDisplay = true;
}
/**
* Performs the computations.
*
* @param numStringA the displayed value
* @param numStringB the stored value
* @param opVal the operation to be performed
* @return the solution as a string variable
*/
private String doComputation(final String numStringA,
final String numStringB, final char opVal) {
String valStringA = numStringA;
String valStringB = numStringB;
char opChar = opVal;
Double valA = 0.0;
Double valB = 0.0;
Double valAnswer = 0.0;
// Make sure register strings are numbers
if (valStringA.length() > 0 && valStringB.length() > 0) {
try {
valA = Double.parseDouble(numStringA);
valB = Double.parseDouble(numStringB);
} catch (final NumberFormatException e) {
return nanErr;
}
} else {
return "";
}
switch (opChar) {
case "+": // Addition
valAnswer = valA + valB;
break;
case "-": // Subtraction
valAnswer = valA - valB;
break;
case "/": // Division
valAnswer = valA / valB;
break;
case "*": // Multiplication
valAnswer = valA * valB;
break;
default: // Do nothing - this should never happen
break;
}
// Convert answer to properly formatted string.
return trimString(valAnswer.toString());
}
/**
* Performs number conversion computations.
*
* @param numString the number to be converted
* @param opVal designation of the operation to be performed
* @return the converted value
*/
private String doConvert(final String numString, final char opVal) {
char opChar = opVal;
String valString = numString;
Double valA = 0.0;
Double valAnswer = 0.0;
// Make sure String is a number. If it is zero-length, assume the
// keystroke was inadvertent and return "".
if (valString.length() > 0) {
try {
valA = Double.parseDouble(valString);
} catch (final NumberFormatException e) {
return nanErr;
}
} else {
return "";
}
switch (opChar) {
case "Q": // Square Root
valAnswer = Math.sqrt(valA);
break;
case "I": // Inverse
valAnswer = 1.0 / valA;
break;
default: // Do nothing - this should never happen
break;
}
// Return properly formatted result String.
return trimString(valAnswer.toString());
}
/**
* Formats String to be displayed.
*
* @param stringVal a new string to be displayed
* @return the properly formatted and trimmed string
*/
private String trimString(final String stringVal) {
String returnString = stringVal;
// Check if value is Not a Number
if (returnString.equals("NaN")) {
return nanErr;
}
// Check if value is infinity
if (returnString.endsWith("Infinity")) {
return infinityErr;
}
// Check if value is -0
if (returnString.equals("-0.0")) {
return "0";
}
// Trim unnecessary trailing .0
if (returnString.endsWith(".0")) {
returnString = returnString.substring(0, returnString.length() - 2);
}
// Check if string is too long to display
if (returnString.length() > displaySize) {
return tooLongErr;
}
return returnString;
}
/**
* Tests if the String is an error message.
*
* @param s the String to be tested
* @return boolean true if this is an error message, false if not
*/
private boolean isError(final String s) {
String testString = s;
if (0 == testString.length()) {
return false;
}
char c = testString.charAt(0);
return ((errChars.indexOf(c) == -1)) ? false : true;
}
/**
* Override to provide useful information when the class toString method is
* called.
*
* @return the information String
* @see java.lang.Object#toString()
*/
@Override
public final String toString() {
return "komo.CalcEngine is the engine portion of the calculator utility";
}
}
