public Format(IStreamReader reader, RecordType id, ushort length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
Debug.Assert(this.Id == ID);
// initialize class members from stream
this.ifmt = reader.ReadUInt16();
this.cch = reader.ReadUInt16();
this.grbit = reader.ReadByte();
// TODO: place code for interpretation of grbit flag here
// TODO: possibly define a wrapper class for Unicode strings
this.rgb = ExcelHelperClass.getStringFromBiffRecord(reader, this.cch, this.grbit);
// assert that the correct number of bytes has been read from the stream
Debug.Assert(this.Offset + this.Length == this.Reader.BaseStream.Position);
}
public void TestA1R1C1Conversion()
{
string a1cell = "A1";
string r1c1cell = "R1C1";
Assert.AreEqual(a1cell, ExcelHelperClass.ConvertR1C1ToA1(r1c1cell));
Assert.AreEqual(r1c1cell, ExcelHelperClass.ConvertA1ToR1C1(a1cell));
a1cell = "C5";
r1c1cell = "R5C3";
Assert.AreEqual(a1cell, ExcelHelperClass.ConvertR1C1ToA1(r1c1cell));
Assert.AreEqual(r1c1cell, ExcelHelperClass.ConvertA1ToR1C1(a1cell));
a1cell = "FE100";
r1c1cell = "R100C161";
Assert.AreEqual(a1cell, ExcelHelperClass.ConvertR1C1ToA1(r1c1cell));
Assert.AreEqual(r1c1cell, ExcelHelperClass.ConvertA1ToR1C1(a1cell));
}
public ARRAY(IStreamReader reader, RecordType id, UInt16 length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
Debug.Assert(this.Id == ID);
this.rwFirst = reader.ReadUInt16();
this.rwLast = reader.ReadUInt16();
this.colFirst = reader.ReadByte();
this.colLast = reader.ReadByte();
this.grbit = reader.ReadUInt16();
this.chn = reader.ReadUInt32(); // this is used for performance reasons only
this.cce = reader.ReadUInt16();
this.ptgStack = new Stack <AbstractPtg>();
// reader.ReadBytes(this.cce);
this.ptgStack = ExcelHelperClass.getFormulaStack(this.Reader, this.cce);
// assert that the correct number of bytes has been read from the stream
Debug.Assert(this.Offset + this.Length == this.Reader.BaseStream.Position);
}
public void TestA1R1C1Conversion()
{
string a1cell = "A1";
string r1c1cell = "R1C1";
Assert.AreEqual(a1cell, ExcelHelperClass.ConvertR1C1ToA1(r1c1cell));
Assert.AreEqual(r1c1cell, ExcelHelperClass.ConvertA1ToR1C1(a1cell));
a1cell = "C5";
r1c1cell = "R5C3";
Assert.AreEqual(a1cell, ExcelHelperClass.ConvertR1C1ToA1(r1c1cell));
Assert.AreEqual(r1c1cell, ExcelHelperClass.ConvertA1ToR1C1(a1cell));
a1cell = "FE100";
r1c1cell = "R100C161";
Assert.AreEqual(a1cell, ExcelHelperClass.ConvertR1C1ToA1(r1c1cell));
Assert.AreEqual(r1c1cell, ExcelHelperClass.ConvertA1ToR1C1(a1cell));
a1cell = "HZ46";
r1c1cell = "R46C234";
Assert.AreEqual(a1cell, ExcelHelperClass.ConvertR1C1ToA1(r1c1cell));
Assert.AreEqual(r1c1cell, ExcelHelperClass.ConvertA1ToR1C1(a1cell));
a1cell = "IU255";
r1c1cell = "R255C255";
Assert.AreEqual(a1cell, ExcelHelperClass.ConvertR1C1ToA1(r1c1cell));
Assert.AreEqual(r1c1cell, ExcelHelperClass.ConvertA1ToR1C1(a1cell));
a1cell = "AA1";
r1c1cell = "R1C27";
Assert.AreEqual(a1cell, ExcelHelperClass.ConvertR1C1ToA1(r1c1cell));
Assert.AreEqual(r1c1cell, ExcelHelperClass.ConvertA1ToR1C1(a1cell));
a1cell = "AZ1";
r1c1cell = "R1C52";
Assert.AreEqual(a1cell, ExcelHelperClass.ConvertR1C1ToA1(r1c1cell));
Assert.AreEqual(r1c1cell, ExcelHelperClass.ConvertA1ToR1C1(a1cell));
}
public List <double> rknumber; // List double values
/// <summary>
/// Ctor
/// </summary>
/// <param name="reader">Streamreader</param>
/// <param name="id">Record ID - Recordtype</param>
/// <param name="length">The recordlegth</param>
public MulRk(IStreamReader reader, RecordType id, ushort length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
Debug.Assert(this.Id == ID);
this.ixfe = new List <ushort>();
this.rknumber = new List <double>();
// count records - 6 standard non variable values !!!
int count = (int)(this.Length - 6) / 6;
this.rw = reader.ReadUInt16();
this.colFirst = reader.ReadUInt16();
for (int i = 0; i < count; i++)
{
this.ixfe.Add(reader.ReadUInt16());
var buffer = reader.ReadBytes(4);
this.rknumber.Add(ExcelHelperClass.NumFromRK(buffer));
}
this.colLast = reader.ReadUInt16();
// assert that the correct number of bytes has been read from the stream
Debug.Assert(this.Offset + this.Length == this.Reader.BaseStream.Position);
}
public async Task <string> ImportProductsAsync(Stream stream)
{
var sb = new StringBuilder();
var dt = ExcelHelperClass.GetDataTableFromExcel(stream);
var products = this.ConvertDatatableToProductInputEnumrable(dt);
var invalidProducts = products.Where(x => !this.IsSkuAvailable(x.SKU));
if (invalidProducts.Any())
{
sb.AppendLine($"Failed to create the following products due to duplicate SKUs: {string.Join(", ", invalidProducts.Select(x => x.SKU))}");
}
products = products.Except(invalidProducts);
foreach (var product in products)
{
ICollection <ValidationResult> validationResults = new List <ValidationResult>();
if (!ExcelHelperClass.TryValidate(product, out validationResults))
{
sb.AppendLine(string.Join(Environment.NewLine, validationResults.Select(x => x.ErrorMessage)));
continue;
}
else
{
var id = await this.CreateProductAsync(product);
var imageInput = new ImageViewModel {
ProductId = id, Url = product.ImageURL
};
await this.AddProductImageAsync(imageInput);
}
}
return(sb.ToString());
}
/// <summary>
/// This static method is used to convert the ptgStack to the infixnotation
/// This method changes every Ptg***N** PtgRecord from a shared formula
/// </summary>
/// <param name="stack"></param>
/// <param name="xlsContext"></param>
/// <param name="rw">Row from the shared formula</param>
/// <param name="col">Column from the shared formula</param>
/// <returns></returns>
public static string mapFormula(Stack <AbstractPtg> stack, ExcelContext xlsContext, int rw, int col)
{
var resultStack = new Stack <string>();
try
{
var opStack = new Stack <AbstractPtg>(stack);
if (opStack.Count == 0)
{
throw new Exception();
}
while (opStack.Count != 0)
{
var ptg = opStack.Pop();
if (ptg is PtgInt || ptg is PtgNum || ptg is PtgBool || ptg is PtgMissArg || ptg is PtgErr)
{
resultStack.Push(ptg.getData());
}
else if (ptg is PtgRef)
{
var ptgref = (PtgRef)ptg;
int realCol = ptgref.col;
int realRw = ptgref.rw + 1;
if (ptgref.colRelative)
{
realCol += col;
}
if (ptgref.rwRelative)
{
realRw += rw;
}
resultStack.Push(ExcelHelperClass.intToABCString(realCol, (realRw).ToString(), ptgref.colRelative, ptgref.rwRelative));
}
else if (ptg is PtgRefN)
{
var ptgrefn = (PtgRefN)ptg;
int realCol = (int)ptgrefn.col;
int realRw;
if (ptgrefn.colRelative)
{
realCol += col;
}
if (realCol >= 0xFF)
{
realCol -= 0x0100;
}
if (ptgrefn.rwRelative)
{
realRw = (short)ptgrefn.rw + 1;
realRw += rw;
}
else
{
realRw = ptgrefn.rw + 1;
}
resultStack.Push(ExcelHelperClass.intToABCString(realCol, (realRw).ToString(), ptgrefn.colRelative, ptgrefn.rwRelative));
}
else if (ptg is PtgUplus || ptg is PtgUminus)
{
string buffer = "";
if (ptg.PopSize() > resultStack.Count)
{
throw new ExtractorException(ExtractorException.PARSEDFORMULAEXCEPTION);
}
buffer = ptg.getData() + resultStack.Pop();
resultStack.Push(buffer);
}
else if (ptg is PtgParen)
{
string buffer = "";
if (ptg.PopSize() > resultStack.Count)
{
throw new ExtractorException(ExtractorException.PARSEDFORMULAEXCEPTION);
}
buffer = "(" + resultStack.Pop() + ")";
resultStack.Push(buffer);
}
else if (ptg is PtgPercent)
{
string buffer = "";
if (ptg.PopSize() > resultStack.Count)
{
throw new ExtractorException(ExtractorException.PARSEDFORMULAEXCEPTION);
}
buffer = resultStack.Pop() + ptg.getData();
resultStack.Push(buffer);
}
else if (ptg is PtgAdd || ptg is PtgDiv || ptg is PtgMul ||
ptg is PtgSub || ptg is PtgPower || ptg is PtgGt ||
ptg is PtgGe || ptg is PtgLt || ptg is PtgLe ||
ptg is PtgEq || ptg is PtgNe || ptg is PtgConcat ||
ptg is PtgUnion || ptg is PtgIsect
)
{
string buffer = "";
if (ptg.PopSize() > resultStack.Count)
{
throw new ExtractorException(ExtractorException.PARSEDFORMULAEXCEPTION);
}
buffer = ptg.getData() + resultStack.Pop();
buffer = resultStack.Pop() + buffer;
resultStack.Push(buffer);
}
else if (ptg is PtgStr)
{
resultStack.Push("\"" + ptg.getData() + "\"");
}
else if (ptg is PtgArea)
{
string buffer = "";
var ptgarea = (PtgArea)ptg;
buffer = ExcelHelperClass.intToABCString((int)ptgarea.colFirst, (ptgarea.rwFirst + 1).ToString(), ptgarea.colFirstRelative, ptgarea.rwFirstRelative);
buffer = buffer + ":" + ExcelHelperClass.intToABCString((int)ptgarea.colLast, (ptgarea.rwLast + 1).ToString(), ptgarea.colLastRelative, ptgarea.rwLastRelative);
resultStack.Push(buffer);
}
else if (ptg is PtgAreaN)
{
string buffer = "";
var ptgarean = (PtgAreaN)ptg;
int realRwFirst;
int realRwLast;
int realColFirst = (int)ptgarean.colFirst;
int realColLast = (int)ptgarean.colLast;
if (ptgarean.colFirstRelative)
{
realColFirst += col;
}
if (realColFirst >= 0xFF)
{
realColFirst -= 0x0100;
}
if (ptgarean.colLastRelative)
{
realColLast += col;
}
if (realColLast >= 0xFF)
{
realColLast -= 0x0100;
}
if (ptgarean.rwFirstRelative)
{
realRwFirst = (short)ptgarean.rwFirst + 1;
realRwFirst += rw;
}
else
{
realRwFirst = ptgarean.rwFirst + 1;
}
if (ptgarean.rwLastRelative)
{
realRwLast = (short)ptgarean.rwLast + 1;
realRwLast += rw;
}
else
{
realRwLast = ptgarean.rwLast + 1;
}
buffer = ExcelHelperClass.intToABCString(realColFirst, (realRwFirst).ToString(), ptgarean.colFirstRelative, ptgarean.rwFirstRelative);
buffer = buffer + ":" + ExcelHelperClass.intToABCString(realColLast, (realRwLast).ToString(), ptgarean.colLastRelative, ptgarean.rwLastRelative);
resultStack.Push(buffer);
}
else if (ptg is PtgAttrSum)
{
string buffer = "";
var ptgref = (PtgAttrSum)ptg;
buffer = ptg.getData() + "(" + resultStack.Pop() + ")";
resultStack.Push(buffer);
}
else if (ptg is PtgAttrIf || ptg is PtgAttrGoto || ptg is PtgAttrSemi ||
ptg is PtgAttrChoose || ptg is PtgAttrSpace)
{
}
else if (ptg is PtgExp)
{
var ptgexp = (PtgExp)ptg;
var newptgstack = ((WorkSheetData)xlsContext.CurrentSheet).getArrayData(ptgexp.rw, ptgexp.col);
resultStack.Push(FormulaInfixMapping.mapFormula(newptgstack, xlsContext));
((WorkSheetData)xlsContext.CurrentSheet).setFormulaUsesArray(ptgexp.rw, ptgexp.col);
}
else if (ptg is PtgRef3d)
{
try
{
var ptgr3d = (PtgRef3d)ptg;
string refstring = ExcelHelperClass.EscapeFormulaString(xlsContext.XlsDoc.WorkBookData.getIXTIString(ptgr3d.ixti));
string cellref = ExcelHelperClass.intToABCString((int)ptgr3d.col, (ptgr3d.rw + 1).ToString(), ptgr3d.colRelative, ptgr3d.rwRelative);
resultStack.Push("'" + refstring + "'" + "!" + cellref);
}
catch (Exception)
{
resultStack.Push("#REF!");
}
}
else if (ptg is PtgArea3d)
{
try
{
var ptga3d = (PtgArea3d)ptg;
string refstring = ExcelHelperClass.EscapeFormulaString(xlsContext.XlsDoc.WorkBookData.getIXTIString(ptga3d.ixti));
string buffer = "";
buffer = ExcelHelperClass.intToABCString((int)ptga3d.colFirst, (ptga3d.rwFirst + 1).ToString(), ptga3d.colFirstRelative, ptga3d.rwFirstRelative);
buffer = buffer + ":" + ExcelHelperClass.intToABCString((int)ptga3d.colLast, (ptga3d.rwLast + 1).ToString(), ptga3d.colLastRelative, ptga3d.rwLastRelative);
resultStack.Push("'" + refstring + "'!" + buffer);
}
catch (Exception)
{
resultStack.Push("#REF!");
}
}
else if (ptg is PtgNameX)
{
var ptgnx = (PtgNameX)ptg;
string opstring = xlsContext.XlsDoc.WorkBookData.getExternNameByRef(ptgnx.ixti, ptgnx.nameindex);
resultStack.Push(opstring);
}
else if (ptg is PtgName)
{
var ptgn = (PtgName)ptg;
string opstring = xlsContext.XlsDoc.WorkBookData.getDefinedNameByRef(ptgn.nameindex);
resultStack.Push(opstring);
}
else if (ptg is PtgRefErr)
{
var ptgreferr = (PtgRefErr)ptg;
resultStack.Push(ptgreferr.getData());
}
else if (ptg is PtgRefErr3d)
{
try
{
var ptgreferr3d = (PtgRefErr3d)ptg;
string refstring = ExcelHelperClass.EscapeFormulaString(xlsContext.XlsDoc.WorkBookData.getIXTIString(ptgreferr3d.ixti));
resultStack.Push("'" + refstring + "'" + "!" + ptgreferr3d.getData());
}
catch (Exception)
{
resultStack.Push("#REF!");
}
}
else if (ptg is PtgAreaErr3d)
{
try
{
var ptgareaerr3d = (PtgAreaErr3d)ptg;
string refstring = ExcelHelperClass.EscapeFormulaString(xlsContext.XlsDoc.WorkBookData.getIXTIString(ptgareaerr3d.ixti));
resultStack.Push("'" + refstring + "'" + "!" + ptgareaerr3d.getData());
}
catch (Exception)
{
resultStack.Push("#REF!");
}
}
else if (ptg is PtgFunc)
{
var ptgf = (PtgFunc)ptg;
var value = (FtabValues)ptgf.tab;
string buffer = value.ToString();
buffer.Replace("_", ".");
// no param
if (value == FtabValues.NA || value == FtabValues.PI ||
value == FtabValues.TRUE || value == FtabValues.FALSE ||
value == FtabValues.RAND || value == FtabValues.NOW ||
value == FtabValues.TODAY
)
{
buffer += "()";
}
// One param
else if (value == FtabValues.ISNA || value == FtabValues.ISERROR ||
value == FtabValues.SIN || value == FtabValues.COS ||
value == FtabValues.TAN || value == FtabValues.ATAN ||
value == FtabValues.SQRT || value == FtabValues.EXP ||
value == FtabValues.LN || value == FtabValues.LOG10 ||
value == FtabValues.ABS || value == FtabValues.INT ||
value == FtabValues.SIGN || value == FtabValues.LEN ||
value == FtabValues.VALUE || value == FtabValues.NOT ||
value == FtabValues.DAY || value == FtabValues.MONTH ||
value == FtabValues.YEAR || value == FtabValues.HOUR ||
value == FtabValues.MINUTE || value == FtabValues.SECOND ||
value == FtabValues.AREAS || value == FtabValues.ROWS ||
value == FtabValues.COLUMNS || value == FtabValues.TRANSPOSE ||
value == FtabValues.TYPE || value == FtabValues.ASIN ||
value == FtabValues.ACOS || value == FtabValues.ISREF ||
value == FtabValues.CHAR || value == FtabValues.LOWER ||
value == FtabValues.UPPER || value == FtabValues.PROPER ||
value == FtabValues.TRIM || value == FtabValues.CODE ||
value == FtabValues.ISERR || value == FtabValues.ISTEXT ||
value == FtabValues.ISNUMBER || value == FtabValues.ISBLANK ||
value == FtabValues.T || value == FtabValues.N ||
value == FtabValues.DATEVALUE || value == FtabValues.TIMEVALUE ||
value == FtabValues.CLEAN || value == FtabValues.MDETERM ||
value == FtabValues.MINVERSE || value == FtabValues.FACT ||
value == FtabValues.ISNONTEXT || value == FtabValues.ISLOGICAL ||
value == FtabValues.LENB || value == FtabValues.DBCS ||
value == FtabValues.SINH || value == FtabValues.COSH ||
value == FtabValues.TANH || value == FtabValues.ASINH ||
value == FtabValues.ACOSH || value == FtabValues.ATANH ||
value == FtabValues.INFO || value == FtabValues.ERROR_TYPE ||
value == FtabValues.GAMMALN || value == FtabValues.EVEN ||
value == FtabValues.FISHER || value == FtabValues.FISHERINV ||
value == FtabValues.NORMSDIST || value == FtabValues.NORMSINV ||
value == FtabValues.ODD || value == FtabValues.RADIANS ||
value == FtabValues.DEGREES || value == FtabValues.COUNTBLANK ||
value == FtabValues.DATESTRING || value == FtabValues.PHONETIC
)
{
buffer += "(" + resultStack.Pop() + ")";
}
// two params
else if (value == FtabValues.ROUND || value == FtabValues.REPT ||
value == FtabValues.MOD || value == FtabValues.TEXT ||
value == FtabValues.ATAN2 || value == FtabValues.EXACT ||
value == FtabValues.MMULT || value == FtabValues.ROUNDUP ||
value == FtabValues.ROUNDDOWN || value == FtabValues.FREQUENCY ||
value == FtabValues.CHIDIST || value == FtabValues.CHIINV ||
value == FtabValues.COMBIN || value == FtabValues.FLOOR ||
value == FtabValues.CEILING || value == FtabValues.PERMUT ||
value == FtabValues.SUMXMY2 || value == FtabValues.SUMX2MY2 ||
value == FtabValues.SUMX2PY2 || value == FtabValues.CHITEST ||
value == FtabValues.CORREL || value == FtabValues.COVAR ||
value == FtabValues.FTEST || value == FtabValues.INTERCEPT ||
value == FtabValues.PEARSON || value == FtabValues.RSQ ||
value == FtabValues.STEYX || value == FtabValues.SLOPE ||
value == FtabValues.LARGE || value == FtabValues.SMALL ||
value == FtabValues.QUARTILE || value == FtabValues.PERCENTILE ||
value == FtabValues.TRIMMEAN || value == FtabValues.TINV ||
value == FtabValues.POWER || value == FtabValues.COUNTIF ||
value == FtabValues.NUMBERSTRING
)
{
buffer += "(";
string buffer2 = resultStack.Pop();
buffer2 = resultStack.Pop() + "," + buffer2;
buffer += buffer2 + ")";
}
// Three params
else if (value == FtabValues.MID || value == FtabValues.DCOUNT ||
value == FtabValues.DSUM || value == FtabValues.DAVERAGE ||
value == FtabValues.DMIN || value == FtabValues.DMAX ||
value == FtabValues.DSTDEV || value == FtabValues.DVAR ||
value == FtabValues.MIRR || value == FtabValues.DATE ||
value == FtabValues.TIME || value == FtabValues.SLN ||
value == FtabValues.DPRODUCT || value == FtabValues.DSTDEVP ||
value == FtabValues.DVARP || value == FtabValues.DCOUNTA ||
value == FtabValues.MIDB || value == FtabValues.DGET ||
value == FtabValues.CONFIDENCE || value == FtabValues.CRITBINOM ||
value == FtabValues.EXPONDIST || value == FtabValues.FDIST
|| value == FtabValues.FINV || value == FtabValues.GAMMAINV ||
value == FtabValues.LOGNORMDIST || value == FtabValues.LOGINV ||
value == FtabValues.NEGBINOMDIST || value == FtabValues.NORMINV ||
value == FtabValues.STANDARDIZE || value == FtabValues.POISSON ||
value == FtabValues.TDIST || value == FtabValues.FORECAST
)
{
buffer += "(";
string buffer2 = resultStack.Pop();
buffer2 = resultStack.Pop() + "," + buffer2;
buffer2 = resultStack.Pop() + "," + buffer2;
buffer += buffer2 + ")";
}
// four params
else if (value == FtabValues.REPLACE || value == FtabValues.SYD ||
value == FtabValues.REPLACEB || value == FtabValues.BINOMDIST ||
value == FtabValues.GAMMADIST || value == FtabValues.HYPGEOMDIST ||
value == FtabValues.NORMDIST || value == FtabValues.WEIBULL ||
value == FtabValues.TTEST || value == FtabValues.ISPMT
)
{
buffer += "(";
string buffer2 = resultStack.Pop();
buffer2 = resultStack.Pop() + "," + buffer2;
buffer2 = resultStack.Pop() + "," + buffer2;
buffer2 = resultStack.Pop() + "," + buffer2;
buffer += buffer2 + ")";
}
if ((int)value != 0xff)
{
}
resultStack.Push(buffer);
}
else if (ptg is PtgFuncVar)
{
var ptgfv = (PtgFuncVar)ptg;
// is Ftab or Cetab
if (!ptgfv.fCelFunc)
{
var value = (FtabValues)ptgfv.tab;
string buffer = value.ToString();
buffer.Replace("_", ".");
// 1 to x parameter
if (value == FtabValues.COUNT || value == FtabValues.IF ||
value == FtabValues.ISNA || value == FtabValues.ISERROR ||
value == FtabValues.AVERAGE || value == FtabValues.MAX ||
value == FtabValues.MIN || value == FtabValues.SUM ||
value == FtabValues.ROW || value == FtabValues.COLUMN ||
value == FtabValues.NPV || value == FtabValues.STDEV ||
value == FtabValues.DOLLAR || value == FtabValues.FIXED ||
value == FtabValues.SIN || value == FtabValues.COS ||
value == FtabValues.LOOKUP || value == FtabValues.INDEX ||
value == FtabValues.AND || value == FtabValues.OR ||
value == FtabValues.VAR || value == FtabValues.LINEST ||
value == FtabValues.TREND || value == FtabValues.LOGEST ||
value == FtabValues.GROWTH || value == FtabValues.PV ||
value == FtabValues.FV || value == FtabValues.NPER ||
value == FtabValues.PMT || value == FtabValues.RATE ||
value == FtabValues.IRR || value == FtabValues.MATCH ||
value == FtabValues.WEEKDAY || value == FtabValues.OFFSET ||
value == FtabValues.ARGUMENT || value == FtabValues.SEARCH ||
value == FtabValues.CHOOSE || value == FtabValues.HLOOKUP ||
value == FtabValues.VLOOKUP || value == FtabValues.LOG ||
value == FtabValues.LEFT || value == FtabValues.RIGHT ||
value == FtabValues.SUBSTITUTE || value == FtabValues.FIND ||
value == FtabValues.CELL || value == FtabValues.DDB ||
value == FtabValues.INDIRECT || value == FtabValues.IPMT ||
value == FtabValues.PPMT || value == FtabValues.COUNTA ||
value == FtabValues.PRODUCT || value == FtabValues.STDEVP ||
value == FtabValues.VARP || value == FtabValues.TRUNC ||
value == FtabValues.USDOLLAR || value == FtabValues.FINDB ||
value == FtabValues.SEARCHB || value == FtabValues.LEFTB ||
value == FtabValues.RIGHTB || value == FtabValues.RANK ||
value == FtabValues.ADDRESS || value == FtabValues.DAYS360 ||
value == FtabValues.VDB || value == FtabValues.MEDIAN ||
value == FtabValues.PRODUCT || value == FtabValues.DB ||
value == FtabValues.AVEDEV || value == FtabValues.BETADIST ||
value == FtabValues.BETAINV || value == FtabValues.PROB ||
value == FtabValues.DEVSQ || value == FtabValues.GEOMEAN ||
value == FtabValues.HARMEAN || value == FtabValues.SUMSQ ||
value == FtabValues.KURT || value == FtabValues.SKEW ||
value == FtabValues.ZTEST || value == FtabValues.PERCENTRANK ||
value == FtabValues.MODE || value == FtabValues.CONCATENATE ||
value == FtabValues.SUBTOTAL || value == FtabValues.SUMIF ||
value == FtabValues.ROMAN || value == FtabValues.GETPIVOTDATA ||
value == FtabValues.HYPERLINK || value == FtabValues.AVERAGEA ||
value == FtabValues.MAXA || value == FtabValues.MINA ||
value == FtabValues.STDEVPA || value == FtabValues.VARPA ||
value == FtabValues.STDEVA || value == FtabValues.VARA
)
{
buffer += "(";
string buffer2 = resultStack.Pop();
for (int i = 1; i < ptgfv.cparams; i++)
{
buffer2 = resultStack.Pop() + "," + buffer2;
}
buffer += buffer2 + ")";
resultStack.Push(buffer);
}
else if ((int)value == 0xFF)
{
buffer = "(";
string buffer2 = resultStack.Pop();
for (int i = 1; i < ptgfv.cparams - 1; i++)
{
buffer2 = resultStack.Pop() + "," + buffer2;
}
buffer += buffer2 + ")";
// take the additional Operator from the Operandstack
buffer = resultStack.Pop() + buffer;
resultStack.Push(buffer);
}
}
}
else if (ptg is PtgMemFunc)
{
string value;
value = FormulaInfixMapping.mapFormula(((PtgMemFunc)ptg).ptgStack, xlsContext);
resultStack.Push(value);
}
}
}
catch (Exception ex)
{
TraceLogger.DebugInternal(ex.Message.ToString());
resultStack.Push("");
}
if (resultStack.Count == 0)
{
resultStack.Push("");
}
return(resultStack.Pop());
}
/// <summary>
/// The overload apply method
/// Creates the Workbook xml document
/// </summary>
/// <param name="bsd">WorkSheetData</param>
public void Apply(SupBookData sbd)
{
Uri uri = new Uri(sbd.VirtPath, UriKind.RelativeOrAbsolute);
ExternalRelationship er = this.xlsContext.SpreadDoc.WorkbookPart.GetExternalLinkPart().AddExternalRelationship(OpenXmlRelationshipTypes.ExternalLinkPath, uri);
_writer.WriteStartDocument();
_writer.WriteStartElement("externalLink", OpenXmlNamespaces.SpreadsheetML);
_writer.WriteStartElement("externalBook");
_writer.WriteAttributeString("r", "id", OpenXmlNamespaces.Relationships, er.Id.ToString());
_writer.WriteStartElement("sheetNames");
foreach (String var in sbd.RGST)
{
_writer.WriteStartElement("sheetName");
_writer.WriteAttributeString("val", var);
_writer.WriteEndElement();
}
_writer.WriteEndElement();
// checks if some externNames exist
if (sbd.ExternNames.Count > 0)
{
_writer.WriteStartElement("definedNames");
foreach (String var in sbd.ExternNames)
{
_writer.WriteStartElement("definedName");
_writer.WriteAttributeString("name", var);
_writer.WriteEndElement();
}
_writer.WriteEndElement();
}
if (sbd.XCTDataList.Count > 0)
{
_writer.WriteStartElement("sheetDataSet");
int counter = 0;
foreach (XCTData var in sbd.XCTDataList)
{
_writer.WriteStartElement("sheetData");
_writer.WriteAttributeString("sheetId", counter.ToString());
counter++;
foreach (CRNData crn in var.CRNDataList)
{
_writer.WriteStartElement("row");
_writer.WriteAttributeString("r", (crn.rw + 1).ToString());
for (byte i = crn.colFirst; i <= crn.colLast; i++)
{
_writer.WriteStartElement("cell");
_writer.WriteAttributeString("r", ExcelHelperClass.intToABCString((int)i, (crn.rw + 1).ToString()));
if (crn.oper[i - crn.colFirst] is bool)
{
_writer.WriteAttributeString("t", "b");
if ((bool)crn.oper[i - crn.colFirst])
{
_writer.WriteElementString("v", "1");
}
else
{
_writer.WriteElementString("v", "0");
}
}
if (crn.oper[i - crn.colFirst] is double)
{
// _writer.WriteAttributeString("t", "b");
_writer.WriteElementString("v", Convert.ToString(crn.oper[i - crn.colFirst], CultureInfo.GetCultureInfo("en-US")));
}
if (crn.oper[i - crn.colFirst] is String)
{
_writer.WriteAttributeString("t", "str");
_writer.WriteElementString("v", crn.oper[i - crn.colFirst].ToString());
}
_writer.WriteEndElement();
}
_writer.WriteEndElement();
}
_writer.WriteEndElement();
}
_writer.WriteEndElement();
}
_writer.WriteEndElement();
_writer.WriteEndElement(); // close worksheet
_writer.WriteEndDocument();
sbd.ExternalLinkId = this.xlsContext.SpreadDoc.WorkbookPart.GetExternalLinkPart().RelId;
sbd.ExternalLinkRef = this.xlsContext.SpreadDoc.WorkbookPart.GetExternalLinkPart().RelIdToString;
// close writer
_writer.Flush();
}
public override string ToString()
{
//Make sure to truncate column values that use any value > 255
return(ExcelHelperClass.ConvertR1C1ToA1(string.Format("R{0}C{1}", rw + 1, (col + 1) & 0xFF)));
}
public MappingException(string prop, ExcelQueryArgs args)
{
mappedProp = prop;
this.args = args;
columnNames = (List <string>)ExcelHelperClass.GetColumnNames(args);
}
private static byte[] GetByteDataFromPtg(AbstractPtg ptg)
{
MemoryStream ms = new MemoryStream();
BinaryWriter bw = new BinaryWriter(ms);
switch (ptg)
{
case PtgInt ptgInt:
bw.Write(Convert.ToUInt16(ptg.getData()));
break;
case PtgArray ptgArray:
bw.Write(ptgArray.DataBytes);
break;
case PtgAdd ptgAdd:
case PtgSub ptgSub:
case PtgMul ptgMul:
case PtgDiv ptgDiv:
case PtgParen ptgParen:
case PtgPower ptgPower:
case PtgPercent ptgPercent:
case PtgGt ptgGt:
case PtgGe ptgGe:
case PtgLt ptgLt:
case PtgLe ptgLe:
case PtgEq ptgEq:
case PtgNe ptgNe:
case PtgUminus ptgUminus:
case PtgUplus ptgUplus:
case PtgConcat ptgConcat:
case PtgUnion ptgUnion:
case PtgIsect ptgIsect:
case PtgMissArg ptgMissArg:
//No Data
break;
case PtgNum ptgNum:
bw.Write(Convert.ToDouble(ptg.getData(), CultureInfo.GetCultureInfo("en-US")));
break;
case PtgRef ptgRef:
RgceLoc loc = new RgceLoc(ptgRef.rw, ptgRef.col, ptgRef.colRelative, ptgRef.rwRelative);
bw.Write(loc.Bytes);
break;
case PtgRefN ptgRefN:
RgceLoc loc2 = new RgceLoc(Convert.ToUInt16(ptgRefN.rw), Convert.ToUInt16(ptgRefN.col), ptgRefN.colRelative, ptgRefN.rwRelative);
bw.Write(loc2.Bytes);
break;
case PtgBool ptgBool:
string boolData = ptgBool.getData();
bw.Write((boolData.Equals("TRUE") ? (byte)1 : (byte)0));
break;
case PtgStr ptgStr:
string unescapedString = ExcelHelperClass.UnescapeFormulaString(ptgStr.getData());
ShortXLUnicodeString ptgString = new ShortXLUnicodeString(unescapedString, ptgStr.isUnicode);
bw.Write(ptgString.Bytes);
break;
case PtgFuncVar ptgFuncVar:
bw.Write(ptgFuncVar.cparams);
ushort tab = ptgFuncVar.tab;
ushort fCeFunc = ptgFuncVar.fCelFunc ? (ushort)0x8000 : (ushort)0;
tab = (ushort)(tab | fCeFunc);
bw.Write(tab);
break;
case PtgFunc ptgFunc:
bw.Write(Convert.ToUInt16(ptgFunc.tab));
break;
case PtgExp ptgExp:
RgceLoc loc3 = new RgceLoc(Convert.ToUInt16(ptgExp.rw), Convert.ToUInt16(ptgExp.col), false, false);
bw.Write(loc3.Bytes);
break;
case PtgRef3d ptgRef3d:
RgceLoc loc4 = new RgceLoc(Convert.ToUInt16(ptgRef3d.rw), Convert.ToUInt16(ptgRef3d.col), ptgRef3d.colRelative, ptgRef3d.rwRelative);
bw.Write(Convert.ToUInt16(ptgRef3d.ixti));
bw.Write(loc4.Bytes);
break;
case PtgAttrBaxcel ptgAttrBaxcel:
bw.Write(ptgAttrBaxcel.DataBytes);
break;
case PtgAttrIf ptgAttrIf:
bw.Write(ptgAttrIf.Offset);
break;
case PtgAttrGoto ptgAttrGoto:
bw.Write(ptgAttrGoto.Offset);
break;
case PtgAttrSpace ptgAttrSpace:
bw.Write(ptgAttrSpace.PtgAttrSpaceType);
break;
case PtgName ptgName:
bw.Write(ptgName.nameindex);
break;
case PtgArea ptgArea:
bw.Write(ptgArea.rwFirst);
bw.Write(ptgArea.rwLast);
bw.Write(ptgArea.colFirst);
bw.Write(ptgArea.colLast);
break;
case PtgErr ptgErr:
bw.Write(ptgErr.Err);
break;
case PtgAttrSum ptgAttrSum: //Start 0x19 ## Section
case PtgAttrSemi ptgAttrSemi:
case PtgAttrChoose ptgAttrChoose:
case PtgNotDocumented ptgNotDocumented:
case PtgMemErr ptgMemErr:
case PtgAreaN ptgAreaN:
case PtgArea3d ptgArea3d:
case PtgNameX ptgNameX:
case PtgRefErr ptgRefErr:
case PtgRefErr3d ptgRefErr3d:
case PtgAreaErr ptgAreaErr:
case PtgAreaErr3d ptgAreaErr3d:
case PtgMemFunc ptgMemFunc:
default:
throw new NotImplementedException(string.Format("No byte conversion implemented for {0}", ptg));
}
return(bw.GetBytesWritten());
}
public Formula(IStreamReader reader, RecordType id, ushort length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
Debug.Assert(this.Id == ID);
this.val = new byte[8];
this.rw = reader.ReadUInt16();
this.col = reader.ReadUInt16();
this.ixfe = reader.ReadUInt16();
this.boolValueSet = false;
long oldStreamPosition = this.Reader.BaseStream.Position;
this.val = reader.ReadBytes(8); // read 8 bytes for the value of the formula
ProcessFormulaValue();
this.grbit = reader.ReadUInt16();
this.chn = reader.ReadUInt32(); // this is used for performance reasons only
this.cce = reader.ReadUInt16();
this.ptgStack = new Stack <AbstractPtg>();
// reader.ReadBytes(this.cce);
// check always calc mode
this.fAlwaysCalc = Utils.BitmaskToBool((int)this.grbit, 0x01);
// check if shared formula
this.fShrFmla = Utils.BitmaskToBool((int)this.grbit, 0x08);
// check if this should ignore error checking
this.fClearErrors = Utils.BitmaskToBool(this.grbit, 0x20);
oldStreamPosition = this.Reader.BaseStream.Position;
if (!this.fShrFmla)
{
try
{
this.ptgStack = ExcelHelperClass.getFormulaStack(this.Reader, this.cce);
List <PtgMemArea> memAreas = this.ptgStack.Where(ptg => ptg is PtgMemArea).Cast <PtgMemArea>().ToList();
//Read out the rgce for relevant PtgExtraMem if necessary
foreach (var memArea in memAreas)
{
memArea.ExtraMem = new PtgExtraMem(this.Reader);
}
}
catch (Exception ex)
{
this.Reader.BaseStream.Seek(oldStreamPosition, System.IO.SeekOrigin.Begin);
this.Reader.BaseStream.Seek(this.cce, System.IO.SeekOrigin.Current);
TraceLogger.Error("Formula parse error in Row {0} Column {1}", this.rw, this.col);
TraceLogger.Debug(ex.StackTrace);
TraceLogger.Debug("Inner exception: {0}", ex.InnerException.StackTrace);
}
}
else
{
//If the next expression isn't 5 bytes long, it's not a PtgExp shared formula reference...just ignore for now
if (this.cce != 5)
{
reader.ReadBytes(this.cce);
}
//First 8 bits are reserved, must be 1 but we'll ignore them for now
byte ptg = reader.ReadByte();
//Next two bytes are the row containing the shared formula
sharedRow = reader.ReadUInt16();
//then the col containing the shared formula
sharedCol = reader.ReadUInt16();
}
// assert that the correct number of bytes has been read from the stream
Debug.Assert(this.Offset + this.Length == this.Reader.BaseStream.Position);
}
public SupBook(IStreamReader reader, RecordType id, ushort length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
Debug.Assert(this.Id == ID);
this.ctab = this.Reader.ReadUInt16();
this.cch = this.Reader.ReadUInt16();
this.isselfreferencing = true;
this.isaddinreferencing = false;
this.isvirtpath = false;
this.isexternalworkbookreferencing = false;
this.isunusedsupportinglink = false;
// Check cch
if (this.cch == 0x0401)
{
this.isselfreferencing = true;
}
else if (this.cch == 0x3A01)
{
this.isaddinreferencing = true;
//0x0001 to 0x00ff (inclusive)
}
else if (this.cch >= 0x0001 && this.cch <= 0x00ff)
{
this.isvirtpath = true;
}
if (this.isvirtpath)
{
this.virtpathstring = "";
byte firstbyte = this.Reader.ReadByte();
int firstbit = firstbyte & 0x1;
for (int i = 0; i < this.cch; i++)
{
if (firstbit == 0)
{
this.virtpathstring += (char)this.Reader.ReadByte();
// read 1 byte per char
}
else
{
// read two byte per char
this.virtpathstring += System.BitConverter.ToChar(this.Reader.ReadBytes(2), 0);
}
}
this.virtpathstring = ExcelHelperClass.parseVirtualPath(this.virtpathstring);
}
if (this.virtpathstring != null)
{
if (this.virtpathstring.Equals(0x00))
{
this.isselfreferencing = true;
}
else if (this.virtpathstring.Equals(0x20))
{
this.isunusedsupportinglink = true;
}
else
{
this.isexternalworkbookreferencing = true;
}
}
if ((this.isexternalworkbookreferencing) || (this.isunusedsupportinglink))
{
this.rgst = new string[this.ctab];
for (int i = 0; i < this.ctab; i++)
{
ushort cch2 = this.Reader.ReadUInt16();
byte firstbyte = this.Reader.ReadByte();
int firstbit = firstbyte & 0x1;
for (int j = 0; j < cch2; j++)
{
if (firstbit == 0)
{
this.rgst[i] += (char)this.Reader.ReadByte();
// read 1 byte per char
}
else
{
// read two byte per char
this.rgst[i] += System.BitConverter.ToChar(this.Reader.ReadBytes(2), 0);
}
}
}
}
if (this.virtpathstring != null && this.virtpathstring.Length > 1)
{
this.isselfreferencing = false;
}
// assert that the correct number of bytes has been read from the stream
Debug.Assert(this.Offset + this.Length == this.Reader.BaseStream.Position);
}
public Formula(IStreamReader reader, RecordType id, ushort length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
Debug.Assert(this.Id == ID);
this.val = new byte[8];
this.rw = reader.ReadUInt16();
this.col = reader.ReadUInt16();
this.ixfe = reader.ReadUInt16();
this.boolValueSet = false;
long oldStreamPosition = this.Reader.BaseStream.Position;
this.val = reader.ReadBytes(8); // read 8 bytes for the value of the formular
if (this.val[6] == 0xFF && this.val[7] == 0xFF)
{
// this value is a string, an error or a boolean value
byte firstOffset = this.val[0];
if (firstOffset == 1)
{
// this is a boolean value
this.boolValue = this.val[2];
this.boolValueSet = true;
}
if (firstOffset == 2)
{
// this is a error value
this.errorValue = (int)this.val[2];
}
}
else
{
this.Reader.BaseStream.Seek(oldStreamPosition, System.IO.SeekOrigin.Begin);
this.calculatedValue = reader.ReadDouble();
}
this.grbit = reader.ReadUInt16();
this.chn = reader.ReadUInt32(); // this is used for performance reasons only
this.cce = reader.ReadUInt16();
this.ptgStack = new Stack <AbstractPtg>();
// reader.ReadBytes(this.cce);
// check always calc mode
this.fAlwaysCalc = Utils.BitmaskToBool((int)this.grbit, 0x01);
// check if shared formula
this.fShrFmla = Utils.BitmaskToBool((int)this.grbit, 0x08);
oldStreamPosition = this.Reader.BaseStream.Position;
if (!this.fShrFmla)
{
try
{
this.ptgStack = ExcelHelperClass.getFormulaStack(this.Reader, this.cce);
}
catch (Exception ex)
{
this.Reader.BaseStream.Seek(oldStreamPosition, System.IO.SeekOrigin.Begin);
this.Reader.BaseStream.Seek(this.cce, System.IO.SeekOrigin.Current);
TraceLogger.Error("Formula parse error in Row {0} Column {1}", this.rw, this.col);
TraceLogger.Debug(ex.StackTrace);
TraceLogger.Debug("Inner exception: {0}", ex.InnerException.StackTrace);
}
}
else
{
reader.ReadBytes(this.cce);
}
// assert that the correct number of bytes has been read from the stream
Debug.Assert(this.Offset + this.Length == this.Reader.BaseStream.Position);
}
public Lbl(IStreamReader reader, RecordType id, ushort length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
//Debug.Assert(this.Id == ID);
ushort flags = reader.ReadUInt16();
this.fHidden = Utils.BitmaskToBool(flags, 0x0001);
this.fFunc = Utils.BitmaskToBool(flags, 0x0002);
this.fOB = Utils.BitmaskToBool(flags, 0x0004);
this.fProc = Utils.BitmaskToBool(flags, 0x0008);
this.fCalcExp = Utils.BitmaskToBool(flags, 0x0010);
this.fBuiltin = Utils.BitmaskToBool(flags, 0x0020);
this.fGrp = Utils.BitmaskToByte(flags, 0x0FC0);
this.fReserved1 = Utils.BitmaskToBool(flags, 0x1000);
this.fPublished = Utils.BitmaskToBool(flags, 0x2000);
this.fWorkbookParam = Utils.BitmaskToBool(flags, 0x4000);
this.fReserved2 = Utils.BitmaskToBool(flags, 0x8000);
this.chKey = reader.ReadByte();
this.cch = reader.ReadByte();
this.cce = reader.ReadUInt16();
//read 2 reserved bytes
this.fReserved3 = reader.ReadUInt16();
this.itab = reader.ReadUInt16();
// read 4 reserved bytes
this.fReserved4 = reader.ReadUInt32();
//Peek at the fHighByte value to figure out if the Lbl is encrypted or not
long oldStreamPosition = this.Reader.BaseStream.Position;
bool fHighByte = Utils.BitmaskToBool(reader.ReadByte(), 0x0001);
this.Reader.BaseStream.Seek(oldStreamPosition, System.IO.SeekOrigin.Begin);
//If a lbl has garbage cce/cch values, ignore reading those values
if (this.Length != CalculateLength(fHighByte))
{
this.RawLblBytes = this.Reader.ReadBytes((int)(this.Length - LblFixedSize));
_name = new XLUnicodeStringNoCch();
_rgce = new Stack <AbstractPtg>();
return;
}
if (this.cch > 0)
{
_name = new XLUnicodeStringNoCch(reader, this.cch);
}
else
{
_name = new XLUnicodeStringNoCch();
}
oldStreamPosition = this.Reader.BaseStream.Position;
try
{
_rgce = ExcelHelperClass.getFormulaStack(this.Reader, this.cce);
}
catch (Exception ex)
{
this.Reader.BaseStream.Seek(oldStreamPosition, System.IO.SeekOrigin.Begin);
this.Reader.BaseStream.Seek(this.cce, System.IO.SeekOrigin.Current);
TraceLogger.Error("Formula parse error in intern name");
TraceLogger.Debug(ex.StackTrace);
}
// assert that the correct number of bytes has been read from the stream
Debug.Assert(this.Offset + this.Length == this.Reader.BaseStream.Position);
}
private static string ImportCellFormula(string cellFormula)
{
if (cellFormula.Length == 0)
{
return(cellFormula);
}
string newCellFormula = cellFormula;
//Unescape the "s if we are looking at a CellFormula that has been escaped
if (newCellFormula.StartsWith('"'))
{
//Strip the outer quotes
newCellFormula = new string(newCellFormula.Skip(1).Take(newCellFormula.Length - 2).ToArray());
//Escape the inside content
newCellFormula = ExcelHelperClass.UnescapeFormulaString(newCellFormula);
}
//Replace any uses of SELECT and ACTIVE.CELL with variable usage to better enable the sheet being hidden
//Mainly for use with importing EXCELntDonut macros
newCellFormula = ReplaceSelectActiveCellFormula(newCellFormula);
//FORMULA requires R1C1 strings
newCellFormula = ConvertA1StringToR1C1String(newCellFormula);
int charReplacements = 0;
//Remap CHAR() to actual bytes
for (int i = 1; i <= 255; i += 1)
{
int oldLength = newCellFormula.Length;
newCellFormula = newCellFormula.Replace(string.Format("CHAR({0})&", i), "" + (char)i);
newCellFormula = newCellFormula.Replace(string.Format("CHAR({0})", i), "" + (char)i);
//Update our poor heuristic for when we're getting a cell that is just CHAR()&CHAR()&CHAR()&CHAR()...
if (oldLength != newCellFormula.Length)
{
double lengthDelta = oldLength - newCellFormula.Length;
charReplacements += (int)Math.Floor(lengthDelta / 6.0);
}
}
//Arbitrary metric to determine if we should convert this to a string cell vs. formula cell
if (charReplacements > 3 && newCellFormula[0] == '=')
{
newCellFormula = new string(newCellFormula.Skip(1).ToArray());
//Excel cells will also check to see if we are a variable assignment cell:
//if we have valid variable letters before an =, it will process the assignment value
bool looksLikeVariableAssignment = LooksLikeVariableAssignment(newCellFormula);
//If we have a raw string content that starts with = or @, we can wrap this with ="" and it will work
//If the string content is already 255 bytes though, this won't work (FORMULA will fail trying to write the 258 byte string)
//If we're close to the limit then populate the cell with =CHAR(w/e)&Ref to cell with remainder of the content
if (newCellFormula.StartsWith('=') || newCellFormula.StartsWith('@') || looksLikeVariableAssignment)
{
//Need to make sure there's room for inserting 3 more characters =""
if (newCellFormula.Length >= 255 - 3)
{
//If this is a max length cell (common with 255 byte increments of shellcode)
//then mark the macro with a marker and we'll break it into two cells when we're building the sheet
return(FormulaHelper.TOOLONGMARKER + newCellFormula);
}
else
{
newCellFormula = string.Format("=\"{0}\"", newCellFormula);
}
}
}
else
{
//TODO Use a proper logging package and log this as DEBUG info
// Console.WriteLine(newCellFormula);
}
if (newCellFormula.Length > 255)
{
throw new ArgumentException(string.Format("Imported Cell Formula is too long - length must be 255 or less:\n{0}", newCellFormula));
}
return(newCellFormula);
}
/// <summary>
/// The overload apply method
/// Creates the Worksheet xml document
/// </summary>
/// <param name="bsd">WorkSheetData</param>
public void Apply(WorkSheetData bsd)
{
_xlsContext.CurrentSheet = bsd;
_writer.WriteStartDocument();
_writer.WriteStartElement("worksheet", OpenXmlNamespaces.SpreadsheetML);
//if (bsd.emtpyWorksheet)
//{
// _writer.WriteStartElement("sheetData");
// _writer.WriteEndElement();
//}
//else
{
// default info
if (bsd.defaultColWidth >= 0 || bsd.defaultRowHeight >= 0)
{
_writer.WriteStartElement("sheetFormatPr");
if (bsd.defaultColWidth >= 0)
{
double colWidht = (double)bsd.defaultColWidth;
_writer.WriteAttributeString("defaultColWidth", Convert.ToString(colWidht, CultureInfo.GetCultureInfo("en-US")));
}
if (bsd.defaultRowHeight >= 0)
{
TwipsValue tv = new TwipsValue(bsd.defaultRowHeight);
_writer.WriteAttributeString("defaultRowHeight", Convert.ToString(tv.ToPoints(), CultureInfo.GetCultureInfo("en-US")));
}
if (bsd.zeroHeight)
{
_writer.WriteAttributeString("zeroHeight", "1");
}
if (bsd.customHeight)
{
_writer.WriteAttributeString("customHeight", "1");
}
if (bsd.thickTop)
{
_writer.WriteAttributeString("thickTop", "1");
}
if (bsd.thickBottom)
{
_writer.WriteAttributeString("thickBottom", "1");
}
_writer.WriteEndElement(); // sheetFormatPr
}
// Col info
if (bsd.colInfoDataTable.Count > 0)
{
_writer.WriteStartElement("cols");
foreach (ColumnInfoData col in bsd.colInfoDataTable)
{
_writer.WriteStartElement("col");
// write min and max
// booth values are 0 based in the binary format and 1 based in the oxml format
// so you have to add 1 to the value!
_writer.WriteAttributeString("min", (col.min + 1).ToString());
_writer.WriteAttributeString("max", (col.max + 1).ToString());
if (col.widht != 0)
{
double colWidht = (double)col.widht / 256;
_writer.WriteAttributeString("width", Convert.ToString(colWidht, CultureInfo.GetCultureInfo("en-US")));
}
if (col.hidden)
{
_writer.WriteAttributeString("hidden", "1");
}
if (col.outlineLevel > 0)
{
_writer.WriteAttributeString("outlineLevel", col.outlineLevel.ToString());
}
if (col.customWidth)
{
_writer.WriteAttributeString("customWidth", "1");
}
if (col.bestFit)
{
_writer.WriteAttributeString("bestFit", "1");
}
if (col.phonetic)
{
_writer.WriteAttributeString("phonetic", "1");
}
if (col.style > 15)
{
_writer.WriteAttributeString("style", Convert.ToString(col.style - this._xlsContext.XlsDoc.WorkBookData.styleData.XFCellStyleDataList.Count, CultureInfo.GetCultureInfo("en-US")));
}
_writer.WriteEndElement(); // col
}
_writer.WriteEndElement();
}
// End col info
_writer.WriteStartElement("sheetData");
// bsd.rowDataTable.Values
foreach (RowData row in bsd.rowDataTable.Values)
{
// write row start tag
// Row
_writer.WriteStartElement("row");
// the rowindex from the binary format is zero based, the ooxml format is one based
_writer.WriteAttributeString("r", (row.Row + 1).ToString());
if (row.height != null)
{
_writer.WriteAttributeString("ht", Convert.ToString(row.height.ToPoints(), CultureInfo.GetCultureInfo("en-US")));
if (row.customHeight)
{
_writer.WriteAttributeString("customHeight", "1");
}
}
if (row.hidden)
{
_writer.WriteAttributeString("hidden", "1");
}
if (row.outlineLevel > 0)
{
_writer.WriteAttributeString("outlineLevel", row.outlineLevel.ToString());
}
if (row.collapsed)
{
_writer.WriteAttributeString("collapsed", "1");
}
if (row.customFormat)
{
_writer.WriteAttributeString("customFormat", "1");
if (row.style > 15)
{
_writer.WriteAttributeString("s", (row.style - this._xlsContext.XlsDoc.WorkBookData.styleData.XFCellStyleDataList.Count).ToString());
}
}
if (row.thickBot)
{
_writer.WriteAttributeString("thickBot", "1");
}
if (row.thickTop)
{
_writer.WriteAttributeString("thickTop", "1");
}
if (row.minSpan + 1 > 0 && row.maxSpan > 0 && row.minSpan + 1 < row.maxSpan)
{
_writer.WriteAttributeString("spans", (row.minSpan + 1).ToString() + ":" + row.maxSpan.ToString());
}
row.Cells.Sort();
foreach (AbstractCellData cell in row.Cells)
{
// Col
_writer.WriteStartElement("c");
_writer.WriteAttributeString("r", ExcelHelperClass.intToABCString((int)cell.Col, (cell.Row + 1).ToString()));
if (cell.TemplateID > 15)
{
_writer.WriteAttributeString("s", (cell.TemplateID - this._xlsContext.XlsDoc.WorkBookData.styleData.XFCellStyleDataList.Count).ToString());
}
if (cell is StringCell)
{
_writer.WriteAttributeString("t", "s");
}
if (cell is FormulaCell)
{
FormulaCell fcell = (FormulaCell)cell;
if (((FormulaCell)cell).calculatedValue is String)
{
_writer.WriteAttributeString("t", "str");
}
else if (((FormulaCell)cell).calculatedValue is double)
{
_writer.WriteAttributeString("t", "n");
}
else if (((FormulaCell)cell).calculatedValue is byte)
{
_writer.WriteAttributeString("t", "b");
}
else if (((FormulaCell)cell).calculatedValue is int)
{
_writer.WriteAttributeString("t", "e");
}
// <f>1</f>
_writer.WriteStartElement("f");
if (!fcell.isSharedFormula)
{
String value = FormulaInfixMapping.mapFormula(fcell.PtgStack, this._xlsContext);
if (fcell.usesArrayRecord)
{
_writer.WriteAttributeString("t", "array");
_writer.WriteAttributeString("ref", ExcelHelperClass.intToABCString((int)cell.Col, (cell.Row + 1).ToString()));
}
if (fcell.alwaysCalculated)
{
_writer.WriteAttributeString("ca", "1");
}
if (value.Equals(""))
{
TraceLogger.Debug("Formula Parse Error in Row {0}\t Column {1}\t", cell.Row.ToString(), cell.Col.ToString());
}
_writer.WriteString(value);
}
/// If this cell is part of a shared formula
///
else
{
SharedFormulaData sfd = bsd.checkFormulaIsInShared(cell.Row, cell.Col);
if (sfd != null)
{
// t="shared"
_writer.WriteAttributeString("t", "shared");
// <f t="shared" ref="C4:C11" si="0">H4+I4-J4</f>
_writer.WriteAttributeString("si", sfd.ID.ToString());
if (sfd.RefCount == 0)
{
/// Write value and reference
_writer.WriteAttributeString("ref", sfd.getOXMLFormatedData());
String value = FormulaInfixMapping.mapFormula(sfd.PtgStack, this._xlsContext, sfd.rwFirst, sfd.colFirst);
_writer.WriteString(value);
sfd.RefCount++;
}
}
else
{
TraceLogger.Debug("Formula Parse Error in Row {0}\t Column {1}\t", cell.Row.ToString(), cell.Col.ToString());
}
}
_writer.WriteEndElement();
/// write down calculated value from a formula
///
_writer.WriteStartElement("v");
if (((FormulaCell)cell).calculatedValue is int)
{
_writer.WriteString(FormulaInfixMapping.getErrorStringfromCode((int)((FormulaCell)cell).calculatedValue));
}
else
{
_writer.WriteString(Convert.ToString(((FormulaCell)cell).calculatedValue, CultureInfo.GetCultureInfo("en-US")));
}
_writer.WriteEndElement();
}
else
{// Data !!!
_writer.WriteElementString("v", cell.getValue());
}
// add a type to the c element if the formula returns following types
_writer.WriteEndElement(); // close cell (c)
}
_writer.WriteEndElement(); // close row
}
// close tags
_writer.WriteEndElement(); // close sheetData
// Add the mergecell part
//
// - <mergeCells count="2">
// <mergeCell ref="B3:C3" />
// <mergeCell ref="E3:F4" />
// </mergeCells>
if (bsd.MERGECELLSData != null)
{
_writer.WriteStartElement("mergeCells");
_writer.WriteAttributeString("count", bsd.MERGECELLSData.cmcs.ToString());
foreach (MergeCellData mcell in bsd.MERGECELLSData.mergeCellDataList)
{
_writer.WriteStartElement("mergeCell");
_writer.WriteAttributeString("ref", mcell.getOXMLFormatedData());
_writer.WriteEndElement();
}
// close mergeCells Tag
_writer.WriteEndElement();
}
// hyperlinks!
if (bsd.HyperLinkList.Count != 0)
{
_writer.WriteStartElement("hyperlinks");
bool writtenParentElement = false;
foreach (HyperlinkData link in bsd.HyperLinkList)
{
// Uri url;
// if (link.absolute)
// {
// if (link.url.StartsWith("http", true, CultureInfo.GetCultureInfo("en-US"))
// || link.url.StartsWith("mailto", true, CultureInfo.GetCultureInfo("en-US")))
// {
// url = new Uri(link.url, UriKind.Absolute);
// }
// else
// {
// link.url = "file:///" + link.url;
// url = new Uri(link.url, UriKind.Absolute);
// }
// }
// else
// {
// url = new Uri(link.url, UriKind.Relative);
// }
// try
// {
// if (System.Uri.IsWellFormedUriString(url.LocalPath.ToString(), System.UriKind.Absolute))
// {
//if (!writtenParentElement)
//{
// writtenParentElement = true;
//}
string refstring;
if (link.colLast == link.colFirst && link.rwLast == link.rwFirst)
{
refstring = ExcelHelperClass.intToABCString((int)link.colLast, (link.rwLast + 1).ToString());
}
else
{
refstring = ExcelHelperClass.intToABCString((int)link.colFirst, (link.rwFirst + 1).ToString()) + ":" + ExcelHelperClass.intToABCString((int)link.colLast, (link.rwLast + 1).ToString());
}
if (link.url != null)
{
ExternalRelationship er = this._xlsContext.SpreadDoc.WorkbookPart.GetWorksheetPart().AddExternalRelationship(OpenXmlRelationshipTypes.HyperLink, link.url.Replace(" ", ""));
_writer.WriteStartElement("hyperlink");
_writer.WriteAttributeString("ref", refstring);
_writer.WriteAttributeString("r", "id", OpenXmlNamespaces.Relationships, er.Id.ToString());
_writer.WriteEndElement();
}
else if (link.location != null)
{
_writer.WriteStartElement("hyperlink");
_writer.WriteAttributeString("ref", refstring);
_writer.WriteAttributeString("location", link.location);
if (link.display != null)
{
_writer.WriteAttributeString("display", link.display);
}
_writer.WriteEndElement();
}
/* }
* }
* catch (Exception ex)
* {
* TraceLogger.DebugInternal(ex.Message.ToString());
* TraceLogger.DebugInternal(ex.StackTrace.ToString());
* }
* }*/
}
_writer.WriteEndElement(); // hyperlinks
if (writtenParentElement)
{
}
}
// worksheet margins !!
if (bsd.leftMargin != null && bsd.topMargin != null &&
bsd.rightMargin != null && bsd.bottomMargin != null &&
bsd.headerMargin != null && bsd.footerMargin != null)
{
_writer.WriteStartElement("pageMargins");
{
_writer.WriteAttributeString("left", Convert.ToString(bsd.leftMargin, CultureInfo.GetCultureInfo("en-US")));
_writer.WriteAttributeString("right", Convert.ToString(bsd.rightMargin, CultureInfo.GetCultureInfo("en-US")));
_writer.WriteAttributeString("top", Convert.ToString(bsd.topMargin, CultureInfo.GetCultureInfo("en-US")));
_writer.WriteAttributeString("bottom", Convert.ToString(bsd.bottomMargin, CultureInfo.GetCultureInfo("en-US")));
_writer.WriteAttributeString("header", Convert.ToString(bsd.headerMargin, CultureInfo.GetCultureInfo("en-US")));
_writer.WriteAttributeString("footer", Convert.ToString(bsd.footerMargin, CultureInfo.GetCultureInfo("en-US")));
}
_writer.WriteEndElement(); // pageMargins
}
// page setup settings
if (bsd.PageSetup != null)
{
_writer.WriteStartElement("pageSetup");
if (!bsd.PageSetup.fNoPls && bsd.PageSetup.iPaperSize > 0 && bsd.PageSetup.iPaperSize < 255)
{
_writer.WriteAttributeString("paperSize", bsd.PageSetup.iPaperSize.ToString());
}
if (bsd.PageSetup.iScale >= 10 && bsd.PageSetup.iScale <= 400)
{
_writer.WriteAttributeString("scale", bsd.PageSetup.iScale.ToString());
}
_writer.WriteAttributeString("firstPageNumber", bsd.PageSetup.iPageStart.ToString());
_writer.WriteAttributeString("fitToWidth", bsd.PageSetup.iFitWidth.ToString());
_writer.WriteAttributeString("fitToHeight", bsd.PageSetup.iFitHeight.ToString());
if (bsd.PageSetup.fLeftToRight)
{
_writer.WriteAttributeString("pageOrder", "overThenDown");
}
if (!bsd.PageSetup.fNoOrient)
{
if (bsd.PageSetup.fPortrait)
{
_writer.WriteAttributeString("orientation", "portrait");
}
else
{
_writer.WriteAttributeString("orientation", "landscape");
}
}
//10 <attribute name="usePrinterDefaults" type="xsd:boolean" use="optional" default="true"/>
if (bsd.PageSetup.fNoColor)
{
_writer.WriteAttributeString("blackAndWhite", "1");
}
if (bsd.PageSetup.fDraft)
{
_writer.WriteAttributeString("draft", "1");
}
if (bsd.PageSetup.fNotes)
{
if (bsd.PageSetup.fEndNotes)
{
_writer.WriteAttributeString("cellComments", "atEnd");
}
else
{
_writer.WriteAttributeString("cellComments", "asDisplayed");
}
}
if (bsd.PageSetup.fUsePage)
{
_writer.WriteAttributeString("useFirstPageNumber", "1");
}
switch (bsd.PageSetup.iErrors)
{
case 0x00: _writer.WriteAttributeString("errors", "displayed"); break;
case 0x01: _writer.WriteAttributeString("errors", "blank"); break;
case 0x02: _writer.WriteAttributeString("errors", "dash"); break;
case 0x03: _writer.WriteAttributeString("errors", "NA"); break;
default: _writer.WriteAttributeString("errors", "displayed"); break;
}
_writer.WriteAttributeString("horizontalDpi", bsd.PageSetup.iRes.ToString());
_writer.WriteAttributeString("verticalDpi", bsd.PageSetup.iVRes.ToString());
if (!bsd.PageSetup.fNoPls)
{
_writer.WriteAttributeString("copies", bsd.PageSetup.iCopies.ToString());
}
_writer.WriteEndElement();
}
// embedded drawings (charts etc)
if (bsd.ObjectsSequence != null)
{
_writer.WriteStartElement(Sml.Sheet.ElDrawing, Sml.Ns);
{
_writer.WriteAttributeString("r", "id", OpenXmlNamespaces.Relationships, this._worksheetPart.DrawingsPart.RelIdToString);
bsd.ObjectsSequence.Convert(new DrawingMapping(this._xlsContext, this._worksheetPart.DrawingsPart, false));
}
_writer.WriteEndElement();
}
}
_writer.WriteEndElement(); // close worksheet
_writer.WriteEndDocument();
// close writer
_writer.Flush();
}
public HLink(IStreamReader reader, RecordType id, ushort length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
Debug.Assert(this.Id == ID);
this.rwFirst = this.Reader.ReadUInt16();
this.rwLast = this.Reader.ReadUInt16();
this.colFirst = this.Reader.ReadUInt16();
this.colLast = this.Reader.ReadUInt16();
this.hlinkClsid = new byte[16];
// read 16 bytes hlinkClsid
this.hlinkClsid = this.Reader.ReadBytes(16);
this.streamVersion = this.Reader.ReadUInt32();
uint buffer = this.Reader.ReadUInt32();
bool hlstmfHasMoniker = Utils.BitmaskToBool(buffer, 0x01);
this.hlstmfIsAbsolute = Utils.BitmaskToBool(buffer, 0x02);
bool hlstmfSiteGaveDisplayName = Utils.BitmaskToBool(buffer, 0x04);
bool hlstmfHasLocationStr = Utils.BitmaskToBool(buffer, 0x08);
bool hlstmfHasDisplayName = Utils.BitmaskToBool(buffer, 0x10);
bool hlstmfHasGUID = Utils.BitmaskToBool(buffer, 0x20);
bool hlstmfHasCreationTime = Utils.BitmaskToBool(buffer, 0x40);
bool hlstmfHasFrameName = Utils.BitmaskToBool(buffer, 0x80);
bool hlstmfMonikerSavedAsStr = Utils.BitmaskToBool(buffer, 0x100);
bool hlstmfAbsFromGetdataRel = Utils.BitmaskToBool(buffer, 0x200);
if (hlstmfHasDisplayName)
{
this.displayName = ExcelHelperClass.getHyperlinkStringFromBiffRecord(this.Reader);
}
if (hlstmfHasFrameName)
{
this.targetFrameName = ExcelHelperClass.getHyperlinkStringFromBiffRecord(this.Reader);
}
if (hlstmfHasMoniker)
{
if (hlstmfMonikerSavedAsStr)
{
this.monikerString = ExcelHelperClass.getHyperlinkStringFromBiffRecord(this.Reader);
}
else
{
// OleMoniker
// read monikerClsid
uint Part1MonikerClsid = this.Reader.ReadUInt32();
ushort Part2MonikerClsid = this.Reader.ReadUInt16();
ushort Part3MonikerClsid = this.Reader.ReadUInt16();
byte Part4MonikerClsid = this.Reader.ReadByte();
byte Part5MonikerClsid = this.Reader.ReadByte();
byte Part6MonikerClsid = this.Reader.ReadByte();
byte Part7MonikerClsid = this.Reader.ReadByte();
byte Part8MonikerClsid = this.Reader.ReadByte();
byte Part9MonikerClsid = this.Reader.ReadByte();
byte Part10MonikerClsid = this.Reader.ReadByte();
byte Part11MonikerClsid = this.Reader.ReadByte();
// URL Moniker
if (Part1MonikerClsid == 0x79EAC9E0)
{
uint lenght = reader.ReadUInt32();
string value = "";
// read until the \0 value
do
{
value += System.BitConverter.ToChar(reader.ReadBytes(2), 0);
} while (value[value.Length - 1] != '\0');
if (value.Length * 2 != lenght)
{
// read guid serial version and uriflags
this.Reader.ReadBytes(24);
}
value = value.Remove(value.Length - 1);
this.monikerString = value;
}
else if (Part1MonikerClsid == 0x00000303)
{
ushort cAnti = this.Reader.ReadUInt16();
uint ansiLength = this.Reader.ReadUInt32();
string ansiPath = "";
for (int i = 0; i < ansiLength; i++)
{
ansiPath += (char)reader.ReadByte();
}
ansiPath = ansiPath.Remove(ansiPath.Length - 1);
ushort endServer = this.Reader.ReadUInt16();
ushort versionNumber = this.Reader.ReadUInt16();
this.monikerString = ansiPath;
// read 20 unused bytes
this.Reader.ReadBytes(20);
uint cbUnicodePathSize = this.Reader.ReadUInt32();
//string unicodePath = "";
if (cbUnicodePathSize != 0)
{
uint cbUnicodePathBytes = this.Reader.ReadUInt32();
ushort usKeyValue = this.Reader.ReadUInt16();
string value = "";
for (int i = 0; i < cbUnicodePathBytes / 2; i++)
{
value += System.BitConverter.ToChar(reader.ReadBytes(2), 0);
}
this.monikerString = value;
}
}
//byte[] monikerClsid = this.Reader.ReadBytes(16);
//string monikerid = "";
//for (int i = 0; i < monikerClsid.Length; i++)
//{
// monikerid = monikerid + monikerClsid[i].ToString();
//}
}
}
if (hlstmfHasLocationStr)
{
this.location = ExcelHelperClass.getHyperlinkStringFromBiffRecord(this.Reader);
}
if (hlstmfHasGUID)
{
this.guid = this.Reader.ReadBytes(16);
}
if (hlstmfHasCreationTime)
{
this.fileTime = this.Reader.ReadBytes(8);
}
}
/// <summary>
/// The overload apply method
/// Creates the Workbook xml document
/// </summary>
/// <param name="bsd">WorkSheetData</param>
public void Apply(WorkBookData workbookData)
{
this._writer.WriteStartDocument();
this._writer.WriteStartElement("workbook", OpenXmlNamespaces.SpreadsheetML);
this._writer.WriteAttributeString("xmlns", Sml.Ns);
this._writer.WriteAttributeString("xmlns", "r", "", OpenXmlNamespaces.Relationships);
// fileVersion
this._writer.WriteStartElement(Sml.Workbook.ElFileVersion, Sml.Ns);
this._writer.WriteAttributeString(Sml.Workbook.AttrAppName, "xl");
this._writer.WriteEndElement();
// workbookPr
this._writer.WriteStartElement(Sml.Workbook.ElWorkbookPr, Sml.Ns);
if (workbookData.CodeName != null)
{
this._writer.WriteAttributeString(Sml.Workbook.AttrCodeName, workbookData.CodeName.codeName.Value);
}
this._writer.WriteEndElement();
this._writer.WriteStartElement("sheets");
// create the sheets
foreach (var sheet in workbookData.boundSheetDataList)
{
OpenXmlPart sheetPart;
switch (sheet.boundsheetRecord.dt)
{
case BoundSheet8.SheetType.Worksheet:
{
var worksheetPart = this._workbookPart.AddWorksheetPart();
sheet.Convert(new WorksheetMapping(this._xlsContext, worksheetPart));
sheetPart = worksheetPart;
}
break;
case BoundSheet8.SheetType.Chartsheet:
{
var chartsheetPart = this._workbookPart.AddChartsheetPart();
sheet.Convert(new ChartsheetMapping(this._xlsContext, chartsheetPart));
sheetPart = chartsheetPart;
}
break;
default:
{
sheet.emtpyWorksheet = true;
var worksheetPart = this._workbookPart.AddWorksheetPart();
sheet.Convert(new WorksheetMapping(this._xlsContext, worksheetPart));
sheetPart = worksheetPart;
}
break;
}
this._writer.WriteStartElement("sheet");
this._writer.WriteAttributeString("name", sheet.boundsheetRecord.stName.Value);
this._writer.WriteAttributeString("sheetId", sheetPart.RelId.ToString());
this._writer.WriteAttributeString("r", "id", OpenXmlNamespaces.Relationships, sheetPart.RelIdToString);
this._writer.WriteEndElement();
}
this._writer.WriteEndElement(); // close sheetData
bool ParentTagWritten = false;
if (workbookData.supBookDataList.Count != 0)
{
/*
* <externalReferences>
* <externalReference r:id="rId4" />
* <externalReference r:id="rId5" />
* </externalReferences>
*/
foreach (var var in workbookData.supBookDataList)
{
if (!var.SelfRef)
{
if (!ParentTagWritten)
{
this._writer.WriteStartElement("externalReferences");
ParentTagWritten = true;
}
this._writer.WriteStartElement("externalReference");
this._writer.WriteAttributeString("r", "id", OpenXmlNamespaces.Relationships, var.ExternalLinkRef);
this._writer.WriteEndElement();
}
}
if (ParentTagWritten)
{
this._writer.WriteEndElement();
}
}
// write definedNames
if (workbookData.definedNameList.Count > 0)
{
//<definedNames>
//<definedName name="abc" comment="test" localSheetId="1">Sheet1!$B$3</definedName>
//</definedNames>
this._writer.WriteStartElement("definedNames");
foreach (var item in workbookData.definedNameList)
{
if (item.rgce.Count > 0)
{
this._writer.WriteStartElement("definedName");
if (item.Name.Value.Length > 1)
{
this._writer.WriteAttributeString("name", item.Name.Value);
}
else
{
string internName = "_xlnm." + ExcelHelperClass.getNameStringfromBuiltInFunctionID(item.Name.Value);
this._writer.WriteAttributeString("name", internName);
}
if (item.itab > 0)
{
this._writer.WriteAttributeString("localSheetId", (item.itab - 1).ToString());
}
this._writer.WriteValue(FormulaInfixMapping.mapFormula(item.rgce, this._xlsContext));
this._writer.WriteEndElement();
}
}
this._writer.WriteEndElement();
}
// close tags
this._writer.WriteEndElement(); // close worksheet
this._writer.WriteEndDocument();
// flush writer
this._writer.Flush();
}
