Ejemplo n.º 1
0
 private void CheckPosition(DirtyItem item, DirtyItem at, DirtyItem prev)
 {
     if (((item.Position - prev.Position) < this._minValue) || ((at.Position - prev.Position) < this._minValue))
     {
         this.AdjustPositions(item);
     }
 }
Ejemplo n.º 2
0
 internal void RemoveDirtyItem(DirtyItem item)
 {
     if (this.IsDirtyItem(item))
     {
         DirtyItem previousItem = item.PreviousItem;
         DirtyItem nextItem     = item.NextItem;
         if (previousItem != null)
         {
             previousItem.NextItem = nextItem;
         }
         else
         {
             this._headerDirtyItems = nextItem;
         }
         if (nextItem != null)
         {
             nextItem.PreviousItem = previousItem;
         }
         else
         {
             this._tailDirtyItems = previousItem;
         }
         item.PreviousItem = null;
         item.NextItem     = null;
     }
 }
Ejemplo n.º 3
0
 /// <summary>
 /// hdt 唐忠宝增加
 /// </summary>
 /// <param name="header"></param>
 /// <param name="tailItem"></param>
 /// <param name="addingItem"></param>
 /// <param name="predencyNode"></param>
 private static void AddDirtyItem(ref DirtyItem header, ref DirtyItem tailItem, DirtyItem addingItem, CalcNode predencyNode)
 {
     if (header == null)
     {
         header = tailItem = addingItem;
     }
     else
     {
         addingItem.PreviousItem = tailItem;
         tailItem.NextItem       = addingItem;
         tailItem = addingItem;
     }
     if (!object.ReferenceEquals(predencyNode, null) && (predencyNode.DirtyItem != null))
     {
         DirtyItem dirtyItem = predencyNode.DirtyItem;
         if (dirtyItem.DependencyCellTemp == null)
         {
             dirtyItem.DependencyCellTemp = new HashSet <CalcNode>();
         }
         if (!dirtyItem.DependencyCellTemp.Contains(tailItem.Node))
         {
             dirtyItem.DependencyCellTemp.Add(tailItem.Node);
             tailItem.PredencyItemCount++;
         }
     }
 }
Ejemplo n.º 4
0
 private void MoveTo(DirtyItem item, DirtyItem beforeAt)
 {
     if (!item.Moved)
     {
         item.Moved = true;
         this._movedItems.Add(item);
         this.RemoveDirtyItem(item);
         DirtyItem previousItem = beforeAt.PreviousItem;
         item.NextItem         = beforeAt;
         item.PreviousItem     = previousItem;
         beforeAt.PreviousItem = item;
         if (previousItem == null)
         {
             this._headerDirtyItems = item;
             item.Position          = beforeAt.Position - 1.0;
         }
         else
         {
             previousItem.NextItem = item;
             item.Position         = previousItem.Position + ((beforeAt.Position - previousItem.Position) / 2.0);
             this.CheckPosition(item, beforeAt, previousItem);
         }
         this.CheckPredencies(item, beforeAt);
     }
 }
Ejemplo n.º 5
0
 /// <summary>
 /// hdt 唐忠宝增加
 /// </summary>
 /// <param name="ids"></param>
 /// <param name="autoCalculate"></param>
 public void Invalidate(IEnumerable <CalcLocalIdentity> ids, bool autoCalculate = true)
 {
     if (object.ReferenceEquals(ids, null))
     {
         throw new ArgumentNullException("ids");
     }
     if (!this.Graph.IsEmpty)
     {
         CalcEvaluatorContext evaluatorContext = this.Source.GetEvaluatorContext(new CalcCellIdentity(0, 0));
         DirtyItem            header           = null;
         DirtyItem            tailItem         = null;
         foreach (CalcLocalIdentity identity in ids)
         {
             this.InvalidateIntersecteds(identity, evaluatorContext, null, ref header, ref tailItem);
         }
         foreach (CalcNode node in this.Graph.GetAllVolantedNodes())
         {
             this.InvalidateIntersecteds(node.Id as CalcLocalIdentity, evaluatorContext, node, ref header, ref tailItem);
         }
         if (header != null)
         {
             this.InvalidateDependencies(ref header, ref tailItem);
         }
         if (autoCalculate)
         {
             this.Service.Recalculate(0xc350, false);
         }
     }
 }
Ejemplo n.º 6
0
 internal void InsertToDirtyBefore(DirtyItem item, DirtyItem at)
 {
     if ((item != null) && !this.IsDirtyItem(item))
     {
         if (at == null)
         {
             this.AddDirtyItem(item);
         }
         else
         {
             DirtyItem previousItem = at.PreviousItem;
             item.NextItem     = at;
             item.PreviousItem = previousItem;
             if (previousItem == null)
             {
                 this._headerDirtyItems = item;
                 item.Position          = at.Position - 1.0;
             }
             else
             {
                 previousItem.NextItem = item;
                 item.Position         = previousItem.Position + ((at.Position - previousItem.Position) / 2.0);
                 this.CheckPosition(item, at, previousItem);
             }
             at.PreviousItem = item;
             this.CheckPredencies(item, at);
             this.ClearMovedItemCatch();
         }
     }
 }
