internal void ResumeCalcGraph()
{
Exception exception = null;
CalcExpression expr = null;
foreach (KeyValuePair <CalcLocalIdentity, Tuple <CalcExpression, bool> > pair in this._tmpFormulas)
{
CalcLocalIdentity key = pair.Key;
expr = pair.Value.Item1;
try
{
this.Graph.SetNode(key, expr, this.Source.GetEvaluatorContext(key), this.Source, pair.Value.Item2);
this._formulas[key] = expr;
}
catch (Exception exception2)
{
if (exception == null)
{
exception = exception2;
}
}
}
this._tmpFormulas.Clear();
if (exception != null)
{
throw exception;
}
}
public DirtyItem(CalcService service, ICalcSource source, CalcLocalIdentity id, CalcNode node)
{
this.Service = service;
this.Source = source;
this.Id = id;
this.Node = node;
}
private void GetBaseIndex(CalcLocalIdentity lid, out int row, out int column)
{
CalcCellIdentity objA = lid as CalcCellIdentity;
if (!object.ReferenceEquals(objA, null))
{
row = objA.RowIndex;
column = objA.ColumnIndex;
}
else
{
CalcRangeIdentity identity2 = lid as CalcRangeIdentity;
if (!object.ReferenceEquals(identity2, null))
{
row = identity2.RowIndex;
row = (row < 0) ? 0 : row;
column = identity2.ColumnIndex;
column = (column < 0) ? 0 : column;
}
else
{
row = -1;
column = -1;
}
}
}
private static object ExtractValueFromReference(CalcLocalIdentity localId, object value)
{
for (CalcReference reference = value as CalcReference; (reference != null) && !(localId is CalcRangeIdentity); reference = value as CalcReference)
{
CalcCellIdentity objA = localId as CalcCellIdentity;
int rowCount = reference.GetRowCount(0);
int columnCount = reference.GetColumnCount(0);
if (((reference.RangeCount <= 0) || (rowCount <= 0)) || (columnCount <= 0))
{
value = CalcErrors.Reference;
}
else
{
try
{
if (!object.ReferenceEquals(objA, null))
{
if ((reference.RangeCount != 1) || ((rowCount > 1) && (columnCount > 1)))
{
value = CalcErrors.Value;
}
else
{
int rowOffset = objA.RowIndex - reference.GetRow(0);
int columnOffset = objA.ColumnIndex - reference.GetColumn(0);
if ((rowCount == 1) && (columnCount == 1))
{
value = reference.GetValue(0, 0, 0);
}
else if (((rowCount == 1) && (columnCount > 1)) && ((columnOffset >= 0) && (columnOffset < columnCount)))
{
value = reference.GetValue(0, 0, columnOffset);
}
else if (((rowCount > 1) && (columnCount == 1)) && ((rowOffset >= 0) && (rowOffset < rowCount)))
{
value = reference.GetValue(0, rowOffset, 0);
}
else
{
value = CalcErrors.Value;
}
}
}
else
{
value = reference.GetValue(0, 0, 0);
}
}
catch (InvalidCastException)
{
value = CalcErrors.Value;
}
}
}
return(value);
}
/// <summary>
/// Gets the value at specified position which indicated by <paramref name="id" />.
/// </summary>
/// <param name="id">A <see cref="T:Dt.CalcEngine.CalcIdentity" /> indicates the identity of a address.</param>
/// <returns>
/// An <see cref="T:System.Object" /> indicates the value.
/// If the <paramref name="id" /> is not recognized, return <see cref="F:Dt.CalcEngine.CalcErrors.Reference" />.
/// </returns>
public virtual object GetValue(CalcIdentity id)
{
if (id is CalcExternalIdentity)
{
CalcExternalIdentity identity = id as CalcExternalIdentity;
ICalcSource source = identity.Source;
if (source != null)
{
CalcLocalIdentity identity3;
CalcLocalIdentity identity2 = identity.ConvertToLocal();
if ((this.ArrayFormulaMode || (this.RowCount > 1)) || (this.ColumnCount > 1))
{
identity3 = new CalcRangeIdentity(this.Row, this.Column, this.RowCount, this.ColumnCount);
}
else
{
identity3 = new CalcCellIdentity(this.Row, this.Column);
}
return(source.GetEvaluatorContext(identity3).GetValue(identity2));
}
}
else if ((this.Source != null) && (id is CalcLocalIdentity))
{
CalcRangeIdentity objA = id as CalcRangeIdentity;
if (object.ReferenceEquals(objA, null))
{
return(this.Source.GetValue(id as CalcLocalIdentity));
}
if (objA._isFullColumn && objA._isFullRow)
{
return(this.Source.GetValue(new CalcCellIdentity(this.Row, this.Column)));
}
if (objA._isFullColumn)
{
return(this.Source.GetValue(new CalcCellIdentity(this.Row, objA._columnIndex)));
}
if (objA._isFullRow)
{
return(this.Source.GetValue(new CalcCellIdentity(objA._rowIndex, this.Column)));
}
if (((objA._rowCount == 1) && (objA._columnIndex <= this.Column)) && (this.Column < (objA._columnIndex + objA._columnCount)))
{
return(this.Source.GetValue(new CalcCellIdentity(objA._rowIndex, this.Column)));
}
if (((objA._columnCount == 1) && (objA._rowIndex <= this.Row)) && (this.Row < (objA._rowIndex + objA._rowCount)))
{
return(this.Source.GetValue(new CalcCellIdentity(this.Row, objA._columnIndex)));
}
if ((objA._rowCount == 1) && (objA._columnCount == 1))
{
return(this.Source.GetValue(new CalcCellIdentity(objA._rowIndex, objA._columnIndex)));
}
return(CalcErrors.Value);
}
return(CalcErrors.Reference);
}
private CalcExpression GetExpressionCore(CalcLocalIdentity id)
{
Tuple <CalcExpression, bool> tuple;
CalcExpression objB = this._formulas[id];
if ((object.ReferenceEquals(null, objB) && this.Service.IsGraphSuspended) && this._tmpFormulas.TryGetValue(id, out tuple))
{
objB = tuple.Item1;
}
return(objB);
}
/// <summary>
/// Normalizes the specified node to convert all external reference to internal reference.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="node">The node.</param>
/// <returns>
/// If <paramref name="node" /> is external identity, return a new node which identity is not external, otherwise, return <paramref name="node" />.
/// </returns>
internal static CalcNode Normalize(CalcService service, CalcNode node)
{
if (!object.ReferenceEquals(node, null) && (node.Id is CalcExternalIdentity))
{
CalcExternalIdentity id = node.Id as CalcExternalIdentity;
CalcGraph graph = service.GetCalculationManager(id.Source, null, true).Graph;
CalcLocalIdentity identity2 = id.ConvertToLocal();
node = graph.GetNode(identity2) ?? new CalcNode(id.Source, identity2);
}
return(node);
}
/// <summary>
/// Gets the formula.
/// </summary>
/// <param name="id">The id.</param>
/// <returns>A <see langword="string" /> indicates the formula.</returns>
/// <exception cref="T:System.ArgumentNullException"><paramref name="id" /> is <see langword="null" />.</exception>
public string GetFormula(CalcLocalIdentity id)
{
if (object.ReferenceEquals(id, null))
{
throw new ArgumentNullException("id");
}
CalcExpression objA = this.GetExpression(id);
if (!object.ReferenceEquals(objA, null))
{
return(this.Parser.Unparse(objA, this.Source.GetParserContext(id)));
}
return(null);
}
/// <summary>
/// hdt 唐忠宝增加
/// </summary>
/// <param name="id"></param>
/// <param name="context"></param>
/// <param name="node"></param>
private void Invalidate(CalcLocalIdentity id, CalcEvaluatorContext context, CalcNode node = null)
{
DirtyItem header = null;
DirtyItem tailItem = null;
this.InvalidateIntersecteds(id, context, node, ref header, ref tailItem);
foreach (CalcNode node2 in this.Graph.GetAllVolantedNodes())
{
this.InvalidateIntersecteds(node2.Id as CalcLocalIdentity, context, node2, ref header, ref tailItem);
}
if (header != null)
{
this.InvalidateDependencies(ref header, ref tailItem);
}
}
/// <summary>
/// Clears the expression.
/// </summary>
/// <param name="id">The id.</param>
public void ClearExpression(CalcLocalIdentity id)
{
if (object.ReferenceEquals(id, null))
{
throw new ArgumentNullException("id");
}
if ((this.Service.IsGraphSuspended && (this._tmpFormulas.Count > 0)) && this._tmpFormulas.ContainsKey(id))
{
this._tmpFormulas.Remove(id);
}
else
{
this._formulas.RemoveAt(id);
this.Graph.RemoveNode(id);
}
}
private void AddPredenceIds(CalcLocalIdentity id, bool isFullRelative)
{
bool flag;
if (this.PredenceIds.TryGetValue(id, out flag))
{
if (!isFullRelative && flag)
{
this.PredenceIds[id] = isFullRelative;
}
}
else
{
this.PredenceIds.Add(id, isFullRelative);
}
}
/// <summary>
/// Gets the reference at specified position which indicated by <paramref name="id" />.
/// </summary>
/// <param name="id">A <see cref="T:Dt.CalcEngine.CalcIdentity" /> indicates the identity of a address.</param>
/// <returns>
/// An <see cref="T:System.Object" /> indicates the reference.
/// If the <paramref name="id" /> is not recognized, return <see cref="F:Dt.CalcEngine.CalcErrors.Reference" />.
/// </returns>
public virtual object GetReference(CalcIdentity id)
{
if (id is CalcExternalIdentity)
{
CalcExternalIdentity identity = id as CalcExternalIdentity;
ICalcSource source = identity.Source;
if (source != null)
{
return(source.GetReference(identity.ConvertToLocal()));
}
}
else
{
if (id is CalcSheetRangeIdentity)
{
IMultiSourceProvider provider = this.Source as IMultiSourceProvider;
if (provider == null)
{
return(CalcErrors.Reference);
}
try
{
CalcSheetRangeIdentity identity2 = id as CalcSheetRangeIdentity;
CalcLocalIdentity identity3 = identity2.ConvertToLocal();
List <CalcReference> references = new List <CalcReference>();
foreach (ICalcSource source2 in provider.GetCalcSources(identity2.StartSource, identity2.EndSource))
{
CalcReference item = source2.GetReference(identity3) as CalcReference;
if (item != null)
{
references.Add(item);
}
}
return(new SheetRangeReference(references));
}
catch
{
return(CalcErrors.Reference);
}
}
if ((this.Source != null) && (id is CalcLocalIdentity))
{
return(this.Source.GetReference(id as CalcLocalIdentity));
}
}
return(CalcErrors.Reference);
}
private static bool IsContains(CalcLocalIdentity id1, CalcLocalIdentity id2)
{
CalcRangeIdentity rangeId = id1 as CalcRangeIdentity;
if (rangeId == null)
{
return(false);
}
CalcRangeIdentity identity2 = id2 as CalcRangeIdentity;
CalcCellIdentity identity3 = id2 as CalcCellIdentity;
if (identity3 != null)
{
return(IsContains(rangeId, identity3.RowIndex, identity3.ColumnIndex, 1, 1));
}
return((identity2 != null) && IsContains(rangeId, identity2.RowIndex, identity2.ColumnIndex, identity2.RowCount, identity2.ColumnCount));
}
/// <summary>
/// hdt 唐忠宝增加
/// </summary>
/// <param name="id"></param>
/// <param name="context"></param>
/// <param name="node"></param>
/// <param name="header"></param>
/// <param name="tailItem"></param>
private void InvalidateIntersecteds(CalcLocalIdentity id, CalcEvaluatorContext context, CalcNode node, ref DirtyItem header, ref DirtyItem tailItem)
{
ICalcSource source = this.Source;
if (node == null)
{
node = this.Graph.GetNode(id);
}
if (!object.ReferenceEquals(node, null))
{
if (node.DirtyItem != null)
{
return;
}
if (node.DirtyItem == null)
{
node.DirtyItem = new DirtyItem(this, node);
}
AddDirtyItem(ref header, ref tailItem, node.DirtyItem, null);
}
if (id is CalcCellIdentity)
{
foreach (CalcNode node2 in this.EnumerateIntersectedNodesExcludeSelf(id as CalcCellIdentity))
{
if (((node2.Dependents != null) && (node2.Dependents.Count > 0)) && (node2.DirtyItem == null))
{
node2.DirtyItem = new DirtyItem(this, node2);
AddDirtyItem(ref header, ref tailItem, node2.DirtyItem, node);
}
}
}
else
{
foreach (CalcNode node3 in this.Graph.EnumerateIntersectedNodesExcludeSelf(context, id))
{
if (node3.DirtyItem == null)
{
node3.DirtyItem = new DirtyItem(this, node3);
AddDirtyItem(ref header, ref tailItem, node3.DirtyItem, node);
}
}
}
}
private static void LocalId2Index(CalcLocalIdentity item, out int startRow, out int startCol, out int endRow, out int endCol)
{
CalcCellIdentity identity = item as CalcCellIdentity;
CalcRangeIdentity identity2 = item as CalcRangeIdentity;
if (identity != null)
{
startRow = endRow = identity.RowIndex;
startCol = endCol = identity.ColumnIndex;
}
else
{
startRow = identity2.RowIndex;
startCol = identity2.ColumnIndex;
endRow = (identity2.RowIndex + identity2.RowCount) - 1;
endCol = (identity2.ColumnIndex + identity2.ColumnCount) - 1;
}
startRow = (startRow < 0) ? 0 : startRow;
startCol = (startCol < 0) ? 0 : startCol;
endRow = (endRow < 0) ? 0xfffff : endRow;
endCol = (endCol < 0) ? 0x3fff : endCol;
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="id">The id.</param>
/// <returns>A <see cref="T:Dt.CalcEngine.Expressions.CalcExpression" /> indicates the expression.</returns>
/// <exception cref="T:System.ArgumentNullException"><paramref name="id" /> is <see langword="null" />.</exception>
public CalcExpression GetExpression(CalcLocalIdentity id)
{
if (object.ReferenceEquals(id, null))
{
throw new ArgumentNullException("id");
}
CalcExpression expressionCore = this.GetExpressionCore(id);
if (object.ReferenceEquals(expressionCore, null) && (id is CalcCellIdentity))
{
CalcRangeIdentity sharedFormulaRange = this.Graph.GetSharedFormulaRange(id as CalcCellIdentity);
if (!object.ReferenceEquals(sharedFormulaRange, null))
{
expressionCore = this.GetExpressionCore(sharedFormulaRange);
if (!object.ReferenceEquals(expressionCore, null) && !(expressionCore is CalcSharedExpression))
{
expressionCore = new CalcSharedExpression(expressionCore);
}
}
}
return(expressionCore);
}
internal void MarkAsDirty(CalcService service, bool recalculateAll = false, bool recursiveToIntersectant = true, bool recursiveToDependency = true, bool recursiveToSharedFormula = true)
{
if (!this.IsDirty && !this._isProcessingDirty)
{
int num;
int num2;
int num3;
int num4;
bool flag;
this._isProcessingDirty = true;
if ((this.DirtyItem == null) && !this._isTempNode)
{
CalcLocalIdentity objA = this.Id as CalcLocalIdentity;
if (object.ReferenceEquals(objA, null))
{
return;
}
this.DirtyItem = new DirtyItem(service, this.Source, objA, this);
}
CalcGraph graph = service.GetCalculationManager(this.Source, null, true).Graph;
CalcReferenceHelper.Id2Range(this.Source, this.Id, out num, out num2, out num3, out num4, out flag);
CalcRangeIdentity id = this.Id as CalcRangeIdentity;
List <CalcNode> searchingDepends = new List <CalcNode>();
List <CalcNode> list2 = new List <CalcNode>();
if (recursiveToIntersectant && !object.ReferenceEquals(id, null))
{
List <CalcNode> list3 = new List <CalcNode>();
for (int i = 0; i < num3; i++)
{
for (int j = 0; j < num4; j++)
{
CalcNode node = graph.GetNode(new CalcCellIdentity(num + i, num2 + j));
if (!object.ReferenceEquals(node, null) && node.IsDirty)
{
list2.Add(node);
}
if ((!object.ReferenceEquals(node, null) && !node._isWattingForProcess) && (!node._isProcessingDirty && !node.IsDirty))
{
node._isWattingForProcess = true;
list3.Add(node);
}
}
}
foreach (CalcNode node2 in list3)
{
node2.MarkAsDirty(service, recalculateAll, false, true, true);
node2._isWattingForProcess = false;
}
}
DirtyItem dependForehand = null;
List <CalcNode> pendingDependDirtyNode = new List <CalcNode>();
if ((this.Dependents != null) && (this.Dependents.Count > 0))
{
searchingDepends.AddRange(this.Dependents.Values);
}
List <SharedFormulaDirtyItem> sharedDirtyItmes = new List <SharedFormulaDirtyItem>();
if (flag || !recalculateAll)
{
foreach (CalcNode node3 in graph.GetAllDependentRangeNodes(num, num2, num3, num4))
{
if ((node3 != this) && ((recalculateAll || !graph.IsSharedFormula(node3.Id as CalcRangeIdentity)) || ((node3.Dependents != null) && (node3.Dependents.Count != 0))))
{
if (!recalculateAll && recursiveToDependency)
{
ExpandSharedFormulaDependency(service, graph, list2, sharedDirtyItmes, node3, this.Id as CalcLocalIdentity);
}
else if (recalculateAll)
{
list2.Add(node3);
}
}
}
if (recursiveToSharedFormula && this._isTempNode)
{
foreach (CalcNode node4 in graph.GetAllDependentSharedNodes(num, num2, num3, num4))
{
list2.Add(node4);
}
}
}
if (recursiveToIntersectant)
{
searchingDepends.AddRange(list2);
list2.Clear();
}
dependForehand = SerchDependForehand(dependForehand, searchingDepends, list2, pendingDependDirtyNode, sharedDirtyItmes);
if (recursiveToSharedFormula && !this._isTempNode)
{
if (dependForehand != null)
{
service.InsertToDirtyBefore(this.DirtyItem, dependForehand);
}
else
{
service.AddDirtyItem(this.DirtyItem);
}
}
if (recursiveToDependency)
{
foreach (CalcNode node5 in pendingDependDirtyNode)
{
node5._isWattingForProcess = true;
}
foreach (CalcNode node6 in pendingDependDirtyNode)
{
node6.MarkAsDirty(service, recalculateAll, true, true, true);
node6._isWattingForProcess = false;
}
foreach (SharedFormulaDirtyItem item2 in sharedDirtyItmes)
{
if (!item2.Node.IsDirty)
{
service.AddDirtyItem(item2);
}
List <CalcNode> list6 = new List <CalcNode>();
foreach (CalcLocalIdentity identity3 in item2.DirtySubIds2)
{
if (!item2.DirtySubIds.Contains(identity3))
{
item2.DirtySubIds.Add(identity3);
CalcNode item = graph.GetNode(identity3);
if (item == null)
{
item = CreateTempNode(this.Source, identity3);
}
item._isWattingForProcess = true;
list6.Add(item);
}
}
foreach (CalcNode node8 in list6)
{
node8.MarkAsDirty(service, recalculateAll, true, true, false);
node8._isWattingForProcess = false;
}
}
}
else if (recalculateAll)
{
foreach (CalcNode node9 in searchingDepends)
{
this.SetPredencyItem(service, node9);
}
foreach (CalcNode node10 in list2)
{
if (IsContains(node10.Id as CalcLocalIdentity, this.Id as CalcLocalIdentity))
{
this.SetPredencyItem(service, node10);
}
}
}
this._isProcessingDirty = false;
}
}
private static List <CalcLocalIdentity> GetDepIdsInSharedFormulaRange(CalcCalculationManager mgr, CalcRangeIdentity sharedFormulaRange, CalcLocalIdentity dityId)
{
int num;
int num2;
int num3;
int num4;
int num5;
int num6;
int num7;
int num8;
List <CalcLocalIdentity> list = new List <CalcLocalIdentity>();
LocalId2Index(sharedFormulaRange, out num, out num2, out num3, out num4);
ReferencePredenceVisitor visitor = new ReferencePredenceVisitor(mgr.Source, num, num2);
visitor.Visit(mgr.GetExpression(sharedFormulaRange), num, num2);
Dictionary <CalcLocalIdentity, bool> predenceIds = visitor.PredenceIds;
LocalId2Index(dityId, out num5, out num6, out num7, out num8);
foreach (KeyValuePair <CalcLocalIdentity, bool> pair in predenceIds)
{
int num9;
int num10;
int num11;
int num12;
CalcRangeIdentity key = pair.Key as CalcRangeIdentity;
if ((key != null) && (key.IsFullRow || key.IsFullColumn))
{
list.Clear();
list.Add(sharedFormulaRange);
return(list);
}
LocalId2Index(pair.Key, out num9, out num10, out num11, out num12);
int rowIndex = (num5 > num11) ? ((num + num5) - num11) : num;
int columnIndex = (num6 > num12) ? ((num2 + num6) - num12) : num2;
int num15 = (num + num7) - num9;
num15 = (num15 > num3) ? num3 : num15;
int num16 = (num2 + num8) - num10;
num16 = (num16 > num4) ? num4 : num16;
if (((rowIndex <= num3) && (num15 >= num)) && ((columnIndex <= num4) && (num16 >= num2)))
{
if (!pair.Value)
{
list.Clear();
list.Add(sharedFormulaRange);
return(list);
}
CalcRangeIdentity item = new CalcRangeIdentity(rowIndex, columnIndex, (num15 - rowIndex) + 1, (num16 - columnIndex) + 1);
if (!list.Contains(item))
{
list.Add(item);
}
}
}
return(list);
}
public SharedFormulaDirtyItem(CalcService service, ICalcSource source, CalcLocalIdentity id, CalcNode node) : base(service, source, id, node)
{
this.DirtySubIds = new List <CalcLocalIdentity>();
this.DirtySubIds2 = new List <CalcLocalIdentity>();
}
/// <summary>
/// Clears the formula.
/// </summary>
/// <param name="id">The id.</param>
public void ClearFormula(CalcLocalIdentity id)
{
this.ClearExpression(id);
}
/// <summary>
/// hdt 唐忠宝增加
/// </summary>
/// <param name="header"></param>
/// <param name="tailItem"></param>
private void GetAllDirtyItems(ref DirtyItem header, ref DirtyItem tailItem)
{
DirtyItem nextItem;
DirtyItem removingItem = header;
while (removingItem != null)
{
nextItem = removingItem.NextItem;
DirtyItem previousItem = removingItem.PreviousItem;
CalcNode objB = removingItem.Node;
if (objB.NodeType != NodeType.None)
{
objB.DirtyItem.DirtyFlag = true;
}
else
{
objB.DirtyItem = null;
RemoveDirtyItem(ref header, ref tailItem, removingItem);
}
if ((objB.Dependents == null) || (objB.Dependents.Count == 0))
{
removingItem = nextItem;
}
else
{
foreach (KeyValuePair <CalcNode, CalcNode> pair in objB.Dependents)
{
if (((pair.Key.DirtyItem == null) && !object.ReferenceEquals(pair.Key, objB)) && ((pair.Key.Id is CalcCellIdentity) || (pair.Key.Id is CalcExternalCellIdentity)))
{
this.CreateDirtyItem(pair.Key);
AddDirtyItem(ref header, ref tailItem, pair.Key.DirtyItem, objB);
CalcLocalIdentity id = pair.Key.Id as CalcLocalIdentity;
CalcGraph graph = pair.Key.DirtyItem.Manager.Graph;
if (object.ReferenceEquals(id, null))
{
id = (pair.Key.Id as CalcExternalIdentity).ConvertToLocal();
}
foreach (CalcNode node2 in graph.Manager.EnumerateIntersectedNodesExcludeSelf(id as CalcCellIdentity))
{
node2.DirtyItem = new DirtyItem(this, node2);
AddDirtyItem(ref header, ref tailItem, node2.DirtyItem, pair.Key);
}
}
}
if (nextItem == null)
{
if ((previousItem == null) && (removingItem != header))
{
removingItem = header;
}
else if ((previousItem != null) && (removingItem != previousItem.NextItem))
{
removingItem = previousItem.NextItem;
}
else
{
removingItem = null;
}
continue;
}
removingItem = nextItem;
}
}
for (removingItem = header; removingItem != null; removingItem = nextItem)
{
nextItem = removingItem.NextItem;
CalcNode node = removingItem.Node;
if (removingItem.Node.Dependents != null)
{
foreach (KeyValuePair <CalcNode, CalcNode> pair2 in removingItem.Node.Dependents)
{
if ((pair2.Key.DirtyItem != null) && !object.ReferenceEquals(pair2.Key, node))
{
if (removingItem.DependencyCellTemp == null)
{
removingItem.DependencyCellTemp = new HashSet <CalcNode>();
}
if (!removingItem.DependencyCellTemp.Contains(pair2.Key))
{
removingItem.DependencyCellTemp.Add(pair2.Key);
pair2.Key.DirtyItem.PredencyItemCount++;
}
}
}
}
}
}
/// <summary>
/// Determines whether the specified <see cref="T:Dt.CalcEngine.CalcIdentity" /> is intersected with an range that has array formula.
/// </summary>
/// <param name="id">The id.</param>
/// <returns>
/// <see langword="true" /> if the specified <see cref="T:Dt.CalcEngine.CalcIdentity" /> is intersected
/// with an range that has array formula; otherwise, <see langword="false" />.
/// </returns>
public bool IsIsIntersectantWithArrayFormula(CalcLocalIdentity id)
{
return(this.Graph.IsIsIntersectantWithArrayFormula(id));
}
/// <summary>
/// Invalidates the specified id.
/// </summary>
/// <param name="id">The data address.</param>
/// <param name="autoCalculate">if set to <see langword="true" /> automatically calculate immediately.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="id" /> is <see langword="null" />.</exception>
public void Invalidate(CalcLocalIdentity id, bool autoCalculate = true)
{
if (object.ReferenceEquals(id, null))
{
throw new ArgumentNullException("id");
}
if (!this.Graph.IsEmpty)
{
CalcNode objA = this.Graph.GetNode(id);
if (!object.ReferenceEquals(objA, null))
{
objA.MarkAsDirty(this.Service, autoCalculate, true, true, true);
}
else if (objA == null)
{
CalcNode.CreateTempNode(this.Source, id).MarkAsDirty(this.Service, autoCalculate, true, true, true);
}
else
{
CalcCellIdentity identity = id as CalcCellIdentity;
if (!object.ReferenceEquals(identity, null))
{
foreach (CalcNode node2 in this.Graph.GetAllDependentRangeNodes(identity.RowIndex, identity.ColumnIndex, 1, 1))
{
node2.MarkAsDirty(this.Service, autoCalculate, false, true, true);
}
}
else
{
CalcRangeIdentity identity2 = id as CalcRangeIdentity;
if (!object.ReferenceEquals(identity2, null))
{
if (identity2.IsFullColumn && identity2.IsFullRow)
{
this.InvalidateAllIdentity();
return;
}
if (!identity2.IsFullColumn && !identity2.IsFullRow)
{
foreach (CalcNode node3 in this.Graph.GetAllDependentRangeNodes(identity2.RowIndex, identity2.ColumnIndex, identity2.RowCount, identity2.ColumnCount))
{
node3.MarkAsDirty(this.Service, autoCalculate, true, true, true);
}
for (int i = 0; i < identity2.RowCount; i++)
{
for (int j = 0; j < identity2.ColumnCount; j++)
{
CalcNode node = this.Graph.GetNode(new CalcCellIdentity(identity2.RowIndex + i, identity2.ColumnIndex + j));
if (!object.ReferenceEquals(node, null))
{
node.MarkAsDirty(this.Service, autoCalculate, false, true, true);
}
}
}
}
else
{
int columnIndex;
int columnCount;
if (identity2.IsFullColumn)
{
columnIndex = identity2.ColumnIndex;
columnCount = identity2.ColumnCount;
}
else
{
columnIndex = identity2.RowIndex;
columnCount = identity2.RowCount;
}
foreach (CalcNode node5 in this.Graph.GetBandDependentNodes(columnIndex, columnCount, identity2.IsFullRow))
{
node5.MarkAsDirty(this.Service, autoCalculate, true, true, true);
}
CalcReference reference = this.Evaluator.Evaluate(new CalcRangeExpression(columnIndex, columnCount, false, false, true), this.Source.GetEvaluatorContext(identity2)) as CalcReference;
if (!object.ReferenceEquals(reference, null) && (reference.RangeCount == 1))
{
for (int k = 0; k < reference.GetRowCount(0); k++)
{
for (int m = 0; m < reference.GetColumnCount(0); m++)
{
CalcNode node6 = this.Graph.GetNode(new CalcCellIdentity(reference.GetRow(0) + k, reference.GetColumn(0) + m));
if (!object.ReferenceEquals(node6, null))
{
node6.MarkAsDirty(this.Service, autoCalculate, false, true, true);
}
}
}
}
}
}
}
}
foreach (CalcLocalIdentity identity3 in this.Graph.GetAllVolantedIdeneities())
{
this.Graph.EnsureNode(identity3, null).MarkAsDirty(this.Service, autoCalculate, true, true, true);
}
if (autoCalculate)
{
this.Service.Recalculate(0xc350, false);
}
}
}
private static void ExpandSharedFormulaDependency(CalcService service, CalcGraph graph, List <CalcNode> searchingDepends, List <SharedFormulaDirtyItem> sharedDirtyItmes, CalcNode rangeIntersected, CalcLocalIdentity currentId)
{
CalcRangeIdentity identity = currentId as CalcRangeIdentity;
CalcRangeIdentity id = rangeIntersected.Id as CalcRangeIdentity;
if ((!object.ReferenceEquals(id, null) && (rangeIntersected.Dependents != null)) && ((rangeIntersected.Dependents.Count > 0) && ShouldExpand(graph, id)))
{
foreach (KeyValuePair <CalcNode, CalcNode> pair in rangeIntersected.Dependents)
{
List <CalcLocalIdentity> list;
CalcRangeIdentity rangeId = pair.Key.Id as CalcRangeIdentity;
if ((rangeId == null) || !graph.IsSharedFormula(rangeId))
{
goto Label_019E;
}
if ((currentId == rangeId) || ((identity != null) && (identity.IsFullRow || identity.IsFullColumn)))
{
searchingDepends.Add(pair.Key);
continue;
}
SharedFormulaDirtyItem dirtyItem = null;
if (pair.Key.DirtyItem != null)
{
if (pair.Key.DirtyItem is SharedFormulaDirtyItem)
{
dirtyItem = pair.Key.DirtyItem as SharedFormulaDirtyItem;
if (!dirtyItem.IsFullRangeDirty)
{
goto Label_0136;
}
}
continue;
}
dirtyItem = new SharedFormulaDirtyItem(service, graph.Manager.Source, rangeId, graph.GetNode(rangeId));
graph.GetNode(rangeId).DirtyItem = dirtyItem;
Label_0136:
list = GetDepIdsInSharedFormulaRange(graph.Manager, rangeId, currentId);
if ((list.Count == 1) && (list[0] == rangeId))
{
dirtyItem.IsFullRangeDirty = true;
searchingDepends.Add(graph.GetNode(rangeId));
}
else
{
dirtyItem.DirtySubIds2.AddRange(list);
if (dirtyItem.DirtySubIds2.Count > 0)
{
sharedDirtyItmes.Add(dirtyItem);
}
}
continue;
Label_019E:
searchingDepends.Add(pair.Key);
}
}
else
{
searchingDepends.Add(rangeIntersected);
}
}
internal bool EvaluateFormula(CalcCalculationManager mgr, DirtyItem dirtyItem)
{
CalcLocalIdentity id = dirtyItem.Id as CalcLocalIdentity;
if (object.ReferenceEquals(id, null))
{
return(false);
}
CalcExpression objA = mgr.GetExpression(id);
if (object.ReferenceEquals(objA, null))
{
return(false);
}
ICalcSource source = mgr.Source;
Dictionary <CalcLocalIdentity, CalcExpression> dictionary = new Dictionary <CalcLocalIdentity, CalcExpression>();
if ((id is CalcRangeIdentity) && mgr.Graph.IsSharedFormula(id as CalcRangeIdentity))
{
List <CalcLocalIdentity> dirtySubIds = new List <CalcLocalIdentity>();
SharedFormulaDirtyItem item = dirtyItem as SharedFormulaDirtyItem;
if ((item != null) && !item.IsFullRangeDirty)
{
dirtySubIds = (dirtyItem as SharedFormulaDirtyItem).DirtySubIds;
}
else
{
dirtySubIds.Add(id);
}
foreach (CalcLocalIdentity identity3 in dirtySubIds)
{
int num;
int num2;
int num3;
int num4;
bool flag;
CalcRangeIdentity identity4 = identity3 as CalcRangeIdentity;
CalcReferenceHelper.Id2Range(source, identity3, out num, out num2, out num3, out num4, out flag);
for (int i = num; i < (num + num3); i++)
{
for (int j = num2; j < (num2 + num4); j++)
{
if ((identity4 != null) && (identity4.IsFullRow || identity4.IsFullColumn))
{
new FullBandMappingVisitor(identity4.IsFullRow, identity4.IsFullRow ? i : j).Visit(objA, 0, 0);
}
CalcCellIdentity identity5 = new CalcCellIdentity(i, j);
CalcExpression expression = mgr.GetExpression(identity5);
if (((expression != null) && (expression == objA)) && !mgr.Graph.IsIsIntersectantWithArrayFormula(identity5))
{
dictionary[identity5] = objA;
}
}
}
}
}
else
{
dictionary.Add(id, objA);
}
foreach (KeyValuePair <CalcLocalIdentity, CalcExpression> pair in dictionary)
{
id = pair.Key;
object obj2 = mgr.Evaluator.Evaluate(pair.Value, source.GetEvaluatorContext(id));
while (!(id is CalcRangeIdentity) && ((obj2 is CalcReference) || (obj2 is CalcArray)))
{
if (obj2 is CalcReference)
{
obj2 = ExtractValueFromReference(id, obj2);
}
if (obj2 is CalcArray)
{
obj2 = (obj2 as CalcArray).GetValue(0);
}
}
source.SetValue(id, obj2);
}
return(true);
}