Attachment #28899 for bug #53372

View | Details | Raw Unified | Return to bug 53372
Collapse All | Expand All

Lines 18-23 Link Here

(-)src/testcases/org/apache/poi/hssf/usermodel/HSSFTestHelper.java (-1 / +6 lines)
18	package org.apache.poi.hssf.usermodel;	18	package org.apache.poi.hssf.usermodel;
19	import org.apache.poi.hssf.model.InternalSheet;	19	import org.apache.poi.hssf.model.InternalSheet;
20	import org.apache.poi.hssf.model.InternalWorkbook;	20	import org.apache.poi.hssf.model.InternalWorkbook;
		21	import org.apache.poi.hssf.record.EscherAggregate;
21		22
22	/**	23	/**
23	* Helper class for HSSF tests that aren't within the	24	* Helper class for HSSF tests that aren't within the
Lines 33-37 Link Here
33	}	34	}
34	public static InternalSheet getSheetForTest(HSSFSheet sheet) {	35	public static InternalSheet getSheetForTest(HSSFSheet sheet) {
35	return sheet.getSheet();	36	return sheet.getSheet();
36	}	37	}
		38
		39	public static HSSFPatriarch createTestPatriarch(HSSFSheet sheet, EscherAggregate agg){
		40	return new HSSFPatriarch(sheet, agg);
		41	}
37	}	42	}




package org.apache.poi.hssf.model;

import junit.framework.TestCase;
import org.apache.poi.ddf.EscherContainerRecord;
import org.apache.poi.ddf.EscherDggRecord;
import org.apache.poi.ddf.EscherRecord;
import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.hssf.record.*;
import org.apache.poi.hssf.record.aggregates.RowRecordsAggregate;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.hssf.usermodel.HSSFTestHelper;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.util.HexRead;

import java.io.*;

 * @author Evgeniy Berlog
 */
public class TestDrawingAggregate extends TestCase {

    private int spgrCount = 0;
    private int spCount = 0;
    private int shapeCount = 0;
    private int shGroupCount = 0;

    /*
     * EscherAggregate must have for each SpgrContainer HSSFShapeGroup and for each SpContainer HSSFShape
     */
    private void checkEscherAndShapesCount(EscherAggregate agg, HSSFSheet sheet) {
        HSSFPatriarch patriarch = HSSFTestHelper.createTestPatriarch(sheet, agg);
        agg.setPatriarch(patriarch);
        EscherAggregate.createShapeTree(EscherAggregate.getMainSpgrContainer(agg), agg.getPatriarch(), agg);
        EscherContainerRecord mainContainer = EscherAggregate.getMainSpgrContainer(agg);
        calculateShapesCount(agg.getPatriarch());
        calculateEscherContainersCount(mainContainer);

        assertEquals(spgrCount, shGroupCount);
        assertEquals(spCount - spgrCount - 1, shapeCount);
    }

    private void calculateEscherContainersCount(EscherContainerRecord spgr) {
        for (EscherRecord record : spgr.getChildRecords()) {
            if (EscherContainerRecord.SP_CONTAINER == record.getRecordId()) {
                spCount++;
                continue;
            }
            if (EscherContainerRecord.SPGR_CONTAINER == record.getRecordId()) {
                spgrCount++;
                calculateEscherContainersCount((EscherContainerRecord) record);
            }
        }
    }

    private void calculateShapesCount(HSSFShapeContainer group) {
        for (HSSFShape shape : (List<HSSFShape>) group.getChildren()) {
            if (shape instanceof HSSFShapeGroup) {
                shGroupCount++;
                calculateShapesCount((HSSFShapeGroup) shape);
            } else {
                shapeCount++;
            }
        }
    }


