internal CompositeRenderingKey(KeyOperator op, string leftText, string rightText)
{
Operator = op;
RenderingType expectedType;
switch (Operator)
{
case KeyOperator.Equal:
case KeyOperator.Different:
case KeyOperator.Assignment:
case KeyOperator.Contains:
case KeyOperator.And:
case KeyOperator.Or:
expectedType = RenderingType.Any;
break;
case KeyOperator.Begins:
case KeyOperator.Ends:
expectedType = RenderingType.String;
break;
default:
expectedType = RenderingType.Numeric;
break;
}
this.leftSide = RenderingKey.Parse(leftText, expectedType);
this.rightSide = RenderingKey.Parse(rightText, expectedType);
}
private void ClearDisplayText()
{
Result = 0;
HasError = false;
ClearTextBeforeNumbersInput = true;
this.DisplayResult = KeyBoardWords.Zero;
lastOperator = KeyOperator.GetResult;
isFirstOperator = true;
}
private void ShowResult(KeyOperator keyOperator)
{
var currentValue = Double.Parse(displayResult);
if (keyOperator == KeyOperator.GetResult)
{
currentValue = lastStepValue;
if (keyOperator != KeyOperator.None)
{
keyOperator = lastOperator;
}
HasOperatorChanged = false;
SendingOperating = false;
}
else
{
HasOperatorChanged = true;
SendingOperating = true;
}
ClearTextBeforeNumbersInput = true;
LastOperator = keyOperator;
if (lastOperator == KeyOperator.None)
{
result = lastStepValue;
}
if (isFirstOperator)
{
result = currentValue;
isFirstOperator = false;
return;
}
if (keyOperator != KeyOperator.GetResult && HasOperatorChanged)
{
if (_lastKey.Type == KeyType.Number)
{
if (keyOperator == KeyOperator.Plus)
result += lastStepValue;
else if (keyOperator == KeyOperator.Minus)
result = result - lastStepValue;
else if (keyOperator == KeyOperator.Multiply)
result = result * lastStepValue;
else if (keyOperator == KeyOperator.Divide)
{
if (currentValue == 0)
{
DisplayResult = AppResources.DividerCantBeZero;
HasError = true;
return;
}
else
{
result = result / lastStepValue;
}
}
}
else
{
lastStepValue = currentValue;
}
DisplayCalculatingResult(result);
return;
}
if (keyOperator == KeyOperator.Plus)
result += currentValue;
else if (keyOperator == KeyOperator.Minus)
result = result - currentValue;
else if (keyOperator == KeyOperator.Multiply)
result = result * currentValue;
else if (keyOperator == KeyOperator.Divide)
{
if (currentValue == 0)
{
DisplayResult = AppResources.DividerCantBeZero;
HasError = true;
return;
}
else
{
result = result / currentValue;
}
}
DisplayCalculatingResult(result);
}
private static object InternalEvaluate(KeyOperator op, object left, object right)
{
switch (op)
{
case KeyOperator.Different:
return(!(bool)InternalEvaluate(KeyOperator.Equal, left, right));
case KeyOperator.LessOrEqual:
return(!(bool)InternalEvaluate(KeyOperator.Greater, left, right));
case KeyOperator.GreaterOrEqual:
return(!(bool)InternalEvaluate(KeyOperator.Less, left, right));
case KeyOperator.And:
{
var leftVal = EvaluateBool(left);
var rightVal = EvaluateBool(right);
return(leftVal && rightVal);
}
case KeyOperator.Or:
{
var leftVal = EvaluateBool(left);
var rightVal = EvaluateBool(right);
return(leftVal || rightVal);
}
case KeyOperator.Contains:
{
if (right == null)
{
return(false);
}
var rightVal = right.ToString();
if (string.IsNullOrEmpty(rightVal))
{
return(false);
}
if (left == null)
{
return(false);
}
if (left is IEnumerable)
{
var list = (IEnumerable)left;
foreach (var entry in list)
{
if (entry.ToString() == rightVal)
{
return(true);
}
}
return(false);
}
else
{
var leftVal = left.ToString();
return(leftVal.Contains(rightVal));
}
}
case KeyOperator.Begins:
{
var leftVal = left.ToString();
var rightVal = right.ToString();
return(leftVal.StartsWith(rightVal));
}
case KeyOperator.Ends:
{
var leftVal = left.ToString();
var rightVal = right.ToString();
return(leftVal.EndsWith(rightVal));
}
case KeyOperator.Equal:
{
if (left == null && right == null)
{
return(true);
}
else
if ((left == null && right != null) || (left != null && right == null))
{
return(false);
}
else
{
return(left.ToString().Equals(right.ToString()));
}
}
case KeyOperator.Less:
{
var leftNumber = EvaluateNumber(left);
var rightNumber = EvaluateNumber(right);
return(leftNumber < rightNumber);
}
case KeyOperator.Greater:
{
var leftNumber = EvaluateNumber(left);
var rightNumber = EvaluateNumber(right);
return(leftNumber > rightNumber);
}
case KeyOperator.Plus:
{
var leftNumber = EvaluateNumber(left);
var rightNumber = EvaluateNumber(right);
return(leftNumber + rightNumber);
}
case KeyOperator.Multiply:
{
var leftNumber = EvaluateNumber(left);
var rightNumber = EvaluateNumber(right);
return(leftNumber * rightNumber);
}
default:
throw new NotImplementedException();
}
}
public CustomizedKey(string keyChar, KeyType keyType = KeyType.Number, KeyOperator opt = KeyOperator.None)
{
this.KeyChar = keyChar;
this.Type = keyType;
this.Opeartor = opt;
}
