double GetColumnWidth(int c, SheetArea sheetArea)
{
bool columnVisible = _sheet.GetColumnVisible(c, sheetArea);
if ((sheetArea == SheetArea.Cells) && (c < _sheet.ColumnCount))
{
columnVisible = columnVisible && !_sheet.ColumnRangeGroup.IsCollapsed(c);
}
if (!columnVisible)
{
return(0.0);
}
double columnWidth = _sheet.GetColumnWidth(c, sheetArea);
if (!_info.BestFitColumns)
{
return(columnWidth);
}
bool rowHeader = sheetArea == (SheetArea.CornerHeader | SheetArea.RowHeader);
double num2 = Math.Ceiling(_excel.GetColumnAutoFitValue(c, rowHeader));
if (num2 <= 0.0)
{
return(columnWidth);
}
return((num2 + 1.0) + 4.0);
}
void OnSpanModelChanged(int row, int column, int rowCount, int columnCount, SheetArea area)
{
if (AutoRefresh)
{
RefreshRange(row, column, rowCount, columnCount, area);
}
}
/// <summary>
/// Gets the cell data.
/// </summary>
/// <param name="worksheet">The sheet</param>
/// <param name="area">The area</param>
/// <param name="rowIndex">Index of the row</param>
/// <param name="columnIndex">Index of the column</param>
/// <param name="opt">The opt</param>
/// <returns></returns>
static object GetCellData(Worksheet worksheet, SheetArea area, int rowIndex, int columnIndex, ImportExportOptions opt)
{
if (opt.Formula && (area == SheetArea.Cells))
{
string formula = worksheet.GetFormula(rowIndex, columnIndex);
if (!string.IsNullOrEmpty(formula))
{
return(string.Format("={0}", (object[])new object[] { formula }));
}
}
if (!opt.UnFormatted)
{
IFormatter formatter = worksheet.GetActualFormatter(rowIndex, columnIndex, area);
if (formatter != null)
{
return(worksheet.Value2Text(worksheet.GetValue(rowIndex, columnIndex, area), formatter));
}
}
object columnLabel = worksheet.GetValue(rowIndex, columnIndex, area);
if ((columnLabel == null) && (area == SheetArea.ColumnHeader))
{
columnLabel = worksheet.GetColumnLabel(rowIndex, columnIndex);
}
if ((columnLabel == null) && (area == (SheetArea.CornerHeader | SheetArea.RowHeader)))
{
columnLabel = worksheet.GetRowLabel(rowIndex, columnIndex);
}
return(columnLabel);
}
/// <summary>
///
/// </summary>
/// <param name="excelWorksheet"></param>
/// <param name="sheetFormat"></param>
/// <param name="selectedAreaJsonArray"></param>
/// <returns></returns>
private List <String> GetExcelHeaderFields(ExcelWorksheet excelWorksheet, SheetFormat sheetFormat, string selectedAreaJsonArray)
{
List <String> headerValues = new List <string>();
int[] areaValues = JsonConvert.DeserializeObject <int[]>(selectedAreaJsonArray);
if (areaValues.Length != 4)
{
throw new InvalidOperationException("Given JSON string for selected area got an invalid length of [" + Convert.ToString(areaValues.Length) + "]");
}
SheetArea selectedArea = new SheetArea(areaValues[1], areaValues[3], areaValues[0], areaValues[2]);
switch (sheetFormat)
{
case SheetFormat.TopDown:
headerValues = GetExcelHeaderFieldsTopDown(excelWorksheet, selectedArea);
break;
case SheetFormat.LeftRight:
headerValues = GetExcelHeaderFieldsLeftRight(excelWorksheet, selectedArea);
break;
case SheetFormat.Matrix:
headerValues.AddRange(GetExcelHeaderFieldsTopDown(excelWorksheet, selectedArea));
headerValues.AddRange(GetExcelHeaderFieldsLeftRight(excelWorksheet, selectedArea));
break;
default:
break;
}
return(headerValues);
}
public TabularPosition(SheetArea area, int row, int column)
{
this = new TabularPosition();
_isNotEmpty = true;
_area = area;
_row = row;
_column = column;
}
/// <summary>
/// 获得行头或Excel当前表总宽
/// </summary>
/// <param name="p_sheet"></param>
/// <param name="p_count"></param>
/// <param name="p_area"></param>
/// <returns></returns>
double GetTotalWidth(Worksheet p_sheet, int p_count, SheetArea p_area)
{
double width = 0.0;
for (int i = 0; i < p_count; i++)
{
width += p_sheet.GetActualColumnWidth(i, p_area);
}
return(width);
}
/// <summary>
/// 获得列头或Excel当前表总高
/// </summary>
/// <param name="p_sheet"></param>
/// <param name="p_count"></param>
/// <param name="p_area"></param>
/// <returns></returns>
double GetTotalHeight(Worksheet p_sheet, int p_count, SheetArea p_area)
{
double height = 0.0;
for (int i = 0; i < p_count; i++)
{
height += p_sheet.GetActualRowHeight(i, p_area);
}
return(height);
}
public static void SetStyleObject(Worksheet sheet, int row, int column, SheetArea area, object style)
{
if (style is string)
{
sheet.SetStyleName(row, column, area, (string)((string)style));
}
else
{
sheet.SetStyleInfo(row, column, area, style as StyleInfo);
}
}
static int GetRowCount(Worksheet worksheet, SheetArea sheetArea)
{
if ((sheetArea == SheetArea.Cells) || (sheetArea == (SheetArea.CornerHeader | SheetArea.RowHeader)))
{
return(worksheet.RowCount);
}
if (sheetArea == SheetArea.ColumnHeader)
{
return(worksheet.ColumnHeader.RowCount);
}
return(0);
}
public HeaderPanel(Excel p_excel, SheetArea p_sheetArea)
{
Area = p_sheetArea;
Excel = p_excel;
CachedSpanGraph = new SpanGraph();
CellCache = new CellCachePool(GetDataContext());
_rows = new Dictionary <int, HeaderItem>();
_recycledRows = new List <HeaderItem>();
HorizontalAlignment = HorizontalAlignment.Left;
VerticalAlignment = VerticalAlignment.Top;
}
public FilterButtonInfo Find(int row, int column, SheetArea sheetArea)
{
for (int i = 0; i < base.Count; i++)
{
FilterButtonInfo info = base[i];
if (((info != null) && (info.Row == row)) && ((info.Column == column) && (info.SheetArea == sheetArea)))
{
return(info);
}
}
return(null);
}
internal static int GetValueRow(Worksheet worksheet, SheetArea area, int row, int column, SheetSpanModelBase spans)
{
if (string.IsNullOrEmpty(worksheet.GetText(row, column, area)) && (spans.Find(row, column) == null))
{
for (int i = row + 1; i < worksheet.RowCount; i++)
{
if (!string.IsNullOrEmpty(worksheet.GetText(i, column, area)))
{
return(i);
}
}
}
return(row);
}
public static void SetFormatter(Worksheet worksheet, int row, int column, SheetArea area, GeneralFormatter gformatter)
{
if (area == SheetArea.Cells)
{
worksheet.Cells[row, column].Formatter = new AutoFormatter(gformatter);
}
if (area == (SheetArea.CornerHeader | SheetArea.RowHeader))
{
worksheet.RowHeader.Cells[row, column].Formatter = new AutoFormatter(gformatter);
}
if (area == SheetArea.ColumnHeader)
{
worksheet.ColumnHeader.Cells[row, column].Formatter = new AutoFormatter(gformatter);
}
}
static void SetAxisBorder(Worksheet workSheet, SheetArea sheetArea, int index, int count, bool[] flags, BorderLine[] lines, bool isRowDirection)
{
for (int i = 0; i < count; i++)
{
int row = isRowDirection ? (index + i) : -1;
int column = isRowDirection ? -1 : (index + i);
StyleInfo style = workSheet.GetStyleInfo(row, column, sheetArea);
if (style == null)
{
style = new StyleInfo();
}
UpdateStyle(style, flags, lines);
workSheet.SetStyleInfo(row, column, sheetArea, style);
}
}
public bool IncludeSheetArea(SheetArea area)
{
switch (area)
{
case SheetArea.Cells:
return(true);
case (SheetArea.CornerHeader | SheetArea.RowHeader):
return(this.RowHeader);
case SheetArea.ColumnHeader:
return(this.ColumnHeader);
}
throw new ArgumentOutOfRangeException("area");
}
public TabularRange(SheetArea area, int row, int column, int rowCount = 1, int columnCount = 1)
{
_area = area;
if (row == -1)
{
rowCount = -1;
}
if (column == -1)
{
columnCount = -1;
}
_row = row;
_column = column;
_rowCount = rowCount;
_columnCount = columnCount;
}
/// <summary>
/// Gets the row heights.
/// </summary>
/// <param name="worksheet">The worksheet.</param>
/// <param name="area">The area.</param>
/// <param name="startIndex">The start index.</param>
/// <param name="count">The count.</param>
/// <returns></returns>
public static List <double> GetRowHeights(Worksheet worksheet, SheetArea area, int startIndex, int count)
{
List <double> list = new List <double>();
for (int i = startIndex; i < (startIndex + count); i++)
{
if (!worksheet.GetActualRowVisible(i, area))
{
list.Add(0.0);
}
else
{
list.Add(worksheet.GetRowHeight(i, area));
}
}
return(list);
}
/// <summary>
/// Gets the span layout data.
/// </summary>
/// <param name="area">The area.</param>
/// <returns></returns>
public SpanLayoutData GetSpanLayoutData(SheetArea area)
{
switch (area)
{
case SheetArea.CornerHeader:
return(this.topLeftCornerSpans);
case SheetArea.Cells:
return(this.cellSpans);
case (SheetArea.CornerHeader | SheetArea.RowHeader):
return(this.rowHeaderSpans);
case SheetArea.ColumnHeader:
return(this.columnHeaderSpans);
}
throw new ArgumentOutOfRangeException("area");
}
double GetRowHeight(int r, SheetArea sheetArea)
{
bool rowVisible = _sheet.GetRowVisible(r, sheetArea);
if ((sheetArea == SheetArea.Cells) && (r < _sheet.RowCount))
{
rowVisible = (rowVisible && !_sheet.Rows[r].IsFilteredOut) && !_sheet.RowRangeGroup.IsCollapsed(r);
}
if (!rowVisible)
{
return(0.0);
}
double rowHeight = _sheet.GetRowHeight(r, sheetArea);
if (!_info.BestFitRows)
{
return(rowHeight);
}
bool columnHeader = sheetArea == SheetArea.ColumnHeader;
double num2 = Math.Ceiling(_excel.GetRowAutoFitValue(r, columnHeader));
if (num2 <= 0.0)
{
return(rowHeight);
}
double defaultRowHeight = (num2 + 1.0) + 2.0;
if (columnHeader)
{
if (defaultRowHeight < _sheet.ColumnHeader.DefaultRowHeight)
{
defaultRowHeight = _sheet.ColumnHeader.DefaultRowHeight;
}
return(defaultRowHeight);
}
if (defaultRowHeight < _sheet.DefaultRowHeight)
{
defaultRowHeight = _sheet.DefaultRowHeight;
}
return(defaultRowHeight);
}
public string GetText()
{
if (!this.sheetValue)
{
return((string)(this.value as string));
}
if ((((this.sheet == null) || (this.row <= -1)) || ((this.row >= this.sheet.RowCount) || (this.column <= -1))) || (this.column >= this.sheet.ColumnCount))
{
return(string.Empty);
}
object obj2 = this.sheet.GetValue(this.row, this.column);
if (obj2 == null)
{
return(string.Empty);
}
SheetArea cells = SheetArea.Cells;
StorageBlock storage = this.sheet.GetStorage(cells);
StyleInfo info = this.sheet.GetCompositeStyle(this.row, this.column, cells, storage);
return(this.sheet.Value2Text(obj2, info.Formatter));
}
public static object GetStyleObject(Worksheet sheet, int row, int column, SheetArea area)
{
StyleInfo objA = sheet.GetStyleInfo(row, column, area);
if (objA != null)
{
string name = objA.Name;
StyleInfo objB = null;
if (sheet.NamedStyles != null)
{
objB = sheet.NamedStyles.Find(name);
}
if (((objB == null) && (sheet.Workbook != null)) && (sheet.Workbook.NamedStyles != null))
{
objB = sheet.Workbook.NamedStyles.Find(name);
}
if ((objB != null) && object.ReferenceEquals(objA, objB))
{
return(name);
}
}
return(objA);
}
public static SpanLayoutData GetSpanLayoutData(Worksheet worksheet, SheetArea area, int rowStartIndex, int rowEndIndex, int columnStartIndex, int columnEndIndex)
{
if ((rowEndIndex < rowStartIndex) || (columnEndIndex < columnStartIndex))
{
return(null);
}
SpanLayoutData data = new SpanLayoutData();
SheetSpanModel spanModel = null;
switch (area)
{
case SheetArea.Cells:
spanModel = worksheet.SpanModel;
break;
case (SheetArea.CornerHeader | SheetArea.RowHeader):
spanModel = worksheet.RowHeaderSpanModel;
break;
case SheetArea.ColumnHeader:
spanModel = worksheet.ColumnHeaderSpanModel;
break;
default:
throw new ArgumentException("area");
}
if (spanModel != null)
{
IEnumerator enumerator = spanModel.GetEnumerator(rowStartIndex, columnStartIndex, (rowEndIndex - rowStartIndex) + 1, (columnEndIndex - columnStartIndex) + 1);
while (enumerator.MoveNext())
{
CellRange current = (CellRange)enumerator.Current;
data.Add(current.Row, current.Column, current.RowCount, current.ColumnCount, true);
}
}
return(data);
}
public static void UndoCellsInfo(Worksheet sheet, CopyMoveCellsInfo cellsInfo, int baseRow, int baseColumn, SheetArea area)
{
int rowCount = cellsInfo.RowCount;
int columnCount = cellsInfo.ColumnCount;
sheet.SuspendCalcService();
try
{
for (int i = 0; i < rowCount; i++)
{
for (int j = 0; j < columnCount; j++)
{
if (cellsInfo.IsFormulaSaved() && (area == SheetArea.Cells))
{
sheet.SetFormula(baseRow + i, baseColumn + j, null);
}
if (cellsInfo.IsSparklineSaved() && (area == SheetArea.Cells))
{
sheet.RemoveSparkline(baseRow + i, baseColumn + j);
}
if (cellsInfo.IsValueSaved())
{
sheet.SetValue(baseRow + i, baseColumn + j, area, null);
}
if (cellsInfo.IsStyleSaved())
{
SetStyleObject(sheet, baseRow + i, baseColumn + j, area, null);
}
if (cellsInfo.IsTagSaved())
{
sheet.SetTag(baseRow + i, baseColumn + j, area, null);
}
}
}
if (cellsInfo.IsFormulaSaved() && (area == SheetArea.Cells))
{
foreach (CellData data in cellsInfo.GetFormulas())
{
sheet.SetFormula(baseRow + data.Row, baseColumn + data.Column, (string)(data.Value as string));
}
}
if (cellsInfo.IsSparklineSaved() && (area == SheetArea.Cells))
{
foreach (CellData data2 in cellsInfo.GetSparklines())
{
SparklineInfo info = data2.Value as SparklineInfo;
if (info == null)
{
((ISparklineSheet)sheet).SetSparkline(baseRow + data2.Row, baseColumn + data2.Column, null);
}
else if (info.DataAxisRange == null)
{
sheet.SetSparkline(baseRow + data2.Row, baseColumn + data2.Column, info.DataRange, info.Sparkline.DataOrientation, info.Sparkline.SparklineType, info.Sparkline.Setting);
}
else
{
sheet.SetSparkline(baseRow + data2.Row, baseColumn + data2.Column, info.DataRange, info.Sparkline.DataOrientation, info.Sparkline.SparklineType, info.DataAxisRange, info.Sparkline.DateAxisOrientation, info.Sparkline.Setting);
}
}
}
if (cellsInfo.IsValueSaved())
{
foreach (CellData data3 in cellsInfo.GetValues())
{
sheet.SetValue(baseRow + data3.Row, baseColumn + data3.Column, area, data3.Value);
}
}
if (cellsInfo.IsStyleSaved())
{
foreach (CellData data4 in cellsInfo.GetStyles())
{
SetStyleObject(sheet, baseRow + data4.Row, baseColumn + data4.Column, area, data4.Value);
}
}
if (cellsInfo.IsTagSaved())
{
foreach (CellData data5 in cellsInfo.GetTags())
{
sheet.SetTag(baseRow + data5.Row, baseColumn + data5.Column, area, data5.Value);
}
}
if (cellsInfo.IsArrayFormulaSaved() && (area == SheetArea.Cells))
{
object[,] arrayFormula = Excel.GetsArrayFormulas(sheet, baseRow, baseColumn, rowCount, columnCount);
if ((arrayFormula != null) && (arrayFormula.Length > 0))
{
int length = arrayFormula.GetLength(0);
for (int k = 0; k < length; k++)
{
CellRange range = (CellRange)arrayFormula[k, 0];
sheet.SetArrayFormula(range.Row, range.Column, range.RowCount, range.ColumnCount, null);
}
}
arrayFormula = cellsInfo.GetArrayFormula();
if ((arrayFormula != null) && (arrayFormula.Length > 0))
{
int num7 = arrayFormula.GetLength(0);
for (int m = 0; m < num7; m++)
{
CellRange range2 = (CellRange)arrayFormula[m, 0];
string formula = (string)((string)arrayFormula[m, 1]);
if (formula.StartsWith("{") && formula.EndsWith("}"))
{
formula = formula.Substring(1, formula.Length - 2);
}
sheet.SetArrayFormula(range2.Row, range2.Column, range2.RowCount, range2.ColumnCount, formula);
}
}
}
}
finally
{
sheet.ResumeCalcService();
}
SheetSpanModel spanModel = null;
if (area == SheetArea.Cells)
{
spanModel = sheet.SpanModel;
}
else if (area == SheetArea.ColumnHeader)
{
spanModel = sheet.ColumnHeaderSpanModel;
}
else if (area == (SheetArea.CornerHeader | SheetArea.RowHeader))
{
spanModel = sheet.RowHeaderSpanModel;
}
if ((spanModel != null) && !spanModel.IsEmpty())
{
List <CellRange> list6 = new List <CellRange>();
IEnumerator enumerator = spanModel.GetEnumerator(baseRow, baseColumn, rowCount, columnCount);
while (enumerator.MoveNext())
{
CellRange current = enumerator.Current as CellRange;
if (current != null)
{
list6.Add(current);
}
}
foreach (CellRange range4 in list6)
{
spanModel.Remove(range4.Row, range4.Column);
}
}
if (cellsInfo.IsSpanSaved() && (spanModel != null))
{
foreach (CellRange range5 in cellsInfo.Spans)
{
spanModel.Add(range5.Row, range5.Column, range5.RowCount, range5.ColumnCount);
}
}
}
/// <summary>
/// Gets all values from selected header area. This method is for left to right scheme, so the header fields are in one coulumn
/// </summary>
/// <param name="excelWorksheet">ExcelWorksheet with the data</param>
/// <param name="selectedArea">Defined header area with start and end for rows and columns</param>
/// <returns>Simple list with values of the header fields as string</returns>
private List <String> GetExcelHeaderFieldsLeftRight(ExcelWorksheet excelWorksheet, SheetArea selectedArea)
{
List <String> headerValues = new List <string>();
String jsonTableString = TaskManager.Bus[EasyUploadTaskManager.SHEET_JSON_DATA].ToString();
String[][] jsonTable = JsonConvert.DeserializeObject <string[][]>(jsonTableString);
for (int row = selectedArea.StartRow; row <= selectedArea.EndColumn; row++)
{
headerValues.Add(jsonTable[row][selectedArea.StartColumn]);
}
return(headerValues);
}
List <PageInfo> HorizontalPaginatorCore(int columnStart, int columnEnd, int repeatColumnStart, int repeatColumnEnd, SheetArea sheetArea, double pageWidth)
{
bool flag = repeatColumnStart < columnStart;
double num = 0.0;
double num2 = 0.0;
double num3 = 0.0;
double num4 = pageWidth;
int num5 = repeatColumnStart;
int num6 = repeatColumnEnd;
double xEnd = 0.0;
PageInfo info = null;
List <PageInfo> list = new List <PageInfo>();
if (columnStart > columnEnd)
{
columnStart = columnEnd;
}
for (int i = columnStart; i <= columnEnd; i++)
{
if (flag && (sheetArea == SheetArea.Cells))
{
num5 = repeatColumnStart;
num6 = repeatColumnEnd;
if ((num5 != -1) && (num5 < i))
{
if (num6 >= i)
{
num6 = i - 1;
}
if (info == null)
{
info = new PageInfo();
}
info.RepeatItemStart = repeatColumnStart;
info.RepeatItemEnd = repeatColumnEnd;
for (int j = num5; j <= num6; j++)
{
double columnWidth = GetColumnWidth(j, sheetArea);
num3 += columnWidth;
}
num4 -= num3;
flag = false;
}
}
double cw = GetColumnWidth(i, sheetArea);
num += cw;
xEnd += cw;
if ((num > num4) || (num == num4))
{
if (num > num4)
{
num2 = (num - GetColumnWidth(i, sheetArea)) + num3;
xEnd = (xEnd - GetColumnWidth(i, sheetArea)) + num3;
i--;
}
else
{
num2 = num + num3;
xEnd += num3;
}
if (info == null)
{
info = new PageInfo();
}
info.ItemEnd = i;
info.ContentSize = num2;
info.XEnd = xEnd;
list.Add(info);
info = null;
num = 0.0;
num2 = 0.0;
num3 = 0.0;
num4 = pageWidth;
flag = true;
}
else if (i == columnEnd)
{
if (info == null)
{
info = new PageInfo();
}
num2 = num + num3;
info.ItemEnd = i;
info.ContentSize = num2;
info.XEnd = xEnd;
list.Add(info);
info = null;
num = 0.0;
num2 = 0.0;
num3 = 0.0;
num4 = pageWidth;
flag = true;
}
}
return(list);
}
/// <summary>
/// Gets the part data.
/// </summary>
/// <param name="worksheet">The sheet</param>
/// <param name="rowStartIndex">Start index of the row</param>
/// <param name="rowEndIndex">End index of the row</param>
/// <param name="columnStartIndex">Start index of the column</param>
/// <param name="columnEndIndex">End index of the column</param>
/// <param name="area">The area</param>
/// <param name="opt">The opt</param>
/// <returns></returns>
static List <List <object> > GetPartData(Worksheet worksheet, int rowStartIndex, int rowEndIndex, int columnStartIndex, int columnEndIndex, SheetArea area, ImportExportOptions opt)
{
if (!opt.IncludeSheetArea(area))
{
return(null);
}
List <List <object> > list = new List <List <object> >();
bool actualVisible = true;
for (int i = rowStartIndex; i <= rowEndIndex; i++)
{
if (area == SheetArea.ColumnHeader)
{
actualVisible = worksheet.ColumnHeader.Rows[i].ActualVisible;
}
else
{
actualVisible = worksheet.Rows[i].ActualVisible;
}
if (actualVisible || !opt.AsViewed)
{
List <object> list2 = new List <object>();
if (opt.RowHeader && (area == SheetArea.Cells))
{
for (int k = 0; k < worksheet.GetColumnCount(SheetArea.CornerHeader | SheetArea.RowHeader); k++)
{
if (worksheet.GetActualColumnVisible(k, SheetArea.CornerHeader | SheetArea.RowHeader) || !opt.AsViewed)
{
list2.Add(GetCellData(worksheet, SheetArea.CornerHeader | SheetArea.RowHeader, i, k, opt));
}
}
}
for (int j = columnStartIndex; j <= columnEndIndex; j++)
{
if (worksheet.GetActualColumnVisible(j, SheetArea.Cells) || !opt.AsViewed)
{
list2.Add(GetCellData(worksheet, area, i, j, opt));
}
}
list.Add(list2);
}
}
return(list);
}
/// <summary>
/// Sets the row data.
/// </summary>
/// <param name="worksheet">The sheet</param>
/// <param name="rowData">The row data</param>
/// <param name="sheetRowIndex">Index of the sheet row</param>
/// <param name="columnIndex">Index of the column</param>
/// <param name="columnCount">The column count</param>
/// <param name="area">The area</param>
/// <param name="opt">The opt</param>
static void SetRowData(Worksheet worksheet, List <string> rowData, int sheetRowIndex, int columnIndex, int columnCount, SheetArea area, ImportExportOptions opt)
{
int num = 0;
for (int i = columnIndex; num < rowData.Count; i++)
{
if ((columnCount > 0) && (i < worksheet.GetColumnCount(area)))
{
SetCellData(worksheet, area, sheetRowIndex, i, rowData[num], opt);
}
num++;
}
}
/// <summary>
/// Sets the cell data.
/// </summary>
/// <param name="worksheet">The sheet</param>
/// <param name="area">The area</param>
/// <param name="rowIndex">Index of the row</param>
/// <param name="columnIndex">Index of the column</param>
/// <param name="value">The value</param>
/// <param name="opt">The opt</param>
static void SetCellData(Worksheet worksheet, SheetArea area, int rowIndex, int columnIndex, string value, ImportExportOptions opt)
{
object obj2 = value;
GeneralFormatter gformatter = null;
if (!opt.UnFormatted)
{
gformatter = new GeneralFormatter().GetPreferredDisplayFormatter(value, out obj2) as GeneralFormatter;
}
if (obj2 == null)
{
worksheet.SetValue(rowIndex, columnIndex, area, obj2);
}
else if (!object.Equals(value, ""))
{
if (!opt.Formula || !value.StartsWith("="))
{
StyleInfo info = worksheet.GetActualStyleInfo(rowIndex, columnIndex, area);
if (info != null)
{
if (!opt.UnFormatted)
{
if (info.Formatter == null)
{
SetFormatter(worksheet, rowIndex, columnIndex, area, gformatter);
}
else if (info.Formatter.FormatString == "@")
{
obj2 = value.ToString();
}
}
else if (info.Formatter != null)
{
if (area == SheetArea.Cells)
{
worksheet.Cells[rowIndex, columnIndex].ResetFormatter();
}
if (area == (SheetArea.CornerHeader | SheetArea.RowHeader))
{
worksheet.RowHeader.Cells[rowIndex, columnIndex].ResetFormatter();
}
if (area == SheetArea.ColumnHeader)
{
worksheet.ColumnHeader.Cells[rowIndex, columnIndex].ResetFormatter();
}
}
}
worksheet.SetValue(rowIndex, columnIndex, area, obj2);
}
else
{
try
{
worksheet.SetFormula(rowIndex, columnIndex, area, value.Substring(1));
}
catch
{
worksheet.SetText(rowIndex, columnIndex, area, value);
}
}
}
else
{
worksheet.SetValue(rowIndex, columnIndex, area, null);
}
}
internal SheetChangedEventArgs(string propertyName, int row, int column, int rowCount, int columnCount, SheetArea sheetArea, SheetChangedEventAction t) : base(propertyName, row, column, rowCount, columnCount, sheetArea)
{
this.type = t;
}
internal Rect GetRangeBounds(CellRange range, SheetArea area)
{
SheetSpanModel spanModel = null;
if (Excel.ActiveSheet != null)
{
switch (area)
{
case SheetArea.Cells:
spanModel = Excel.ActiveSheet.SpanModel;
break;
case (SheetArea.CornerHeader | SheetArea.RowHeader):
spanModel = Excel.ActiveSheet.RowHeaderSpanModel;
break;
case SheetArea.ColumnHeader:
spanModel = Excel.ActiveSheet.ColumnHeaderSpanModel;
break;
}
}
if (spanModel != null)
{
CellRange range2 = spanModel.Find(range.Row, range.Column);
if (((range2 != null) && (range2.RowCount >= range.RowCount)) && (range2.ColumnCount >= range.ColumnCount))
{
range = range2;
}
}
RowLayoutModel rowLayoutModel = Excel.GetRowLayoutModel(RowViewportIndex, area);
ColumnLayoutModel columnLayoutModel = Excel.GetColumnLayoutModel(ColumnViewportIndex, area);
int row = (rowLayoutModel.Count > 0) ? rowLayoutModel[0].Row : -1;
int num2 = (rowLayoutModel.Count > 0) ? rowLayoutModel[rowLayoutModel.Count - 1].Row : -1;
int column = (columnLayoutModel.Count > 0) ? columnLayoutModel[0].Column : -1;
int num4 = (columnLayoutModel.Count > 0) ? columnLayoutModel[columnLayoutModel.Count - 1].Column : -1;
if (!range.Intersects(row, column, (num2 - row) + 1, (num4 - column) + 1))
{
return(Rect.Empty);
}
int index = Math.Max(range.Row, row);
int num6 = Math.Max(range.Column, column);
int num7 = Math.Min((range.Row + range.RowCount) - 1, num2);
int num8 = Math.Min((range.Column + range.ColumnCount) - 1, num4);
RowLayout layout = rowLayoutModel.Find(index);
RowLayout layout2 = rowLayoutModel.Find(num7);
ColumnLayout layout3 = columnLayoutModel.Find(num6);
ColumnLayout layout4 = columnLayoutModel.Find(num8);
double x = -1.0;
double y = -1.0;
double height = 0.0;
double width = 0.0;
if ((layout != null) && (layout2 != null))
{
y = layout.Y;
height = (layout2.Y + layout2.Height) - layout.Y;
}
else if (rowLayoutModel.Count > 0)
{
y = rowLayoutModel[0].Y;
height = (rowLayoutModel[rowLayoutModel.Count - 1].Y + rowLayoutModel[rowLayoutModel.Count - 1].Height) - y;
}
if ((layout3 != null) && (layout4 != null))
{
x = layout3.X;
width = (layout4.X + layout4.Width) - layout3.X;
}
else if (columnLayoutModel.Count > 0)
{
x = columnLayoutModel[0].X;
width = (columnLayoutModel[columnLayoutModel.Count - 1].X + columnLayoutModel[columnLayoutModel.Count - 1].Width) - x;
}
return(new Rect(PointToClient(new Point(x, y)), new Size(width, height)));
}
