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); } }