using System;
using System.Diagnostics;
using System.Globalization;
using CPF.Drawing;
using CPF.ReoGrid.Common;
using CPF.ReoGrid.Core;
using CPF.ReoGrid.Drawing.Text;
using CPF.ReoGrid.Graphics;
using CPF.ReoGrid.XML;

namespace CPF.ReoGrid.Utility
{
	public sealed class StyleUtility
	{
		public static bool HasStyle(WorksheetRangeStyle style, PlainStyleFlag flag)
		{
			return (style.Flag & flag) == flag;
		}

		internal static PlainStyleFlag CheckDistinctStyle(WorksheetRangeStyle style, WorksheetRangeStyle referStyle)
		{
			bool flag = style == null || style.Flag == PlainStyleFlag.None;
			PlainStyleFlag result;
			if (flag)
			{
				result = PlainStyleFlag.None;
			}
			else
			{
				bool flag2 = referStyle == null || referStyle.Flag == PlainStyleFlag.None;
				if (flag2)
				{
					result = PlainStyleFlag.None;
				}
				else
				{
					PlainStyleFlag plainStyleFlag = style.Flag;
					bool flag3 = StyleUtility.HasStyle(style, PlainStyleFlag.FillPatternColor) && style.FillPatternColor == referStyle.FillPatternColor;
					if (flag3)
					{
						plainStyleFlag &= (PlainStyleFlag)(-524289L);
					}
					bool flag4 = StyleUtility.HasStyle(style, PlainStyleFlag.FillPatternStyle) && style.FillPatternStyle == referStyle.FillPatternStyle;
					if (flag4)
					{
						plainStyleFlag &= (PlainStyleFlag)(-1048577L);
					}
					bool flag5 = StyleUtility.HasStyle(style, PlainStyleFlag.BackColor) && style.BackColor == referStyle.BackColor;
					if (flag5)
					{
						plainStyleFlag &= (PlainStyleFlag)(-129L);
					}
					bool flag6 = StyleUtility.HasStyle(style, PlainStyleFlag.TextColor) && style.TextColor == referStyle.TextColor;
					if (flag6)
					{
						plainStyleFlag &= (PlainStyleFlag)(-65L);
					}
					bool flag7 = StyleUtility.HasStyle(style, PlainStyleFlag.FontName) && style.FontName == referStyle.FontName;
					if (flag7)
					{
						plainStyleFlag &= (PlainStyleFlag)(-2L);
					}
					bool flag8 = StyleUtility.HasStyle(style, PlainStyleFlag.FontSize) && style.FontSize == referStyle.FontSize;
					if (flag8)
					{
						plainStyleFlag &= (PlainStyleFlag)(-3L);
					}
					bool flag9 = StyleUtility.HasStyle(style, PlainStyleFlag.FontStyleBold) && style.Bold == referStyle.Bold;
					if (flag9)
					{
						plainStyleFlag &= (PlainStyleFlag)(-5L);
					}
					bool flag10 = StyleUtility.HasStyle(style, PlainStyleFlag.FontStyleItalic) && style.Italic == referStyle.Italic;
					if (flag10)
					{
						plainStyleFlag &= (PlainStyleFlag)(-9L);
					}
					bool flag11 = StyleUtility.HasStyle(style, PlainStyleFlag.FontStyleStrikethrough) && style.Strikethrough == referStyle.Strikethrough;
					if (flag11)
					{
						plainStyleFlag &= (PlainStyleFlag)(-17L);
					}
					bool flag12 = StyleUtility.HasStyle(style, PlainStyleFlag.FontStyleUnderline) && style.Underline == referStyle.Underline;
					if (flag12)
					{
						plainStyleFlag &= (PlainStyleFlag)(-33L);
					}
					bool flag13 = StyleUtility.HasStyle(style, PlainStyleFlag.HorizontalAlign) && style.HAlign == referStyle.HAlign;
					if (flag13)
					{
						plainStyleFlag &= (PlainStyleFlag)(-8193L);
					}
					bool flag14 = StyleUtility.HasStyle(style, PlainStyleFlag.VerticalAlign) && style.VAlign == referStyle.VAlign;
					if (flag14)
					{
						plainStyleFlag &= (PlainStyleFlag)(-16385L);
					}
					bool flag15 = StyleUtility.HasStyle(style, PlainStyleFlag.TextWrap) && style.TextWrapMode == referStyle.TextWrapMode;
					if (flag15)
					{
						plainStyleFlag &= (PlainStyleFlag)(-2097153L);
					}
					bool flag16 = StyleUtility.HasStyle(style, PlainStyleFlag.Indent) && style.Indent == referStyle.Indent;
					if (flag16)
					{
						plainStyleFlag &= (PlainStyleFlag)(-4194305L);
					}
					bool flag17 = StyleUtility.HasStyle(style, PlainStyleFlag.Padding) && style.Padding == referStyle.Padding;
					if (flag17)
					{
						plainStyleFlag &= (PlainStyleFlag)(-8388609L);
					}
					bool flag18 = StyleUtility.HasStyle(style, PlainStyleFlag.RotationAngle) && style.RotationAngle == referStyle.RotationAngle;
					if (flag18)
					{
						plainStyleFlag &= (PlainStyleFlag)(-16777217L);
					}
					result = plainStyleFlag;
				}
			}
			return result;
		}

