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 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);
}
/// <summary>
/// Calculates the number.
/// </summary>
/// <param name="value">Value</param>
/// <returns>Returns the value.</returns>
internal double?CalculateNumber(object value)
{
try
{
return(new double?(ConditionValueConverter.ToDouble(value)));
}
catch (InvalidCastException)
{
return(null);
}
}
/// <summary>
/// Calculates the formula.
/// </summary>
/// <param name="evaluator"></param>
/// <param name="baseRow"></param>
/// <param name="baseColumn"></param>
/// <param name="formula">Formula</param>
/// <returns>Returns the formula.</returns>
internal double?CalculateFormula(ICalcEvaluator evaluator, int baseRow, int baseColumn, string formula)
{
object obj2 = ValueObject.FromFormula(formula).GetValue(evaluator, baseRow, baseColumn);
try
{
return(new double?(ConditionValueConverter.ToDouble(obj2)));
}
catch (InvalidCastException)
{
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);
}
/// <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 bool TryConvertToNumber(object value, out double dValue)
{
dValue = 0.0;
if (ConditionValueConverter.IsNumber(value))
{
try
{
dValue = ConditionValueConverter.ToDouble(value);
}
catch
{
return(false);
}
return(true);
}
return((value is string) && double.TryParse((string)(value as string), (NumberStyles)NumberStyles.Any, (IFormatProvider)CultureInfo.InvariantCulture, out dValue));
}
/// <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>
/// Calculates the percentile for the specified value.
/// </summary>
/// <param name="evaluator"></param>
/// <param name="baseRow"></param>
/// <param name="baseColumn"></param>
/// <param name="value">Value</param>
/// <returns>Returns the percentile for the value.</returns>
internal double?CalculatePercentile(ICalcEvaluator evaluator, int baseRow, int baseColumn, object value)
{
double?nullable = this.CalculateValue(evaluator, baseRow, baseColumn, value);
if ((!nullable.HasValue || (0.0 > nullable.Value)) || (nullable.Value > 100.0))
{
return(null);
}
double num = 0.0;
foreach (CellRange range in base.Ranges)
{
object expression = evaluator.CreateExpression("CalcPercentileFunction", new object[] { range, (double)(nullable.Value / 100.0) });
object obj3 = evaluator.EvaluateExpression(expression, 0, 0, baseRow, baseColumn, false);
try
{
num += ConditionValueConverter.ToDouble(obj3);
}
catch (InvalidCastException)
{
}
}
return(new double?(num / ((double)base.Ranges.Length)));
}
/// <summary>
/// Checks the condition.
/// </summary>
/// <param name="expectedValue">Expected value for the condition.</param>
/// <param name="actualValue">Actual value for the condition.</param>
/// <returns>
/// <c>true</c> if the value satisfies the condition; otherwise, <c>false</c>.
/// </returns>
bool CheckCondition(object expectedValue, object actualValue)
{
double dValue = 0.0;
bool flag = false;
if (expectedValue is bool)
{
bool @this = (bool)((bool)expectedValue);
switch (this.compareType)
{
case GeneralCompareType.EqualsTo:
return(object.Equals(actualValue, expectedValue));
case GeneralCompareType.NotEqualsTo:
return(!object.Equals(actualValue, expectedValue));
case GeneralCompareType.GreaterThan:
if (@this.CompareTo(actualValue) >= 0)
{
return(false);
}
return(true);
case GeneralCompareType.GreaterThanOrEqualsTo:
if (@this.CompareTo(actualValue) > 0)
{
return(false);
}
return(true);
case GeneralCompareType.LessThan:
if (@this.CompareTo(actualValue) <= 0)
{
return(false);
}
return(true);
case GeneralCompareType.LessThanOrEqualsTo:
if (@this.CompareTo(actualValue) < 0)
{
return(false);
}
return(true);
}
}
if (actualValue is TimeSpan)
{
TimeSpan span = (TimeSpan)actualValue;
dValue = span.TotalSeconds;
flag = true;
}
else
{
flag = TryConvertToNumber(actualValue, out dValue);
}
if ((actualValue == null) && (expectedValue == null))
{
switch (this.compareType)
{
case GeneralCompareType.EqualsTo:
case GeneralCompareType.GreaterThanOrEqualsTo:
case GeneralCompareType.LessThanOrEqualsTo:
return(true);
case GeneralCompareType.NotEqualsTo:
case GeneralCompareType.GreaterThan:
case GeneralCompareType.LessThan:
return(false);
}
return(false);
}
if (this.TreatNullValueAsZero && (actualValue == null))
{
flag = true;
dValue = 0.0;
}
if (flag)
{
double totalSeconds = 0.0;
try
{
if (expectedValue is DateTime)
{
totalSeconds = ((DateTime)expectedValue).ToOADate();
}
else if (expectedValue is TimeSpan)
{
TimeSpan span2 = (TimeSpan)expectedValue;
totalSeconds = span2.TotalSeconds;
}
else
{
totalSeconds = ConditionValueConverter.ToDouble(expectedValue);
}
}
catch
{
switch (this.CompareType)
{
case GeneralCompareType.EqualsTo:
return(false);
case GeneralCompareType.NotEqualsTo:
return(true);
}
return(false);
}
switch (this.CompareType)
{
case GeneralCompareType.EqualsTo:
return(dValue == totalSeconds);
case GeneralCompareType.NotEqualsTo:
return(!(dValue == totalSeconds));
case GeneralCompareType.GreaterThan:
return(dValue > totalSeconds);
case GeneralCompareType.GreaterThanOrEqualsTo:
return(dValue >= totalSeconds);
case GeneralCompareType.LessThan:
return(dValue < totalSeconds);
case GeneralCompareType.LessThanOrEqualsTo:
return(dValue <= totalSeconds);
}
}
else if (actualValue is string)
{
string str = null;
if (expectedValue is string)
{
str = (string)(expectedValue as string);
}
else
{
switch (this.CompareType)
{
case GeneralCompareType.EqualsTo:
return(false);
case GeneralCompareType.NotEqualsTo:
return(true);
}
return(false);
}
string strB = (string)((string)actualValue);
switch (this.CompareType)
{
case GeneralCompareType.EqualsTo:
return(strB == str);
case GeneralCompareType.NotEqualsTo:
return(strB != str);
case GeneralCompareType.GreaterThan:
return(str.CompareTo(strB) < 0);
case GeneralCompareType.GreaterThanOrEqualsTo:
return(str.CompareTo(strB) <= 0);
case GeneralCompareType.LessThan:
return(str.CompareTo(strB) > 0);
case GeneralCompareType.LessThanOrEqualsTo:
return(str.CompareTo(strB) >= 0);
}
}
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 (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>
/// Checks the condition.
/// </summary>
/// <param name="expectedValue">Expected value for the condition.</param>
/// <param name="actualValue">Actual value for the condition.</param>
/// <returns>
/// <c>true</c> if the value satisfies the condition; otherwise, <c>false</c>.
/// </returns>
bool CheckCondition(object expectedValue, object actualValue)
{
if (this.IgnoreBlank && ((actualValue == null) || actualValue.Equals(string.Empty)))
{
return(true);
}
if (ConditionValueConverter.IsNumber(actualValue))
{
double?nullable = null;
object obj2 = expectedValue;
if (obj2 is string)
{
return((this.CompareType == GeneralCompareType.NotEqualsTo) && ConditionValueConverter.IsNumber(actualValue));
}
if (ConditionValueConverter.IsNumber(obj2))
{
nullable = new double?(ConditionValueConverter.ToDouble(obj2));
}
if (!nullable.HasValue)
{
if (this.IgnoreBlank)
{
return(true);
}
nullable = 0.0;
}
double d = 0.0;
try
{
d = ConditionValueConverter.ToDouble(actualValue);
}
catch (FormatException)
{
return(false);
}
if (!this.IntegerValue || ((d - Math.Floor(d)) == 0.0))
{
switch (this.CompareType)
{
case GeneralCompareType.EqualsTo:
return(d == nullable.Value);
case GeneralCompareType.NotEqualsTo:
return(d != nullable.Value);
case GeneralCompareType.GreaterThan:
return(d > nullable.Value);
case GeneralCompareType.GreaterThanOrEqualsTo:
return(d >= nullable.Value);
case GeneralCompareType.LessThan:
return(d < nullable.Value);
case GeneralCompareType.LessThanOrEqualsTo:
return(d <= nullable.Value);
}
}
}
return(false);
}
internal override bool IsConditionEvaluateToTrue(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual)
{
if (base.condition != null)
{
this.TryCache(actual);
if (base.Contains(baseRow, baseColumn))
{
object obj2 = actual.GetValue();
if (obj2 == null)
{
return(false);
}
try
{
double num = ConditionValueConverter.ToDouble(obj2);
double?nullable = this.GetActualValue(evaluator, baseRow, baseColumn, 0, actual);
double?nullable2 = this.GetActualValue(evaluator, baseRow, baseColumn, 1, actual);
double?nullable3 = this.GetActualValue(evaluator, baseRow, baseColumn, 2, actual);
if (!nullable2.HasValue)
{
if (nullable.HasValue && nullable3.HasValue)
{
double?nullable4 = nullable;
double?nullable5 = nullable3;
if ((((double)nullable4.GetValueOrDefault()) > ((double)nullable5.GetValueOrDefault())) && (nullable4.HasValue & nullable5.HasValue))
{
return(false);
}
return(true);
}
}
else if ((nullable.HasValue && nullable3.HasValue) && nullable2.HasValue)
{
double?nullable6 = nullable;
double?nullable7 = nullable3;
if ((((double)nullable6.GetValueOrDefault()) > ((double)nullable7.GetValueOrDefault())) && (nullable6.HasValue & nullable7.HasValue))
{
return(false);
}
double num2 = num;
double?nullable8 = nullable;
if ((num2 >= ((double)nullable8.GetValueOrDefault())) || !nullable8.HasValue)
{
double num3 = num;
double?nullable9 = nullable3;
if ((num3 >= ((double)nullable9.GetValueOrDefault())) && nullable9.HasValue)
{
return(true);
}
Evaluate2Scale(nullable2.Value, nullable.Value, nullable3.Value);
if ((nullable.Value <= num) && (num <= nullable2.Value))
{
return(true);
}
}
return(true);
}
}
catch
{
return(false);
}
}
}
return(false);
}
/// <summary>
/// Evaluates 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.TryCache(actual);
if (base.Contains(baseRow, baseColumn))
{
object obj2 = actual.GetValue();
if (obj2 == null)
{
return(null);
}
try
{
double num = ConditionValueConverter.ToDouble(obj2);
double?nullable = this.GetActualValue(evaluator, baseRow, baseColumn, 0, actual);
double?nullable2 = this.GetActualValue(evaluator, baseRow, baseColumn, 1, actual);
double?nullable3 = this.GetActualValue(evaluator, baseRow, baseColumn, 2, actual);
if (!nullable2.HasValue)
{
if (nullable.HasValue && nullable3.HasValue)
{
double?nullable4 = nullable;
double?nullable5 = nullable3;
if ((((double)nullable4.GetValueOrDefault()) > ((double)nullable5.GetValueOrDefault())) && (nullable4.HasValue & nullable5.HasValue))
{
return(null);
}
return((double)Evaluate2Scale(num, nullable.Value, nullable3.Value));
}
}
else if ((nullable.HasValue && nullable3.HasValue) && nullable2.HasValue)
{
double?nullable6 = nullable;
double?nullable7 = nullable3;
if ((((double)nullable6.GetValueOrDefault()) > ((double)nullable7.GetValueOrDefault())) && (nullable6.HasValue & nullable7.HasValue))
{
return(null);
}
double num5 = num;
double?nullable8 = nullable;
if ((num5 < ((double)nullable8.GetValueOrDefault())) && nullable8.HasValue)
{
return((double)0.0);
}
double num6 = num;
double?nullable9 = nullable3;
if ((num6 >= ((double)nullable9.GetValueOrDefault())) && nullable9.HasValue)
{
return((double)2.0);
}
Evaluate2Scale(nullable2.Value, nullable.Value, nullable3.Value);
if ((nullable.Value <= num) && (num <= nullable2.Value))
{
return((double)Evaluate2Scale(num, nullable.Value, nullable2.Value));
}
double num4 = 1.0 + Evaluate2Scale(num, nullable.Value, nullable3.Value);
return((double)num4);
}
}
catch
{
return(null);
}
}
return(null);
}
