/// <summary>
/// Creates the lowerlevel OBJ records for this shape.
/// </summary>
/// <param name="hssfShape">The HSSF shape.</param>
/// <param name="shapeId">The shape id.</param>
/// <returns></returns>
private ObjRecord CreateObjRecord(HSSFShape hssfShape, int shapeId)
{
HSSFShape shape = hssfShape;
ObjRecord obj = new ObjRecord();
CommonObjectDataSubRecord c = new CommonObjectDataSubRecord();
c.ObjectType = (CommonObjectType)((HSSFSimpleShape)shape).ShapeType;
c.ObjectId = shapeId;
c.IsLocked = true;
c.IsPrintable = true;
c.IsAutoFill = true;
c.IsAutoline = true;
EndSubRecord e = new EndSubRecord();
obj.AddSubRecord(c);
obj.AddSubRecord(e);
return(obj);
}
/// <summary>
/// Creates the lowerlevel OBJ records for this shape.
/// </summary>
/// <param name="hssfShape">The HSSF shape.</param>
/// <param name="shapeId">The shape id.</param>
/// <returns></returns>
private ObjRecord CreateObjRecord(HSSFShape hssfShape, int shapeId)
{
HSSFShape shape = hssfShape;
ObjRecord obj = new ObjRecord();
CommonObjectDataSubRecord c = new CommonObjectDataSubRecord();
c.ObjectType = CommonObjectType.MICROSOFT_OFFICE_DRAWING;
c.ObjectId = shapeId;
c.IsLocked = true;
c.IsPrintable = true;
c.IsAutoFill = true;
c.IsAutoline = true;
EndSubRecord e = new EndSubRecord();
obj.AddSubRecord(c);
obj.AddSubRecord(e);
return(obj);
}
protected override ObjRecord CreateObjRecord()
{
ObjRecord obj = new ObjRecord();
CommonObjectDataSubRecord c = new CommonObjectDataSubRecord();
c.ObjectType = CommonObjectType.ComboBox;
c.IsLocked = (true);
c.IsPrintable = (false);
c.IsAutoFill = (true);
c.IsAutoline = (false);
FtCblsSubRecord f = new FtCblsSubRecord();
LbsDataSubRecord l = LbsDataSubRecord.CreateAutoFilterInstance();
EndSubRecord e = new EndSubRecord();
obj.AddSubRecord(c);
obj.AddSubRecord(f);
obj.AddSubRecord(l);
obj.AddSubRecord(e);
return(obj);
}
/**
* No NullPointerException should appear
*/
public void TestDefaultSettingsWithEmptyContainer()
{
EscherContainerRecord Container = new EscherContainerRecord();
EscherOptRecord opt = new EscherOptRecord();
opt.RecordId = (EscherOptRecord.RECORD_ID);
Container.AddChildRecord(opt);
ObjRecord obj = new ObjRecord();
CommonObjectDataSubRecord cod = new CommonObjectDataSubRecord();
cod.ObjectType = (CommonObjectType)(HSSFSimpleShape.OBJECT_TYPE_PICTURE);
obj.AddSubRecord(cod);
HSSFPicture picture = new HSSFPicture(Container, obj);
Assert.AreEqual(picture.LineWidth, HSSFShape.LINEWIDTH_DEFAULT);
Assert.AreEqual(picture.FillColor, HSSFShape.FILL__FILLCOLOR_DEFAULT);
Assert.AreEqual(picture.LineStyle, HSSFShape.LINESTYLE_DEFAULT);
Assert.AreEqual(picture.LineStyleColor, HSSFShape.LINESTYLE__COLOR_DEFAULT);
Assert.AreEqual(picture.IsNoFill, HSSFShape.NO_FILL_DEFAULT);
Assert.AreEqual(picture.PictureIndex, -1);//not Set yet
}
internal HSSFShape CloneShape(HSSFPatriarch patriarch)
{
EscherContainerRecord spgrContainer = new EscherContainerRecord();
spgrContainer.RecordId = (EscherContainerRecord.SPGR_CONTAINER);
spgrContainer.Options = ((short)0x000F);
EscherContainerRecord spContainer = new EscherContainerRecord();
EscherContainerRecord cont = (EscherContainerRecord)GetEscherContainer().GetChildById(EscherContainerRecord.SP_CONTAINER);
byte[] inSp = cont.Serialize();
spContainer.FillFields(inSp, 0, new DefaultEscherRecordFactory());
spgrContainer.AddChildRecord(spContainer);
ObjRecord obj = null;
if (null != this.GetObjRecord())
{
obj = (ObjRecord)this.GetObjRecord().CloneViaReserialise();
}
HSSFShapeGroup group = new HSSFShapeGroup(spgrContainer, obj);
group.Patriarch = patriarch;
foreach (HSSFShape shape in Children)
{
HSSFShape newShape;
if (shape is HSSFShapeGroup)
{
newShape = ((HSSFShapeGroup)shape).CloneShape(patriarch);
}
else
{
newShape = shape.CloneShape();
}
group.AddShape(newShape);
group.OnCreate(newShape);
}
return(group);
}
/**
* Creates the low level OBJ record for this shape.
*/
private ObjRecord CreateObjRecord(HSSFSimpleShape shape, int shapeId)
{
ObjRecord obj = new ObjRecord();
CommonObjectDataSubRecord c = new CommonObjectDataSubRecord();
c.ObjectType = CommonObjectType.COMBO_BOX;
c.ObjectId = (short)shapeId;
c.IsLocked = (true);
c.IsPrintable = false;
c.IsAutoFill = true;
c.IsAutoline = false;
LbsDataSubRecord l = LbsDataSubRecord.CreateAutoFilterInstance();
EndSubRecord e = new EndSubRecord();
obj.AddSubRecord(c);
obj.AddSubRecord(l);
obj.AddSubRecord(e);
return(obj);
}
public void TestWayTooMuchPAdding_bug46545()
{
byte[] data = HexRead.ReadFromString(""
+ "15 00 12 00 14 00 13 00 01 21 00 00 00"
+ "00 98 0B 5B 09 00 00 00 00 0C 00 14 00 00 00 00 00 00 00 00"
+ "00 00 00 01 00 01 00 00 00 10 00 00 00 "
// ftLbs
+ "13 00 EE 1F 00 00 "
+ "01 00 00 00 01 06 00 00 02 00 08 00 75 00 "
// ftEnd
+ "00 00 00 00"
);
int LBS_START_POS = 0x002E;
int WRONG_LBS_SIZE = 0x1FEE;
Assert.AreEqual(0x0013, LittleEndian.GetShort(data, LBS_START_POS + 0));
Assert.AreEqual(WRONG_LBS_SIZE, LittleEndian.GetShort(data, LBS_START_POS + 2));
int wrongTotalSize = LBS_START_POS + 4 + WRONG_LBS_SIZE;
byte[] wrongData = new byte[wrongTotalSize];
Array.Copy(data, 0, wrongData, 0, data.Length);
// wrongData has the ObjRecord data as would have been written by v3.1
RecordInputStream in1 = TestcaseRecordInputStream.Create(ObjRecord.sid, wrongData);
ObjRecord or;
try
{
or = new ObjRecord(in1);
}
catch (RecordFormatException e)
{
if (e.Message.StartsWith("Leftover 8154 bytes in subrecord data"))
{
throw new AssertionException("Identified bug 46545");
}
throw e;
}
// make sure POI properly tRuncates the ObjRecord data
byte[] data2 = or.Serialize();
TestcaseRecordInputStream.ConfirmRecordEncoding(ObjRecord.sid, data, data2);
}
public void Test_Remove_padding()
{
byte[] data = HexRead.ReadFromString(
"5D, 00, 4C, 00, " +
"15, 00, 12, 00, 12, 00, 01, 00, 11, 00, " +
"00, 00, 00, 00, 00, 00, 00, 00, 00, 00, " +
"00, 00, 0C, 00, 14, 00, 00, 00, 00, 00, " +
"00, 00, 00, 00, 00, 00, 01, 00, 09, 00, " +
"00, 00, 0F, 00, 01, 00, " +
"13, 00, 1B, 00, " +
"10, 00, " + //next 16 bytes is a ptg aray
"09, 00, 00, 00, 00, 00, 25, 09, 00, 0C, 00, 07, 00, 07, 00, 00, " +
"01, 00, " + //num lines
"00, 00, " + //selected
"08, 00, " +
"00, 00, " +
"00, 00, 00, 00, 00"); //pAdding bytes
RecordInputStream in1 = TestcaseRecordInputStream.Create(data);
// check read OK
ObjRecord record = new ObjRecord(in1);
// check that it re-Serializes to the same data
byte[] ser = record.Serialize();
Assert.AreEqual(data.Length - 5, ser.Length);
for (int i = 0; i < ser.Length; i++)
{
Assert.AreEqual(data[i], ser[i]);
}
//check we can read the Trimmed record
RecordInputStream in2 = TestcaseRecordInputStream.Create(ser);
ObjRecord record2 = new ObjRecord(in2);
byte[] ser2 = record2.Serialize();
Assert.IsTrue(Arrays.Equals(ser, ser2));
}
public HSSFShapeGroup(EscherContainerRecord spgrContainer, ObjRecord objRecord)
: base(spgrContainer, objRecord)
{
// read internal and external coordinates from spgrContainer
EscherContainerRecord spContainer = spgrContainer.ChildContainers[0];
_spgrRecord = (EscherSpgrRecord)spContainer.GetChild(0);
foreach (EscherRecord ch in spContainer.ChildRecords)
{
switch (ch.RecordId)
{
case EscherSpgrRecord.RECORD_ID:
break;
case EscherClientAnchorRecord.RECORD_ID:
anchor = new HSSFClientAnchor((EscherClientAnchorRecord)ch);
break;
case EscherChildAnchorRecord.RECORD_ID:
anchor = new HSSFChildAnchor((EscherChildAnchorRecord)ch);
break;
}
}
}
public void Test_45778()
{
byte[] data = HexRead.ReadFromString(
"15, 00, 12, 00, 14, 00, 01, 00, 01, 00, " +
"01, 21, 00, 00, 3C, 13, F4, 03, 00, 00, " +
"00, 00, 0C, 00, 14, 00, 00, 00, 00, 00, " +
"00, 00, 00, 00, 00, 00, 01, 00, 08, 00, 00, " +
"00, 10, 00, 00, 00, " +
"13, 00, EE, 1F, " +
"00, 00, " +
"08, 00, " + //number of items
"08, 00, " + //selected item
"01, 03, " + //flags
"00, 00, " + //objId
//LbsDropData
"0A, 00, " + //flags
"14, 00, " + //the number of lines to be displayed in the dropdown
"6C, 00, " + //the smallest width in pixels allowed for the dropdown window
"00, 00, " + //num chars
"00, 00");
RecordInputStream in1 = TestcaseRecordInputStream.Create(ObjRecord.sid, data);
// check read OK
ObjRecord record = new ObjRecord(in1);
SubRecord sr = record.SubRecords[(2)];
Assert.IsTrue(sr is LbsDataSubRecord);
LbsDataSubRecord lbs = (LbsDataSubRecord)sr;
Assert.AreEqual(8, lbs.NumberOfItems);
Assert.IsNull(lbs.Formula);
// check that it re-Serializes to the same data
byte[] ser = record.Serialize();
TestcaseRecordInputStream.ConfirmRecordEncoding(ObjRecord.sid, data, ser);
}
public void TestResultEqualsToAbstractShape()
{
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sh = wb.CreateSheet() as HSSFSheet;
HSSFPatriarch patriarch = sh.CreateDrawingPatriarch() as HSSFPatriarch;
HSSFComment comment = patriarch.CreateCellComment(new HSSFClientAnchor()) as HSSFComment;
HSSFRow row = sh.CreateRow(0) as HSSFRow;
HSSFCell cell = row.CreateCell(0) as HSSFCell;
cell.CellComment = (comment);
CommentShape commentShape = HSSFTestModelHelper.CreateCommentShape(1025, comment);
Assert.AreEqual(comment.GetEscherContainer().ChildRecords.Count, 5);
Assert.AreEqual(commentShape.SpContainer.ChildRecords.Count, 5);
//sp record
byte[] expected = commentShape.SpContainer.GetChild(0).Serialize();
byte[] actual = comment.GetEscherContainer().GetChild(0).Serialize();
Assert.AreEqual(expected.Length, actual.Length);
Assert.IsTrue(Arrays.Equals(expected, actual));
expected = commentShape.SpContainer.GetChild(2).Serialize();
actual = comment.GetEscherContainer().GetChild(2).Serialize();
Assert.AreEqual(expected.Length, actual.Length);
Assert.IsTrue(Arrays.Equals(expected, actual));
expected = commentShape.SpContainer.GetChild(3).Serialize();
actual = comment.GetEscherContainer().GetChild(3).Serialize();
Assert.AreEqual(expected.Length, actual.Length);
Assert.IsTrue(Arrays.Equals(expected, actual));
expected = commentShape.SpContainer.GetChild(4).Serialize();
actual = comment.GetEscherContainer().GetChild(4).Serialize();
Assert.AreEqual(expected.Length, actual.Length);
Assert.IsTrue(Arrays.Equals(expected, actual));
ObjRecord obj = comment.GetObjRecord();
ObjRecord objShape = commentShape.ObjRecord;
expected = obj.Serialize();
actual = objShape.Serialize();
Assert.AreEqual(expected.Length, actual.Length);
//assertArrayEquals(expected, actual);
TextObjectRecord tor = comment.GetTextObjectRecord();
TextObjectRecord torShape = commentShape.TextObjectRecord;
expected = tor.Serialize();
actual = torShape.Serialize();
Assert.AreEqual(expected.Length, actual.Length);
Assert.IsTrue(Arrays.Equals(expected, actual));
NoteRecord note = comment.NoteRecord;
NoteRecord noteShape = commentShape.NoteRecord;
expected = note.Serialize();
actual = noteShape.Serialize();
Assert.AreEqual(expected.Length, actual.Length);
Assert.IsTrue(Arrays.Equals(expected, actual));
wb.Close();
}
public HSSFPicture(EscherContainerRecord spContainer, ObjRecord objRecord)
: base(spContainer, objRecord)
{
}
public HSSFObjectData(EscherContainerRecord spContainer, ObjRecord objRecord, DirectoryEntry _root)
: base(spContainer, objRecord)
{
this._root = _root;
}
/**
* Constructs object data by wrapping a lower level object record.
*
* @param record the low-level object record.
* @param poifs the filesystem, required for retrieving the object data.
*/
public HSSFObjectData(ObjRecord record, POIFSFileSystem poifs)
{
this.record = record;
this.poifs = poifs;
}
public HSSFPolygon(EscherContainerRecord spContainer, ObjRecord objRecord)
: base(spContainer, objRecord)
{
}
/**
* Constructs object data by wrapping a lower level object record.
*
* @param record the low-level object record.
* @param poifs the filesystem, required for retrieving the object data.
*/
public HSSFObjectData(ObjRecord record, DirectoryEntry root)
{
this.record = record;
_root = root;
}
/// <summary>
/// Creates the low evel records for an polygon.
/// </summary>
/// <param name="hssfShape">The highlevel shape.</param>
/// <param name="shapeId">The shape id to use for this shape.</param>
public PolygonShape(HSSFPolygon hssfShape, int shapeId)
{
spContainer = CreateSpContainer(hssfShape, shapeId);
objRecord = CreateObjRecord(hssfShape, shapeId);
}
/**
* build shape tree from escher container
* @param container root escher container from which escher records must be taken
* @param agg - EscherAggregate
* @param out - shape container to which shapes must be added
* @param root - node to create HSSFObjectData shapes
*/
public static void CreateShapeTree(EscherContainerRecord container, EscherAggregate agg,
HSSFShapeContainer out1, DirectoryNode root)
{
if (container.RecordId == EscherContainerRecord.SPGR_CONTAINER)
{
ObjRecord obj = null;
EscherClientDataRecord clientData = (EscherClientDataRecord)((EscherContainerRecord)container.GetChild(0)).GetChildById(EscherClientDataRecord.RECORD_ID);
if (null != clientData)
{
obj = (ObjRecord)agg.GetShapeToObjMapping()[clientData];
}
HSSFShapeGroup group = new HSSFShapeGroup(container, obj);
IList <EscherContainerRecord> children = container.ChildContainers;
// skip the first child record, it is group descriptor
for (int i = 0; i < children.Count; i++)
{
EscherContainerRecord spContainer = children[(i)];
if (i != 0)
{
CreateShapeTree(spContainer, agg, group, root);
}
}
out1.AddShape(group);
}
else if (container.RecordId == EscherContainerRecord.SP_CONTAINER)
{
Dictionary <EscherRecord, Record.Record> shapeToObj = agg.GetShapeToObjMapping();
ObjRecord objRecord = null;
TextObjectRecord txtRecord = null;
foreach (EscherRecord record in container.ChildRecords)
{
switch (record.RecordId)
{
case EscherClientDataRecord.RECORD_ID:
objRecord = (ObjRecord)shapeToObj[(record)];
break;
case EscherTextboxRecord.RECORD_ID:
txtRecord = (TextObjectRecord)shapeToObj[(record)];
break;
}
}
if (IsEmbeddedObject(objRecord))
{
HSSFObjectData objectData = new HSSFObjectData(container, objRecord, root);
out1.AddShape(objectData);
return;
}
CommonObjectDataSubRecord cmo = (CommonObjectDataSubRecord)objRecord.SubRecords[0];
HSSFShape shape;
switch (cmo.ObjectType)
{
case CommonObjectType.Picture:
shape = new HSSFPicture(container, objRecord);
break;
case CommonObjectType.Rectangle:
shape = new HSSFSimpleShape(container, objRecord, txtRecord);
break;
case CommonObjectType.Line:
shape = new HSSFSimpleShape(container, objRecord);
break;
case CommonObjectType.ComboBox:
shape = new HSSFCombobox(container, objRecord);
break;
case CommonObjectType.MicrosoftOfficeDrawing:
EscherOptRecord optRecord = (EscherOptRecord)container.GetChildById(EscherOptRecord.RECORD_ID);
EscherProperty property = optRecord.Lookup(EscherProperties.GEOMETRY__VERTICES);
if (null != property)
{
shape = new HSSFPolygon(container, objRecord, txtRecord);
}
else
{
shape = new HSSFSimpleShape(container, objRecord, txtRecord);
}
break;
case CommonObjectType.Text:
shape = new HSSFTextbox(container, objRecord, txtRecord);
break;
case CommonObjectType.Comment:
shape = new HSSFComment(container, objRecord, txtRecord, agg.GetNoteRecordByObj(objRecord));
break;
default:
shape = new HSSFSimpleShape(container, objRecord, txtRecord);
break;
}
out1.AddShape(shape);
}
}
/// <summary> Reads in the contents of this sheet</summary>
internal void read()
{
Record r = null;
BaseSharedFormulaRecord sharedFormula = null;
bool sharedFormulaAdded = false;
bool cont = true;
// Set the position within the file
excelFile.Pos = startPosition;
// Handles to the last drawing and obj records
MsoDrawingRecord msoRecord = null;
ObjRecord objRecord = null;
// A handle to window2 record
Window2Record window2Record = null;
// A handle to printgridlines record
PrintGridLinesRecord printGridLinesRecord = null;
// A handle to printheaders record
PrintHeadersRecord printHeadersRecord = null;
while (cont)
{
r = excelFile.next();
if (r.Type == NExcel.Biff.Type.UNKNOWN && r.Code == 0)
{
//System.Console.Error.Write("Warning: biff code zero found");
// Try a dimension record
if (r.Length == 0xa)
{
logger.warn("Biff code zero found - trying a dimension record.");
r.Type = (NExcel.Biff.Type.DIMENSION);
}
else
{
logger.warn("Biff code zero found - Ignoring.");
}
}
if (r.Type == NExcel.Biff.Type.DIMENSION)
{
DimensionRecord dr = null;
if (workbookBof.isBiff8())
{
dr = new DimensionRecord(r);
}
else
{
dr = new DimensionRecord(r, DimensionRecord.biff7);
}
numRows = dr.NumberOfRows;
numCols = dr.NumberOfColumns;
cells = new Cell[numRows][];
for (int i = 0; i < numRows; i++)
{
cells[i] = new Cell[numCols];
}
}
else if (r.Type == NExcel.Biff.Type.LABELSST)
{
LabelSSTRecord label = new LabelSSTRecord(r, sharedStrings, formattingRecords, sheet);
addCell(label);
}
else if (r.Type == NExcel.Biff.Type.RK || r.Type == NExcel.Biff.Type.RK2)
{
RKRecord rkr = new RKRecord(r, formattingRecords, sheet);
if (formattingRecords.isDate(rkr.XFIndex))
{
DateCell dc = new DateRecord(rkr, rkr.XFIndex, formattingRecords, nineteenFour, sheet);
addCell(dc);
}
else
{
addCell(rkr);
}
}
else if (r.Type == NExcel.Biff.Type.HLINK)
{
HyperlinkRecord hr = new HyperlinkRecord(r, sheet, workbookSettings);
hyperlinks.Add(hr);
}
else if (r.Type == NExcel.Biff.Type.MERGEDCELLS)
{
MergedCellsRecord mc = new MergedCellsRecord(r, sheet);
if (mergedCells == null)
{
mergedCells = mc.Ranges;
}
else
{
Range[] newMergedCells = new Range[mergedCells.Length + mc.Ranges.Length];
Array.Copy(mergedCells, 0, newMergedCells, 0, mergedCells.Length);
Array.Copy(mc.Ranges, 0, newMergedCells, mergedCells.Length, mc.Ranges.Length);
mergedCells = newMergedCells;
}
}
else if (r.Type == NExcel.Biff.Type.MULRK)
{
MulRKRecord mulrk = new MulRKRecord(r);
// Get the individual cell records from the multiple record
int num = mulrk.NumberOfColumns;
int ixf = 0;
for (int i = 0; i < num; i++)
{
ixf = mulrk.getXFIndex(i);
NumberValue nv = new NumberValue(mulrk.Row, mulrk.FirstColumn + i, RKHelper.getDouble(mulrk.getRKNumber(i)), ixf, formattingRecords, sheet);
if (formattingRecords.isDate(ixf))
{
DateCell dc = new DateRecord(nv, ixf, formattingRecords, nineteenFour, sheet);
addCell(dc);
}
else
{
nv.setNumberFormat(formattingRecords.getNumberFormat(ixf));
addCell(nv);
}
}
}
else if (r.Type == NExcel.Biff.Type.NUMBER)
{
NumberRecord nr = new NumberRecord(r, formattingRecords, sheet);
if (formattingRecords.isDate(nr.XFIndex))
{
DateCell dc = new DateRecord(nr, nr.XFIndex, formattingRecords, nineteenFour, sheet);
addCell(dc);
}
else
{
addCell(nr);
}
}
else if (r.Type == NExcel.Biff.Type.BOOLERR)
{
BooleanRecord br = new BooleanRecord(r, formattingRecords, sheet);
if (br.Error)
{
ErrorRecord er = new ErrorRecord(br.getRecord(), formattingRecords, sheet);
addCell(er);
}
else
{
addCell(br);
}
}
else if (r.Type == NExcel.Biff.Type.PRINTGRIDLINES)
{
printGridLinesRecord = new PrintGridLinesRecord(r);
settings.PrintGridLines = (printGridLinesRecord.PrintGridLines);
}
else if (r.Type == NExcel.Biff.Type.PRINTHEADERS)
{
printHeadersRecord = new PrintHeadersRecord(r);
settings.PrintHeaders = (printHeadersRecord.PrintHeaders);
}
else if (r.Type == NExcel.Biff.Type.WINDOW2)
{
window2Record = new Window2Record(r);
settings.ShowGridLines = (window2Record.ShowGridLines);
settings.DisplayZeroValues = (window2Record.DisplayZeroValues);
settings.setSelected();
}
else if (r.Type == NExcel.Biff.Type.PANE)
{
PaneRecord pr = new PaneRecord(r);
if (window2Record != null && window2Record.Frozen && window2Record.FrozenNotSplit)
{
settings.VerticalFreeze = (pr.RowsVisible);
settings.HorizontalFreeze = (pr.ColumnsVisible);
}
}
else if (r.Type == NExcel.Biff.Type.CONTINUE)
{
;
}
else if (r.Type == NExcel.Biff.Type.NOTE)
{
;
}
else if (r.Type == NExcel.Biff.Type.ARRAY)
{
;
}
else if (r.Type == NExcel.Biff.Type.PROTECT)
{
ProtectRecord pr = new ProtectRecord(r);
settings.Protected = (pr.IsProtected());
}
else if (r.Type == NExcel.Biff.Type.SHAREDFORMULA)
{
if (sharedFormula == null)
{
logger.warn("Shared template formula is null - " + "trying most recent formula template");
SharedFormulaRecord lastSharedFormula = (SharedFormulaRecord)sharedFormulas[sharedFormulas.Count - 1];
if (lastSharedFormula != null)
{
sharedFormula = lastSharedFormula.TemplateFormula;
}
}
SharedFormulaRecord sfr = new SharedFormulaRecord(r, sharedFormula, workbook, workbook, sheet);
sharedFormulas.Add(sfr);
sharedFormula = null;
}
else if (r.Type == NExcel.Biff.Type.FORMULA || r.Type == NExcel.Biff.Type.FORMULA2)
{
FormulaRecord fr = new FormulaRecord(r, excelFile, formattingRecords, workbook, workbook, sheet, workbookSettings);
if (fr.Shared)
{
BaseSharedFormulaRecord prevSharedFormula = sharedFormula;
sharedFormula = (BaseSharedFormulaRecord)fr.Formula;
// See if it fits in any of the shared formulas
sharedFormulaAdded = addToSharedFormulas(sharedFormula);
if (sharedFormulaAdded)
{
sharedFormula = prevSharedFormula;
}
// If we still haven't added the previous base shared formula,
// revert it to an ordinary formula and add it to the cell
if (!sharedFormulaAdded && prevSharedFormula != null)
{
// Do nothing. It's possible for the biff file to contain the
// record sequence
// FORMULA-SHRFMLA-FORMULA-SHRFMLA-FORMULA-FORMULA-FORMULA
// ie. it first lists all the formula templates, then it
// lists all the individual formulas
addCell(revertSharedFormula(prevSharedFormula));
}
}
else
{
Cell cell = fr.Formula;
// See if the formula evaluates to date
if (fr.Formula.Type == CellType.NUMBER_FORMULA)
{
NumberFormulaRecord nfr = (NumberFormulaRecord)fr.Formula;
if (formattingRecords.isDate(nfr.XFIndex))
{
cell = new DateFormulaRecord(nfr, formattingRecords, workbook, workbook, nineteenFour, sheet);
}
}
addCell(cell);
}
}
else if (r.Type == NExcel.Biff.Type.LABEL)
{
LabelRecord lr = null;
if (workbookBof.isBiff8())
{
lr = new LabelRecord(r, formattingRecords, sheet, workbookSettings);
}
else
{
lr = new LabelRecord(r, formattingRecords, sheet, workbookSettings, LabelRecord.biff7);
}
addCell(lr);
}
else if (r.Type == NExcel.Biff.Type.RSTRING)
{
RStringRecord lr = null;
// RString records are obsolete in biff 8
Assert.verify(!workbookBof.isBiff8());
lr = new RStringRecord(r, formattingRecords, sheet, workbookSettings, RStringRecord.biff7);
addCell(lr);
}
else if (r.Type == NExcel.Biff.Type.NAME)
{
;
}
else if (r.Type == NExcel.Biff.Type.PASSWORD)
{
PasswordRecord pr = new PasswordRecord(r);
settings.PasswordHash = (pr.PasswordHash);
}
else if (r.Type == NExcel.Biff.Type.ROW)
{
RowRecord rr = new RowRecord(r);
// See if the row has anything funny about it
if (!rr.isDefaultHeight() || rr.isCollapsed() || rr.isZeroHeight())
{
rowProperties.Add(rr);
}
}
else if (r.Type == NExcel.Biff.Type.BLANK)
{
BlankCell bc = new BlankCell(r, formattingRecords, sheet);
addCell(bc);
}
else if (r.Type == NExcel.Biff.Type.MULBLANK)
{
MulBlankRecord mulblank = new MulBlankRecord(r);
// Get the individual cell records from the multiple record
int num = mulblank.NumberOfColumns;
for (int i = 0; i < num; i++)
{
int ixf = mulblank.getXFIndex(i);
MulBlankCell mbc = new MulBlankCell(mulblank.Row, mulblank.FirstColumn + i, ixf, formattingRecords, sheet);
addCell(mbc);
}
}
else if (r.Type == NExcel.Biff.Type.SCL)
{
SCLRecord scl = new SCLRecord(r);
settings.ZoomFactor = (scl.ZoomFactor);
}
else if (r.Type == NExcel.Biff.Type.COLINFO)
{
ColumnInfoRecord cir = new ColumnInfoRecord(r);
columnInfosArray.Add(cir);
}
else if (r.Type == NExcel.Biff.Type.HEADER)
{
HeaderRecord hr = null;
if (workbookBof.isBiff8())
{
hr = new HeaderRecord(r, workbookSettings);
}
else
{
hr = new HeaderRecord(r, workbookSettings, HeaderRecord.biff7);
}
NExcel.HeaderFooter header = new NExcel.HeaderFooter(hr.Header);
settings.Header = (header);
}
else if (r.Type == NExcel.Biff.Type.FOOTER)
{
FooterRecord fr = null;
if (workbookBof.isBiff8())
{
fr = new FooterRecord(r, workbookSettings);
}
else
{
fr = new FooterRecord(r, workbookSettings, FooterRecord.biff7);
}
NExcel.HeaderFooter footer = new NExcel.HeaderFooter(fr.Footer);
settings.Footer = (footer);
}
else if (r.Type == NExcel.Biff.Type.SETUP)
{
SetupRecord sr = new SetupRecord(r);
if (sr.isPortrait())
{
settings.Orientation = (PageOrientation.PORTRAIT);
}
else
{
settings.Orientation = (PageOrientation.LANDSCAPE);
}
settings.PaperSize = (PaperSize.getPaperSize(sr.PaperSize));
settings.HeaderMargin = (sr.HeaderMargin);
settings.FooterMargin = (sr.FooterMargin);
settings.ScaleFactor = (sr.ScaleFactor);
settings.PageStart = (sr.PageStart);
settings.FitWidth = (sr.FitWidth);
settings.FitHeight = (sr.FitHeight);
settings.HorizontalPrintResolution = (sr.HorizontalPrintResolution);
settings.VerticalPrintResolution = (sr.VerticalPrintResolution);
settings.Copies = (sr.Copies);
if (workspaceOptions != null)
{
settings.FitToPages = (workspaceOptions.FitToPages);
}
}
else if (r.Type == NExcel.Biff.Type.WSBOOL)
{
workspaceOptions = new WorkspaceInformationRecord(r);
}
else if (r.Type == NExcel.Biff.Type.DEFCOLWIDTH)
{
DefaultColumnWidthRecord dcwr = new DefaultColumnWidthRecord(r);
settings.DefaultColumnWidth = (dcwr.Width);
}
else if (r.Type == NExcel.Biff.Type.DEFAULTROWHEIGHT)
{
DefaultRowHeightRecord drhr = new DefaultRowHeightRecord(r);
if (drhr.Height != 0)
{
settings.DefaultRowHeight = (drhr.Height);
}
}
else if (r.Type == NExcel.Biff.Type.LEFTMARGIN)
{
MarginRecord m = new LeftMarginRecord(r);
settings.LeftMargin = (m.Margin);
}
else if (r.Type == NExcel.Biff.Type.RIGHTMARGIN)
{
MarginRecord m = new RightMarginRecord(r);
settings.RightMargin = (m.Margin);
}
else if (r.Type == NExcel.Biff.Type.TOPMARGIN)
{
MarginRecord m = new TopMarginRecord(r);
settings.TopMargin = (m.Margin);
}
else if (r.Type == NExcel.Biff.Type.BOTTOMMARGIN)
{
MarginRecord m = new BottomMarginRecord(r);
settings.BottomMargin = (m.Margin);
}
else if (r.Type == NExcel.Biff.Type.HORIZONTALPAGEBREAKS)
{
HorizontalPageBreaksRecord dr = null;
if (workbookBof.isBiff8())
{
dr = new HorizontalPageBreaksRecord(r);
}
else
{
dr = new HorizontalPageBreaksRecord(r, HorizontalPageBreaksRecord.biff7);
}
rowBreaks = dr.RowBreaks;
}
else if (r.Type == NExcel.Biff.Type.PLS)
{
plsRecord = new PLSRecord(r);
}
else if (r.Type == NExcel.Biff.Type.OBJ)
{
objRecord = new ObjRecord(r);
if (objRecord.Type == ObjRecord.PICTURE && !workbookSettings.DrawingsDisabled)
{
if (msoRecord == null)
{
logger.warn("object record is not associated with a drawing " + " record - ignoring");
}
else
{
Drawing drawing = new Drawing(msoRecord, objRecord, workbook.DrawingGroup);
drawings.Add(drawing);
}
msoRecord = null;
objRecord = null;
}
}
else if (r.Type == NExcel.Biff.Type.MSODRAWING)
{
msoRecord = new MsoDrawingRecord(r);
}
else if (r.Type == NExcel.Biff.Type.BOF)
{
BOFRecord br = new BOFRecord(r);
Assert.verify(!br.isWorksheet());
int startpos = excelFile.Pos - r.Length - 4;
// Skip to the end of the nested bof
// Thanks to Rohit for spotting this
Record r2 = excelFile.next();
while (r2.Code != NExcel.Biff.Type.EOF.Value)
{
r2 = excelFile.next();
}
if (br.isChart())
{
Chart chart = new Chart(msoRecord, objRecord, startpos, excelFile.Pos, excelFile, workbookSettings);
charts.Add(chart);
if (workbook.DrawingGroup != null)
{
workbook.DrawingGroup.add(chart);
}
// Reset the drawing records
msoRecord = null;
objRecord = null;
}
// If this worksheet is just a chart, then the EOF reached
// represents the end of the sheet as well as the end of the chart
if (sheetBof.isChart())
{
cont = false;
}
}
else if (r.Type == NExcel.Biff.Type.EOF)
{
cont = false;
}
}
// Restore the file to its accurate position
excelFile.restorePos();
// Add all the shared formulas to the sheet as individual formulas
foreach (SharedFormulaRecord sfr in sharedFormulas)
{
Cell[] sfnr = sfr.getFormulas(formattingRecords, nineteenFour);
for (int sf = 0; sf < sfnr.Length; sf++)
{
addCell(sfnr[sf]);
}
}
// If the last base shared formula wasn't added to the sheet, then
// revert it to an ordinary formula and add it
if (!sharedFormulaAdded && sharedFormula != null)
{
addCell(revertSharedFormula(sharedFormula));
}
}
public HSSFTextbox(EscherContainerRecord spContainer, ObjRecord objRecord, TextObjectRecord textObjectRecord)
: base(spContainer, objRecord, textObjectRecord)
{
}
//private TextObjectRecord txo = null;
public HSSFComment(EscherContainerRecord spContainer, ObjRecord objRecord, TextObjectRecord textObjectRecord, NoteRecord _note)
: base(spContainer, objRecord, textObjectRecord)
{
this._note = _note;
}
public void ResultEqualsToNonExistingAbstractShape()
{
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sh = wb.CreateSheet() as HSSFSheet;
HSSFPatriarch patriarch = sh.CreateDrawingPatriarch() as HSSFPatriarch;
HSSFComment comment = patriarch.CreateCellComment(new HSSFClientAnchor()) as HSSFComment;
HSSFRow row = sh.CreateRow(0) as HSSFRow;
HSSFCell cell = row.CreateCell(0) as HSSFCell;
cell.CellComment = (comment);
Assert.AreEqual(comment.GetEscherContainer().ChildRecords.Count, 5);
//sp record
byte[] expected = TestDrawingAggregate.decompress("H4sIAAAAAAAAAFvEw/WBg4GBgZEFSHAxMAAA9gX7nhAAAAA=");
byte[] actual = comment.GetEscherContainer().GetChild(0).Serialize();
Assert.AreEqual(expected.Length, actual.Length);
Assert.IsTrue(Arrays.Equals(expected, actual));
expected = TestDrawingAggregate.decompress("H4sIAAAAAAAAAGNgEPggxIANAABK4+laGgAAAA==");
actual = comment.GetEscherContainer().GetChild(2).Serialize();
Assert.AreEqual(expected.Length, actual.Length);
Assert.IsTrue(Arrays.Equals(expected, actual));
expected = TestDrawingAggregate.decompress("H4sIAAAAAAAAAGNgEPzAAAQACl6c5QgAAAA=");
actual = comment.GetEscherContainer().GetChild(3).Serialize();
Assert.AreEqual(expected.Length, actual.Length);
Assert.IsTrue(Arrays.Equals(expected, actual));
expected = TestDrawingAggregate.decompress("H4sIAAAAAAAAAGNg4P3AAAQA6pyIkQgAAAA=");
actual = comment.GetEscherContainer().GetChild(4).Serialize();
Assert.AreEqual(expected.Length, actual.Length);
Assert.IsTrue(Arrays.Equals(expected, actual));
ObjRecord obj = comment.GetObjRecord();
expected = TestDrawingAggregate.decompress("H4sIAAAAAAAAAItlMGEQZRBikGRgZBF0YEACvAxiDLgBAJZsuoU4AAAA");
actual = obj.Serialize();
Assert.AreEqual(expected.Length, actual.Length);
//assertArrayEquals(expected, actual);
TextObjectRecord tor = comment.GetTextObjectRecord();
expected = TestDrawingAggregate.decompress("H4sIAAAAAAAAANvGKMQgxMSABgBGi8T+FgAAAA==");
actual = tor.Serialize();
Assert.AreEqual(expected.Length, actual.Length);
Assert.IsTrue(Arrays.Equals(expected, actual));
NoteRecord note = comment.NoteRecord;
expected = TestDrawingAggregate.decompress("H4sIAAAAAAAAAJNh4GGAAEYWEAkAS0KXuRAAAAA=");
actual = note.Serialize();
Assert.AreEqual(expected.Length, actual.Length);
Assert.IsTrue(Arrays.Equals(expected, actual));
wb.Close();
}
public void TestCreateAggregate()
{
string msoDrawingRecord1 =
"0F 00 02 F0 20 01 00 00 10 00 08 F0 08 00 00 00 \n" +
"03 00 00 00 02 04 00 00 0F 00 03 F0 08 01 00 00 \n" +
"0F 00 04 F0 28 00 00 00 01 00 09 F0 10 00 00 00 \n" +
"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 \n" +
"02 00 0A F0 08 00 00 00 00 04 00 00 05 00 00 00 \n" +
"0F 00 04 F0 64 00 00 00 42 01 0A F0 08 00 00 00 \n" +
"01 04 00 00 00 0A 00 00 73 00 0B F0 2A 00 00 00 \n" +
"BF 00 08 00 08 00 44 01 04 00 00 00 7F 01 00 00 \n" +
"01 00 BF 01 00 00 11 00 C0 01 40 00 00 08 FF 01 \n" +
"10 00 10 00 BF 03 00 00 08 00 00 00 10 F0 12 00 \n" +
"00 00 00 00 01 00 54 00 05 00 45 00 01 00 88 03 \n" +
"05 00 94 00 00 00 11 F0 00 00 00 00";
string msoDrawingRecord2 =
"0F 00 04 F0 64 00 00 00 42 01 0A F0 08 00 00 00 " +
"02 04 00 00 80 0A 00 00 73 00 0B F0 2A 00 00 00 " +
"BF 00 08 00 08 00 44 01 04 00 00 00 7F 01 00 00 " +
"01 00 BF 01 00 00 11 00 C0 01 40 00 00 08 FF 01 " +
"10 00 10 00 BF 03 00 00 08 00 00 00 10 F0 12 00 " +
"00 00 00 00 01 00 8D 03 05 00 E4 00 03 00 4D 03 " +
"0B 00 0C 00 00 00 11 F0 00 00 00 00";
DrawingRecord d1 = new DrawingRecord();
d1.Data = HexRead.ReadFromString(msoDrawingRecord1);
ObjRecord r1 = new ObjRecord();
DrawingRecord d2 = new DrawingRecord();
d2.Data = (HexRead.ReadFromString(msoDrawingRecord2));
TextObjectRecord r2 = new TextObjectRecord();
r2.Str = (new HSSFRichTextString("Aggregated"));
NoteRecord n2 = new NoteRecord();
List <RecordBase> recordStream = new List <RecordBase>();
recordStream.Add(InternalSheet.CreateBOF());
recordStream.Add(d1);
recordStream.Add(r1);
recordStream.Add(CreateWindow2Record());
recordStream.Add(EOFRecord.instance);
ConfirmAggregatedRecords(recordStream);
recordStream = new List <RecordBase>();
recordStream.Add(InternalSheet.CreateBOF());
recordStream.Add(d1);
recordStream.Add(r1);
recordStream.Add(d2);
recordStream.Add(r2);
recordStream.Add(CreateWindow2Record());
recordStream.Add(EOFRecord.instance);
ConfirmAggregatedRecords(recordStream);
recordStream = new List <RecordBase>();
recordStream.Add(InternalSheet.CreateBOF());
recordStream.Add(d1);
recordStream.Add(r1);
recordStream.Add(d2);
recordStream.Add(r2);
recordStream.Add(n2);
recordStream.Add(CreateWindow2Record());
recordStream.Add(EOFRecord.instance);
ConfirmAggregatedRecords(recordStream);
}
public HSSFCombobox(EscherContainerRecord spContainer, ObjRecord objRecord)
: base(spContainer, objRecord)
{
}
/// <summary>
/// Creates the low evel records for a textbox.
/// </summary>
/// <param name="hssfShape">The highlevel shape.</param>
/// <param name="shapeId">The shape id to use for this shape.</param>
public TextboxShape(HSSFTextbox hssfShape, int shapeId)
{
spContainer = CreateSpContainer(hssfShape, shapeId);
objRecord = CreateObjRecord(hssfShape, shapeId);
textObjectRecord = CreateTextObjectRecord(hssfShape, shapeId);
}
/**
* Adds a new OLE Package Shape
*
* @param anchor the client anchor describes how this picture is
* attached to the sheet.
* @param storageId the storageId returned by {@Link HSSFWorkbook.AddOlePackage}
* @param pictureIndex the index of the picture (used as preview image) in the
* workbook collection of pictures.
*
* @return newly Created shape
*/
public HSSFObjectData CreateObjectData(HSSFClientAnchor anchor, int storageId, int pictureIndex)
{
ObjRecord obj = new ObjRecord();
CommonObjectDataSubRecord ftCmo = new CommonObjectDataSubRecord();
ftCmo.ObjectType = (/*setter*/ CommonObjectType.Picture);
// ftCmo.ObjectId=(/*setter*/oleShape.ShapeId); ... will be Set by onCreate(...)
ftCmo.IsLocked = (/*setter*/ true);
ftCmo.IsPrintable = (/*setter*/ true);
ftCmo.IsAutoFill = (/*setter*/ true);
ftCmo.IsAutoline = (/*setter*/ true);
ftCmo.Reserved1 = (/*setter*/ 0);
ftCmo.Reserved2 = (/*setter*/ 0);
ftCmo.Reserved3 = (/*setter*/ 0);
obj.AddSubRecord(ftCmo);
// FtCf (pictFormat)
FtCfSubRecord ftCf = new FtCfSubRecord();
HSSFPictureData pictData = Sheet.Workbook.GetAllPictures()[(pictureIndex - 1)] as HSSFPictureData;
switch ((PictureType)pictData.Format)
{
case PictureType.WMF:
case PictureType.EMF:
// this needs patch #49658 to be applied to actually work
ftCf.Flags = (/*setter*/ FtCfSubRecord.METAFILE_BIT);
break;
case PictureType.DIB:
case PictureType.PNG:
case PictureType.JPEG:
case PictureType.PICT:
ftCf.Flags = (/*setter*/ FtCfSubRecord.BITMAP_BIT);
break;
}
obj.AddSubRecord(ftCf);
// FtPioGrbit (pictFlags)
FtPioGrbitSubRecord ftPioGrbit = new FtPioGrbitSubRecord();
ftPioGrbit.SetFlagByBit(FtPioGrbitSubRecord.AUTO_PICT_BIT, true);
obj.AddSubRecord(ftPioGrbit);
EmbeddedObjectRefSubRecord ftPictFmla = new EmbeddedObjectRefSubRecord();
ftPictFmla.SetUnknownFormulaData(new byte[] { 2, 0, 0, 0, 0 });
ftPictFmla.OLEClassName = (/*setter*/ "Paket");
ftPictFmla.SetStorageId(storageId);
obj.AddSubRecord(ftPictFmla);
obj.AddSubRecord(new EndSubRecord());
String entryName = "MBD" + HexDump.ToHex(storageId);
DirectoryEntry oleRoot;
try
{
DirectoryNode dn = (_sheet.Workbook as HSSFWorkbook).RootDirectory;
if (dn == null)
{
throw new FileNotFoundException();
}
oleRoot = (DirectoryEntry)dn.GetEntry(entryName);
}
catch (FileNotFoundException e)
{
throw new InvalidOperationException("trying to add ole shape without actually Adding data first - use HSSFWorkbook.AddOlePackage first", e);
}
// create picture shape, which need to be minimal modified for oleshapes
HSSFPicture shape = new HSSFPicture(null, anchor);
shape.PictureIndex = (/*setter*/ pictureIndex);
EscherContainerRecord spContainer = shape.GetEscherContainer();
EscherSpRecord spRecord = spContainer.GetChildById(EscherSpRecord.RECORD_ID) as EscherSpRecord;
spRecord.Flags = (/*setter*/ spRecord.Flags | EscherSpRecord.FLAG_OLESHAPE);
HSSFObjectData oleShape = new HSSFObjectData(spContainer, obj, oleRoot);
AddShape(oleShape);
OnCreate(oleShape);
return(oleShape);
}
public HSSFPolygon(EscherContainerRecord spContainer, ObjRecord objRecord, TextObjectRecord _textObjectRecord)
: base(spContainer, objRecord, _textObjectRecord)
{
}
public HSSFSimpleShape(EscherContainerRecord spContainer, ObjRecord objRecord, TextObjectRecord textObjectRecord)
: base(spContainer, objRecord)
{
this._textObjectRecord = textObjectRecord;
}
/// <summary>
/// Creates the line shape from the highlevel user shape. All low level
/// records are Created at this point.
/// </summary>
/// <param name="hssfShape">The user model shape</param>
/// <param name="shapeId">The identifier to use for this shape.</param>
public LineShape(HSSFSimpleShape hssfShape, int shapeId)
{
spContainer = CreateSpContainer(hssfShape, shapeId);
objRecord = CreateObjRecord(hssfShape, shapeId);
}
public HSSFSimpleShape(EscherContainerRecord spContainer, ObjRecord objRecord)
: base(spContainer, objRecord)
{
}
