| Methods Summary |
|---|
| public int | addMergedRegion(int rowFrom, short colFrom, int rowTo, short colTo)
if (merged == null || merged.getNumAreas() == 1027)
{
merged = ( MergeCellsRecord ) createMergedCells();
mergedRecords.add(merged);
records.add(records.size() - 1, merged);
}
merged.addArea(rowFrom, colFrom, rowTo, colTo);
return numMergedRegions++;
|
| public void | addRow(org.apache.poi.hssf.record.RowRecord row)Adds a row record to the sheet
This method is "loc" sensitive. Meaning you need to set LOC to where you
want it to start searching. If you don't know do this: setLoc(getDimsLoc).
When adding several rows you can just start at the last one by leaving loc
at what this sets it to.
checkRows();
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "addRow ");
DimensionsRecord d = ( DimensionsRecord ) records.get(getDimsLoc());
if (row.getRowNumber() >= d.getLastRow())
{
d.setLastRow(row.getRowNumber() + 1);
}
if (row.getRowNumber() < d.getFirstRow())
{
d.setFirstRow(row.getRowNumber());
}
//IndexRecord index = null;
//If the row exists remove it, so that any cells attached to the row are removed
RowRecord existingRow = rows.getRow(row.getRowNumber());
if (existingRow != null)
rows.removeRow(existingRow);
rows.insertRow(row);
/*
* for (int k = loc; k < records.size(); k++)
* {
* Record rec = ( Record ) records.get(k);
*
* if (rec.getSid() == IndexRecord.sid)
* {
* index = ( IndexRecord ) rec;
* }
* if (rec.getSid() == RowRecord.sid)
* {
* RowRecord rowrec = ( RowRecord ) rec;
*
* if (rowrec.getRowNumber() > row.getRowNumber())
* {
* records.add(k, row);
* loc = k;
* break;
* }
* }
* if (rec.getSid() == WindowTwoRecord.sid)
* {
* records.add(k, row);
* loc = k;
* break;
* }
* }
* if (index != null)
* {
* if (index.getLastRowAdd1() <= row.getRowNumber())
* {
* index.setLastRowAdd1(row.getRowNumber() + 1);
* }
* }
*/
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "exit addRow");
|
| public void | addValueRecord(int row, org.apache.poi.hssf.record.CellValueRecordInterface col)Adds a value record to the sheet's contained binary records
(i.e. LabelSSTRecord or NumberRecord).
This method is "loc" sensitive. Meaning you need to set LOC to where you
want it to start searching. If you don't know do this: setLoc(getDimsLoc).
When adding several rows you can just start at the last one by leaving loc
at what this sets it to.
checkCells();
if(log.check(POILogger.DEBUG))
{
log.logFormatted(POILogger.DEBUG, "add value record row,loc %,%", new int[]
{
row, loc
});
}
DimensionsRecord d = ( DimensionsRecord ) records.get(getDimsLoc());
if (col.getColumn() > d.getLastCol())
{
d.setLastCol(( short ) (col.getColumn() + 1));
}
if (col.getColumn() < d.getFirstCol())
{
d.setFirstCol(col.getColumn());
}
cells.insertCell(col);
/*
* for (int k = loc; k < records.size(); k++)
* {
* Record rec = ( Record ) records.get(k);
*
* if (rec.getSid() == RowRecord.sid)
* {
* RowRecord rowrec = ( RowRecord ) rec;
*
* if (rowrec.getRowNumber() == col.getRow())
* {
* records.add(k + 1, col);
* loc = k;
* if (rowrec.getLastCol() <= col.getColumn())
* {
* rowrec.setLastCol((( short ) (col.getColumn() + 1)));
* }
* break;
* }
* }
* }
*/
|
| public int | aggregateDrawingRecords(org.apache.poi.hssf.model.DrawingManager2 drawingManager)
int loc = findFirstRecordLocBySid(DrawingRecord.sid);
boolean noDrawingRecordsFound = loc == -1;
if (noDrawingRecordsFound)
{
EscherAggregate aggregate = new EscherAggregate( drawingManager );
loc = findFirstRecordLocBySid(EscherAggregate.sid);
if (loc == -1)
{
loc = findFirstRecordLocBySid( WindowTwoRecord.sid );
}
else
{
getRecords().remove(loc);
}
getRecords().add( loc, aggregate );
return loc;
}
else
{
List records = getRecords();
EscherAggregate r = EscherAggregate.createAggregate( records, loc, drawingManager );
int startloc = loc;
while ( loc + 1 < records.size()
&& records.get( loc ) instanceof DrawingRecord
&& records.get( loc + 1 ) instanceof ObjRecord )
{
loc += 2;
}
int endloc = loc-1;
for(int i = 0; i < (endloc - startloc + 1); i++)
records.remove(startloc);
records.add(startloc, r);
return startloc;
}
|
| private void | checkCells()
if (cells == null)
{
cells = new ValueRecordsAggregate();
records.add(getDimsLoc() + 1, cells);
}
|
| public void | checkDimsLoc(org.apache.poi.hssf.record.Record rec, int recloc)in the event the record is a dimensions record, resets both the loc index and dimsloc index
if (rec.getSid() == DimensionsRecord.sid)
{
loc = recloc;
dimsloc = recloc;
}
|
| private void | checkRows()
if (rows == null)
{
rows = new RowRecordsAggregate();
records.add(getDimsLoc() + 1, rows);
}
|
| public org.apache.poi.hssf.model.Sheet | cloneSheet()Clones the low level records of this sheet and returns the new sheet instance.
This method is implemented by adding methods for deep cloning to all records that
can be added to a sheet. The Record object does not implement cloneable.
When adding a new record, implement a public clone method if and only if the record
belongs to a sheet.
ArrayList clonedRecords = new ArrayList(this.records.size());
for (int i=0; i<this.records.size();i++) {
Record rec = (Record)((Record)this.records.get(i)).clone();
//Need to pull out the Row record and the Value records from their
//Aggregates.
//This is probably the best way to do it since we probably dont want the createSheet
//To cater for these artificial Record types
if (rec instanceof RowRecordsAggregate) {
RowRecordsAggregate rrAgg = (RowRecordsAggregate)rec;
for (Iterator rowIter = rrAgg.getIterator();rowIter.hasNext();) {
Record rowRec = (Record)rowIter.next();
clonedRecords.add(rowRec);
}
} else if (rec instanceof ValueRecordsAggregate) {
ValueRecordsAggregate vrAgg = (ValueRecordsAggregate)rec;
for (Iterator cellIter = vrAgg.getIterator();cellIter.hasNext();) {
Record valRec = (Record)cellIter.next();
if (valRec instanceof FormulaRecordAggregate) {
FormulaRecordAggregate fmAgg = (FormulaRecordAggregate)valRec;
Record fmAggRec = fmAgg.getFormulaRecord();
if (fmAggRec != null)
clonedRecords.add(fmAggRec);
fmAggRec = fmAgg.getStringRecord();
if (fmAggRec != null)
clonedRecords.add(fmAggRec);
} else {
clonedRecords.add(valRec);
}
}
} else if (rec instanceof FormulaRecordAggregate) { //Is this required now??
FormulaRecordAggregate fmAgg = (FormulaRecordAggregate)rec;
Record fmAggRec = fmAgg.getFormulaRecord();
if (fmAggRec != null)
clonedRecords.add(fmAggRec);
fmAggRec = fmAgg.getStringRecord();
if (fmAggRec != null)
clonedRecords.add(fmAggRec);
} else {
clonedRecords.add(rec);
}
}
return createSheet(clonedRecords, 0, 0);
|
| protected org.apache.poi.hssf.record.Record | createBOF()creates the BOF record
BOFRecord retval = new BOFRecord();
retval.setVersion(( short ) 0x600);
retval.setType(( short ) 0x010);
// retval.setBuild((short)0x10d3);
retval.setBuild(( short ) 0x0dbb);
retval.setBuildYear(( short ) 1996);
retval.setHistoryBitMask(0xc1);
retval.setRequiredVersion(0x6);
return retval;
|
| public org.apache.poi.hssf.record.BlankRecord | createBlank(int row, short col)create a BLANK record (does not add it to the records contained in this sheet)
//log.logFormatted(POILogger.DEBUG, "create blank row,col %,%", new short[]
log.logFormatted(POILogger.DEBUG, "create blank row,col %,%", new int[]
{
row, col
});
BlankRecord rec = new BlankRecord();
//rec.setRow(( short ) row);
rec.setRow(row);
rec.setColumn(col);
rec.setXFIndex(( short ) 0x0f);
return rec;
|
| protected org.apache.poi.hssf.record.Record | createCalcCount()creates the CalcCount record and sets it to 0x64 (default number of iterations)
CalcCountRecord retval = new CalcCountRecord();
retval.setIterations(( short ) 0x64); // default 64 iterations
return retval;
|
| protected org.apache.poi.hssf.record.Record | createCalcMode()creates the CalcMode record and sets it to 1 (automatic formula caculation)
CalcModeRecord retval = new CalcModeRecord();
retval.setCalcMode(( short ) 1);
return retval;
|
| protected org.apache.poi.hssf.record.Record | createColInfo()creates the ColumnInfo Record and sets it to a default column/width
return ColumnInfoRecordsAggregate.createColInfo();
|
| protected org.apache.poi.hssf.record.Record | createDefaultColWidth()creates the DefaultColWidth Record and sets it to 8
DefaultColWidthRecord retval = new DefaultColWidthRecord();
retval.setColWidth(( short ) 8);
return retval;
|
| protected org.apache.poi.hssf.record.Record | createDefaultRowHeight()creates the DefaultRowHeight Record and sets its options to 0 and rowheight to 0xff
DefaultRowHeightRecord retval = new DefaultRowHeightRecord();
retval.setOptionFlags(( short ) 0);
retval.setRowHeight(( short ) 0xff);
return retval;
|
| protected org.apache.poi.hssf.record.Record | createDelta()creates the Delta record and sets it to 0.0010 (default accuracy)
DeltaRecord retval = new DeltaRecord();
retval.setMaxChange(0.0010);
return retval;
|
| protected org.apache.poi.hssf.record.Record | createDimensions()creates the Dimensions Record and sets it to bogus values (you should set this yourself
or let the high level API do it for you)
DimensionsRecord retval = new DimensionsRecord();
retval.setFirstCol(( short ) 0);
retval.setLastRow(1); // one more than it is
retval.setFirstRow(0);
retval.setLastCol(( short ) 1); // one more than it is
return retval;
|
| protected org.apache.poi.hssf.record.Record | createEOF()creates the EOF record
return new EOFRecord();
|
| protected org.apache.poi.hssf.record.Record | createFooter()creates the Footer Record and sets it to nothing/0 length
FooterRecord retval = new FooterRecord();
retval.setFooterLength(( byte ) 0);
retval.setFooter(null);
return retval;
|
| public org.apache.poi.hssf.record.FormulaRecord | createFormula(int row, short col, java.lang.String formula)Attempts to parse the formula into PTGs and create a formula record
DOES NOT WORK YET
log.logFormatted(POILogger.DEBUG, "create formula row,col,formula %,%,%",
//new short[]
new int[]
{
row, col
}, formula);
FormulaRecord rec = new FormulaRecord();
rec.setRow(row);
rec.setColumn(col);
rec.setOptions(( short ) 2);
rec.setValue(0);
rec.setXFIndex(( short ) 0x0f);
FormulaParser fp = new FormulaParser(formula,null); //fix - do we need this method?
fp.parse();
Ptg[] ptg = fp.getRPNPtg();
int size = 0;
for (int k = 0; k < ptg.length; k++)
{
size += ptg[ k ].getSize();
rec.pushExpressionToken(ptg[ k ]);
}
rec.setExpressionLength(( short ) size);
return rec;
|
| public void | createFreezePane(int colSplit, int rowSplit, int topRow, int leftmostColumn)Creates a split (freezepane). Any existing freezepane or split pane is overwritten.
int paneLoc = findFirstRecordLocBySid(PaneRecord.sid);
if (paneLoc != -1)
records.remove(paneLoc);
int loc = findFirstRecordLocBySid(WindowTwoRecord.sid);
PaneRecord pane = new PaneRecord();
pane.setX((short)colSplit);
pane.setY((short)rowSplit);
pane.setTopRow((short) topRow);
pane.setLeftColumn((short) leftmostColumn);
if (rowSplit == 0)
{
pane.setTopRow((short)0);
pane.setActivePane((short)1);
}
else if (colSplit == 0)
{
pane.setLeftColumn((short)64);
pane.setActivePane((short)2);
}
else
{
pane.setActivePane((short)0);
}
records.add(loc+1, pane);
windowTwo.setFreezePanes(true);
windowTwo.setFreezePanesNoSplit(true);
SelectionRecord sel = (SelectionRecord) findFirstRecordBySid(SelectionRecord.sid);
sel.setPane((byte)pane.getActivePane());
|
| protected org.apache.poi.hssf.record.Record | createGridset()creates the Gridset record and sets it to true (user has mucked with the gridlines)
GridsetRecord retval = new GridsetRecord();
retval.setGridset(true);
return retval;
|
| protected org.apache.poi.hssf.record.Record | createGuts()creates the Guts record and sets leftrow/topcol guttter and rowlevelmax/collevelmax to 0
GutsRecord retval = new GutsRecord();
retval.setLeftRowGutter(( short ) 0);
retval.setTopColGutter(( short ) 0);
retval.setRowLevelMax(( short ) 0);
retval.setColLevelMax(( short ) 0);
return retval;
|
| protected org.apache.poi.hssf.record.Record | createHCenter()creates the HCenter Record and sets it to false (don't horizontally center)
HCenterRecord retval = new HCenterRecord();
retval.setHCenter(false);
return retval;
|
| protected org.apache.poi.hssf.record.Record | createHeader()creates the Header Record and sets it to nothing/0 length
HeaderRecord retval = new HeaderRecord();
retval.setHeaderLength(( byte ) 0);
retval.setHeader(null);
return retval;
|
| protected org.apache.poi.hssf.record.Record | createIndex()creates the Index record - not currently used
IndexRecord retval = new IndexRecord();
retval.setFirstRow(0); // must be set explicitly
retval.setLastRowAdd1(0);
return retval;
|
| protected org.apache.poi.hssf.record.Record | createIteration()creates the Iteration record and sets it to false (don't iteratively calculate formulas)
IterationRecord retval = new IterationRecord();
retval.setIteration(false);
return retval;
|
| public org.apache.poi.hssf.record.LabelSSTRecord | createLabelSST(int row, short col, int index)Create a LABELSST Record (does not add it to the records contained in this sheet)
log.logFormatted(POILogger.DEBUG, "create labelsst row,col,index %,%,%",
new int[]
{
row, col, index
});
LabelSSTRecord rec = new LabelSSTRecord();
rec.setRow(row);
rec.setColumn(col);
rec.setSSTIndex(index);
rec.setXFIndex(( short ) 0x0f);
return rec;
|
| protected org.apache.poi.hssf.record.Record | createMergedCells()
MergeCellsRecord retval = new MergeCellsRecord();
retval.setNumAreas(( short ) 0);
return retval;
|
| public org.apache.poi.hssf.record.NumberRecord | createNumber(int row, short col, double value)Create a NUMBER Record (does not add it to the records contained in this sheet)
log.logFormatted(POILogger.DEBUG, "create number row,col,value %,%,%",
new double[]
{
row, col, value
});
NumberRecord rec = new NumberRecord();
//rec.setRow(( short ) row);
rec.setRow(row);
rec.setColumn(col);
rec.setValue(value);
rec.setXFIndex(( short ) 0x0f);
return rec;
|
| protected org.apache.poi.hssf.record.Record | createPrintGridlines()creates the PrintGridlines record and sets it to false (that makes for ugly sheets). As far as I can
tell this does the same thing as the GridsetRecord
PrintGridlinesRecord retval = new PrintGridlinesRecord();
retval.setPrintGridlines(false);
return retval;
|
| protected org.apache.poi.hssf.record.Record | createPrintHeaders()creates the PrintHeaders record and sets it to false (we don't create headers yet so why print them)
PrintHeadersRecord retval = new PrintHeadersRecord();
retval.setPrintHeaders(false);
return retval;
|
| protected org.apache.poi.hssf.record.Record | createPrintSetup()creates the PrintSetup Record and sets it to defaults and marks it invalid
PrintSetupRecord retval = new PrintSetupRecord();
retval.setPaperSize(( short ) 1);
retval.setScale(( short ) 100);
retval.setPageStart(( short ) 1);
retval.setFitWidth(( short ) 1);
retval.setFitHeight(( short ) 1);
retval.setOptions(( short ) 2);
retval.setHResolution(( short ) 300);
retval.setVResolution(( short ) 300);
retval.setHeaderMargin( 0.5);
retval.setFooterMargin( 0.5);
retval.setCopies(( short ) 0);
return retval;
|
| protected org.apache.poi.hssf.record.Record | createProtect()creates a Protect record with protect set to false.
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "create protect record with protection disabled");
ProtectRecord retval = new ProtectRecord();
retval.setProtect(false);
// by default even when we support encryption we won't
return retval;
|
| protected org.apache.poi.hssf.record.Record | createRefMode()creates the RefMode record and sets it to A1 Mode (default reference mode)
RefModeRecord retval = new RefModeRecord();
retval.setMode(RefModeRecord.USE_A1_MODE);
return retval;
|
| public org.apache.poi.hssf.record.RowRecord | createRow(int row)Create a row record. (does not add it to the records contained in this sheet)
return RowRecordsAggregate.createRow( row );
|
| protected org.apache.poi.hssf.record.Record | createSaveRecalc()creates the SaveRecalc record and sets it to true (recalculate before saving)
SaveRecalcRecord retval = new SaveRecalcRecord();
retval.setRecalc(true);
return retval;
|
| protected org.apache.poi.hssf.record.Record | createSelection()Creates the Selection record and sets it to nothing selected
SelectionRecord retval = new SelectionRecord();
retval.setPane(( byte ) 0x3);
retval.setActiveCellCol(( short ) 0x0);
retval.setActiveCellRow(( short ) 0x0);
retval.setNumRefs(( short ) 0x0);
return retval;
|
| public static org.apache.poi.hssf.model.Sheet | createSheet(java.util.List recs, int sheetnum, int offset)read support (offset used as starting point for search) for low level
API. Pass in an array of Record objects, the sheet number (0 based) and
a record offset (should be the location of the sheets BOF record). A Sheet
object is constructed and passed back with all of its initialization set
to the passed in records and references to those records held. This function
is normally called via Workbook.
if (log.check( POILogger.DEBUG ))
log.logFormatted(POILogger.DEBUG,
"Sheet createSheet (existing file) with %",
new Integer(recs.size()));
Sheet retval = new Sheet();
ArrayList records = new ArrayList(recs.size() / 5);
boolean isfirstcell = true;
boolean isfirstrow = true;
int bofEofNestingLevel = 0;
for (int k = offset; k < recs.size(); k++)
{
Record rec = ( Record ) recs.get(k);
if (rec.getSid() == BOFRecord.sid)
{
bofEofNestingLevel++;
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "Hit BOF record. Nesting increased to " + bofEofNestingLevel);
}
else if (rec.getSid() == EOFRecord.sid)
{
--bofEofNestingLevel;
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "Hit EOF record. Nesting decreased to " + bofEofNestingLevel);
if (bofEofNestingLevel == 0) {
records.add(rec);
retval.eofLoc = k;
break;
}
}
else if (rec.getSid() == DimensionsRecord.sid)
{
// Make a columns aggregate if one hasn't ready been created.
if (retval.columns == null)
{
retval.columns = new ColumnInfoRecordsAggregate();
records.add(retval.columns);
}
retval.dims = ( DimensionsRecord ) rec;
retval.dimsloc = records.size();
}
else if (rec.getSid() == MergeCellsRecord.sid)
{
retval.mergedRecords.add(rec);
retval.merged = ( MergeCellsRecord ) rec;
retval.numMergedRegions += retval.merged.getNumAreas();
}
else if (rec.getSid() == ColumnInfoRecord.sid)
{
ColumnInfoRecord col = (ColumnInfoRecord)rec;
if (retval.columns != null)
{
rec = null; //only add the aggregate once
}
else
{
rec = retval.columns = new ColumnInfoRecordsAggregate();
}
retval.columns.insertColumn(col);
}
else if (rec.getSid() == DefaultColWidthRecord.sid)
{
retval.defaultcolwidth = ( DefaultColWidthRecord ) rec;
}
else if (rec.getSid() == DefaultRowHeightRecord.sid)
{
retval.defaultrowheight = ( DefaultRowHeightRecord ) rec;
}
else if ( rec.isValue() && bofEofNestingLevel == 1 )
{
if ( isfirstcell )
{
retval.cells = new ValueRecordsAggregate();
rec = retval.cells;
retval.cells.construct( k, recs );
isfirstcell = false;
}
else
{
rec = null;
}
}
else if ( rec.getSid() == StringRecord.sid )
{
rec = null;
}
else if ( rec.getSid() == RowRecord.sid )
{
RowRecord row = (RowRecord)rec;
if (!isfirstrow) rec = null; //only add the aggregate once
if ( isfirstrow )
{
retval.rows = new RowRecordsAggregate();
rec = retval.rows;
isfirstrow = false;
}
retval.rows.insertRow(row);
}
else if ( rec.getSid() == PrintGridlinesRecord.sid )
{
retval.printGridlines = (PrintGridlinesRecord) rec;
}
else if ( rec.getSid() == GridsetRecord.sid )
{
retval.gridset = (GridsetRecord) rec;
}
else if ( rec.getSid() == HeaderRecord.sid && bofEofNestingLevel == 1)
{
retval.header = (HeaderRecord) rec;
}
else if ( rec.getSid() == FooterRecord.sid && bofEofNestingLevel == 1)
{
retval.footer = (FooterRecord) rec;
}
else if ( rec.getSid() == PrintSetupRecord.sid && bofEofNestingLevel == 1)
{
retval.printSetup = (PrintSetupRecord) rec;
}
else if ( rec.getSid() == LeftMarginRecord.sid)
{
retval.getMargins()[LeftMargin] = (LeftMarginRecord) rec;
}
else if ( rec.getSid() == RightMarginRecord.sid)
{
retval.getMargins()[RightMargin] = (RightMarginRecord) rec;
}
else if ( rec.getSid() == TopMarginRecord.sid)
{
retval.getMargins()[TopMargin] = (TopMarginRecord) rec;
}
else if ( rec.getSid() == BottomMarginRecord.sid)
{
retval.getMargins()[BottomMargin] = (BottomMarginRecord) rec;
}
else if ( rec.getSid() == SelectionRecord.sid )
{
retval.selection = (SelectionRecord) rec;
}
else if ( rec.getSid() == WindowTwoRecord.sid )
{
retval.windowTwo = (WindowTwoRecord) rec;
}
else if ( rec.getSid() == DBCellRecord.sid )
{
rec = null;
}
else if ( rec.getSid() == IndexRecord.sid )
{
rec = null;
}
else if ( rec.getSid() == ProtectRecord.sid )
{
retval.protect = (ProtectRecord) rec;
}
else if (rec.getSid() == PageBreakRecord.HORIZONTAL_SID)
{
retval.rowBreaks = (PageBreakRecord)rec;
}
else if (rec.getSid() == PageBreakRecord.VERTICAL_SID)
{
retval.colBreaks = (PageBreakRecord)rec;
}
if (rec != null)
{
records.add(rec);
}
}
retval.records = records;
// if (retval.rows == null)
// {
// retval.rows = new RowRecordsAggregate();
// }
retval.checkCells();
retval.checkRows();
// if (retval.cells == null)
// {
// retval.cells = new ValueRecordsAggregate();
// }
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "sheet createSheet (existing file) exited");
return retval;
|
| public static org.apache.poi.hssf.model.Sheet | createSheet(java.util.List records, int sheetnum)read support (offset = 0) Same as createSheet(Record[] recs, int, int)
only the record offset is assumed to be 0.
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG,
"Sheet createSheet (exisiting file) assumed offset 0");
return createSheet(records, sheetnum, 0);
|
| public static org.apache.poi.hssf.model.Sheet | createSheet()Creates a sheet with all the usual records minus values and the "index"
record (not required). Sets the location pointer to where the first value
records should go. Use this to create a sheet from "scratch".
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "Sheet createsheet from scratch called");
Sheet retval = new Sheet();
ArrayList records = new ArrayList(30);
records.add(retval.createBOF());
// records.add(retval.createIndex());
records.add(retval.createCalcMode());
records.add(retval.createCalcCount() );
records.add( retval.createRefMode() );
records.add( retval.createIteration() );
records.add( retval.createDelta() );
records.add( retval.createSaveRecalc() );
records.add( retval.createPrintHeaders() );
retval.printGridlines = (PrintGridlinesRecord) retval.createPrintGridlines();
records.add( retval.printGridlines );
retval.gridset = (GridsetRecord) retval.createGridset();
records.add( retval.gridset );
records.add( retval.createGuts() );
retval.defaultrowheight =
(DefaultRowHeightRecord) retval.createDefaultRowHeight();
records.add( retval.defaultrowheight );
records.add( retval.createWSBool() );
retval.rowBreaks = new PageBreakRecord(PageBreakRecord.HORIZONTAL_SID);
records.add(retval.rowBreaks);
retval.colBreaks = new PageBreakRecord(PageBreakRecord.VERTICAL_SID);
records.add(retval.colBreaks);
retval.header = (HeaderRecord) retval.createHeader();
records.add( retval.header );
retval.footer = (FooterRecord) retval.createFooter();
records.add( retval.footer );
records.add( retval.createHCenter() );
records.add( retval.createVCenter() );
retval.printSetup = (PrintSetupRecord) retval.createPrintSetup();
records.add( retval.printSetup );
retval.defaultcolwidth =
(DefaultColWidthRecord) retval.createDefaultColWidth();
records.add( retval.defaultcolwidth);
ColumnInfoRecordsAggregate columns = new ColumnInfoRecordsAggregate();
records.add( columns );
retval.columns = columns;
retval.dims = ( DimensionsRecord ) retval.createDimensions();
records.add(retval.dims);
retval.dimsloc = records.size()-1;
records.add(retval.windowTwo = retval.createWindowTwo());
retval.setLoc(records.size() - 1);
retval.selection =
(SelectionRecord) retval.createSelection();
records.add(retval.selection);
retval.protect = (ProtectRecord) retval.createProtect();
records.add(retval.protect);
records.add(retval.createEOF());
retval.records = records;
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "Sheet createsheet from scratch exit");
return retval;
|
| public void | createSplitPane(int xSplitPos, int ySplitPos, int topRow, int leftmostColumn, int activePane)Creates a split pane. Any existing freezepane or split pane is overwritten.
int paneLoc = findFirstRecordLocBySid(PaneRecord.sid);
if (paneLoc != -1)
records.remove(paneLoc);
int loc = findFirstRecordLocBySid(WindowTwoRecord.sid);
PaneRecord r = new PaneRecord();
r.setX((short)xSplitPos);
r.setY((short)ySplitPos);
r.setTopRow((short) topRow);
r.setLeftColumn((short) leftmostColumn);
r.setActivePane((short) activePane);
records.add(loc+1, r);
windowTwo.setFreezePanes(false);
windowTwo.setFreezePanesNoSplit(false);
SelectionRecord sel = (SelectionRecord) findFirstRecordBySid(SelectionRecord.sid);
sel.setPane(PANE_LOWER_RIGHT);
|
| protected org.apache.poi.hssf.record.Record | createVCenter()creates the VCenter Record and sets it to false (don't horizontally center)
VCenterRecord retval = new VCenterRecord();
retval.setVCenter(false);
return retval;
|
| protected org.apache.poi.hssf.record.Record | createWSBool()creates the WSBoolRecord and sets its values to defaults
WSBoolRecord retval = new WSBoolRecord();
retval.setWSBool1(( byte ) 0x4);
retval.setWSBool2(( byte ) 0xffffffc1);
return retval;
|
| protected org.apache.poi.hssf.record.WindowTwoRecord | createWindowTwo()creates the WindowTwo Record and sets it to:
options = 0x6b6
toprow = 0
leftcol = 0
headercolor = 0x40
pagebreakzoom = 0x0
normalzoom = 0x0
WindowTwoRecord retval = new WindowTwoRecord();
retval.setOptions(( short ) 0x6b6);
retval.setTopRow(( short ) 0);
retval.setLeftCol(( short ) 0);
retval.setHeaderColor(0x40);
retval.setPageBreakZoom(( short ) 0);
retval.setNormalZoom(( short ) 0);
return retval;
|
| public org.apache.poi.hssf.record.Record | findFirstRecordBySid(short sid)Returns the first occurance of a record matching a particular sid.
for (Iterator iterator = records.iterator(); iterator.hasNext(); )
{
Record record = ( Record ) iterator.next();
if (record.getSid() == sid)
{
return record;
}
}
return null;
|
| public int | findFirstRecordLocBySid(short sid)Finds the first occurance of a record matching a particular sid and
returns it's position.
int index = 0;
for (Iterator iterator = records.iterator(); iterator.hasNext(); )
{
Record record = ( Record ) iterator.next();
if (record.getSid() == sid)
{
return index;
}
index++;
}
return -1;
|
| public short | getActiveCellCol()Returns the active column
if (selection == null)
{
return (short) 0;
}
return selection.getActiveCellCol();
|
| public int | getActiveCellRow()Returns the active row
if (selection == null)
{
return 0;
}
return selection.getActiveCellRow();
|
| public java.util.Iterator | getColumnBreaks()Returns all the column page breaks
return colBreaks.getBreaksIterator();
|
| public short | getColumnWidth(short column)get the width of a given column in units of 1/20th of a point width (twips?)
short retval = 0;
ColumnInfoRecord ci = null;
if (columns != null)
{
int count=columns.getNumColumns();
for ( int k=0;k<count;k++ )
{
ci = columns.getColInfo(k);
if ((ci.getFirstColumn() <= column)
&& (column <= ci.getLastColumn()))
{
break;
}
ci = null;
}
}
if (ci != null)
{
retval = ci.getColumnWidth();
}
else
{
retval = defaultcolwidth.getColWidth();
}
return retval;
|
| public short | getDefaultColumnWidth()get the default column width for the sheet (if the columns do not define their own width)
return defaultcolwidth.getColWidth();
|
| public short | getDefaultRowHeight()get the default row height for the sheet (if the rows do not define their own height)
return defaultrowheight.getRowHeight();
|
| public int | getDimsLoc()get the location of the DimensionsRecord (which is the last record before the value section)
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "getDimsLoc dimsloc= " + dimsloc);
return dimsloc;
|
| public int | getEofLoc()
return eofLoc;
|
| public org.apache.poi.hssf.record.FooterRecord | getFooter()Returns the FooterRecord.
return footer;
|
| public org.apache.poi.hssf.record.GridsetRecord | getGridsetRecord()Gets the gridset record for this sheet.
return gridset;
|
| public org.apache.poi.hssf.record.HeaderRecord | getHeader()Returns the HeaderRecord.
return header;
|
| public short | getLeftCol()
return (windowTwo==null) ? (short) 0 : windowTwo.getLeftCol();
|
| public int | getLoc()Returns the location pointer to the first record to look for when adding rows/values
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "sheet.getLoc():" + loc);
return loc;
|
| public double | getMargin(short margin)Gets the size of the margin in inches.
if (getMargins()[margin] != null)
return margins[margin].getMargin();
else {
switch ( margin )
{
case LeftMargin:
return .75;
case RightMargin:
return .75;
case TopMargin:
return 1.0;
case BottomMargin:
return 1.0;
default :
throw new RuntimeException( "Unknown margin constant: " + margin );
}
}
|
| protected org.apache.poi.hssf.record.Margin[] | getMargins()Returns the array of margins. If not created, will create.
if (margins == null)
margins = new Margin[4];
return margins;
|
| public MergeCellsRecord.MergedRegion | getMergedRegionAt(int index)
//safety checks
if (index >= numMergedRegions || mergedRecords.size() == 0)
return null;
int pos = 0;
int startNumRegions = 0;
//optimisation for current record
if (numMergedRegions - index < merged.getNumAreas())
{
pos = mergedRecords.size() - 1;
startNumRegions = numMergedRegions - merged.getNumAreas();
}
else
{
for (int n = 0; n < mergedRecords.size(); n++)
{
MergeCellsRecord record = (MergeCellsRecord) mergedRecords.get(n);
if (startNumRegions + record.getNumAreas() > index)
{
pos = n;
break;
}
startNumRegions += record.getNumAreas();
}
}
return ((MergeCellsRecord) mergedRecords.get(pos)).getAreaAt(index - startNumRegions);
|
| public org.apache.poi.hssf.record.RowRecord | getNextRow()get the NEXT RowRecord (from LOC). The first record that is a Row record
(starting at LOC) will be returned.
This method is "loc" sensitive. Meaning you need to set LOC to where you
want it to start searching. If you don't know do this: setLoc(getDimsLoc).
When adding several rows you can just start at the last one by leaving loc
at what this sets it to. For this method, set loc to dimsloc to start with.
subsequent calls will return rows in (physical) sequence or NULL when you get to the end.
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "getNextRow loc= " + loc);
if (rowRecIterator == null)
{
rowRecIterator = rows.getIterator();
}
if (!rowRecIterator.hasNext())
{
return null;
}
return ( RowRecord ) rowRecIterator.next();
/* if (this.getLoc() < records.size())
{
for (int k = this.getLoc(); k < records.size(); k++)
{
Record rec = ( Record ) records.get(k);
this.setLoc(k + 1);
if (rec.getSid() == RowRecord.sid)
{
return ( RowRecord ) rec;
}
}
}*/
|
| public org.apache.poi.hssf.record.CellValueRecordInterface | getNextValueRecord()get the NEXT value record (from LOC). The first record that is a value record
(starting at LOC) will be returned.
This method is "loc" sensitive. Meaning you need to set LOC to where you
want it to start searching. If you don't know do this: setLoc(getDimsLoc).
When adding several rows you can just start at the last one by leaving loc
at what this sets it to. For this method, set loc to dimsloc to start with,
subsequent calls will return values in (physical) sequence or NULL when you get to the end.
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "getNextValue loc= " + loc);
if (valueRecIterator == null)
{
valueRecIterator = cells.getIterator();
}
if (!valueRecIterator.hasNext())
{
return null;
}
return ( CellValueRecordInterface ) valueRecIterator.next();
/*
* if (this.getLoc() < records.size())
* {
* for (int k = getLoc(); k < records.size(); k++)
* {
* Record rec = ( Record ) records.get(k);
*
* this.setLoc(k + 1);
* if (rec instanceof CellValueRecordInterface)
* {
* return ( CellValueRecordInterface ) rec;
* }
* }
* }
* return null;
*/
|
| public int | getNumColumnBreaks()Returns the number of column page breaks
return (colBreaks == null) ? 0 : (int)colBreaks.getNumBreaks();
|
| public int | getNumMergedRegions()
return numMergedRegions;
|
| public int | getNumRecords()Returns the number of low level binary records in this sheet. This adjusts things for the so called
AgregateRecords.
checkCells();
checkRows();
if (log.check( POILogger.DEBUG ))
{
log.log(POILogger.DEBUG, "Sheet.getNumRecords");
log.logFormatted(POILogger.DEBUG, "returning % + % + % - 2 = %", new int[]
{
records.size(), cells.getPhysicalNumberOfCells(),
rows.getPhysicalNumberOfRows(),
records.size() + cells.getPhysicalNumberOfCells()
+ rows.getPhysicalNumberOfRows() - 2
});
}
return records.size() + cells.getPhysicalNumberOfCells()
+ rows.getPhysicalNumberOfRows() - 2;
|
| public int | getNumRowBreaks()Returns the number of row page breaks
return (rowBreaks == null) ? 0 : (int)rowBreaks.getNumBreaks();
|
| public org.apache.poi.hssf.util.PaneInformation | getPaneInformation()Returns the information regarding the currently configured pane (split or freeze).
PaneRecord rec = (PaneRecord)findFirstRecordBySid(PaneRecord.sid);
if (rec == null)
return null;
return new PaneInformation(rec.getX(), rec.getY(), rec.getTopRow(),
rec.getLeftColumn(), (byte)rec.getActivePane(), windowTwo.getFreezePanes());
|
| public int | getPreOffset()get the preoffset when using DBCELL records (currently unused) - this is
the position of this sheet within the whole file.
return preoffset;
|
| public org.apache.poi.hssf.record.PrintGridlinesRecord | getPrintGridlines()Returns the PrintGridlinesRecord.
return printGridlines;
|
| public org.apache.poi.hssf.record.PrintSetupRecord | getPrintSetup()Returns the PrintSetupRecord.
return printSetup;
|
| public org.apache.poi.hssf.record.ProtectRecord | getProtect()Returns the ProtectRecord.
If one is not contained in the sheet, then one is created.
if (protect == null) {
protect = (ProtectRecord)createProtect();
//Insert the newlycreated protect record at the end of the record (just before the EOF)
int loc = findFirstRecordLocBySid(EOFRecord.sid);
records.add(loc, protect);
}
return protect;
|
| public java.util.List | getRecords()
return records;
|
| public org.apache.poi.hssf.record.RowRecord | getRow(int rownum)get the NEXT (from LOC) RowRecord where rownumber matches the given rownum.
The first record that is a Row record (starting at LOC) that has the
same rownum as the given rownum will be returned.
This method is "loc" sensitive. Meaning you need to set LOC to where you
want it to start searching. If you don't know do this: setLoc(getDimsLoc).
When adding several rows you can just start at the last one by leaving loc
at what this sets it to. For this method, set loc to dimsloc to start with.
subsequent calls will return rows in (physical) sequence or NULL when you get to the end.
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "getNextRow loc= " + loc);
return rows.getRow(rownum);
/*
* if (this.getLoc() < records.size())
* {
* for (int k = this.getLoc(); k < records.size(); k++)
* {
* Record rec = ( Record ) records.get(k);
*
* this.setLoc(k + 1);
* if (rec.getSid() == RowRecord.sid)
* {
* if ((( RowRecord ) rec).getRowNumber() == rownum)
* {
* return ( RowRecord ) rec;
* }
* }
* }
* }
*/
// return null;
|
| public java.util.Iterator | getRowBreaks()Returns all the row page breaks
return rowBreaks.getBreaksIterator();
|
| public org.apache.poi.hssf.record.SelectionRecord | getSelection()
return selection;
|
| public int | getSize()
int retval = 0;
for ( int k = 0; k < records.size(); k++ )
{
retval += ( (Record) records.get( k ) ).getRecordSize();
}
//Add space for the IndexRecord
if (rows != null) {
final int blocks = rows.getRowBlockCount();
retval += IndexRecord.getRecordSizeForBlockCount(blocks);
//Add space for the DBCell records
//Once DBCell per block.
//8 bytes per DBCell (non variable section)
//2 bytes per row reference
retval += (8 * blocks);
for (Iterator itr = rows.getIterator(); itr.hasNext();) {
RowRecord row = (RowRecord)itr.next();
if (cells != null && cells.rowHasCells(row.getRowNumber()))
retval += 2;
}
}
return retval;
|
| public short | getTopRow()
return (windowTwo==null) ? (short) 0 : windowTwo.getTopRow();
|
| public short | getXFIndexForColAt(short column)get the index to the ExtendedFormatRecord "associated" with
the column at specified 0-based index. (In this case, an
ExtendedFormatRecord index is actually associated with a
ColumnInfoRecord which spans 1 or more columns)
Returns the index to the default ExtendedFormatRecord (0xF)
if no ColumnInfoRecord exists that includes the column
index specified.
short retval = 0;
ColumnInfoRecord ci = null;
if (columns != null) {
int count=columns.getNumColumns();
for ( int k=0;k<count;k++ )
{
ci = columns.getColInfo(k);
if ((ci.getFirstColumn() <= column)
&& (column <= ci.getLastColumn())) {
break;
}
ci = null;
}
}
retval = (ci != null) ? ci.getXFIndex() : 0xF;
return retval;
|
| public void | groupColumnRange(short fromColumn, short toColumn, boolean indent)Creates an outline group for the specified columns.
// Set the level for each column
columns.groupColumnRange( fromColumn, toColumn, indent);
// Determine the maximum overall level
int maxLevel = 0;
int count=columns.getNumColumns();
for ( int k=0;k<count;k++ )
{
ColumnInfoRecord columnInfoRecord = columns.getColInfo(k);
maxLevel = Math.max(columnInfoRecord.getOutlineLevel(), maxLevel);
}
GutsRecord guts = (GutsRecord) findFirstRecordBySid( GutsRecord.sid );
guts.setColLevelMax( (short) ( maxLevel+1 ) );
if (maxLevel == 0)
guts.setTopColGutter( (short)0 );
else
guts.setTopColGutter( (short) ( 29 + (12 * (maxLevel-1)) ) );
|
| public void | groupRowRange(int fromRow, int toRow, boolean indent)
checkRows();
for (int rowNum = fromRow; rowNum <= toRow; rowNum++)
{
RowRecord row = getRow( rowNum );
if (row == null)
{
row = createRow( rowNum );
addRow( row );
}
int level = row.getOutlineLevel();
if (indent) level++; else level--;
level = Math.max(0, level);
level = Math.min(7, level);
row.setOutlineLevel((short) ( level ));
}
recalcRowGutter();
|
| public boolean | isColumnBroken(short column)Queries if the specified column has a page break
return (colBreaks == null) ? false : colBreaks.getBreak(column) != null;
|
| public boolean | isColumnHidden(short column)Get the hidden property for a given column.
boolean retval = false;
ColumnInfoRecord ci = null;
if (columns != null)
{
for ( Iterator iterator = columns.getIterator(); iterator.hasNext(); )
{
ci = ( ColumnInfoRecord ) iterator.next();
if ((ci.getFirstColumn() <= column)
&& (column <= ci.getLastColumn()))
{
break;
}
ci = null;
}
}
if (ci != null)
{
retval = ci.getHidden();
}
return retval;
|
| public boolean | isDisplayFormulas()Returns if formulas are displayed.
return windowTwo.getDisplayFormulas();
|
| public boolean | isDisplayGridlines()Returns if gridlines are displayed.
return windowTwo.getDisplayGridlines();
|
| public boolean | isDisplayRowColHeadings()Returns if RowColHeadings are displayed.
return windowTwo.getDisplayRowColHeadings();
|
| public boolean | isGridsPrinted()get whether gridlines are printed.
if (gridset == null) {
gridset = (GridsetRecord)createGridset();
//Insert the newlycreated Gridset record at the end of the record (just before the EOF)
int loc = findFirstRecordLocBySid(EOFRecord.sid);
records.add(loc, gridset);
}
return !gridset.getGridset();
|
| public boolean | isRowBroken(int row)Queries if the specified row has a page break
return (rowBreaks == null) ? false : rowBreaks.getBreak((short)row) != null;
|
| public void | preSerialize()Perform any work necessary before the sheet is about to be serialized.
For instance the escher aggregates size needs to be calculated before
serialization so that the dgg record (which occurs first) can be written.
for ( Iterator iterator = getRecords().iterator(); iterator.hasNext(); )
{
Record r = (Record) iterator.next();
if (r instanceof EscherAggregate)
r.getRecordSize(); // Trigger flatterning of user model and corresponding update of dgg record.
}
|
| private void | recalcRowGutter()
int maxLevel = 0;
Iterator iterator = rows.getIterator();
while ( iterator.hasNext() )
{
RowRecord rowRecord = (RowRecord) iterator.next();
maxLevel = Math.max(rowRecord.getOutlineLevel(), maxLevel);
}
GutsRecord guts = (GutsRecord) findFirstRecordBySid( GutsRecord.sid );
guts.setRowLevelMax( (short) ( maxLevel + 1 ) );
guts.setLeftRowGutter( (short) ( 29 + (12 * (maxLevel)) ) );
|
| public void | removeColumnBreak(short column)Removes a page break at the indicated column
if (colBreaks == null)
throw new IllegalArgumentException("Sheet does not define any column breaks");
colBreaks.removeBreak(column);
|
| public void | removeMergedRegion(int index)
//safety checks
if (index >= numMergedRegions || mergedRecords.size() == 0)
return;
int pos = 0;
int startNumRegions = 0;
//optimisation for current record
if (numMergedRegions - index < merged.getNumAreas())
{
pos = mergedRecords.size() - 1;
startNumRegions = numMergedRegions - merged.getNumAreas();
}
else
{
for (int n = 0; n < mergedRecords.size(); n++)
{
MergeCellsRecord record = (MergeCellsRecord) mergedRecords.get(n);
if (startNumRegions + record.getNumAreas() > index)
{
pos = n;
break;
}
startNumRegions += record.getNumAreas();
}
}
MergeCellsRecord rec = (MergeCellsRecord) mergedRecords.get(pos);
rec.removeAreaAt(index - startNumRegions);
numMergedRegions--;
if (rec.getNumAreas() == 0)
{
mergedRecords.remove(pos);
//get rid of the record from the sheet
records.remove(merged);
if (merged == rec) {
//pull up the LAST record for operations when we finally
//support continue records for mergedRegions
if (mergedRecords.size() > 0) {
merged = (MergeCellsRecord) mergedRecords.get(mergedRecords.size() - 1);
} else {
merged = null;
}
}
}
|
| public void | removeRow(org.apache.poi.hssf.record.RowRecord row)Removes a row record
This method is not loc sensitive, it resets loc to = dimsloc so no worries.
checkRows();
// IndexRecord index = null;
setLoc(getDimsLoc());
rows.removeRow(row);
/*
* for (int k = loc; k < records.size(); k++)
* {
* Record rec = ( Record ) records.get(k);
*
* // checkDimsLoc(rec,k);
* if (rec.getSid() == RowRecord.sid)
* {
* RowRecord rowrec = ( RowRecord ) rec;
*
* if (rowrec.getRowNumber() == row.getRowNumber())
* {
* records.remove(k);
* break;
* }
* }
* if (rec.getSid() == WindowTwoRecord.sid)
* {
* break;
* }
* }
*/
|
| public void | removeRowBreak(int row)Removes a page break at the indicated row
if (rowBreaks == null)
throw new IllegalArgumentException("Sheet does not define any row breaks");
rowBreaks.removeBreak((short)row);
|
| public void | removeValueRecord(int row, org.apache.poi.hssf.record.CellValueRecordInterface col)remove a value record from the records array.
This method is not loc sensitive, it resets loc to = dimsloc so no worries.
checkCells();
log.logFormatted(POILogger.DEBUG, "remove value record row,dimsloc %,%",
new int[]{row, dimsloc} );
loc = dimsloc;
cells.removeCell(col);
/*
* for (int k = loc; k < records.size(); k++)
* {
* Record rec = ( Record ) records.get(k);
*
* // checkDimsLoc(rec,k);
* if (rec.isValue())
* {
* CellValueRecordInterface cell =
* ( CellValueRecordInterface ) rec;
*
* if ((cell.getRow() == col.getRow())
* && (cell.getColumn() == col.getColumn()))
* {
* records.remove(k);
* break;
* }
* }
* }
*/
|
| public void | replaceValueRecord(org.apache.poi.hssf.record.CellValueRecordInterface newval)replace a value record from the records array.
This method is not loc sensitive, it resets loc to = dimsloc so no worries.
checkCells();
setLoc(dimsloc);
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "replaceValueRecord ");
//The ValueRecordsAggregate use a tree map underneath.
//The tree Map uses the CellValueRecordInterface as both the
//key and the value, if we dont do a remove, then
//the previous instance of the key is retained, effectively using
//double the memory
cells.removeCell(newval);
cells.insertCell(newval);
/*
* CellValueRecordInterface oldval = getNextValueRecord();
*
* while (oldval != null)
* {
* if (oldval.isEqual(newval))
* {
* records.set(( short ) (getLoc() - 1), newval);
* return;
* }
* oldval = getNextValueRecord();
* }
* addValueRecord(newval.getRow(), newval);
* setLoc(dimsloc);
*/
|
| public int | serialize(int offset, byte[] data)Serializes all records in the sheet into one big byte array. Use this to write
the sheet out.
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "Sheet.serialize using offsets");
int pos = offset;
boolean haveSerializedIndex = false;
for (int k = 0; k < records.size(); k++)
{
Record record = (( Record ) records.get(k));
//Once the rows have been found in the list of records, start
//writing out the blocked row information. This includes the DBCell references
if (record instanceof RowRecordsAggregate) {
pos += ((RowRecordsAggregate)record).serialize(pos, data, cells); // rec.length;
} else if (record instanceof ValueRecordsAggregate) {
//Do nothing here. The records were serialized during the RowRecordAggregate block serialization
} else {
pos += record.serialize(pos, data ); // rec.length;
}
//If the BOF record was just serialized then add the IndexRecord
if (record.getSid() == BOFRecord.sid) {
//Can there be more than one BOF for a sheet? If not then we can
//remove this guard. So be safe it is left here.
if (rows != null && !haveSerializedIndex) {
haveSerializedIndex = true;
pos += serializeIndexRecord(k, pos, data);
}
}
//// uncomment to test record sizes ////
// System.out.println( record.getClass().getName() );
// byte[] data2 = new byte[record.getRecordSize()];
// record.serialize(0, data2 ); // rec.length;
// if (LittleEndian.getUShort(data2, 2) != record.getRecordSize() - 4
// && record instanceof RowRecordsAggregate == false
// && record instanceof ValueRecordsAggregate == false
// && record instanceof EscherAggregate == false)
// {
// throw new RuntimeException("Blah!!! Size off by " + ( LittleEndian.getUShort(data2, 2) - record.getRecordSize() - 4) + " records.");
// }
//asd: int len = record.serialize(pos + offset, data );
///// DEBUG BEGIN /////
//asd: if (len != record.getRecordSize())
//asd: throw new IllegalStateException("Record size does not match serialized bytes. Serialized size = " + len + " but getRecordSize() returns " + record.getRecordSize() + ". Record object is " + record.getClass());
///// DEBUG END /////
//asd: pos += len; // rec.length;
}
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "Sheet.serialize returning ");
return pos-offset;
|
| private int | serializeIndexRecord(int BOFRecordIndex, int offset, byte[] data)
IndexRecord index = new IndexRecord();
index.setFirstRow(rows.getFirstRowNum());
index.setLastRowAdd1(rows.getLastRowNum()+1);
//Calculate the size of the records from the end of the BOF
//and up to the RowRecordsAggregate...
int sheetRecSize = 0;
for (int j = BOFRecordIndex+1; j < records.size(); j++)
{
Record tmpRec = (( Record ) records.get(j));
if (tmpRec instanceof RowRecordsAggregate)
break;
sheetRecSize+= tmpRec.getRecordSize();
}
//Add the references to the DBCells in the IndexRecord (one for each block)
int blockCount = rows.getRowBlockCount();
//Calculate the size of this IndexRecord
int indexRecSize = IndexRecord.getRecordSizeForBlockCount(blockCount);
int rowBlockOffset = 0;
int cellBlockOffset = 0;
int dbCellOffset = 0;
for (int block=0;block<blockCount;block++) {
rowBlockOffset += rows.getRowBlockSize(block);
cellBlockOffset += null == cells ? 0 : cells.getRowCellBlockSize(rows.getStartRowNumberForBlock(block),
rows.getEndRowNumberForBlock(block));
//Note: The offsets are relative to the Workbook BOF. Assume that this is
//0 for now.....
index.addDbcell(offset + indexRecSize + sheetRecSize + dbCellOffset + rowBlockOffset + cellBlockOffset);
//Add space required to write the dbcell record(s) (whose references were just added).
dbCellOffset += (8 + (rows.getRowCountForBlock(block) * 2));
}
return index.serialize(offset, data);
|
| public void | setActiveCellCol(short col)Sets the active column
//shouldn't have a sheet w/o a SelectionRecord, but best to guard anyway
if (selection != null)
{
selection.setActiveCellCol(col);
}
|
| public void | setActiveCellRow(int row)Sets the active row
//shouldn't have a sheet w/o a SelectionRecord, but best to guard anyway
if (selection != null)
{
selection.setActiveCellRow(row);
}
|
| public void | setColumn(short column, java.lang.Short width, java.lang.Integer level, java.lang.Boolean hidden, java.lang.Boolean collapsed)
if (columns == null)
columns = new ColumnInfoRecordsAggregate();
columns.setColumn( column, null, width, level, hidden, collapsed );
|
| public void | setColumn(short column, java.lang.Short xfStyle, java.lang.Short width, java.lang.Integer level, java.lang.Boolean hidden, java.lang.Boolean collapsed)
if (columns == null)
columns = new ColumnInfoRecordsAggregate();
columns.setColumn( column, xfStyle, width, level, hidden, collapsed );
|
| public void | setColumnBreak(short column, short fromRow, short toRow)Sets a page break at the indicated column
if (colBreaks == null) {
int loc = findFirstRecordLocBySid(WindowTwoRecord.sid);
colBreaks = new PageBreakRecord(PageBreakRecord.VERTICAL_SID);
records.add(loc, colBreaks);
}
colBreaks.addBreak(column, fromRow, toRow);
|
| public void | setColumnGroupCollapsed(short columnNumber, boolean collapsed)
if (collapsed)
{
columns.collapseColumn( columnNumber );
}
else
{
columns.expandColumn( columnNumber );
}
|
| public void | setColumnHidden(short column, boolean hidden)Get the hidden property for a given column.
setColumn( column, null, null, new Boolean(hidden), null);
|
| public void | setColumnWidth(short column, short width)set the width for a given column in 1/20th of a character width units
setColumn( column, new Short(width), null, null, null);
|
| public void | setDefaultColumnWidth(short dcw)set the default column width for the sheet (if the columns do not define their own width)
defaultcolwidth.setColWidth(dcw);
|
| public void | setDefaultRowHeight(short dch)set the default row height for the sheet (if the rows do not define their own height)
defaultrowheight.setRowHeight(dch);
|
| public void | setDimensions(int firstrow, short firstcol, int lastrow, short lastcol)Per an earlier reported bug in working with Andy Khan's excel read library. This
sets the values in the sheet's DimensionsRecord object to be correct. Excel doesn't
really care, but we want to play nice with other libraries.
if (log.check( POILogger.DEBUG ))
{
log.log(POILogger.DEBUG, "Sheet.setDimensions");
log.log(POILogger.DEBUG,
(new StringBuffer("firstrow")).append(firstrow)
.append("firstcol").append(firstcol).append("lastrow")
.append(lastrow).append("lastcol").append(lastcol)
.toString());
}
dims.setFirstCol(firstcol);
dims.setFirstRow(firstrow);
dims.setLastCol(lastcol);
dims.setLastRow(lastrow);
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "Sheet.setDimensions exiting");
|
| public void | setDisplayFormulas(boolean show)Sets whether the formulas are shown in a viewer.
windowTwo.setDisplayFormulas(show);
|
| public void | setDisplayGridlines(boolean show)Sets whether the gridlines are shown in a viewer.
windowTwo.setDisplayGridlines(show);
|
| public void | setDisplayRowColHeadings(boolean show)Sets whether the RowColHeadings are shown in a viewer.
windowTwo.setDisplayRowColHeadings(show);
|
| public void | setFooter(org.apache.poi.hssf.record.FooterRecord newFooter)Sets the FooterRecord.
footer = newFooter;
|
| public void | setGridsPrinted(boolean value)set whether gridlines printed or not.
gridset.setGridset(!value);
|
| public void | setHeader(org.apache.poi.hssf.record.HeaderRecord newHeader)Sets the HeaderRecord.
header = newHeader;
|
| public void | setLeftCol(short leftCol)Sets the left column to show in desktop window pane.
if (windowTwo!=null)
{
windowTwo.setLeftCol(leftCol);
}
|
| public void | setLoc(int loc)set the locator for where we should look for the next value record. The
algorythm will actually start here and find the correct location so you
can set this to 0 and watch performance go down the tubes but it will work.
After a value is set this is automatically advanced. Its also set by the
create method. So you probably shouldn't mess with this unless you have
a compelling reason why or the help for the method you're calling says so.
Check the other methods for whether they care about
the loc pointer. Many of the "modify" and "remove" methods re-initialize this
to "dimsloc" which is the location of the Dimensions Record and presumably the
start of the value section (at or around 19 dec).
valueRecIterator = null;
if (log.check( POILogger.DEBUG ))
log.log(POILogger.DEBUG, "sheet.setLoc(): " + loc);
this.loc = loc;
|
| public void | setMargin(short margin, double size)Sets the size of the margin in inches.
Margin m = getMargins()[margin];
if (m == null) {
switch ( margin )
{
case LeftMargin:
m = new LeftMarginRecord();
records.add( getDimsLoc() + 1, m );
break;
case RightMargin:
m = new RightMarginRecord();
records.add( getDimsLoc() + 1, m );
break;
case TopMargin:
m = new TopMarginRecord();
records.add( getDimsLoc() + 1, m );
break;
case BottomMargin:
m = new BottomMarginRecord();
records.add( getDimsLoc() + 1, m );
break;
default :
throw new RuntimeException( "Unknown margin constant: " + margin );
}
margins[margin] = m;
}
m.setMargin( size );
|
| public void | setPreOffset(int offset)Set the preoffset when using DBCELL records (currently unused) - this is
the position of this sheet within the whole file.
this.preoffset = offset;
|
| public void | setPrintGridlines(org.apache.poi.hssf.record.PrintGridlinesRecord newPrintGridlines)Sets the PrintGridlinesRecord.
printGridlines = newPrintGridlines;
|
| public void | setPrintSetup(org.apache.poi.hssf.record.PrintSetupRecord newPrintSetup)Sets the PrintSetupRecord.
printSetup = newPrintSetup;
|
| public void | setRowBreak(int row, short fromCol, short toCol)Sets a page break at the indicated row
if (rowBreaks == null) {
int loc = findFirstRecordLocBySid(WindowTwoRecord.sid);
rowBreaks = new PageBreakRecord(PageBreakRecord.HORIZONTAL_SID);
records.add(loc, rowBreaks);
}
rowBreaks.addBreak((short)row, fromCol, toCol);
|
| public void | setRowGroupCollapsed(int row, boolean collapse)
if (collapse)
{
rows.collapseRow( row );
}
else
{
rows.expandRow( row );
}
|
| public void | setSCLRecord(org.apache.poi.hssf.record.SCLRecord sclRecord)Sets the SCL record or creates it in the correct place if it does not
already exist.
int oldRecordLoc = findFirstRecordLocBySid(SCLRecord.sid);
if (oldRecordLoc == -1)
{
// Insert it after the window record
int windowRecordLoc = findFirstRecordLocBySid(WindowTwoRecord.sid);
records.add(windowRecordLoc+1, sclRecord);
}
else
{
records.set(oldRecordLoc, sclRecord);
}
|
| public void | setSelected(boolean sel)Sets whether the sheet is selected
windowTwo.setSelected(sel);
|
| public void | setSelection(org.apache.poi.hssf.record.SelectionRecord selection)
this.selection = selection;
|
| public void | setTopRow(short topRow)
if (windowTwo!=null)
{
windowTwo.setTopRow(topRow);
}
|
| public void | shiftBreaks(org.apache.poi.hssf.record.PageBreakRecord breaks, short start, short stop, int count)Shifts all the page breaks in the range "count" number of rows/columns
if(rowBreaks == null)
return;
Iterator iterator = breaks.getBreaksIterator();
List shiftedBreak = new ArrayList();
while(iterator.hasNext())
{
PageBreakRecord.Break breakItem = (PageBreakRecord.Break)iterator.next();
short breakLocation = breakItem.main;
boolean inStart = (breakLocation >= start);
boolean inEnd = (breakLocation <= stop);
if(inStart && inEnd)
shiftedBreak.add(breakItem);
}
iterator = shiftedBreak.iterator();
while (iterator.hasNext()) {
PageBreakRecord.Break breakItem = (PageBreakRecord.Break)iterator.next();
breaks.removeBreak(breakItem.main);
breaks.addBreak((short)(breakItem.main+count), breakItem.subFrom, breakItem.subTo);
}
|
| public void | shiftColumnBreaks(short startingCol, short endingCol, short count)Shifts the vertical page breaks for the indicated count
shiftBreaks(colBreaks, startingCol, endingCol, count);
|
| public void | shiftRowBreaks(int startingRow, int endingRow, int count)Shifts the horizontal page breaks for the indicated count
shiftBreaks(rowBreaks, (short)startingRow, (short)endingRow, (short)count);
|
