internal void method_1(XmlReader xmlReader_0)
{
foreach (XmlReaderAttributeItem item in xmlReader_0.GetAttributes())
{
string localName = item.LocalName;
if (localName != null)
{
if (localName != "Color")
{
if (!(localName == "PatternColor"))
{
if (localName == "Pattern")
{
this.Pattern = ObjectExtensions.ParseEnum <Aisino.Framework.Plugin.Core.ExcelXml.Pattern>(item.Value);
}
}
else
{
this.PatternColor = XmlStyle.smethod_1(item.Value);
}
}
else
{
this.Color = XmlStyle.smethod_1(item.Value);
}
}
}
}
internal void Import(XmlReader reader)
{
foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
{
switch (xa.LocalName)
{
case "Color":
{
Color = XmlStyle.ExcelFormatToColor(xa.Value);
break;
}
case "PatternColor":
{
PatternColor = XmlStyle.ExcelFormatToColor(xa.Value);
break;
}
case "Pattern":
{
Pattern = ObjectExtensions.ParseEnum <Pattern>(xa.Value);
break;
}
}
}
}
internal static void ImportNamedRanges(XmlReader reader, ExcelXmlWorkbook book, Worksheet ws)
{
if (!reader.IsEmptyElement)
{
while (reader.Read() && !(reader.Name == "Names" && reader.NodeType == XmlNodeType.EndElement))
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name == "NamedRange")
{
Range range = null;
string name = "";
foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
{
if (xa.LocalName == "Name" && xa.HasValue)
{
name = xa.Value;
}
if (xa.LocalName == "RefersTo" && xa.HasValue)
{
range = new Range(xa.Value);
}
}
NamedRange nr = new NamedRange(range, name, ws);
book.NamedRanges.Add(nr);
}
}
}
}
}
internal static void smethod_0(XmlReader xmlReader_0, List <Class139> list_3, Worksheet worksheet_0)
{
if (!xmlReader_0.IsEmptyElement)
{
while (xmlReader_0.Read())
{
if ((xmlReader_0.Name == "Names") && (xmlReader_0.NodeType == XmlNodeType.EndElement))
{
break;
}
if ((xmlReader_0.NodeType == XmlNodeType.Element) && (xmlReader_0.Name == "NamedRange"))
{
Aisino.Framework.Plugin.Core.ExcelXml.Range range = null;
string str = "";
foreach (XmlReaderAttributeItem item in xmlReader_0.GetAttributes())
{
if ((item.LocalName == "Name") && item.HasValue)
{
str = item.Value;
}
if ((item.LocalName == "RefersTo") && item.HasValue)
{
range = new Aisino.Framework.Plugin.Core.ExcelXml.Range(item.Value);
}
}
Class139 class2 = new Class139(range, str, worksheet_0);
list_3.Add(class2);
}
}
}
}
/// <summary>
/// Extension method to get a single attribute and its value
/// </summary>
/// <param name="reader">XmlReader on which extension method is used</param>
/// <param name="attribute">Attribute to read</param>
/// <param name="moveToEnd">Move to the end of the element?</param>
/// <returns>XmlReaderAttributeItem instance if attribute found, null otherwise</returns>
public static XmlReaderAttributeItem GetSingleAttribute(this XmlReader reader, string attribute, bool moveToEnd)
{
string element = reader.Name;
if (moveToEnd && reader.IsEmptyElement)
{
moveToEnd = false;
}
foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
{
if (xa.LocalName == attribute)
{
if (moveToEnd)
{
while (reader.Read() && !(reader.Name == element && reader.NodeType == XmlNodeType.EndElement))
{
;
}
}
return(xa);
}
}
if (moveToEnd)
{
while (reader.Read() && !(reader.Name == element && reader.NodeType == XmlNodeType.EndElement))
{
;
}
}
return(null);
}
internal void Import(XmlReader reader)
{
foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
{
switch (xa.LocalName)
{
case "Vertical":
{
Vertical = ObjectExtensions.ParseEnum <VerticalAlignment>(xa.Value);
break;
}
case "Horizontal":
{
Horizontal = ObjectExtensions.ParseEnum <HorizontalAlignment>(xa.Value);
break;
}
case "WrapText":
{
WrapText = xa.Value == "1" ? true : false;
break;
}
case "ShrinkToFit":
{
ShrinkToFit = xa.Value == "1" ? true : false;
break;
}
case "Indent":
{
int i;
if (xa.Value.ParseToInt(out i))
{
Indent = i;
}
break;
}
case "Rotate":
{
int i;
if (xa.Value.ParseToInt(out i))
{
Rotate = i;
}
break;
}
}
}
}
private void method_10(XmlReader xmlReader_0)
{
bool isEmptyElement = xmlReader_0.IsEmptyElement;
int count = this.list_1.Count;
double num2 = -1.0;
XmlStyle style = null;
bool flag2 = false;
foreach (XmlReaderAttributeItem item in xmlReader_0.GetAttributes())
{
if ((item.LocalName == "Height") && item.HasValue)
{
item.Value.ParseToInt <double>(out num2);
}
if ((item.LocalName == "Index") && item.HasValue)
{
item.Value.ParseToInt <int>(out count);
count--;
}
if ((item.LocalName == "StyleID") && item.HasValue)
{
style = this.excelXmlWorkbook_0.method_6(item.Value);
}
if ((item.LocalName == "Hidden") && item.HasValue)
{
flag2 = item.Value == "1";
}
}
Row row = this.method_13(count);
row.Hidden = flag2;
if (num2 != -1.0)
{
row.Height = num2;
}
if (style != null)
{
row.Style = style;
}
if (!isEmptyElement)
{
while (xmlReader_0.Read())
{
if ((xmlReader_0.Name == "Row") && (xmlReader_0.NodeType == XmlNodeType.EndElement))
{
return;
}
if ((xmlReader_0.NodeType == XmlNodeType.Element) && (xmlReader_0.Name == "Cell"))
{
this.method_11(xmlReader_0, row);
}
}
}
}
internal void Import(XmlReader reader)
{
foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
{
switch (xa.LocalName)
{
case "FontName":
{
Name = xa.Value;
break;
}
case "Size":
{
int i;
if (xa.Value.ParseToInt(out i))
{
Size = i;
}
break;
}
case "Color":
{
Color = XmlStyle.ExcelFormatToColor(xa.Value);
break;
}
case "Bold":
{
Bold = xa.Value == "1" ? true : false;
break;
}
case "Italic":
{
Italic = xa.Value == "1" ? true : false;
break;
}
case "Underline":
{
Underline = xa.Value == "Single" ? true : false;
break;
}
case "Strikeout":
{
Strikeout = xa.Value == "1" ? true : false;
break;
}
}
}
}
private void ImportRow(XmlReader reader)
{
bool isEmpty = reader.IsEmptyElement;
int rowIndex = _Rows.Count;
double height = -1;
XmlStyle style = null;
bool hidden = false;
foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
{
if (xa.LocalName == "Height" && xa.HasValue)
{
xa.Value.ParseToInt(out height);
}
if (xa.LocalName == "Index" && xa.HasValue)
{
xa.Value.ParseToInt(out rowIndex);
rowIndex--;
}
if (xa.LocalName == "StyleID" && xa.HasValue)
{
style = ParentBook.GetStyleByID(xa.Value);
}
if (xa.LocalName == "Hidden" && xa.HasValue)
{
hidden = xa.Value == "1";
}
}
Row row = GetRowByIndex(rowIndex);
row.Hidden = hidden;
if (height != -1)
{
row.Height = height;
}
if (style != null)
{
row.Style = style;
}
if (isEmpty)
{
return;
}
while (reader.Read() && !(reader.Name == "Row" && reader.NodeType == XmlNodeType.EndElement))
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name == "Cell")
{
ImportCell(reader, row);
}
}
}
}
internal void Import(XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
while (reader.Read() && !(reader.Name == "Borders" && reader.NodeType == XmlNodeType.EndElement))
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name == "Border")
{
foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
{
switch (xa.LocalName)
{
case "Position":
{
Sides |= ObjectExtensions.ParseEnum <BorderSides>(xa.Value);
break;
}
case "LineStyle":
{
LineStyle = ObjectExtensions.ParseEnum <Borderline>(xa.Value);
break;
}
case "Weight":
{
int i;
if (xa.Value.ParseToInt(out i))
{
Weight = i;
}
break;
}
}
}
}
}
}
}
public static XmlReaderAttributeItem GetSingleAttribute(this XmlReader xmlReader_0, string string_0, bool bool_0)
{
string name = xmlReader_0.Name;
if (bool_0 && xmlReader_0.IsEmptyElement)
{
bool_0 = false;
}
using (IEnumerator <XmlReaderAttributeItem> enumerator = xmlReader_0.GetAttributes().GetEnumerator())
{
XmlReaderAttributeItem current;
while (enumerator.MoveNext())
{
current = enumerator.Current;
if (current.LocalName == string_0)
{
goto Label_0043;
}
}
goto Label_0078;
Label_0043:
if (bool_0)
{
while (xmlReader_0.Read())
{
if ((xmlReader_0.Name == name) && (xmlReader_0.NodeType == XmlNodeType.EndElement))
{
return(current);
}
}
}
return(current);
}
Label_0078:
if (bool_0)
{
while (xmlReader_0.Read())
{
if ((xmlReader_0.Name == name) && (xmlReader_0.NodeType == XmlNodeType.EndElement))
{
break;
}
}
}
return(null);
}
internal void Import(XmlReader reader)
{
foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
{
if (xa.LocalName == "Name" && xa.HasValue)
{
Name = xa.Value;
}
if (xa.LocalName == "StyleID" && xa.HasValue)
{
Style = ParentBook.GetStyleByID(xa.Value);
}
}
while (reader.Read() && !(reader.Name == "Worksheet" && reader.NodeType == XmlNodeType.EndElement))
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Names":
{
ExcelXmlWorkbook.ImportNamedRanges(reader, GetParentBook(), this);
break;
}
case "Table":
{
ImportTable(reader);
break;
}
case "WorksheetOptions":
{
ImportOptions(reader);
break;
}
}
}
}
}
internal void method_5(XmlReader xmlReader_0)
{
foreach (XmlReaderAttributeItem item in xmlReader_0.GetAttributes())
{
if ((item.LocalName == "Name") && item.HasValue)
{
this.Name = item.Value;
}
if ((item.LocalName == "StyleID") && item.HasValue)
{
base.Style = this.excelXmlWorkbook_0.method_6(item.Value);
}
}
while (xmlReader_0.Read())
{
string str;
if ((xmlReader_0.Name == "Worksheet") && (xmlReader_0.NodeType == XmlNodeType.EndElement))
{
break;
}
if ((xmlReader_0.NodeType == XmlNodeType.Element) && ((str = xmlReader_0.Name) != null))
{
if (str != "Names")
{
if (!(str == "Table"))
{
if (str == "WorksheetOptions")
{
this.method_6(xmlReader_0);
}
}
else
{
this.method_9(xmlReader_0);
}
}
else
{
ExcelXmlWorkbook.smethod_0(xmlReader_0, this.vmethod_0().list_2, this);
}
}
}
}
internal void method_1(XmlReader xmlReader_0)
{
foreach (XmlReaderAttributeItem item in xmlReader_0.GetAttributes())
{
string localName = item.LocalName;
if (localName != null)
{
if (localName == "Vertical")
{
this.Vertical = ObjectExtensions.ParseEnum <VerticalAlignment>(item.Value);
}
else if (localName == "Horizontal")
{
this.Horizontal = ObjectExtensions.ParseEnum <HorizontalAlignment>(item.Value);
}
else if (localName == "WrapText")
{
this.WrapText = item.Value == "1";
}
else if (localName == "ShrinkToFit")
{
this.ShrinkToFit = item.Value == "1";
}
else if (!(localName == "Indent"))
{
int num;
if ((localName == "Rotate") && item.Value.ParseToInt <int>(out num))
{
this.Rotate = num;
}
}
else
{
int num2;
if (item.Value.ParseToInt <int>(out num2))
{
this.Indent = num2;
}
}
}
}
}
internal void method_1(XmlReader xmlReader_0)
{
if (!xmlReader_0.IsEmptyElement)
{
while (xmlReader_0.Read())
{
if ((xmlReader_0.Name == "Borders") && (xmlReader_0.NodeType == XmlNodeType.EndElement))
{
return;
}
if ((xmlReader_0.NodeType == XmlNodeType.Element) && (xmlReader_0.Name == "Border"))
{
foreach (XmlReaderAttributeItem item in xmlReader_0.GetAttributes())
{
string localName = item.LocalName;
if (localName != null)
{
if (localName != "Position")
{
if (!(localName == "LineStyle"))
{
int num;
if ((localName == "Weight") && item.Value.ParseToInt <int>(out num))
{
this.Weight = num;
}
}
else
{
this.LineStyle = ObjectExtensions.ParseEnum <Borderline>(item.Value);
}
}
else
{
this.Sides |= (BorderSides)ObjectExtensions.ParseEnum <BorderSides>(item.Value);
}
}
}
}
}
}
}
internal void method_1(XmlReader xmlReader_0)
{
foreach (XmlReaderAttributeItem item in xmlReader_0.GetAttributes())
{
switch (item.LocalName)
{
case "FontName":
this.Name = item.Value;
break;
case "Size":
int num;
if (item.Value.ParseToInt <int>(out num))
{
this.Size = num;
}
break;
case "Color":
this.Color = XmlStyle.smethod_1(item.Value);
break;
case "Bold":
this.Bold = item.Value == "1";
break;
case "Italic":
this.Italic = item.Value == "1";
break;
case "Underline":
this.Underline = item.Value == "Single";
break;
case "Strikeout":
this.Strikeout = item.Value == "1";
break;
}
}
}
/// <summary>
/// Extension method to get a single attribute and its value
/// </summary>
/// <param name="reader">XmlReader on which extension method is used</param>
/// <param name="attribute">Attribute to read</param>
/// <param name="moveToEnd">Move to the end of the element?</param>
/// <returns>XmlReaderAttributeItem instance if attribute found, null otherwise</returns>
public static XmlReaderAttributeItem GetSingleAttribute(this XmlReader reader, string attribute, bool moveToEnd)
{
string name = reader.Name;
if (moveToEnd && reader.IsEmptyElement)
{
moveToEnd = false;
}
XmlReaderAttributeItem result;
foreach (XmlReaderAttributeItem current in reader.GetAttributes())
{
if (current.LocalName == attribute)
{
if (moveToEnd)
{
while (reader.Read() && (!(reader.Name == name) || reader.NodeType != XmlNodeType.EndElement))
{
}
}
result = current;
return(result);
}
}
if (moveToEnd)
{
while (reader.Read() && (!(reader.Name == name) || reader.NodeType != XmlNodeType.EndElement))
{
}
}
result = null;
return(result);
}
private void method_9(XmlReader xmlReader_0)
{
if (!xmlReader_0.IsEmptyElement)
{
int num = 0;
while (xmlReader_0.Read())
{
string str;
if ((xmlReader_0.Name == "Table") && (xmlReader_0.NodeType == XmlNodeType.EndElement))
{
break;
}
if ((xmlReader_0.NodeType == XmlNodeType.Element) && ((str = xmlReader_0.Name) != null))
{
if (!(str == "Column"))
{
if (str == "Row")
{
this.method_10(xmlReader_0);
}
}
else
{
double num2 = 0.0;
bool flag = false;
int num4 = 1;
XmlStyle style = null;
foreach (XmlReaderAttributeItem item in xmlReader_0.GetAttributes())
{
double num5;
if (((item.LocalName == "Width") && item.HasValue) && item.Value.ParseToInt <double>(out num5))
{
num2 = num5;
}
if ((item.LocalName == "Hidden") && item.HasValue)
{
flag = item.Value == "1";
}
if ((item.LocalName == "Index") && item.HasValue)
{
item.Value.ParseToInt <int>(out num);
}
if ((item.LocalName == "Span") && item.HasValue)
{
item.Value.ParseToInt <int>(out num4);
}
if ((item.LocalName == "StyleID") && item.HasValue)
{
style = this.excelXmlWorkbook_0.method_6(item.Value);
}
}
for (int i = 1; i <= num4; i++)
{
this.Columns(num).Width = num2;
this.Columns(num).Hidden = flag;
if (style != null)
{
this.Columns(num).Style = style;
}
num++;
}
}
}
}
}
}
private void ImportCell(XmlReader reader, Row row)
{
bool isEmpty = reader.IsEmptyElement;
int cellIndex = row._Cells.Count;
int mergeDown = 0;
int mergeAcross = 0;
XmlStyle style = null;
string formula = "";
string reference = "";
foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
{
if (xa.LocalName == "Index" && xa.HasValue)
{
xa.Value.ParseToInt(out cellIndex);
cellIndex--;
}
if (xa.LocalName == "StyleID" && xa.HasValue)
{
style = ParentBook.GetStyleByID(xa.Value);
}
if (xa.LocalName == "HRef" && xa.HasValue)
{
reference = xa.Value;
}
if (xa.LocalName == "Formula" && xa.HasValue)
{
formula = xa.Value;
}
if (xa.LocalName == "MergeAcross" && xa.HasValue)
{
xa.Value.ParseToInt(out mergeAcross);
}
if (xa.LocalName == "MergeDown" && xa.HasValue)
{
xa.Value.ParseToInt(out mergeDown);
}
}
Cell cell = Cells(cellIndex, row.RowIndex);
if (style != null)
{
cell.Style = style;
}
if (!reference.IsNullOrEmpty())
{
cell.HRef = reference;
}
if (!formula.IsNullOrEmpty())
{
FormulaParser.Parse(cell, formula);
return;
}
if (isEmpty)
{
return;
}
if (mergeDown > 0 || mergeAcross > 0)
{
cell.MergeStart = true;
Range range = new Range(cell, Cells(cellIndex + mergeAcross, row.RowIndex + mergeDown));
_MergedCells.Add(range);
cell.ColumnSpan = range.ColumnCount;
cell.RowSpan = range.RowCount;
}
while (reader.Read() && !(reader.Name == "Cell" && reader.NodeType == XmlNodeType.EndElement))
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name == "Data")
{
ImportCellData(reader, cell);
}
else if (reader.Name == "Comment")
{
ImportCellComment(reader, cell);
}
}
}
}
private void method_8(XmlReader xmlReader_0)
{
if (!xmlReader_0.IsEmptyElement)
{
while (xmlReader_0.Read())
{
string str;
if ((xmlReader_0.Name == "PageSetup") && (xmlReader_0.NodeType == XmlNodeType.EndElement))
{
return;
}
if ((xmlReader_0.NodeType == XmlNodeType.Element) && ((str = xmlReader_0.Name) != null))
{
if (str == "Layout")
{
XmlReaderAttributeItem item3 = xmlReader_0.GetSingleAttribute("Orientation", true);
if (item3 != null)
{
this.PrintOptions.Orientation = ObjectExtensions.ParseEnum <PageOrientation>(item3.Value);
}
}
else if (str == "Header")
{
double num3;
XmlReaderAttributeItem item4 = xmlReader_0.GetSingleAttribute("Margin", true);
if ((item4 != null) && item4.Value.ParseToInt <double>(out num3))
{
this.PrintOptions.double_4 = num3;
}
}
else if (str == "Footer")
{
double num;
XmlReaderAttributeItem item = xmlReader_0.GetSingleAttribute("Margin", true);
if ((item != null) && item.Value.ParseToInt <double>(out num))
{
this.PrintOptions.double_5 = num;
}
}
else if (str == "PageMargins")
{
foreach (XmlReaderAttributeItem item2 in xmlReader_0.GetAttributes())
{
double num2;
string str2;
if (item2.Value.ParseToInt <double>(out num2) && ((str2 = item2.LocalName) != null))
{
if (str2 == "Bottom")
{
this.PrintOptions.double_3 = num2;
}
else if (str2 == "Left")
{
this.PrintOptions.double_0 = num2;
}
else if (!(str2 == "Right"))
{
if (str2 == "Top")
{
this.PrintOptions.double_2 = num2;
}
}
else
{
this.PrintOptions.double_1 = num2;
}
}
}
}
}
}
}
}
private void ImportPageSetup(XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
while (reader.Read() && !(reader.Name == "PageSetup" && reader.NodeType == XmlNodeType.EndElement))
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Layout":
{
XmlReaderAttributeItem xa = reader.GetSingleAttribute("Orientation", true);
if (xa != null)
{
PrintOptions.Orientation = ObjectExtensions.ParseEnum <PageOrientation>(xa.Value);
}
break;
}
case "Header":
{
XmlReaderAttributeItem xa = reader.GetSingleAttribute("Margin", true);
if (xa != null)
{
double d;
if (xa.Value.ParseToInt(out d))
{
PrintOptions.HeaderMargin = d;
}
}
break;
}
case "Footer":
{
XmlReaderAttributeItem xa = reader.GetSingleAttribute("Margin", true);
if (xa != null)
{
double d;
if (xa.Value.ParseToInt(out d))
{
PrintOptions.FooterMargin = d;
}
}
break;
}
case "PageMargins":
{
foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
{
double d;
if (xa.Value.ParseToInt(out d))
{
switch (xa.LocalName)
{
case "Bottom":
PrintOptions.BottomMargin = d;
break;
case "Left":
PrintOptions.LeftMargin = d;
break;
case "Right":
PrintOptions.RightMargin = d;
break;
case "Top":
PrintOptions.TopMargin = d;
break;
}
}
}
break;
}
}
}
}
}
private void method_11(XmlReader xmlReader_0, Row row_0)
{
bool isEmptyElement = xmlReader_0.IsEmptyElement;
int count = row_0.list_0.Count;
int num2 = 0;
int num3 = 0;
XmlStyle style = null;
string str = "";
string str2 = "";
foreach (XmlReaderAttributeItem item in xmlReader_0.GetAttributes())
{
if ((item.LocalName == "Index") && item.HasValue)
{
item.Value.ParseToInt <int>(out count);
count--;
}
if ((item.LocalName == "StyleID") && item.HasValue)
{
style = this.excelXmlWorkbook_0.method_6(item.Value);
}
if ((item.LocalName == "HRef") && item.HasValue)
{
str2 = item.Value;
}
if ((item.LocalName == "Formula") && item.HasValue)
{
str = item.Value;
}
if ((item.LocalName == "MergeAcross") && item.HasValue)
{
item.Value.ParseToInt <int>(out num3);
}
if ((item.LocalName == "MergeDown") && item.HasValue)
{
item.Value.ParseToInt <int>(out num2);
}
}
Cell cell = this.method_12(count, row_0.int_0);
if (style != null)
{
cell.Style = style;
}
if (!str2.IsNullOrEmpty())
{
cell.HRef = str2;
}
if (!str.IsNullOrEmpty())
{
Class129.smethod_3(cell, str);
}
else if (!isEmptyElement)
{
if ((num2 > 0) || (num3 > 0))
{
cell.bool_0 = true;
Aisino.Framework.Plugin.Core.ExcelXml.Range range = new Aisino.Framework.Plugin.Core.ExcelXml.Range(cell, this.method_12(count + num3, row_0.int_0 + num2));
this.list_2.Add(range);
cell.ColumnSpan = range.ColumnCount;
cell.RowSpan = range.RowCount;
}
while (xmlReader_0.Read())
{
if ((xmlReader_0.Name == "Cell") && (xmlReader_0.NodeType == XmlNodeType.EndElement))
{
break;
}
if (xmlReader_0.NodeType == XmlNodeType.Element)
{
if (xmlReader_0.Name == "Data")
{
smethod_2(xmlReader_0, cell);
}
else if (xmlReader_0.Name == "Comment")
{
smethod_3(xmlReader_0, cell);
}
}
}
}
}
private void ImportTable(XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
int column = 0;
while (reader.Read() && !(reader.Name == "Table" && reader.NodeType == XmlNodeType.EndElement))
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Column":
{
double width = 0;
bool hidden = false;
int span = 1;
XmlStyle style = null;
foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
{
if (xa.LocalName == "Width" && xa.HasValue)
{
double d;
if (xa.Value.ParseToInt(out d))
{
width = d;
}
}
if (xa.LocalName == "Hidden" && xa.HasValue)
{
hidden = xa.Value == "1";
}
if (xa.LocalName == "Index" && xa.HasValue)
{
xa.Value.ParseToInt(out column);
}
if (xa.LocalName == "Span" && xa.HasValue)
{
xa.Value.ParseToInt(out span);
}
if (xa.LocalName == "StyleID" && xa.HasValue)
{
style = ParentBook.GetStyleByID(xa.Value);
}
}
for (int i = 1; i <= span; i++)
{
Columns(column).Width = width;
Columns(column).Hidden = hidden;
if (style != null)
{
Columns(column).Style = style;
}
column++;
}
break;
}
case "Row":
{
ImportRow(reader);
break;
}
}
}
}
}
internal static void ImportNamedRanges(XmlReader reader, ExcelXmlWorkbook book, Worksheet ws)
{
if (!reader.IsEmptyElement)
{
while (reader.Read() && !(reader.Name == "Names" && reader.NodeType == XmlNodeType.EndElement))
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name == "NamedRange")
{
Range range = null;
string name = "";
foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
{
if (xa.LocalName == "Name" && xa.HasValue)
name = xa.Value;
if (xa.LocalName == "RefersTo" && xa.HasValue)
range = new Range(xa.Value);
}
NamedRange nr = new NamedRange(range, name, ws);
book.NamedRanges.Add(nr);
}
}
}
}
}