    private static byte[] toByteArray(List<RecordBase> records) {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        for (RecordBase rb : records) {
            Record r = (Record) rb;
                            out.write(r.serialize());
            try {
                out.write(r.serialize());
            } catch (IOException e) {
                        }
                }
            return out.toByteArray();
        }
                throw new RuntimeException(e);
            }
        }
        return out.toByteArray();
    }

    public void testSolverContainerMustBeSavedDuringSerialization(){
        HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("SolverContainerAfterSPGR.xls");
        HSSFSheet sh = wb.getSheetAt(0);
        InternalSheet ish = HSSFTestHelper.getSheetForTest(sh);
        sh.getDrawingPatriarch();
        EscherAggregate agg = (EscherAggregate) ish.findFirstRecordBySid(EscherAggregate.sid);
        assertEquals(agg.getEscherRecords().get(0).getChildRecords().size(), 3);
        assertEquals(agg.getEscherRecords().get(0).getChild(2).getRecordId(), EscherContainerRecord.SOLVER_CONTAINER);
        wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
        sh = wb.getSheetAt(0);
        sh.getDrawingPatriarch();
        ish = HSSFTestHelper.getSheetForTest(sh);
        agg = (EscherAggregate) ish.findFirstRecordBySid(EscherAggregate.sid);
        assertEquals(agg.getEscherRecords().get(0).getChildRecords().size(), 3);
        assertEquals(agg.getEscherRecords().get(0).getChild(2).getRecordId(), EscherContainerRecord.SOLVER_CONTAINER);

    }

    /**
     * test reading drawing aggregate from a test file from Bugzilla 45129
     */

        byte[] dgBytesAfterSave = agg.serialize();
        assertEquals("different size of drawing data before and after save", dgBytes.length, dgBytesAfterSave.length);
        assertTrue("drawing data brefpore and after save is different", Arrays.equals(dgBytes, dgBytesAfterSave));
        checkEscherAndShapesCount(agg, sh);
    }

    /**

        assertEquals("different size of drawing data before and after save", dgBytes.length, dgBytesAfterSave.length);
        assertTrue("drawing data before and after save is different", Arrays.equals(dgBytes, dgBytesAfterSave));

        checkEscherAndShapesCount(agg, sh);
    }



        List<RecordBase> records = isheet.getRecords();

        HSSFWorkbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb);
        InternalSheet isheet2 = HSSFTestHelper.getSheetForTest(wb2.getSheetAt(0));
        List<RecordBase> records2 = isheet2.getRecords();

        assertEquals(records.size(), records2.size());
        for (int i = 0; i < records.size(); i++) {
            RecordBase r1 = records.get(i);
            RecordBase r2 = records2.get(i);
            assertTrue(r1.getClass() == r2.getClass());
            assertEquals(r1.getRecordSize(), r2.getRecordSize());
            if (r1 instanceof Record) {
                assertEquals(((Record) r1).getSid(), ((Record) r2).getSid());
                assertTrue(Arrays.equals(((Record) r1).serialize(), ((Record) r2).serialize()));
            }
        }

    }

    public void testSerializeDrawingWithComments() throws IOException {

        byte[] dgBytesAfterSave = agg.serialize();
        assertEquals("different size of drawing data before and after save", dgBytes.length, dgBytesAfterSave.length);
        assertTrue("drawing data before and after save is different", Arrays.equals(dgBytes, dgBytesAfterSave));
        checkEscherAndShapesCount(agg, sh);
    }




        byte[] dgBytesAfterSave = agg.serialize();
        assertEquals("different size of drawing data before and after save", dgBytes.length, dgBytesAfterSave.length);
        assertTrue("drawing data before and after save is different", Arrays.equals(dgBytes, dgBytesAfterSave));
        checkEscherAndShapesCount(agg, sh);
    }

    public void testUnhandledContinue() {

Lines 17-22 Link Here

(-)src/java/org/apache/poi/hssf/usermodel/HSSFShape.java (-2 / +20 lines)
17		17
18	package org.apache.poi.hssf.usermodel;	18	package org.apache.poi.hssf.usermodel;
19		19
		20	import org.apache.poi.ddf.EscherContainerRecord;
		21	import org.apache.poi.hssf.record.ObjRecord;
		22
20	/**	23	/**
21	* An abstract shape.	24	* An abstract shape.
22	*	25	*
Lines 40-46 Link Here
40	public static final int LINESTYLE_NONE = -1;	43	public static final int LINESTYLE_NONE = -1;
41		44
42	// TODO - make all these fields private	45	// TODO - make all these fields private
43	final HSSFShape parent;	46	HSSFShape parent;
44	HSSFAnchor anchor;	47	HSSFAnchor anchor;
45	HSSFPatriarch _patriarch;	48	HSSFPatriarch _patriarch;
46	private int _lineStyleColor = 0x08000040;	49	private int _lineStyleColor = 0x08000040;
Lines 49-61 Link Here
49	private int _lineStyle = LINESTYLE_SOLID;	52	private int _lineStyle = LINESTYLE_SOLID;
50	private boolean _noFill = false;	53	private boolean _noFill = false;
51		54
		55	private EscherContainerRecord spContainer;
		56	private ObjRecord objRecord;
		57
		58	public HSSFShape(EscherContainerRecord spContainer, ObjRecord objRecord){
		59	this.spContainer = spContainer;
		60	this.objRecord = objRecord;
		61	}
52	/**	62	/**
53	* Create a new shape with the specified parent and anchor.	63	* Create a new shape with the specified parent and anchor.
54	*/	64	*/
55	HSSFShape( HSSFShape parent, HSSFAnchor anchor )	65	public HSSFShape( HSSFShape parent, HSSFAnchor anchor )
56	{	66	{
57	this.parent = parent;	67	this.parent = parent;
58	this.anchor = anchor;	68	this.anchor = anchor;
		69	}
		70
		71	public EscherContainerRecord getSpContainer() {
		72	return spContainer;
		73	}
		74
		75	public ObjRecord getObjRecord() {
		76	return objRecord;
59	}	77	}
60		78
61	/**	79	/**




package org.apache.poi.hssf.usermodel;

import org.apache.poi.ddf.EscherContainerRecord;
import org.apache.poi.ddf.EscherRecord;
import org.apache.poi.ddf.EscherSpgrRecord;
import org.apache.poi.hssf.record.ObjRecord;
/**
 * @author evgeniy
 *         date: 05.06.12
 */
