static bool ContainsOrEqual(CalcCalculationManager mgr, CalcLocalIdentity id1, CalcLocalIdentity id2)
{
CalcLocalIdentityExtension.CompareResult result;
CalcLocalIdentityExtension.CompareResult result2;
if (id2.TryCompareTo(id1, out result, out result2))
{
CalcNode objA = mgr.Graph.GetNode(id2);
CalcExpression expression = mgr.GetExpression(id2);
if (expression == null)
{
return(false);
}
if ((!object.ReferenceEquals(objA, null) && (objA.OwnerNode != null)) && (expression is CalcSharedExpression))
{
return(false);
}
if (((id2 is CalcRangeIdentity) && (((result == CalcLocalIdentityExtension.CompareResult.Great_Intersected) || (result == CalcLocalIdentityExtension.CompareResult.Less_Intersected)) || (result == CalcLocalIdentityExtension.CompareResult.Contains))) && (((result2 == CalcLocalIdentityExtension.CompareResult.Great_Intersected) || (result2 == CalcLocalIdentityExtension.CompareResult.Less_Intersected)) || (result2 == CalcLocalIdentityExtension.CompareResult.Contains)))
{
if (!(mgr.GetExpression(id2) is CalcSharedExpression))
{
throw new InvalidOperationException(ResourceStrings.FormulaChangePartOfArrayFormulaError);
}
return(false);
}
if (((result == CalcLocalIdentityExtension.CompareResult.Contained) || (result == CalcLocalIdentityExtension.CompareResult.Equal)) && ((result2 == CalcLocalIdentityExtension.CompareResult.Contained) || (result2 == CalcLocalIdentityExtension.CompareResult.Equal)))
{
return(true);
}
}
return(false);
}
static void InvalidateNode(IFormulaOperatorSource mgr, ChangingContext context, CalcNode node)
{
using (Dictionary <CalcNode, CalcNode> .Enumerator enumerator = node.Dependents.GetEnumerator())
{
while (enumerator.MoveNext())
{
CalcLocalIdentity id = enumerator.Current.Key.Id as CalcLocalIdentity;
if ((id != null) && (node.Source == mgr.Source))
{
if (!context.ChangingIdentities.ContainsKey(id) && (mgr.GetExpression(id) != null))
{
context.InvalidateFormula(mgr, id);
}
}
else if (id != null)
{
IFormulaOperatorSource externalManager = mgr.GetExternalManager(node.Source);
if ((externalManager != null) && (externalManager.GetExpression(id) != null))
{
context.InvalidateFormula(externalManager, id);
}
}
}
}
}
public static bool ExtractIdentity(this CalcLocalIdentity id, out int row, out int column, out int rowCount, out int columnCount)
{
int num7;
int num8;
CalcCellIdentity objA = id as CalcCellIdentity;
CalcRangeIdentity identity2 = id as CalcRangeIdentity;
ConditionalGraph.ConditionalIdentity identity3 = id as ConditionalGraph.ConditionalIdentity;
if (!object.ReferenceEquals(objA, null))
{
row = objA.RowIndex;
column = objA.ColumnIndex;
rowCount = columnCount = 1;
return(true);
}
if (!object.ReferenceEquals(identity2, null))
{
if (identity2.IsFullRow && identity2.IsFullColumn)
{
int num2;
int num3;
columnCount = num2 = -1;
rowCount = num3 = num2;
row = column = num3;
}
else if (identity2.IsFullRow)
{
column = columnCount = -1;
row = identity2.RowIndex;
rowCount = identity2.RowCount;
}
else if (identity2.IsFullColumn)
{
row = rowCount = -1;
column = identity2.ColumnIndex;
columnCount = identity2.ColumnCount;
}
else
{
row = identity2.RowIndex;
rowCount = identity2.RowCount;
column = identity2.ColumnIndex;
columnCount = identity2.ColumnCount;
}
return(true);
}
if (!object.ReferenceEquals(identity3, null))
{
return(identity3.ActualIdentity.ExtractIdentity(out row, out column, out rowCount, out columnCount));
}
columnCount = num7 = -2147483648;
rowCount = num8 = num7;
row = column = num8;
return(false);
}
public void AddDataValidation(int row, int column, DataValidator validator)
{
IConditionalFormula[] formulaConditions = validator.FormulaConditions;
if ((formulaConditions != null) && (formulaConditions.Length != 0))
{
CalcLocalIdentity actualId = FormulaOperatorHelper.Indexs2Identity(row, column, row, column);
List <IConditionalFormula> list = new List <IConditionalFormula>();
list.AddRange(formulaConditions);
base.AddConditionals(actualId, (ICollection <IConditionalFormula>)list);
}
}
public void AddExtChangedFormula(IFormulaOperatorSource manager, CalcLocalIdentity id, CalcLocalIdentity oldId, CalcExpression expr)
{
Dictionary <CalcLocalIdentity, Tuple <CalcLocalIdentity, CalcExpression> > dictionary;
if (!this.ExtChangedFormulas.TryGetValue(manager, out dictionary))
{
dictionary = new Dictionary <CalcLocalIdentity, Tuple <CalcLocalIdentity, CalcExpression> >();
this.ExtChangedFormulas[manager] = dictionary;
}
dictionary[id] = new Tuple <CalcLocalIdentity, CalcExpression>(oldId, expr);
}
public void InvalidateFormula(IFormulaOperatorSource manager, CalcLocalIdentity id)
{
Dictionary <CalcLocalIdentity, CalcLocalIdentity> dictionary;
if (!this.InvalidateIdentities.TryGetValue(manager, out dictionary))
{
dictionary = new Dictionary <CalcLocalIdentity, CalcLocalIdentity>();
this.InvalidateIdentities[manager] = dictionary;
}
dictionary[id] = id;
}
public static void SetFormula(CalcCalculationManager mgr, CalcLocalIdentity id, string fromula, bool isArrayFormual)
{
if (id is CalcCellIdentity)
{
mgr.SetFormula(id as CalcCellIdentity, fromula, isArrayFormual);
}
if (id is CalcRangeIdentity)
{
mgr.SetFormula(id as CalcRangeIdentity, fromula, isArrayFormual);
}
}
static void GetDependentsFromulas(CalcCalculationManager sourceMgr, CalcCalculationManager targetMgr, ChangingContext context, int fromRow, int fromColumn, int toRow, int toColumn, int fromRowCount, Dictionary <CalcLocalIdentity, CalcExpression> formulas, int fromColumnCount, bool offsetSelf, bool updataDependens)
{
int rowOffset = toRow - fromRow;
int columnOffset = toColumn - fromColumn;
CalcLocalIdentity id = FormulaOperatorHelper.Indexs2Identity(fromRow, fromColumn, (fromRow + fromRowCount) - 1, (fromColumn + fromColumnCount) - 1);
CellRange fromRange = new CellRange(fromRow, fromColumn, fromRowCount, fromColumnCount);
MoveVisitor visitor = new MoveVisitor(fromRange, rowOffset, columnOffset, 0x7fffffff, 0x7fffffff, true, targetMgr.Source, sourceMgr != targetMgr, null, !offsetSelf);
sourceMgr.Source.GetEvaluatorContext(new CalcCellIdentity(toRow, toColumn));
new Dictionary <CalcIdentity, CalcIdentity>();
CalcNode node = sourceMgr.Graph.GetNode(id);
IFormulaOperatorSource mgr = new SpreadCalcAxialManager.FormulaOperatorSource(sourceMgr);
List <CalcLocalIdentity> list = new List <CalcLocalIdentity>();
HashSet <CalcNode> arrayFormulaNodes = new HashSet <CalcNode>();
if ((node != null) && updataDependens)
{
list = FormulaOperatorHelper.GetChangedDependents(mgr, context, node, arrayFormulaNodes, formulas, null);
}
if (offsetSelf && updataDependens)
{
foreach (CalcIdentity identity2 in sourceMgr.Graph.GetAllLocalIdentities())
{
int num3;
int num4;
int num5;
int num6;
FormulaOperatorHelper.Identity2Indexs(identity2, out num3, out num4, out num5, out num6);
if ((((fromRow == -1) || (num3 >= fromRow)) && ((fromRow == -1) || (num5 < (fromRow + fromRowCount)))) && (((fromColumn == -1) || (num4 >= fromColumn)) && ((fromColumn == -1) || (num6 < (fromColumn + fromColumnCount)))))
{
CalcNode node2 = sourceMgr.Graph.GetNode(identity2);
if ((node2 != null) && (node2.Dependents != null))
{
list.AddRange((IEnumerable <CalcLocalIdentity>)FormulaOperatorHelper.GetChangedDependents(mgr, context, node2, arrayFormulaNodes, formulas, null));
}
}
}
visitor.CurrentCalcSource = sourceMgr.Source;
foreach (CalcLocalIdentity identity3 in list)
{
int num7;
int num8;
int num9;
int num10;
CalcExpression expr = formulas[identity3];
FormulaOperatorHelper.Identity2Indexs(identity3, out num7, out num8, out num9, out num10);
expr = visitor.Visit(expr, num7, num8);
formulas[identity3] = expr;
}
}
FormulaOperatorHelper.UpdataInvalidFormula(mgr, context, visitor);
}
public static void UpdataChangings(IFormulaOperatorSource manager, ChangingContext context)
{
Dictionary <CalcLocalIdentity, Tuple <CalcLocalIdentity, CalcExpression> > changedFormulas = context.ChangedFormulas;
Dictionary <IFormulaOperatorSource, Dictionary <CalcLocalIdentity, Tuple <CalcLocalIdentity, CalcExpression> > > extChangedFormulas = context.ExtChangedFormulas;
foreach (CalcLocalIdentity identity in changedFormulas.Keys)
{
manager.ClearExpression(identity);
}
foreach (KeyValuePair <IFormulaOperatorSource, Dictionary <CalcLocalIdentity, Tuple <CalcLocalIdentity, CalcExpression> > > pair in extChangedFormulas)
{
foreach (CalcLocalIdentity identity2 in pair.Value.Keys)
{
pair.Key.ClearExpression(identity2);
}
}
foreach (KeyValuePair <CalcLocalIdentity, Tuple <CalcLocalIdentity, CalcExpression> > pair2 in changedFormulas)
{
if (pair2.Value != null)
{
CalcLocalIdentity id = pair2.Key;
manager.SetExpression(id, pair2.Value.Item2);
context.InvalidateFormula(manager, id);
}
}
foreach (KeyValuePair <IFormulaOperatorSource, Dictionary <CalcLocalIdentity, Tuple <CalcLocalIdentity, CalcExpression> > > pair3 in extChangedFormulas)
{
foreach (KeyValuePair <CalcLocalIdentity, Tuple <CalcLocalIdentity, CalcExpression> > pair4 in pair3.Value)
{
if (pair4.Value != null)
{
CalcLocalIdentity identity4 = pair4.Key;
pair3.Key.SetExpression(identity4, pair4.Value.Item2);
context.InvalidateFormula(pair3.Key, identity4);
}
}
}
foreach (KeyValuePair <IFormulaOperatorSource, Dictionary <CalcLocalIdentity, CalcLocalIdentity> > pair5 in context.InvalidateIdentities)
{
foreach (KeyValuePair <CalcLocalIdentity, CalcLocalIdentity> pair6 in pair5.Value)
{
if (pair6.Value != null)
{
CalcLocalIdentity identity5 = pair6.Key;
pair5.Key.Invalidate(identity5, false);
}
}
}
}
static CalcLocalIdentity Offset(CalcLocalIdentity id, int rowOffset, int colOffset)
{
CalcCellIdentity cellIdentity = id as CalcCellIdentity;
CalcRangeIdentity range = id as CalcRangeIdentity;
if (cellIdentity != null)
{
return(new CalcCellIdentity(cellIdentity, rowOffset, colOffset));
}
if (range != null)
{
return(new CalcRangeIdentity(range, rowOffset, colOffset));
}
return(id);
}
public static CompareResult CompareRowTo(this CalcLocalIdentity This, CalcLocalIdentity other)
{
int num;
int num2;
int num3;
int num4;
int num5;
int num6;
int num7;
int num8;
if (This.ExtractIdentity(out num, out num3, out num2, out num4) && other.ExtractIdentity(out num5, out num7, out num6, out num8))
{
return(Compare(num, num2, num5, num6));
}
return(CompareResult.None);
}
public static void Clear(CalcCalculationManager mgr, CalcLocalIdentity id)
{
Dictionary <CalcCellIdentity, CalcExpression> dictionary;
Dictionary <CalcRangeIdentity, CalcExpression> dictionary2;
FormulaOperatorHelper.GetAllContainsIds(mgr, id, out dictionary, out dictionary2);
foreach (CalcCellIdentity identity in dictionary.Keys)
{
mgr.ClearExpression(identity);
mgr.Invalidate(identity, false);
}
foreach (CalcRangeIdentity identity2 in dictionary2.Keys)
{
mgr.ClearExpression(identity2);
mgr.Invalidate(identity2, false);
}
}
public void Swap(int fromRow, int fromColumn, int toRow, int toColumn, int rowCount, int columnCount)
{
CalcLocalIdentity id = FormulaOperatorHelper.Indexs2Identity(fromRow, fromColumn, (fromRow + rowCount) - 1, (fromColumn + columnCount) - 1);
Dictionary <CalcLocalIdentity, CalcExpression> allContainsIds = FormulaOperatorHelper.GetAllContainsIds(this.Manager, id);
CalcLocalIdentity identity2 = FormulaOperatorHelper.Indexs2Identity(toRow, toColumn, (toRow + rowCount) - 1, (toColumn + columnCount) - 1);
Dictionary <CalcLocalIdentity, CalcExpression> dictionary2 = FormulaOperatorHelper.GetAllContainsIds(this.Manager, identity2);
foreach (KeyValuePair <CalcLocalIdentity, CalcExpression> pair in allContainsIds)
{
this.Manager.ClearExpression(pair.Key);
}
foreach (KeyValuePair <CalcLocalIdentity, CalcExpression> pair2 in dictionary2)
{
this.Manager.ClearExpression(pair2.Key);
}
int rowOffset = toRow - fromRow;
int colOffset = toColumn - fromColumn;
ReferenceValidateVisitor visitor = new ReferenceValidateVisitor(new int?(this.RowCount), new int?(this.ColumnCount));
foreach (KeyValuePair <CalcLocalIdentity, CalcExpression> pair3 in allContainsIds)
{
int num3;
int num4;
int num5;
int num6;
FormulaOperatorHelper.Identity2Indexs(pair3.Key, out num3, out num4, out num5, out num6);
CalcLocalIdentity identity3 = Offset(pair3.Key, rowOffset, colOffset);
bool?isArrayFormula = null;
CalcExpressionHelper.SetExpression(this.Manager, identity3, visitor.Visit(pair3.Value, num3 + rowOffset, num4 + colOffset), isArrayFormula);
this.Manager.Invalidate(identity3, false);
}
foreach (KeyValuePair <CalcLocalIdentity, CalcExpression> pair4 in dictionary2)
{
int num7;
int num8;
int num9;
int num10;
FormulaOperatorHelper.Identity2Indexs(pair4.Key, out num7, out num8, out num9, out num10);
CalcLocalIdentity identity4 = Offset(pair4.Key, -rowOffset, -colOffset);
bool?nullable2 = null;
CalcExpressionHelper.SetExpression(this.Manager, identity4, visitor.Visit(pair4.Value, num7 - rowOffset, num8 - colOffset), nullable2);
this.Manager.Invalidate(identity4, false);
}
}
public static void SetExpression(CalcCalculationManager mgr, CalcLocalIdentity id, CalcExpression expr, bool?isArrayFormula = new bool?())
{
if (id is CalcCellIdentity)
{
mgr.SetExpression(id as CalcCellIdentity, expr, false);
}
if (id is CalcRangeIdentity)
{
if (!isArrayFormula.HasValue)
{
isArrayFormula = new bool?(!(expr is CalcSharedExpression));
}
else
{
CalcSharedExpression expression1 = expr as CalcSharedExpression;
}
mgr.SetExpression(id as CalcRangeIdentity, expr, isArrayFormula.Value);
}
}
Dictionary <CalcLocalIdentity, List <ConditionalGraph.ConditionalIdentity> > GetAllFromulas(int row, int col, int rowCount, int colCount)
{
Dictionary <CalcLocalIdentity, List <ConditionalGraph.ConditionalIdentity> > dictionary = new Dictionary <CalcLocalIdentity, List <ConditionalGraph.ConditionalIdentity> >();
rowCount = (rowCount <= 0) ? 1 : rowCount;
colCount = (colCount <= 0) ? 1 : colCount;
for (int i = 0; i < (row + rowCount); i++)
{
for (int j = 0; j < (col + colCount); j++)
{
CalcLocalIdentity actualId = FormulaOperatorHelper.Indexs2Identity(i, j, i, j);
List <ConditionalGraph.ConditionalIdentity> formulas = base.GetFormulas(actualId);
if ((formulas != null) && (formulas.Count > 0))
{
dictionary[actualId] = formulas;
}
}
}
return(dictionary);
}
public static bool TryCompareTo(this CalcLocalIdentity This, CalcLocalIdentity other, out CompareResult rowCompareResult, out CompareResult columnCompareResult)
{
int num;
int num2;
int num3;
int num4;
int num5;
int num6;
int num7;
int num8;
if (This.ExtractIdentity(out num, out num3, out num2, out num4) && other.ExtractIdentity(out num5, out num7, out num6, out num8))
{
rowCompareResult = Compare(num, num2, num5, num6);
columnCompareResult = Compare(num3, num4, num7, num8);
return(true);
}
rowCompareResult = CompareResult.None;
columnCompareResult = CompareResult.None;
return(false);
}
Dictionary <CalcLocalIdentity, CalcExpression> GetFormulaIds(int fromRow, int fromColumn, int rowCount, int columnCount, CalcCalculationManager sourceMgr, ChangingContext context, bool clearSource)
{
CalcLocalIdentity id = FormulaOperatorHelper.Indexs2Identity(fromRow, fromColumn, (fromRow + rowCount) - 1, (fromColumn + columnCount) - 1);
Dictionary <CalcLocalIdentity, CalcExpression> allContainsIds = FormulaOperatorHelper.GetAllContainsIds(sourceMgr, id);
if (clearSource)
{
foreach (CalcLocalIdentity identity2 in allContainsIds.Keys)
{
if (sourceMgr == this.Manager)
{
context.ChangedFormulas[identity2] = null;
}
else
{
context.AddExtChangedFormula(new FormulaOperatorSource(sourceMgr), identity2, identity2, null);
}
}
}
return(allContainsIds);
}
internal static void GetAllContainsIds(CalcCalculationManager mgr, CalcLocalIdentity id, out Dictionary <CalcCellIdentity, CalcExpression> cellFromulas, out Dictionary <CalcRangeIdentity, CalcExpression> arrayFormulas)
{
cellFromulas = new Dictionary <CalcCellIdentity, CalcExpression>();
arrayFormulas = new Dictionary <CalcRangeIdentity, CalcExpression>();
CalcLocalIdentity identity = id;
CalcExpression expression = mgr.GetExpression(identity);
if ((expression == null) && (id is CalcCellIdentity))
{
int rowIndex = (id as CalcCellIdentity).RowIndex;
int columnIndex = (id as CalcCellIdentity).ColumnIndex;
CalcRangeIdentity identity2 = new CalcRangeIdentity(rowIndex, columnIndex, 1, 1);
expression = mgr.GetExpression(identity2);
identity = identity2;
}
bool flag = false;
if (expression == null)
{
flag = mgr.IsIsIntersectantWithArrayFormula(identity);
}
if (expression != null)
{
if (identity is CalcCellIdentity)
{
cellFromulas.Add(identity as CalcCellIdentity, expression);
}
else if (identity is CalcRangeIdentity)
{
arrayFormulas.Add(identity as CalcRangeIdentity, expression);
}
}
else
{
if ((id is CalcCellIdentity) && flag)
{
throw new InvalidOperationException(ResourceStrings.FormulaChangePartOfArrayFormulaError);
}
if (id is CalcRangeIdentity)
{
CalcRangeIdentity identity3 = id as CalcRangeIdentity;
if ((identity3.RowCount != 1) || (identity3.ColumnCount != 1))
{
foreach (CalcLocalIdentity identity4 in mgr.Graph.GetAllLocalIdentities())
{
if (ContainsOrEqual(mgr, id, identity4))
{
expression = mgr.GetExpression(identity4);
if (expression != null)
{
if (identity4 is CalcCellIdentity)
{
cellFromulas[identity4 as CalcCellIdentity] = expression;
}
else if (identity4 is CalcRangeIdentity)
{
arrayFormulas.Add(identity4 as CalcRangeIdentity, expression);
}
}
}
}
}
}
}
}
public void RemoveDataValidation(int row, int column)
{
CalcLocalIdentity actualId = FormulaOperatorHelper.Indexs2Identity(row, column, row, column);
base.RemoveConditionals(actualId, null);
}
public static List <CalcLocalIdentity> GetChangedDependents(IFormulaOperatorSource mgr, ChangingContext context, CalcNode node, HashSet <CalcNode> arrayFormulaNodes, Dictionary <CalcLocalIdentity, CalcExpression> formulas1 = null, Dictionary <CalcLocalIdentity, CalcExpression> formulas2 = null)
{
List <CalcLocalIdentity> list = new List <CalcLocalIdentity>();
if (node.Dependents != null)
{
CalcNode myOwnerNode;
foreach (CalcNode ownerNode in node.Dependents.Keys)
{
myOwnerNode = ownerNode;
if (ownerNode.OwnerNode != null)
{
myOwnerNode = ownerNode.OwnerNode;
if (arrayFormulaNodes.Contains(myOwnerNode) || (mgr.GetExpression(myOwnerNode.Id as CalcLocalIdentity) is CalcSharedExpression))
{
continue;
}
arrayFormulaNodes.Add(myOwnerNode);
}
CalcLocalIdentity id = myOwnerNode.Id as CalcLocalIdentity;
if ((id != null) && (myOwnerNode.Source == mgr.Source))
{
if (!context.ChangingIdentities.ContainsKey(id))
{
CalcExpression expression = mgr.GetExpression(id);
if (expression != null)
{
if (((formulas1 != null) && formulas1.ContainsKey(id)) || ((formulas2 != null) && formulas2.ContainsKey(id)))
{
list.Add(id);
}
else
{
context.ChangedFormulas[id] = new Tuple <CalcLocalIdentity, CalcExpression>(id, expression);
}
}
}
}
else if ((id != null) && ((myOwnerNode.Source != mgr.Source) || !context.ChangingIdentities.ContainsKey(id)))
{
IFormulaOperatorSource externalManager = mgr.GetExternalManager(myOwnerNode.Source);
if (externalManager != null)
{
CalcExpression expr = externalManager.GetExpression(id);
if (expr != null)
{
if (((formulas1 != null) && formulas1.ContainsKey(id)) || ((formulas2 != null) && formulas2.ContainsKey(id)))
{
list.Add(id);
}
else
{
context.AddExtChangedFormula(externalManager, id, id, expr);
}
}
}
}
}
}
return(list);
}
public void SetValue(CalcLocalIdentity id, object value)
{
throw new InvalidOperationException();
}
public static List <CalcRangeIdentity> GetAllContainsArrayFormulaIds(CalcCalculationManager manager, CalcLocalIdentity id)
{
int num;
int num2;
int num3;
int num4;
List <CalcRangeIdentity> list = new List <CalcRangeIdentity>();
Identity2Indexs(id, out num, out num2, out num3, out num4);
foreach (CalcRangeIdentity identity in manager.Graph.GetAllArrayFormulaIdentities())
{
if (ContainsOrEqual(manager, id, identity))
{
list.Add(identity);
}
}
return(list);
}
public static bool TryCompareColumnTo(this CalcLocalIdentity This, CalcLocalIdentity other, out CompareResult columnCompareResult)
{
columnCompareResult = This.CompareColumnTo(other);
return(columnCompareResult != CompareResult.None);
}
static void GetChangingIds(IFormulaOperatorSource mgr, bool row, ChangingContext context, OperatorExpressionVisistor visitor, bool updateDependents)
{
foreach (CalcLocalIdentity identity in mgr.GetAllLocalIdentities())
{
CalcIdentity id = identity;
if (identity is ConditionalGraph.ConditionalIdentity)
{
ConditionalGraph.ConditionalIdentity identity3 = identity as ConditionalGraph.ConditionalIdentity;
id = (identity3.OldActualIdentity != null) ? identity3.OldActualIdentity : identity3.ActualIdentity;
}
CalcNode node = mgr.GetNode(id);
if ((node == null) || (node.OwnerNode == null))
{
CalcCellIdentity identity4 = id as CalcCellIdentity;
CalcRangeIdentity identity5 = id as CalcRangeIdentity;
CalcExpression expression = mgr.GetExpression(identity);
CalcLocalIdentity identity6 = null;
int oldStart = -2147483648;
int oldEnd = -2147483648;
int newEnd = -2147483648;
if (identity4 != null)
{
oldStart = row ? identity4.RowIndex : identity4.ColumnIndex;
}
else if (identity5 != null)
{
if (identity5.IsFullRow && identity5.IsFullColumn)
{
identity6 = identity;
oldStart = 0;
}
else if ((identity5.IsFullRow && !row) || (identity5.IsFullColumn && row))
{
if (node != null)
{
context.InvalidateFormula(mgr, identity5);
}
if (((node == null) || (node.Dependents == null)) || ((node.Dependents.Count == 0) || !updateDependents))
{
continue;
}
InvalidateNode(mgr, context, node);
}
else
{
oldStart = row ? identity5.RowIndex : identity5.ColumnIndex;
oldEnd = row ? ((identity5.RowIndex + identity5.RowCount) - 1) : ((identity5.ColumnIndex + identity5.ColumnCount) - 1);
}
}
if (oldStart != -2147483648)
{
if (identity6 == null)
{
int num2;
if (identity5 != null)
{
visitor.GetRangeOffset(oldStart, oldEnd, out num2, out newEnd);
if ((num2 == oldStart) && (newEnd == oldEnd))
{
continue;
}
if ((num2 == -2147483648) || (newEnd == -2147483648))
{
expression = null;
}
else if (identity5.IsFullRow && row)
{
identity6 = new CalcRangeIdentity(num2, (newEnd - num2) + 1, true);
}
else if (identity5.IsFullColumn && !row)
{
identity6 = new CalcRangeIdentity(num2, (newEnd - num2) + 1, false);
}
else if (row)
{
identity6 = new CalcRangeIdentity(num2, identity5.ColumnIndex, (newEnd - num2) + 1, identity5.ColumnCount);
}
else
{
identity6 = new CalcRangeIdentity(identity5.RowIndex, num2, identity5.RowCount, (newEnd - num2) + 1);
}
}
else if (identity4 != null)
{
visitor.GetCellOffset(oldStart, out num2);
if (num2 == oldStart)
{
continue;
}
if (num2 == -2147483648)
{
expression = null;
}
else if (identity4 != null)
{
identity6 = row ? new CalcCellIdentity(num2, identity4.ColumnIndex) : new CalcCellIdentity(identity4.RowIndex, num2);
}
}
}
context.ChangingIdentities[identity] = identity;
if (expression != null)
{
identity6 = (identity is ConditionalGraph.ConditionalIdentity) ? identity : identity6;
context.ChangedFormulas[identity6] = new Tuple <CalcLocalIdentity, CalcExpression>(identity, expression);
}
}
}
}
}
internal static Dictionary <CalcLocalIdentity, CalcExpression> GetAllContainsIds(CalcCalculationManager mgr, CalcLocalIdentity id)
{
Dictionary <CalcCellIdentity, CalcExpression> dictionary2;
Dictionary <CalcRangeIdentity, CalcExpression> dictionary3;
Dictionary <CalcLocalIdentity, CalcExpression> dictionary = new Dictionary <CalcLocalIdentity, CalcExpression>();
GetAllContainsIds(mgr, id, out dictionary2, out dictionary3);
foreach (KeyValuePair <CalcCellIdentity, CalcExpression> pair in dictionary2)
{
CalcCellIdentity introduced7 = pair.Key;
dictionary[introduced7] = pair.Value;
}
foreach (KeyValuePair <CalcRangeIdentity, CalcExpression> pair2 in dictionary3)
{
CalcRangeIdentity introduced8 = pair2.Key;
dictionary[introduced8] = pair2.Value;
}
return(dictionary);
}
public CalcParserContext GetParserContext(CalcLocalIdentity baseAddress)
{
throw new InvalidOperationException();
}
public void SetExpression(CalcLocalIdentity id, CalcExpression expr)
{
CalcExpressionHelper.SetExpression(this.Manager, id, expr, null);
}
public object GetValue(CalcLocalIdentity id)
{
throw new InvalidOperationException();
}
public static bool TryCompareRowTo(this CalcLocalIdentity This, CalcLocalIdentity other, out CompareResult rowCompareResult)
{
rowCompareResult = This.CompareRowTo(other);
return(rowCompareResult != CompareResult.None);
}
public static void UpdataInvalidFormula(IFormulaOperatorSource mgr, ChangingContext context, Dt.Cells.Data.ExpressionVisitor visitor)
{
foreach (KeyValuePair <CalcLocalIdentity, CalcLocalIdentity> pair in context.ChangingIdentities)
{
if (mgr.GetExpression(pair.Key) != null)
{
mgr.ClearExpression(pair.Key);
}
else
{
mgr.ClearNode(pair.Key);
}
}
foreach (KeyValuePair <CalcLocalIdentity, Tuple <CalcLocalIdentity, CalcExpression> > pair2 in context.ChangedFormulas)
{
if (pair2.Value == null)
{
mgr.ClearExpression(pair2.Key);
}
else
{
int num;
int num2;
int num3;
int num4;
Identity2Indexs(GetActualId(pair2.Value.Item1), out num, out num2, out num3, out num4);
CalcExpression expr = visitor.Visit(pair2.Value.Item2, num, num2);
mgr.SetExpression(pair2.Key, expr);
}
context.InvalidateFormula(mgr, pair2.Key);
}
OperatorExpressionVisistorBase base2 = visitor as OperatorExpressionVisistorBase;
if (base2 != null)
{
base2.CurrentCalcSource = mgr.Source;
base2.OffsetExternalOnly = true;
}
foreach (KeyValuePair <IFormulaOperatorSource, Dictionary <CalcLocalIdentity, Tuple <CalcLocalIdentity, CalcExpression> > > pair3 in context.ExtChangedFormulas)
{
foreach (KeyValuePair <CalcLocalIdentity, Tuple <CalcLocalIdentity, CalcExpression> > pair4 in pair3.Value)
{
CalcLocalIdentity id = pair4.Key;
if (pair4.Value.Item2 == null)
{
pair3.Key.ClearExpression(id);
}
else
{
int num5;
int num6;
int num7;
int num8;
Identity2Indexs(GetActualId(pair4.Value.Item1), out num5, out num6, out num7, out num8);
CalcExpression expression2 = visitor.Visit(pair4.Value.Item2, num5, num6);
pair3.Key.SetExpression(id, expression2);
}
context.InvalidateFormula(pair3.Key, id);
}
}
foreach (KeyValuePair <IFormulaOperatorSource, Dictionary <CalcLocalIdentity, CalcLocalIdentity> > pair5 in context.InvalidateIdentities)
{
List <CalcLocalIdentity> list = new List <CalcLocalIdentity>();
foreach (KeyValuePair <CalcLocalIdentity, CalcLocalIdentity> pair6 in pair5.Value)
{
if (pair6.Value != null)
{
list.Add(pair6.Key);
}
}
pair5.Key.Invalidate((IEnumerable <CalcLocalIdentity>)list, false);
}
}