Ejemplo n.º 7
0
 /// <summary>
 /// hdt 唐忠宝增加
 /// </summary>
 /// <param name="header"></param>
 /// <param name="tailItem"></param>
 /// <param name="removingItem"></param>
 private static void RemoveDirtyItem(ref DirtyItem header, ref DirtyItem tailItem, DirtyItem removingItem)
 {
     if (header == removingItem)
     {
         header = removingItem.NextItem;
     }
     if (tailItem == removingItem)
     {
         tailItem = removingItem.PreviousItem;
     }
     if (removingItem.PreviousItem != null)
     {
         removingItem.PreviousItem.NextItem = removingItem.NextItem;
     }
     if (removingItem.NextItem != null)
     {
         removingItem.NextItem.PreviousItem = removingItem.PreviousItem;
     }
     removingItem.NextItem = removingItem.PreviousItem = null;
     if (removingItem.DependencyCellTemp != null)
     {
         foreach (CalcNode node in removingItem.DependencyCellTemp)
         {
             if (node.DirtyItem != null)
             {
                 node.DirtyItem.PredencyItemCount--;
             }
         }
     }
 }
Ejemplo n.º 8
0
 private static DirtyItem SerchDependForehand(DirtyItem dependForehand, List <CalcNode> searchingDepends, List <CalcNode> intersectants, List <CalcNode> pendingDependDirtyNode, List <SharedFormulaDirtyItem> sharedDirtyItmes)
 {
     if (searchingDepends.Count > 0)
     {
         foreach (CalcNode node in searchingDepends)
         {
             if (node.IsDirty)
             {
                 if (dependForehand == null)
                 {
                     dependForehand = node.DirtyItem;
                 }
                 else if (node.DirtyItem.Position < dependForehand.Position)
                 {
                     dependForehand = node.DirtyItem;
                 }
             }
             else if (!node._isProcessingDirty && !node._isWattingForProcess)
             {
                 pendingDependDirtyNode.Add(node);
             }
         }
     }
     if ((intersectants != null) && (intersectants.Count > 0))
     {
         foreach (CalcNode node2 in intersectants)
         {
             if (node2.IsDirty)
             {
                 if (dependForehand == null)
                 {
                     dependForehand = node2.DirtyItem;
                 }
                 else if (node2.DirtyItem.Position < dependForehand.Position)
                 {
                     dependForehand = node2.DirtyItem;
                 }
             }
         }
     }
     if (sharedDirtyItmes.Count > 0)
     {
         foreach (SharedFormulaDirtyItem item in sharedDirtyItmes)
         {
             if (item.Node.IsDirty)
             {
                 if (dependForehand == null)
                 {
                     dependForehand = item;
                 }
                 else if (item.Position < dependForehand.Position)
                 {
                     dependForehand = item;
                 }
             }
         }
     }
     return(dependForehand);
 }
Ejemplo n.º 9
0
 internal bool IsDirtyItem(DirtyItem item)
 {
     if (item.PreviousItem == null)
     {
         return(item == this._headerDirtyItems);
     }
     return(true);
 }
Ejemplo n.º 10
0
        private void ClearDirtyItem()
        {
            DirtyItem item2;

            for (DirtyItem item = this._headerDirtyItems; item != null; item = item2)
            {
                item2             = (item == null) ? null : item.NextItem;
                item.PreviousItem = null;
                item.NextItem     = null;
            }
            this._headerDirtyItems = this._tailDirtyItems = null;
        }
Ejemplo n.º 11
0
 private void CheckPredencies(DirtyItem item, DirtyItem at)
 {
     if (item.HasPredencyItem)
     {
         foreach (KeyValuePair <CalcIdentity, DirtyItem> pair in item.PredencyItems)
         {
             if (at.Position <= pair.Value.Position)
             {
                 this.MoveTo(pair.Value, item);
             }
         }
     }
 }
Ejemplo n.º 12
0
        /// <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);
            }
        }
Ejemplo n.º 13
0
 internal void AddDirtyItem(DirtyItem item)
 {
     if ((item != null) && !this.IsDirtyItem(item))
     {
         if (this._tailDirtyItems != null)
         {
             this._tailDirtyItems.NextItem = item;
             item.Position = this._tailDirtyItems.Position + 1.0;
         }
         else
         {
             item.Position          = (this._headerDirtyItems != null) ? (this._headerDirtyItems.Position - 1.0) : 0.0;
             this._headerDirtyItems = item;
         }
         item.PreviousItem    = this._tailDirtyItems;
         item.NextItem        = null;
         this._tailDirtyItems = item;
     }
 }