		internal static WorksheetRangeStyle DistinctStyle(WorksheetRangeStyle style, WorksheetRangeStyle referStyle)
		{
			bool flag = style == null || style.Flag == PlainStyleFlag.None;
			WorksheetRangeStyle result;
			if (flag)
			{
				result = null;
			}
			else
			{
				bool flag2 = referStyle == null || referStyle.Flag == PlainStyleFlag.None;
				if (flag2)
				{
					result = new WorksheetRangeStyle(style);
				}
				else
				{
					PlainStyleFlag plainStyleFlag = StyleUtility.CheckDistinctStyle(style, referStyle);
					bool flag3 = plainStyleFlag == PlainStyleFlag.None;
					if (flag3)
					{
						result = null;
					}
					else
					{
						WorksheetRangeStyle worksheetRangeStyle = new WorksheetRangeStyle();
						StyleUtility.CopyStyle(style, worksheetRangeStyle, plainStyleFlag);
						result = worksheetRangeStyle;
					}
				}
			}
			return result;
		}

		internal static WorksheetRangeStyle CheckAndRemoveCellStyle(Worksheet grid, Cell cell)
		{
			bool flag = cell.InnerStyle == null || cell.InnerStyle == null;
			WorksheetRangeStyle result;
			if (flag)
			{
				result = null;
			}
			else
			{
				bool flag2 = cell.StyleParentKind == StyleParentKind.Root || cell.StyleParentKind == StyleParentKind.Col || cell.StyleParentKind == StyleParentKind.Row;
				if (flag2)
				{
					result = null;
				}
				else
				{
					int internalRow = cell.InternalRow;
					int internalCol = cell.InternalCol;
					WorksheetRangeStyle innerStyle = cell.InnerStyle;
					StyleParentKind styleParentKind = StyleParentKind.Own;
					WorksheetRangeStyle referStyle = StyleUtility.FindCellParentStyle(grid, internalRow, internalCol, out styleParentKind);
					result = StyleUtility.DistinctStyle(innerStyle, referStyle);
				}
			}
			return result;
		}

		internal static void CopyStyle(WorksheetRangeStyle sourceStyle, WorksheetRangeStyle targetStyle)
		{
			StyleUtility.CopyStyle(sourceStyle, targetStyle, sourceStyle.Flag);
		}

		internal static void CopyStyle(WorksheetRangeStyle sourceStyle, WorksheetRangeStyle targetStyle, PlainStyleFlag flag)
		{
			bool flag2 = (flag & PlainStyleFlag.BackColor) == PlainStyleFlag.BackColor;
			if (flag2)
			{
				targetStyle.BackColor = sourceStyle.BackColor;
			}
			bool flag3 = (flag & PlainStyleFlag.FillPatternColor) == PlainStyleFlag.FillPatternColor;
			if (flag3)
			{
				targetStyle.FillPatternColor = sourceStyle.FillPatternColor;
			}
			bool flag4 = (flag & PlainStyleFlag.FillPatternStyle) == PlainStyleFlag.FillPatternStyle;
			if (flag4)
			{
				targetStyle.FillPatternStyle = sourceStyle.FillPatternStyle;
			}
			bool flag5 = (flag & PlainStyleFlag.TextColor) == PlainStyleFlag.TextColor;
			if (flag5)
			{
				targetStyle.TextColor = sourceStyle.TextColor;
			}
			bool flag6 = (flag & PlainStyleFlag.FontName) == PlainStyleFlag.FontName;
			if (flag6)
			{
				targetStyle.FontName = sourceStyle.FontName;
				Debug.Assert(!string.IsNullOrEmpty(targetStyle.FontName));
			}
			bool flag7 = (flag & PlainStyleFlag.FontSize) == PlainStyleFlag.FontSize;
			if (flag7)
			{
				targetStyle.FontSize = sourceStyle.FontSize;
			}
			bool flag8 = (flag & PlainStyleFlag.FontStyleBold) == PlainStyleFlag.FontStyleBold;
			if (flag8)
			{
				targetStyle.Bold = sourceStyle.Bold;
			}
			bool flag9 = (flag & PlainStyleFlag.FontStyleItalic) == PlainStyleFlag.FontStyleItalic;
			if (flag9)
			{
				targetStyle.Italic = sourceStyle.Italic;
			}
			bool flag10 = (flag & PlainStyleFlag.FontStyleStrikethrough) == PlainStyleFlag.FontStyleStrikethrough;
			if (flag10)
			{
				targetStyle.Strikethrough = sourceStyle.Strikethrough;
			}
			bool flag11 = (flag & PlainStyleFlag.FontStyleUnderline) == PlainStyleFlag.FontStyleUnderline;
			if (flag11)
			{
				targetStyle.Underline = sourceStyle.Underline;
			}
			bool flag12 = (flag & PlainStyleFlag.HorizontalAlign) == PlainStyleFlag.HorizontalAlign;
			if (flag12)
			{
				targetStyle.HAlign = sourceStyle.HAlign;
			}
			bool flag13 = (flag & PlainStyleFlag.VerticalAlign) == PlainStyleFlag.VerticalAlign;
			if (flag13)
			{
				targetStyle.VAlign = sourceStyle.VAlign;
			}
			bool flag14 = (flag & PlainStyleFlag.TextWrap) == PlainStyleFlag.TextWrap;
			if (flag14)
			{
				targetStyle.TextWrapMode = sourceStyle.TextWrapMode;
			}
			bool flag15 = (flag & PlainStyleFlag.Indent) == PlainStyleFlag.Indent;
			if (flag15)
			{
				targetStyle.Indent = sourceStyle.Indent;
			}
			bool flag16 = (flag & PlainStyleFlag.Padding) == PlainStyleFlag.Padding;
			if (flag16)
			{
				targetStyle.Padding = sourceStyle.Padding;
			}
			bool flag17 = (flag & PlainStyleFlag.RotationAngle) == PlainStyleFlag.RotationAngle;
			if (flag17)
			{
				targetStyle.RotationAngle = sourceStyle.RotationAngle;
			}
			targetStyle.Flag |= flag;
		}

