Feature/formula refactoring after delete rows

ReoGrid/Core/Cell.cs

@@ -972,7 +972,7 @@ private void ValidateAssociation()
 		[NonSerialized]
 		internal STNode formulaTree;
 
-		internal STNode FormulaTree { get { return this.formulaTree; } set { this.formulaTree = value; } }
+		internal STNode FormulaSyntaxTree { get { return this.formulaTree; } set { this.formulaTree = value; } }
 #endif
 
 		/// <summary>

ReoGrid/Core/Formula.cs

@@ -134,11 +134,11 @@ internal void SetCellFormula(Cell cell, STNode node)
 				{
 					IterateToAddReference(cell, node, referencedRanges, true);
 
-					cell.FormulaTree = node;
+					cell.FormulaSyntaxTree = node;
 				}
 				catch (CircularReferenceException crex)
 				{
-					cell.FormulaTree = null;
+					cell.FormulaSyntaxTree = null;
 					cell.InnerFormula = null;
 
 					cell.formulaStatus = FormulaStatus.CircularReference;
@@ -401,7 +401,7 @@ internal void RecalcCell(Cell cell, Stack<List<Cell>> dirtyCellStack = null)
 			{
 				try
 				{
-					value = Evaluator.CheckAndGetDefaultValue(cell, Evaluator.Evaluate(cell, cell.FormulaTree)).value;
+					value = Evaluator.CheckAndGetDefaultValue(cell, Evaluator.Evaluate(cell, cell.FormulaSyntaxTree)).value;
 
 					cell.formulaStatus = FormulaStatus.Normal;
 				}

ReoGrid/Core/Header.cs

@@ -34,6 +34,7 @@
 using unvell.ReoGrid.Actions;
 using unvell.ReoGrid.Utility;
 using System.Collections;
+using unvell.ReoGrid.Formula;
 
 #if OUTLINE
 using unvell.ReoGrid.Outline;
@@ -2145,6 +2146,17 @@ internal void DeleteRows(int row, int count, RemoveRowsAction action)
 			}
 			#endregion // Update frozen rows
 
+			#region Update Formulas
+			IterateCells(row + count, 0, MaxContentRow - row - count + 1, MaxContentCol + 1, true, (ir, ic, icell) =>
+				 {
+					 if (icell.HasFormula)
+					 {
+						 FormulaRefactor.OffsetFormulaReferences(this, icell, row + count, 0, -count, 0);
+					 }
+					 return true;
+				 });
+			#endregion Update Formulas
+
 			suspendingUIUpdates = false;
 
 			UpdateViewportController();

ReoGrid/Core/Range.cs

@@ -206,7 +206,7 @@ public void DeleteRangeData(RangePosition range, bool checkReadonly = false)
 
 					cell.InnerFormula = null;
 #if FORMULA
-					cell.FormulaTree = null;
+					cell.FormulaSyntaxTree = null;
 					this.ClearCellReferenceList(cell);
 
 					if (formulaDirtyCells.Contains(cell))

ReoGrid/Formula/Evaluator.cs

@@ -35,7 +35,7 @@ class Evaluator
 		public static FormulaValue Evaluate(Cell cell)
 		{
 			if (cell == null) return null;
-			return Evaluate(cell.Worksheet == null ? null : cell.Worksheet.workbook, cell, cell.FormulaTree);
+			return Evaluate(cell.Worksheet == null ? null : cell.Worksheet.workbook, cell, cell.FormulaSyntaxTree);
 		}
 
 		public static FormulaValue Evaluate(IWorkbook workbook, string input)

ReoGrid/Formula/Parser.cs

@@ -764,7 +764,7 @@ public override string ToString()
 		}
 
 		/// <summary>
-		/// Create a copy from this stnode.
+		/// Create a copy from this syntax tree node.
 		/// </summary>
 		/// <returns>The copied stnode.</returns>
 		public virtual object Clone()

ReoGrid/Formula/Refactor.cs

@@ -38,7 +38,7 @@ class FormulaRefactor
 	{
 		#region Generator
 		/// <summary>
-		/// Generate formula from a syntax tree in memory
+		/// Generate formula from a syntax tree in memory.
 		/// </summary>
 		/// <param name="node">root node of syntax tree used to generate formula</param>
 		/// <returns>formula generated from a syntax tree</returns>
@@ -48,7 +48,7 @@ internal static string Generate(string input, STNode node)
 		}
 
 		/// <summary>
-		/// Generate formula form a syntax tree in memory by specified format styles
+		/// Generate formula form a syntax tree in memory by specified format styles.
 		/// </summary>
 		/// <param name="node">root node of syntax tree used to generate formula</param>
 		/// <param name="flag">generating format style flags</param>
@@ -179,7 +179,7 @@ internal static void Reuse(Worksheet sheet, CellPosition fromPosition, RangePosi
 			#region Arguments Check
 			if (cell == null
 				|| string.IsNullOrEmpty(cell.InnerFormula)
-				|| cell.FormulaTree == null)
+				|| cell.FormulaSyntaxTree == null)
 			{
 				throw new InvalidOperationException("cannot found formula from specified position, try reset formula for the cell again");
 			}
