| /******************************************************************************* | |
| * You may amend and distribute as you like, but don't remove this header! | |
| * | |
| * EPPlus provides server-side generation of Excel 2007/2010 spreadsheets. | |
| * See http://www.codeplex.com/EPPlus for details. | |
| * | |
| * Copyright (C) 2011 Jan Källman | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
| * See the GNU Lesser General Public License for more details. | |
| * | |
| * The GNU Lesser General Public License can be viewed at http://www.opensource.org/licenses/lgpl-license.php | |
| * If you unfamiliar with this license or have questions about it, here is an http://www.gnu.org/licenses/gpl-faq.html | |
| * | |
| * All code and executables are provided "as is" with no warranty either express or implied. | |
| * The author accepts no liability for any damage or loss of business that this product may cause. | |
| * | |
| * Code change notes: | |
| * | |
| * Author Change Date | |
| * ****************************************************************************** | |
| * Jan Källman Initial Release 2009-10-01 | |
| * Jan Källman License changed GPL-->LGPL 2011-12-16 | |
| *******************************************************************************/ | |
| using System; | |
| using System.Collections.Generic; | |
| using System.Globalization; | |
| using System.Text; | |
| using System.Xml; | |
| using System.Drawing; | |
| namespace OfficeOpenXml.Style.XmlAccess | |
| { | |
| /// <summary> | |
| /// Xml access class xfs records. This is the top level style object. | |
| /// </summary> | |
| public sealed class ExcelXfs : StyleXmlHelper | |
| { | |
| ExcelStyles _styles; | |
| internal ExcelXfs(XmlNamespaceManager nameSpaceManager, ExcelStyles styles) : base(nameSpaceManager) | |
| { | |
| _styles = styles; | |
| isBuildIn = false; | |
| } | |
| internal ExcelXfs(XmlNamespaceManager nsm, XmlNode topNode, ExcelStyles styles) : | |
| base(nsm, topNode) | |
| { | |
| _styles = styles; | |
| _xfID = GetXmlNodeInt("@xfId"); | |
| if (_xfID == 0) isBuildIn = true; //Normal taggen | |
| _numFmtId = GetXmlNodeInt("@numFmtId"); | |
| _fontId = GetXmlNodeInt("@fontId"); | |
| _fillId = GetXmlNodeInt("@fillId"); | |
| _borderId = GetXmlNodeInt("@borderId"); | |
| _readingOrder = GetReadingOrder(GetXmlNodeString(readingOrderPath)); | |
| _indent = GetXmlNodeInt(indentPath); | |
| _shrinkToFit = GetXmlNodeString(shrinkToFitPath) == "1" ? true : false; | |
| _verticalAlignment = GetVerticalAlign(GetXmlNodeString(verticalAlignPath)); | |
| _horizontalAlignment = GetHorizontalAlign(GetXmlNodeString(horizontalAlignPath)); | |
| _wrapText = GetXmlNodeBool(wrapTextPath); | |
| _textRotation = GetXmlNodeInt(textRotationPath); | |
| _hidden = GetXmlNodeBool(hiddenPath); | |
| _locked = GetXmlNodeBool(lockedPath,true); | |
| } | |
| private ExcelReadingOrder GetReadingOrder(string value) | |
| { | |
| switch(value) | |
| { | |
| case "1": | |
| return ExcelReadingOrder.LeftToRight; | |
| case "2": | |
| return ExcelReadingOrder.RightToLeft; | |
| default: | |
| return ExcelReadingOrder.ContextDependent; | |
| } | |
| } | |
| private ExcelHorizontalAlignment GetHorizontalAlign(string align) | |
| { | |
| if (align == "") return ExcelHorizontalAlignment.General; | |
| align = align.Substring(0, 1).ToUpper(CultureInfo.InvariantCulture) + align.Substring(1, align.Length - 1); | |
| try | |
| { | |
| return (ExcelHorizontalAlignment)Enum.Parse(typeof(ExcelHorizontalAlignment), align); | |
| } | |
| catch | |
| { | |
| return ExcelHorizontalAlignment.General; | |
| } | |
| } | |
| private ExcelVerticalAlignment GetVerticalAlign(string align) | |
| { | |
| if (align == "") return ExcelVerticalAlignment.Bottom; | |
| align = align.Substring(0, 1).ToUpper(CultureInfo.InvariantCulture) + align.Substring(1, align.Length - 1); | |
| try | |
| { | |
| return (ExcelVerticalAlignment)Enum.Parse(typeof(ExcelVerticalAlignment), align); | |
| } | |
| catch | |
| { | |
| return ExcelVerticalAlignment.Bottom; | |
| } | |
| } | |
| internal void Xf_ChangedEvent(object sender, EventArgs e) | |
| { | |
| //if (_cell != null) | |
| //{ | |
| // if (!Styles.ChangedCells.ContainsKey(_cell.Id)) | |
| // { | |
| // //_cell.Style = ""; | |
| // _cell.SetNewStyleID(int.MinValue.ToString()); | |
| // Styles.ChangedCells.Add(_cell.Id, _cell); | |
| // } | |
| //} | |
| } | |
| int _xfID; | |
| /// <summary> | |
| /// Style index | |
| /// </summary> | |
| public int XfId | |
| { | |
| get | |
| { | |
| return _xfID; | |
| } | |
| set | |
| { | |
| _xfID = value; | |
| } | |
| } | |
| #region Internal Properties | |
| int _numFmtId; | |
| internal int NumberFormatId | |
| { | |
| get | |
| { | |
| return _numFmtId; | |
| } | |
| set | |
| { | |
| _numFmtId = value; | |
| ApplyNumberFormat = (value>0); | |
| } | |
| } | |
| int _fontId; | |
| internal int FontId | |
| { | |
| get | |
| { | |
| return _fontId; | |
| } | |
| set | |
| { | |
| _fontId = value; | |
| } | |
| } | |
| int _fillId; | |
| internal int FillId | |
| { | |
| get | |
| { | |
| return _fillId; | |
| } | |
| set | |
| { | |
| _fillId = value; | |
| } | |
| } | |
| int _borderId; | |
| internal int BorderId | |
| { | |
| get | |
| { | |
| return _borderId; | |
| } | |
| set | |
| { | |
| _borderId = value; | |
| } | |
| } | |
| private bool isBuildIn | |
| { | |
| get; | |
| set; | |
| } | |
| internal bool ApplyNumberFormat | |
| { | |
| get; | |
| set; | |
| } | |
| internal bool ApplyFont | |
| { | |
| get; | |
| set; | |
| } | |
| internal bool ApplyFill | |
| { | |
| get; | |
| set; | |
| } | |
| internal bool ApplyBorder | |
| { | |
| get; | |
| set; | |
| } | |
| internal bool ApplyAlignment | |
| { | |
| get; | |
| set; | |
| } | |
| internal bool ApplyProtection | |
| { | |
| get; | |
| set; | |
| } | |
| #endregion | |
| #region Public Properties | |
| public ExcelStyles Styles { get; private set; } | |
| /// <summary> | |
| /// Numberformat properties | |
| /// </summary> | |
| public ExcelNumberFormatXml Numberformat | |
| { | |
| get | |
| { | |
| return _styles.NumberFormats[_numFmtId < 0 ? 0 : _numFmtId]; | |
| } | |
| } | |
| /// <summary> | |
| /// Font properties | |
| /// </summary> | |
| public ExcelFontXml Font | |
| { | |
| get | |
| { | |
| return _styles.Fonts[_fontId < 0 ? 0 : _fontId]; | |
| } | |
| } | |
| /// <summary> | |
| /// Fill properties | |
| /// </summary> | |
| public ExcelFillXml Fill | |
| { | |
| get | |
| { | |
| return _styles.Fills[_fillId < 0 ? 0 : _fillId]; | |
| } | |
| } | |
| /// <summary> | |
| /// Border style properties | |
| /// </summary> | |
| public ExcelBorderXml Border | |
| { | |
| get | |
| { | |
| return _styles.Borders[_borderId < 0 ? 0 : _borderId]; | |
| } | |
| } | |
| const string horizontalAlignPath = "d:alignment/@horizontal"; | |
| ExcelHorizontalAlignment _horizontalAlignment = ExcelHorizontalAlignment.General; | |
| /// <summary> | |
| /// Horizontal alignment | |
| /// </summary> | |
| public ExcelHorizontalAlignment HorizontalAlignment | |
| { | |
| get | |
| { | |
| return _horizontalAlignment; | |
| } | |
| set | |
| { | |
| _horizontalAlignment = value; | |
| } | |
| } | |
| const string verticalAlignPath = "d:alignment/@vertical"; | |
| ExcelVerticalAlignment _verticalAlignment=ExcelVerticalAlignment.Bottom; | |
| /// <summary> | |
| /// Vertical alignment | |
| /// </summary> | |
| public ExcelVerticalAlignment VerticalAlignment | |
| { | |
| get | |
| { | |
| return _verticalAlignment; | |
| } | |
| set | |
| { | |
| _verticalAlignment = value; | |
| } | |
| } | |
| const string wrapTextPath = "d:alignment/@wrapText"; | |
| bool _wrapText=false; | |
| /// <summary> | |
| /// Wraped text | |
| /// </summary> | |
| public bool WrapText | |
| { | |
| get | |
| { | |
| return _wrapText; | |
| } | |
| set | |
| { | |
| _wrapText = value; | |
| } | |
| } | |
| string textRotationPath = "d:alignment/@textRotation"; | |
| int _textRotation = 0; | |
| /// <summary> | |
| /// Text rotation angle | |
| /// </summary> | |
| public int TextRotation | |
| { | |
| get | |
| { | |
| return (_textRotation == int.MinValue ? 0 : _textRotation); | |
| } | |
| set | |
| { | |
| _textRotation = value; | |
| } | |
| } | |
| const string lockedPath = "d:protection/@locked"; | |
| bool _locked = true; | |
| /// <summary> | |
| /// Locked when sheet is protected | |
| /// </summary> | |
| public bool Locked | |
| { | |
| get | |
| { | |
| return _locked; | |
| } | |
| set | |
| { | |
| _locked = value; | |
| } | |
| } | |
| const string hiddenPath = "d:protection/@hidden"; | |
| bool _hidden = false; | |
| /// <summary> | |
| /// Hide formulas when sheet is protected | |
| /// </summary> | |
| public bool Hidden | |
| { | |
| get | |
| { | |
| return _hidden; | |
| } | |
| set | |
| { | |
| _hidden = value; | |
| } | |
| } | |
| const string readingOrderPath = "d:alignment/@readingOrder"; | |
| ExcelReadingOrder _readingOrder = ExcelReadingOrder.ContextDependent; | |
| /// <summary> | |
| /// Readingorder | |
| /// </summary> | |
| public ExcelReadingOrder ReadingOrder | |
| { | |
| get | |
| { | |
| return _readingOrder; | |
| } | |
| set | |
| { | |
| _readingOrder = value; | |
| } | |
| } | |
| const string shrinkToFitPath = "d:alignment/@shrinkToFit"; | |
| bool _shrinkToFit = false; | |
| /// <summary> | |
| /// Shrink to fit | |
| /// </summary> | |
| public bool ShrinkToFit | |
| { | |
| get | |
| { | |
| return _shrinkToFit; | |
| } | |
| set | |
| { | |
| _shrinkToFit = value; | |
| } | |
| } | |
| const string indentPath = "d:alignment/@indent"; | |
| int _indent = 0; | |
| /// <summary> | |
| /// Indentation | |
| /// </summary> | |
| public int Indent | |
| { | |
| get | |
| { | |
| return (_indent == int.MinValue ? 0 : _indent); | |
| } | |
| set | |
| { | |
| _indent=value; | |
| } | |
| } | |
| #endregion | |
| internal void RegisterEvent(ExcelXfs xf) | |
| { | |
| // RegisterEvent(xf, xf.Xf_ChangedEvent); | |
| } | |
| internal override string Id | |
| { | |
| get | |
| { | |
| return XfId + "|" + NumberFormatId.ToString() + "|" + FontId.ToString() + "|" + FillId.ToString() + "|" + BorderId.ToString() + VerticalAlignment.ToString() + "|" + HorizontalAlignment.ToString() + "|" + WrapText.ToString() + "|" + ReadingOrder.ToString() + "|" + isBuildIn.ToString() + TextRotation.ToString() + Locked.ToString() + Hidden.ToString() + ShrinkToFit.ToString() + Indent.ToString(); | |
| //return Numberformat.Id + "|" + Font.Id + "|" + Fill.Id + "|" + Border.Id + VerticalAlignment.ToString() + "|" + HorizontalAlignment.ToString() + "|" + WrapText.ToString() + "|" + ReadingOrder.ToString(); | |
| } | |
| } | |
| internal ExcelXfs Copy() | |
| { | |
| return Copy(_styles); | |
| } | |
| internal ExcelXfs Copy(ExcelStyles styles) | |
| { | |
| ExcelXfs newXF = new ExcelXfs(NameSpaceManager, styles); | |
| newXF.NumberFormatId = _numFmtId; | |
| newXF.FontId = _fontId; | |
| newXF.FillId = _fillId; | |
| newXF.BorderId = _borderId; | |
| newXF.XfId = _xfID; | |
| newXF.ReadingOrder = _readingOrder; | |
| newXF.HorizontalAlignment = _horizontalAlignment; | |
| newXF.VerticalAlignment = _verticalAlignment; | |
| newXF.WrapText = _wrapText; | |
| newXF.ShrinkToFit = _shrinkToFit; | |
| newXF.Indent = _indent; | |
| newXF.TextRotation = _textRotation; | |
| newXF.Locked = _locked; | |
| newXF.Hidden = _hidden; | |
| return newXF; | |
| } | |
| internal int GetNewID(ExcelStyleCollection<ExcelXfs> xfsCol, StyleBase styleObject, eStyleClass styleClass, eStyleProperty styleProperty, object value) | |
| { | |
| ExcelXfs newXfs = this.Copy(); | |
| switch(styleClass) | |
| { | |
| case eStyleClass.Numberformat: | |
| newXfs.NumberFormatId = GetIdNumberFormat(styleProperty, value); | |
| styleObject.SetIndex(newXfs.NumberFormatId); | |
| break; | |
| case eStyleClass.Font: | |
| { | |
| newXfs.FontId = GetIdFont(styleProperty, value); | |
| styleObject.SetIndex(newXfs.FontId); | |
| break; | |
| } | |
| case eStyleClass.Fill: | |
| case eStyleClass.FillBackgroundColor: | |
| case eStyleClass.FillPatternColor: | |
| newXfs.FillId = GetIdFill(styleClass, styleProperty, value); | |
| styleObject.SetIndex(newXfs.FillId); | |
| break; | |
| case eStyleClass.GradientFill: | |
| case eStyleClass.FillGradientColor1: | |
| case eStyleClass.FillGradientColor2: | |
| newXfs.FillId = GetIdGradientFill(styleClass, styleProperty, value); | |
| styleObject.SetIndex(newXfs.FillId); | |
| break; | |
| case eStyleClass.Border: | |
| case eStyleClass.BorderBottom: | |
| case eStyleClass.BorderDiagonal: | |
| case eStyleClass.BorderLeft: | |
| case eStyleClass.BorderRight: | |
| case eStyleClass.BorderTop: | |
| newXfs.BorderId = GetIdBorder(styleClass, styleProperty, value); | |
| styleObject.SetIndex(newXfs.BorderId); | |
| break; | |
| case eStyleClass.Style: | |
| switch(styleProperty) | |
| { | |
| case eStyleProperty.XfId: | |
| newXfs.XfId = (int)value; | |
| break; | |
| case eStyleProperty.HorizontalAlign: | |
| newXfs.HorizontalAlignment=(ExcelHorizontalAlignment)value; | |
| break; | |
| case eStyleProperty.VerticalAlign: | |
| newXfs.VerticalAlignment = (ExcelVerticalAlignment)value; | |
| break; | |
| case eStyleProperty.WrapText: | |
| newXfs.WrapText = (bool)value; | |
| break; | |
| case eStyleProperty.ReadingOrder: | |
| newXfs.ReadingOrder = (ExcelReadingOrder)value; | |
| break; | |
| case eStyleProperty.ShrinkToFit: | |
| newXfs.ShrinkToFit=(bool)value; | |
| break; | |
| case eStyleProperty.Indent: | |
| newXfs.Indent = (int)value; | |
| break; | |
| case eStyleProperty.TextRotation: | |
| newXfs.TextRotation = (int)value; | |
| break; | |
| case eStyleProperty.Locked: | |
| newXfs.Locked = (bool)value; | |
| break; | |
| case eStyleProperty.Hidden: | |
| newXfs.Hidden = (bool)value; | |
| break; | |
| default: | |
| throw (new Exception("Invalid property for class style.")); | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| int id = xfsCol.FindIndexByID(newXfs.Id); | |
| if (id < 0) | |
| { | |
| return xfsCol.Add(newXfs.Id, newXfs); | |
| } | |
| return id; | |
| } | |
| private int GetIdBorder(eStyleClass styleClass, eStyleProperty styleProperty, object value) | |
| { | |
| ExcelBorderXml border = Border.Copy(); | |
| switch (styleClass) | |
| { | |
| case eStyleClass.BorderBottom: | |
| SetBorderItem(border.Bottom, styleProperty, value); | |
| break; | |
| case eStyleClass.BorderDiagonal: | |
| SetBorderItem(border.Diagonal, styleProperty, value); | |
| break; | |
| case eStyleClass.BorderLeft: | |
| SetBorderItem(border.Left, styleProperty, value); | |
| break; | |
| case eStyleClass.BorderRight: | |
| SetBorderItem(border.Right, styleProperty, value); | |
| break; | |
| case eStyleClass.BorderTop: | |
| SetBorderItem(border.Top, styleProperty, value); | |
| break; | |
| case eStyleClass.Border: | |
| if (styleProperty == eStyleProperty.BorderDiagonalUp) | |
| { | |
| border.DiagonalUp = (bool)value; | |
| } | |
| else if (styleProperty == eStyleProperty.BorderDiagonalDown) | |
| { | |
| border.DiagonalDown = (bool)value; | |
| } | |
| else | |
| { | |
| throw (new Exception("Invalid property for class Border.")); | |
| } | |
| break; | |
| default: | |
| throw (new Exception("Invalid class/property for class Border.")); | |
| } | |
| int subId; | |
| string id = border.Id; | |
| subId = _styles.Borders.FindIndexByID(id); | |
| if (subId == int.MinValue) | |
| { | |
| return _styles.Borders.Add(id, border); | |
| } | |
| return subId; | |
| } | |
| private void SetBorderItem(ExcelBorderItemXml excelBorderItem, eStyleProperty styleProperty, object value) | |
| { | |
| if(styleProperty==eStyleProperty.Style) | |
| { | |
| excelBorderItem.Style = (ExcelBorderStyle)value; | |
| } | |
| else if (styleProperty == eStyleProperty.Color || styleProperty== eStyleProperty.Tint || styleProperty==eStyleProperty.IndexedColor) | |
| { | |
| if (excelBorderItem.Style == ExcelBorderStyle.None) | |
| { | |
| throw(new Exception("Can't set bordercolor when style is not set.")); | |
| } | |
| excelBorderItem.Color.Rgb = value.ToString(); | |
| } | |
| } | |
| private int GetIdFill(eStyleClass styleClass, eStyleProperty styleProperty, object value) | |
| { | |
| ExcelFillXml fill = Fill.Copy(); | |
| switch (styleProperty) | |
| { | |
| case eStyleProperty.PatternType: | |
| if (fill is ExcelGradientFillXml) | |
| { | |
| fill = new ExcelFillXml(NameSpaceManager); | |
| } | |
| fill.PatternType = (ExcelFillStyle)value; | |
| break; | |
| case eStyleProperty.Color: | |
| case eStyleProperty.Tint: | |
| case eStyleProperty.IndexedColor: | |
| case eStyleProperty.AutoColor: | |
| if (fill is ExcelGradientFillXml) | |
| { | |
| fill = new ExcelFillXml(NameSpaceManager); | |
| } | |
| if (fill.PatternType == ExcelFillStyle.None) | |
| { | |
| throw (new ArgumentException("Can't set color when patterntype is not set.")); | |
| } | |
| ExcelColorXml destColor; | |
| if (styleClass==eStyleClass.FillPatternColor) | |
| { | |
| destColor = fill.PatternColor; | |
| } | |
| else | |
| { | |
| destColor = fill.BackgroundColor; | |
| } | |
| if (styleProperty == eStyleProperty.Color) | |
| { | |
| destColor.Rgb = value.ToString(); | |
| } | |
| else if (styleProperty == eStyleProperty.Tint) | |
| { | |
| destColor.Tint = (decimal)value; | |
| } | |
| else if (styleProperty == eStyleProperty.IndexedColor) | |
| { | |
| destColor.Indexed = (int)value; | |
| } | |
| else | |
| { | |
| destColor.Auto = (bool)value; | |
| } | |
| break; | |
| default: | |
| throw (new ArgumentException("Invalid class/property for class Fill.")); | |
| } | |
| int subId; | |
| string id = fill.Id; | |
| subId = _styles.Fills.FindIndexByID(id); | |
| if (subId == int.MinValue) | |
| { | |
| return _styles.Fills.Add(id, fill); | |
| } | |
| return subId; | |
| } | |
| private int GetIdGradientFill(eStyleClass styleClass, eStyleProperty styleProperty, object value) | |
| { | |
| ExcelGradientFillXml fill; | |
| if(Fill is ExcelGradientFillXml) | |
| { | |
| fill = (ExcelGradientFillXml)Fill.Copy(); | |
| } | |
| else | |
| { | |
| fill = new ExcelGradientFillXml(Fill.NameSpaceManager); | |
| fill.GradientColor1.SetColor(Color.White); | |
| fill.GradientColor2.SetColor(Color.FromArgb(79,129,189)); | |
| fill.Type=ExcelFillGradientType.Linear; | |
| fill.Degree=90; | |
| fill.Top = double.NaN; | |
| fill.Bottom = double.NaN; | |
| fill.Left = double.NaN; | |
| fill.Right = double.NaN; | |
| } | |
| switch (styleProperty) | |
| { | |
| case eStyleProperty.GradientType: | |
| fill.Type = (ExcelFillGradientType)value; | |
| break; | |
| case eStyleProperty.GradientDegree: | |
| fill.Degree = (double)value; | |
| break; | |
| case eStyleProperty.GradientTop: | |
| fill.Top = (double)value; | |
| break; | |
| case eStyleProperty.GradientBottom: | |
| fill.Bottom = (double)value; | |
| break; | |
| case eStyleProperty.GradientLeft: | |
| fill.Left = (double)value; | |
| break; | |
| case eStyleProperty.GradientRight: | |
| fill.Right = (double)value; | |
| break; | |
| case eStyleProperty.Color: | |
| case eStyleProperty.Tint: | |
| case eStyleProperty.IndexedColor: | |
| case eStyleProperty.AutoColor: | |
| ExcelColorXml destColor; | |
| if (styleClass == eStyleClass.FillGradientColor1) | |
| { | |
| destColor = fill.GradientColor1; | |
| } | |
| else | |
| { | |
| destColor = fill.GradientColor2; | |
| } | |
| if (styleProperty == eStyleProperty.Color) | |
| { | |
| destColor.Rgb = value.ToString(); | |
| } | |
| else if (styleProperty == eStyleProperty.Tint) | |
| { | |
| destColor.Tint = (decimal)value; | |
| } | |
| else if (styleProperty == eStyleProperty.IndexedColor) | |
| { | |
| destColor.Indexed = (int)value; | |
| } | |
| else | |
| { | |
| destColor.Auto = (bool)value; | |
| } | |
| break; | |
| default: | |
| throw (new ArgumentException("Invalid class/property for class Fill.")); | |
| } | |
| int subId; | |
| string id = fill.Id; | |
| subId = _styles.Fills.FindIndexByID(id); | |
| if (subId == int.MinValue) | |
| { | |
| return _styles.Fills.Add(id, fill); | |
| } | |
| return subId; | |
| } | |
| private int GetIdNumberFormat(eStyleProperty styleProperty, object value) | |
| { | |
| if (styleProperty == eStyleProperty.Format) | |
| { | |
| ExcelNumberFormatXml item=null; | |
| if (!_styles.NumberFormats.FindByID(value.ToString(), ref item)) | |
| { | |
| item = new ExcelNumberFormatXml(NameSpaceManager) { Format = value.ToString(), NumFmtId = _styles.NumberFormats.NextId++ }; | |
| _styles.NumberFormats.Add(value.ToString(), item); | |
| } | |
| return item.NumFmtId; | |
| } | |
| else | |
| { | |
| throw (new Exception("Invalid property for class Numberformat")); | |
| } | |
| } | |
| private int GetIdFont(eStyleProperty styleProperty, object value) | |
| { | |
| ExcelFontXml fnt = Font.Copy(); | |
| switch (styleProperty) | |
| { | |
| case eStyleProperty.Name: | |
| fnt.Name = value.ToString(); | |
| break; | |
| case eStyleProperty.Size: | |
| fnt.Size = (float)value; | |
| break; | |
| case eStyleProperty.Family: | |
| fnt.Family = (int)value; | |
| break; | |
| case eStyleProperty.Bold: | |
| fnt.Bold = (bool)value; | |
| break; | |
| case eStyleProperty.Italic: | |
| fnt.Italic = (bool)value; | |
| break; | |
| case eStyleProperty.Strike: | |
| fnt.Strike = (bool)value; | |
| break; | |
| case eStyleProperty.UnderlineType: | |
| fnt.UnderLineType = (ExcelUnderLineType)value; | |
| break; | |
| case eStyleProperty.Color: | |
| fnt.Color.Rgb=value.ToString(); | |
| break; | |
| case eStyleProperty.VerticalAlign: | |
| fnt.VerticalAlign = ((ExcelVerticalAlignmentFont)value) == ExcelVerticalAlignmentFont.None ? "" : value.ToString().ToLower(CultureInfo.InvariantCulture); | |
| break; | |
| default: | |
| throw (new Exception("Invalid property for class Font")); | |
| } | |
| int subId; | |
| string id = fnt.Id; | |
| subId = _styles.Fonts.FindIndexByID(id); | |
| if (subId == int.MinValue) | |
| { | |
| return _styles.Fonts.Add(id,fnt); | |
| } | |
| return subId; | |
| } | |
| internal override XmlNode CreateXmlNode(XmlNode topNode) | |
| { | |
| return CreateXmlNode(topNode, false); | |
| } | |
| internal XmlNode CreateXmlNode(XmlNode topNode, bool isCellStyleXsf) | |
| { | |
| TopNode = topNode; | |
| var doSetXfId = (!isCellStyleXsf && _xfID > int.MinValue && _styles.CellStyleXfs.Count > 0 && _styles.CellStyleXfs[_xfID].newID > int.MinValue); | |
| if (_numFmtId > 0) | |
| { | |
| SetXmlNodeString("@numFmtId", _numFmtId.ToString()); | |
| if(doSetXfId) SetXmlNodeString("@applyNumberFormat", "1"); | |
| } | |
| if (_fontId >= 0) | |
| { | |
| SetXmlNodeString("@fontId", _styles.Fonts[_fontId].newID.ToString()); | |
| if (doSetXfId) SetXmlNodeString("@applyFont", "1"); | |
| } | |
| if (_fillId >= 0) | |
| { | |
| SetXmlNodeString("@fillId", _styles.Fills[_fillId].newID.ToString()); | |
| if (doSetXfId) SetXmlNodeString("@applyFill", "1"); | |
| } | |
| if (_borderId >= 0) | |
| { | |
| SetXmlNodeString("@borderId", _styles.Borders[_borderId].newID.ToString()); | |
| if (doSetXfId) SetXmlNodeString("@applyBorder", "1"); | |
| } | |
| if(_horizontalAlignment != ExcelHorizontalAlignment.General) this.SetXmlNodeString(horizontalAlignPath, SetAlignString(_horizontalAlignment)); | |
| if (doSetXfId) | |
| { | |
| SetXmlNodeString("@xfId", _styles.CellStyleXfs[_xfID].newID.ToString()); | |
| } | |
| if (_verticalAlignment != ExcelVerticalAlignment.Bottom) this.SetXmlNodeString(verticalAlignPath, SetAlignString(_verticalAlignment)); | |
| if(_wrapText) this.SetXmlNodeString(wrapTextPath, "1"); | |
| if(_readingOrder!=ExcelReadingOrder.ContextDependent) this.SetXmlNodeString(readingOrderPath, ((int)_readingOrder).ToString()); | |
| if (_shrinkToFit) this.SetXmlNodeString(shrinkToFitPath, "1"); | |
| if (_indent > 0) SetXmlNodeString(indentPath, _indent.ToString()); | |
| if (_textRotation > 0) this.SetXmlNodeString(textRotationPath, _textRotation.ToString()); | |
| if (!_locked) this.SetXmlNodeString(lockedPath, "0"); | |
| if (_hidden) this.SetXmlNodeString(hiddenPath, "1"); | |
| return TopNode; | |
| } | |
| private string SetAlignString(Enum align) | |
| { | |
| string newName = Enum.GetName(align.GetType(), align); | |
| return newName.Substring(0, 1).ToLower(CultureInfo.InvariantCulture) + newName.Substring(1, newName.Length - 1); | |
| } | |
| } | |
| } |