		internal static WorksheetRangeStyle CreateMergedStyle(WorksheetRangeStyle style1, WorksheetRangeStyle style2)
		{
			WorksheetRangeStyle worksheetRangeStyle = new WorksheetRangeStyle
			{
				Flag = (style1.Flag | style2.Flag)
			};
			PlainStyleFlag flag = style1.Flag;
			PlainStyleFlag flag2 = style2.Flag;
			bool flag3 = (flag & PlainStyleFlag.BackColor) == PlainStyleFlag.BackColor;
			if (flag3)
			{
				worksheetRangeStyle.BackColor = style1.BackColor;
			}
			else
			{
				bool flag4 = (flag2 & PlainStyleFlag.BackColor) == PlainStyleFlag.BackColor;
				if (flag4)
				{
					worksheetRangeStyle.BackColor = style2.BackColor;
				}
			}
			bool flag5 = (flag & PlainStyleFlag.FillPatternColor) == PlainStyleFlag.FillPatternColor;
			if (flag5)
			{
				worksheetRangeStyle.FillPatternColor = style1.FillPatternColor;
			}
			else
			{
				bool flag6 = (flag2 & PlainStyleFlag.FillPatternColor) == PlainStyleFlag.FillPatternColor;
				if (flag6)
				{
					worksheetRangeStyle.FillPatternColor = style2.FillPatternColor;
				}
			}
			bool flag7 = (flag & PlainStyleFlag.FillPatternStyle) == PlainStyleFlag.FillPatternStyle;
			if (flag7)
			{
				worksheetRangeStyle.FillPatternStyle = style1.FillPatternStyle;
			}
			else
			{
				bool flag8 = (flag2 & PlainStyleFlag.FillPatternStyle) == PlainStyleFlag.FillPatternStyle;
				if (flag8)
				{
					worksheetRangeStyle.FillPatternStyle = style2.FillPatternStyle;
				}
			}
			bool flag9 = (flag & PlainStyleFlag.TextColor) == PlainStyleFlag.TextColor;
			if (flag9)
			{
				worksheetRangeStyle.TextColor = style1.TextColor;
			}
			else
			{
				bool flag10 = (flag2 & PlainStyleFlag.TextColor) == PlainStyleFlag.TextColor;
				if (flag10)
				{
					worksheetRangeStyle.TextColor = style2.TextColor;
				}
			}
			bool flag11 = (flag & PlainStyleFlag.FontName) == PlainStyleFlag.FontName;
			if (flag11)
			{
				worksheetRangeStyle.FontName = style1.FontName;
			}
			else
			{
				bool flag12 = (flag2 & PlainStyleFlag.FontName) == PlainStyleFlag.FontName;
				if (flag12)
				{
					worksheetRangeStyle.FontName = style2.FontName;
				}
			}
			bool flag13 = (flag & PlainStyleFlag.FontSize) == PlainStyleFlag.FontSize;
			if (flag13)
			{
				worksheetRangeStyle.FontSize = style1.FontSize;
			}
			else
			{
				bool flag14 = (flag2 & PlainStyleFlag.FontSize) == PlainStyleFlag.FontSize;
				if (flag14)
				{
					worksheetRangeStyle.FontSize = style2.FontSize;
				}
			}
			bool flag15 = (flag & PlainStyleFlag.FontStyleBold) == PlainStyleFlag.FontStyleBold;
			if (flag15)
			{
				worksheetRangeStyle.Bold = style1.Bold;
			}
			else
			{
				bool flag16 = (flag2 & PlainStyleFlag.FontStyleBold) == PlainStyleFlag.FontStyleBold;
				if (flag16)
				{
					worksheetRangeStyle.Bold = style2.Bold;
				}
			}
			bool flag17 = (flag & PlainStyleFlag.FontStyleItalic) == PlainStyleFlag.FontStyleItalic;
			if (flag17)
			{
				worksheetRangeStyle.Italic = style1.Italic;
			}
			else
			{
				bool flag18 = (flag2 & PlainStyleFlag.FontStyleItalic) == PlainStyleFlag.FontStyleItalic;
				if (flag18)
				{
					worksheetRangeStyle.Italic = style2.Italic;
				}
			}
			bool flag19 = (flag & PlainStyleFlag.FontStyleStrikethrough) == PlainStyleFlag.FontStyleStrikethrough;
			if (flag19)
			{
				worksheetRangeStyle.Strikethrough = style1.Strikethrough;
			}
			else
			{
				bool flag20 = (flag2 & PlainStyleFlag.FontStyleStrikethrough) == PlainStyleFlag.FontStyleStrikethrough;
				if (flag20)
				{
					worksheetRangeStyle.Strikethrough = style2.Strikethrough;
				}
			}
			bool flag21 = (flag & PlainStyleFlag.FontStyleUnderline) == PlainStyleFlag.FontStyleUnderline;
			if (flag21)
			{
				worksheetRangeStyle.Underline = style1.Underline;
			}
			else
			{
				bool flag22 = (flag2 & PlainStyleFlag.FontStyleUnderline) == PlainStyleFlag.FontStyleUnderline;
				if (flag22)
				{
					worksheetRangeStyle.Underline = style2.Underline;
				}
			}
			bool flag23 = (flag & PlainStyleFlag.HorizontalAlign) == PlainStyleFlag.HorizontalAlign;
			if (flag23)
			{
				worksheetRangeStyle.HAlign = style1.HAlign;
			}
			else
			{
				bool flag24 = (flag2 & PlainStyleFlag.HorizontalAlign) == PlainStyleFlag.HorizontalAlign;
				if (flag24)
				{
					worksheetRangeStyle.HAlign = style2.HAlign;
				}
			}
			bool flag25 = (flag & PlainStyleFlag.VerticalAlign) == PlainStyleFlag.VerticalAlign;
			if (flag25)
			{
				worksheetRangeStyle.VAlign = style1.VAlign;
			}
			else
			{
				bool flag26 = (flag2 & PlainStyleFlag.VerticalAlign) == PlainStyleFlag.VerticalAlign;
				if (flag26)
				{
					worksheetRangeStyle.VAlign = style2.VAlign;
				}
			}
			bool flag27 = (flag & PlainStyleFlag.TextWrap) == PlainStyleFlag.TextWrap;
			if (flag27)
			{
				worksheetRangeStyle.TextWrapMode = style1.TextWrapMode;
			}
			else
			{
				bool flag28 = (flag2 & PlainStyleFlag.TextWrap) == PlainStyleFlag.TextWrap;
				if (flag28)
				{
					worksheetRangeStyle.TextWrapMode = style2.TextWrapMode;
				}
			}
			bool flag29 = (flag & PlainStyleFlag.Indent) == PlainStyleFlag.Indent;
			if (flag29)
			{
				worksheetRangeStyle.Indent = style1.Indent;
			}
			else
			{
				bool flag30 = (flag2 & PlainStyleFlag.Indent) == PlainStyleFlag.Indent;
				if (flag30)
				{
					worksheetRangeStyle.Indent = style2.Indent;
				}
			}
			bool flag31 = (flag & PlainStyleFlag.Padding) == PlainStyleFlag.Padding;
			if (flag31)
			{
				worksheetRangeStyle.Padding = style1.Padding;
			}
			else
			{
				bool flag32 = (flag2 & PlainStyleFlag.Padding) == PlainStyleFlag.Padding;
				if (flag32)
				{
					worksheetRangeStyle.Padding = style2.Padding;
				}
			}
			bool flag33 = (flag & PlainStyleFlag.RotationAngle) == PlainStyleFlag.RotationAngle;
			if (flag33)
			{
				worksheetRangeStyle.RotationAngle = style1.RotationAngle;
			}
			else
			{
				bool flag34 = (flag2 & PlainStyleFlag.RotationAngle) == PlainStyleFlag.RotationAngle;
				if (flag34)
				{
					worksheetRangeStyle.RotationAngle = style2.RotationAngle;
				}
			}
			return worksheetRangeStyle;
		}