@@ -195,8 +195,8 @@ internal static void Reuse(Worksheet sheet, CellPosition fromPosition, RangePosi
 			}
 			#endregion // Arguments Check
 
-			var rs = new ReplacableString(cell.InnerFormula);
-			STNode node = cell.FormulaTree;
+			var formulaString = new ReplacableString(cell.InnerFormula);
+			STNode node = cell.FormulaSyntaxTree;
 
 			Stack<List<Cell>> dirtyCells = new Stack<List<Cell>>();
 
@@ -212,7 +212,7 @@ internal static void Reuse(Worksheet sheet, CellPosition fromPosition, RangePosi
 						continue;
 					}
 
-					FormulaRefactor.CopyFormula(fromPosition, node, toCell, rs, dirtyCells);
+					FormulaRefactor.CopyFormula(fromPosition, node, toCell, formulaString, dirtyCells);
 
 					c += cell.Colspan;
 				}
@@ -340,6 +340,108 @@ internal static void CopyFormula(CellPosition fromPosition, STNode fromNode, Cel
 
 		}
 		#endregion // Reuse
+
+		internal static void OffsetFormulaReferences(Worksheet sheet, Cell cell, int startRow, int startCol,
+			int offsetRows, int offsetCols)
+		{
+			var node = cell.formulaTree;
+			var rs = new ReplacableString(cell.InnerFormula);
+
+			STNode.RecursivelyIterate(node, _n =>
+			{
+				switch (_n.Type)
+				{
+					case STNodeType.CELL:
+						#region Cell Offset
+						{
+							var refCellNode = (STCellNode)_n;
+
+							var newPos = refCellNode.Position;
+
+							if (refCellNode.Position.Row >= startRow
+								&& refCellNode.Position.Col >= startCol)
+							{
+								if (newPos.RowProperty == PositionProperty.Relative)
+								{
+									newPos.Row += offsetRows;
+								}
+
+								if (newPos.ColumnProperty == PositionProperty.Relative)
+								{
+									newPos.Col += offsetCols;
+								}
+							}
+
+							if (newPos.Row < 0 || newPos.Col < 0
+								|| newPos.Row >= sheet.rows.Count || newPos.Col >= sheet.cols.Count)
+							{
+								cell.formulaStatus = FormulaStatus.InvalidReference;
+							}
+
+							refCellNode.Position = newPos;
+
+							_n.Start += rs.Offset;
+							int diff = rs.Replace(_n.Start, _n.Length, newPos.ToAddress());
+							_n.Length += diff;
+						}
+						break;
+					#endregion // Cell Offset
+
+					case STNodeType.RANGE:
+						#region Range Offset
+						{
+							var refRangeNode = (STRangeNode)_n;
+							var newRange = refRangeNode.Range;
+
+							if (refRangeNode.Range.Row >= startRow
+								&& refRangeNode.Range.Col >= startCol)
+							{
+								if (newRange.StartRowProperty == PositionProperty.Relative)
+								{
+									newRange.Row += offsetRows;
+								}
+
+								if (newRange.StartColumnProperty == PositionProperty.Relative)
+								{
+									newRange.Col += offsetCols;
+								}
+							}
+
+							if (refRangeNode.Range.EndRow >= startRow
+								&& refRangeNode.Range.EndCol >= startCol)
+							{
+								if (newRange.StartRowProperty == PositionProperty.Relative)
+								{
+									newRange.Rows += offsetRows;
+								}
+
+								if (newRange.StartColumnProperty == PositionProperty.Relative)
+								{
+									newRange.Cols += offsetCols;
+								}
+							}
+
+							if (newRange.Row < 0 || newRange.Col < 0
+								|| newRange.Row >= sheet.rows.Count || newRange.Col >= sheet.cols.Count
+								|| newRange.EndRow < 0 || newRange.EndCol < 0
+								|| newRange.EndRow >= sheet.rows.Count || newRange.EndCol >= sheet.cols.Count)
+							{
+								cell.formulaStatus = FormulaStatus.InvalidReference;
+							}
+
+							refRangeNode.Range = newRange;
+
+							_n.Start += rs.Offset;
+							int diff = rs.Replace(_n.Start, _n.Length, newRange.ToAddress());
+							_n.Length += diff;
+						}
+						break;
+						#endregion // Range Offset
+				}
+			});
+
+			cell.InnerFormula = rs.ToString();
+		}
 	}
 
 	class ReplacableString

ReoGrid/Worksheet.cs

@@ -1171,6 +1171,11 @@ public void IterateCells(RangePosition range, bool skipEmptyCells, Func<int, int
 			this.IterateCells(fixedRange.Row, fixedRange.Col, fixedRange.Rows, fixedRange.Cols, skipEmptyCells, iterator);
 		}
 
+		public void IterateCells(int row, int col, int rows, int cols, Func<int, int, Cell, bool> iterator)
+		{
+			IterateCells(row, col, rows, cols, true, iterator);
+		}
+
 		/// <summary>
 		/// Iterate over all valid cells inside specified range. Invalid cells (merged by others cell) will be skipped.
 		/// </summary>