void AccumulateDigits(string msg, bool isInput)
{
if (isInput)
{
calcState = CalcState.AccumulateDigits;
tempNumber += msg;
changeTextDelegate.Invoke(tempNumber);
}
else
{
if (Rules.IsDigit(msg))
{
AccumulateDigits(msg, true);
}
else if (Rules.IsOperation(msg))
{
Operation(msg, true);
}
else if (Rules.IsResult(msg))
{
Result(msg, true);
}
else if (Rules.IsQuickOperation(msg))
{
QuickOperation(msg, true);
}
else if (Rules.IsPoint(msg) && isPoint)
{
isPoint = false;
AccumulateDigits(msg, true);
}
}
}
void Compute(bool isInput, string msg)
{
if (isInput || operation == "f")
{
calcState = CalcState.Compute;
if (operation.Length > 0)
{
Calculate();
displayMsg(resultNumber);
}
else
{
resultNumber = tempNumber;
}
tempNumber = "";
operation = msg;
}
else
{
if (Rules.IsDigit(msg))
{
AccumulateDigit(true, msg);
}
}
}
void Operation(string msg, bool isInput)
{
if (isInput)
{
calcState = CalcState.Operation;
if (operation.Length != 0)
{
PerformCalculation();
changeTextDelegate(resultNumber);
}
if (resultNumber == "")
{
resultNumber = tempNumber;
}
isPoint = true;
operation = msg;
//changeTextDelegate.Invoke(msg);
tempNumber = "";
}
else
{
if (Rules.IsDigit(msg))
{
AccumulateDigits(msg, true);
}
else if (Rules.IsOperation(msg))
{
operation = "";
Operation(msg, true);
}
}
}
void AccumulateDigitsWithDecimal(string msg, bool isInput)
{
if (isInput)
{
calcState = CalcState.AccumulateDigitsWithDecimal;
tempNumber += msg;
changeTextDelegate.Invoke(tempNumber);
}
else
{
if (Rules.IsDigit(msg))
{
AccumulateDigitsWithDecimal(msg, true);
}
else if (Rules.IsOperation(msg) || Rules.IsOneOperation(msg) || Rules.IsPlusMinus(msg) || Rules.IsDelete(msg))
{
Compute(msg, true);
}
else if (Rules.IsEqualSign(msg))
{
Result(msg, true);
}
else if (Rules.IsC(msg))
{
Zero(msg, true);
}
else if (Rules.IsCE(msg))
{
tempNumber = "";
AccumulateDigits(tempNumber, true);
}
}
}
private void AccumulateDigitsWithDecimal(bool isInput, string msg)
{
if (isInput)
{
calcState = CalcState.AC_DGTS_WDCML;
if (!tempNumber.Contains(","))
{
tempNumber += ",";
}
displayMsg(tempNumber);
}
else
{
if (Rules.IsChangeSign(msg))
{
if (double.Parse(tempNumber) > 0)
{
tempNumber = "-" + tempNumber;
}
else
{
tempNumber = tempNumber.Substring(1, tempNumber.Length - 2);
}
displayMsg(tempNumber);
AccumulateDigits(false, " ");
}
if (Rules.IsDigit(msg))
{
AccumulateDigits(true, msg);
}
else if (Rules.IsOperator(msg))
{
Compute(true, msg);
}
else if (Rules.IsEqualSign(msg))
{
Result(true, msg);
}
if (Rules.IsBackSpace(msg))
{
tempNumber = tempNumber.Substring(0, tempNumber.Length - 2);
AccumulateDigits(false, msg);
}
}
}
void AccumulateDigit(bool isInput, string msg)
{
if (isInput)
{
calcState = CalcState.AccumulateDigit;
tempNumber += msg;
displayMsg(tempNumber);
}
else
{
if (Rules.IsDigit(msg))
{
AccumulateDigit(true, msg);
}
else if (Rules.IsOperator(msg))
{
Compute(true, msg);
}
else if (Rules.IsEqualSign(msg))
{
Result(true, msg);
}
}
}
void Compute(string msg, bool isInput)
{
if (isInput)
{
calcState = CalcState.Compute;
if (Rules.IsOneOperation(msg) || Rules.IsPlusMinus(msg) || Rules.IsDelete(msg))
{
operation = msg;
if (operation.Length > 0)
{
if (Rules.IsOneOperation(msg))
{
OneOperation();
}
if (Rules.IsPlusMinus(msg))
{
PlusMinus();
}
if (Rules.IsDelete(msg))
{
Delete();
}
changeTextDelegate(resultNumber);
}
resultNumber = tempNumber;
operation = "";
}
else
{
if (operation.Length > 0)
{
if (Rules.IsOperation(msg))
{
Operation();
changeTextDelegate(resultNumber);
}
}
else
{
resultNumber = tempNumber;
}
operation = msg;
tempNumber = "";
}
}
else
{
if (Rules.IsDigit(msg))
{
AccumulateDigits(msg, true);
}
else if (Rules.IsC(msg))
{
Zero(msg, true);
}
else if (Rules.IsCE(msg))
{
tempNumber = "";
AccumulateDigits(tempNumber, true);
}
//else if (Rules.IsOperation(msg) || Rules.IsOneOperation(msg) || Rules.IsPlusMinus(msg) || Rules.IsDelete(msg))
//{
// Compute(msg, true);
//}
}
}
void MemorySave(string msg, bool isInput)
{
if (isInput)
{
calcState = CalcState.MemorySave;
double result = double.Parse(memoryNumber.Replace(",", "."), System.Globalization.CultureInfo.InvariantCulture);;
double num;
if (secondNumber == "")
{
secondNumber = "0";
}
if (resultToMemory)
{
num = double.Parse(resultNumber.Replace(",", "."), System.Globalization.CultureInfo.InvariantCulture);
}
else
{
num = double.Parse(secondNumber.Replace(",", "."), System.Globalization.CultureInfo.InvariantCulture);
}
if (msg == "M+")
{
result += num;
memoryNumber = result.ToString();
memoryBox.Add(memoryNumber);
}
else if (msg == "M-")
{
result -= num;
memoryNumber = result.ToString();
memoryBox.Add(memoryNumber);
}
else if (msg == "MS")
{
memoryNumber = num.ToString();
}
else if (msg == "MR")
{
if (memoryNumberToFirst)
{
operation = "";
firstNumber = memoryNumber;
changeTextDelegate.Invoke(firstNumber);
}
else
{
secondNumber = memoryNumber;
changeTextDelegate.Invoke(secondNumber);
}
}
else if (msg == "MC")
{
memoryNumber = "0";
memoryBox = new List <string>();
}
memoryNumberToFirst = false;
}
else
{
if (Rules.IsDigit(msg))
{
FullReset();
AccumulateDigits(msg, true);
}
else if (Rules.IsMemoryOperation(msg))
{
MemorySave(msg, true);
}
else if (Rules.IsOperation(msg))
{
Operation(msg, true);
}
else if (Rules.IsResult(msg))
{
Result(msg, true);
}
else if (Rules.IsFullReset(msg))
{
FullReset();
}
}
resultToMemory = false;
}
void Result(string msg, bool isInput)
{
if (isInput)
{
calcState = CalcState.Result;
if (operation == "Mod")
{
resultNumber = (int.Parse(firstNumber) % int.Parse(secondNumber)).ToString();
}
else if (operation == "pow")
{
resultNumber = Math.Pow(double.Parse(firstNumber), double.Parse(secondNumber)).ToString();
}
else if (operation == "root")
{
resultNumber = Math.Pow(double.Parse(firstNumber), 1.0 / double.Parse(secondNumber)).ToString();
}
else if (isExpression == true || isAdvancedExpression == true)
{
if (operations.Peek() == "+")
{
sumNumbers.Push(int.Parse(secondNumber));
}
else if (operations.Peek() == "-")
{
sumNumbers.Push(int.Parse(secondNumber) * (-1));
}
else if (operations.Peek() == "x")
{
if (signs.Peek() == "-")
{
precendence *= (-1);
}
precendence *= int.Parse(secondNumber);
sumNumbers.Push(precendence);
}
else if (operations.Peek() == "÷")
{
if (signs.Peek() == "-")
{
precendence *= (-1);
}
precendence /= int.Parse(secondNumber);
sumNumbers.Push(precendence);
}
int temp = 0;
while (sumNumbers.Count > 0)
{
temp += sumNumbers.Peek();
sumNumbers.Pop();
}
resultNumber = temp.ToString();
}
/*else if (isAdvancedExpression == true)
* {
*
* }*/
else
{
resultNumber = PerformCalculation();
}
changeTextDelegate.Invoke(resultNumber);
firstNumber = resultNumber;
isExpression = false;
isAdvancedExpression = false;
reccuring = new List <string>();
changeRecurringTextDelegate.Invoke("");
}
else
{
if (Rules.IsOperation(msg))
{
afterResult = true;
Operation(msg, true);
}
else if (Rules.IsDigit(msg))
{
AccumulateDigits(msg, true);
}
else if (Rules.IsResult(msg))
{
Result(msg, true);
}
else if (Rules.IsMemoryOperation(msg))
{
memoryNumberToFirst = true;
resultToMemory = true;
MemorySave(msg, true);
}
else if (Rules.IsFullReset(msg))
{
FullReset();
}
else if (Rules.IsReset(msg))
{
Reset();
}
}
}
void Operation(string msg, bool isInput)
{
if (isInput)
{
calcState = CalcState.Operation;
if (operation.Length != 0 && afterResult == false)
{
isExpression = true;
if ((msg == "x" || msg == "÷") && (operations.Peek() == "+" || operations.Peek() == "-"))
{
operation = msg;
operations.Push(operation);
firstNumber = secondNumber;
reccuring.Add(secondNumber);
secondNumber = "";
precendence = int.Parse(firstNumber);
}
else if ((msg == "x" || msg == "÷") && (operations.Peek() == "x" || operations.Peek() == "÷"))
{
if (operation == "x")
{
precendence *= int.Parse(secondNumber);
}
else if (operation == "÷")
{
precendence /= int.Parse(secondNumber);
}
changeTextDelegate.Invoke(precendence.ToString());
operation = msg;
operations.Push(operation);
reccuring.Add(secondNumber);
secondNumber = "";
}
else if ((msg == "+" || msg == "-") && (operations.Peek() == "x" || operations.Peek() == "÷"))
{
if (operation == "x")
{
precendence *= int.Parse(secondNumber);
}
else if (operation == "÷")
{
precendence /= int.Parse(secondNumber);
}
if (signs.Count > 0 && signs.Peek() == "-")
{
precendence *= (-1);
}
sumNumbers.Push(precendence);
Stack <int> stack = new Stack <int>();
int temp = 0;
while (sumNumbers.Count > 0)
{
temp += sumNumbers.Peek();
stack.Push(sumNumbers.Peek());
sumNumbers.Pop();
}
while (stack.Count > 0)
{
sumNumbers.Push(stack.Peek());
stack.Pop();
}
changeTextDelegate.Invoke(temp.ToString());
precendence = 0;
operation = msg;
operations.Push(operation);
signs.Push(operation);
reccuring.Add(secondNumber);
secondNumber = "";
}
else if ((msg == "+" || msg == "-") && (operations.Peek() == "-" || operations.Peek() == "-"))
{
if (operation == "-")
{
sumNumbers.Push(int.Parse(secondNumber) * (-1));
}
else if (operation == "+")
{
sumNumbers.Push(int.Parse(secondNumber));
}
operation = msg;
operations.Push(operation);
signs.Push(operation);
reccuring.Add(secondNumber);
secondNumber = "";
}
}
else if (operation.Length != 0 && afterResult == true)
{
operation = msg;
firstNumber = resultNumber;
reccuring.Add(secondNumber);
secondNumber = "";
afterResult = false;
}
else
{
operation = msg;
operations.Push(operation);
if (operation == "+" || operation == "-")
{
sumNumbers.Push(int.Parse(secondNumber));
signs.Push(operation);
}
else if (operation == "x" || operation == "÷")
{
precendence = int.Parse(secondNumber);
}
reccuring.Add(secondNumber);
if (firstNumber == "")
{
firstNumber = secondNumber;
}
//reccuring.Add(firstNumber);
secondNumber = "";
}
string text = string.Join(" ", reccuring.ToArray());
changeRecurringTextDelegate.Invoke(text);
}
else
{
if (Rules.IsDigit(msg))
{
AccumulateDigits(msg, true);
}
else if (Rules.IsResult(msg))
{
secondNumber = firstNumber;
Result(msg, true);
}
else if (Rules.IsFullReset(msg))
{
FullReset();
}
else if (Rules.IsReset(msg))
{
Reset();
}
else if (Rules.IsMemoryOperation(msg))
{
MemorySave(msg, true);
}
else if (msg == "(")
{
reccuring.Add("(");
string text = string.Join(" ", reccuring.ToArray());
changeRecurringTextDelegate.Invoke(text);
Expression(msg, true);
}
}
}
void AccumulateDigits(string msg, bool isInput)
{
if (isInput)
{
calcState = CalcState.AccumulateDigits;
if (msg == "," && secondNumber.Contains(',') == false)
{
secondNumber = "0,";
changeTextDelegate.Invoke(secondNumber);
}
else
{
secondNumber += msg;
changeTextDelegate.Invoke(secondNumber);
}
}
else
{
if (Rules.IsDigit(msg))
{
secondNumber += msg;
changeTextDelegate.Invoke(secondNumber);
}
else if (Rules.IsSeparator(msg))
{
if (secondNumber.Contains(',') == false)
{
secondNumber += ",";
changeTextDelegate.Invoke(secondNumber);
}
}
else if (Rules.IsChangingSign(msg))
{
if (secondNumber[0] == '-')
{
secondNumber = secondNumber.Remove(0, 1);
}
else
{
secondNumber = "-" + secondNumber;
}
changeTextDelegate.Invoke(secondNumber);
}
else if (Rules.IsOperation(msg))
{
Operation(msg, true);
reccuring.Add(msg);
string text = string.Join(" ", reccuring.ToArray());
changeRecurringTextDelegate.Invoke(text);
}
else if (Rules.IsPercent(msg))
{
if (operation == "+" || operation == "-")
{
CalculatePercent();
}
else if (operation == "x" || operation == "÷")
{
CalculateSecondPercent();
}
changeTextDelegate.Invoke(secondNumber);
}
else if (Rules.IsResult(msg))
{
Result(msg, true);
}
else if (Rules.IsFullReset(msg))
{
FullReset();
}
else if (Rules.IsReset(msg))
{
Reset();
}
else if (Rules.IsBackspace(msg))
{
secondNumber = secondNumber.Remove(secondNumber.Length - 1);
changeTextDelegate.Invoke(secondNumber);
if (secondNumber.Length <= 0)
{
changeTextDelegate.Invoke("0");
}
}
else if (Rules.IsMemoryOperation(msg))
{
MemorySave(msg, true);
}
else if (Rules.IsSinCos(msg))
{
SinCos(msg, true);
}
else if (msg == "Mod")
{
Modulo(msg, true);
}
else if (msg == "log")
{
Logarithm(msg, true);
}
else if (msg == "x^y")
{
ParticularPower(msg, true);
}
else if (msg == "10^x")
{
PowerOfTen(msg, true);
}
else if (msg == "n!")
{
Factorial(msg, true);
}
else if (msg == "yrootx")
{
AnyRoot(msg, true);
}
else if (msg == ")")
{
reccuring.Add(secondNumber);
reccuring.Add(")");
string text = string.Join(" ", reccuring.ToArray());
changeRecurringTextDelegate.Invoke(text);
Expression(msg, true);
}
}
}
private void AccumulateDigits(bool isInput, string msg)
{
if (isInput)
{
calcState = CalcState.AC_DGTS;
tempNumber += msg;
displayMsg(tempNumber);
}
else
{
if (Rules.IsPrimeSum(msg))
{
Compute(true, msg);
}
if (Rules.IsChangeSign(msg))
{
if (double.Parse(tempNumber) > 0)
{
tempNumber = "-" + tempNumber;
}
else
{
tempNumber = tempNumber.Substring(1, tempNumber.Length - 2);
}
displayMsg(tempNumber);
AccumulateDigits(false, " ");
}
if (Rules.IsDigit(msg))
{
AccumulateDigits(true, msg);
}
else if (Rules.IsOperator(msg))
{
Compute(true, msg);
}
else if (Rules.IsEqualSign(msg))
{
Result(true, msg);
}
if (Rules.IsSeparator(msg))
{
AccumulateDigitsWithDecimal(true, msg);
}
if (Rules.IsBackSpace(msg))
{
if (tempNumber.Length != 1)
{
tempNumber = tempNumber.Substring(0, tempNumber.Length - 1);
displayMsg(tempNumber);
AccumulateDigits(false, " ");
}
else
{
tempNumber = tempNumber.Substring(0, tempNumber.Length - 1);
displayMsg("0");
AccumulateDigits(false, " ");
}
}
}
}
