public EscherAggregate(DrawingManager2 drawingManager) 
{
        
        this.drawingManager = drawingManager;
}

 public Object assoicateShapeToObjRecord(EscherRecord r,
    Record objRecord) 
{
        return shapeToObj.put( r, objRecord );
}

Associates an escher record to an OBJ record or a TXO record.

 public  void clear() 
{
        clearEscherRecords();
        shapeToObj.clear();
//        lastShapeId = 1024;
}

 public  void convertRecordsToUserModel() 
{
    	if(patriarch == null) {
    		throw new IllegalStateException("Must call setPatriarch() first");
    	}
    	// The top level container ought to have
    	//  the DgRecord and the container of one container
    	//  per shape group (patriach overall first)
    	EscherContainerRecord topContainer =
    		(EscherContainerRecord)getEscherContainer();
    	if(topContainer == null) {
    		return;
    	}
    	topContainer = (EscherContainerRecord) 
    		topContainer.getChildContainers().get(0);
    	List tcc = topContainer.getChildContainers();
    	if(tcc.size() == 0) {
    		throw new IllegalStateException("No child escher containers at the point that should hold the patriach data, and one container per top level shape!");
    	}
    	// First up, get the patriach position
    	// This is in the first EscherSpgrRecord, in
    	//  the first container, with a EscherSRecord too
    	EscherContainerRecord patriachContainer =
    		(EscherContainerRecord)tcc.get(0);
    	EscherSpgrRecord spgr = null;
    	for(Iterator it = patriachContainer.getChildRecords().iterator(); it.hasNext();) {
    		EscherRecord r = (EscherRecord)it.next();
    		if(r instanceof EscherSpgrRecord) {
    			spgr = (EscherSpgrRecord)r;
    			break;
    		}
    	}
    	if(spgr != null) {
    		patriarch.setCoordinates(
    				spgr.getRectX1(), spgr.getRectY1(),
    				spgr.getRectX2(), spgr.getRectY2()
    		);
    	}
    	// Now process the containers for each group
    	//  and objects
    	for(int i=1; i< tcc.size(); i++) {
    		EscherContainerRecord shapeContainer =
    			(EscherContainerRecord)tcc.get(i);
    		//System.err.println("\n\n*****\n\n");
    		//System.err.println(shapeContainer);
    		// Could be a group, or a base object
    		if(shapeContainer.getChildRecords().size() == 1 &&
    				shapeContainer.getChildContainers().size() == 1) {
    			// Group
    			HSSFShapeGroup group =
    				new HSSFShapeGroup(null, new HSSFClientAnchor());
    			patriarch.getChildren().add(group);
    			EscherContainerRecord groupContainer =
    				(EscherContainerRecord)shapeContainer.getChild(0);
    			convertRecordsToUserModel(groupContainer, group);
    		} else if(shapeContainer.hasChildOfType((short)0xF00D)) {
    			// TextBox
    			HSSFTextbox box =
    				new HSSFTextbox(null, new HSSFClientAnchor());
    			patriarch.getChildren().add(box);
    			convertRecordsToUserModel(shapeContainer, box);
    		} else if(shapeContainer.hasChildOfType((short)0xF011)) {
    			// Not yet supporting EscherClientDataRecord stuff
    		} else {
    			// Base level
    			convertRecordsToUserModel(shapeContainer, patriarch);
    		}
    	}
    	// Now, clear any trace of what records make up
    	//  the patriarch
    	// Otherwise, everything will go horribly wrong
    	//  when we try to write out again....
//    	clearEscherRecords();
    	drawingManager.getDgg().setFileIdClusters(new EscherDggRecord.FileIdCluster[0]);
    	// TODO: Support converting our records
    	//  back into shapes
    	log.log(POILogger.WARN, "Not processing objects into Patriarch!");
}

Converts the Records into UserModel objects on the bound HSSFPatriarch

 public static EscherAggregate createAggregate(List records,
    int locFirstDrawingRecord,
    DrawingManager2 drawingManager) 
{
        // Keep track of any shape records created so we can match them back to the object id's.
        // Textbox objects are also treated as shape objects.
        final List shapeRecords = new ArrayList();
        EscherRecordFactory recordFactory = new DefaultEscherRecordFactory()
        {
            public EscherRecord createRecord( byte[] data, int offset )
            {
                EscherRecord r = super.createRecord( data, offset );
                if ( r.getRecordId() == EscherClientDataRecord.RECORD_ID || r.getRecordId() == EscherTextboxRecord.RECORD_ID )
                {
                    shapeRecords.add( r );
                }
                return r;
            }
        };
        // Calculate the size of the buffer
        EscherAggregate agg = new EscherAggregate(drawingManager);
        int loc = locFirstDrawingRecord;
        int dataSize = 0;
        while ( loc + 1 <  records.size()
                && sid( records, loc ) == DrawingRecord.sid
                && isObjectRecord( records, loc + 1 ) )
        {
            dataSize += ( (DrawingRecord) records.get( loc ) ).getData().length;
            loc += 2;
        }
        // Create one big buffer
        byte buffer[] = new byte[dataSize];
        int offset = 0;
        loc = locFirstDrawingRecord;
        while ( loc + 1 <  records.size()
                && sid( records, loc ) == DrawingRecord.sid
                && isObjectRecord( records, loc + 1 ) )
        {
            DrawingRecord drawingRecord = (DrawingRecord) records.get( loc );
            System.arraycopy( drawingRecord.getData(), 0, buffer, offset, drawingRecord.getData().length );
            offset += drawingRecord.getData().length;
            loc += 2;
        }
        // Decode the shapes
        //        agg.escherRecords = new ArrayList();
        int pos = 0;
        while ( pos <  dataSize )
        {
            EscherRecord r = recordFactory.createRecord( buffer, pos );
            int bytesRead = r.fillFields( buffer, pos, recordFactory );
            agg.addEscherRecord( r );
            pos += bytesRead;
        }
        // Associate the object records with the shapes
        loc = locFirstDrawingRecord;
        int shapeIndex = 0;
        agg.shapeToObj = new HashMap();
        while ( loc + 1 <  records.size()
                && sid( records, loc ) == DrawingRecord.sid
                && isObjectRecord( records, loc + 1 ) )
        {
            Record objRecord = (Record) records.get( loc + 1 );
            agg.shapeToObj.put( shapeRecords.get( shapeIndex++ ), objRecord );
            loc += 2;
        }
        return agg;
}

