internal override bool IsConditionEvaluateToTrue(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { if (base.condition != null) { this.lastActualValue = actual; object val = actual.GetValue(baseRow, baseColumn); if (val != null) { double?nullable = ConditionValueConverter.TryDouble(val); if (!nullable.HasValue) { return(false); } double currentValue = nullable.Value; double?nullable2 = this.CalcuteMinValue(evaluator, baseRow, baseColumn, 0, actual); double?nullable3 = this.CalcuteMaxValue(evaluator, baseRow, baseColumn, 2, actual); if (nullable2.HasValue && nullable3.HasValue) { double?nullable5 = nullable2; double?nullable6 = nullable3; if ((((double)nullable5.GetValueOrDefault()) > ((double)nullable6.GetValueOrDefault())) && (nullable5.HasValue & nullable6.HasValue)) { double?nullable4 = nullable3; nullable3 = nullable2; nullable2 = nullable4; } double axisScale = -1.0; this.EvaluateScale(currentValue, nullable2.Value, nullable3.Value, out axisScale); return(true); } } } return(false); }
internal override bool IsConditionEvaluateToTrue(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { if (base.condition == null) { return(false); } this.lastActualValue = actual; object obj2 = actual.GetValue(baseRow, baseColumn); if (obj2 != null) { try { ConditionValueConverter.ToDouble(obj2); } catch (InvalidCastException) { return(false); } double?nullable = base.GetActualValue(evaluator, baseRow, baseColumn, 0, actual); double?nullable2 = base.GetActualValue(evaluator, baseRow, baseColumn, 2, actual); if (nullable.HasValue && nullable2.HasValue) { return(true); } } return(true); }
/// <summary> /// Returns a drawing object based on a specified parameter. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The base row.</param> /// <param name="baseColumn">The base column.</param> /// <param name="actual">The current value.</param> /// <returns>The data bar object.</returns> public override object Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { this.lastActualValue = actual; object val = actual.GetValue(baseRow, baseColumn); if (val != null) { double?nullable = ConditionValueConverter.TryDouble(val); if (!nullable.HasValue) { return(null); } double currentValue = nullable.Value; double?nullable2 = this.CalcuteMinValue(evaluator, baseRow, baseColumn, 0, actual); double?nullable3 = this.CalcuteMaxValue(evaluator, baseRow, baseColumn, 2, actual); if (nullable2.HasValue && nullable3.HasValue) { double?nullable5 = nullable2; double?nullable6 = nullable3; if ((((double)nullable5.GetValueOrDefault()) > ((double)nullable6.GetValueOrDefault())) && (nullable5.HasValue & nullable6.HasValue)) { double?nullable4 = nullable3; nullable3 = nullable2; nullable2 = nullable4; } double axisScale = -1.0; double scale = this.EvaluateScale(currentValue, nullable2.Value, nullable3.Value, out axisScale); Windows.UI.Color fillColor = ((currentValue < 0.0) && this.useNegativeFillColor) ? this.negativeFillColor : this.color; return(new DataBarDrawingObject(baseRow, baseColumn, fillColor, ((currentValue < 0.0) && this.useNegativeBorderColor) ? this.negativeBorderColor : this.borderColor, this.showBorder, this.axisColor, this.gradient, this.direction, axisScale, scale, this.showBarOnly)); } } return(null); }
/// <summary> /// Returns a specified value of the rule if the cell satisfies the condition. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The row index.</param> /// <param name="baseColumn">The column index.</param> /// <param name="actual">The current value.</param> /// <returns>Returns the conditional number value.</returns> public override object Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { this.lastActualValue = actual; object obj2 = actual.GetValue(baseRow, baseColumn); if (obj2 != null) { double num; try { num = ConditionValueConverter.ToDouble(obj2); } catch (InvalidCastException) { return(null); } double?nullable = base.GetActualValue(evaluator, baseRow, baseColumn, 0, actual); double?nullable2 = base.GetActualValue(evaluator, baseRow, baseColumn, 2, actual); if (nullable.HasValue && nullable2.HasValue) { return(ScaleRule.EvaluateColor(ScaleRule.Evaluate2Scale(num, nullable.Value, nullable2.Value), this.MinimumColor, this.MaximumColor)); } } return(null); }
internal void TryCache(IActualValue actual) { if (!this.cahced) { this.CalculateLowestValueAndHighestValue(actual, out this.lowestValueCached, out this.highestValueCached, base.Ranges); this.cahced = true; } }
internal static List <double> GetMinValues(IActualValue actualValue, int rank, ICellRange[] ranges) { List <double> list = new List <double>(); if (ranges != null) { double minValue = double.MinValue; int num2 = 0; foreach (ICellRange range in ranges) { for (int i = 0; i < range.RowCount; i++) { int row = i + range.Row; for (int j = 0; j < range.ColumnCount; j++) { int column = j + range.Column; object val = actualValue.GetValue(row, column); double num7 = 0.0; if (val != null) { double?nullable = ConditionValueConverter.TryDouble(val); if (nullable.HasValue) { num7 = nullable.Value; if (num2 < rank) { list.Add(num7); if (num7 > minValue) { minValue = num7; } num2++; } else if (num7 < minValue) { list.Remove(minValue); list.Add(num7); if (list.IndexOf(minValue) < 0) { minValue = num7; for (int k = 0; k < list.Count; k++) { if (list[k] > minValue) { minValue = list[k]; } } } } } } } } } } return(list); }
internal void TryCache(IActualValue actual) { if (!this.cahced) { this.lowestValueCached = this.CalculateLowestValueEx(actual); this.highestValueCached = this.CalculateHighestValueEx(actual); this.cahced = true; } }
/// <summary> /// Calculates the lowest value. /// </summary> /// <param name="actualValue"></param> /// <returns>Returns the value.</returns> internal double?CalculateLowestValueEx(IActualValue actualValue) { List <double> list = Top10Condition.GetMinValues(actualValue, 1, base.Ranges); if ((list != null) && (list.Count > 0)) { return(new double?(list[0])); } return(null); }
internal override bool IsConditionEvaluateToTrue(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { if (base.condition != null) { this.lastActualValue = actual; object obj2 = actual.GetValue(baseRow, baseColumn); if (obj2 != null) { double num; try { num = ConditionValueConverter.ToDouble(obj2); } catch (InvalidCastException) { return(false); } double?nullable = base.GetActualValue(evaluator, baseRow, baseColumn, 0, actual); double?nullable2 = base.GetActualValue(evaluator, baseRow, baseColumn, 1, actual); double?nullable3 = base.GetActualValue(evaluator, baseRow, baseColumn, 2, actual); if ((nullable.HasValue && nullable3.HasValue) && nullable2.HasValue) { double?nullable4 = nullable; double?nullable5 = nullable3; if ((((double)nullable4.GetValueOrDefault()) > ((double)nullable5.GetValueOrDefault())) && (nullable4.HasValue & nullable5.HasValue)) { return(false); } double num2 = num; double?nullable6 = nullable; if ((num2 >= ((double)nullable6.GetValueOrDefault())) || !nullable6.HasValue) { double num3 = num; double?nullable7 = nullable3; if ((num3 >= ((double)nullable7.GetValueOrDefault())) && nullable7.HasValue) { return(true); } if ((nullable.Value <= num) && (num <= nullable2.Value)) { ScaleRule.Evaluate2Scale(num, nullable.Value, nullable2.Value); return(true); } ScaleRule.Evaluate2Scale(num, nullable2.Value, nullable3.Value); } return(true); } } } return(false); }
bool IsEqualsBackgroundColor(IActualValue actualObj) { Windows.UI.Color?nullable = base.GetExpectedColor(null, 0, 0); if (nullable.HasValue) { Windows.UI.Color?backgroundColor = actualObj.GetBackgroundColor(); if (backgroundColor.HasValue) { return((((backgroundColor.Value.A == nullable.Value.A) && (backgroundColor.Value.R == nullable.Value.R)) && (backgroundColor.Value.G == nullable.Value.G)) && (backgroundColor.Value.B == nullable.Value.B)); } Windows.UI.Color?defaultBackgroundColor = actualObj.GetDefaultBackgroundColor(); return(nullable.Value == (defaultBackgroundColor.HasValue ? defaultBackgroundColor.Value : Colors.Transparent)); } return(this.IgnoreBlank); }
void CalculateLowestValueAndHighestValue(IActualValue actualValue, out double?min, out double?max, ICellRange[] ranges) { min = 0; max = 0; if (ranges != null) { foreach (ICellRange range in ranges) { for (int i = 0; i < range.RowCount; i++) { int row = i + range.Row; for (int j = 0; j < range.ColumnCount; j++) { int column = j + range.Column; object val = actualValue.GetValue(row, column); if (val != null) { double?nullable = ConditionValueConverter.TryDouble(val); if (nullable.HasValue) { double num5 = nullable.Value; if (!min.HasValue) { min = new double?(num5); } if (!max.HasValue) { max = new double?(num5); } double num7 = num5; double?nullable2 = min; if ((num7 < ((double)nullable2.GetValueOrDefault())) && nullable2.HasValue) { min = new double?(num5); } double num8 = num5; double?nullable3 = max; if ((num8 > ((double)nullable3.GetValueOrDefault())) && nullable3.HasValue) { max = new double?(num5); } } } } } } } }
/// <summary> /// Returns the specified value of the rule if the cell meets the condition. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The row index.</param> /// <param name="baseColumn">The column index.</param> /// <param name="actual">The current value.</param> /// <returns>Returns the conditional number value.</returns> public override object Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { this.lastActualValue = actual; object obj2 = actual.GetValue(baseRow, baseColumn); if (obj2 != null) { double num; try { num = ConditionValueConverter.ToDouble(obj2); } catch (InvalidCastException) { return(null); } double?nullable = base.GetActualValue(evaluator, baseRow, baseColumn, 0, actual); double?nullable2 = base.GetActualValue(evaluator, baseRow, baseColumn, 1, actual); double?nullable3 = base.GetActualValue(evaluator, baseRow, baseColumn, 2, actual); if ((nullable.HasValue && nullable3.HasValue) && nullable2.HasValue) { double?nullable4 = nullable; double?nullable5 = nullable3; if ((((double)nullable4.GetValueOrDefault()) > ((double)nullable5.GetValueOrDefault())) && (nullable4.HasValue & nullable5.HasValue)) { return(null); } double num4 = num; double?nullable6 = nullable; if ((num4 < ((double)nullable6.GetValueOrDefault())) && nullable6.HasValue) { return(this.MinimumColor); } double num5 = num; double?nullable7 = nullable3; if ((num5 >= ((double)nullable7.GetValueOrDefault())) && nullable7.HasValue) { return(this.MaximumColor); } if ((nullable.Value <= num) && (num <= nullable2.Value)) { return(ScaleRule.EvaluateColor(ScaleRule.Evaluate2Scale(num, nullable.Value, nullable2.Value), this.MinimumColor, this.MidpointColor)); } return(ScaleRule.EvaluateColor(ScaleRule.Evaluate2Scale(num, nullable2.Value, nullable3.Value), this.MidpointColor, this.MaximumColor)); } } return(null); }
static List <object> GetDuplicated(IActualValue actualValue, ICellRange[] ranges, int maxRowCount = 0x7fffffff, int maxColumnCount = 0x7fffffff) { Dictionary <object, int> dictionary = new Dictionary <object, int>(); if (ranges != null) { foreach (ICellRange range in ranges) { int num = Math.Min(range.RowCount, maxRowCount); for (int i = 0; i < num; i++) { int row = i + range.Row; int num4 = Math.Min(range.ColumnCount, maxColumnCount); for (int j = 0; j < num4; j++) { int column = j + range.Column; object obj2 = actualValue.GetValue(row, column); if (obj2 != null) { if (ConditionValueConverter.IsNumber(obj2)) { obj2 = (double)ConditionValueConverter.TryDouble(obj2).Value; } int num7 = 0; dictionary.TryGetValue(obj2, out num7); dictionary[obj2] = num7 + 1; } } } } } List <object> list = new List <object>(); foreach (KeyValuePair <object, int> pair in dictionary) { if (pair.Value > 1) { list.Add(pair.Key); } } return(list); }
/// <summary> /// Returns the cell style of the rule if the cell satisfies the condition. /// </summary> /// <param name="evaluator"></param> /// <param name="baseRow">The row index.</param> /// <param name="baseColumn">The column index.</param> /// <param name="actual"></param> /// <returns> /// Returns the conditional <see cref="T:Dt.Cells.Data.StyleInfo" /> object. /// </returns> public virtual object Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { int num; int num2; if (!this.Contains(baseRow, baseColumn)) { return(null); } this.InitCondition(); this.GetBaseCoordinate(out num, out num2); this.condition.AdjustOffset(baseRow - num, baseColumn - num2, true); object expected = null; if (this.condition.Evaluate(evaluator, baseRow, baseColumn, actual)) { expected = this.GetExpected(); } this.condition.AdjustOffset(0, 0, true); return(expected); }
/// <summary> /// Returns a specified value of the rule if the cell satisfies the condition. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The row index.</param> /// <param name="baseColumn">The column index.</param> /// <param name="actual">The current object.</param> /// <returns>Returns an icon object.</returns> public override object Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { object obj2 = actual.GetValue(baseRow, baseColumn); if (obj2 == null) { return(null); } double num = 0.0; if (!FormatConverter.IsNumber(obj2)) { return(null); } double?nullable = FormatConverter.TryDouble(obj2, false); if (!nullable.HasValue) { return(null); } num = nullable.Value; int num2 = 0; if ((this.iconSetType >= Dt.Cells.Data.IconSetType.ThreeArrowsColored) && (this.iconSetType <= Dt.Cells.Data.IconSetType.ThreeSymbolsUncircled)) { num2 = 3; } else if ((this.iconSetType >= Dt.Cells.Data.IconSetType.FourArrowsColored) && (this.iconSetType <= Dt.Cells.Data.IconSetType.FourTrafficLights)) { num2 = 4; } else if ((this.iconSetType >= Dt.Cells.Data.IconSetType.FiveArrowsColored) && (this.iconSetType <= Dt.Cells.Data.IconSetType.FiveBoxes)) { num2 = 5; } if (this.iconCriteria == null) { return((int)0); } double maxValue = double.MaxValue; for (int i = num2 - 1; i > 0; i--) { if (i >= (this.iconCriteria.Length + 1)) { return(new IconDrawingObject(baseRow, baseColumn, this.iconSetType, this.modifyIconIndex(0), this.showIconOnly)); } IconCriterion criterion = this.iconCriteria[i - 1]; if ((criterion == null) || (criterion.Value == null)) { return(new IconDrawingObject(baseRow, baseColumn, this.iconSetType, this.modifyIconIndex(0), this.showIconOnly)); } double?nullable2 = this.GetActualValue(evaluator, baseRow, baseColumn, i - 1, actual); if (!nullable2.HasValue) { return(new IconDrawingObject(baseRow, baseColumn, this.iconSetType, this.modifyIconIndex(0), this.showIconOnly)); } if (criterion.IsGreaterThanOrEqualTo) { if ((num < maxValue) && (num >= nullable2.Value)) { return(new IconDrawingObject(baseRow, baseColumn, this.iconSetType, this.modifyIconIndex(i), this.showIconOnly)); } } else if ((num < maxValue) && (num > nullable2.Value)) { return(new IconDrawingObject(baseRow, baseColumn, this.iconSetType, this.modifyIconIndex(i), this.showIconOnly)); } } return(new IconDrawingObject(baseRow, baseColumn, this.iconSetType, this.modifyIconIndex(0), this.showIconOnly)); }
/// <summary> /// Evaluates using the specified evaluator. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The base row.</param> /// <param name="baseColumn">The base column.</param> /// <param name="actualObj">The actual value object.</param> /// <returns><c>true</c> if the result is successful; otherwise, <c>false</c>.</returns> public override bool Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actualObj) { switch (this.compareType) { case ColorCompareType.BackgroundColor: return(this.IsEqualsBackgroundColor(actualObj)); case ColorCompareType.ForegroundColor: return(this.IsEqualsForegroundColor(actualObj)); } return(false); }
/// <summary> /// Evaluates using the specified evaluator. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The base row.</param> /// <param name="baseColumn">The base column.</param> /// <param name="actualObj">The actual value object.</param> /// <returns><c>true</c> if the result is successful; otherwise, <c>false</c>.</returns> public override bool Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actualObj) { if (this.customValueType == CustomValueType.Formula) { object val = base.GetExpected(evaluator, baseRow, baseColumn); if (this.IgnoreBlank && (val == null)) { return(true); } bool?nullable = ConditionValueConverter.TryBool(val); if (!nullable.HasValue) { return(false); } return(nullable.Value); } object objA = actualObj.GetValue(); switch (this.customValueType) { case CustomValueType.Empty: return((objA == null) || object.Equals(objA, string.Empty)); case CustomValueType.NonEmpty: if (objA == null) { return(false); } return(!object.Equals(objA, string.Empty)); case CustomValueType.Error: return(evaluator.IsCalcError(objA)); case CustomValueType.NonError: return(!evaluator.IsCalcError(objA)); } return(false); }
/// <summary> /// Evaluates using the specified evaluator. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The base row.</param> /// <param name="baseColumn">The base column.</param> /// <param name="actualObj">The actual value object.</param> /// <returns><c>true</c> if the result is successful; otherwise, <c>false</c>.</returns> public override bool Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actualObj) { object obj2 = actualObj.GetValue(); if (obj2 == null) { return(this.IgnoreBlank); } if (ConditionValueConverter.IsNumber(obj2)) { obj2 = (double)ConditionValueConverter.TryDouble(obj2).Value; } bool?nullable = base.GetExpectedBoolean(evaluator, baseRow, baseColumn); if (!nullable.HasValue) { return(false); } Worksheet worksheet = evaluator as Worksheet; List <object> list = null; if (worksheet != null) { list = GetDuplicated(actualObj, this.ranges, worksheet.RowCount, worksheet.ColumnCount); } else { list = GetDuplicated(actualObj, this.ranges, 0x7fffffff, 0x7fffffff); } if (list != null) { if (list.Contains(obj2)) { return(nullable.Value); } if (nullable.Value) { return(false); } return(true); } if (nullable.Value) { return(false); } return(true); }
public override bool Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actualObj) { object obj2 = actualObj.GetValue(); if ((obj2 == null) || obj2.Equals(string.Empty)) { return(this.IgnoreBlank); } object[] objArray = this.GetValidList(evaluator, baseRow, baseColumn); object obj3 = (obj2 is string) ? new GeneralFormatter().Parse((string)(obj2 as string)) : obj2; object obj4 = obj3; if (obj3 is TimeSpan) { TimeSpan span = (TimeSpan)obj3; obj3 = new DateTime(0x76b, 12, 30, span.Hours, span.Minutes, span.Seconds, span.Milliseconds); } if (objArray != null) { foreach (object obj5 in objArray) { if ((obj5 == null) && (obj2 == null)) { return(true); } if (obj5 != null) { if (this.IsNumber(obj5) && this.IsNumber(obj3)) { double num; double num2; if ((double.TryParse(obj5.ToString(), (NumberStyles)NumberStyles.Any, (IFormatProvider)CultureInfo.InvariantCulture.NumberFormat, out num) && double.TryParse(obj3.ToString(), (NumberStyles)NumberStyles.Any, (IFormatProvider)CultureInfo.InvariantCulture.NumberFormat, out num2)) && (Math.Round(Math.Abs((double)(num - num2)), 10) <= 1E-10)) { return(true); } } else { if (obj5.Equals(obj3)) { return(true); } if (((obj5 is TimeSpan) && (obj4 is TimeSpan)) && obj5.Equals(obj4)) { return(true); } } } } } return(false); }
/// <summary> /// Evaluates using the specified evaluator. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The base row.</param> /// <param name="baseColumn">The base column.</param> /// <param name="actualObj">The actual value object.</param> /// <returns><c>true</c> if the result is successful; otherwise, <c>false</c>.</returns> public override bool Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actualObj) { object obj2 = actualObj.GetValue(); if (obj2 == null) { return(this.IgnoreBlank); } int?nullable = base.GetExpectedInt(evaluator, baseRow, baseColumn); if (nullable.HasValue) { List <double> list = null; if (this.type == Top10ConditionType.Top) { list = GetMaxValues(actualObj, nullable.Value, this.ranges); } else if (this.type == Top10ConditionType.Bottom) { list = GetMinValues(actualObj, nullable.Value, this.ranges); } if (list != null) { double num = 0.0; try { num = ConditionValueConverter.ToDouble(obj2); } catch (InvalidCastException) { return(false); } if (list.Contains(num)) { return(true); } } } return(false); }
/// <summary> /// Evaluates using the specified evaluator. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The base row.</param> /// <param name="baseColumn">The base column.</param> /// <param name="actualObj">The actual value object.</param> /// <returns><c>true</c> if the result is successful; otherwise, <c>false</c>.</returns> public override bool Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actualObj) { string text = actualObj.GetText(); if (string.IsNullOrEmpty(text)) { return(this.IgnoreBlank); } int num = (text == null) ? 0 : text.Length; int?nullable = base.GetExpectedInt(evaluator, baseRow, baseColumn); if (nullable.HasValue) { switch (this.compareType) { case GeneralCompareType.EqualsTo: return(num == nullable.Value); case GeneralCompareType.NotEqualsTo: return(num != nullable.Value); case GeneralCompareType.GreaterThan: return(num > nullable.Value); case GeneralCompareType.GreaterThanOrEqualsTo: return(num >= nullable.Value); case GeneralCompareType.LessThan: return(num < nullable.Value); case GeneralCompareType.LessThanOrEqualsTo: return(num <= nullable.Value); } } return(false); }
internal double?GetActualValue(ICalcEvaluator evaluator, int baseRow, int baseColumn, int index, IActualValue actual) { IconCriterion criterion = this.iconCriteria[index]; if (criterion != null) { switch (criterion.IconValueType) { case IconValueType.Number: return(this.CalculateValue(evaluator, baseRow, baseColumn, criterion.Value)); case IconValueType.Percent: return(this.CalculatePercent(evaluator, baseRow, baseColumn, criterion.Value, actual)); case IconValueType.Percentile: return(this.CalculatePercentile(evaluator, baseRow, baseColumn, criterion.Value)); case IconValueType.Formula: return(this.CalculateValue(evaluator, baseRow, baseColumn, criterion.Value)); } } return(null); }
internal override bool IsConditionEvaluateToTrue(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { if (base.condition == null) { return(false); } object obj2 = actual.GetValue(baseRow, baseColumn); if (obj2 == null) { return(false); } double num = 0.0; if (!FormatConverter.IsNumber(obj2)) { return(false); } double?nullable = FormatConverter.TryDouble(obj2, false); if (!nullable.HasValue) { return(false); } num = nullable.Value; int num2 = 0; if ((this.iconSetType >= Dt.Cells.Data.IconSetType.ThreeArrowsColored) && (this.iconSetType <= Dt.Cells.Data.IconSetType.ThreeSymbolsUncircled)) { num2 = 3; } else if ((this.iconSetType >= Dt.Cells.Data.IconSetType.FourArrowsColored) && (this.iconSetType <= Dt.Cells.Data.IconSetType.FourTrafficLights)) { num2 = 4; } else if ((this.iconSetType >= Dt.Cells.Data.IconSetType.FiveArrowsColored) && (this.iconSetType <= Dt.Cells.Data.IconSetType.FiveBoxes)) { num2 = 5; } if (this.iconCriteria != null) { double maxValue = double.MaxValue; for (int i = num2 - 1; i > 0; i--) { if (i >= (this.iconCriteria.Length + 1)) { return(true); } IconCriterion criterion = this.iconCriteria[i - 1]; if ((criterion == null) || (criterion.Value == null)) { return(true); } double?nullable2 = this.GetActualValue(evaluator, baseRow, baseColumn, i - 1, actual); if (!nullable2.HasValue) { return(true); } if (criterion.IsGreaterThanOrEqualTo) { if ((num < maxValue) && (num >= nullable2.Value)) { return(true); } } else if ((num < maxValue) && (num > nullable2.Value)) { return(true); } } } return(true); }
/// <summary> /// Evaluates by the specified evaluator. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The base row.</param> /// <param name="baseColumn">The base column.</param> /// <param name="actual">The actual value object.</param> /// <returns><c>true</c> if the result is successful, otherwise <c>false</c>.</returns> public abstract bool Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual);
internal virtual bool IsConditionEvaluateToTrue(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { if (this.Contains(baseRow, baseColumn)) { int num; int num2; this.InitCondition(); this.GetBaseCoordinate(out num, out num2); this.condition.AdjustOffset(baseRow - num, baseColumn - num2, true); return(this.condition.Evaluate(evaluator, baseRow, baseColumn, actual)); } return(false); }
/// <summary> /// Evaluates using the specified evaluator. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The base row.</param> /// <param name="baseColumn">The base column.</param> /// <param name="actualObj">The actual value object.</param> /// <returns><c>true</c> if the result is successful; otherwise, <c>false</c>.</returns> public override bool Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actualObj) { object expectedValue = null; object actualValue = actualObj.GetValue(); if (this.integerValue) { int?nullable = base.GetExpectedInt(evaluator, baseRow, baseColumn); expectedValue = nullable.HasValue ? ((object)((int)nullable.Value)) : null; } else { expectedValue = base.GetExpected(evaluator, baseRow, baseColumn); } return(this.CheckCondition(expectedValue, actualValue)); }
/// <summary> /// Evaluates using the specified evaluator. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The base row.</param> /// <param name="baseColumn">The base column.</param> /// <param name="actualObj">The actual value object.</param> /// <returns><c>true</c> if the result is successful; otherwise, <c>false</c>.</returns> public override bool Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actualObj) { object obj2 = actualObj.GetValue(); if (this.IgnoreBlank && (obj2 == null)) { return(true); } this.RebuildFormula(evaluator); double?nullable = base.GetExpectedDouble(evaluator, baseRow, baseColumn); double?nullable2 = null; object val = (this.stdValueObject != null) ? this.stdValueObject.GetValue(evaluator, baseRow, baseColumn) : null; if (val != null) { nullable2 = ConditionValueConverter.TryDouble(val); } if (ConditionValueConverter.IsNumber(obj2)) { double num = ConditionValueConverter.ToDouble(obj2); if (nullable.HasValue) { switch (this.type) { case AverageConditionType.Above: return(num > nullable.Value); case AverageConditionType.Below: return(num < nullable.Value); case AverageConditionType.EqualOrAbove: return(num >= nullable.Value); case AverageConditionType.EqualOrBelow: return(num <= nullable.Value); case AverageConditionType.Above1StdDev: { this.stdValueObject.GetValue(evaluator, baseRow, baseColumn); if (!nullable2.HasValue) { return(false); } double num2 = num; double?nullable3 = nullable; double num3 = nullable2.Value; double?nullable5 = nullable3.HasValue ? new double?(((double)nullable3.GetValueOrDefault()) + num3) : null; if (num2 <= ((double)nullable5.GetValueOrDefault())) { return(false); } return(nullable5.HasValue); } case AverageConditionType.Below1StdDev: { if (!nullable2.HasValue) { return(false); } double num4 = num; double?nullable6 = nullable; double num5 = nullable2.Value; double?nullable8 = nullable6.HasValue ? new double?(((double)nullable6.GetValueOrDefault()) - num5) : null; if (num4 >= ((double)nullable8.GetValueOrDefault())) { return(false); } return(nullable8.HasValue); } case AverageConditionType.Above2StdDev: { if (!nullable2.HasValue) { return(false); } double num6 = num; double?nullable9 = nullable; double num7 = 2.0 * nullable2.Value; double?nullable11 = nullable9.HasValue ? new double?(((double)nullable9.GetValueOrDefault()) + num7) : null; if (num6 <= ((double)nullable11.GetValueOrDefault())) { return(false); } return(nullable11.HasValue); } case AverageConditionType.Below2StdDev: { if (!nullable2.HasValue) { return(false); } double num8 = num; double?nullable12 = nullable; double num9 = 2.0 * nullable2.Value; double?nullable14 = nullable12.HasValue ? new double?(((double)nullable12.GetValueOrDefault()) - num9) : null; if (num8 >= ((double)nullable14.GetValueOrDefault())) { return(false); } return(nullable14.HasValue); } case AverageConditionType.Above3StdDev: { if (!nullable2.HasValue) { return(false); } double num10 = num; double?nullable15 = nullable; double num11 = 3.0 * nullable2.Value; double?nullable17 = nullable15.HasValue ? new double?(((double)nullable15.GetValueOrDefault()) + num11) : null; if (num10 <= ((double)nullable17.GetValueOrDefault())) { return(false); } return(nullable17.HasValue); } case AverageConditionType.Below3StdDev: { if (!nullable2.HasValue) { return(false); } double num12 = num; double?nullable18 = nullable; double num13 = 3.0 * nullable2.Value; double?nullable20 = nullable18.HasValue ? new double?(((double)nullable18.GetValueOrDefault()) - num13) : null; if (num12 >= ((double)nullable20.GetValueOrDefault())) { return(false); } return(nullable20.HasValue); } } } } return(false); }
/// <summary> /// Evaluates using the specified evaluator. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The base row.</param> /// <param name="baseColumn">The base column.</param> /// <param name="actualObj">The actual value object.</param> /// <returns><c>true</c> if the result is successful; otherwise, <c>false</c>.</returns> public override bool Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actualObj) { if ((actualObj.GetValue() == null) && this.IgnoreBlank) { return(true); } object obj2 = actualObj.GetValue(NumberFormatType.DateTime); if (obj2 is DateTime) { DateTime?nullable = base.GetExpectedDateTime(evaluator, baseRow, baseColumn); if (!nullable.HasValue && this.IgnoreBlank) { return(true); } if (!nullable.HasValue) { return(false); } switch (this.CompareType) { case DateCompareType.EqualsTo: return(this.IsEquals(nullable.Value, (DateTime)obj2)); case DateCompareType.NotEqualsTo: return(!this.IsEquals(nullable.Value, (DateTime)obj2)); case DateCompareType.Before: return(this.IsBefore(nullable.Value, (DateTime)obj2)); case DateCompareType.BeforeEqualsTo: return(this.IsBefore(nullable.Value, (DateTime)obj2) || this.IsEquals(nullable.Value, (DateTime)obj2)); case DateCompareType.After: return(this.IsAfter(nullable.Value, (DateTime)obj2)); case DateCompareType.AfterEqualsTo: return(this.IsAfter(nullable.Value, (DateTime)obj2) || this.IsEquals(nullable.Value, (DateTime)obj2)); } } return(false); }
public override bool Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actualObj) { object expectedValue = base.GetExpected(evaluator, baseRow, baseColumn); object actualValue = actualObj.GetValue(); return(this.CheckCondition(expectedValue, actualValue)); }
/// <summary> /// Evaluates using the specified evaluator. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The base row.</param> /// <param name="baseColumn">The base column.</param> /// <param name="actualObj">The actual value object.</param> /// <returns><c>true</c> if the result is successful; otherwise, <c>false</c>.</returns> public override bool Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actualObj) { string text; if (this.forceValue2Text) { text = actualObj.GetText(); } else { object obj2 = actualObj.GetValue(); if ((obj2 is DateTime) || (obj2 is TimeSpan)) { return((((this.compareType != TextCompareType.BeginsWith) && (this.compareType != TextCompareType.EndsWith)) && (this.compareType != TextCompareType.Contains)) && (((this.compareType == TextCompareType.DoesNotBeginWith) || (this.compareType == TextCompareType.DoesNotEndWith)) || (this.compareType == TextCompareType.DoesNotContain))); } text = (obj2 == null) ? actualObj.GetText() : obj2.ToString(); } if (this.IgnoreBlank && string.IsNullOrEmpty(text)) { return(true); } string expected = base.GetExpectedString(evaluator, baseRow, baseColumn); switch (this.CompareType) { case TextCompareType.EqualsTo: return(this.IsEquals(expected, text)); case TextCompareType.NotEqualsTo: return(!this.IsEquals(expected, text)); case TextCompareType.BeginsWith: return(this.IsStartWith(expected, text)); case TextCompareType.DoesNotBeginWith: return(!this.IsStartWith(expected, text)); case TextCompareType.EndsWith: return(this.IsEndWith(expected, text)); case TextCompareType.DoesNotEndWith: return(!this.IsEndWith(expected, text)); case TextCompareType.Contains: return(this.IsContains(expected, text)); case TextCompareType.DoesNotContain: return(!this.IsContains(expected, text)); } return(false); }