1415 lines
41 KiB
C#
1415 lines
41 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Text;
|
|
using CPF.Drawing;
|
|
using CPF.ReoGrid.Core;
|
|
using CPF.ReoGrid.DataFormat;
|
|
using CPF.ReoGrid.Drawing;
|
|
using CPF.ReoGrid.Drawing.Text;
|
|
using CPF.ReoGrid.IO.OpenXML.Schema;
|
|
using CPF.ReoGrid.Rendering;
|
|
using CPF.ReoGrid.Utility;
|
|
|
|
namespace CPF.ReoGrid.IO.OpenXML
|
|
{
|
|
internal sealed class ExcelWriter
|
|
{
|
|
public static void WriteStream(IWorkbook rgWorkbook, Stream stream)
|
|
{
|
|
Document document = Document.CreateOnStream(stream);
|
|
ExcelWriter.WriteDefaultStyles(document, rgWorkbook);
|
|
Schema.Workbook workbook = document.Workbook;
|
|
foreach (Worksheet worksheet in rgWorkbook.Worksheets)
|
|
{
|
|
ExcelWriter.WriteWorksheet(document, worksheet);
|
|
bool flag = worksheet.NamedRanges.Count > 0;
|
|
if (flag)
|
|
{
|
|
bool flag2 = workbook.definedNames == null;
|
|
if (flag2)
|
|
{
|
|
workbook.definedNames = new List<DefinedName>();
|
|
}
|
|
foreach (NamedRange namedRange in worksheet.NamedRanges)
|
|
{
|
|
workbook.definedNames.Add(new DefinedName
|
|
{
|
|
name = namedRange.Name,
|
|
address = worksheet.Name + "!" + namedRange.Position.ToAbsoluteAddress()
|
|
});
|
|
}
|
|
}
|
|
}
|
|
document.Flush();
|
|
}
|
|
|
|
private static int WriteFill(Document doc, Color c)
|
|
{
|
|
Stylesheet stylesheet = doc.Stylesheet;
|
|
int num = stylesheet.fills.FindIndex(delegate(Fill f)
|
|
{
|
|
bool result2;
|
|
if (f.patternFill.patternType == "solid")
|
|
{
|
|
Color? rgColor = f.patternFill.foregroundColor._rgColor;
|
|
Color c2 = c;
|
|
result2 = (rgColor != null && (rgColor == null || rgColor.GetValueOrDefault() == c2));
|
|
}
|
|
else
|
|
{
|
|
result2 = false;
|
|
}
|
|
return result2;
|
|
});
|
|
bool flag = num >= 0;
|
|
int result;
|
|
if (flag)
|
|
{
|
|
result = num;
|
|
}
|
|
else
|
|
{
|
|
stylesheet.fills.Add(new Fill
|
|
{
|
|
patternFill = new PatternFill
|
|
{
|
|
patternType = "solid",
|
|
foregroundColor = new ColorValue(c)
|
|
{
|
|
_rgColor = new Color?(c)
|
|
},
|
|
backgroundColor = new ColorValue
|
|
{
|
|
indexed = "64"
|
|
}
|
|
}
|
|
});
|
|
result = stylesheet.fills.Count - 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static int WriteFont(Document doc, WorksheetRangeStyle rgStyle)
|
|
{
|
|
Stylesheet stylesheet = doc.Stylesheet;
|
|
PlainStyleFlag flag = rgStyle.Flag;
|
|
string fontName = rgStyle.FontName;
|
|
float fontSize = rgStyle.FontSize;
|
|
int num = stylesheet.fonts.FindIndex((CPF.ReoGrid.IO.OpenXML.Schema.Font f) => (flag & PlainStyleFlag.FontName) == PlainStyleFlag.FontName && f.name != null && string.Equals(f.name.value, fontName, StringComparison.CurrentCultureIgnoreCase) && (flag & PlainStyleFlag.FontSize) == PlainStyleFlag.FontSize && f.size != null && f._size == fontSize && (((flag & PlainStyleFlag.FontStyleBold) == PlainStyleFlag.FontStyleBold && f.bold != null && f.bold != null) || ((flag & PlainStyleFlag.FontStyleBold) != PlainStyleFlag.FontStyleBold && f.bold == null)) && (((flag & PlainStyleFlag.FontStyleItalic) == PlainStyleFlag.FontStyleItalic && f.italic != null && f.italic != null) || ((flag & PlainStyleFlag.FontStyleItalic) != PlainStyleFlag.FontStyleItalic && f.italic == null)) && (((flag & PlainStyleFlag.FontStyleStrikethrough) == PlainStyleFlag.FontStyleStrikethrough && f.strikethrough != null && f.strikethrough != null) || ((flag & PlainStyleFlag.FontStyleStrikethrough) != PlainStyleFlag.FontStyleStrikethrough && f.strikethrough == null)) && (((flag & PlainStyleFlag.FontStyleUnderline) == PlainStyleFlag.FontStyleUnderline && f.underline != null && f.underline != null) || ((flag & PlainStyleFlag.FontStyleUnderline) != PlainStyleFlag.FontStyleUnderline && f.underline == null)) && (((flag & PlainStyleFlag.TextColor) == PlainStyleFlag.TextColor && f.color != null && f.color._rgColor != null && f.color._rgColor.Value == rgStyle.TextColor) || ((flag & PlainStyleFlag.TextColor) != PlainStyleFlag.TextColor && f.color == null)));
|
|
bool flag2 = num >= 0;
|
|
int result;
|
|
if (flag2)
|
|
{
|
|
result = num;
|
|
}
|
|
else
|
|
{
|
|
stylesheet.fonts.Add(new CPF.ReoGrid.IO.OpenXML.Schema.Font(rgStyle));
|
|
result = stylesheet.fonts.Count - 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static string ConvertToExcelBorderStyle(BorderLineStyle bls)
|
|
{
|
|
string result;
|
|
switch (bls)
|
|
{
|
|
default:
|
|
result = "thin";
|
|
break;
|
|
case BorderLineStyle.Dotted:
|
|
result = "hair";
|
|
break;
|
|
case BorderLineStyle.Dashed:
|
|
result = "dashed";
|
|
break;
|
|
case BorderLineStyle.DoubleLine:
|
|
result = "double";
|
|
break;
|
|
case BorderLineStyle.Dashed2:
|
|
result = "dotted";
|
|
break;
|
|
case BorderLineStyle.DashDot:
|
|
result = "dashDotDot";
|
|
break;
|
|
case BorderLineStyle.DashDotDot:
|
|
result = "slantDashDot";
|
|
break;
|
|
case BorderLineStyle.BoldDashDot:
|
|
result = "mediumDashed";
|
|
break;
|
|
case BorderLineStyle.BoldDashDotDot:
|
|
result = "mediumDashDotDot";
|
|
break;
|
|
case BorderLineStyle.BoldDashed:
|
|
result = "mediumDashDot";
|
|
break;
|
|
case BorderLineStyle.BoldDotted:
|
|
result = "mediumDashDotDot";
|
|
break;
|
|
case BorderLineStyle.BoldSolid:
|
|
result = "medium";
|
|
break;
|
|
case BorderLineStyle.BoldSolidStrong:
|
|
result = "thick";
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static int WriteBorder(Document doc, RangeBorderStyle? top, RangeBorderStyle? bottom, RangeBorderStyle? left, RangeBorderStyle? right)
|
|
{
|
|
Stylesheet stylesheet = doc.Stylesheet;
|
|
int num = stylesheet.borders.FindIndex((Border _b) => ((_b.top != null && top != null && _b._top == top.Value) || (_b.top == null && top == null)) && ((_b.bottom != null && bottom != null && _b._bottom == bottom.Value) || (_b.bottom == null && bottom == null)) && ((_b.left != null && left != null && _b._left == left.Value) || (_b.left == null && left == null)) && ((_b.right != null && right != null && _b._right == right.Value) || (_b.right == null && right == null)));
|
|
bool flag = num >= 0;
|
|
int result;
|
|
if (flag)
|
|
{
|
|
result = num;
|
|
}
|
|
else
|
|
{
|
|
Border border = new Border();
|
|
bool flag2 = top != null;
|
|
if (flag2)
|
|
{
|
|
border.top = new SideBorder
|
|
{
|
|
color = new ColorValue(top.Value.Color),
|
|
style = ExcelWriter.ConvertToExcelBorderStyle(top.Value.Style)
|
|
};
|
|
border._top = top.Value;
|
|
}
|
|
bool flag3 = bottom != null;
|
|
if (flag3)
|
|
{
|
|
border.bottom = new SideBorder
|
|
{
|
|
color = new ColorValue(bottom.Value.Color),
|
|
style = ExcelWriter.ConvertToExcelBorderStyle(bottom.Value.Style)
|
|
};
|
|
border._bottom = bottom.Value;
|
|
}
|
|
bool flag4 = left != null;
|
|
if (flag4)
|
|
{
|
|
border.left = new SideBorder
|
|
{
|
|
color = new ColorValue(left.Value.Color),
|
|
style = ExcelWriter.ConvertToExcelBorderStyle(left.Value.Style)
|
|
};
|
|
border._left = left.Value;
|
|
}
|
|
bool flag5 = right != null;
|
|
if (flag5)
|
|
{
|
|
border.right = new SideBorder
|
|
{
|
|
color = new ColorValue(right.Value.Color),
|
|
style = ExcelWriter.ConvertToExcelBorderStyle(right.Value.Style)
|
|
};
|
|
border._right = right.Value;
|
|
}
|
|
stylesheet.borders.Add(border);
|
|
result = stylesheet.borders.Count - 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static string ConvertToExcelNumberPattern(NumberDataFormatter.INumberFormatArgs arg, string prefix = null, string postfix = null)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
bool useSeparator = arg.UseSeparator;
|
|
if (useSeparator)
|
|
{
|
|
stringBuilder.Append("#,##");
|
|
}
|
|
stringBuilder.Append('0');
|
|
bool flag = arg.DecimalPlaces > 0;
|
|
if (flag)
|
|
{
|
|
stringBuilder.Append('.');
|
|
for (int i = 0; i < (int)arg.DecimalPlaces; i++)
|
|
{
|
|
stringBuilder.Append('0');
|
|
}
|
|
}
|
|
string value = stringBuilder.ToString();
|
|
bool flag2 = !string.IsNullOrEmpty(prefix);
|
|
if (flag2)
|
|
{
|
|
prefix = "\"" + prefix + "\"";
|
|
}
|
|
bool flag3 = !string.IsNullOrEmpty(postfix);
|
|
if (flag3)
|
|
{
|
|
postfix = "\"" + postfix + "\"";
|
|
}
|
|
StringBuilder stringBuilder2 = new StringBuilder();
|
|
bool flag4 = !string.IsNullOrEmpty(prefix);
|
|
if (flag4)
|
|
{
|
|
stringBuilder2.Append(prefix);
|
|
}
|
|
stringBuilder2.Append(value);
|
|
bool flag5 = !string.IsNullOrEmpty(postfix);
|
|
if (flag5)
|
|
{
|
|
stringBuilder2.Append(postfix);
|
|
}
|
|
stringBuilder2.Append(';');
|
|
switch (arg.NegativeStyle)
|
|
{
|
|
default:
|
|
{
|
|
bool flag6 = !string.IsNullOrEmpty(prefix);
|
|
if (flag6)
|
|
{
|
|
stringBuilder2.Append(prefix);
|
|
}
|
|
stringBuilder2.Append('-');
|
|
stringBuilder2.Append(value);
|
|
bool flag7 = !string.IsNullOrEmpty(postfix);
|
|
if (flag7)
|
|
{
|
|
stringBuilder2.Append(postfix);
|
|
}
|
|
break;
|
|
}
|
|
case NumberDataFormatter.NumberNegativeStyle.Red:
|
|
case NumberDataFormatter.NumberNegativeStyle.RedMinus:
|
|
{
|
|
bool flag8 = !string.IsNullOrEmpty(prefix);
|
|
if (flag8)
|
|
{
|
|
stringBuilder2.Append(prefix);
|
|
}
|
|
stringBuilder2.Append("[Red]");
|
|
bool flag9 = (arg.NegativeStyle & NumberDataFormatter.NumberNegativeStyle.Default) == NumberDataFormatter.NumberNegativeStyle.Default;
|
|
if (flag9)
|
|
{
|
|
stringBuilder2.Append("-");
|
|
}
|
|
stringBuilder2.Append(value);
|
|
bool flag10 = !string.IsNullOrEmpty(postfix);
|
|
if (flag10)
|
|
{
|
|
stringBuilder2.Append(postfix);
|
|
}
|
|
break;
|
|
}
|
|
case NumberDataFormatter.NumberNegativeStyle.Brackets:
|
|
case NumberDataFormatter.NumberNegativeStyle.BracketsMinus:
|
|
{
|
|
bool flag11 = !string.IsNullOrEmpty(prefix);
|
|
if (flag11)
|
|
{
|
|
stringBuilder2.Append(prefix);
|
|
}
|
|
stringBuilder2.Append('(');
|
|
bool flag12 = (arg.NegativeStyle & NumberDataFormatter.NumberNegativeStyle.Default) == NumberDataFormatter.NumberNegativeStyle.Default;
|
|
if (flag12)
|
|
{
|
|
stringBuilder2.Append("-");
|
|
}
|
|
stringBuilder2.Append(value);
|
|
stringBuilder2.Append(')');
|
|
bool flag13 = !string.IsNullOrEmpty(postfix);
|
|
if (flag13)
|
|
{
|
|
stringBuilder2.Append(postfix);
|
|
}
|
|
break;
|
|
}
|
|
case NumberDataFormatter.NumberNegativeStyle.RedBrackets:
|
|
case NumberDataFormatter.NumberNegativeStyle.RedBracketsMinus:
|
|
{
|
|
bool flag14 = !string.IsNullOrEmpty(prefix);
|
|
if (flag14)
|
|
{
|
|
stringBuilder2.Append(prefix);
|
|
}
|
|
stringBuilder2.Append("[Red](");
|
|
bool flag15 = (arg.NegativeStyle & NumberDataFormatter.NumberNegativeStyle.Default) == NumberDataFormatter.NumberNegativeStyle.Default;
|
|
if (flag15)
|
|
{
|
|
stringBuilder2.Append("-");
|
|
}
|
|
stringBuilder2.Append(value);
|
|
stringBuilder2.Append(')');
|
|
bool flag16 = !string.IsNullOrEmpty(postfix);
|
|
if (flag16)
|
|
{
|
|
stringBuilder2.Append(postfix);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
stringBuilder2.Append(';');
|
|
bool flag17 = !string.IsNullOrEmpty(prefix);
|
|
if (flag17)
|
|
{
|
|
stringBuilder2.Append(prefix);
|
|
}
|
|
stringBuilder2.Append(value);
|
|
bool flag18 = !string.IsNullOrEmpty(postfix);
|
|
if (flag18)
|
|
{
|
|
stringBuilder2.Append(postfix);
|
|
}
|
|
return stringBuilder2.ToString();
|
|
}
|
|
|
|
private static int WriteNumberFormat(CellDataFormatFlag flag, object arg, Stylesheet styles)
|
|
{
|
|
bool flag2 = styles.numberFormats == null;
|
|
if (flag2)
|
|
{
|
|
styles.numberFormats = new NumberFormatCollection();
|
|
}
|
|
int result;
|
|
switch (flag)
|
|
{
|
|
case CellDataFormatFlag.Number:
|
|
{
|
|
bool flag3 = arg == null;
|
|
if (flag3)
|
|
{
|
|
result = 1;
|
|
}
|
|
else
|
|
{
|
|
NumberDataFormatter.NumberFormatArgs numberFormatArgs = (NumberDataFormatter.NumberFormatArgs)arg;
|
|
int num = 0;
|
|
for (int i = 0; i < styles.numberFormats.list.Count; i++)
|
|
{
|
|
NumberFormat numberFormat = styles.numberFormats.list[i];
|
|
bool flag4 = numberFormat._iarg.Equals(numberFormatArgs);
|
|
if (flag4)
|
|
{
|
|
num = i + 165;
|
|
break;
|
|
}
|
|
}
|
|
bool flag5 = num > 0;
|
|
if (flag5)
|
|
{
|
|
result = num;
|
|
}
|
|
else
|
|
{
|
|
num = styles.numberFormats.Count + 165;
|
|
string prefix = null;
|
|
string postfix = null;
|
|
bool flag6 = numberFormatArgs.NegativeStyle == NumberDataFormatter.NumberNegativeStyle.CustomSymbol;
|
|
if (flag6)
|
|
{
|
|
prefix = numberFormatArgs.CustomNegativePrefix;
|
|
postfix = numberFormatArgs.CustomNegativePostfix;
|
|
}
|
|
string formatCode = ExcelWriter.ConvertToExcelNumberPattern(numberFormatArgs, prefix, postfix);
|
|
styles.numberFormats.Add(new NumberFormat
|
|
{
|
|
_iarg = numberFormatArgs,
|
|
formatId = num,
|
|
formatCode = formatCode
|
|
});
|
|
result = num;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case CellDataFormatFlag.DateTime:
|
|
{
|
|
bool flag7 = arg == null;
|
|
if (flag7)
|
|
{
|
|
result = 14;
|
|
}
|
|
else
|
|
{
|
|
DateTimeDataFormatter.DateTimeFormatArgs dateTimeFormatArgs = (DateTimeDataFormatter.DateTimeFormatArgs)arg;
|
|
string format = dateTimeFormatArgs.Format;
|
|
string text = format;
|
|
uint num2 = PrivateImplementationDetails.ComputeStringHash(text);
|
|
if (num2 <= 1718795045U)
|
|
{
|
|
if (num2 <= 926503001U)
|
|
{
|
|
if (num2 != 515506635U)
|
|
{
|
|
if (num2 != 649191109U)
|
|
{
|
|
if (num2 == 926503001U)
|
|
{
|
|
if (text == "h:mm")
|
|
{
|
|
result = 20;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (text == "h:mm:ss tt")
|
|
{
|
|
result = 19;
|
|
break;
|
|
}
|
|
}
|
|
else if (text == "h:mm tt")
|
|
{
|
|
result = 18;
|
|
break;
|
|
}
|
|
}
|
|
else if (num2 != 1211042079U)
|
|
{
|
|
if (num2 != 1361753126U)
|
|
{
|
|
if (num2 == 1718795045U)
|
|
{
|
|
if (text == "mm:ss")
|
|
{
|
|
result = 45;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (text == "M/d/yy h:mm")
|
|
{
|
|
result = 22;
|
|
break;
|
|
}
|
|
}
|
|
else if (text == "d-MMM")
|
|
{
|
|
result = 16;
|
|
break;
|
|
}
|
|
}
|
|
else if (num2 <= 3848225324U)
|
|
{
|
|
if (num2 != 2942138037U)
|
|
{
|
|
if (num2 != 3363686679U)
|
|
{
|
|
if (num2 == 3848225324U)
|
|
{
|
|
if (text == "d-MMM-yy")
|
|
{
|
|
result = 15;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (text == "h:mm:ss")
|
|
{
|
|
result = 46;
|
|
break;
|
|
}
|
|
}
|
|
else if (text == "mmss.f")
|
|
{
|
|
result = 47;
|
|
break;
|
|
}
|
|
}
|
|
else if (num2 != 3855691565U)
|
|
{
|
|
if (num2 != 3888993171U)
|
|
{
|
|
if (num2 == 4180059319U)
|
|
{
|
|
if (text == "H:mm:ss")
|
|
{
|
|
result = 21;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (text == "MMM-yy")
|
|
{
|
|
result = 17;
|
|
break;
|
|
}
|
|
}
|
|
else if (text == "yyyy/MM/dd")
|
|
{
|
|
result = 14;
|
|
break;
|
|
}
|
|
int num3 = styles.numberFormats.Count + 165;
|
|
styles.numberFormats.Add(new NumberFormat
|
|
{
|
|
_iarg = dateTimeFormatArgs,
|
|
formatId = num3,
|
|
formatCode = dateTimeFormatArgs.Format
|
|
});
|
|
result = num3;
|
|
}
|
|
break;
|
|
}
|
|
case CellDataFormatFlag.Percent:
|
|
{
|
|
bool flag8 = arg == null;
|
|
if (flag8)
|
|
{
|
|
result = 9;
|
|
}
|
|
else
|
|
{
|
|
NumberDataFormatter.NumberFormatArgs numberFormatArgs = (NumberDataFormatter.NumberFormatArgs)arg;
|
|
bool flag9 = numberFormatArgs.DecimalPlaces == 0;
|
|
if (flag9)
|
|
{
|
|
result = 9;
|
|
}
|
|
else
|
|
{
|
|
result = 10;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case CellDataFormatFlag.Currency:
|
|
{
|
|
bool flag10 = arg == null;
|
|
if (flag10)
|
|
{
|
|
result = 1;
|
|
}
|
|
else
|
|
{
|
|
CurrencyDataFormatter.CurrencyFormatArgs currencyFormatArgs = (CurrencyDataFormatter.CurrencyFormatArgs)arg;
|
|
int num4 = 0;
|
|
for (int j = 0; j < styles.numberFormats.list.Count; j++)
|
|
{
|
|
NumberFormat numberFormat2 = styles.numberFormats.list[j];
|
|
bool flag11 = numberFormat2._iarg.Equals(arg);
|
|
if (flag11)
|
|
{
|
|
num4 = j + 165;
|
|
break;
|
|
}
|
|
}
|
|
bool flag12 = num4 > 0;
|
|
if (flag12)
|
|
{
|
|
result = num4;
|
|
}
|
|
else
|
|
{
|
|
string formatCode2 = ExcelWriter.ConvertToExcelNumberPattern(currencyFormatArgs, currencyFormatArgs.PrefixSymbol, currencyFormatArgs.PostfixSymbol);
|
|
num4 = styles.numberFormats.Count + 165;
|
|
styles.numberFormats.Add(new NumberFormat
|
|
{
|
|
_iarg = currencyFormatArgs,
|
|
formatId = num4,
|
|
formatCode = formatCode2
|
|
});
|
|
result = num4;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case CellDataFormatFlag.Text:
|
|
result = 49;
|
|
break;
|
|
default:
|
|
result = -1;
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static string ConvertToExcelHorAlign(ReoGridHorAlign halign)
|
|
{
|
|
string result;
|
|
switch (halign)
|
|
{
|
|
default:
|
|
result = "general";
|
|
break;
|
|
case ReoGridHorAlign.Left:
|
|
result = "left";
|
|
break;
|
|
case ReoGridHorAlign.Center:
|
|
result = "center";
|
|
break;
|
|
case ReoGridHorAlign.Right:
|
|
result = "right";
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static string ConvertToExcelVerAlign(ReoGridVerAlign valign)
|
|
{
|
|
string result;
|
|
switch (valign)
|
|
{
|
|
default:
|
|
result = "general";
|
|
break;
|
|
case ReoGridVerAlign.Top:
|
|
result = "top";
|
|
break;
|
|
case ReoGridVerAlign.Middle:
|
|
result = "center";
|
|
break;
|
|
case ReoGridVerAlign.Bottom:
|
|
result = "bottom";
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static int WriteStyle(Document doc, WorksheetRangeStyle rgStyle, RangeBorderStyle? top = null, RangeBorderStyle? bottom = null, RangeBorderStyle? left = null, RangeBorderStyle? right = null, CellDataFormatFlag dataFormatFlag = CellDataFormatFlag.General, object dataFormatArg = null)
|
|
{
|
|
Stylesheet stylesheet = doc.Stylesheet;
|
|
string fillId = null;
|
|
string fontId = null;
|
|
string borderId = null;
|
|
string numberFormatId = null;
|
|
bool flag = rgStyle != null && (rgStyle.Flag & PlainStyleFlag.BackColor) == PlainStyleFlag.BackColor;
|
|
if (flag)
|
|
{
|
|
fillId = ExcelWriter.WriteFill(doc, rgStyle.BackColor).ToString();
|
|
}
|
|
bool flag2 = rgStyle != null && (rgStyle.Flag & (PlainStyleFlag)127L) > PlainStyleFlag.None;
|
|
if (flag2)
|
|
{
|
|
fontId = ExcelWriter.WriteFont(doc, rgStyle).ToString();
|
|
}
|
|
bool flag3 = top != null || bottom != null || left != null || right != null;
|
|
if (flag3)
|
|
{
|
|
borderId = ExcelWriter.WriteBorder(doc, top, bottom, left, right).ToString();
|
|
}
|
|
bool flag4 = dataFormatFlag > CellDataFormatFlag.General;
|
|
if (flag4)
|
|
{
|
|
int num = ExcelWriter.WriteNumberFormat(dataFormatFlag, dataFormatArg, doc.Stylesheet);
|
|
bool flag5 = num > 0;
|
|
if (flag5)
|
|
{
|
|
numberFormatId = num.ToString();
|
|
}
|
|
}
|
|
bool horAlign = false;
|
|
bool verAlign = false;
|
|
bool textWrap = false;
|
|
bool textRotate = false;
|
|
float? num2 = null;
|
|
bool flag6 = rgStyle != null;
|
|
if (flag6)
|
|
{
|
|
bool flag7 = (rgStyle.Flag & PlainStyleFlag.HorizontalAlign) == PlainStyleFlag.HorizontalAlign && rgStyle.HAlign > ReoGridHorAlign.General;
|
|
if (flag7)
|
|
{
|
|
horAlign = true;
|
|
bool flag8 = (rgStyle.Flag & PlainStyleFlag.Indent) == PlainStyleFlag.Indent;
|
|
if (flag8)
|
|
{
|
|
num2 = new float?((float)rgStyle.Indent);
|
|
}
|
|
}
|
|
bool flag9 = (rgStyle.Flag & PlainStyleFlag.VerticalAlign) == PlainStyleFlag.VerticalAlign && rgStyle.VAlign != ReoGridVerAlign.General && rgStyle.VAlign != ReoGridVerAlign.Bottom;
|
|
if (flag9)
|
|
{
|
|
verAlign = true;
|
|
}
|
|
bool flag10 = (rgStyle.Flag & PlainStyleFlag.TextWrap) == PlainStyleFlag.TextWrap && rgStyle.TextWrapMode > TextWrapMode.NoWrap;
|
|
if (flag10)
|
|
{
|
|
textWrap = true;
|
|
}
|
|
bool flag11 = (rgStyle.Flag & PlainStyleFlag.RotationAngle) == PlainStyleFlag.RotationAngle && rgStyle.RotationAngle != 0f;
|
|
if (flag11)
|
|
{
|
|
textRotate = true;
|
|
}
|
|
}
|
|
int num3 = stylesheet.cellFormats.FindIndex((CellFormat s) => s.fillId == fillId && s.fontId == fontId && s.numberFormatId == numberFormatId && s.borderId == borderId && ((horAlign && s.alignment != null && s.alignment._horAlign == rgStyle.HAlign) || (!horAlign && (s.alignment == null || s.alignment.horizontal == null))) && ((verAlign && s.alignment != null && s.alignment._verAlign == rgStyle.VAlign) || (!verAlign && (s.alignment == null || s.alignment.vertical == null))) && ((textWrap && s.alignment != null && s.alignment.wrapText == "1") || (!textWrap && (s.alignment == null || s.alignment.wrapText == null))) && ((textRotate && s.alignment != null && s.alignment._rotateAngle == (int)rgStyle.RotationAngle) || (!textRotate && (s.alignment == null || s.alignment.textRotation == null))));
|
|
bool flag12 = num3 >= 0;
|
|
int result;
|
|
if (flag12)
|
|
{
|
|
result = num3;
|
|
}
|
|
else
|
|
{
|
|
CellFormat cellFormat = new CellFormat
|
|
{
|
|
fillId = fillId,
|
|
applyFill = ((fillId != null) ? "1" : null),
|
|
fontId = fontId,
|
|
applyFont = ((fontId != null) ? "1" : null),
|
|
borderId = borderId,
|
|
applyBorder = ((borderId != null) ? "1" : null),
|
|
numberFormatId = numberFormatId,
|
|
applyNumberFormat = ((!string.IsNullOrEmpty(numberFormatId)) ? "1" : null)
|
|
};
|
|
bool flag13 = horAlign | verAlign | textWrap | textRotate;
|
|
if (flag13)
|
|
{
|
|
Alignment alignment = new Alignment();
|
|
cellFormat.alignment = alignment;
|
|
bool horAlign2 = horAlign;
|
|
if (horAlign2)
|
|
{
|
|
alignment.horizontal = ExcelWriter.ConvertToExcelHorAlign(rgStyle.HAlign);
|
|
alignment._horAlign = rgStyle.HAlign;
|
|
bool flag14 = rgStyle.HAlign == ReoGridHorAlign.Left;
|
|
if (flag14)
|
|
{
|
|
alignment.indent = Convert.ToString(rgStyle.Indent);
|
|
}
|
|
}
|
|
bool verAlign2 = verAlign;
|
|
if (verAlign2)
|
|
{
|
|
alignment.vertical = ExcelWriter.ConvertToExcelVerAlign(rgStyle.VAlign);
|
|
alignment._verAlign = rgStyle.VAlign;
|
|
}
|
|
bool textWrap2 = textWrap;
|
|
if (textWrap2)
|
|
{
|
|
alignment.wrapText = "1";
|
|
}
|
|
bool textRotate2 = textRotate;
|
|
if (textRotate2)
|
|
{
|
|
alignment._rotateAngle = (int)rgStyle.RotationAngle;
|
|
alignment.textRotation = ((rgStyle.RotationAngle < 0f) ? Math.Abs(rgStyle.RotationAngle - 90f) : rgStyle.RotationAngle).ToString();
|
|
}
|
|
cellFormat.applyAlignment = "true";
|
|
}
|
|
Debug.Assert(fillId != null || fontId != null || numberFormatId != null || borderId != null || !horAlign || !verAlign);
|
|
stylesheet.cellFormats.Add(cellFormat);
|
|
result = stylesheet.cellFormats.Count - 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static void WriteDefaultStyles(Document doc, IWorkbook rgWorkbook)
|
|
{
|
|
doc.Stylesheet = doc.CreateStyles();
|
|
Stylesheet stylesheet = doc.Stylesheet;
|
|
WorksheetRangeStyle rootStyle = rgWorkbook.Worksheets[0].RootStyle;
|
|
stylesheet.fonts.Add(new CPF.ReoGrid.IO.OpenXML.Schema.Font(rootStyle));
|
|
stylesheet.fills.Add(new Fill
|
|
{
|
|
patternFill = new PatternFill
|
|
{
|
|
patternType = "none"
|
|
}
|
|
});
|
|
stylesheet.fills.Add(new Fill
|
|
{
|
|
patternFill = new PatternFill
|
|
{
|
|
patternType = "gray125"
|
|
}
|
|
});
|
|
stylesheet.borders.Add(new Border
|
|
{
|
|
left = new SideBorder(),
|
|
right = new SideBorder(),
|
|
top = new SideBorder(),
|
|
bottom = new SideBorder(),
|
|
diagonal = new SideBorder()
|
|
});
|
|
stylesheet.cellFormats.Add(new CellFormat
|
|
{
|
|
xfId = "0",
|
|
numberFormatId = "0",
|
|
fontId = "0",
|
|
fillId = "0",
|
|
borderId = "0"
|
|
});
|
|
stylesheet.cellStyleFormats.Add(new CellFormat
|
|
{
|
|
numberFormatId = "0",
|
|
fontId = "0",
|
|
fillId = "0",
|
|
borderId = "0"
|
|
});
|
|
stylesheet.cellStyles.Add(new CellStyle
|
|
{
|
|
name = "Normal",
|
|
xfId = "0",
|
|
builtinId = "0"
|
|
});
|
|
}
|
|
|
|
private static int AddSharedString(Document doc, string str)
|
|
{
|
|
bool flag = doc.SharedStrings == null;
|
|
if (flag)
|
|
{
|
|
doc.SharedStrings = doc.CreateSharedStrings();
|
|
}
|
|
int num = doc.SharedStrings.items.FindIndex((SharedStringItem s) => s.text != null && s.text.val == str);
|
|
bool flag2 = num < 0;
|
|
if (flag2)
|
|
{
|
|
doc.SharedStrings.items.Add(new SharedStringItem
|
|
{
|
|
text = new ElementText(str)
|
|
});
|
|
num = doc.SharedStrings.items.Count - 1;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
private static int AddSharedString(Document doc, RichText rt)
|
|
{
|
|
bool flag = doc.SharedStrings == null;
|
|
if (flag)
|
|
{
|
|
doc.SharedStrings = doc.CreateSharedStrings();
|
|
}
|
|
int num = doc.SharedStrings.items.FindIndex((SharedStringItem s) => s._rt == rt);
|
|
bool flag2 = num < 0;
|
|
if (flag2)
|
|
{
|
|
SharedStringItem sharedStringItem = new SharedStringItem
|
|
{
|
|
runs = new List<CPF.ReoGrid.IO.OpenXML.Schema.Run>(),
|
|
_rt = rt
|
|
};
|
|
CPF.ReoGrid.IO.OpenXML.Schema.Run run = null;
|
|
foreach (CPF.ReoGrid.Drawing.Text.Paragraph paragraph in rt.Paragraphcs)
|
|
{
|
|
bool flag3 = run != null;
|
|
if (flag3)
|
|
{
|
|
Text text = run.text;
|
|
text.innerText += Environment.NewLine;
|
|
run = null;
|
|
}
|
|
foreach (CPF.ReoGrid.Drawing.Text.Run run2 in paragraph.Runs)
|
|
{
|
|
RunProperty runProperty = new RunProperty
|
|
{
|
|
color = new ColorValue(run2.TextColor),
|
|
font = run2.FontName,
|
|
size = run2.FontSize.ToString(ExcelWriter.EnglishCulture)
|
|
};
|
|
bool flag4 = (run2.FontStyles & CPF.ReoGrid.Drawing.Text.FontStyles.Strikethrough) == CPF.ReoGrid.Drawing.Text.FontStyles.Strikethrough;
|
|
if (flag4)
|
|
{
|
|
runProperty.strike = new ElementValue<string>();
|
|
}
|
|
bool flag5 = (run2.FontStyles & CPF.ReoGrid.Drawing.Text.FontStyles.Bold) == CPF.ReoGrid.Drawing.Text.FontStyles.Bold;
|
|
if (flag5)
|
|
{
|
|
runProperty.b = new ElementValue<string>();
|
|
}
|
|
bool flag6 = (run2.FontStyles & CPF.ReoGrid.Drawing.Text.FontStyles.Italic) == CPF.ReoGrid.Drawing.Text.FontStyles.Italic;
|
|
if (flag6)
|
|
{
|
|
runProperty.i = new ElementValue<string>();
|
|
}
|
|
bool flag7 = (run2.FontStyles & CPF.ReoGrid.Drawing.Text.FontStyles.Underline) == CPF.ReoGrid.Drawing.Text.FontStyles.Underline;
|
|
if (flag7)
|
|
{
|
|
runProperty.u = new ElementValue<string>();
|
|
}
|
|
bool flag8 = (run2.FontStyles & CPF.ReoGrid.Drawing.Text.FontStyles.Superscrit) == CPF.ReoGrid.Drawing.Text.FontStyles.Superscrit;
|
|
if (flag8)
|
|
{
|
|
runProperty.vertAlign = "superscript";
|
|
}
|
|
else
|
|
{
|
|
bool flag9 = (run2.FontStyles & CPF.ReoGrid.Drawing.Text.FontStyles.Subscript) == CPF.ReoGrid.Drawing.Text.FontStyles.Subscript;
|
|
if (flag9)
|
|
{
|
|
runProperty.vertAlign = "subscript";
|
|
}
|
|
}
|
|
List<CPF.ReoGrid.IO.OpenXML.Schema.Run> runs = sharedStringItem.runs;
|
|
CPF.ReoGrid.IO.OpenXML.Schema.Run run3 = new CPF.ReoGrid.IO.OpenXML.Schema.Run();
|
|
run3.property = runProperty;
|
|
run3.text = new Text
|
|
{
|
|
innerText = run2.Text,
|
|
space = ((run2.Text.StartsWith(" ") || run2.Text.EndsWith(" ")) ? "preserve" : null)
|
|
};
|
|
run = run3;
|
|
runs.Add(run3);
|
|
}
|
|
}
|
|
doc.SharedStrings.items.Add(sharedStringItem);
|
|
num = doc.SharedStrings.items.Count - 1;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
private static CellAnchor CreateCellAnchorByLocation(Worksheet rgSheet, Point p)
|
|
{
|
|
float dpi = PlatformUtility.GetDPI();
|
|
int num = 0;
|
|
int num2 = 0;
|
|
rgSheet.FindColumnByPosition(p.X, out num2);
|
|
rgSheet.FindRowByPosition(p.Y, out num);
|
|
ColumnHeader columnHeader = rgSheet.RetrieveColumnHeader(num2);
|
|
int colOff = MeasureToolkit.PixelToEMU(p.X - (float)columnHeader.Left, dpi);
|
|
RowHeader rowHeader = rgSheet.RetrieveRowHeader(num);
|
|
int rowOff = MeasureToolkit.PixelToEMU(p.Y - (float)rowHeader.Top, dpi);
|
|
return new CellAnchor
|
|
{
|
|
col = num2,
|
|
colOff = colOff,
|
|
row = num,
|
|
rowOff = rowOff
|
|
};
|
|
}
|
|
|
|
private static ShapeProperty CreateShapeProperty(DrawingObject image)
|
|
{
|
|
float dpi = PlatformUtility.GetDPI();
|
|
return new ShapeProperty
|
|
{
|
|
transform = new Schema.Transform
|
|
{
|
|
offset = new Offset
|
|
{
|
|
x = MeasureToolkit.PixelToEMU(image.X, dpi),
|
|
y = MeasureToolkit.PixelToEMU(image.Y, dpi)
|
|
},
|
|
extents = new Extents
|
|
{
|
|
cx = MeasureToolkit.PixelToEMU(image.Right, dpi),
|
|
cy = MeasureToolkit.PixelToEMU(image.Bottom, dpi)
|
|
}
|
|
},
|
|
prstGeom = new PresetGeometry
|
|
{
|
|
presetType = "rect",
|
|
avList = new List<ShapeGuide>()
|
|
}
|
|
};
|
|
}
|
|
|
|
private static void WriteImage(Document doc, Schema.Worksheet sheet, Schema.Drawing drawing, Worksheet rgSheet, ImageObject image)
|
|
{
|
|
bool flag = drawing.twoCellAnchors == null;
|
|
if (flag)
|
|
{
|
|
drawing.twoCellAnchors = new List<TwoCellAnchor>();
|
|
}
|
|
string friendlyTypeName = image.GetFriendlyTypeName();
|
|
int num = 0;
|
|
drawing._typeObjectCount.TryGetValue(friendlyTypeName, out num);
|
|
num++;
|
|
drawing._typeObjectCount[friendlyTypeName] = num;
|
|
TwoCellAnchor twoCellAnchor = new TwoCellAnchor();
|
|
twoCellAnchor.from = ExcelWriter.CreateCellAnchorByLocation(rgSheet, image.Location);
|
|
float right = image.Right;
|
|
float bottom = image.Bottom;
|
|
twoCellAnchor.to = ExcelWriter.CreateCellAnchorByLocation(rgSheet, new Point(ref right, ref bottom));
|
|
Pic pic = new Pic();
|
|
NvPicProperty nvPicProperty = new NvPicProperty();
|
|
NonVisualProp nonVisualProp = new NonVisualProp();
|
|
int drawingObjectCount = drawing._drawingObjectCount;
|
|
drawing._drawingObjectCount = drawingObjectCount + 1;
|
|
nonVisualProp.id = drawingObjectCount;
|
|
nonVisualProp.name = friendlyTypeName + " " + num.ToString();
|
|
nvPicProperty.cNvPr = nonVisualProp;
|
|
nvPicProperty.cNvPicPr = new CNvPicProperty
|
|
{
|
|
picLocks = new PicLocks()
|
|
};
|
|
pic.nvPicPr = nvPicProperty;
|
|
pic.blipFill = new BlipFill
|
|
{
|
|
blip = doc.AddMediaImage(sheet, drawing, image),
|
|
stretch = new Stretch
|
|
{
|
|
fillRect = new FillRect()
|
|
}
|
|
};
|
|
pic.prop = ExcelWriter.CreateShapeProperty(image);
|
|
twoCellAnchor.pic = pic;
|
|
twoCellAnchor.clientData = new ClientData();
|
|
TwoCellAnchor item = twoCellAnchor;
|
|
drawing.twoCellAnchors.Add(item);
|
|
}
|
|
|
|
private static void WriteWorksheet(Document doc, Worksheet rgSheet)
|
|
{
|
|
bool flag = rgSheet.Rows == 0 || rgSheet.Columns == 0;
|
|
if (flag)
|
|
{
|
|
Debug.Assert(false, "rows or columns on worksheet must not be zero.");
|
|
}
|
|
else
|
|
{
|
|
Schema.Worksheet worksheet = doc.Workbook.CreateWorksheet(rgSheet.Name);
|
|
float dpi = PlatformUtility.GetDPI();
|
|
int num = Math.Max(rgSheet.MaxContentRow, 0);
|
|
int num2 = Math.Max(rgSheet.MaxContentCol, 0);
|
|
RangePosition rangePosition = new RangePosition(0, 0, num + 1, num2 + 1);
|
|
worksheet.dimension = new Dimension
|
|
{
|
|
address = (rangePosition.IsSingleCell ? rangePosition.StartPos.ToRelativeAddress() : rangePosition.ToRelativeAddress())
|
|
};
|
|
worksheet.sheetViews = new List<SheetView>(new SheetView[]
|
|
{
|
|
new SheetView
|
|
{
|
|
tabSelected = ((rgSheet.controlAdapter == null) ? ((rgSheet.workbook.GetWorksheetIndex(rgSheet) == 0) ? "1" : "0") : ((rgSheet == rgSheet.controlAdapter.ControlInstance.CurrentWorksheet) ? "1" : "0")),
|
|
workbookViewId = "0",
|
|
showGridLines = (rgSheet.HasSettings(WorksheetSettings.View_ShowGridLine) ? null : "0"),
|
|
showRowColHeaders = (rgSheet.settings.HasAny(WorksheetSettings.View_ShowHeaders) ? null : "0"),
|
|
zoomScale = ((rgSheet.ScaleFactor == 1f) ? null : (rgSheet.ScaleFactor * 100f).ToString(ExcelWriter.EnglishCulture))
|
|
}
|
|
});
|
|
CellPosition freezePos = rgSheet.FreezePos;
|
|
bool flag2 = freezePos.Row > 0 || freezePos.Col > 0;
|
|
if (flag2)
|
|
{
|
|
worksheet.sheetViews[0].pane = new Pane
|
|
{
|
|
activePane = "bottomRight",
|
|
state = "frozen",
|
|
topLeftCell = freezePos.ToRelativeAddress(),
|
|
xSplit = freezePos.Col.ToString(),
|
|
ySplit = freezePos.Row.ToString()
|
|
};
|
|
}
|
|
bool flag3 = rgSheet.defaultRowHeight != Worksheet.InitDefaultRowHeight;
|
|
if (flag3)
|
|
{
|
|
worksheet.sheetFormatProperty = new SheetFormatProperty
|
|
{
|
|
defaultRowHeight = ((float)rgSheet.defaultRowHeight * 72f / dpi).ToString(ExcelWriter.EnglishCulture),
|
|
customHeight = "1"
|
|
};
|
|
}
|
|
ColumnHeader columnHeader = rgSheet.RetrieveColumnHeader(0);
|
|
int num3 = 0;
|
|
int num4 = (int)columnHeader.InnerWidth;
|
|
bool flag4 = columnHeader.InnerStyle != null && !columnHeader.InnerStyle.Equals(rgSheet.RootStyle);
|
|
int num5;
|
|
if (flag4)
|
|
{
|
|
num5 = ExcelWriter.WriteStyle(doc, columnHeader.InnerStyle, null, null, null, null, CellDataFormatFlag.General, null);
|
|
}
|
|
else
|
|
{
|
|
num5 = -1;
|
|
}
|
|
bool isAutoWidth = columnHeader.IsAutoWidth;
|
|
for (int i = 1; i <= num2; i++)
|
|
{
|
|
ColumnHeader columnHeader2 = rgSheet.RetrieveColumnHeader(i);
|
|
int num6 = -1;
|
|
bool flag5 = columnHeader2.InnerStyle != null && !columnHeader2.InnerStyle.Equals(rgSheet.RootStyle);
|
|
if (flag5)
|
|
{
|
|
num6 = ExcelWriter.WriteStyle(doc, columnHeader2.InnerStyle, null, null, null, null, CellDataFormatFlag.General, null);
|
|
}
|
|
int innerWidth = (int)columnHeader2.InnerWidth;
|
|
bool flag6 = innerWidth != num4 || num6 != num5 || columnHeader2.IsAutoWidth != isAutoWidth;
|
|
if (flag6)
|
|
{
|
|
bool flag7 = num4 != (int)rgSheet.defaultColumnWidth;
|
|
bool flag8 = worksheet.cols == null;
|
|
if (flag8)
|
|
{
|
|
worksheet.cols = new List<Column>();
|
|
}
|
|
float num7 = (float)num4 - 0f;
|
|
worksheet.cols.Add(new Column
|
|
{
|
|
min = num3 + 1,
|
|
max = i,
|
|
width = Math.Truncate((double)(num7 / 7f) * 100.0 + 0.5) / 100.0,
|
|
customWidth = ((!isAutoWidth) ? "1" : null),
|
|
style = ((num5 >= 0) ? num5.ToString() : null)
|
|
});
|
|
num4 = innerWidth;
|
|
num3 = i;
|
|
num5 = num6;
|
|
isAutoWidth = columnHeader2.IsAutoWidth;
|
|
}
|
|
}
|
|
bool flag9 = num3 > 0 && num3 <= num2;
|
|
if (flag9)
|
|
{
|
|
bool flag10 = isAutoWidth || num4 != (int)rgSheet.defaultColumnWidth || num5 >= 0;
|
|
if (flag10)
|
|
{
|
|
bool flag11 = worksheet.cols == null;
|
|
if (flag11)
|
|
{
|
|
worksheet.cols = new List<Column>();
|
|
}
|
|
worksheet.cols.Add(new Column
|
|
{
|
|
min = num3 + 1,
|
|
max = num2 + 1,
|
|
width = Math.Truncate((double)(((float)num4 - 0f) / 7f) * 100.0 + 0.5) / 100.0,
|
|
customWidth = ((!isAutoWidth) ? "1" : null),
|
|
style = ((num5 >= 0) ? num5.ToString() : null)
|
|
});
|
|
num3 = num2 + 1;
|
|
}
|
|
}
|
|
bool flag12 = num3 > 0 && num3 < rgSheet.Columns;
|
|
if (flag12)
|
|
{
|
|
bool flag13 = worksheet.cols == null;
|
|
if (flag13)
|
|
{
|
|
worksheet.cols = new List<Column>();
|
|
}
|
|
worksheet.cols.Add(new Column
|
|
{
|
|
min = num3 + 1,
|
|
max = rgSheet.Columns,
|
|
width = Math.Truncate((double)(((float)rgSheet.defaultColumnWidth - 0f) / 7f) * 100.0 + 0.5) / 100.0
|
|
});
|
|
}
|
|
Row row = null;
|
|
for (int j = 0; j <= num; j++)
|
|
{
|
|
RowHeader rowHeader = rgSheet.RetrieveRowHeader(j);
|
|
bool flag14 = rowHeader.InnerHeight != rgSheet.defaultRowHeight || !rowHeader.IsAutoHeight || rowHeader.InnerStyle != null;
|
|
if (flag14)
|
|
{
|
|
row = new Row
|
|
{
|
|
index = j + 1,
|
|
hidden = ((!rowHeader.IsVisible) ? "1" : null)
|
|
};
|
|
bool flag15 = !rowHeader.IsAutoHeight;
|
|
if (flag15)
|
|
{
|
|
row.customHeight = "1";
|
|
}
|
|
row.height = ((float)rowHeader.InnerHeight * 72f / dpi).ToString(ExcelWriter.EnglishCulture);
|
|
bool flag16 = rowHeader.InnerStyle != null;
|
|
if (flag16)
|
|
{
|
|
row.styleIndex = ExcelWriter.WriteStyle(doc, rowHeader.InnerStyle, null, null, null, null, CellDataFormatFlag.General, null).ToString();
|
|
row.customFormat = "1";
|
|
}
|
|
}
|
|
int k = 0;
|
|
while (k <= num2)
|
|
{
|
|
Cell cell = rgSheet.GetCell(j, k);
|
|
int num8 = 1;
|
|
Schema.Cell cell2 = null;
|
|
WorksheetRangeStyle worksheetRangeStyle = null;
|
|
CellDataFormatFlag dataFormatFlag = CellDataFormatFlag.General;
|
|
object dataFormatArg = null;
|
|
bool flag17 = cell != null;
|
|
if (flag17)
|
|
{
|
|
bool flag18 = !cell.IsValidCell && !cell.IsStartMergedCell;
|
|
if (!flag18)
|
|
{
|
|
cell2 = new Schema.Cell
|
|
{
|
|
address = RGUtility.ToAddress(j, k, 1, 1, true)
|
|
};
|
|
object innerData = cell.InnerData;
|
|
bool hasFormula = cell.HasFormula;
|
|
bool flag19 = CellUtility.IsNumberData(innerData);
|
|
if (flag19)
|
|
{
|
|
cell2.value = new ElementText(Convert.ToString(innerData, ExcelWriter.EnglishCulture));
|
|
}
|
|
else
|
|
{
|
|
bool flag20 = innerData is RichText;
|
|
if (flag20)
|
|
{
|
|
cell2.value = new ElementText(ExcelWriter.AddSharedString(doc, (RichText)innerData).ToString());
|
|
cell2.dataType = "s";
|
|
}
|
|
else
|
|
{
|
|
bool flag21 = innerData is DateTime;
|
|
if (flag21)
|
|
{
|
|
DateTime d = (DateTime)innerData;
|
|
double num9 = (d - DateTimeDataFormatter.BaseStartDate).TotalDays + 1.0;
|
|
bool flag22 = num9 > 59.0;
|
|
if (flag22)
|
|
{
|
|
num9 += 1.0;
|
|
}
|
|
cell2.value = new ElementText(Convert.ToString(num9, ExcelWriter.EnglishCulture));
|
|
}
|
|
else
|
|
{
|
|
bool flag23 = innerData != null;
|
|
if (flag23)
|
|
{
|
|
string text = (innerData is string) ? ((string)innerData) : Convert.ToString(innerData);
|
|
bool flag24 = text.Length > 0;
|
|
if (flag24)
|
|
{
|
|
bool flag25 = hasFormula;
|
|
if (flag25)
|
|
{
|
|
cell2.dataType = "str";
|
|
cell2.value = new ElementText(text);
|
|
}
|
|
else
|
|
{
|
|
bool flag26 = innerData != null;
|
|
if (flag26)
|
|
{
|
|
cell2.value = new ElementText(ExcelWriter.AddSharedString(doc, text).ToString());
|
|
cell2.dataType = "s";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
bool flag27 = hasFormula;
|
|
if (flag27)
|
|
{
|
|
cell2.formula = new Schema.Formula
|
|
{
|
|
val = cell.InnerFormula
|
|
};
|
|
}
|
|
bool flag28 = cell.DataFormat > CellDataFormatFlag.General;
|
|
if (flag28)
|
|
{
|
|
dataFormatFlag = cell.DataFormat;
|
|
dataFormatArg = cell.DataFormatArgs;
|
|
}
|
|
switch (cell.StyleParentKind)
|
|
{
|
|
case StyleParentKind.Root:
|
|
worksheetRangeStyle = rgSheet.RootStyle;
|
|
break;
|
|
case StyleParentKind.Col:
|
|
{
|
|
ColumnHeader columnHeader3 = rgSheet.RetrieveColumnHeader(k);
|
|
worksheetRangeStyle = columnHeader3.InnerStyle;
|
|
break;
|
|
}
|
|
case StyleParentKind.Row:
|
|
worksheetRangeStyle = rowHeader.InnerStyle;
|
|
break;
|
|
case StyleParentKind.Range:
|
|
case StyleParentKind.Own:
|
|
goto IL_9C8;
|
|
default:
|
|
goto IL_9C8;
|
|
}
|
|
IL_9D3:
|
|
bool flag29 = cell.IsStartMergedCell && (cell.Colspan > 1 || cell.Rowspan > 1);
|
|
if (flag29)
|
|
{
|
|
bool flag30 = worksheet.mergeCells == null;
|
|
if (flag30)
|
|
{
|
|
worksheet.mergeCells = new List<MergeCell>();
|
|
}
|
|
worksheet.mergeCells.Add(new MergeCell
|
|
{
|
|
address = new RangePosition(cell.MergeStartPos, cell.MergeEndPos).ToAddress()
|
|
});
|
|
num8 = (int)cell.Colspan;
|
|
}
|
|
goto IL_A57;
|
|
IL_9C8:
|
|
worksheetRangeStyle = cell.InnerStyle;
|
|
goto IL_9D3;
|
|
}
|
|
num8 = cell.MergeEndPos.Col - k;
|
|
bool flag31 = num8 <= 0;
|
|
if (flag31)
|
|
{
|
|
num8 = 1;
|
|
}
|
|
IL_A57:;
|
|
}
|
|
ReoGridHBorder validHBorderByPos = rgSheet.GetValidHBorderByPos(j, k, HBorderOwnerPosition.Top);
|
|
ReoGridHBorder validHBorderByPos2 = rgSheet.GetValidHBorderByPos(j + 1, k, HBorderOwnerPosition.Bottom);
|
|
ReoGridVBorder validVBorderByPos = rgSheet.GetValidVBorderByPos(j, k, VBorderOwnerPosition.Left);
|
|
ReoGridVBorder validVBorderByPos2 = rgSheet.GetValidVBorderByPos(j, k + 1, VBorderOwnerPosition.Right);
|
|
bool flag32 = worksheetRangeStyle == null && validHBorderByPos == null && validHBorderByPos2 == null && validVBorderByPos == null && validVBorderByPos2 == null;
|
|
if (flag32)
|
|
{
|
|
k += num8;
|
|
}
|
|
else
|
|
{
|
|
bool flag33 = cell2 == null;
|
|
if (flag33)
|
|
{
|
|
cell2 = new Schema.Cell
|
|
{
|
|
address = RGUtility.ToAddress(j, k, 1, 1, true)
|
|
};
|
|
}
|
|
cell2.styleIndex = ExcelWriter.WriteStyle(doc, worksheetRangeStyle, (validHBorderByPos != null) ? new RangeBorderStyle?(validHBorderByPos.Style) : null, (validHBorderByPos2 != null) ? new RangeBorderStyle?(validHBorderByPos2.Style) : null, (validVBorderByPos != null) ? new RangeBorderStyle?(validVBorderByPos.Style) : null, (validVBorderByPos2 != null) ? new RangeBorderStyle?(validVBorderByPos2.Style) : null, dataFormatFlag, dataFormatArg).ToString();
|
|
bool flag34 = row == null;
|
|
if (flag34)
|
|
{
|
|
row = new Row
|
|
{
|
|
index = j + 1
|
|
};
|
|
}
|
|
bool flag35 = row.cells == null;
|
|
if (flag35)
|
|
{
|
|
row.cells = new List<Schema.Cell>();
|
|
}
|
|
row.cells.Add(cell2);
|
|
k++;
|
|
}
|
|
}
|
|
bool flag36 = row != null && ((row.cells != null && row.cells.Count > 0) || row.height != null);
|
|
if (flag36)
|
|
{
|
|
worksheet.rows.Add(row);
|
|
}
|
|
row = null;
|
|
}
|
|
bool flag37 = rgSheet.FloatingObjects != null && rgSheet.FloatingObjects.Count > 0;
|
|
if (flag37)
|
|
{
|
|
Schema.Drawing drawing = doc.CreateDrawing(worksheet);
|
|
foreach (IDrawingObject drawingObject in rgSheet.FloatingObjects)
|
|
{
|
|
bool flag38 = drawingObject is ImageObject;
|
|
if (flag38)
|
|
{
|
|
ImageObject imageObject = (ImageObject)drawingObject;
|
|
bool flag39 = imageObject.Image != null;
|
|
if (flag39)
|
|
{
|
|
ExcelWriter.WriteImage(doc, worksheet, drawing, rgSheet, (ImageObject)drawingObject);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private const int BaseUserNumberFormatId = 165;
|
|
|
|
internal static readonly CultureInfo EnglishCulture = CultureInfo.GetCultureInfo("en-US");
|
|
}
|
|
}
|