public void HandleMultiplication(Calculator calculator, CalculatorOperations calcOps)
{
if (currentOperation == CalculatorOperations.CurrentOperation.Equals || currentOperation == CalculatorOperations.CurrentOperation.SquareRoot || currentOperation == CalculatorOperations.CurrentOperation.Reciprocal)
{
currentOperation = CalculatorOperations.CurrentOperation.Multiplication;
calculator.OperationString = calculator.CurrentSubTotal + " * ";
}
else
{
if (calculator.CurrentSubTotal != 0)
{
calculator.CurrentSubTotal = calcOps.Multiplication(calculator.CurrentSubTotal, (double)calculator.CurrentDigit);
calculator.OperationString += calculator.CurrentDigit + " * ";
}
else
{
Console.WriteLine("0");
calculator.CurrentSubTotal = (double)calculator.CurrentDigit;
calculator.OperationString = calculator.CurrentDigit + " * ";
}
calculator.OperationSet = true;
calcOps.DigitEntrySet = false;
ClearCurrentDigit(calculator);
SetResultsString(calculator, false, calculator.CurrentSubTotal);
currentOperation = CalculatorOperations.CurrentOperation.Multiplication;
}
}
public void PerformOperation(Calculator calculator, CalculatorOperations calcOps)
{
switch (currentOperation)
{
case (CalculatorOperations.CurrentOperation.Addition):
HandleAddition(calculator, calcOps);
break;
case (CalculatorOperations.CurrentOperation.Subtraction):
HandleSubtraction(calculator, calcOps);
break;
case (CalculatorOperations.CurrentOperation.Multiplication):
HandleMultiplication(calculator, calcOps);
break;
case (CalculatorOperations.CurrentOperation.Division):
HandleDivision(calculator, calcOps);
break;
case (CalculatorOperations.CurrentOperation.Reciprocal):
HandleReciprocal(calculator, calcOps);
break;
case (CalculatorOperations.CurrentOperation.SquareRoot):
HandleSquareRoot(calculator, calcOps);
break;
}
}
public void HandleSubtraction(Calculator calculator, CalculatorOperations calcOps)
{
if (currentOperation == CalculatorOperations.CurrentOperation.Equals || currentOperation == CalculatorOperations.CurrentOperation.SquareRoot || currentOperation == CalculatorOperations.CurrentOperation.Reciprocal && calculator.CurrentSubTotal != 0)
{
currentOperation = CalculatorOperations.CurrentOperation.Subtraction;
calculator.OperationString = calculator.CurrentSubTotal + " - ";
}
else
{
if (calculator.CurrentSubTotal != 0)
{
calculator.CurrentSubTotal = calcOps.Subtraction(calculator.CurrentSubTotal, (double)calculator.CurrentDigit);
calculator.OperationString += calculator.CurrentDigit + " - ";
}
else
{
calculator.CurrentSubTotal = (double)calculator.CurrentDigit;
calculator.OperationString = calculator.CurrentDigit + " - ";
}
calcOps.DigitEntrySet = false;
SetResultsString(calculator, false, calculator.CurrentSubTotal);
ClearCurrentDigit(calculator);
currentOperation = CalculatorOperations.CurrentOperation.Subtraction;
}
}
public void HandleMemoryChange(Calculator calculator, CalculatorOperations calcOps, bool Addition)
{
if (calcOps.DigitEntrySet)
{
if (Addition)
{
calculator.MemoryValue += (double)calculator.CurrentDigit;
}
else
{
calculator.MemoryValue -= (double)calculator.CurrentDigit;
}
}
else
{
if (Addition)
{
calculator.MemoryValue += calculator.CurrentSubTotal;
}
else
{
calculator.MemoryValue -= calculator.CurrentSubTotal;
}
}
SetMemoryIndicator(calculator, true);
}
public void HandleEquals(Calculator calculator, CalculatorOperations calcOps)
{
PerformOperation(calculator, calcOps);
calculator.OperationString = "";
currentOperation = CalculatorOperations.CurrentOperation.Equals;
calculator.OperationSet = true;
Console.WriteLine("Current sub equals: " + calculator.CurrentSubTotal);
}
public void HandleClear(Calculator calculator, CalculatorOperations calcOps)
{
calculator.ResultsString = "0";
calculator.OperationString = "";
calculator.CurrentDigit = 0;
calculator.CurrentSubTotal = 0;
calcOps.DecimalUsed = false;
currentOperation = CalculatorOperations.CurrentOperation.NoOperation;
}
public void HandleNegation(Calculator calculator, CalculatorOperations calcOps)
{
if (calcOps.DigitEntrySet)
{
calculator.CurrentDigit *= -1;
SetResultsString(calculator, true, (double)calculator.CurrentDigit);
}
else
{
calculator.CurrentSubTotal *= -1;
SetResultsString(calculator, false, calculator.CurrentSubTotal);
}
}
public void HandleMemoryRecall(Calculator calculator, CalculatorOperations calcOps)
{
if (calcOps.DigitEntrySet)
{
calculator.CurrentDigit = (decimal)calculator.MemoryValue;
SetResultsString(calculator, true, (double)calculator.CurrentDigit);
}
else
{
SetResultsString(calculator, true, calculator.CurrentSubTotal);
}
calculator.CurrentSubTotal = calculator.MemoryValue;
calcOps.DigitEntrySet = false;
}
public void ArithmeticHandler(Button button, Calculator calculator, CalculatorOperations calcOps)
{
if (!calcOps.ArithemticDone)
{
switch (button.Name)
{
case ("Addition"):
HandleAddition(calculator, calcOps);
calcOps.ArithemticDone = true;
break;
case ("Subtraction"):
HandleSubtraction(calculator, calcOps);
calcOps.ArithemticDone = true;
break;
case ("Equals"):
HandleEquals(calculator, calcOps);
calcOps.ArithemticDone = false;
break;
case ("Division"):
HandleDivision(calculator, calcOps);
calcOps.ArithemticDone = true;
break;
case ("Multiplication"):
HandleMultiplication(calculator, calcOps);
break;
case ("SquareRoot"):
HandleSquareRoot(calculator, calcOps);
break;
case ("Reciproval"):
HandleReciprocal(calculator, calcOps);
break;
case ("Percentage"):
HandlePercentage(calculator, calcOps);
break;
default:
MessageBox.Show("Not implemented");
break;
}
}
}
public void GeneralButtonHandler(Button button, Calculator calculator, CalculatorOperations calcOps)
{
switch (button.Name)
{
case ("Negation"):
HandleNegation(calculator, calcOps);
break;
case ("Clear"):
HandleClear(calculator, calcOps);
break;
case ("ClearLast"):
HandleClearLast(calculator, calcOps);
break;
case ("RemoveDigit"):
HandleRemoveDigit(calculator, calcOps);
break;
case ("MemoryClear"):
HandleMemoryClear(calculator);
break;
case ("MemoryRecall"):
HandleMemoryRecall(calculator, calcOps);
break;
case ("MemorySave"):
HandleMemorySet(calculator, calcOps);
break;
case ("MemoryAdd"):
HandleMemoryChange(calculator, calcOps, true);
break;
case ("MemorySubtract"):
HandleMemoryChange(calculator, calcOps, false);
break;
default:
MessageBox.Show("Not implemented");
break;
}
}
public void HandleMemorySet(Calculator calculator, CalculatorOperations calcOps)
{
if (calcOps.DigitEntrySet)
{
if (calculator.CurrentDigit != 0)
{
calculator.MemoryValue = (double)calculator.CurrentDigit;
}
}
else
{
if (calculator.CurrentSubTotal != 0)
{
calculator.MemoryValue = calculator.CurrentSubTotal;
}
}
SetMemoryIndicator(calculator, true);
}
public void HandlePercentage(Calculator calculator, CalculatorOperations calcOps)
{
double numberToBeActioned;
if (calcOps.DigitEntrySet)
{
if (calculator.CurrentSubTotal != 0)
{
numberToBeActioned = (double)calculator.CurrentDigit / calculator.CurrentSubTotal;
calcOps.DigitEntrySet = false;
ClearCurrentDigit(calculator);
calculator.CurrentDigit = (decimal)numberToBeActioned;
SetResultsString(calculator, true, numberToBeActioned);
}
else
{
SystemSounds.Exclamation.Play();
}
}
}
public void HandleRemoveDigit(Calculator calculator, CalculatorOperations calcops)
{
if (calcops.DigitEntrySet)
{
if (calculator.ResultsString.Length > 1)
{
calculator.ResultsString = calculator.ResultsString.Remove(calculator.ResultsString.Length - 1);
calculator.CurrentDigit = decimal.Parse(calculator.ResultsString);
SetResultsString(calculator, true, (double)calculator.CurrentDigit);
}
else
{
calculator.CurrentDigit = 0;
SetResultsString(calculator, true, (double)calculator.CurrentDigit);
}
}
else
{
SystemSounds.Exclamation.Play();
}
}
public void HandleSquareRoot(Calculator calculator, CalculatorOperations calcOps)
{
double numberToBeActioned;
if (calcOps.DigitEntrySet)
{
numberToBeActioned = (double)calculator.CurrentDigit;
calculator.CurrentSubTotal = Math.Sqrt((double)calculator.CurrentDigit);
SetResultsString(calculator, false, calculator.CurrentSubTotal);
}
else
{
numberToBeActioned = calculator.CurrentSubTotal;
calculator.CurrentSubTotal = Math.Sqrt(calculator.CurrentSubTotal);
SetResultsString(calculator, false, calculator.CurrentSubTotal);
}
calculator.OperationString = "√(" + numberToBeActioned + ")";
calcOps.DigitEntrySet = false;
ClearCurrentDigit(calculator);
SetResultsString(calculator, false, calculator.CurrentSubTotal);
currentOperation = CalculatorOperations.CurrentOperation.SquareRoot;
}
public void HandleReciprocal(Calculator calculator, CalculatorOperations calcOps)
{
double numberToBeActioned;
if (calcOps.DigitEntrySet)
{
numberToBeActioned = (double)calculator.CurrentDigit;
calculator.CurrentSubTotal = (double)(1 / (calculator.CurrentDigit));
SetResultsString(calculator, false, calculator.CurrentSubTotal);
}
else
{
numberToBeActioned = calculator.CurrentSubTotal;
calculator.CurrentSubTotal = 1 / (calculator.CurrentSubTotal);
SetResultsString(calculator, false, calculator.CurrentSubTotal);
}
calculator.OperationString = "reciproc(" + numberToBeActioned + ")";
calcOps.DigitEntrySet = false;
ClearCurrentDigit(calculator);
SetResultsString(calculator, false, calculator.CurrentSubTotal);
currentOperation = CalculatorOperations.CurrentOperation.Reciprocal;
}
private void HandlePercentage(Calculator calculator, CalculatorOperations calcOps)
{
calcButtonHandlers.HandlePercentage(calculator, calcOps);
}
public void NumberEntryHandler(Button numberButton, Calculator calculator, CalculatorOperations calcOps)
{
calcOps.DigitEntrySet = true;
string newValue;
if (calculator.CurrentDigit.ToString().Length >= calculator.MaximumResultsStringLength - 1)
{
SystemSounds.Exclamation.Play();
newValue = calculator.ResultsString;
}
else
{
if (calculator.CurrentDigit.ToString() == "0")
{
if (numberButton.Tag.ToString() == ".")
{
if (calcOps.DecimalUsed)
{
SystemSounds.Exclamation.Play();
newValue = calculator.ResultsString;
}
else
{
newValue = "0" + numberButton.Tag.ToString() + "0";
calcOps.DecimalUsed = true;
}
}
else
{
newValue = numberButton.Tag.ToString();
if (newValue.Length <= 1)
{
newValue = newValue.Replace("0", string.Empty);
}
}
}
else
{
if (numberButton.Tag.ToString() == ".")
{
if (calcOps.DecimalUsed)
{
SystemSounds.Exclamation.Play();
newValue = calculator.ResultsString;
}
else
{
newValue = calculator.CurrentDigit.ToString() + numberButton.Tag.ToString() + "0";
calcOps.DecimalUsed = true;
}
}
else
{
newValue = calculator.CurrentDigit.ToString() + numberButton.Tag.ToString();
if (newValue.Length <= 1)
{
newValue = newValue.Replace("0", string.Empty);
}
}
}
calcOps.DigitEntrySet = true;
decimal.TryParse(newValue, out numberButtonDigit);
calculator.CurrentDigit = numberButtonDigit;
UpdateCurrentOperationString(newValue, calculator);
calcOps.ArithemticDone = false;
}
}
private void HandleMemoryRecall(Calculator calculator, CalculatorOperations calcOps)
{
calcButtonHandlers.HandleMemoryRecall(calculator, calcOps);
}
private void HandleMemoryChange(Calculator calculator, CalculatorOperations calcOps, bool Addition)
{
calcButtonHandlers.HandleMemoryChange(calculator, calcOps, Addition);
}
private void HandleSquareRoot(Calculator calculator, CalculatorOperations calcOps)
{
calcButtonHandlers.HandleSquareRoot(calculator, calcOps);
}
private void HandleReciprocal(Calculator calculator, CalculatorOperations calcOps)
{
calcButtonHandlers.HandleReciprocal(calculator, calcOps);
}
private void HandleRemoveDigit(Calculator calculator, CalculatorOperations calcOps)
{
calcButtonHandlers.HandleRemoveDigit(calculator, calcOps);
}
private void HandleClearLast(Calculator calculator, CalculatorOperations calcOps)
{
calcButtonHandlers.HandleClearLast(calculator, calcOps);
}
private void HandleNegation(Calculator calculator, CalculatorOperations calcOps)
{
calcButtonHandlers.HandleNegation(calculator, calcOps);
}
private void HandleEquals(Calculator calculator, CalculatorOperations calcOps)
{
calcButtonHandlers.HandleEquals(calculator, calcOps);
}
public void HandleClearLast(Calculator calculator, CalculatorOperations calcOps)
{
calculator.CurrentDigit = 0;
currentOperation = CalculatorOperations.CurrentOperation.NoOperation;
SetResultsString(calculator, true, (double)calculator.CurrentDigit);
}