		internal static WorksheetRangeStyle FindCellParentStyle(Worksheet sheet, int row, int col, out StyleParentKind pKind)
		{
			RowHeader rowHeader = sheet.RetrieveRowHeader(row);
			bool flag = rowHeader.InnerStyle != null;
			WorksheetRangeStyle result;
			if (flag)
			{
				pKind = StyleParentKind.Row;
				result = rowHeader.InnerStyle;
			}
			else
			{
				ColumnHeader columnHeader = sheet.RetrieveColumnHeader(col);
				bool flag2 = columnHeader.InnerStyle != null;
				if (flag2)
				{
					pKind = StyleParentKind.Col;
					result = columnHeader.InnerStyle;
				}
				else
				{
					pKind = StyleParentKind.Root;
					result = sheet.RootStyle;
				}
			}
			return result;
		}

		internal static void UpdateCellParentStyle(Worksheet grid, Cell cell)
		{
			RowHeader rowHeader = grid.RetrieveRowHeader(cell.InternalRow);
			bool flag = rowHeader.InnerStyle != null;
			if (flag)
			{
				cell.InnerStyle = rowHeader.InnerStyle;
				cell.StyleParentKind = StyleParentKind.Row;
			}
			else
			{
				ColumnHeader columnHeader = grid.RetrieveColumnHeader(cell.InternalCol);
				bool flag2 = columnHeader.InnerStyle != null;
				if (flag2)
				{
					cell.InnerStyle = columnHeader.InnerStyle;
					cell.StyleParentKind = StyleParentKind.Col;
				}
				else
				{
					cell.InnerStyle = grid.RootStyle;
					cell.StyleParentKind = StyleParentKind.Root;
				}
			}
		}

