private void CreateColumnCopies(uint colFromIdx, int numOfColumns, Func <CellProxy, CellProxy> fnCreate)
{
Action <uint, uint> action = delegate(uint rowIdx, uint colIdx) {
RowColumn column = new RowColumn {
Row = rowIdx,
Column = colIdx
};
if (column.Column == colFromIdx)
{
foreach (int num in Enumerable.Range(((int)colFromIdx) + 1, numOfColumns))
{
RowColumn column2 = new RowColumn {
Row = column.Row,
Column = (uint)num
};
CellProxy cell = this.GetCell(column.Row, column.Column);
if (cell != null)
{
CellProxy c = fnCreate(cell);
if (c != null)
{
this.AddCellToCache(c, column2.Row, column2.Column);
}
}
}
}
};
this.LoopCells(action);
}
private void CreateColumnCopies(uint colFromIdx, int numOfColumns, Func <CellProxy, CellProxy> fnCreate)
{
Action <uint, uint> actionCopyColumn = (rowIdx, colIdx) =>
{
RowColumn rcOld = new RowColumn()
{
Row = rowIdx, Column = colIdx
};
if (rcOld.Column == colFromIdx)
{
foreach (var newColIdx in Enumerable.Range((int)colFromIdx + 1, numOfColumns))
{
RowColumn rcNew = new RowColumn()
{
Row = rcOld.Row, Column = (uint)newColIdx
};
CellProxy cOld = GetCell(rcOld.Row, rcOld.Column);
if (cOld != null)
{
CellProxy cNew = fnCreate(cOld);
if (cNew != null)
{
AddCellToCache(cNew, rcNew.Row, rcNew.Column);
}
}
}
}
};
LoopCells(actionCopyColumn);
}
private void AddCellToCache(CellProxy c, uint rowIdx, uint colIdx)
{
SortedList <uint, CellProxy> list;
this.Modified = true;
if (!this._cachedCells.TryGetValue(rowIdx, out list))
{
list = new SortedList <uint, CellProxy>();
this._cachedCells[rowIdx] = list;
}
list[colIdx] = c;
}
private void AddCellToCache(CellProxy c, uint rowIdx, uint colIdx)
{
this.Modified = true;
SortedList <uint, CellProxy> rowCache;
if (!_cachedCells.TryGetValue(rowIdx, out rowCache))
{
rowCache = new SortedList <uint, CellProxy>();
_cachedCells[rowIdx] = rowCache;
}
rowCache[colIdx] = c;
}
private CellProxy RemoveCellFromCache(uint rowIdx, uint colIdx)
{
SortedList <uint, CellProxy> list;
this.Modified = true;
CellProxy proxy = null;
if (this._cachedCells.TryGetValue(rowIdx, out list) && list.TryGetValue(colIdx, out proxy))
{
list.Remove(colIdx);
return(proxy);
}
return(null);
}
public void RecalcCellReferences(SheetChange sheetChange)
{
foreach (KeyValuePair <ulong, CellProxy> pair in this.Cells())
{
CellProxy proxy = pair.Value;
if (proxy.Formula != null)
{
proxy.Formula.Text = ExcelFormula.TranslateForSheetChange(proxy.Formula.Text, sheetChange, this._wsheet.Name);
proxy.Formula.R1 = ExcelRange.TranslateForSheetChange(proxy.Formula.R1, sheetChange, this._wsheet.Name);
proxy.Formula.R2 = ExcelRange.TranslateForSheetChange(proxy.Formula.R2, sheetChange, this._wsheet.Name);
proxy.Formula.Reference = ExcelRange.TranslateForSheetChange(proxy.Formula.Reference, sheetChange, this._wsheet.Name);
}
}
List <ConditionalFormatting> list = new List <ConditionalFormatting>();
foreach (ConditionalFormatting formatting in this.GetElements <ConditionalFormatting>())
{
bool flag = false;
List <StringValue> list2 = new List <StringValue>();
foreach (StringValue value2 in formatting.SequenceOfReferences.Items)
{
string str = ExcelRange.TranslateForSheetChange(value2.Value, sheetChange, this._wsheet.Name);
if (!str.StartsWith("#"))
{
list2.Add(new StringValue(str));
}
else
{
list.Add(formatting);
flag = true;
break;
}
}
if (flag)
{
break;
}
formatting.SequenceOfReferences = new ListValue <StringValue>(list2);
foreach (Formula formula in formatting.Descendants <Formula>())
{
formula.Text = ExcelFormula.TranslateForSheetChange(formula.Text, sheetChange, this._wsheet.Name);
}
}
foreach (ConditionalFormatting formatting2 in list)
{
this.RemoveElement(formatting2);
}
}
private CellProxy RemoveCellFromCache(uint rowIdx, uint colIdx)
{
this.Modified = true;
CellProxy c = null;
SortedList <uint, CellProxy> rowCache;
if (_cachedCells.TryGetValue(rowIdx, out rowCache))
{
if (rowCache.TryGetValue(colIdx, out c))
{
rowCache.Remove(colIdx);
return(c);
}
}
return(null);
}
public CellProxy EnsureCell(uint row, uint col)
{
CellProxy c = null;
SortedList <uint, CellProxy> list;
if (!this._cachedCells.TryGetValue(row, out list))
{
c = new CellProxy(this);
this.AddCellToCache(c, row, col);
return(c);
}
if (!list.TryGetValue(col, out c))
{
c = new CellProxy(this);
if (list != null)
{
this.AddCellToCache(c, list, col);
}
}
return(c);
}
private void CreateRowCopies(uint rowFromIdx, int numOfRows, Func <CellProxy, CellProxy> fnCreate)
{
SortedList <uint, CellProxy> rowCache;
if (_cachedCells.TryGetValue(rowFromIdx, out rowCache))
{
Row cachedRow;
_cachedRows.TryGetValue(rowFromIdx, out cachedRow);
foreach (var newRowIdx in Enumerable.Range((int)rowFromIdx + 1, numOfRows))
{
if (cachedRow != null)
{
Row cachedRowCopy = (Row)cachedRow.CloneNode(false);
cachedRowCopy.RowIndex = (uint)newRowIdx;
_cachedRows.Add(cachedRowCopy.RowIndex, cachedRowCopy);
}
foreach (var colIdx in rowCache.Keys)
{
RowColumn rcOld = new RowColumn()
{
Row = rowFromIdx, Column = colIdx
};
RowColumn rcNew = new RowColumn()
{
Row = (uint)newRowIdx, Column = colIdx
};
CellProxy cOld = GetCell(rcOld.Row, rcOld.Column);
CellProxy cNew = fnCreate(cOld);
if (cNew != null)
{
AddCellToCache(cNew, rcNew.Row, rcNew.Column);
}
}
}
}
}
public CellProxy EnsureCell(uint row, uint col)
{
CellProxy c = null;
SortedList <uint, CellProxy> rowCache;
if (!_cachedCells.TryGetValue(row, out rowCache))
{
c = new CellProxy(this);
AddCellToCache(c, row, col);
}
else
{
if (!rowCache.TryGetValue(col, out c))
{
c = new CellProxy(this);
if (rowCache != null)
{
AddCellToCache(c, rowCache, col);
}
}
}
return(c);
}
private void CreateRowCopies(uint rowFromIdx, int numOfRows, Func <CellProxy, CellProxy> fnCreate)
{
SortedList <uint, CellProxy> list;
if (this._cachedCells.TryGetValue(rowFromIdx, out list))
{
Row row;
this._cachedRows.TryGetValue(rowFromIdx, out row);
foreach (int num in Enumerable.Range(((int)rowFromIdx) + 1, numOfRows))
{
if (row != null)
{
Row row2 = (Row)row.CloneNode(false);
row2.RowIndex = (UInt32Value)(uint)num;
this._cachedRows.Add((uint)row2.RowIndex, row2);
}
foreach (uint num2 in list.Keys)
{
RowColumn column = new RowColumn {
Row = rowFromIdx,
Column = num2
};
RowColumn column2 = new RowColumn {
Row = (uint)num,
Column = num2
};
CellProxy cell = this.GetCell(column.Row, column.Column);
CellProxy c = fnCreate(cell);
if (c != null)
{
this.AddCellToCache(c, column2.Row, column2.Column);
}
}
}
}
}
public void Load()
{
if (this._wsheet.GetOWorksheetPart() != null)
{
Action <Cell> action = delegate(Cell cell) {
RowColumn column = ExcelAddress.ToRowColumn((string)cell.CellReference);
CellProxy proxy = this.EnsureCell(column.Row, column.Column);
if (cell.DataType != null)
{
proxy.DataType = new CellValues?(cell.DataType.Value);
if (((CellValues)cell.DataType.Value) == CellValues.InlineString)
{
proxy.Value = cell.InlineString.Text.Text;
}
else if (cell.CellValue != null)
{
proxy.Value = cell.CellValue.Text;
}
else
{
proxy.Value = string.Empty;
}
}
else if (cell.CellValue != null)
{
proxy.Value = cell.CellValue.Text;
}
if (cell.StyleIndex != null)
{
proxy.StyleIndex = new uint?((uint)cell.StyleIndex);
}
if (cell.ShowPhonetic != null)
{
proxy.ShowPhonetic = new bool?((bool)cell.ShowPhonetic);
}
if (cell.ValueMetaIndex != null)
{
proxy.ValueMetaIndex = new uint?((uint)cell.ValueMetaIndex);
}
if (cell.CellFormula != null)
{
proxy.CreateFormula();
proxy.Formula.Text = cell.CellFormula.Text;
proxy.Formula.R1 = (string)cell.CellFormula.R1;
proxy.Formula.R2 = (string)cell.CellFormula.R2;
proxy.Formula.Reference = (string)cell.CellFormula.Reference;
if (cell.CellFormula.AlwaysCalculateArray != null)
{
proxy.Formula.AlwaysCalculateArray = new bool?((bool)cell.CellFormula.AlwaysCalculateArray);
}
if (cell.CellFormula.Bx != null)
{
proxy.Formula.Bx = new bool?((bool)cell.CellFormula.Bx);
}
if (cell.CellFormula.CalculateCell != null)
{
proxy.Formula.CalculateCell = new bool?((bool)cell.CellFormula.CalculateCell);
}
if (cell.CellFormula.DataTable2D != null)
{
proxy.Formula.DataTable2D = new bool?((bool)cell.CellFormula.DataTable2D);
}
if (cell.CellFormula.DataTableRow != null)
{
proxy.Formula.DataTableRow = new bool?((bool)cell.CellFormula.DataTableRow);
}
if (cell.CellFormula.FormulaType != null)
{
proxy.Formula.FormulaType = new CellFormulaValues?((CellFormulaValues)cell.CellFormula.FormulaType);
}
if (cell.CellFormula.Input1Deleted != null)
{
proxy.Formula.Input1Deleted = new bool?((bool)cell.CellFormula.Input1Deleted);
}
if (cell.CellFormula.Input2Deleted != null)
{
proxy.Formula.Input2Deleted = new bool?((bool)cell.CellFormula.Input2Deleted);
}
if (cell.CellFormula.SharedIndex != null)
{
proxy.Formula.SharedIndex = new uint?((uint)cell.CellFormula.SharedIndex);
}
proxy.Value = null;
}
};
OpenXmlReader reader = OpenXmlReader.Create(this._wsheet.GetOWorksheetPart());
bool flag = false;
while (reader.Read())
{
if (flag && reader.IsStartElement)
{
if ((reader.ElementType == typeof(Row)) && reader.IsStartElement)
{
Row row = (Row)reader.LoadCurrentElement();
if ((from a in row.GetAttributes()
let ln = a.LocalName
where (ln != "r") && (ln != "spans")
select a).Any <OpenXmlAttribute>())
{
this._cachedRows.Add((uint)row.RowIndex, (Row)row.CloneNode(false));
}
foreach (Cell cell in row.Elements <Cell>())
{
action(cell);
}
}
else if (reader.ElementType == typeof(SheetData))
{
bool isStartElement = reader.IsStartElement;
}
else if (reader.IsStartElement)
{
OpenXmlElement item = reader.LoadCurrentElement();
this._cachedElements.Add(item);
}
}
else if (reader.ElementType == typeof(Worksheet))
{
flag = reader.IsStartElement;
}
}
this.Modified = false;
}
}
private void AddCellToCache(CellProxy c, SortedList <uint, CellProxy> rowCache, uint colIdx)
{
this.Modified = true;
rowCache[colIdx] = c;
}
public void InsertOrDeleteColumns(uint colStart, int colDelta, bool copyPreviousStyle)
{
Func <Column, bool> func = null;
Func <CellProxy, CellProxy> fnCreate = null;
if (colDelta != 0)
{
this.Modified = true;
Action <uint, uint> action = delegate(uint rowIdx, uint colIdx) {
if (colIdx >= colStart)
{
CellProxy c = this.RemoveCellFromCache(rowIdx, colIdx);
int num = ((int)colIdx) + colDelta;
if ((num >= colStart) && (num >= 1))
{
if (colIdx >= ExcelConstraints.MaxColumns)
{
throw new InvalidOperationException("Max number of columns exceeded");
}
this.AddCellToCache(c, rowIdx, (uint)num);
}
}
};
if (colDelta > 0)
{
this.LoopCellsReverse(action);
}
else
{
this.LoopCells(action);
}
Columns firstElement = this.GetFirstElement <Columns>();
if (firstElement != null)
{
List <Column> list = new List <Column>();
foreach (Column column in firstElement)
{
if (column.Min >= colStart)
{
column.Min = (uint)Math.Max((long)0L, (long)(((long)((ulong)column.Min)) + colDelta));
}
if (column.Max >= colStart)
{
column.Max = (uint)Math.Max((long)0L, (long)(((long)((ulong)column.Max)) + colDelta));
}
if ((column.Min <= 0) || (column.Max < column.Min))
{
list.Add(column);
}
}
foreach (Column column2 in list)
{
column2.Remove();
}
if (func == null)
{
func = col => col.Max == (colStart - 1);
}
Column column3 = Enumerable.Where <Column>(firstElement.Elements <Column>(), func).FirstOrDefault <Column>();
if (column3 != null)
{
column3.Max = (uint)(((ulong)column3.Max) + (ulong)colDelta);
}
if (firstElement.ChildElements.Count == 0)
{
this._cachedElements.Remove(firstElement);
}
}
if (colDelta > 0)
{
if (copyPreviousStyle)
{
if (fnCreate == null)
{
fnCreate = delegate(CellProxy cOld) {
if (cOld.StyleIndex.HasValue)
{
return(new CellProxy(this)
{
StyleIndex = cOld.StyleIndex
});
}
return(null);
};
}
this.CreateColumnCopies(colStart - 1, colDelta, fnCreate);
}
else
{
for (uint i = colStart; i < (colStart + colDelta); i++)
{
this.EnsureSingleSpanColumn(i);
this.DeleteSingleSpanColumn(i);
}
}
}
}
}
public void Load()
{
WorksheetPart wp = _wsheet.GetOWorksheetPart();
if (wp == null)
{
return;
}
Action <Cell> readCell = (cell) =>
{
RowColumn rc = ExcelAddress.ToRowColumn(cell.CellReference);
CellProxy cellProxy = this.EnsureCell(rc.Row, rc.Column);
if (cell.DataType != null)
{
cellProxy.DataType = cell.DataType.Value;
if (cell.DataType.Value == CellValues.InlineString)
{
cellProxy.Value = cell.InlineString.Text.Text;
}
else
{
if (cell.CellValue != null)
{
cellProxy.Value = cell.CellValue.Text;
}
else
{
cellProxy.Value = string.Empty;
}
}
}
else
{
if (cell.CellValue != null)
{
cellProxy.Value = cell.CellValue.Text;
}
}
if (cell.StyleIndex != null)
{
cellProxy.StyleIndex = cell.StyleIndex;
}
if (cell.ShowPhonetic != null)
{
cellProxy.ShowPhonetic = cell.ShowPhonetic;
}
if (cell.ValueMetaIndex != null)
{
cellProxy.ValueMetaIndex = cell.ValueMetaIndex;
}
if (cell.CellFormula != null)
{
cellProxy.CreateFormula();
cellProxy.Formula.Text = cell.CellFormula.Text;
cellProxy.Formula.R1 = cell.CellFormula.R1;
cellProxy.Formula.R2 = cell.CellFormula.R2;
cellProxy.Formula.Reference = cell.CellFormula.Reference;
if (cell.CellFormula.AlwaysCalculateArray != null)
{
cellProxy.Formula.AlwaysCalculateArray = cell.CellFormula.AlwaysCalculateArray;
}
if (cell.CellFormula.Bx != null)
{
cellProxy.Formula.Bx = cell.CellFormula.Bx;
}
if (cell.CellFormula.CalculateCell != null)
{
cellProxy.Formula.CalculateCell = cell.CellFormula.CalculateCell;
}
if (cell.CellFormula.DataTable2D != null)
{
cellProxy.Formula.DataTable2D = cell.CellFormula.DataTable2D;
}
if (cell.CellFormula.DataTableRow != null)
{
cellProxy.Formula.DataTableRow = cell.CellFormula.DataTableRow;
}
if (cell.CellFormula.FormulaType != null)
{
cellProxy.Formula.FormulaType = cell.CellFormula.FormulaType;
}
if (cell.CellFormula.Input1Deleted != null)
{
cellProxy.Formula.Input1Deleted = cell.CellFormula.Input1Deleted;
}
if (cell.CellFormula.Input2Deleted != null)
{
cellProxy.Formula.Input2Deleted = cell.CellFormula.Input2Deleted;
}
if (cell.CellFormula.SharedIndex != null)
{
cellProxy.Formula.SharedIndex = cell.CellFormula.SharedIndex;
}
cellProxy.Value = null; // Don't cache/store values for formulas
}
};
OpenXmlReader reader = OpenXmlReader.Create(_wsheet.GetOWorksheetPart());
bool inWorksheet = false;
bool inSheetData = false;
while (reader.Read())
{
if (inWorksheet && reader.IsStartElement)
{
if (reader.ElementType == typeof(Row) && reader.IsStartElement)
{
// ----------------------------------------
// Scan row if anything other than RowIndex and Spans has been set,
// if so then cache
Row r = (Row)reader.LoadCurrentElement();
var needToCacheRow = (from a in r.GetAttributes()
let ln = a.LocalName
where ln != "r" && ln != "spans"
select a).Any();
if (needToCacheRow)
{
_cachedRows.Add(r.RowIndex, (Row)r.CloneNode(false));
}
foreach (Cell cell in r.Elements <Cell>())
{
readCell(cell);
}
// ----------------------------------------
}
else if (reader.ElementType == typeof(SheetData))
{
inSheetData = reader.IsStartElement;
}
else if (reader.IsStartElement)
{
var e = reader.LoadCurrentElement();
_cachedElements.Add(e);
}
}
else if (reader.ElementType == typeof(Worksheet))
{
inWorksheet = reader.IsStartElement;
}
}
// Reset modified to false (loading sets it to true due to CellProxy loading)
this.Modified = false;
}
private IEnumerable <OpenXmlAttribute> EnumCellProxyAttributes(uint row, uint col, CellProxy cellProxy)
{
OpenXmlAttribute iteratorVariable0 = new OpenXmlAttribute {
LocalName = "r",
Value = RowColumn.ToAddress(row, col)
};
yield return(iteratorVariable0);
if (cellProxy.DataType.HasValue)
{
OpenXmlAttribute iteratorVariable1 = new OpenXmlAttribute {
LocalName = "t",
Value = this.STCellType(cellProxy.DataType.Value)
};
yield return(iteratorVariable1);
}
if (cellProxy.StyleIndex.HasValue)
{
OpenXmlAttribute iteratorVariable2 = new OpenXmlAttribute {
LocalName = "s",
Value = cellProxy.StyleIndex.Value.ToString()
};
yield return(iteratorVariable2);
}
}
private void WriteSheetData(OpenXmlWriter writer)
{
writer.WriteStartElement(new SheetData());
foreach (var rowItem in _cachedCells)
{
uint rowIdx = rowItem.Key;
var cells = rowItem.Value;
var rowAttrs = EnumRowAttributes(rowIdx, cells).ToList();
if (rowAttrs.Count > 0 || cells.Count > 0)
{
writer.WriteStartElement(new Row(), rowAttrs);
foreach (var cellItem in cells)
{
uint colIdx = cellItem.Key;
CellProxy cellProxy = cellItem.Value;
writer.WriteStartElement(new Cell(), EnumCellProxyAttributes(rowIdx, colIdx, cellProxy));
if (cellProxy.Formula != null)
{
CellFormula cf = new CellFormula(cellProxy.Formula.Text);
if (cellProxy.Formula.R1 != null)
{
cf.R1 = cellProxy.Formula.R1;
}
if (cellProxy.Formula.R2 != null)
{
cf.R2 = cellProxy.Formula.R2;
}
if (cellProxy.Formula.Reference != null)
{
cf.Reference = cellProxy.Formula.Reference;
}
if (cellProxy.Formula.AlwaysCalculateArray != null)
{
cf.AlwaysCalculateArray = cellProxy.Formula.AlwaysCalculateArray;
}
if (cellProxy.Formula.Bx != null)
{
cf.Bx = cellProxy.Formula.Bx;
}
if (cellProxy.Formula.CalculateCell != null)
{
cf.CalculateCell = cellProxy.Formula.CalculateCell;
}
if (cellProxy.Formula.DataTable2D != null)
{
cf.DataTable2D = cellProxy.Formula.DataTable2D;
}
if (cellProxy.Formula.DataTableRow != null)
{
cf.DataTableRow = cellProxy.Formula.DataTableRow;
}
if (cellProxy.Formula.FormulaType != null)
{
cf.FormulaType = cellProxy.Formula.FormulaType;
}
if (cellProxy.Formula.Input1Deleted != null)
{
cf.Input1Deleted = cellProxy.Formula.Input1Deleted;
}
if (cellProxy.Formula.Input2Deleted != null)
{
cf.Input2Deleted = cellProxy.Formula.Input2Deleted;
}
if (cellProxy.Formula.SharedIndex != null)
{
cf.SharedIndex = cellProxy.Formula.SharedIndex;
}
writer.WriteElement(cf);
}
if (cellProxy.Value != null)
{
writer.WriteElement(new CellValue(cellProxy.SerializedValue));
}
writer.WriteEndElement(); // c
}
writer.WriteEndElement(); // row
}
}
writer.WriteEndElement(); // sheetData
}
public void InsertOrDeleteColumns(uint colStart, int colDelta, bool copyPreviousStyle)
{
if (colDelta == 0)
{
return;
}
this.Modified = true;
Action <uint, uint> shiftCells = (rowIdx, colIdx) =>
{
if (colIdx >= colStart)
{
CellProxy c = RemoveCellFromCache(rowIdx, colIdx);
int newColIdx = (int)colIdx + colDelta;
// If delta is negative, cells will be not put back, i.e. deleted
if (newColIdx >= colStart && newColIdx >= 1)
{
if (colIdx >= ExcelConstraints.MaxColumns)
{
throw new InvalidOperationException("Max number of columns exceeded");
}
AddCellToCache(c, rowIdx, (uint)newColIdx);
}
}
};
if (colDelta > 0)
{
LoopCellsReverse(shiftCells);
}
else
{
LoopCells(shiftCells);
}
// Adjust cached <col> elements
Columns cols = this.GetFirstElement <Columns>();
if (cols != null)
{
List <Column> colsToRemove = new List <Column>();
foreach (Column col in cols)
{
if (col.Min >= colStart)
{
col.Min = (uint)Math.Max(0, col.Min + colDelta);
}
if (col.Max >= colStart)
{
col.Max = (uint)Math.Max(0, col.Max + colDelta);
}
if (col.Min <= 0 || col.Max < col.Min)
{
colsToRemove.Add(col);
}
}
foreach (Column col in colsToRemove)
{
col.Remove();
}
Column colPrev = (from col in cols.Elements <Column>()
where col.Max == colStart - 1
select col).FirstOrDefault();
if (colPrev != null)
{
colPrev.Max = (uint)(colPrev.Max + colDelta);
}
if (cols.ChildElements.Count == 0)
{
_cachedElements.Remove(cols);
}
}
if (colDelta > 0)
{
if (copyPreviousStyle)
{
CreateColumnCopies(colStart - 1, colDelta,
cOld =>
{
if (cOld.StyleIndex != null)
{
var cNew = new CellProxy(this);
cNew.StyleIndex = cOld.StyleIndex;
return(cNew);
}
return(null);
}
);
}
else
{
// Ensure this column does not have a column defintion
// so we don't copy previous column style
// TODO: make this more efficient
for (uint ctr = colStart; ctr < colStart + colDelta; ctr++)
{
EnsureSingleSpanColumn(ctr);
DeleteSingleSpanColumn(ctr);
}
}
}
}
public void InsertOrDeleteRows(uint rowStart, int rowDelta, bool copyPreviousStyle)
{
if (rowDelta == 0)
{
return;
}
this.Modified = true;
IList <uint> rowIndexes;
if (rowDelta > 0)
{
rowIndexes = _cachedCells.Keys.Reverse().ToList();
}
else
{
rowIndexes = _cachedCells.Keys.ToList();
}
var newCellProxies = new SortedList <uint, SortedList <uint, CellProxy> >();
foreach (uint rowIdx in rowIndexes)
{
uint newRowIdx;
if (rowIdx >= rowStart)
{
newRowIdx = (uint)(rowIdx + rowDelta);
}
else
{
newRowIdx = rowIdx;
}
newCellProxies[newRowIdx] = _cachedCells[rowIdx];
}
_cachedCells = newCellProxies;
// Adjust cached <row> elements
IEnumerable <uint> affectedCachedRowIndexes;
if (rowDelta > 0)
{
affectedCachedRowIndexes = _cachedRows.Keys.Where(k => k >= rowStart).Reverse().ToList();
}
else
{
affectedCachedRowIndexes = _cachedRows.Keys.Where(k => k >= rowStart).ToList();
}
foreach (var rowIdx in affectedCachedRowIndexes)
{
Row r = _cachedRows[rowIdx];
int newRowIdx = (int)r.RowIndex.Value + rowDelta;
_cachedRows.Remove(rowIdx);
// If delta is negative, rows will be not put back, i.e. deleted
if (newRowIdx >= rowStart && newRowIdx >= 1)
{
r.RowIndex = (uint)(newRowIdx);
_cachedRows[r.RowIndex] = r;
}
}
if (rowDelta > 0 && copyPreviousStyle)
{
CreateRowCopies(rowStart - 1, rowDelta,
cOld =>
{
if (cOld.StyleIndex != null)
{
var cNew = new CellProxy(this);
cNew.StyleIndex = cOld.StyleIndex;
return(cNew);
}
return(null);
}
);
}
}
private void WriteSheetData(OpenXmlWriter writer)
{
writer.WriteStartElement(new SheetData());
foreach (KeyValuePair <uint, SortedList <uint, CellProxy> > pair in this._cachedCells)
{
uint key = pair.Key;
SortedList <uint, CellProxy> cells = pair.Value;
List <OpenXmlAttribute> attributes = this.EnumRowAttributes(key, cells).ToList <OpenXmlAttribute>();
if ((attributes.Count > 0) || (cells.Count > 0))
{
writer.WriteStartElement(new Row(), attributes);
foreach (KeyValuePair <uint, CellProxy> pair2 in cells)
{
uint col = pair2.Key;
CellProxy cellProxy = pair2.Value;
writer.WriteStartElement(new Cell(), this.EnumCellProxyAttributes(key, col, cellProxy));
if (cellProxy.Formula != null)
{
CellFormula elementObject = new CellFormula(cellProxy.Formula.Text);
if (cellProxy.Formula.R1 != null)
{
elementObject.R1 = cellProxy.Formula.R1;
}
if (cellProxy.Formula.R2 != null)
{
elementObject.R2 = cellProxy.Formula.R2;
}
if (cellProxy.Formula.Reference != null)
{
elementObject.Reference = cellProxy.Formula.Reference;
}
if (cellProxy.Formula.AlwaysCalculateArray.HasValue)
{
bool?alwaysCalculateArray = cellProxy.Formula.AlwaysCalculateArray;
elementObject.AlwaysCalculateArray = alwaysCalculateArray.HasValue ? ((BooleanValue)alwaysCalculateArray.GetValueOrDefault()) : null;
}
if (cellProxy.Formula.Bx.HasValue)
{
bool?bx = cellProxy.Formula.Bx;
elementObject.Bx = bx.HasValue ? ((BooleanValue)bx.GetValueOrDefault()) : null;
}
if (cellProxy.Formula.CalculateCell.HasValue)
{
bool?calculateCell = cellProxy.Formula.CalculateCell;
elementObject.CalculateCell = calculateCell.HasValue ? ((BooleanValue)calculateCell.GetValueOrDefault()) : null;
}
if (cellProxy.Formula.DataTable2D.HasValue)
{
bool?nullable8 = cellProxy.Formula.DataTable2D;
elementObject.DataTable2D = nullable8.HasValue ? ((BooleanValue)nullable8.GetValueOrDefault()) : null;
}
if (cellProxy.Formula.DataTableRow.HasValue)
{
bool?dataTableRow = cellProxy.Formula.DataTableRow;
elementObject.DataTableRow = dataTableRow.HasValue ? ((BooleanValue)dataTableRow.GetValueOrDefault()) : null;
}
if (cellProxy.Formula.FormulaType.HasValue)
{
CellFormulaValues?formulaType = cellProxy.Formula.FormulaType;
elementObject.FormulaType = formulaType.HasValue ? ((EnumValue <CellFormulaValues>)formulaType.GetValueOrDefault()) : null;
}
if (cellProxy.Formula.Input1Deleted.HasValue)
{
bool?nullable14 = cellProxy.Formula.Input1Deleted;
elementObject.Input1Deleted = nullable14.HasValue ? ((BooleanValue)nullable14.GetValueOrDefault()) : null;
}
if (cellProxy.Formula.Input2Deleted.HasValue)
{
bool?nullable16 = cellProxy.Formula.Input2Deleted;
elementObject.Input2Deleted = nullable16.HasValue ? ((BooleanValue)nullable16.GetValueOrDefault()) : null;
}
if (cellProxy.Formula.SharedIndex.HasValue)
{
uint?sharedIndex = cellProxy.Formula.SharedIndex;
elementObject.SharedIndex = sharedIndex.HasValue ? ((UInt32Value)sharedIndex.GetValueOrDefault()) : null;
}
writer.WriteElement(elementObject);
}
if (cellProxy.Value != null)
{
writer.WriteElement(new CellValue(cellProxy.SerializedValue));
}
writer.WriteEndElement();
}
writer.WriteEndElement();
}
}
writer.WriteEndElement();
}
private IEnumerable <OpenXmlAttribute> EnumCellProxyAttributes(uint row, uint col, CellProxy cellProxy)
{
yield return(new OpenXmlAttribute()
{
LocalName = "r", Value = RowColumn.ToAddress(row, col)
});
if (cellProxy.DataType != null)
{
yield return(new OpenXmlAttribute()
{
LocalName = "t", Value = STCellType((CellValues)cellProxy.DataType)
});
}
if (cellProxy.StyleIndex != null)
{
yield return(new OpenXmlAttribute()
{
LocalName = "s", Value = cellProxy.StyleIndex.Value.ToString()
});
}
}
