package org.apache.poi.hssf.record.aggregates;import org.apache.poi.hssf.record.ColumnInfoRecord;import org.apache.poi.hssf.record.Record;import java.util.ArrayList;import java.util.Iterator;import java.util.List;/** * @author Glen Stampoultzis * @version $Id: ColumnInfoRecordsAggregate.java,v 1.3 2005/05/01 11:26:17 glens Exp $ */public class ColumnInfoRecordsAggregate    extends Record{//    int     size     = 0;    List records = null;    public ColumnInfoRecordsAggregate()    {        records = new ArrayList();    }    /** You never fill an aggregate */    protected void fillFields(byte [] data, short size, int offset)    {    }    /** Not required by an aggregate */    protected void validateSid(short id)    {    }    /** It's an aggregate... just made something up */    public short getSid()    {        return -1012;    }    public int getRecordSize()    {        int size = 0;        for ( Iterator iterator = records.iterator(); iterator.hasNext(); )            size += ( (ColumnInfoRecord) iterator.next() ).getRecordSize();        return size;    }    public Iterator getIterator()    {        return records.iterator();    }    /**     * Performs a deep clone of the record     */    public Object clone()    {        ColumnInfoRecordsAggregate rec = new ColumnInfoRecordsAggregate();        for ( Iterator colIter = getIterator(); colIter.hasNext(); )        {            //return the cloned Row Record & insert            ColumnInfoRecord col = (ColumnInfoRecord) ( (ColumnInfoRecord) colIter.next() ).clone();            rec.insertColumn( col );        }        return rec;    }    /**     * Inserts a column into the aggregate (at the end of the list).     */    public void insertColumn( ColumnInfoRecord col )    {        records.add( col );    }    /**     * Inserts a column into the aggregate (at the position specified     * by <code>idx</code>.     */    public void insertColumn( int idx, ColumnInfoRecord col )    {        records.add( idx, col );    }    public int getNumColumns( )    {        return records.size();    }    /**     * called by the class that is responsible for writing this sucker.     * Subclasses should implement this so that their data is passed back in a     * byte array.     *     * @param offset    offset to begin writing at     * @param data      byte array containing instance data     * @return          number of bytes written     */    public int serialize(int offset, byte [] data)    {        Iterator itr = records.iterator();        int      pos = offset;        while (itr.hasNext())        {            pos += (( Record ) itr.next()).serialize(pos, data);        }        return pos - offset;    }    public int findStartOfColumnOutlineGroup(int idx)    {        // Find the start of the group.        ColumnInfoRecord columnInfo = (ColumnInfoRecord) records.get( idx );        int level = columnInfo.getOutlineLevel();        while (idx != 0)        {            ColumnInfoRecord prevColumnInfo = (ColumnInfoRecord) records.get( idx - 1 );            if (columnInfo.getFirstColumn() - 1 == prevColumnInfo.getLastColumn())            {                if (prevColumnInfo.getOutlineLevel() < level)                {                    break;                }                idx--;                columnInfo = prevColumnInfo;            }            else            {                break;            }        }        return idx;    }    public int findEndOfColumnOutlineGroup(int idx)    {        // Find the end of the group.        ColumnInfoRecord columnInfo = (ColumnInfoRecord) records.get( idx );        int level = columnInfo.getOutlineLevel();        while (idx < records.size() - 1)        {            ColumnInfoRecord nextColumnInfo = (ColumnInfoRecord) records.get( idx + 1 );            if (columnInfo.getLastColumn() + 1 == nextColumnInfo.getFirstColumn())            {                if (nextColumnInfo.getOutlineLevel() < level)                {                    break;                }                idx++;                columnInfo = nextColumnInfo;            }            else            {                break;            }        }        return idx;    }    public ColumnInfoRecord getColInfo(int idx)    {        return (ColumnInfoRecord) records.get( idx );    }    public ColumnInfoRecord writeHidden( ColumnInfoRecord columnInfo, int idx, boolean hidden )    {        int level = columnInfo.getOutlineLevel();        while (idx < records.size())        {            columnInfo.setHidden( hidden );            if (idx + 1 < records.size())            {                ColumnInfoRecord nextColumnInfo = (ColumnInfoRecord) records.get( idx + 1 );                if (columnInfo.getLastColumn() + 1 == nextColumnInfo.getFirstColumn())                {                    if (nextColumnInfo.getOutlineLevel() < level)                        break;                    columnInfo = nextColumnInfo;                }                else                {                    break;                }            }            idx++;        }        return columnInfo;    }    public boolean isColumnGroupCollapsed( int idx )    {        int endOfOutlineGroupIdx = findEndOfColumnOutlineGroup( idx );        if (endOfOutlineGroupIdx >= records.size())            return false;        if (getColInfo(endOfOutlineGroupIdx).getLastColumn() + 1 != getColInfo(endOfOutlineGroupIdx + 1).getFirstColumn())            return false;        else            return getColInfo(endOfOutlineGroupIdx+1).getCollapsed();    }    public boolean isColumnGroupHiddenByParent( int idx )    {        // Look out outline details of end        int endLevel;        boolean endHidden;        int endOfOutlineGroupIdx = findEndOfColumnOutlineGroup( idx );        if (endOfOutlineGroupIdx >= records.size())        {            endLevel = 0;            endHidden = false;        }        else if (getColInfo(endOfOutlineGroupIdx).getLastColumn() + 1 != getColInfo(endOfOutlineGroupIdx + 1).getFirstColumn())        {            endLevel = 0;            endHidden = false;        }        else        {            endLevel = getColInfo( endOfOutlineGroupIdx + 1).getOutlineLevel();            endHidden = getColInfo( endOfOutlineGroupIdx + 1).getHidden();        }        // Look out outline details of start        int startLevel;        boolean startHidden;        int startOfOutlineGroupIdx = findStartOfColumnOutlineGroup( idx );        if (startOfOutlineGroupIdx <= 0)        {            startLevel = 0;            startHidden = false;        }        else if (getColInfo(startOfOutlineGroupIdx).getFirstColumn() - 1 != getColInfo(startOfOutlineGroupIdx - 1).getLastColumn())        {            startLevel = 0;            startHidden = false;        }        else        {            startLevel = getColInfo( startOfOutlineGroupIdx - 1).getOutlineLevel();            startHidden = getColInfo( startOfOutlineGroupIdx - 1 ).getHidden();        }        if (endLevel > startLevel)        {            return endHidden;        }        else        {            return startHidden;        }    }