		internal static RGXmlCellStyle ConvertToXmlStyle(WorksheetRangeStyle style)
		{
			bool flag = style == null || style.Flag == PlainStyleFlag.None;
			RGXmlCellStyle result;
			if (flag)
			{
				result = null;
			}
			else
			{
				RGXmlCellStyle rgxmlCellStyle = new RGXmlCellStyle();
				bool flag2 = StyleUtility.HasStyle(style, PlainStyleFlag.BackColor);
				if (flag2)
				{
					rgxmlCellStyle.backColor = TextFormatHelper.EncodeColor(style.BackColor);
				}
				bool flag3 = StyleUtility.HasStyle(style, PlainStyleFlag.FillPattern);
				if (flag3)
				{
					RGXmlCellStyleFillPattern fillPattern = new RGXmlCellStyleFillPattern
					{
						color = TextFormatHelper.EncodeColor(style.FillPatternColor),
						patternStyleId = (int)style.FillPatternStyle
					};
					rgxmlCellStyle.fillPattern = fillPattern;
				}
				bool flag4 = StyleUtility.HasStyle(style, PlainStyleFlag.TextColor);
				if (flag4)
				{
					rgxmlCellStyle.textColor = TextFormatHelper.EncodeColor(style.TextColor);
				}
				bool flag5 = StyleUtility.HasStyle(style, PlainStyleFlag.FontName);
				if (flag5)
				{
					rgxmlCellStyle.font = style.FontName;
				}
				bool flag6 = StyleUtility.HasStyle(style, PlainStyleFlag.FontSize);
				if (flag6)
				{
					rgxmlCellStyle.fontSize = style.FontSize.ToString();
				}
				bool flag7 = StyleUtility.HasStyle(style, PlainStyleFlag.FontStyleBold);
				if (flag7)
				{
					rgxmlCellStyle.bold = style.Bold.ToString().ToLower();
				}
				bool flag8 = StyleUtility.HasStyle(style, PlainStyleFlag.FontStyleItalic);
				if (flag8)
				{
					rgxmlCellStyle.italic = style.Italic.ToString().ToLower();
				}
				bool flag9 = StyleUtility.HasStyle(style, PlainStyleFlag.FontStyleStrikethrough);
				if (flag9)
				{
					rgxmlCellStyle.strikethrough = style.Strikethrough.ToString().ToLower();
				}
				bool flag10 = StyleUtility.HasStyle(style, PlainStyleFlag.FontStyleUnderline);
				if (flag10)
				{
					rgxmlCellStyle.underline = style.Underline.ToString().ToLower();
				}
				bool flag11 = StyleUtility.HasStyle(style, PlainStyleFlag.HorizontalAlign);
				if (flag11)
				{
					rgxmlCellStyle.hAlign = XmlFileFormatHelper.EncodeHorizontalAlign(style.HAlign);
				}
				bool flag12 = StyleUtility.HasStyle(style, PlainStyleFlag.VerticalAlign);
				if (flag12)
				{
					rgxmlCellStyle.vAlign = XmlFileFormatHelper.EncodeVerticalAlign(style.VAlign);
				}
				bool flag13 = StyleUtility.HasStyle(style, PlainStyleFlag.TextWrap);
				if (flag13)
				{
					rgxmlCellStyle.textWrap = XmlFileFormatHelper.EncodeTextWrapMode(style.TextWrapMode);
				}
				bool flag14 = StyleUtility.HasStyle(style, PlainStyleFlag.Indent);
				if (flag14)
				{
					rgxmlCellStyle.indent = style.Indent.ToString();
				}
				bool flag15 = StyleUtility.HasStyle(style, PlainStyleFlag.Padding);
				if (flag15)
				{
					rgxmlCellStyle.padding = TextFormatHelper.EncodePadding(style.Padding);
				}
				bool flag16 = StyleUtility.HasStyle(style, PlainStyleFlag.RotationAngle);
				if (flag16)
				{
					rgxmlCellStyle.rotateAngle = style.RotationAngle.ToString();
				}
				result = rgxmlCellStyle;
			}
			return result;
		}

