|
/* ====================================================================
|
Licensed to the Apache Software Foundation (ASF) Under one or more
|
contributor license agreements. See the NOTICE file distributed with
|
this work for Additional information regarding copyright ownership.
|
The ASF licenses this file to You Under the Apache License, Version 2.0
|
(the "License"); you may not use this file except in compliance with
|
the License. You may obtain a copy of the License at
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
Unless required by applicable law or agreed to in writing, software
|
distributed Under the License is distributed on an "AS Is" BASIS,
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
See the License for the specific language governing permissions and
|
limitations Under the License.
|
==================================================================== */
|
|
|
namespace HH.WMS.Utils.NPOI.HSSF.Record.Aggregates
|
{
|
using System;
|
using System.Collections;
|
using HH.WMS.Utils.NPOI.HSSF.Record;
|
using HH.WMS.Utils.NPOI.HSSF.Util;
|
using HH.WMS.Utils.NPOI.Util;
|
using HH.WMS.Utils.NPOI.SS.Formula;
|
using HH.WMS.Utils.NPOI.HSSF.Model;
|
using System.Collections.Generic;
|
|
/**
|
*
|
* @author andy
|
* @author Jason Height (jheight at chariot dot net dot au)
|
*/
|
|
public class RowRecordsAggregate : RecordAggregate
|
{
|
private int firstrow = -1;
|
private int lastrow = -1;
|
private SortedList _rowRecords;
|
//private int size = 0;
|
private ValueRecordsAggregate _valuesAgg;
|
private List<Record> _unknownRecords;
|
private SharedValueManager _sharedValueManager;
|
|
// Cache values to speed up performance of
|
// getStartRowNumberForBlock / getEndRowNumberForBlock, see Bugzilla 47405
|
private RowRecord[] _rowRecordValues = null;
|
|
|
/** Creates a new instance of ValueRecordsAggregate */
|
|
public RowRecordsAggregate()
|
: this(SharedValueManager.CreateEmpty())
|
{
|
}
|
|
public CellValueRecordInterface[] GetValueRecords()
|
{
|
return _valuesAgg.GetValueRecords();
|
}
|
private RowRecordsAggregate(SharedValueManager svm)
|
{
|
_rowRecords = new SortedList();
|
_valuesAgg = new ValueRecordsAggregate();
|
_unknownRecords = new List<Record>();
|
_sharedValueManager = svm;
|
}
|
private int VisitRowRecordsForBlock(int blockIndex, RecordVisitor rv)
|
{
|
int startIndex = blockIndex * DBCellRecord.BLOCK_SIZE;
|
int endIndex = startIndex + DBCellRecord.BLOCK_SIZE;
|
|
IEnumerator rowIterator = _rowRecords.Values.GetEnumerator();
|
|
//Given that we basically iterate through the rows in order,
|
//For a performance improvement, it would be better to return an instance of
|
//an iterator and use that instance throughout, rather than recreating one and
|
//having to move it to the right position.
|
int i = 0;
|
for (; i < startIndex && rowIterator.MoveNext(); i++) ;
|
|
int result = 0;
|
while (rowIterator.MoveNext() && (i++ < endIndex))
|
{
|
Record rec = (Record)rowIterator.Current;
|
result += rec.RecordSize;
|
rv.VisitRecord(rec);
|
}
|
return result;
|
}
|
|
public override void VisitContainedRecords(RecordVisitor rv)
|
{
|
|
PositionTrackingVisitor stv = new PositionTrackingVisitor(rv, 0);
|
//DBCells are serialized before row records.
|
int blockCount = this.RowBlockCount;
|
for (int blockIndex = 0; blockIndex < blockCount; blockIndex++)
|
{
|
// Serialize a block of rows.
|
// Hold onto the position of the first row in the block
|
int pos = 0;
|
// Hold onto the size of this block that was serialized
|
int rowBlockSize = VisitRowRecordsForBlock(blockIndex, rv);
|
pos += rowBlockSize;
|
// Serialize a block of cells for those rows
|
int startRowNumber = GetStartRowNumberForBlock(blockIndex);
|
int endRowNumber = GetEndRowNumberForBlock(blockIndex);
|
DBCellRecord cellRecord = new DBCellRecord();
|
// Note: Cell references start from the second row...
|
int cellRefOffset = (rowBlockSize - RowRecord.ENCODED_SIZE);
|
for (int row = startRowNumber; row <= endRowNumber; row++)
|
{
|
if (_valuesAgg.RowHasCells(row))
|
{
|
stv.Position = 0;
|
_valuesAgg.VisitCellsForRow(row, stv);
|
int rowCellSize = stv.Position;
|
pos += rowCellSize;
|
// Add the offset to the first cell for the row into the
|
// DBCellRecord.
|
cellRecord.AddCellOffset((short)cellRefOffset);
|
cellRefOffset = rowCellSize;
|
}
|
}
|
// Calculate Offset from the start of a DBCellRecord to the first Row
|
cellRecord.RowOffset = (pos);
|
rv.VisitRecord(cellRecord);
|
}
|
for (int i = 0; i < _unknownRecords.Count; i++)
|
{
|
// Potentially breaking the file here since we don't know exactly where to write these records
|
rv.VisitRecord((Record)_unknownRecords[i]);
|
}
|
}
|
/**
|
* @param rs record stream with all {@link SharedFormulaRecord}
|
* {@link ArrayRecord}, {@link TableRecord} {@link MergeCellsRecord} Records removed
|
*/
|
public RowRecordsAggregate(RecordStream rs, SharedValueManager svm)
|
: this(svm)
|
{
|
while (rs.HasNext())
|
{
|
Record rec = rs.GetNext();
|
switch (rec.Sid)
|
{
|
case RowRecord.sid:
|
InsertRow((RowRecord)rec);
|
continue;
|
case DBCellRecord.sid:
|
// end of 'Row Block'. Should only occur after cell records
|
// ignore DBCELL records because POI generates them upon re-serialization
|
continue;
|
}
|
if (rec is UnknownRecord)
|
{
|
// might need to keep track of where exactly these belong
|
AddUnknownRecord((UnknownRecord)rec);
|
|
while (rs.PeekNextSid() == ContinueRecord.sid)
|
{
|
AddUnknownRecord(rs.GetNext());
|
}
|
continue;
|
}
|
if (rec is MulBlankRecord) {
|
_valuesAgg.AddMultipleBlanks((MulBlankRecord) rec);
|
continue;
|
}
|
|
if (!(rec is CellValueRecordInterface))
|
{
|
throw new InvalidOperationException("Unexpected record type (" + rec.GetType().Name + ")");
|
}
|
_valuesAgg.Construct((CellValueRecordInterface)rec, rs, svm);
|
}
|
}
|
/**
|
* Handles UnknownRecords which appear within the row/cell records
|
*/
|
private void AddUnknownRecord(Record rec)
|
{
|
// ony a few distinct record IDs are encountered by the existing POI test cases:
|
// 0x1065 // many
|
// 0x01C2 // several
|
// 0x0034 // few
|
// No documentation could be found for these
|
|
// keep the unknown records for re-serialization
|
_unknownRecords.Add(rec);
|
}
|
public void InsertRow(RowRecord row)
|
{
|
_rowRecords[row.RowNumber] = row;
|
// Clear the cached values
|
_rowRecordValues = null;
|
|
|
if (row.RowNumber < firstrow|| firstrow == -1)
|
{
|
firstrow = row.RowNumber;
|
}
|
if (row.RowNumber > lastrow|| lastrow == -1)
|
{
|
lastrow = row.RowNumber;
|
}
|
}
|
|
public void RemoveRow(RowRecord row)
|
{
|
int rowIndex = row.RowNumber;
|
_valuesAgg.RemoveAllCellsValuesForRow(rowIndex);
|
int key = rowIndex;
|
RowRecord rr = (RowRecord)_rowRecords[key];
|
_rowRecords.Remove(key);
|
if (rr == null)
|
{
|
throw new Exception("Invalid row index (" + key + ")");
|
}
|
if (row != rr)
|
{
|
_rowRecords[key] = rr;
|
throw new Exception("Attempt to remove row that does not belong to this sheet");
|
}
|
// Clear the cached values
|
_rowRecordValues = null;
|
}
|
public void InsertCell(CellValueRecordInterface cvRec)
|
{
|
_valuesAgg.InsertCell(cvRec);
|
}
|
public void RemoveCell(CellValueRecordInterface cvRec)
|
{
|
if (cvRec is FormulaRecordAggregate)
|
{
|
((FormulaRecordAggregate)cvRec).NotifyFormulaChanging();
|
}
|
_valuesAgg.RemoveCell(cvRec);
|
}
|
public RowRecord GetRow(int rowIndex)
|
{
|
// Row must be between 0 and 65535
|
if (rowIndex < 0 || rowIndex > 65535)
|
{
|
throw new ArgumentException("The row number must be between 0 and 65535");
|
}
|
return (RowRecord)_rowRecords[rowIndex];
|
}
|
public FormulaRecordAggregate CreateFormula(int row, int col)
|
{
|
FormulaRecord fr = new FormulaRecord();
|
fr.Row=(row);
|
fr.Column=((short)col);
|
return new FormulaRecordAggregate(fr, null, _sharedValueManager);
|
}
|
public int PhysicalNumberOfRows
|
{
|
get
|
{
|
return _rowRecords.Count;
|
}
|
}
|
|
public int FirstRowNum
|
{
|
get
|
{
|
return firstrow;
|
}
|
}
|
|
public int LastRowNum
|
{
|
get
|
{
|
return lastrow;
|
}
|
}
|
|
/** Returns the number of row blocks.
|
* <p/>The row blocks are goupings of rows that contain the DBCell record
|
* after them
|
*/
|
public int RowBlockCount
|
{
|
get
|
{
|
int size = _rowRecords.Count / DBCellRecord.BLOCK_SIZE;
|
if ((_rowRecords.Count % DBCellRecord.BLOCK_SIZE) != 0)
|
size++;
|
return size;
|
}
|
}
|
|
public int GetRowBlockSize(int block)
|
{
|
return 20 * GetRowCountForBlock(block);
|
}
|
|
/** Returns the number of physical rows within a block*/
|
public int GetRowCountForBlock(int block)
|
{
|
int startIndex = block * DBCellRecord.BLOCK_SIZE;
|
int endIndex = startIndex + DBCellRecord.BLOCK_SIZE - 1;
|
if (endIndex >= _rowRecords.Count)
|
endIndex = _rowRecords.Count - 1;
|
|
return endIndex - startIndex + 1;
|
}
|
|
/** Returns the physical row number of the first row in a block*/
|
public int GetStartRowNumberForBlock(int block)
|
{
|
//Given that we basically iterate through the rows in order,
|
//For a performance improvement, it would be better to return an instance of
|
//an iterator and use that instance throughout, rather than recreating one and
|
//having to move it to the right position.
|
|
|
int startIndex = block * DBCellRecord.BLOCK_SIZE;
|
|
if (_rowRecordValues == null)
|
{
|
_rowRecordValues=new RowRecord[_rowRecords.Count];
|
_rowRecords.Values.CopyTo(_rowRecordValues,0);
|
}
|
try
|
{
|
return _rowRecordValues[startIndex].RowNumber;
|
}
|
catch (IndexOutOfRangeException)
|
{
|
throw new Exception("Did not find start row for block " + block);
|
}
|
}
|
|
/** Returns the physical row number of the end row in a block*/
|
public int GetEndRowNumberForBlock(int block)
|
{
|
int endIndex = ((block + 1) * DBCellRecord.BLOCK_SIZE) - 1;
|
if (endIndex >= _rowRecords.Count)
|
endIndex = _rowRecords.Count - 1;
|
|
if (_rowRecordValues == null)
|
{
|
_rowRecordValues = new RowRecord[_rowRecords.Count];
|
_rowRecords.Values.CopyTo(_rowRecordValues,0);
|
}
|
|
try
|
{
|
return _rowRecordValues[endIndex].RowNumber;
|
}
|
catch (IndexOutOfRangeException)
|
{
|
throw new Exception("Did not find end row for block " + block);
|
}
|
}
|
|
public IEnumerator GetEnumerator()
|
{
|
return _rowRecords.Values.GetEnumerator();
|
}
|
|
|
public int FindStartOfRowOutlineGroup(int row)
|
{
|
// Find the start of the Group.
|
RowRecord rowRecord = this.GetRow(row);
|
int level = rowRecord.OutlineLevel;
|
int currentRow = row;
|
while (this.GetRow(currentRow) != null)
|
{
|
rowRecord = this.GetRow(currentRow);
|
if (rowRecord.OutlineLevel < level)
|
return currentRow + 1;
|
currentRow--;
|
}
|
|
return currentRow + 1;
|
}
|
|
public int FindEndOfRowOutlineGroup(int row)
|
{
|
int level = GetRow(row).OutlineLevel;
|
int currentRow;
|
for (currentRow = row; currentRow < this.LastRowNum; currentRow++)
|
{
|
if (GetRow(currentRow) == null || GetRow(currentRow).OutlineLevel < level)
|
{
|
break;
|
}
|
}
|
|
return currentRow - 1;
|
}
|
|
public int WriteHidden(RowRecord rowRecord, int row, bool hidden)
|
{
|
int level = rowRecord.OutlineLevel;
|
while (rowRecord != null && this.GetRow(row).OutlineLevel >= level)
|
{
|
rowRecord.ZeroHeight = (hidden);
|
row++;
|
rowRecord = this.GetRow(row);
|
}
|
return row - 1;
|
}
|
|
public void CollapseRow(int rowNumber)
|
{
|
|
// Find the start of the Group.
|
int startRow = FindStartOfRowOutlineGroup(rowNumber);
|
RowRecord rowRecord = GetRow(startRow);
|
|
// Hide all the columns Until the end of the Group
|
int lastRow = WriteHidden(rowRecord, startRow, true);
|
|
// Write collapse field
|
if (GetRow(lastRow + 1) != null)
|
{
|
GetRow(lastRow + 1).Colapsed = (true);
|
}
|
else
|
{
|
RowRecord row = CreateRow(lastRow + 1);
|
row.Colapsed = (true);
|
InsertRow(row);
|
}
|
}
|
public DimensionsRecord CreateDimensions()
|
{
|
DimensionsRecord result = new DimensionsRecord();
|
result.FirstRow=(firstrow);
|
result.LastRow=(lastrow);
|
result.FirstCol =_valuesAgg.FirstCellNum;
|
result.LastCol = _valuesAgg.LastCellNum;
|
return result;
|
}
|
|
/**
|
* Create a row record.
|
*
|
* @param row number
|
* @return RowRecord Created for the passed in row number
|
* @see org.apache.poi.hssf.record.RowRecord
|
*/
|
public static RowRecord CreateRow(int rowNumber)
|
{
|
return new RowRecord(rowNumber);
|
}
|
|
public IndexRecord CreateIndexRecord(int indexRecordOffset, int sizeOfInitialSheetRecords, int offsetDefaultColWidth)
|
{
|
IndexRecord result = new IndexRecord();
|
result.FirstRow= firstrow;
|
result.LastRowAdd1= lastrow+1;
|
// Calculate the size of the records from the end of the BOF
|
// and up to the RowRecordsAggregate...
|
|
// Add the references to the DBCells in the IndexRecord (one for each block)
|
// Note: The offsets are relative to the Workbook BOF. Assume that this is
|
// 0 for now.....
|
|
int blockCount = RowBlockCount;
|
// Calculate the size of this IndexRecord
|
int indexRecSize = IndexRecord.GetRecordSizeForBlockCount(blockCount);
|
|
int currentOffset = indexRecordOffset + indexRecSize + sizeOfInitialSheetRecords;
|
|
for (int block = 0; block < blockCount; block++)
|
{
|
// each row-block has a DBCELL record.
|
// The offset of each DBCELL record needs to be updated in the INDEX record
|
|
// account for row records in this row-block
|
currentOffset += GetRowBlockSize(block);
|
// account for cell value records after those
|
currentOffset += _valuesAgg.GetRowCellBlockSize(
|
GetStartRowNumberForBlock(block), GetEndRowNumberForBlock(block));
|
|
// currentOffset is now the location of the DBCELL record for this row-block
|
result.AddDbcell(currentOffset);
|
// Add space required to write the DBCELL record (whose reference was just added).
|
currentOffset += (8 + (GetRowCountForBlock(block) * 2));
|
}
|
return result;
|
}
|
|
public bool IsRowGroupCollapsed(int row)
|
{
|
int collapseRow = FindEndOfRowOutlineGroup(row) + 1;
|
|
if (GetRow(collapseRow) == null)
|
return false;
|
else
|
return GetRow(collapseRow).Colapsed;
|
}
|
|
public void ExpandRow(int rowNumber)
|
{
|
int idx = rowNumber;
|
if (idx == -1)
|
return;
|
|
// If it is already expanded do nothing.
|
if (!IsRowGroupCollapsed(idx))
|
return;
|
|
// Find the start of the Group.
|
int startIdx = FindStartOfRowOutlineGroup(idx);
|
RowRecord row = GetRow(startIdx);
|
|
// Find the end of the Group.
|
int endIdx = FindEndOfRowOutlineGroup(idx);
|
|
// expand:
|
// collapsed bit must be UnSet
|
// hidden bit Gets UnSet _if_ surrounding Groups are expanded you can determine
|
// this by looking at the hidden bit of the enclosing Group. You will have
|
// to look at the start and the end of the current Group to determine which
|
// is the enclosing Group
|
// hidden bit only is altered for this outline level. ie. don't Un-collapse contained Groups
|
if (!IsRowGroupHiddenByParent(idx))
|
{
|
for (int i = startIdx; i <= endIdx; i++)
|
{
|
if (row.OutlineLevel == GetRow(i).OutlineLevel)
|
GetRow(i).ZeroHeight = (false);
|
else if (!IsRowGroupCollapsed(i))
|
GetRow(i).ZeroHeight = (false);
|
}
|
}
|
|
// Write collapse field
|
GetRow(endIdx + 1).Colapsed = (false);
|
}
|
|
public void UpdateFormulasAfterRowShift(FormulaShifter formulaShifter, int currentExternSheetIndex)
|
{
|
_valuesAgg.UpdateFormulasAfterRowShift(formulaShifter, currentExternSheetIndex);
|
}
|
|
public bool IsRowGroupHiddenByParent(int row)
|
{
|
// Look out outline details of end
|
int endLevel;
|
bool endHidden;
|
int endOfOutlineGroupIdx = FindEndOfRowOutlineGroup(row);
|
if (GetRow(endOfOutlineGroupIdx + 1) == null)
|
{
|
endLevel = 0;
|
endHidden = false;
|
}
|
else
|
{
|
endLevel = GetRow(endOfOutlineGroupIdx + 1).OutlineLevel;
|
endHidden = GetRow(endOfOutlineGroupIdx + 1).ZeroHeight;
|
}
|
|
// Look out outline details of start
|
int startLevel;
|
bool startHidden;
|
int startOfOutlineGroupIdx = FindStartOfRowOutlineGroup(row);
|
if (startOfOutlineGroupIdx - 1 < 0 || GetRow(startOfOutlineGroupIdx - 1) == null)
|
{
|
startLevel = 0;
|
startHidden = false;
|
}
|
else
|
{
|
startLevel = GetRow(startOfOutlineGroupIdx - 1).OutlineLevel;
|
startHidden = GetRow(startOfOutlineGroupIdx - 1).ZeroHeight;
|
}
|
|
if (endLevel > startLevel)
|
{
|
return endHidden;
|
}
|
else
|
{
|
return startHidden;
|
}
|
}
|
|
}
|
|
}
|
