1 /
55
56 package org.apache.poi.hssf.model;
57
58 import java.util.List;
59 import java.util.ArrayList;
60 import java.util.Iterator;
61
62 import org.apache.poi.hssf
63 .record.*;
64 import org.apache.poi.hssf.record.formula.Ptg;
65 import org.apache.poi.util.*;
66 import org.apache.poi.hssf.record
67 .aggregates.*;
68
69
90
91 public class Sheet implements Model
92 {
93 public static final short LeftMargin = 0;
94 public static final short RightMargin = 1;
95 public static final short TopMargin = 2;
96 public static final short BottomMargin = 3;
97
98 protected ArrayList records = null;
99 int preoffset = 0;
100 int loc = 0;
101 protected boolean containsLabels = false;
102 protected int dimsloc = 0;
103 protected DimensionsRecord dims;
104 protected DefaultColWidthRecord defaultcolwidth = null;
105 protected DefaultRowHeightRecord defaultrowheight = null;
106 protected GridsetRecord gridset = null;
107 protected PrintSetupRecord printSetup = null;
108 protected HeaderRecord header = null;
109 protected FooterRecord footer = null;
110 protected PrintGridlinesRecord printGridlines = null;
111 protected MergeCellsRecord merged = null;
112 protected SelectionRecord selection = null;
113 protected int mergedloc = 0;
114 private static POILogger log = POILogFactory.getLogger(Sheet.class);
115 private ArrayList columnSizes = null;
116 protected ValueRecordsAggregate cells = null;
117 protected RowRecordsAggregate rows = null;
118 private Iterator valueRecIterator = null;
119 private Iterator rowRecIterator = null;
120 protected int eofLoc = 0;
121
122 public static final byte PANE_LOWER_RIGHT = (byte)0;
123 public static final byte PANE_UPPER_RIGHT = (byte)1;
124 public static final byte PANE_LOWER_LEFT = (byte)2;
125 public static final byte PANE_UPPER_LEFT = (byte)3;
126
127
131 public Sheet()
132 {
133 }
134
135
152 public static Sheet createSheet(List recs, int sheetnum, int offset)
153 {
154 log.logFormatted(log.DEBUG,
155 "Sheet createSheet (existing file) with %",
156 new Integer(recs.size()));
157 Sheet retval = new Sheet();
158 ArrayList records = new ArrayList(recs.size() / 5);
159 boolean isfirstcell = true;
160 boolean isfirstrow = true;
161 int bofEofNestingLevel = 0;
162
163 for (int k = offset; k < recs.size(); k++)
164 {
165 Record rec = ( Record ) recs.get(k);
166
167 if (rec.getSid() == LabelRecord.sid)
168 {
169 log.log(log.DEBUG, "Hit label record.");
170 retval.containsLabels = true;
171 }
172 else if (rec.getSid() == BOFRecord.sid)
173 {
174 bofEofNestingLevel++;
175 log.log(log.DEBUG, "Hit BOF record. Nesting increased to " + bofEofNestingLevel);
176 }
177 else if (rec.getSid() == EOFRecord.sid)
178 {
179 --bofEofNestingLevel;
180 log.log(log.DEBUG, "Hit EOF record. Nesting decreased to " + bofEofNestingLevel);
181 if (bofEofNestingLevel == 0) {
182 records.add(rec);
183 retval.eofLoc = k;
184 break;
185 }
186 }
187 else if (rec.getSid() == DimensionsRecord.sid)
188 {
189 retval.dims = ( DimensionsRecord ) rec;
190 retval.dimsloc = records.size();
191 }
192 else if (rec.getSid() == MergeCellsRecord.sid)
193 {
194 retval.merged = ( MergeCellsRecord ) rec;
195 retval.mergedloc = k - offset;
196 }
197 else if (rec.getSid() == ColumnInfoRecord.sid)
198 {
199 if (retval.columnSizes == null)
200 {
201 retval.columnSizes = new ArrayList();
202 }
203 retval.columnSizes.add(rec);
204 }
205 else if (rec.getSid() == DefaultColWidthRecord.sid)
206 {
207 retval.defaultcolwidth = ( DefaultColWidthRecord ) rec;
208 }
209 else if (rec.getSid() == DefaultRowHeightRecord.sid)
210 {
211 retval.defaultrowheight = ( DefaultRowHeightRecord ) rec;
212 }
213 else if ( rec.isValue() && bofEofNestingLevel == 1 )
214 {
215 if ( isfirstcell )
216 {
217 retval.cells = new ValueRecordsAggregate();
218 rec = retval.cells;
219 retval.cells.construct( k, recs );
220 isfirstcell = false;
221 }
222 else
223 {
224 rec = null;
225 }
226 }
227 else if ( rec.getSid() == StringRecord.sid )
228 {
229 rec = null;
230 }
231 else if ( rec.getSid() == RowRecord.sid )
232 {
233 if ( isfirstrow )
234 {
235 retval.rows = new RowRecordsAggregate();
236 rec = retval.rows;
237 retval.rows.construct( k, recs );
238 isfirstrow = false;
239 }
240 else
241 {
242 rec = null;
243 }
244 }
245 else if ( rec.getSid() == PrintGridlinesRecord.sid )
246 {
247 retval.printGridlines = (PrintGridlinesRecord) rec;
248 }
249 else if ( rec.getSid() == HeaderRecord.sid )
250 {
251 retval.header = (HeaderRecord) rec;
252 }
253 else if ( rec.getSid() == FooterRecord.sid )
254 {
255 retval.footer = (FooterRecord) rec;
256 }
257 else if ( rec.getSid() == PrintSetupRecord.sid )
258 {
259 retval.printSetup = (PrintSetupRecord) rec;
260 }
261 else if ( rec.getSid() == SelectionRecord.sid )
262 {
263 retval.selection = (SelectionRecord) rec;
264 }
265
266 if (rec != null)
267 {
268 records.add(rec);
269 }
270 }
271 retval.records = records;
272 if (retval.rows == null)
273 {
274 retval.rows = new RowRecordsAggregate();
275 }
276 if (retval.cells == null)
277 {
278 retval.cells = new ValueRecordsAggregate();
279 }
280 log.log(log.DEBUG, "sheet createSheet (existing file) exited");
281 return retval;
282 }
283
284
287 public Sheet cloneSheet()
288 {
289 ArrayList clonedRecords = new ArrayList(this.records.size());
290 for (int i=0; i<this.records.size();i++) {
291 Record rec = (Record)((Record)this.records.get(i)).clone();
292
293
294
295
296 if (rec instanceof RowRecordsAggregate) {
297 RowRecordsAggregate rrAgg = (RowRecordsAggregate)rec;
298 for (Iterator rowIter = rrAgg.getIterator();rowIter.hasNext();) {
299 Record rowRec = (Record)rowIter.next();
300 clonedRecords.add(rowRec);
301 }
302 } else if (rec instanceof ValueRecordsAggregate) {
303 ValueRecordsAggregate vrAgg = (ValueRecordsAggregate)rec;
304 for (Iterator cellIter = vrAgg.getIterator();cellIter.hasNext();) {
305 Record valRec = (Record)cellIter.next();
306 clonedRecords.add(valRec);
307 }
308 } else if (rec instanceof FormulaRecordAggregate) {
309 FormulaRecordAggregate fmAgg = (FormulaRecordAggregate)rec;
310 Record fmAggRec = fmAgg.getFormulaRecord();
311 if (fmAggRec != null)
312 clonedRecords.add(fmAggRec);
313 fmAggRec = fmAgg.getStringRecord();
314 if (fmAggRec != null)
315 clonedRecords.add(fmAggRec);
316 } else {
317 clonedRecords.add(rec);
318 }
319 }
320 return createSheet(clonedRecords, 0, 0);
321 }
322
323
324
332
333 public static Sheet createSheet(List records, int sheetnum)
334 {
335 log.log(log.DEBUG,
336 "Sheet createSheet (exisiting file) assumed offset 0");
337 return createSheet(records, sheetnum, 0);
338 }
339
340
347
348 public static Sheet createSheet()
349 {
350 log.log(log.DEBUG, "Sheet createsheet from scratch called");
351 Sheet retval = new Sheet();
352 ArrayList records = new ArrayList(30);
353
354 records.add(retval.createBOF());
355
356
357 records.add(retval.createCalcMode());
358 records.add(retval.createCalcCount() );
359 records.add( retval.createRefMode() );
360 records.add( retval.createIteration() );
361 records.add( retval.createDelta() );
362 records.add( retval.createSaveRecalc() );
363 records.add( retval.createPrintHeaders() );
364 retval.printGridlines = (PrintGridlinesRecord) retval.createPrintGridlines();
365 records.add( retval.printGridlines );
366 retval.gridset = (GridsetRecord) retval.createGridset();
367 records.add( retval.gridset );
368 records.add( retval.createGuts() );
369 retval.defaultrowheight =
370 (DefaultRowHeightRecord) retval.createDefaultRowHeight();
371 records.add( retval.defaultrowheight );
372 records.add( retval.createWSBool() );
373 retval.header = (HeaderRecord) retval.createHeader();
374 records.add( retval.header );
375 retval.footer = (FooterRecord) retval.createFooter();
376 records.add( retval.footer );
377 records.add( retval.createHCenter() );
378 records.add( retval.createVCenter() );
379 retval.printSetup = (PrintSetupRecord) retval.createPrintSetup();
380 records.add( retval.printSetup );
381 retval.defaultcolwidth =
382 (DefaultColWidthRecord) retval.createDefaultColWidth();
383 records.add( retval.defaultcolwidth);
384 retval.dims = ( DimensionsRecord ) retval.createDimensions();
385 retval.dimsloc = 19;
386 records.add(retval.dims);
387 records.add(retval.createWindowTwo());
388 retval.setLoc(records.size() - 1);
389 retval.selection =
390 (SelectionRecord) retval.createSelection();
391 records.add(retval.selection);
392 records.add(retval.createEOF());
393 retval.records = records;
394 log.log(log.DEBUG, "Sheet createsheet from scratch exit");
395 return retval;
396 }
397
398 private void checkCells()
399 {
400 if (cells == null)
401 {
402 cells = new ValueRecordsAggregate();
403 records.add(getDimsLoc() + 1, cells);
404 }
405 }
406
407 private void checkRows()
408 {
409 if (rows == null)
410 {
411 rows = new RowRecordsAggregate();
412 records.add(getDimsLoc() + 1, rows);
413 }
414 }
415
416
417 public int addMergedRegion(int rowFrom, short colFrom, int rowTo,
418 short colTo)
419 {
420 if (merged == null)
421 {
422 merged = ( MergeCellsRecord ) createMergedCells();
423 mergedloc = records.size() - 1;
424 records.add(records.size() - 1, merged);
425 }
426 return merged.addArea(rowFrom, colFrom, rowTo, colTo);
427 }
428
429 public void removeMergedRegion(int index)
430 {
431 merged.removeAreaAt(index);
432 if (merged.getNumAreas() == 0)
433 {
434 merged = null;
435 records.remove(mergedloc);
436 mergedloc = 0;
437 }
438 }
439
440 public MergeCellsRecord.MergedRegion getMergedRegionAt(int index)
441 {
442 return merged.getAreaAt(index);
443 }
444
445 public int getNumMergedRegions()
446 {
447 return merged!=null ? merged.getNumAreas() : 0;
448 }
449
450
451
466
467 public void convertLabelRecords(Workbook wb)
468 {
469 log.log(log.DEBUG, "convertLabelRecords called");
470 if (containsLabels)
471 {
472 for (int k = 0; k < records.size(); k++)
473 {
474 Record rec = ( Record ) records.get(k);
475
476 if (rec.getSid() == LabelRecord.sid)
477 {
478 LabelRecord oldrec = ( LabelRecord ) rec;
479
480 records.remove(k);
481 LabelSSTRecord newrec = new LabelSSTRecord();
482 int stringid =
483 wb.addSSTString(oldrec.getValue());
484
485 newrec.setRow(oldrec.getRow());
486 newrec.setColumn(oldrec.getColumn());
487 newrec.setXFIndex(oldrec.getXFIndex());
488 newrec.setSSTIndex(stringid);
489 records.add(k, newrec);
490 }
491 }
492 }
493 log.log(log.DEBUG, "convertLabelRecords exit");
494 }
495
496
502
503 public int getNumRecords()
504 {
505 checkCells();
506 checkRows();
507 log.log(log.DEBUG, "Sheet.getNumRecords");
508 log.logFormatted(log.DEBUG, "returning % + % + % - 2 = %", new int[]
509 {
510 records.size(), cells.getPhysicalNumberOfCells(),
511 rows.getPhysicalNumberOfRows(),
512 records.size() + cells.getPhysicalNumberOfCells()
513 + rows.getPhysicalNumberOfRows() - 2
514 });
515 return records.size() + cells.getPhysicalNumberOfCells()
516 + rows.getPhysicalNumberOfRows() - 2;
517 }
518
519
526
527
528 public void setDimensions(int firstrow, short firstcol, int lastrow,
529 short lastcol)
530 {
531 log.log(log.DEBUG, "Sheet.setDimensions");
532 log.log(log.DEBUG,
533 (new StringBuffer("firstrow")).append(firstrow)
534 .append("firstcol").append(firstcol).append("lastrow")
535 .append(lastrow).append("lastcol").append(lastcol)
536 .toString());
537 dims.setFirstCol(firstcol);
538 dims.setFirstRow(firstrow);
539 dims.setLastCol(lastcol);
540 dims.setLastRow(lastrow);
541 log.log(log.DEBUG, "Sheet.setDimensions exiting");
542 }
543
544
559
560 public void setLoc(int loc)
561 {
562 valueRecIterator = null;
563 log.log(log.DEBUG, "sheet.setLoc(): " + loc);
564 this.loc = loc;
565 }
566
567
571
572 public int getLoc()
573 {
574 log.log(log.DEBUG, "sheet.getLoc():" + loc);
575 return loc;
576 }
577
578
584
585 public void setPreOffset(int offset)
586 {
587 this.preoffset = offset;
588 }
589
590
596
597 public int getPreOffset()
598 {
599 return preoffset;
600 }
601
602
609
610 public byte [] serialize()
611 {
612 log.log(log.DEBUG, "Sheet.serialize");
613
614
615 byte[] retval = null;
616
617
618 int arraysize = getSize();
619 int pos = 0;
620
621
622
623
624
625
626
627
628
629
630
631
632 retval = new byte[ arraysize ];
633 for (int k = 0; k < records.size(); k++)
634 {
635
636
637
638 pos += (( Record ) records.get(k)).serialize(pos,
639 retval);
640 }
641 log.log(log.DEBUG, "Sheet.serialize returning " + retval);
642 return retval;
643 }
644
645
653
654 public int serialize(int offset, byte [] data)
655 {
656 log.log(log.DEBUG, "Sheet.serialize using offsets");
657
658
659
660
661 int pos = 0;
662
663
664
665
666
667
668
669
670
671
672
673
674 for (int k = 0; k < records.size(); k++)
675 {
676
677
678 Record record = (( Record ) records.get(k));
679
680
681
682
683
684
685
686
687 pos += record.serialize(pos + offset, data );
688
689 }
690 log.log(log.DEBUG, "Sheet.serialize returning ");
691 return pos;
692 }
693
694
701
702 public RowRecord createRow(int row)
703 {
704 log.log(log.DEBUG, "create row number " + row);
705 RowRecord rowrec = new RowRecord();
706
707
708 rowrec.setRowNumber(row);
709 rowrec.setHeight(( short ) 0xff);
710 rowrec.setOptimize(( short ) 0x0);
711 rowrec.setOptionFlags(( short ) 0x0);
712 rowrec.setXFIndex(( short ) 0x0);
713 return rowrec;
714 }
715
716
725
726
727 public LabelSSTRecord createLabelSST(int row, short col, int index)
728 {
729 log.logFormatted(log.DEBUG, "create labelsst row,col,index %,%,%",
730 new int[]
731 {
732 row, col, index
733 });
734 LabelSSTRecord rec = new LabelSSTRecord();
735
736 rec.setRow(row);
737 rec.setColumn(col);
738 rec.setSSTIndex(index);
739 rec.setXFIndex(( short ) 0x0f);
740 return rec;
741 }
742
743
752
753
754 public NumberRecord createNumber(int row, short col, double value)
755 {
756 log.logFormatted(log.DEBUG, "create number row,col,value %,%,%",
757 new double[]
758 {
759 row, col, value
760 });
761 NumberRecord rec = new NumberRecord();
762
763
764 rec.setRow(row);
765 rec.setColumn(col);
766 rec.setValue(value);
767 rec.setXFIndex(( short ) 0x0f);
768 return rec;
769 }
770
771
777
778
779 public BlankRecord createBlank(int row, short col)
780 {
781
782 log.logFormatted(log.DEBUG, "create blank row,col %,%", new int[]
783 {
784 row, col
785 });
786 BlankRecord rec = new BlankRecord();
787
788
789 rec.setRow(row);
790 rec.setColumn(col);
791 rec.setXFIndex(( short ) 0x0f);
792 return rec;
793 }
794
795
804
805
806 public FormulaRecord createFormula(int row, short col, String formula)
807 {
808 log.logFormatted(log.DEBUG, "create formula row,col,formula %,%,%",
809
810 new int[]
811 {
812 row, col
813 }, formula);
814 FormulaRecord rec = new FormulaRecord();
815
816 rec.setRow(row);
817 rec.setColumn(col);
818 rec.setOptions(( short ) 2);
819 rec.setValue(0);
820 rec.setXFIndex(( short ) 0x0f);
821 FormulaParser fp = new FormulaParser(formula,null);
822 fp.parse();
823 Ptg[] ptg = fp.getRPNPtg();
824 int size = 0;
825
826 for (int k = 0; k < ptg.length; k++)
827 {
828 size += ptg[ k ].getSize();
829 rec.pushExpressionToken(ptg[ k ]);
830 }
831 rec.setExpressionLength(( short ) size);
832 return rec;
833 }
834
835
847
848
849 public void addValueRecord(int row, CellValueRecordInterface col)
850 {
851 checkCells();
852 log.logFormatted(log.DEBUG, "add value record row,loc %,%", new int[]
853 {
854 row, loc
855 });
856 DimensionsRecord d = ( DimensionsRecord ) records.get(getDimsLoc());
857
858 if (col.getColumn() > d.getLastCol())
859 {
860 d.setLastCol(( short ) (col.getColumn() + 1));
861 }
862 if (col.getColumn() < d.getFirstCol())
863 {
864 d.setFirstCol(col.getColumn());
865 }
866 cells.insertCell(col);
867
868
890 }
891
892
901
902
903 public void removeValueRecord(int row, CellValueRecordInterface col)
904 {
905 checkCells();
906 log.logFormatted(log.DEBUG, "remove value record row,dimsloc %,%",
907 new int[]
908 {
909 row, dimsloc
910 });
911 loc = dimsloc;
912 cells.removeCell(col);
913
914
934 }
935
936
945
946 public void replaceValueRecord(CellValueRecordInterface newval)
947 {
948 checkCells();
949 setLoc(dimsloc);
950 log.log(log.DEBUG, "replaceValueRecord ");
951 cells.insertCell(newval);
952
953
968 }
969
970
982
983 public void addRow(RowRecord row)
984 {
985 checkRows();
986 log.log(log.DEBUG, "addRow ");
987 DimensionsRecord d = ( DimensionsRecord ) records.get(getDimsLoc());
988
989 if (row.getRowNumber() > d.getLastRow())
990 {
991 d.setLastRow(row.getRowNumber() + 1);
992 }
993 if (row.getRowNumber() < d.getFirstRow())
994 {
995 d.setFirstRow(row.getRowNumber());
996 }
997
998
999 RowRecord existingRow = rows.getRow(row.getRowNumber());
1000 if (existingRow != null)
1001 rows.removeRow(existingRow);
1002
1003 rows.insertRow(row);
1004
1005
1040 log.log(log.DEBUG, "exit addRow");
1041 }
1042
1043
1050
1051 public void removeRow(RowRecord row)
1052 {
1053 checkRows();
1054
1055
1056 setLoc(getDimsLoc());
1057 rows.removeRow(row);
1058
1059
1081 }
1082
1083
1097
1098 public CellValueRecordInterface getNextValueRecord()
1099 {
1100 log.log(log.DEBUG, "getNextValue loc= " + loc);
1101 if (valueRecIterator == null)
1102 {
1103 valueRecIterator = cells.getIterator();
1104 }
1105 if (!valueRecIterator.hasNext())
1106 {
1107 return null;
1108 }
1109 return ( CellValueRecordInterface ) valueRecIterator.next();
1110
1111
1127 }
1128
1129
1144
1145
1169
1170
1184
1185 public RowRecord getNextRow()
1186 {
1187 log.log(log.DEBUG, "getNextRow loc= " + loc);
1188 if (rowRecIterator == null)
1189 {
1190 rowRecIterator = rows.getIterator();
1191 }
1192 if (!rowRecIterator.hasNext())
1193 {
1194 return null;
1195 }
1196 return ( RowRecord ) rowRecIterator.next();
1197
1198
1211 }
1212
1213
1229
1230
1231 public RowRecord getRow(int rownum)
1232 {
1233 log.log(log.DEBUG, "getNextRow loc= " + loc);
1234 return rows.getRow(rownum);
1235
1236
1254
1255
1256 }
1257
1258
1262
1263 public void addDBCellRecords()
1264 {
1265 int offset = 0;
1266 int recnum = 0;
1267 int rownum = 0;
1268
1269
1270 IndexRecord index = null;
1271
1272
1273 IntList rowOffsets = new IntList();
1274
1275 for (recnum = 0; recnum < records.size(); recnum++)
1276 {
1277 Record rec = ( Record ) records.get(recnum);
1278
1279 if (rec.getSid() == IndexRecord.sid)
1280 {
1281 index = ( IndexRecord ) rec;
1282 }
1283 if (rec.getSid() != RowRecord.sid)
1284 {
1285 offset += rec.serialize().length;
1286 }
1287 else
1288 {
1289 break;
1290 }
1291 }
1292
1293
1294 for (; recnum < records.size(); recnum++)
1295 {
1296 Record rec = ( Record ) records.get(recnum);
1297
1298 if (rec.getSid() == RowRecord.sid)
1299 {
1300 rownum++;
1301 rowOffsets.add(offset);
1302 if ((rownum % 32) == 0)
1303 {
1304
1305
1306
1307 for (int rn = recnum; rn < records.size(); rn++)
1308 {
1309 rec = ( Record ) records.get(rn);
1310 if ((!rec.isInValueSection())
1311 || (rec.getSid() == RowRecord.sid))
1312 {
1313
1314
1315 records.add(rn,
1316 createDBCell(offset, rowOffsets,
1317 index));
1318 recnum = rn;
1319 break;
1320 }
1321 }
1322 }
1323 else
1324 {
1325 }
1326 }
1327 if (!rec.isInValueSection())
1328 {
1329 records.add(recnum, createDBCell(offset, rowOffsets, index));
1330 break;
1331 }
1332 offset += rec.serialize().length;
1333 }
1334 }
1335
1336
1337
1338 private DBCellRecord createDBCell(int offset, IntList rowoffsets,
1339 IndexRecord index)
1340 {
1341 DBCellRecord rec = new DBCellRecord();
1342
1343 rec.setRowOffset(offset - rowoffsets.get(0));
1344
1345
1346 rec.addCellOffset(( short ) 0x0);
1347
1348
1349 addDbCellToIndex(offset, index);
1350 return rec;
1351 }
1352
1353
1354
1355 private void addDbCellToIndex(int offset, IndexRecord index)
1356 {
1357 int numdbcells = index.getNumDbcells() + 1;
1358
1359 index.addDbcell(offset + preoffset);
1360
1361
1362 for (int k = 0; k < numdbcells; k++)
1363 {
1364 int dbval = index.getDbcellAt(k);
1365
1366 index.setDbcell(k, dbval + 4);
1367 }
1368 }
1369
1370
1376
1377 protected Record createBOF()
1378 {
1379 BOFRecord retval = new BOFRecord();
1380
1381 retval.setVersion(( short ) 0x600);
1382 retval.setType(( short ) 0x010);
1383
1384
1385 retval.setBuild(( short ) 0x0dbb);
1386 retval.setBuildYear(( short ) 1996);
1387 retval.setHistoryBitMask(0xc1);
1388 retval.setRequiredVersion(0x6);
1389 return retval;
1390 }
1391
1392
1398
1399 protected Record createIndex()
1400 {
1401 IndexRecord retval = new IndexRecord();
1402
1403 retval.setFirstRow(0);
1404 retval.setLastRowAdd1(0);
1405 return retval;
1406 }
1407
1408
1414
1415 protected Record createCalcMode()
1416 {
1417 CalcModeRecord retval = new CalcModeRecord();
1418
1419 retval.setCalcMode(( short ) 1);
1420 return retval;
1421 }
1422
1423
1429
1430 protected Record createCalcCount()
1431 {
1432 CalcCountRecord retval = new CalcCountRecord();
1433
1434 retval.setIterations(( short ) 0x64);
1435 return retval;
1436 }
1437
1438
1444
1445 protected Record createRefMode()
1446 {
1447 RefModeRecord retval = new RefModeRecord();
1448
1449 retval.setMode(retval.USE_A1_MODE);
1450 return retval;
1451 }
1452
1453
1459
1460 protected Record createIteration()
1461 {
1462 IterationRecord retval = new IterationRecord();
1463
1464 retval.setIteration(false);
1465 return retval;
1466 }
1467
1468
1474
1475 protected Record createDelta()
1476 {
1477 DeltaRecord retval = new DeltaRecord();
1478
1479 retval.setMaxChange(0.0010);
1480 return retval;
1481 }
1482
1483
1489
1490 protected Record createSaveRecalc()
1491 {
1492 SaveRecalcRecord retval = new SaveRecalcRecord();
1493
1494 retval.setRecalc(true);
1495 return retval;
1496 }
1497
1498
1504
1505 protected Record createPrintHeaders()
1506 {
1507 PrintHeadersRecord retval = new PrintHeadersRecord();
1508
1509 retval.setPrintHeaders(false);
1510 return retval;
1511 }
1512
1513
1521
1522 protected Record createPrintGridlines()
1523 {
1524 PrintGridlinesRecord retval = new PrintGridlinesRecord();
1525
1526 retval.setPrintGridlines(false);
1527 return retval;
1528 }
1529
1530
1536
1537 protected Record createGridset()
1538 {
1539 GridsetRecord retval = new GridsetRecord();
1540
1541 retval.setGridset(true);
1542 return retval;
1543 }
1544
1545
1551
1552 protected Record createGuts()
1553 {
1554 GutsRecord retval = new GutsRecord();
1555
1556 retval.setLeftRowGutter(( short ) 0);
1557 retval.setTopColGutter(( short ) 0);
1558 retval.setRowLevelMax(( short ) 0);
1559 retval.setColLevelMax(( short ) 0);
1560 return retval;
1561 }
1562
1563
1569
1570 protected Record createDefaultRowHeight()
1571 {
1572 DefaultRowHeightRecord retval = new DefaultRowHeightRecord();
1573
1574 retval.setOptionFlags(( short ) 0);
1575 retval.setRowHeight(( short ) 0xff);
1576 return retval;
1577 }
1578
1579
1585
1586 protected Record createWSBool()
1587 {
1588 WSBoolRecord retval = new WSBoolRecord();
1589
1590 retval.setWSBool1(( byte ) 0x4);
1591 retval.setWSBool2(( byte ) 0xffffffc1);
1592 return retval;
1593 }
1594
1595
1601
1602 protected Record createHeader()
1603 {
1604 HeaderRecord retval = new HeaderRecord();
1605
1606 retval.setHeaderLength(( byte ) 0);
1607 retval.setHeader(null);
1608 return retval;
1609 }
1610
1611
1617
1618 protected Record createFooter()
1619 {
1620 FooterRecord retval = new FooterRecord();
1621
1622 retval.setFooterLength(( byte ) 0);
1623 retval.setFooter(null);
1624 return retval;
1625 }
1626
1627
1633
1634 protected Record createHCenter()
1635 {
1636 HCenterRecord retval = new HCenterRecord();
1637
1638 retval.setHCenter(false);
1639 return retval;
1640 }
1641
1642
1648
1649 protected Record createVCenter()
1650 {
1651 VCenterRecord retval = new VCenterRecord();
1652
1653 retval.setVCenter(false);
1654 return retval;
1655 }
1656
1657
1663
1664 protected Record createPrintSetup()
1665 {
1666 PrintSetupRecord retval = new PrintSetupRecord();
1667
1668 retval.setPaperSize(( short ) 1);
1669 retval.setScale(( short ) 100);
1670 retval.setPageStart(( short ) 1);
1671 retval.setFitWidth(( short ) 1);
1672 retval.setFitHeight(( short ) 1);
1673 retval.setOptions(( short ) 2);
1674 retval.setHResolution(( short ) 300);
1675 retval.setVResolution(( short ) 300);
1676 retval.setHeaderMargin( 0.5);
1677 retval.setFooterMargin( 0.5);
1678 retval.setCopies(( short ) 0);
1679 return retval;
1680 }
1681
1682
1688
1689 protected Record createDefaultColWidth()
1690 {
1691 DefaultColWidthRecord retval = new DefaultColWidthRecord();
1692
1693 retval.setColWidth(( short ) 8);
1694 return retval;
1695 }
1696
1697
1702
1703 protected Record createColInfo()
1704 {
1705 ColumnInfoRecord retval = new ColumnInfoRecord();
1706
1707 retval.setColumnWidth(( short ) 0x8);
1708 retval.setOptions(( short ) 6);
1709 retval.setXFIndex(( short ) 0x0f);
1710 return retval;
1711 }
1712
1713
1717
1718 public short getDefaultColumnWidth()
1719 {
1720 return defaultcolwidth.getColWidth();
1721 }
1722
1723
1727
1728 public boolean isGridsPrinted()
1729 {
1730 return !gridset.getGridset();
1731 }
1732
1733
1737
1738 public void setGridsPrinted(boolean value)
1739 {
1740 gridset.setGridset(!value);
1741 }
1742
1743
1747
1748 public void setDefaultColumnWidth(short dcw)
1749 {
1750 defaultcolwidth.setColWidth(dcw);
1751 }
1752
1753
1756
1757 public void setDefaultRowHeight(short dch)
1758 {
1759 defaultrowheight.setRowHeight(dch);
1760 }
1761
1762
1766
1767 public short getDefaultRowHeight()
1768 {
1769 return defaultrowheight.getRowHeight();
1770 }
1771
1772
1780
1781 public short getColumnWidth(short column)
1782 {
1783 short retval = 0;
1784 ColumnInfoRecord ci = null;
1785 int k = 0;
1786
1787 if (columnSizes != null)
1788 {
1789 for (k = 0; k < columnSizes.size(); k++)
1790 {
1791 ci = ( ColumnInfoRecord ) columnSizes.get(k);
1792 if ((ci.getFirstColumn() >= column)
1793 && (column <= ci.getLastColumn()))
1794 {
1795 break;
1796 }
1797 ci = null;
1798 }
1799 }
1800 if (ci != null)
1801 {
1802 retval = ci.getColumnWidth();
1803 }
1804 else
1805 {
1806 retval = defaultcolwidth.getColWidth();
1807 }
1808 return retval;
1809 }
1810
1811
1816
1817 public void setColumnWidth(short column, short width)
1818 {
1819 ColumnInfoRecord ci = null;
1820 int k = 0;
1821
1822 if (columnSizes == null)
1823 {
1824 columnSizes = new ArrayList();
1825 }
1826
1827
1828 for (k = 0; k < columnSizes.size(); k++)
1829 {
1830 ci = ( ColumnInfoRecord ) columnSizes.get(k);
1831 if ((ci.getFirstColumn() >= column)
1832 && (column <= ci.getLastColumn()))
1833 {
1834 break;
1835 }
1836 ci = null;
1837 }
1838 if (ci != null)
1839 {
1840 if (ci.getColumnWidth() == width)
1841 {
1842
1843
1844 }
1845 else if ((ci.getFirstColumn() == column)
1846 && (ci.getLastColumn() == column))
1847 {
1848 ci.setColumnWidth(width);
1849 }
1850 else if ((ci.getFirstColumn() == column)
1851 || (ci.getLastColumn() == column))
1852 {
1853
1854
1855
1856 if (ci.getFirstColumn() == column)
1857 {
1858 ci.setFirstColumn(( short ) (column + 1));
1859 }
1860 else
1861 {
1862 ci.setLastColumn(( short ) (column - 1));
1863 }
1864 ColumnInfoRecord nci = ( ColumnInfoRecord ) createColInfo();
1865
1866 nci.setFirstColumn(column);
1867 nci.setLastColumn(column);
1868 nci.setOptions(ci.getOptions());
1869 nci.setXFIndex(ci.getXFIndex());
1870 nci.setColumnWidth(width);
1871 columnSizes.add(k, nci);
1872 records.add((1 + getDimsLoc() - columnSizes.size()) + k, nci);
1873 dimsloc++;
1874 }
1875 }
1876 else
1877 {
1878
1879
1880 ColumnInfoRecord nci = ( ColumnInfoRecord ) createColInfo();
1881
1882 nci.setFirstColumn(column);
1883 nci.setLastColumn(column);
1884 nci.setColumnWidth(width);
1885 columnSizes.add(k, nci);
1886 records.add((1 + getDimsLoc() - columnSizes.size()) + k, nci);
1887 dimsloc++;
1888 }
1889 }
1890
1891
1898
1899 protected Record createDimensions()
1900 {
1901 DimensionsRecord retval = new DimensionsRecord();
1902
1903 retval.setFirstCol(( short ) 0);
1904 retval.setLastRow(1);
1905 retval.setFirstRow(0);
1906 retval.setLastCol(( short ) 1);
1907 return retval;
1908 }
1909
1910
1922
1923 protected Record createWindowTwo()
1924 {
1925 WindowTwoRecord retval = new WindowTwoRecord();
1926
1927 retval.setOptions(( short ) 0x6b6);
1928 retval.setTopRow(( short ) 0);
1929 retval.setLeftCol(( short ) 0);
1930 retval.setHeaderColor(0x40);
1931 retval.setPageBreakZoom(( short ) 0);
1932 retval.setNormalZoom(( short ) 0);
1933 return retval;
1934 }
1935
1936
1943
1944 protected Record createSelection()
1945 {
1946 SelectionRecord retval = new SelectionRecord();
1947
1948 retval.setPane(( byte ) 0x3);
1949 retval.setActiveCellCol(( short ) 0x0);
1950 retval.setActiveCellRow(( short ) 0x0);
1951 retval.setNumRefs(( short ) 0x0);
1952 return retval;
1953 }
1954
1955
1961 public int getActiveCellRow()
1962 {
1963 if (selection == null)
1964 {
1965 return 0;
1966 }
1967 return selection.getActiveCellRow();
1968 }
1969
1970
1976 public void setActiveCellRow(int row)
1977 {
1978
1979 if (selection != null)
1980 {
1981 selection.setActiveCellRow(row);
1982 }
1983 }
1984
1985
1991 public short getActiveCellCol()
1992 {
1993 if (selection == null)
1994 {
1995 return (short) 0;
1996 }
1997 return selection.getActiveCellCol();
1998 }
1999
2000
2006 public void setActiveCellCol(short col)
2007 {
2008
2009 if (selection != null)
2010 {
2011 selection.setActiveCellCol(col);
2012 }
2013 }
2014
2015 protected Record createMergedCells()
2016 {
2017 MergeCellsRecord retval = new MergeCellsRecord();
2018
2019 retval.setNumAreas(( short ) 0);
2020 return retval;
2021 }
2022
2023
2029
2030 protected Record createEOF()
2031 {
2032 return new EOFRecord();
2033 }
2034
2035
2039
2040 public int getDimsLoc()
2041 {
2042 log.log(log.DEBUG, "getDimsLoc dimsloc= " + dimsloc);
2043 return dimsloc;
2044 }
2045
2046
2049
2050 public void checkDimsLoc(Record rec, int recloc)
2051 {
2052 if (rec.getSid() == DimensionsRecord.sid)
2053 {
2054 loc = recloc;
2055 dimsloc = recloc;
2056 }
2057 }
2058
2059 public int getSize()
2060 {
2061 int retval = 0;
2062
2063 for (int k = 0; k < records.size(); k++)
2064 {
2065 retval += (( Record ) records.get(k)).getRecordSize();
2066 }
2067 return retval;
2068 }
2069
2070 public List getRecords()
2071 {
2072 return records;
2073 }
2074
2075
2078
2079 public GridsetRecord getGridsetRecord()
2080 {
2081 return gridset;
2082 }
2083
2084
2087
2088 public Record findFirstRecordBySid(short sid)
2089 {
2090 for (Iterator iterator = records.iterator(); iterator.hasNext(); )
2091 {
2092 Record record = ( Record ) iterator.next();
2093
2094 if (record.getSid() == sid)
2095 {
2096 return record;
2097 }
2098 }
2099 return null;
2100 }
2101
2102
2108 public void setSCLRecord(SCLRecord sclRecord)
2109 {
2110 int oldRecordLoc = findFirstRecordLocBySid(SCLRecord.sid);
2111 if (oldRecordLoc == -1)
2112 {
2113
2114 int windowRecordLoc = findFirstRecordLocBySid(WindowTwoRecord.sid);
2115 records.add(windowRecordLoc+1, sclRecord);
2116 }
2117 else
2118 {
2119 records.set(oldRecordLoc, sclRecord);
2120 }
2121
2122 }
2123
2124
2131 public int findFirstRecordLocBySid( short sid )
2132 {
2133 int index = 0;
2134 for (Iterator iterator = records.iterator(); iterator.hasNext(); )
2135 {
2136 Record record = ( Record ) iterator.next();
2137
2138 if (record.getSid() == sid)
2139 {
2140 return index;
2141 }
2142 index++;
2143 }
2144 return -1;
2145 }
2146
2147
2151 public HeaderRecord getHeader ()
2152 {
2153 return header;
2154 }
2155
2156
2160 public void setHeader (HeaderRecord newHeader)
2161 {
2162 header = newHeader;
2163 }
2164
2165
2169 public FooterRecord getFooter ()
2170 {
2171 return footer;
2172 }
2173
2174
2178 public void setFooter (FooterRecord newFooter)
2179 {
2180 footer = newFooter;
2181 }
2182
2183
2187 public PrintSetupRecord getPrintSetup ()
2188 {
2189 return printSetup;
2190 }
2191
2192
2196 public void setPrintSetup (PrintSetupRecord newPrintSetup)
2197 {
2198 printSetup = newPrintSetup;
2199 }
2200
2201
2205 public PrintGridlinesRecord getPrintGridlines ()
2206 {
2207 return printGridlines;
2208 }
2209
2210
2214 public void setPrintGridlines (PrintGridlinesRecord newPrintGridlines)
2215 {
2216 printGridlines = newPrintGridlines;
2217 }
2218
2219
2223 public void setSelected(boolean sel) {
2224 WindowTwoRecord windowTwo = (WindowTwoRecord) findFirstRecordBySid(WindowTwoRecord.sid);
2225 windowTwo.setSelected(sel);
2226 }
2227
2228
2233 public double getMargin(short margin) {
2234 Margin m;
2235 switch ( margin )
2236 {
2237 case LeftMargin:
2238 m = (Margin) findFirstRecordBySid( LeftMarginRecord.sid );
2239 if ( m == null )
2240 return .75;
2241 break;
2242 case RightMargin:
2243 m = (Margin) findFirstRecordBySid( RightMarginRecord.sid );
2244 if ( m == null )
2245 return .75;
2246 break;
2247 case TopMargin:
2248 m = (Margin) findFirstRecordBySid( TopMarginRecord.sid );
2249 if ( m == null )
2250 return 1.0;
2251 break;
2252 case BottomMargin:
2253 m = (Margin) findFirstRecordBySid( BottomMarginRecord.sid );
2254 if ( m == null )
2255 return 1.0;
2256 break;
2257 default :
2258 throw new RuntimeException( "Unknown margin constant: " + margin );
2259 }
2260 return m.getMargin();
2261 }
2262
2263
2268 public void setMargin(short margin, double size) {
2269 Margin m;
2270 switch ( margin )
2271 {
2272 case LeftMargin:
2273 m = (Margin) findFirstRecordBySid( LeftMarginRecord.sid );
2274 if ( m == null )
2275 {
2276 m = new LeftMarginRecord();
2277 records.add( getDimsLoc() + 1, m );
2278 }
2279 break;
2280 case RightMargin:
2281 m = (Margin) findFirstRecordBySid( RightMarginRecord.sid );
2282 if ( m == null )
2283 {
2284 m = new RightMarginRecord();
2285 records.add( getDimsLoc() + 1, m );
2286 }
2287 break;
2288 case TopMargin:
2289 m = (Margin) findFirstRecordBySid( TopMarginRecord.sid );
2290 if ( m == null )
2291 {
2292 m = new TopMarginRecord();
2293 records.add( getDimsLoc() + 1, m );
2294 }
2295 break;
2296 case BottomMargin:
2297 m = (Margin) findFirstRecordBySid( BottomMarginRecord.sid );
2298 if ( m == null )
2299 {
2300 m = new BottomMarginRecord();
2301 records.add( getDimsLoc() + 1, m );
2302 }
2303 break;
2304 default :
2305 throw new RuntimeException( "Unknown margin constant: " + margin );
2306 }
2307 m.setMargin( size );
2308 }
2309
2310 public int getEofLoc()
2311 {
2312 return eofLoc;
2313 }
2314
2315
2322 public void createFreezePane(int colSplit, int rowSplit, int topRow, int leftmostColumn )
2323 {
2324 int loc = findFirstRecordLocBySid(WindowTwoRecord.sid);
2325 PaneRecord pane = new PaneRecord();
2326 pane.setX((short)colSplit);
2327 pane.setY((short)rowSplit);
2328 pane.setTopRow((short) topRow);
2329 pane.setLeftColumn((short) leftmostColumn);
2330 if (rowSplit == 0)
2331 {
2332 pane.setTopRow((short)0);
2333 pane.setActivePane((short)1);
2334 }
2335 else if (colSplit == 0)
2336 {
2337 pane.setLeftColumn((short)64);
2338 pane.setActivePane((short)2);
2339 }
2340 else
2341 {
2342 pane.setActivePane((short)0);
2343 }
2344 records.add(loc+1, pane);
2345
2346 WindowTwoRecord windowRecord = (WindowTwoRecord) records.get(loc);
2347 windowRecord.setFreezePanes(true);
2348 windowRecord.setFreezePanesNoSplit(true);
2349
2350 SelectionRecord sel = (SelectionRecord) findFirstRecordBySid(SelectionRecord.sid);
2351
2352
2353
2354
2355
2356 sel.setPane((byte)pane.getActivePane());
2357
2358
2359
2360
2361 int selLoc = findFirstRecordLocBySid(SelectionRecord.sid);
2362
2363
2364
2365
2366
2367
2368
2369
2370 }
2371
2372
2385 public void createSplitPane(int xSplitPos, int ySplitPos, int topRow, int leftmostColumn, int activePane )
2386 {
2387 int loc = findFirstRecordLocBySid(WindowTwoRecord.sid);
2388 PaneRecord r = new PaneRecord();
2389 r.setX((short)xSplitPos);
2390 r.setY((short)ySplitPos);
2391 r.setTopRow((short) topRow);
2392 r.setLeftColumn((short) leftmostColumn);
2393 r.setActivePane((short) activePane);
2394 records.add(loc+1, r);
2395
2396 WindowTwoRecord windowRecord = (WindowTwoRecord) records.get(loc);
2397 windowRecord.setFreezePanes(false);
2398 windowRecord.setFreezePanesNoSplit(false);
2399
2400 SelectionRecord sel = (SelectionRecord) findFirstRecordBySid(SelectionRecord.sid);
2401
2402
2403
2404 sel.setPane(PANE_LOWER_RIGHT);
2405
2406
2407
2408
2409
2410
2411 int selLoc = findFirstRecordLocBySid(SelectionRecord.sid);
2412
2413
2414
2415
2416
2417
2418
2419
2420 }
2421
2422 public SelectionRecord getSelection()
2423 {
2424 return selection;
2425 }
2426
2427 public void setSelection( SelectionRecord selection )
2428 {
2429 this.selection = selection;
2430 }
2431
2432 }
2433