//Called when a cell's propertyChanged event is called. TExt or BGColor
public void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == "Text")
{
BasicCell temporary = sender as BasicCell;
string cellname = temporary.GetCellName();
//Delete the dependencies because the text has changed, need to edit
DeleteDependency(cellname);
//if the cell text is a formula, create an new expression tree and set the new dependencies!
if (temporary.Text != "" && temporary.Text[0] == '=' && temporary.Text.Length > 1)
{
string textlength = temporary.Text.Substring(2);
Int32.TryParse(textlength, out int textint);
if (textint > 50 || textint == 0)
{
temporary.setValue("!(bad Reference)");
}
ExpressionTree tree = new ExpressionTree(temporary.Text.Substring(1));
SetDependency(cellname, tree.GetVariables());
}
EvaluateCell(sender as Cell);
}
else if (e.PropertyName == "BGColor")
{
CellPropertyChanged(sender, new PropertyChangedEventArgs("BGColor"));
}
}
//helper function to evaluate the text value of a cell to determine the value value
private void EvaluateCell(Cell cell)
{
//make BasicCell to evaluate the cell
BasicCell evalCell = cell as BasicCell;
//variable for errors, if true, we have an error and should just return null
bool error = false;
//First check to see if it's empty
if (string.IsNullOrWhiteSpace(evalCell.Text))
{
//if text is empty, the value should be empty
evalCell.setValue("");
CellPropertyChanged(cell, new PropertyChangedEventArgs("Value"));
}
//next check to see if there is an '=' to make it a formula (and that it's more than just the =...
else if (evalCell.Text.Length > 1 && evalCell.Text[0] == '=')
{
//first get rid of the = at (0)
string text = evalCell.Text.Substring(1);
//create an expression tree!
ExpressionTree evalTree = new ExpressionTree(text);
// get the variables from the tree
string[] variables = evalTree.GetVariables();
//go through each variable. They are the locations of each cell needed for the formula.
foreach (string variableName in variables)
{
//First check to make sure that there is even a value to reference (call our new GetCell)
if (GetCell(variableName) == null)
{
//there was nothing to reference. Tell the user through the cell and cell prop changed
CellPropertyChanged(cell, new PropertyChangedEventArgs("Value"));
//break out of the loop & set error to true
error = true;
break;
}
// We have determine that the cell reference is valid. Set the variable to the expTree variable
//get the cell we need to edit
Cell variableCell = GetCell(variableName);
double variableValue;
//We will need to chck to make sure it work
//if the cell's value is empty, set the variable to 0.
if (string.IsNullOrEmpty(variableCell.Value))
{
evalTree.SetVar(variableName, 0);
}
//if the value of the cell is not a number, set to 0
else if (!double.TryParse(variableCell.Value, out variableValue))
{
evalTree.SetVar(variableName, 0);
}
//ELSE: should be valid! Set to the value!
else
{
evalTree.SetVar(variableName, variableValue);
}
//Don't have to worry about circular references, but self references could be bad here
string cellToEval = evalCell.ColumnIndex.ToString() + evalCell.RowIndex.ToString();
if (variableName == cellToEval)
{
evalCell.setValue("!(Self Reference)");
CellPropertyChanged(cell, new PropertyChangedEventArgs("Value"));
error = true;
break;
}
}
//if there is an error, stop here and return
if (error)
{
return;
}
//CIRCULAR REFERENCES - CASE 3 (HW 10)
//check each variable in the cell's list of variables
foreach (string variableName in variables)
{
//Check for circular references
if (IsCircularReference(variableName, evalCell.GetCellName()))
{
evalCell.setValue("!(Circular Reference)");
CellPropertyChanged(cell, new PropertyChangedEventArgs("Value"));
//if we find the circular reference we have an error and do not need to check further.
error = true;
break;
}
}
//Again, if there is an error, stop and return.
if (error)
{
return;
}
//Now, all variables should be set and we can evaluate the formula using the expression tree
evalCell.setValue(evalTree.Eval().ToString());
CellPropertyChanged(cell, new PropertyChangedEventArgs("Value"));
}
//last if it's neither of the above, it's not an formula, just test the value to the text of the original cell
else
{
evalCell.setValue(evalCell.Text);
CellPropertyChanged(cell, new PropertyChangedEventArgs("Value"));
}
//VERY LAST THING WE NEED IS TO UPDATE DEPENDENCIES! And evaluate all cells that were dependent on the one we just changed.
string cellName = evalCell.GetCellName();
if (dependencyDict.ContainsKey(cellName))
{
foreach (string dependentCell in dependencyDict[cellName])
{
EvaluateCell(GetCell(dependentCell));
}
}
}