public class HSSFShapeFactory {

    public static HSSFShape createShape(EscherRecord container, ObjRecord objRecord){
        if (0 == container.getChildRecords().size()){
            throw new IllegalArgumentException("Couldn't create shape from empty escher container");
        }
        if (container.getChild(0) instanceof EscherSpgrRecord){
            return new HSSFShapeGroup((EscherContainerRecord) container, objRecord);
        }

        //TODO implement cases for all shapes
        return new HSSFUnknownShape(container, objRecord);
    }

    public static HSSFShapeGroup createShapeGroup(){
        return null;
    }

    public static HSSFShapeGroup createSimpleShape(EscherRecord container, ObjRecord objRecord){
        return null;
    }
}





        _patriarch = new HSSFPatriarch(this, agg);
        agg.setPatriarch(_patriarch);
        EscherAggregate.createShapeTree(EscherAggregate.getMainSpgrContainer(agg), agg.getPatriarch(), agg);

        // Have it process the records into high level objects
        //  as best it can do (this step may eat anything
        //  that isn't supported, you were warned...)
//        agg.convertRecordsToUserModel();

        // Return what we could cope with
        return _patriarch;




package org.apache.poi.hssf.usermodel;

import org.apache.poi.ddf.EscherContainerRecord;
import org.apache.poi.ddf.EscherRecord;
import org.apache.poi.hssf.record.ObjRecord;

/**
 * @author Evgeniy Berlog
 * date: 05.06.12
 */
public class HSSFUnknownShape extends HSSFShape {

    public HSSFUnknownShape(EscherRecord spContainer, ObjRecord objRecord) {
        super((EscherContainerRecord) spContainer, objRecord);
    }
}

Lines 17-22 Link Here

(-)src/java/org/apache/poi/hssf/usermodel/HSSFShapeGroup.java (+6 lines)
17		17
18	package org.apache.poi.hssf.usermodel;	18	package org.apache.poi.hssf.usermodel;
19		19
		20	import org.apache.poi.ddf.EscherContainerRecord;
		21	import org.apache.poi.hssf.record.ObjRecord;
		22
20	import java.util.ArrayList;	23	import java.util.ArrayList;
21	import java.util.List;	24	import java.util.List;
22	import java.util.Iterator;	25	import java.util.Iterator;
Lines 37-42 Link Here
37	int x2 = 1023;	40	int x2 = 1023;
38	int y2 = 255;	41	int y2 = 255;
39		42
		43	public HSSFShapeGroup(EscherContainerRecord spContainer, ObjRecord objRecord) {
		44	super(spContainer, objRecord);
		45	}