		internal static WorksheetRangeStyle ConvertFromXmlStyle(Worksheet grid, RGXmlCellStyle xmlStyle, CultureInfo culture)
		{
			WorksheetRangeStyle worksheetRangeStyle = new WorksheetRangeStyle();
			bool flag = xmlStyle == null;
			WorksheetRangeStyle result;
			if (flag)
			{
				result = worksheetRangeStyle;
			}
			else
			{
				bool flag2 = !string.IsNullOrEmpty(xmlStyle.backColor);
				if (flag2)
				{
					Color backColor;
					bool flag3 = TextFormatHelper.DecodeColor(xmlStyle.backColor, out backColor);
					if (flag3)
					{
						worksheetRangeStyle.Flag |= PlainStyleFlag.BackColor;
						worksheetRangeStyle.BackColor = backColor;
					}
				}
				bool flag4 = xmlStyle.fillPattern != null;
				if (flag4)
				{
					Color fillPatternColor;
					bool flag5 = TextFormatHelper.DecodeColor(xmlStyle.fillPattern.color, out fillPatternColor);
					if (flag5)
					{
						worksheetRangeStyle.Flag |= PlainStyleFlag.FillPattern;
						worksheetRangeStyle.FillPatternColor = fillPatternColor;
						worksheetRangeStyle.FillPatternStyle = (HatchStyles)xmlStyle.fillPattern.patternStyleId;
					}
				}
				bool flag6 = !string.IsNullOrEmpty(xmlStyle.textColor);
				if (flag6)
				{
					Color textColor;
					bool flag7 = TextFormatHelper.DecodeColor(xmlStyle.textColor, out textColor);
					if (flag7)
					{
						worksheetRangeStyle.Flag |= PlainStyleFlag.TextColor;
						worksheetRangeStyle.TextColor = textColor;
					}
				}
				bool flag8 = !string.IsNullOrEmpty(xmlStyle.hAlign);
				if (flag8)
				{
					worksheetRangeStyle.Flag |= PlainStyleFlag.HorizontalAlign;
					worksheetRangeStyle.HAlign = XmlFileFormatHelper.DecodeHorizontalAlign(xmlStyle.hAlign);
				}
				bool flag9 = !string.IsNullOrEmpty(xmlStyle.vAlign);
				if (flag9)
				{
					worksheetRangeStyle.Flag |= PlainStyleFlag.VerticalAlign;
					worksheetRangeStyle.VAlign = XmlFileFormatHelper.DecodeVerticalAlign(xmlStyle.vAlign);
				}
				bool flag10 = !string.IsNullOrEmpty(xmlStyle.font);
				if (flag10)
				{
					worksheetRangeStyle.Flag |= PlainStyleFlag.FontName;
					worksheetRangeStyle.FontName = xmlStyle.font;
				}
				bool flag11 = xmlStyle.fontSize != null;
				if (flag11)
				{
					worksheetRangeStyle.Flag |= PlainStyleFlag.FontSize;
					worksheetRangeStyle.FontSize = TextFormatHelper.GetFloatValue(xmlStyle.fontSize, grid.RootStyle.FontSize, culture);
				}
				bool flag12 = xmlStyle.bold != null;
				if (flag12)
				{
					worksheetRangeStyle.Flag |= PlainStyleFlag.FontStyleBold;
					worksheetRangeStyle.Bold = (xmlStyle.bold == "true");
				}
				bool flag13 = xmlStyle.italic != null;
				if (flag13)
				{
					worksheetRangeStyle.Flag |= PlainStyleFlag.FontStyleItalic;
					worksheetRangeStyle.Italic = (xmlStyle.italic == "true");
				}
				bool flag14 = xmlStyle.strikethrough != null;
				if (flag14)
				{
					worksheetRangeStyle.Flag |= PlainStyleFlag.FontStyleStrikethrough;
					worksheetRangeStyle.Strikethrough = (xmlStyle.strikethrough == "true");
				}
				bool flag15 = xmlStyle.underline != null;
				if (flag15)
				{
					worksheetRangeStyle.Flag |= PlainStyleFlag.FontStyleUnderline;
					worksheetRangeStyle.Underline = (xmlStyle.underline == "true");
				}
				bool flag16 = !string.IsNullOrEmpty(xmlStyle.textWrap);
				if (flag16)
				{
					worksheetRangeStyle.Flag |= PlainStyleFlag.TextWrap;
					worksheetRangeStyle.TextWrapMode = XmlFileFormatHelper.DecodeTextWrapMode(xmlStyle.textWrap);
				}
				bool flag17 = !string.IsNullOrEmpty(xmlStyle.indent);
				if (flag17)
				{
					worksheetRangeStyle.Flag |= PlainStyleFlag.Indent;
					int pixelValue = TextFormatHelper.GetPixelValue(xmlStyle.indent, 0);
					bool flag18 = pixelValue > 0 && pixelValue < 65535;
					if (flag18)
					{
						worksheetRangeStyle.Indent = (ushort)pixelValue;
					}
				}
				bool flag19 = !string.IsNullOrEmpty(xmlStyle.padding);
				if (flag19)
				{
					worksheetRangeStyle.Flag |= PlainStyleFlag.Padding;
					worksheetRangeStyle.Padding = TextFormatHelper.DecodePadding(xmlStyle.padding);
				}
				int num = 0;
				bool flag20 = !string.IsNullOrEmpty(xmlStyle.rotateAngle) && int.TryParse(xmlStyle.rotateAngle, out num);
				if (flag20)
				{
					worksheetRangeStyle.Flag |= PlainStyleFlag.RotationAngle;
					worksheetRangeStyle.RotationAngle = (float)num;
				}
				result = worksheetRangeStyle;
			}
			return result;
		}

