using System.Drawing;
using System.Globalization;
using System.Windows.Forms;
namespace FastReport.Import.RDL
{
///
/// The RDL units converter.
///
public static partial class UnitsConverter
{
#region Public Methods
///
/// Converts the RDL Boolean to bool value.
///
/// The RDL Boolean value.
/// The bool value.
public static bool BooleanToBool(string boolean)
{
if (boolean.ToLower() == "true")
{
return true;
}
return false;
}
///
/// Converts the RDL Color to Color.
///
/// The RDL Color value.
/// The Color value.
public static Color ConvertColor(string colorName)
{
return Color.FromName(colorName);
}
///
/// Converts the RDL Size to float value.
///
/// The RDL Size value.
/// The RDL Size units measure.
/// The float value of RDL Size.
public static float SizeToFloat(string size, string unit)
{
return float.Parse(size.Replace(unit, ""), new CultureInfo("en-US", false).NumberFormat);
}
///
/// Converts the RDL Size to int value.
///
/// The RDL Size value.
/// The RDL Size units measure.
/// The int value of RDL Size.
public static int SizeToInt(string size, string unit)
{
int resSize = 0;
int.TryParse(size.Replace(unit, ""), NumberStyles.None, new CultureInfo("en-US", false).NumberFormat, out resSize);
return resSize;
}
///
/// Converts the RDL Size to millimeters.
///
/// The RDL Size value.
/// The float value of RDL Size in millimeters.
public static float SizeToMillimeters(string size)
{
if (size.Contains(SizeUnits.Millimeter))
{
return SizeToFloat(size, SizeUnits.Millimeter);
}
else if (size.Contains(SizeUnits.Centimeter))
{
return SizeToFloat(size, SizeUnits.Centimeter) * SizeUnitsM.Centimeter;
}
else if (size.Contains(SizeUnits.Inch))
{
return SizeToFloat(size, SizeUnits.Inch) * SizeUnitsM.Inch;
}
else if (size.Contains(SizeUnits.Point))
{
return SizeToFloat(size, SizeUnits.Point) * SizeUnitsM.Point;
}
else if (size.Contains(SizeUnits.Pica))
{
return SizeToFloat(size, SizeUnits.Pica) * SizeUnitsM.Pica;
}
return 0.0f;
}
///
/// Converts the RDL Size to pixels.
///
/// The RDL Size value.
/// The float value of RDL Size in pixels.
public static float SizeToPixels(string size)
{
if (size.Contains(SizeUnits.Millimeter))
{
return SizeToFloat(size, SizeUnits.Millimeter) * SizeUnitsP.Millimeter;
}
else if (size.Contains(SizeUnits.Centimeter))
{
return SizeToFloat(size, SizeUnits.Centimeter) * SizeUnitsP.Centimeter;
}
else if (size.Contains(SizeUnits.Inch))
{
return SizeToFloat(size, SizeUnits.Inch) * SizeUnitsP.Inch;
}
else if (size.Contains(SizeUnits.Point))
{
return SizeToFloat(size, SizeUnits.Point) * SizeUnitsP.Point;
}
else if (size.Contains(SizeUnits.Pica))
{
return SizeToFloat(size, SizeUnits.Pica) * SizeUnitsP.Pica;
}
return 0.0f;
}
///
/// Converts the RDL FontStyle to FontStyle.
///
/// The RDL FontStyle value.
/// The FontStyle value.
public static FontStyle ConvertFontStyle(string fontStyle)
{
if (fontStyle == "Italic")
{
return FontStyle.Italic;
}
return FontStyle.Regular;
}
///
/// Converts the RDL FontSize to float.
///
/// The RDL FontSize value.
/// The float value of RDL FontSize in points.
public static float ConvertFontSize(string fontSize)
{
return float.Parse(fontSize.Replace(SizeUnits.Point, ""), new CultureInfo("en-US", false).NumberFormat);
}
///
/// Converts the RDL TextAlign to HorzAlign.
///
/// The RDL TextAlign value.
/// The HorzAlign value.
public static HorzAlign ConvertTextAlign(string textAlign)
{
if (textAlign == "Center")
{
return HorzAlign.Center;
}
else if (textAlign == "Right")
{
return HorzAlign.Right;
}
return HorzAlign.Left;
}
///
/// Converts the RDL TextAlign to VerticalAlign.
///
/// The RDL VerticalAlign value.
/// The VertAlign value.
public static VertAlign ConvertVerticalAlign(string verticalAlign)
{
if (verticalAlign == "Middle")
{
return VertAlign.Center;
}
else if (verticalAlign == "Bottom")
{
return VertAlign.Bottom;
}
return VertAlign.Top;
}
///
/// Converts the RDL WritingMode to Angle.
///
/// The RDL WritingMode value.
/// The int value of RDL WritingMode in degree.
public static int ConvertWritingMode(string writingMode)
{
if (writingMode == "tb-rl")
{
return 90;
}
return 0;
}
///
/// Converts the RDL TextAlign to StringAlignment.
///
/// The RDL TextAling value.
/// The StringAlignment value.
public static StringAlignment ConvertTextAlignToStringAlignment(string textAlign)
{
if (textAlign == "Left")
{
return StringAlignment.Near;
}
else if (textAlign == "Right")
{
return StringAlignment.Far;
}
return StringAlignment.Center;
}
///
/// Converts the RDL TextAlign and VerticalAlign to ContentAlignment.
///
/// The RDL TextAlign value.
/// The RDL VerticalAlign value.
/// The ContentAlignment value.
public static ContentAlignment ConvertTextAndVerticalAlign(string textAlign, string vertAlign)
{
if (textAlign == "General" || textAlign == "Center")
{
if (vertAlign == "Top")
{
return ContentAlignment.TopCenter;
}
else if (vertAlign == "Middle")
{
return ContentAlignment.MiddleCenter;
}
else if (vertAlign == "Bottom")
{
return ContentAlignment.BottomCenter;
}
return ContentAlignment.TopCenter;
}
else if (textAlign == "Left")
{
if (vertAlign == "Top")
{
return ContentAlignment.TopLeft;
}
else if (vertAlign == "Middle")
{
return ContentAlignment.MiddleLeft;
}
else if (vertAlign == "Bottom")
{
return ContentAlignment.BottomLeft;
}
return ContentAlignment.TopLeft;
}
else if (textAlign == "Right")
{
if (vertAlign == "Top")
{
return ContentAlignment.TopRight;
}
else if (vertAlign == "Middle")
{
return ContentAlignment.MiddleRight;
}
else if (vertAlign == "Bottom")
{
return ContentAlignment.BottomRight;
}
return ContentAlignment.TopRight;
}
return ContentAlignment.TopLeft;
}
///
/// Converts the RDL BorderStyle to LineStyle.
///
/// The RDL BorderStyle value.
/// The LineStyle value.
public static LineStyle ConvertBorderStyle(string borderStyle)
{
if (borderStyle == "Dotted")
{
return LineStyle.Dot;
}
else if (borderStyle == "Dashed")
{
return LineStyle.Dash;
}
else if (borderStyle == "Double")
{
return LineStyle.Double;
}
return LineStyle.Solid;
}
///
/// Converts the RDL Sizing to PictureBoxSizeMode.
///
/// The RDL Sizing value.
/// The PictureBoxSizeMode value.
public static PictureBoxSizeMode ConvertSizing(string sizing)
{
if (sizing == "AutoSize")
{
return PictureBoxSizeMode.AutoSize;
}
else if (sizing == "Fit")
{
return PictureBoxSizeMode.StretchImage;
}
else if (sizing == "Clip")
{
return PictureBoxSizeMode.Normal;
}
return PictureBoxSizeMode.Zoom;
}
///
/// Converts the RDL GradientType to GradientStyle.
///
/// The RDL GradientType value.
/// The GradientStyle value.
/*public static GradientStyle ConvertGradientType(string gradientType)
{
if (gradientType == "LeftRight")
{
return GradientStyle.LeftRight;
}
else if (gradientType == "TopBottom")
{
return GradientStyle.TopBottom;
}
else if (gradientType == "Center")
{
return GradientStyle.Center;
}
else if (gradientType == "DiagonalLeft")
{
return GradientStyle.DiagonalLeft;
}
else if (gradientType == "DiagonalRight")
{
return GradientStyle.DiagonalRight;
}
else if (gradientType == "HorizontalCenter")
{
return GradientStyle.HorizontalCenter;
}
else if (gradientType == "VerticalCenter")
{
return GradientStyle.VerticalCenter;
}
return GradientStyle.None;
}*/
///
/// Converts the RDL Chart.Type to SeriesChartType.
///
/// The RDL Chart.Type value.
/// The SeriesChartType value.
/*public static SeriesChartType ConvertChartType(string chartType)
{
if (chartType == "Area")
{
return SeriesChartType.Area;
}
else if (chartType == "Bar")
{
return SeriesChartType.Bar;
}
else if (chartType == "Doughnut")
{
return SeriesChartType.Doughnut;
}
else if (chartType == "Line")
{
return SeriesChartType.Line;
}
else if (chartType == "Pie")
{
return SeriesChartType.Pie;
}
else if (chartType == "Bubble")
{
return SeriesChartType.Bubble;
}
return SeriesChartType.Column;
}*/
///
/// Converts the RDL Chart.Palette to ChartColorPalette.
///
/// The RDL Chart.Palette value.
/// The RDL ChartColorPalette value.
/*public static ChartColorPalette ConvertChartPalette(string chartPalette)
{
if (chartPalette == "EarthTones")
{
return ChartColorPalette.EarthTones;
}
else if (chartPalette == "Excel")
{
return ChartColorPalette.Excel;
}
else if (chartPalette == "GrayScale")
{
return ChartColorPalette.Grayscale;
}
else if (chartPalette == "Light")
{
return ChartColorPalette.Light;
}
else if (chartPalette == "Pastel")
{
return ChartColorPalette.Pastel;
}
else if (chartPalette == "SemiTransparent")
{
return ChartColorPalette.SemiTransparent;
}
return ChartColorPalette.None;
}*/
///
/// Converts the RDL Chart.Legend.Position to Legend.Docking and Legend.Alignment.
///
/// The RDL Chart.Legend.Position value.
/// The Legend instance to convert to.
/*public static void ConvertChartLegendPosition(string chartLegendPosition, Legend legend)
{
if (chartLegendPosition == "TopLeft")
{
legend.Docking = Docking.Top;
legend.Alignment = StringAlignment.Near;
}
else if (chartLegendPosition == "TopCenter")
{
legend.Docking = Docking.Top;
legend.Alignment = StringAlignment.Center;
}
else if (chartLegendPosition == "TopRight")
{
legend.Docking = Docking.Top;
legend.Alignment = StringAlignment.Far;
}
else if (chartLegendPosition == "LeftTop")
{
legend.Docking = Docking.Left;
legend.Alignment = StringAlignment.Near;
}
else if (chartLegendPosition == "LeftCenter")
{
legend.Docking = Docking.Left;
legend.Alignment = StringAlignment.Center;
}
else if (chartLegendPosition == "LeftBottom")
{
legend.Docking = Docking.Left;
legend.Alignment = StringAlignment.Far;
}
else if (chartLegendPosition == "RightTop")
{
legend.Docking = Docking.Right;
legend.Alignment = StringAlignment.Near;
}
else if (chartLegendPosition == "RightCenter")
{
legend.Docking = Docking.Right;
legend.Alignment = StringAlignment.Center;
}
else if (chartLegendPosition == "RightBottom")
{
legend.Docking = Docking.Right;
legend.Alignment = StringAlignment.Far;
}
else if (chartLegendPosition == "BottomLeft")
{
legend.Docking = Docking.Bottom;
legend.Alignment = StringAlignment.Near;
}
else if (chartLegendPosition == "BottomCenter")
{
legend.Docking = Docking.Bottom;
legend.Alignment = StringAlignment.Center;
}
else if (chartLegendPosition == "BottomRight")
{
legend.Docking = Docking.Bottom;
legend.Alignment = StringAlignment.Far;
}
}*/
///
/// Converts the RDL Chart.Legend.Layout to LegendStyle.
///
/// The RDL Chart.Legend.Layout value.
/// The LegendStyle value.
/*public static LegendStyle ConvertChartLegendLayout(string chartLegendLayout)
{
if (chartLegendLayout == "Table")
{
return LegendStyle.Table;
}
else if (chartLegendLayout == "Row")
{
return LegendStyle.Row;
}
return LegendStyle.Column;
}*/
///
/// Converts the RDL BorderStyle to ChartDashStyle.
///
/// The RDL BorderStyle value.
/// The ChartDashStyle value.
/*public static ChartDashStyle ConvertBorderStyleToChartDashStyle(string borderStyle)
{
if (borderStyle == "Dotted")
{
return ChartDashStyle.Dot;
}
else if (borderStyle == "Dashed")
{
return ChartDashStyle.Dash;
}
return ChartDashStyle.Solid;
}*/
///
/// Converts the RDL Axis.Visible to AxisEnabled.
///
/// The RDL Axis.Visible value.
/// The AxisEnabled value.
/*public static AxisEnabled ConvertAxisVisibleToAxisEnabled(string axisVisible)
{
if (axisVisible.ToLower() == "true")
{
return AxisEnabled.True;
}
else if (axisVisible.ToLower() == "false")
{
return AxisEnabled.False;
}
return AxisEnabled.Auto;
}*/
///
/// Converts the RDL TickMarkStyle to TickMarkStyle.
///
/// The RDL TickMarkStyle value.
/// The TickMarkStyle value.
/*public static TickMarkStyle ConvertTickMarkStyle(string tickMarkStyle)
{
if (tickMarkStyle == "Inside")
{
return TickMarkStyle.InsideArea;
}
else if (tickMarkStyle == "Outside")
{
return TickMarkStyle.OutsideArea;
}
else if (tickMarkStyle == "Cross")
{
return TickMarkStyle.AcrossAxis;
}
return TickMarkStyle.None;
}*/
///
/// Converts the RDL Shading to LightStyle.
///
/// The RDL Shading value.
/// The LightStyle value.
/*public static LightStyle ConvertShading(string shading)
{
if (shading == "Simple")
{
return LightStyle.Simplistic;
}
else if (shading == "Real")
{
return LightStyle.Realistic;
}
return LightStyle.None;
}*/
#endregion // Public Methods
}
}