Collapses the drawing records into an aggregate.

 protected  void fillFields(byte[] data,
    short size,
    int offset) 
{
        throw new IllegalStateException( "Should not reach here" );
}

Unused since this is an aggregate record. Use createAggregate().

 public HSSFPatriarch getPatriarch() 
{
        return patriarch;
}

 protected String getRecordName() 
{
        return "ESCHERAGGREGATE";
}

 public int getRecordSize() 
{
        convertUserModelToRecords();
        List records = getEscherRecords();
        int rawEscherSize = getEscherRecordSize( records );
        int drawingRecordSize = rawEscherSize + ( shapeToObj.size() ) * 4;
        int objRecordSize = 0;
        for ( Iterator iterator = shapeToObj.values().iterator(); iterator.hasNext(); )
        {
            Record r = (Record) iterator.next();
            objRecordSize += r.getRecordSize();
        }
        int tailRecordSize = 0;
        for ( Iterator iterator = tailRec.iterator(); iterator.hasNext(); )
        {
            Record r = (Record) iterator.next();
            tailRecordSize += r.getRecordSize();
        }
        return drawingRecordSize + objRecordSize + tailRecordSize;
}

The number of bytes required to serialize this record.

 public short getSid() 
{
        return sid;
}

 public int serialize(int offset,
    byte[] data) 
{
        convertUserModelToRecords();
        // Determine buffer size
        List records = getEscherRecords();
        int size = getEscherRecordSize( records );
        byte[] buffer = new byte[size];
        // Serialize escher records into one big data structure and keep note of ending offsets.
        final List spEndingOffsets = new ArrayList();
        final List shapes = new ArrayList();
        int pos = 0;
        for ( Iterator iterator = records.iterator(); iterator.hasNext(); )
        {
            EscherRecord e = (EscherRecord) iterator.next();
            pos += e.serialize( pos, buffer, new EscherSerializationListener()
            {
                public void beforeRecordSerialize( int offset, short recordId, EscherRecord record )
                {
                }
                public void afterRecordSerialize( int offset, short recordId, int size, EscherRecord record )
                {
                    if ( recordId == EscherClientDataRecord.RECORD_ID || recordId == EscherTextboxRecord.RECORD_ID )
                    {
                        spEndingOffsets.add( new Integer( offset ) );
                        shapes.add( record );
                    }
                }
            } );
        }
        // todo: fix this
        shapes.add( 0, null );
        spEndingOffsets.add( 0, null );
        // Split escher records into separate MSODRAWING and OBJ, TXO records.  (We don't break on
        // the first one because it's the patriach).
        pos = offset;
        for ( int i = 1; i <  shapes.size(); i++ )
        {
            int endOffset = ( (Integer) spEndingOffsets.get( i ) ).intValue() - 1;
            int startOffset;
            if ( i == 1 )
                startOffset = 0;
            else
                startOffset = ( (Integer) spEndingOffsets.get( i - 1 ) ).intValue();
            // Create and write a new MSODRAWING record
            DrawingRecord drawing = new DrawingRecord();
            byte[] drawingData = new byte[endOffset - startOffset + 1];
            System.arraycopy( buffer, startOffset, drawingData, 0, drawingData.length );
            drawing.setData( drawingData );
            int temp = drawing.serialize( pos, data );
            pos += temp;
            // Write the matching OBJ record
            Record obj = (Record) shapeToObj.get( shapes.get( i ) );
            temp = obj.serialize( pos, data );
            pos += temp;
        }
        // write records that need to be serialized after all drawing group records
        for ( int i = 0; i <  tailRec.size(); i++ )
        {
            Record rec = (Record)tailRec.get(i);
            pos += rec.serialize( pos, data );
        }
        int bytesWritten = pos - offset;
        if ( bytesWritten != getRecordSize() )
            throw new RecordFormatException( bytesWritten + " bytes written but getRecordSize() reports " + getRecordSize() );
        return bytesWritten;
}

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

 public  void setPatriarch(HSSFPatriarch patriarch) 
{
        this.patriarch = patriarch;
}

 public String toString() 
{
        String nl = System.getProperty( "line.separtor" );
        StringBuffer result = new StringBuffer();
        result.append( '[" ).append( getRecordName() ).append( ']" + nl );
        for ( Iterator iterator = getEscherRecords().iterator(); iterator.hasNext(); )
        {
            EscherRecord escherRecord = (EscherRecord) iterator.next();
            result.append( escherRecord.toString() );
        }
        result.append( "[/" ).append( getRecordName() ).append( ']" + nl );
        return result.toString();
}

Calculates the string representation of this record. This is simply a dump of all the records.