		internal static void UpdateCellRenderAlign(Worksheet ctrl, Cell cell)
		{
			bool flag = cell.InnerStyle != null && cell.InnerStyle.HAlign > ReoGridHorAlign.General;
			if (flag)
			{
				switch (cell.InnerStyle.HAlign)
				{
				case ReoGridHorAlign.Left:
					cell.RenderHorAlign = ReoGridRenderHorAlign.Left;
					break;
				case ReoGridHorAlign.Center:
					cell.RenderHorAlign = ReoGridRenderHorAlign.Center;
					break;
				case ReoGridHorAlign.Right:
					cell.RenderHorAlign = ReoGridRenderHorAlign.Right;
					break;
				}
			}
		}

		internal bool Equals(WorksheetRangeStyle styleA, WorksheetRangeStyle styleB)
		{
			bool flag = (styleA == null && styleB != null) || (styleA != null && styleB == null) || styleA.Flag != styleB.Flag;
			bool result;
			if (flag)
			{
				result = false;
			}
			else
			{
				bool flag2 = styleA.HasStyle(PlainStyleFlag.BackColor) && styleA.BackColor != styleB.BackColor;
				if (flag2)
				{
					result = false;
				}
				else
				{
					bool flag3 = styleA.HasStyle(PlainStyleFlag.FillPatternColor) && styleA.FillPatternColor != styleB.FillPatternColor;
					if (flag3)
					{
						result = false;
					}
					else
					{
						bool flag4 = styleA.HasStyle(PlainStyleFlag.FillPatternStyle) && styleA.FillPatternStyle != styleB.FillPatternStyle;
						if (flag4)
						{
							result = false;
						}
						else
						{
							bool flag5 = styleA.HasStyle(PlainStyleFlag.TextColor) && styleA.TextColor != styleB.TextColor;
							if (flag5)
							{
								result = false;
							}
							else
							{
								bool flag6 = styleA.HasStyle(PlainStyleFlag.FontName) && styleA.FontName != styleB.FontName;
								if (flag6)
								{
									result = false;
								}
								else
								{
									bool flag7 = styleA.HasStyle(PlainStyleFlag.FontSize) && styleA.FontSize != styleB.FontSize;
									if (flag7)
									{
										result = false;
									}
									else
									{
										bool flag8 = styleA.HasStyle(PlainStyleFlag.FontStyleBold) && styleA.Bold != styleB.Bold;
										if (flag8)
										{
											result = false;
										}
										else
										{
											bool flag9 = styleA.HasStyle(PlainStyleFlag.FontStyleItalic) && styleA.Italic != styleB.Italic;
											if (flag9)
											{
												result = false;
											}
											else
											{
												bool flag10 = styleA.HasStyle(PlainStyleFlag.FontStyleStrikethrough) && styleA.Strikethrough != styleB.Strikethrough;
												if (flag10)
												{
													result = false;
												}
												else
												{
													bool flag11 = styleA.HasStyle(PlainStyleFlag.FontStyleUnderline) && styleA.Underline != styleB.Underline;
													if (flag11)
													{
														result = false;
													}
													else
													{
														bool flag12 = styleA.HasStyle(PlainStyleFlag.HorizontalAlign) && styleA.HAlign != styleB.HAlign;
														if (flag12)
														{
															result = false;
														}
														else
														{
															bool flag13 = styleA.HasStyle(PlainStyleFlag.VerticalAlign) && styleA.VAlign != styleB.VAlign;
															if (flag13)
															{
																result = false;
															}
															else
															{
																bool flag14 = styleA.HasStyle(PlainStyleFlag.TextWrap) && styleA.TextWrapMode != styleB.TextWrapMode;
																if (flag14)
																{
																	result = false;
																}
																else
																{
																	bool flag15 = styleA.HasStyle(PlainStyleFlag.Indent) && styleA.Indent != styleB.Indent;
																	if (flag15)
																	{
																		result = false;
																	}
																	else
																	{
																		bool flag16 = styleA.HasStyle(PlainStyleFlag.Padding) && styleA.Padding != styleB.Padding;
																		if (flag16)
																		{
																			result = false;
																		}
																		else
																		{
																			bool flag17 = styleA.HasStyle(PlainStyleFlag.RotationAngle) && styleA.RotationAngle != styleB.RotationAngle;
																			result = !flag17;
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
			return result;
		}

		public static object GetStyleItem(WorksheetRangeStyle style, PlainStyleFlag flag)
		{
			if (flag <= PlainStyleFlag.HorizontalAlign)
			{
				if (flag <= PlainStyleFlag.FontStyleStrikethrough)
				{
					long num = flag - PlainStyleFlag.FontName;
					if (num <= 3L)
					{
						switch ((uint)num)
						{
						case 0U:
							return style.FontName;
						case 1U:
							return style.FontSize;
						case 2U:
							goto IL_1F8;
						case 3U:
							return style.Bold;
						}
					}
					if (flag == PlainStyleFlag.FontStyleItalic)
					{
						return style.Italic;
					}
					if (flag == PlainStyleFlag.FontStyleStrikethrough)
					{
						return style.Strikethrough;
					}
				}
				else if (flag <= PlainStyleFlag.TextColor)
				{
					if (flag == PlainStyleFlag.FontStyleUnderline)
					{
						return style.Underline;
					}
					if (flag == PlainStyleFlag.TextColor)
					{
						return style.TextColor;
					}
				}
				else
				{
					if (flag == PlainStyleFlag.BackColor)
					{
						return style.BackColor;
					}
					if (flag == PlainStyleFlag.HorizontalAlign)
					{
						return style.HAlign;
					}
				}
			}
			else if (flag <= PlainStyleFlag.FillPatternStyle)
			{
				if (flag == PlainStyleFlag.VerticalAlign)
				{
					return style.VAlign;
				}
				if (flag == PlainStyleFlag.FillPatternColor)
				{
					return style.FillPatternColor;
				}
				if (flag == PlainStyleFlag.FillPatternStyle)
				{
					return style.FillPatternStyle;
				}
			}
			else if (flag <= PlainStyleFlag.Indent)
			{
				if (flag == PlainStyleFlag.TextWrap)
				{
					return style.TextWrapMode;
				}
				if (flag == PlainStyleFlag.Indent)
				{
					return style.Indent;
				}
			}
			else
			{
				if (flag == PlainStyleFlag.Padding)
				{
					return style.Padding;
				}
				if (flag == PlainStyleFlag.RotationAngle)
				{
					return style.RotationAngle;
				}
			}
			IL_1F8:
			return null;
		}

		public static CPF.ReoGrid.Drawing.Text.FontStyles CreateFontStyle(WorksheetRangeStyle style)
		{
			CPF.ReoGrid.Drawing.Text.FontStyles fontStyles = CPF.ReoGrid.Drawing.Text.FontStyles.Regular;
			bool flag = style.HasStyle(PlainStyleFlag.FontStyleBold) && style.Bold;
			if (flag)
			{
				fontStyles |= CPF.ReoGrid.Drawing.Text.FontStyles.Bold;
			}
			bool flag2 = style.HasStyle(PlainStyleFlag.FontStyleItalic) && style.Italic;
			if (flag2)
			{
				fontStyles |= CPF.ReoGrid.Drawing.Text.FontStyles.Italic;
			}
			bool flag3 = style.HasStyle(PlainStyleFlag.FontStyleStrikethrough) && style.Strikethrough;
			if (flag3)
			{
				fontStyles |= CPF.ReoGrid.Drawing.Text.FontStyles.Strikethrough;
			}
			bool flag4 = style.HasStyle(PlainStyleFlag.FontStyleUnderline) && style.Underline;
			if (flag4)
			{
				fontStyles |= CPF.ReoGrid.Drawing.Text.FontStyles.Underline;
			}
			return fontStyles;
		}
	}
}