Ejemplo n.º 14
0
        /// <summary>
        /// Recalculates this instance.
        /// </summary>
        /// <param name="maxCalcCount">The max iterator.</param>
        /// <param name="forceRecalculateAll">Whether force recalculate all formula in current manager.</param>
        /// <returns><see langword="true" /> if all dirty nodes have been recalculated, otherwise, <see langword="false" /></returns>
        public bool Recalculate(int maxCalcCount = 0xc350, bool forceRecalculateAll = false)
        {
            if (forceRecalculateAll)
            {
                this.ClearDirtyItem();
                foreach (CalcCalculationManager manager in this._calcManagers.Values)
                {
                    if (manager.FormulaCount > 0)
                    {
                        manager.InvalidateAllIdentity();
                        maxCalcCount += manager.FormulaCount;
                    }
                }
            }
            int num = 0;

            while ((this._headerDirtyItems != null) && (num < maxCalcCount))
            {
                DirtyItem dirtyItem        = this._headerDirtyItems;
                CalcCalculationManager mgr = this.GetCalculationManager(dirtyItem.Source, null, true);
                this.EvaluateFormula(mgr, dirtyItem);
                CalcNode objA = dirtyItem.Node;
                if (object.ReferenceEquals(objA, null))
                {
                    objA = mgr.Graph.GetNode(dirtyItem.Id);
                }
                if (!object.ReferenceEquals(objA, null))
                {
                    objA.ClearDirty();
                    if (dirtyItem == this._headerDirtyItems)
                    {
                        this.RemoveDirtyItem(dirtyItem);
                    }
                }
                else
                {
                    this.RemoveDirtyItem(dirtyItem);
                }
                num++;
            }
            return(num < maxCalcCount);
        }
Ejemplo n.º 15
0
        internal void DisposeCalculationManager(CalcCalculationManager mgr)
        {
            ICalcSource key = mgr.Source;

            if (key != null)
            {
                DirtyItem nextItem;
                if (this._calcManagers.ContainsKey(key))
                {
                    this._calcManagers.Remove(key);
                }
                for (DirtyItem item = this._headerDirtyItems; item != null; item = nextItem)
                {
                    nextItem = item.NextItem;
                    if (item.Source == key)
                    {
                        this.RemoveDirtyItem(item);
                    }
                }
            }
        }
Ejemplo n.º 16
0
        private void AdjustPositions(DirtyItem item)
        {
            double position = 0.0;

            while (!object.ReferenceEquals(item.PreviousItem, null) && ((item.Position - item.PreviousItem.Position) < 0.0001))
            {
                item = item.PreviousItem;
            }
            if (object.ReferenceEquals(item, null))
            {
                item     = this._headerDirtyItems;
                position = 0.0;
            }
            else
            {
                position = item.Position;
            }
            while (!object.ReferenceEquals(item, null))
            {
                position++;
                item.Position = position;
                item          = item.NextItem;
            }
        }
Ejemplo n.º 17
0
 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;
     }
 }
Ejemplo n.º 18
0
 /// <summary>
 /// hdt 唐忠宝增加
 /// </summary>
 /// <param name="header"></param>
 /// <param name="tailItem"></param>
 private void InvalidateDependencies(ref DirtyItem header, ref DirtyItem tailItem)
 {
     this.GetAllDirtyItems(ref header, ref tailItem);
     while (header != null)
     {
         DirtyItem removingItem = header;
         bool      flag         = false;
         while (removingItem != null)
         {
             DirtyItem nextItem = removingItem.NextItem;
             if (removingItem.PredencyItemCount == 0)
             {
                 RemoveDirtyItem(ref header, ref tailItem, removingItem);
                 this.Service.AddDirtyItem(removingItem);
                 flag = true;
             }
             removingItem = nextItem;
         }
         if ((header != null) && !flag)
         {
             Queue <DirtyItem> queue = new Queue <DirtyItem>();
             queue.Enqueue(header);
             header.CircleReferenceCount++;
             DirtyItem item3 = header;
             while ((queue.Count > 0) || (item3 != null))
             {
                 removingItem = queue.Dequeue();
                 if (removingItem.DependencyCellTemp != null)
                 {
                     foreach (CalcNode node in removingItem.DependencyCellTemp)
                     {
                         node.DirtyItem.CircleReferenceCount++;
                         if (node.DirtyItem.CircleReferenceCount > node.DirtyItem.PredencyItemCount)
                         {
                             RemoveDirtyItem(ref header, ref tailItem, node.DirtyItem);
                             this.Service.AddDirtyItem(node.DirtyItem);
                             flag         = true;
                             removingItem = node.DirtyItem;
                             break;
                         }
                         queue.Enqueue(node.DirtyItem);
                     }
                 }
                 if (flag)
                 {
                     item3 = header;
                     while (item3 != null)
                     {
                         item3.CircleReferenceCount = 0;
                         item3 = item3.NextItem;
                     }
                     continue;
                 }
                 if ((queue.Count == 0) && (item3 != null))
                 {
                     item3 = item3.NextItem;
                     while ((item3 != null) && (item3.CircleReferenceCount != 0))
                     {
                         item3 = item3.NextItem;
                     }
                     if (item3 == null)
                     {
                         continue;
                     }
                     queue.Enqueue(item3);
                 }
             }
         }
     }
 }
Ejemplo n.º 19
0
        /// <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);
                    }
                }
            }
        }
Ejemplo n.º 20
0
        /// <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++;
                            }
                        }
                    }
                }
            }
        }
Ejemplo n.º 21
0
        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);
        }