40		46
41	public HSSFShapeGroup( HSSFShape parent, HSSFAnchor anchor )	47	public HSSFShapeGroup( HSSFShape parent, HSSFAnchor anchor )
42	{	48	{




import org.apache.poi.hssf.model.ConvertAnchor;
import org.apache.poi.hssf.model.DrawingManager2;
import org.apache.poi.hssf.model.TextboxShape;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.hssf.usermodel.HSSFShapeFactory;
import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
import org.apache.poi.hssf.usermodel.HSSFPatriarch;
import org.apache.poi.hssf.usermodel.HSSFPicture;
import org.apache.poi.hssf.usermodel.HSSFShape;
import org.apache.poi.hssf.usermodel.HSSFShapeContainer;
import org.apache.poi.hssf.usermodel.HSSFShapeGroup;
import org.apache.poi.hssf.usermodel.HSSFSimpleShape;
import org.apache.poi.hssf.usermodel.HSSFTextbox;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;


        }

        // Decode the shapes
        // agg.escherRecords = new ArrayList();
        int pos = 0;
        while (pos < buffer.size()) {
            EscherRecord r = recordFactory.createRecord(buffer.toByteArray(), pos);

        records.subList(locFirstDrawingRecord, locLastDrawingRecord).clear();
        records.add(locFirstDrawingRecord, agg);


        return agg;
    }

    public static EscherContainerRecord getMainSpgrContainer(EscherAggregate agg){
        EscherContainerRecord topContainer = agg.getEscherContainer();
        return topContainer.getChildContainers().get(0);
    }

    public static void createShapeTree(EscherContainerRecord container, HSSFShapeContainer shapeGroup, EscherAggregate agg){
        for (EscherRecord record: container.getChildRecords()){
            if (record instanceof EscherContainerRecord){
                if (EscherContainerRecord.SP_CONTAINER == record.getRecordId()){
                    if (record.getChild(0) instanceof EscherSpgrRecord){
                        //TODO set properties for HSSFDrawingPatriarch
                        continue;
                    }
                    shapeGroup.addShape(HSSFShapeFactory.createShape(record, (ObjRecord) agg.shapeToObj.get(container.getChildById(EscherClientDataRecord.RECORD_ID))));
                    continue;
                }
                if (EscherContainerRecord.SPGR_CONTAINER == record.getRecordId()){
                    EscherContainerRecord spContainer = (EscherContainerRecord) container.getChild(0);
                    HSSFShapeGroup group = (HSSFShapeGroup) HSSFShapeFactory.createShape(spContainer, (ObjRecord) agg.shapeToObj.get(spContainer.getChildById(EscherClientDataRecord.RECORD_ID)));
                    shapeGroup.addShape(group);
                    createShapeTree((EscherContainerRecord)record, group, agg);
                }
            }
        }
    }

    /**
     * Serializes this aggregate to a byte array.  Since this is an aggregate
     * record it will effectively serialize the aggregated records.

     * @return The number of bytes serialized.
     */
    public int serialize(int offset, byte[] data) {
//        convertUserModelToRecords();

        // Determine buffer size
        List records = getEscherRecords();


                public void afterRecordSerialize(int offset, short recordId, int size, EscherRecord record) {
                    if (recordId == EscherClientDataRecord.RECORD_ID || recordId == EscherTextboxRecord.RECORD_ID) {
                        spEndingOffsets.add(offset);
                        shapes.add(record);
                    }
                }

        pos = offset;
        int writtenEscherBytes = 0;
        for (int i = 1; i < shapes.size(); i++) {
            int endOffset;
            if (i == shapes.size()-1){
                endOffset = buffer.length - 1;
            } else {
                endOffset = (Integer) spEndingOffsets.get(i) - 1;
            }
            int startOffset;
            if (i == 1)
                startOffset = 0;
            else
                startOffset = (Integer) spEndingOffsets.get(i - 1);


            byte[] drawingData = new byte[endOffset - startOffset + 1];


    public int getRecordSize() {
        // TODO - convert this to RecordAggregate
//        convertUserModelToRecords();
        // To determine size of aggregate record we have to know size of each DrawingRecord because if DrawingRecord
        // is split into several continue records we have to add header size to total EscherAggregate size
        int continueRecordsHeadersSize = 0;

Lines 31-34 Link Here

(-)src/java/org/apache/poi/hssf/usermodel/HSSFShapeContainer.java (+6 lines)
31	*/	31	*/
32	List getChildren();	32	List getChildren();
33		33
		34	/**
		35	* add shape to the list of child records
		36	* @param shape
		37	*/
		38	public void addShape(HSSFShape shape);
		39
34	}	40	}

Return to bug 53372

Lines 1739-1749 Link Here

(-)src/java/org/apache/poi/hssf/usermodel/HSSFSheet.java (-1 / +2 lines)
1739		1739
1740	_patriarch = new HSSFPatriarch(this, agg);	1740	_patriarch = new HSSFPatriarch(this, agg);
1741	agg.setPatriarch(_patriarch);	1741	agg.setPatriarch(_patriarch);
		1742	EscherAggregate.createShapeTree(EscherAggregate.getMainSpgrContainer(agg), agg.getPatriarch(), agg);
1742		1743
1743	// Have it process the records into high level objects	1744	// Have it process the records into high level objects
1744	// as best it can do (this step may eat anything	1745	// as best it can do (this step may eat anything
1745	// that isn't supported, you were warned...)	1746	// that isn't supported, you were warned...)
1746	agg.convertRecordsToUserModel();	1747	// agg.convertRecordsToUserModel();
1747		1748
1748	// Return what we could cope with	1749	// Return what we could cope with
1749	return _patriarch;	1750	return _patriarch;

Lines 43-58 Link Here

(-)src/java/org/apache/poi/hssf/record/EscherAggregate.java (-17 / +39 lines)
43	import org.apache.poi.hssf.model.ConvertAnchor;	43	import org.apache.poi.hssf.model.ConvertAnchor;
44	import org.apache.poi.hssf.model.DrawingManager2;	44	import org.apache.poi.hssf.model.DrawingManager2;
45	import org.apache.poi.hssf.model.TextboxShape;	45	import org.apache.poi.hssf.model.TextboxShape;
46	import org.apache.poi.hssf.usermodel.HSSFAnchor;	46	import org.apache.poi.hssf.usermodel.*;
47	import org.apache.poi.hssf.usermodel.HSSFChildAnchor;	47	import org.apache.poi.hssf.usermodel.HSSFShapeFactory;
48	import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
49	import org.apache.poi.hssf.usermodel.HSSFPatriarch;
50	import org.apache.poi.hssf.usermodel.HSSFPicture;
51	import org.apache.poi.hssf.usermodel.HSSFShape;
52	import org.apache.poi.hssf.usermodel.HSSFShapeContainer;
53	import org.apache.poi.hssf.usermodel.HSSFShapeGroup;
54	import org.apache.poi.hssf.usermodel.HSSFSimpleShape;
55	import org.apache.poi.hssf.usermodel.HSSFTextbox;
56	import org.apache.poi.util.POILogFactory;	48	import org.apache.poi.util.POILogFactory;
57	import org.apache.poi.util.POILogger;	49	import org.apache.poi.util.POILogger;
58		50
Lines 413-419 Link Here
413	}	405	}
414		406
415	// Decode the shapes	407	// Decode the shapes
416	// agg.escherRecords = new ArrayList();	408	// agg.escherRecords = new ArrayList();
417	int pos = 0;	409	int pos = 0;
418	while (pos < buffer.size()) {	410	while (pos < buffer.size()) {
419	EscherRecord r = recordFactory.createRecord(buffer.toByteArray(), pos);	411	EscherRecord r = recordFactory.createRecord(buffer.toByteArray(), pos);
Lines 453-462 Link Here
453	records.subList(locFirstDrawingRecord, locLastDrawingRecord).clear();	445	records.subList(locFirstDrawingRecord, locLastDrawingRecord).clear();
454	records.add(locFirstDrawingRecord, agg);	446	records.add(locFirstDrawingRecord, agg);
455		447
456
457	return agg;	448	return agg;
458	}	449	}
459		450
		451	public static EscherContainerRecord getMainSpgrContainer(EscherAggregate agg){
		452	EscherContainerRecord topContainer = agg.getEscherContainer();
		453	return topContainer.getChildContainers().get(0);
		454	}
		455
		456	public static void createShapeTree(EscherContainerRecord container, HSSFShapeContainer shapeGroup, EscherAggregate agg){
		457	for (EscherRecord record: container.getChildRecords()){
		458	if (record instanceof EscherContainerRecord){
		459	if (EscherContainerRecord.SP_CONTAINER == record.getRecordId()){
		460	if (record.getChild(0) instanceof EscherSpgrRecord){
		461	//TODO set properties for HSSFDrawingPatriarch
		462	continue;
		463	}
		464	shapeGroup.addShape(HSSFShapeFactory.createShape(record, (ObjRecord) agg.shapeToObj.get(container.getChildById(EscherClientDataRecord.RECORD_ID))));
		465	continue;
		466	}
		467	if (EscherContainerRecord.SPGR_CONTAINER == record.getRecordId()){
		468	EscherContainerRecord spContainer = (EscherContainerRecord) container.getChild(0);
		469	HSSFShapeGroup group = (HSSFShapeGroup) HSSFShapeFactory.createShape(spContainer, (ObjRecord) agg.shapeToObj.get(spContainer.getChildById(EscherClientDataRecord.RECORD_ID)));
		470	shapeGroup.addShape(group);
		471	createShapeTree((EscherContainerRecord)record, group, agg);
		472	}
		473	}
		474	}
		475	}
		476
