private static string ValidateSize(string size, double minValue, double maxValue, IErrorContext errorContext)
{
RVUnit rVUnit = default(RVUnit);
if (!Validator.ValidateSizeString(size, out rVUnit))
{
errorContext.Register(ProcessingErrorCode.rsInvalidSize, Severity.Warning, size);
return(null);
}
if (!Validator.ValidateSizeUnitType(rVUnit))
{
errorContext.Register(ProcessingErrorCode.rsInvalidMeasurementUnit, Severity.Warning, rVUnit.Type.ToString());
return(null);
}
if (!Validator.ValidateSizeIsPositive(rVUnit))
{
errorContext.Register(ProcessingErrorCode.rsNegativeSize, Severity.Warning);
return(null);
}
double sizeInMM = Converter.ConvertToMM(rVUnit);
if (!Validator.ValidateSizeValue(sizeInMM, minValue, maxValue))
{
errorContext.Register(ProcessingErrorCode.rsOutOfRangeSize, Severity.Warning, size, Converter.ConvertSize(minValue), Converter.ConvertSize(maxValue));
return(null);
}
return(size);
}
private static bool ValidateSize(string size, bool allowNegative, double minValue, double maxValue, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext, out double validSizeInMM, out string newSize)
{
validSizeInMM = minValue;
newSize = minValue + "mm";
RVUnit sizeValue = default(RVUnit);
if (!Validator.ValidateSizeString(size, out sizeValue))
{
errorContext.Register(ProcessingErrorCode.rsInvalidSize, Severity.Error, objectType, objectName, propertyName, size);
return(false);
}
if (!Validator.ValidateSizeUnitType(sizeValue))
{
errorContext.Register(ProcessingErrorCode.rsInvalidMeasurementUnit, Severity.Error, objectType, objectName, propertyName, sizeValue.Type.ToString());
return(false);
}
if (!allowNegative && !Validator.ValidateSizeIsPositive(sizeValue))
{
errorContext.Register(ProcessingErrorCode.rsNegativeSize, Severity.Error, objectType, objectName, propertyName);
return(false);
}
RVUnit unit = new RVUnit(Math.Round(sizeValue.Value, Validator.DecimalPrecision), sizeValue.Type);
double num = Converter.ConvertToMM(unit);
if (!Validator.ValidateSizeValue(num, minValue, maxValue))
{
errorContext.Register(ProcessingErrorCode.rsOutOfRangeSize, Severity.Error, objectType, objectName, propertyName, size, Converter.ConvertSize(minValue), Converter.ConvertSize(maxValue));
return(false);
}
validSizeInMM = Math.Round(num, Validator.DecimalPrecision);
newSize = unit.ToString(CultureInfo.InvariantCulture);
return(true);
}
public static bool ValidateSize(string size, bool allowNegative, double minValue, double maxValue, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext, out double validSizeInMM, out string newSize)
{
validSizeInMM = minValue;
newSize = minValue + "mm";
RVUnit rVUnit = default(RVUnit);
if (!Validator.ValidateSizeString(size, out rVUnit))
{
errorContext.Register(ProcessingErrorCode.rsInvalidSize, Severity.Error, objectType, objectName, propertyName, size);
return(false);
}
if (!Validator.ValidateSizeUnitType(rVUnit))
{
errorContext.Register(ProcessingErrorCode.rsInvalidMeasurementUnit, Severity.Error, objectType, objectName, propertyName, rVUnit.Type.ToString());
return(false);
}
if (!allowNegative && !Validator.ValidateSizeIsPositive(rVUnit))
{
errorContext.Register(ProcessingErrorCode.rsNegativeSize, Severity.Error, objectType, objectName, propertyName);
return(false);
}
double num = Converter.ConvertToMM(rVUnit);
if (!Validator.ValidateSizeValue(num, minValue, maxValue))
{
errorContext.Register(ProcessingErrorCode.rsOutOfRangeSize, Severity.Error, objectType, objectName, propertyName, size, Converter.ConvertSizeFromMM(allowNegative ? minValue : Math.Max(0.0, minValue), rVUnit.Type), Converter.ConvertSizeFromMM(maxValue, rVUnit.Type));
return(false);
}
validSizeInMM = num;
newSize = rVUnit.ToString(CultureInfo.InvariantCulture);
return(true);
}
internal static double ConvertToMM(RVUnit unit)
{
double num = unit.Value;
switch (unit.Type)
{
case RVUnitType.Cm:
num *= 10.0;
break;
case RVUnitType.Inch:
num *= 25.4;
break;
case RVUnitType.Pica:
num *= 4.2333;
break;
case RVUnitType.Point:
num *= 0.3528;
break;
default:
Global.Tracer.Assert(condition: false);
break;
case RVUnitType.Mm:
break;
}
return(num);
}
public static double ConvertToMM(RVUnit unit)
{
if (!Validator.ValidateSizeUnitType(unit))
{
Global.Tracer.Assert(false);
}
return(unit.ToMillimeters());
}
public static bool ValidateSizeIsPositive(RVUnit sizeValue)
{
if (sizeValue.Value >= 0.0)
{
return(true);
}
return(false);
}
public static bool ValidateSizeUnitType(RVUnit sizeValue)
{
switch (sizeValue.Type)
{
case RVUnitType.Cm:
case RVUnitType.Inch:
case RVUnitType.Mm:
case RVUnitType.Pica:
case RVUnitType.Point:
return(true);
default:
return(false);
}
}
public static bool ValidateSizeString(string sizeString, out RVUnit sizeValue)
{
try
{
sizeValue = RVUnit.Parse(sizeString, CultureInfo.InvariantCulture);
if (sizeValue.Type == RVUnitType.Pixel)
{
return(false);
}
return(true);
}
catch
{
sizeValue = RVUnit.Empty;
return(false);
}
}
public void Validate()
{
RVUnit rVUnit = default(RVUnit);
if (!Validator.ValidateSizeString(this.m_size, out rVUnit))
{
throw new ReportRenderingException(ErrorCode.rrInvalidSize, this.m_size);
}
if (!Validator.ValidateSizeUnitType(rVUnit))
{
throw new ReportRenderingException(ErrorCode.rrInvalidMeasurementUnit, this.m_size);
}
if (!Validator.ValidateSizeIsPositive(rVUnit))
{
throw new ReportRenderingException(ErrorCode.rrNegativeSize, this.m_size);
}
double sizeInMM = Converter.ConvertToMM(rVUnit);
if (!Validator.ValidateSizeValue(sizeInMM, Validator.NormalMin, Validator.NormalMax))
{
throw new ReportRenderingException(ErrorCode.rrOutOfRange, this.m_size);
}
this.m_sizeInMM = sizeInMM;
}
public void Validate()
{
RVUnit rVUnit = default(RVUnit);
if (!AspNetCore.ReportingServices.ReportPublishing.Validator.ValidateSizeString(this.m_size, out rVUnit))
{
throw new RenderingObjectModelException(ErrorCode.rrInvalidSize, this.m_size);
}
if (!AspNetCore.ReportingServices.ReportPublishing.Validator.ValidateSizeUnitType(rVUnit))
{
throw new RenderingObjectModelException(ErrorCode.rrInvalidMeasurementUnit, this.m_size);
}
if (!this.m_allowNegative && !AspNetCore.ReportingServices.ReportPublishing.Validator.ValidateSizeIsPositive(rVUnit))
{
throw new RenderingObjectModelException(ErrorCode.rrNegativeSize, this.m_size);
}
double sizeInMM = AspNetCore.ReportingServices.ReportPublishing.Converter.ConvertToMM(rVUnit);
if (!AspNetCore.ReportingServices.ReportPublishing.Validator.ValidateSizeValue(sizeInMM, this.m_allowNegative ? AspNetCore.ReportingServices.ReportPublishing.Validator.NegativeMin : AspNetCore.ReportingServices.ReportPublishing.Validator.NormalMin, AspNetCore.ReportingServices.ReportPublishing.Validator.NormalMax))
{
throw new RenderingObjectModelException(ErrorCode.rrOutOfRange, this.m_size);
}
this.m_sizeInMM = sizeInMM;
}
public static byte[] ScaleImage(byte[] sourceImageBytes, RVUnit frameWidth, RVUnit frameHeight)
{
ImageFormat imageFormat = default(ImageFormat);
return(ImageUtility.ScaleImage(sourceImageBytes, (int)ImageUtility.ConvertToPixels(frameWidth), (int)ImageUtility.ConvertToPixels(frameHeight), out imageFormat));
}
public static void ParseSize(string size, out double sizeInMM)
{
RVUnit unit = RVUnit.Parse(size, CultureInfo.InvariantCulture);
sizeInMM = Converter.ConvertToMM(unit);
}
public void ParseSize()
{
this.m_sizeInMM = RVUnit.Parse(this.m_size, CultureInfo.InvariantCulture).ToMillimeters();
}
internal void ParseSize()
{
m_sizeInMM = RVUnit.Parse(m_size, CultureInfo.InvariantCulture).ToMillimeters();
}
private static double ConvertToPixels(RVUnit unit)
{
return(unit.ToMillimeters() * 96.0 / 25.4);
}
internal static byte[] ScaleImage(byte[] sourceImageBytes, RVUnit frameWidth, RVUnit frameHeight)
{
ImageFormat imageFormat;
return(ScaleImage(sourceImageBytes, (int)ConvertToPixels(frameWidth), (int)ConvertToPixels(frameHeight), out imageFormat));
}
private static double ConvertToPixels(RVUnit unit)
{
double num = unit.ToMillimeters();
return(num * 96.0 / 25.4);
}
