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>
/// 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 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);
}
public static SheetCellRange[] ValidateFormula(ICalcEvaluator evaluator, string formula, bool acceptConstantExpression = false)
{
if (string.IsNullOrEmpty(formula) || (evaluator == null))
{
return(null);
}
CalcExpression expression = FormulaUtility.Formula2Expression(evaluator, formula);
if (expression == null)
{
throw new ArgumentException("Formula is invalid.");
}
if ((expression is CalcConstantExpression) && acceptConstantExpression)
{
return(null);
}
SheetCellRange[] rangeArray = SheetCellRangeUtility.ExtractAllExternalReference(evaluator, formula);
if (rangeArray == null)
{
throw new ArgumentException("Formula is invalid.");
}
if (rangeArray.Length > 0)
{
Worksheet sheet = null;
foreach (SheetCellRange range in rangeArray)
{
if ((sheet != null) && (range.Sheet != sheet))
{
throw new ArgumentException("Formula is invalid.");
}
sheet = range.Sheet;
}
}
return(rangeArray);
}
internal void InitializeFormula(ICalcEvaluator evaluator, int baseRow, int baseColumn, bool forceReparse)
{
if (((this.isFormula && !string.IsNullOrEmpty(this.formula)) && (evaluator != null)) && (forceReparse || (this.expression == null)))
{
this.expression = evaluator.Formula2Expression(this.formula, baseRow - this.rowOffset, baseColumn - this.columnOffset);
}
}
void RebuildFormula(ICalcEvaluator evaluator)
{
base.ClearExpected();
this.stdValueObject = null;
if (this.ranges != null)
{
base.ExpectedExpression = evaluator.CreateExpression("CalcAverageFunction", this.ranges);
switch (this.type)
{
case AverageConditionType.Above1StdDev:
case AverageConditionType.Below1StdDev:
case AverageConditionType.Above2StdDev:
case AverageConditionType.Below2StdDev:
case AverageConditionType.Above3StdDev:
case AverageConditionType.Below3StdDev:
{
object expression = evaluator.CreateExpression("CalcStDevFunction", this.ranges);
this.stdValueObject = ValueObject.FromExpression(expression);
break;
}
default:
return;
}
}
}
internal double?CalcuteMinValue(ICalcEvaluator evaluator, int baseRow, int baseColumn, int index, IActualValue actual)
{
ScaleValue value2 = base.scales[index];
CellRange range = null;
if (value2 != null)
{
if ((value2.Type != ScaleValueType.Formula) && (value2.Type != ScaleValueType.Percentile))
{
return(base.GetActualValue(evaluator, baseRow, baseColumn, 0, actual));
}
for (int i = 0; i < base.Ranges.Length; i++)
{
if (base.Ranges[i].IntersectRow(baseRow))
{
range = base.Ranges[i];
break;
}
}
if (range != null)
{
return(base.GetActualValue(evaluator, range.Row, range.Column, 0, actual));
}
}
return(null);
}
public static SheetCellRange ExtractRange(ICalcEvaluator sheet, CalcExpression value)
{
if ((value != null) && !(value is CalcConstantExpression))
{
if ((value is CalcExternalCellExpression) || (value is CalcExternalRangeExpression))
{
CalcExternalCellExpression expression = value as CalcExternalCellExpression;
if (expression != null)
{
return(new SheetCellRange(expression.Source as Worksheet, expression.Row, expression.Column, 1, 1));
}
CalcExternalRangeExpression expression2 = value as CalcExternalRangeExpression;
if (expression2 != null)
{
return(new SheetCellRange(expression2.Source as Worksheet, expression2.StartRow, expression2.StartColumn, (expression2.EndRow - expression2.StartRow) + 1, (expression2.EndColumn - expression2.StartColumn) + 1));
}
}
else if (value is CalcExternalNameExpression)
{
SheetCellRange[] rangeArray = SheetCellRangeUtility.ExtractAllExternalReference(sheet, value);
if ((rangeArray != null) && (rangeArray.Length > 0))
{
return(rangeArray[0]);
}
}
}
return(null);
}
/// <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);
}
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);
}
public static string BuildFormula(ICalcEvaluator evaluator, List <SheetCellRange> ranges)
{
if ((ranges == null) || (ranges.Count == 0))
{
return(null);
}
StringBuilder builder = new StringBuilder();
foreach (SheetCellRange range in ranges)
{
if (ranges != null)
{
string str = SheetRange2Formula(evaluator, range);
builder.Append(str);
builder.Append(CultureInfo.InvariantCulture.TextInfo.ListSeparator);
}
}
string str2 = builder.ToString();
if (str2 != string.Empty)
{
int startIndex = str2.LastIndexOf(CultureInfo.InvariantCulture.TextInfo.ListSeparator);
if (startIndex != -1)
{
str2 = str2.Remove(startIndex);
}
}
return(str2);
}
public static SheetCellRange[] ExtractAllExternalReference(ICalcEvaluator evaluator, CalcExpression expression)
{
if (expression != null)
{
List <CalcReferenceExpression> nodes = new List <CalcReferenceExpression>();
FormulaUtility.ExtractAllReferenceExpression(evaluator, expression, nodes);
if (nodes.Count > 0)
{
List <SheetCellRange> list2 = new List <SheetCellRange>();
foreach (CalcReferenceExpression expression2 in nodes)
{
if (expression2 is CalcExternalRangeExpression)
{
CalcExternalRangeExpression expression3 = expression2 as CalcExternalRangeExpression;
SheetCellRange range = new SheetCellRange(expression3.Source as Worksheet, expression3.StartRow, expression3.StartColumn, (expression3.EndRow - expression3.StartRow) + 1, (expression3.EndColumn - expression3.StartColumn) + 1);
list2.Add(range);
}
else if (expression2 is CalcExternalCellExpression)
{
CalcExternalCellExpression expression4 = expression2 as CalcExternalCellExpression;
SheetCellRange range2 = new SheetCellRange(expression4.Source as Worksheet, expression4.Row, expression4.Column, 1, 1);
list2.Add(range2);
}
else
{
return(null);
}
}
return(list2.ToArray());
}
}
return(null);
}
public static string BuildFormula(ICalcEvaluator evaluator, List <CalcExpression> expressions)
{
if (expressions.Count == 0)
{
return(string.Empty);
}
StringBuilder builder = new StringBuilder();
foreach (CalcExpression expression in expressions)
{
if (expressions != null)
{
string str = evaluator.Expression2Formula(expression, 0, 0);
builder.Append(str);
builder.Append(CultureInfo.InvariantCulture.TextInfo.ListSeparator);
}
}
string str2 = builder.ToString();
if (str2 != string.Empty)
{
int startIndex = str2.LastIndexOf(CultureInfo.InvariantCulture.TextInfo.ListSeparator);
if (startIndex != -1)
{
str2 = str2.Remove(startIndex);
}
}
return(str2);
}
public static void ExtractAllReferenceExpression(ICalcEvaluator evaluator, CalcExpression expression, out CalcReferenceExpression[] expressions)
{
List <CalcReferenceExpression> nodes = new List <CalcReferenceExpression>();
ExtractAllReferenceExpression(evaluator, expression, nodes);
expressions = nodes.ToArray();
}
internal void Init()
{
this.DetachEvents();
this.groups = null;
this.sheet = null;
this.evaluator = null;
}
public object GetValue(ICalcEvaluator evaluator, int baseRow, int baseColumn, bool isArrayFormula)
{
if (!this.isFormula)
{
return(this.value);
}
this.InitializeFormula(evaluator, baseRow, baseColumn, false);
object obj2 = evaluator.EvaluateExpression(this.expression, this.rowOffset, this.columnOffset, baseRow, baseColumn, isArrayFormula);
if (this.ExpectArrayValue || !(obj2 is Array))
{
return(obj2);
}
Array array = obj2 as Array;
if (array.Rank != 2)
{
return(obj2);
}
int length = array.GetLength(0);
int num2 = array.GetLength(1);
if ((length == 1) && (num2 == 1))
{
return(array.GetValue(new int[2]));
}
if ((this.columnOffset < length) && (this.rowOffset < num2))
{
return(array.GetValue(new int[] { this.columnOffset, this.rowOffset }));
}
return(CalcErrors.NotAvailable);
}
public DefaultDataSeries(CalcExpression dataReference, Dt.Cells.Data.DataOrientation dataOrientation, bool displayHiddenData, Dt.Cells.Data.EmptyValueStyle emptyValueStyle, ICalcEvaluator evalutor)
{
this._dataReference = dataReference;
this._dataOrientation = new Dt.Cells.Data.DataOrientation?(dataOrientation);
this._displayHiddenData = displayHiddenData;
this._emptyValueStyle = emptyValueStyle;
this._evaluator = evalutor;
}
internal double?CalculateValue(ICalcEvaluator evaluator, int baseRow, int baseColumn, object value)
{
if (IsFormula(value))
{
return(this.CalculateFormula(evaluator, baseRow, baseColumn, TrimFormula((string)(value as string))));
}
return(ConditionValueConverter.TryDouble(value));
}
/// <summary>
/// Returns the valid data lists if the data validation type is list; otherwise, returns null.
/// </summary>
/// <param name="evaluator">The evaluator.</param>
/// <param name="baseRow">The base row.</param>
/// <param name="baseColumn">The base column.</param>
/// <returns>The valid list.</returns>
public object[] GetValidList(ICalcEvaluator evaluator, int baseRow, int baseColumn)
{
if (((this.Condition != null) && (this.Type == CriteriaType.List)) && (this.Condition is AreaCondition))
{
return((this.Condition as AreaCondition).GetValidList(evaluator, baseRow, baseColumn));
}
return(null);
}
public static SheetCellRange Formula2SheetRange(ICalcEvaluator evaluator, string formula)
{
CalcExternalRangeExpression expression = FormulaUtility.Formula2Expression(evaluator, formula) as CalcExternalRangeExpression;
if (expression == null)
{
return(null);
}
return(new SheetCellRange(expression.Source as Worksheet, expression.StartRow, expression.StartColumn, (expression.EndRow - expression.StartRow) + 1, (expression.EndColumn - expression.StartColumn) + 1));
}
public static SheetCellRange[] ExtractAllExternalReference(ICalcEvaluator evaluator, string formula)
{
CalcExpression expression = FormulaUtility.Formula2Expression(evaluator, formula);
if (expression == null)
{
return(null);
}
return(ExtractAllExternalReference(evaluator, expression));
}
/// <summary>
/// Gets the expected string.
/// </summary>
/// <param name="evaluator">The evaluator.</param>
/// <param name="baseRow">The base row index.</param>
/// <param name="baseColumn">The base column index.</param>
/// <returns>Returns the expected string.</returns>
protected string GetExpectedString(ICalcEvaluator evaluator, int baseRow, int baseColumn)
{
object obj2 = this.GetExpected(evaluator, baseRow, baseColumn);
if (obj2 != null)
{
return(obj2.ToString());
}
return(null);
}
/// <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);
}
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>
/// 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 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);
}
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>
/// 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);
}
/// <summary>
/// Calculates the actual value for a specified <see cref="T:Dt.Cells.Data.ScaleRule" />.
/// </summary>
/// <returns>Returns the actual value of a specified <see cref="T:Dt.Cells.Data.ScaleRule" /> value.</returns>
internal double?GetActualValue(ICalcEvaluator evaluator, int baseRow, int baseColumn, int index, IActualValue actual)
{
ScaleValue value2 = this.scales[index];
if (value2 != null)
{
switch (value2.Type)
{
case ScaleValueType.Number:
return(this.CalculateValue(evaluator, baseRow, baseColumn, value2.Value));
case ScaleValueType.LowestValue:
return(this.GetLowestValue(actual));
case ScaleValueType.HighestValue:
return(this.GetHighestValue(actual));
case ScaleValueType.Percent:
return(this.CalculatePercent(evaluator, baseRow, baseColumn, value2.Value, actual));
case ScaleValueType.Percentile:
return(this.CalculatePercentile(evaluator, baseRow, baseColumn, value2.Value));
case ScaleValueType.Automin:
{
double?lowestValue = this.GetLowestValue(actual);
if (!lowestValue.HasValue || (lowestValue.Value <= 0.0))
{
return(lowestValue);
}
return(0.0);
}
case ScaleValueType.Formula:
return(this.CalculateValue(evaluator, baseRow, baseColumn, value2.Value));
case ScaleValueType.Automax:
{
double?highestValue = this.GetHighestValue(actual);
if (!highestValue.HasValue || (highestValue.Value >= 0.0))
{
return(highestValue);
}
return(0.0);
}
}
}
return(null);
}
/// <summary>
/// Calculates the percent scale value type.
/// </summary>
/// <param name="evaluator">Sheet for value object calculating</param>
/// <param name="baseRow"></param>
/// <param name="baseColumn"></param>
/// <param name="value">Scale value</param>
/// <param name="actualValue"></param>
/// <returns>Returns the result of the calculation.</returns>
internal double?CalculatePercent(ICalcEvaluator evaluator, int baseRow, int baseColumn, object value, IActualValue actualValue)
{
double?nullable = this.CalculateValue(evaluator, baseRow, baseColumn, value);
if ((nullable.HasValue && (0.0 <= nullable.Value)) && (nullable.Value <= 100.0))
{
double?lowestValue = this.GetLowestValue(actualValue);
double?highestValue = this.GetHighestValue(actualValue);
if (lowestValue.HasValue && highestValue.HasValue)
{
return(new double?(lowestValue.Value + (((highestValue.Value - lowestValue.Value) * nullable.Value) / 100.0)));
}
}
return(null);
}