460	/**	477	/**
461	* Serializes this aggregate to a byte array. Since this is an aggregate	478	* Serializes this aggregate to a byte array. Since this is an aggregate
462	* record it will effectively serialize the aggregated records.	479	* record it will effectively serialize the aggregated records.
Lines 466-472 Link Here
466	* @return The number of bytes serialized.	483	* @return The number of bytes serialized.
467	*/	484	*/
468	public int serialize(int offset, byte[] data) {	485	public int serialize(int offset, byte[] data) {
469	convertUserModelToRecords();	486	// convertUserModelToRecords();
470		487
471	// Determine buffer size	488	// Determine buffer size
472	List records = getEscherRecords();	489	List records = getEscherRecords();
Lines 486-492 Link Here
486		503
487	public void afterRecordSerialize(int offset, short recordId, int size, EscherRecord record) {	504	public void afterRecordSerialize(int offset, short recordId, int size, EscherRecord record) {
488	if (recordId == EscherClientDataRecord.RECORD_ID \|\| recordId == EscherTextboxRecord.RECORD_ID) {	505	if (recordId == EscherClientDataRecord.RECORD_ID \|\| recordId == EscherTextboxRecord.RECORD_ID) {
489	spEndingOffsets.add(Integer.valueOf(offset));	506	spEndingOffsets.add(offset);
490	shapes.add(record);	507	shapes.add(record);
491	}	508	}
492	}	509	}
Lines 501-512 Link Here
501	pos = offset;	518	pos = offset;
502	int writtenEscherBytes = 0;	519	int writtenEscherBytes = 0;
503	for (int i = 1; i < shapes.size(); i++) {	520	for (int i = 1; i < shapes.size(); i++) {
504	int endOffset = ((Integer) spEndingOffsets.get(i)).intValue() - 1;	521	int endOffset;
		522	if (i == shapes.size()-1){
		523	endOffset = buffer.length - 1;
		524	} else {
		525	endOffset = (Integer) spEndingOffsets.get(i) - 1;
		526	}
505	int startOffset;	527	int startOffset;
506	if (i == 1)	528	if (i == 1)
507	startOffset = 0;	529	startOffset = 0;
508	else	530	else
509	startOffset = ((Integer) spEndingOffsets.get(i - 1)).intValue();	531	startOffset = (Integer) spEndingOffsets.get(i - 1);
510		532
511		533
512	byte[] drawingData = new byte[endOffset - startOffset + 1];	534	byte[] drawingData = new byte[endOffset - startOffset + 1];
Lines 570-576 Link Here
570		592
571	public int getRecordSize() {	593	public int getRecordSize() {
572	// TODO - convert this to RecordAggregate	594	// TODO - convert this to RecordAggregate
573	convertUserModelToRecords();	595	// convertUserModelToRecords();
574	// To determine size of aggregate record we have to know size of each DrawingRecord because if DrawingRecord	596	// To determine size of aggregate record we have to know size of each DrawingRecord because if DrawingRecord
575	// is split into several continue records we have to add header size to total EscherAggregate size	597	// is split into several continue records we have to add header size to total EscherAggregate size
576	int continueRecordsHeadersSize = 0;	598	int continueRecordsHeadersSize = 0;

Lines 17-29 Link Here

(-)src/testcases/org/apache/poi/hssf/model/TestDrawingAggregate.java (-22 / +88 lines)
17	package org.apache.poi.hssf.model;	17	package org.apache.poi.hssf.model;
18		18
19	import junit.framework.TestCase;	19	import junit.framework.TestCase;
		20	import org.apache.poi.ddf.EscherContainerRecord;
20	import org.apache.poi.ddf.EscherDggRecord;	21	import org.apache.poi.ddf.EscherDggRecord;
		22	import org.apache.poi.ddf.EscherRecord;
21	import org.apache.poi.hssf.HSSFTestDataSamples;	23	import org.apache.poi.hssf.HSSFTestDataSamples;
22	import org.apache.poi.hssf.record.*;	24	import org.apache.poi.hssf.record.*;
23	import org.apache.poi.hssf.record.aggregates.RowRecordsAggregate;	25	import org.apache.poi.hssf.record.aggregates.RowRecordsAggregate;
24	import org.apache.poi.hssf.usermodel.HSSFSheet;	26	import org.apache.poi.hssf.usermodel.*;
25	import org.apache.poi.hssf.usermodel.HSSFTestHelper;
26	import org.apache.poi.hssf.usermodel.HSSFWorkbook;
27	import org.apache.poi.util.HexRead;	27	import org.apache.poi.util.HexRead;
28		28
29	import java.io.*;	29	import java.io.*;
Lines 35-53 Link Here
35	* @author Evgeniy Berlog	35	* @author Evgeniy Berlog
36	*/	36	*/
37	public class TestDrawingAggregate extends TestCase {	37	public class TestDrawingAggregate extends TestCase {
38	private static byte[] toByteArray(List<RecordBase> records){	38
		39	private int spgrCount = 0;
		40	private int spCount = 0;
		41	private int shapeCount = 0;
		42	private int shGroupCount = 0;
		43
		44	/*
		45	* EscherAggregate must have for each SpgrContainer HSSFShapeGroup and for each SpContainer HSSFShape
		46	*/
		47	private void checkEscherAndShapesCount(EscherAggregate agg, HSSFSheet sheet) {
		48	HSSFPatriarch patriarch = HSSFTestHelper.createTestPatriarch(sheet, agg);
		49	agg.setPatriarch(patriarch);
		50	EscherAggregate.createShapeTree(EscherAggregate.getMainSpgrContainer(agg), agg.getPatriarch(), agg);
		51	EscherContainerRecord mainContainer = EscherAggregate.getMainSpgrContainer(agg);
		52	calculateShapesCount(agg.getPatriarch());
		53	calculateEscherContainersCount(mainContainer);
		54
		55	assertEquals(spgrCount, shGroupCount);
		56	assertEquals(spCount - spgrCount - 1, shapeCount);
		57	}
		58
		59	private void calculateEscherContainersCount(EscherContainerRecord spgr) {
		60	for (EscherRecord record : spgr.getChildRecords()) {
		61	if (EscherContainerRecord.SP_CONTAINER == record.getRecordId()) {
		62	spCount++;
		63	continue;
		64	}
		65	if (EscherContainerRecord.SPGR_CONTAINER == record.getRecordId()) {
		66	spgrCount++;
		67	calculateEscherContainersCount((EscherContainerRecord) record);
		68	}
		69	}
		70	}
		71
		72	private void calculateShapesCount(HSSFShapeContainer group) {
		73	for (HSSFShape shape : (List<HSSFShape>) group.getChildren()) {
		74	if (shape instanceof HSSFShapeGroup) {
		75	shGroupCount++;
		76	calculateShapesCount((HSSFShapeGroup) shape);
		77	} else {
		78	shapeCount++;
		79	}
		80	}
		81	}
		82
		83
39	ByteArrayOutputStream out = new ByteArrayOutputStream();	84	private static byte[] toByteArray(List<RecordBase> records) {
40	for(RecordBase rb : records) {	85	ByteArrayOutputStream out = new ByteArrayOutputStream();
41	Record r = (Record)rb;	86	for (RecordBase rb : records) {
42	try {	87	Record r = (Record) rb;
43	out.write(r.serialize());
44	} catch (IOException e){	88	try {
		89	out.write(r.serialize());
45	throw new RuntimeException(e);	90	} catch (IOException e) {
46	}
47	}
48	return out.toByteArray();
49	}
		91	throw new RuntimeException(e);
		92	}
		93	}
		94	return out.toByteArray();
		95	}
50		96
		97	public void testSolverContainerMustBeSavedDuringSerialization(){
		98	HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("SolverContainerAfterSPGR.xls");
		99	HSSFSheet sh = wb.getSheetAt(0);
		100	InternalSheet ish = HSSFTestHelper.getSheetForTest(sh);
		101	sh.getDrawingPatriarch();
		102	EscherAggregate agg = (EscherAggregate) ish.findFirstRecordBySid(EscherAggregate.sid);
		103	assertEquals(agg.getEscherRecords().get(0).getChildRecords().size(), 3);
		104	assertEquals(agg.getEscherRecords().get(0).getChild(2).getRecordId(), EscherContainerRecord.SOLVER_CONTAINER);
		105	wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
		106	sh = wb.getSheetAt(0);
		107	sh.getDrawingPatriarch();
		108	ish = HSSFTestHelper.getSheetForTest(sh);
		109	agg = (EscherAggregate) ish.findFirstRecordBySid(EscherAggregate.sid);
		110	assertEquals(agg.getEscherRecords().get(0).getChildRecords().size(), 3);
		111	assertEquals(agg.getEscherRecords().get(0).getChild(2).getRecordId(), EscherContainerRecord.SOLVER_CONTAINER);
		112
		113	}
		114
51	/**	115	/**
52	* test reading drawing aggregate from a test file from Bugzilla 45129	116	* test reading drawing aggregate from a test file from Bugzilla 45129
53	*/	117	*/
Lines 107-112 Link Here
107	byte[] dgBytesAfterSave = agg.serialize();	171	byte[] dgBytesAfterSave = agg.serialize();
108	assertEquals("different size of drawing data before and after save", dgBytes.length, dgBytesAfterSave.length);	172	assertEquals("different size of drawing data before and after save", dgBytes.length, dgBytesAfterSave.length);
109	assertTrue("drawing data brefpore and after save is different", Arrays.equals(dgBytes, dgBytesAfterSave));	173	assertTrue("drawing data brefpore and after save is different", Arrays.equals(dgBytes, dgBytesAfterSave));
		174	checkEscherAndShapesCount(agg, sh);
110	}	175	}
111		176
112	/**	177	/**
Lines 174-180 Link Here
174	assertEquals("different size of drawing data before and after save", dgBytes.length, dgBytesAfterSave.length);	239	assertEquals("different size of drawing data before and after save", dgBytes.length, dgBytesAfterSave.length);
175	assertTrue("drawing data before and after save is different", Arrays.equals(dgBytes, dgBytesAfterSave));	240	assertTrue("drawing data before and after save is different", Arrays.equals(dgBytes, dgBytesAfterSave));
176		241
177		242	checkEscherAndShapesCount(agg, sh);
178	}	243	}
179		244
180		245
Lines 185-205 Link Here
185	List<RecordBase> records = isheet.getRecords();	250	List<RecordBase> records = isheet.getRecords();
186		251
187	HSSFWorkbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb);	252	HSSFWorkbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb);
188	InternalSheet isheet2 = HSSFTestHelper.getSheetForTest( wb2.getSheetAt(0));	253	InternalSheet isheet2 = HSSFTestHelper.getSheetForTest(wb2.getSheetAt(0));
189	List<RecordBase> records2 = isheet2.getRecords();	254	List<RecordBase> records2 = isheet2.getRecords();
190		255
191	assertEquals(records.size(), records2.size());	256	assertEquals(records.size(), records2.size());
192	for(int i = 0; i < records.size(); i++) {	257	for (int i = 0; i < records.size(); i++) {
193	RecordBase r1 = records.get(i);	258	RecordBase r1 = records.get(i);
194	RecordBase r2 = records2.get(i);	259	RecordBase r2 = records2.get(i);
195	assertTrue(r1.getClass() == r2.getClass());	260	assertTrue(r1.getClass() == r2.getClass());
196	assertEquals(r1.getRecordSize(), r2.getRecordSize());	261	assertEquals(r1.getRecordSize(), r2.getRecordSize());
197	if(r1 instanceof Record ){	262	if (r1 instanceof Record) {
198	assertEquals(((Record)r1).getSid(), ((Record)r2).getSid());	263	assertEquals(((Record) r1).getSid(), ((Record) r2).getSid());
199	assertTrue(Arrays.equals(((Record) r1).serialize(), ((Record) r2).serialize()));	264	assertTrue(Arrays.equals(((Record) r1).serialize(), ((Record) r2).serialize()));
200	}	265	}
201	}	266	}
202
203	}	267	}
204		268
205	public void testSerializeDrawingWithComments() throws IOException {	269	public void testSerializeDrawingWithComments() throws IOException {
Lines 257-262 Link Here
257	byte[] dgBytesAfterSave = agg.serialize();	321	byte[] dgBytesAfterSave = agg.serialize();
258	assertEquals("different size of drawing data before and after save", dgBytes.length, dgBytesAfterSave.length);	322	assertEquals("different size of drawing data before and after save", dgBytes.length, dgBytesAfterSave.length);
259	assertTrue("drawing data before and after save is different", Arrays.equals(dgBytes, dgBytesAfterSave));	323	assertTrue("drawing data before and after save is different", Arrays.equals(dgBytes, dgBytesAfterSave));
		324	checkEscherAndShapesCount(agg, sh);
260	}	325	}
261		326
262		327
Lines 314-320 Link Here
314		379
315	byte[] dgBytesAfterSave = agg.serialize();	380	byte[] dgBytesAfterSave = agg.serialize();
316	assertEquals("different size of drawing data before and after save", dgBytes.length, dgBytesAfterSave.length);	381	assertEquals("different size of drawing data before and after save", dgBytes.length, dgBytesAfterSave.length);
317	assertTrue("drawing data brefpore and after save is different", Arrays.equals(dgBytes, dgBytesAfterSave));	382	assertTrue("drawing data before and after save is different", Arrays.equals(dgBytes, dgBytesAfterSave));
		383	checkEscherAndShapesCount(agg, sh);
318	}	384	}
319		385
320	public void testUnhandledContinue() {	386	public void testUnhandledContinue() {