SANHOPE.mes.wcf/DK.Basics/BaseControls/ExportExcel/UPOI/Module1.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Printing;
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text;
using System.Windows.Forms;
using Microsoft.VisualBasic;
using Microsoft.VisualBasic.CompilerServices;

namespace Dongke.IBOSS.PRD.Framework.Controls {

	[StandardModule]
	internal sealed class Module1
	{
		public const string G_CustomDefinedPaperName = "[自定义纸张]";

		public static Ruler G_ruler = new Ruler();

		public static bool G_CancelDocument = false;

		public static bool G_CancelExportDGVToExcel = false;

		public static bool G_CancelPrint = false;

		private static byte[] G_mykey = new byte[24]
		{
		10, 32, 53, 24, 53, 23, 88, 223, 99, 10,
		33, 62, 64, 76, 68, 98, 13, 131, 93, 33,
		15, 56, 13, 13
		};

		private static byte[] G_myiv = new byte[8] { 13, 56, 87, 13, 98, 53, 80, 32 };

		[DllImport("kernel32", CharSet = CharSet.Ansi, EntryPoint = "GetPrivateProfileStringA", ExactSpelling = true, SetLastError = true)]
		private static extern int GetPrivateProfileString([MarshalAs(UnmanagedType.VBByRefStr)] ref string lpApplicationName, [MarshalAs(UnmanagedType.VBByRefStr)] ref string lpKeyName, [MarshalAs(UnmanagedType.VBByRefStr)] ref string lpDefault, [MarshalAs(UnmanagedType.VBByRefStr)] ref string lpReturnedString, int nSize, [MarshalAs(UnmanagedType.VBByRefStr)] ref string lpFileName);

		[DllImport("kernel32", CharSet = CharSet.Ansi, EntryPoint = "WritePrivateProfileStringA", ExactSpelling = true, SetLastError = true)]
		private static extern int WritePrivateProfileString([MarshalAs(UnmanagedType.VBByRefStr)] ref string lpApplicationName, [MarshalAs(UnmanagedType.VBByRefStr)] ref string lpKeyName, [MarshalAs(UnmanagedType.VBByRefStr)] ref string lpString, [MarshalAs(UnmanagedType.VBByRefStr)] ref string lpFileName);

		public static void CopyTreeView(TreeView s, ref TreeView d, bool isaddrowname)
		{
			d.Nodes.Clear();
			if (s == null)
			{
				d = null;
				return;
			}
			d.StateImageList = s.StateImageList;
			d.ImageList = s.ImageList;
			d.ImageIndex = s.ImageIndex;
			if (Operators.CompareString(s.ImageKey, "", TextCompare: false) != 0)
			{
				d.ImageKey = s.ImageKey;
			}
			d.CheckBoxes = s.CheckBoxes;
			d.LineColor = s.LineColor;
			d.Font = (Font)s.Font.Clone();
			d.ForeColor = s.ForeColor;
			int num = 0;
			checked
			{
				int num2 = s.Nodes.Count - 1;
				for (int i = num; i <= num2; i++)
				{
					TreeNode d2 = d.Nodes.Add(s.Nodes[i].Text);
					d2.Checked = s.Nodes[i].Checked;
					d2.ImageIndex = s.Nodes[i].ImageIndex;
					if (Operators.CompareString(s.Nodes[i].ImageKey, "", TextCompare: false) != 0)
					{
						d2.ImageKey = s.Nodes[i].ImageKey;
					}
					d2.StateImageIndex = s.Nodes[i].StateImageIndex;
					if (Operators.CompareString(s.Nodes[i].StateImageKey, "", TextCompare: false) != 0)
					{
						d2.StateImageKey = s.Nodes[i].StateImageKey;
					}
					d2.ForeColor = s.Nodes[i].ForeColor;
					d2.BackColor = s.Nodes[i].BackColor;
					if (s.Nodes[i].NodeFont != null)
					{
						d2.NodeFont = (Font)s.Nodes[i].NodeFont.Clone();
					}
					CopyNodes(s.Nodes[i], ref d2);
				}
				if (isaddrowname)
				{
					d.Nodes.Insert(0, "行号");
				}
			}
		}

		private static void CopyNodes(TreeNode s, ref TreeNode d)
		{
			if (s == null)
			{
				return;
			}
			int num = 0;
			checked
			{
				int num2 = s.Nodes.Count - 1;
				for (int i = num; i <= num2; i++)
				{
					TreeNode d2 = d.Nodes.Add(s.Nodes[i].Text);
					d2.Checked = s.Nodes[i].Checked;
					d2.ImageIndex = s.Nodes[i].ImageIndex;
					if (Operators.CompareString(s.Nodes[i].ImageKey, "", TextCompare: false) != 0)
					{
						d2.ImageKey = s.Nodes[i].ImageKey;
					}
					d2.StateImageIndex = s.Nodes[i].StateImageIndex;
					if (Operators.CompareString(s.Nodes[i].StateImageKey, "", TextCompare: false) != 0)
					{
						d2.StateImageKey = s.Nodes[i].StateImageKey;
					}
					d2.ForeColor = s.Nodes[i].ForeColor;
					d2.BackColor = s.Nodes[i].BackColor;
					if (s.Nodes[i].NodeFont != null)
					{
						d2.NodeFont = (Font)s.Nodes[i].NodeFont.Clone();
					}
					CopyNodes(s.Nodes[i], ref d2);
				}
			}
		}

		public static string GetINI(string Section, string AppName, string lpDefault, string FileName)
		{
			string source = "";
			source = Strings.LSet(source, 256);
			GetPrivateProfileString(ref Section, ref AppName, ref lpDefault, ref source, Strings.Len(source), ref FileName);
			string expression = Strings.Trim(Strings.Left(source, checked(Strings.InStr(source, "\0") - 1)));
			expression = Strings.Replace(expression, "&<br>&", "\r\n");
			if (expression == null)
			{
				expression = "";
			}
			return expression;
		}

		public static long WriteINI(string Section, string AppName, string lpDefault, string FileName)
		{
			lpDefault = Strings.Replace(lpDefault, "\r\n", "&<br>&");
			if (lpDefault == null)
			{
				lpDefault = "";
			}
			return WritePrivateProfileString(ref Section, ref AppName, ref lpDefault, ref FileName);
		}

		public static string ConvertFontToString(Font myfont)
		{
			FontConverter fontConverter = new FontConverter();
			return fontConverter.ConvertToString(myfont);
		}

		public static string ConvertColorToString(Color mycolor)
		{
			ColorConverter colorConverter = new ColorConverter();
			return colorConverter.ConvertToString(mycolor);
		}

		public static Color ConvertStringToColor(string pp)
		{
			ColorConverter colorConverter = new ColorConverter();
			try
			{
				object obj = colorConverter.ConvertFromString(pp);
				Color black = Color.Black;
				return (obj != null) ? ((Color)obj) : black;
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				Color result = Color.FromArgb(0);
				ProjectData.ClearProjectError();
				return result;
			}
		}

		public static Font ConvertStringToFont(string pp)
		{
			FontConverter fontConverter = new FontConverter();
			Font result;
			if (Operators.CompareString(pp, "(无)", TextCompare: false) == 0)
			{
				result = null;
			}
			else
			{
				try
				{
					Font font = (Font)fontConverter.ConvertFromString(pp);
					result = font;
				}
				catch (Exception projectError)
				{
					ProjectData.SetProjectError(projectError);
					result = null;
					ProjectData.ClearProjectError();
				}
			}
			return result;
		}

		public static void CopyDataGridView(DataGridView sdv, DataGridView ddv, bool IsAddRowHeaderColumn)
		{
			CopyDataGridView(sdv, ddv);
			if (!IsAddRowHeaderColumn)
			{
				return;
			}
			checked
			{
				try
				{
					if (ddv.Columns.Count <= 0)
					{
						return;
					}
					DataGridViewTextBoxColumn dataGridViewTextBoxColumn = new DataGridViewTextBoxColumn();
					dataGridViewTextBoxColumn.HeaderCell = (DataGridViewColumnHeaderCell)sdv.TopLeftHeaderCell.Clone();
					if (sdv.TopLeftHeaderCell.HasStyle)
					{
						dataGridViewTextBoxColumn.HeaderCell.Style = sdv.TopLeftHeaderCell.Style.Clone();
					}
					dataGridViewTextBoxColumn.Width = sdv.RowHeadersWidth;
					if (Operators.CompareString(dataGridViewTextBoxColumn.Name ?? "", "", TextCompare: false) == 0)
					{
						dataGridViewTextBoxColumn.Name = "行标题";
					}
					dataGridViewTextBoxColumn.SortMode = DataGridViewColumnSortMode.NotSortable;
					ddv.Columns.Insert(0, dataGridViewTextBoxColumn);
					int rowCount = ddv.RowCount;
					int num = 0;
					int num2 = rowCount - 1;
					for (int i = num; i <= num2; i++)
					{
						ddv.Rows[i].Cells[0].Value = Conversions.ToString(sdv.Rows[i].HeaderCell.FormattedValue) ?? "";
						if (sdv.Rows[i].HeaderCell.Style.Font != null)
						{
							ddv.Rows[i].Cells[0].Style.Font = (Font)sdv.Rows[i].HeaderCell.Style.Font.Clone();
						}
						else if (sdv.RowHeadersDefaultCellStyle.Font != null)
						{
							ddv.Rows[i].Cells[0].Style.Font = (Font)sdv.RowHeadersDefaultCellStyle.Font.Clone();
						}
						if (sdv.Rows[i].HeaderCell.Style.Alignment != 0)
						{
							ddv.Rows[i].Cells[0].Style.Alignment = sdv.Rows[i].HeaderCell.Style.Alignment;
						}
						else
						{
							ddv.Rows[i].Cells[0].Style.Alignment = sdv.RowHeadersDefaultCellStyle.Alignment;
						}
						if (sdv.Rows[i].HeaderCell.Style.ForeColor.ToArgb() != 0)
						{
							ddv.Rows[i].Cells[0].Style.ForeColor = sdv.Rows[i].HeaderCell.Style.ForeColor;
						}
						else if (sdv.RowHeadersDefaultCellStyle.ForeColor.ToArgb() != 0)
						{
							ddv.Rows[i].Cells[0].Style.ForeColor = sdv.RowHeadersDefaultCellStyle.ForeColor;
						}
						if (sdv.Rows[i].HeaderCell.Style.BackColor.ToArgb() != 0)
						{
							ddv.Rows[i].Cells[0].Style.BackColor = sdv.Rows[i].HeaderCell.Style.BackColor;
						}
						else if (sdv.RowHeadersDefaultCellStyle.BackColor.ToArgb() != 0)
						{
							ddv.Rows[i].Cells[0].Style.BackColor = sdv.RowHeadersDefaultCellStyle.BackColor;
						}
						if (sdv.Rows[i].HeaderCell.Style.WrapMode != 0)
						{
							ddv.Rows[i].Cells[0].Style.WrapMode = sdv.Rows[i].HeaderCell.Style.WrapMode;
						}
						else if (sdv.RowHeadersDefaultCellStyle.WrapMode != 0)
						{
							ddv.Rows[i].Cells[0].Style.WrapMode = sdv.RowHeadersDefaultCellStyle.WrapMode;
						}
					}
				}
				catch (Exception projectError)
				{
					ProjectData.SetProjectError(projectError);
					ProjectData.ClearProjectError();
				}
			}
		}

		public static void CopyDataGridViewShowStatus(DataGridView sdv, DataGridView ddv, bool isprintrowheadercolumn)
		{
			progress2 progress3 = new progress2();
			progress3.Show();
			progress3.Label1.Text = "正在复制数据……请稍侯";
			Application.DoEvents();
			CopyDataGridView(sdv, ddv, isprintrowheadercolumn);
			progress3.Close();
			progress3.Dispose();
		}

		public static void CopyDataGridViewShowStatus(DataGridView sdv, DataGridView ddv, int fromrow, int torow, bool isprintrowheadercolumn)
		{
			progress2 progress3 = new progress2();
			progress3.Show();
			progress3.Label1.Text = "正在复制数据……请稍侯";
			Application.DoEvents();
			CopyDataGridView(sdv, ddv, fromrow, torow, isprintrowheadercolumn);
			progress3.Close();
			progress3.Dispose();
		}

		public static void MyMsgBox(string ss)
		{
		}

		public static void CopyDataGridView(DataGridView sdv, DataGridView ddv)
		{
			if (sdv == null || ddv == null)
			{
				return;
			}
			if (sdv.Equals(ddv))
			{
				MyMsgBox("在CopyDataGridView函数中发现要复制的DGV与目标DGV完全一样");
				return;
			}
			ddv.AllowUserToAddRows = false;
			while (ddv.ColumnCount >= 1)
			{
				ddv.Columns.RemoveAt(0);
			}
			ddv.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.None;
			ddv.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.None;
			int columnCount = sdv.ColumnCount;
			int num = 0;
			checked
			{
				int num2 = columnCount - 1;
				for (int i = num; i <= num2; i++)
				{
					if (Operators.CompareString(Versioned.TypeName(sdv.Columns[i]), "DataGridViewComboBoxColumn", TextCompare: false) == 0)
					{
						DataGridViewTextBoxColumn dataGridViewTextBoxColumn = new DataGridViewTextBoxColumn();
						try
						{
							dataGridViewTextBoxColumn.DefaultCellStyle = sdv.Columns[i].DefaultCellStyle.Clone();
							dataGridViewTextBoxColumn.AutoSizeMode = sdv.Columns[i].AutoSizeMode;
							dataGridViewTextBoxColumn.DisplayIndex = sdv.Columns[i].DisplayIndex;
						}
						catch (Exception projectError)
						{
							ProjectData.SetProjectError(projectError);
							ProjectData.ClearProjectError();
						}
						try
						{
							dataGridViewTextBoxColumn.HeaderCell = (DataGridViewColumnHeaderCell)sdv.Columns[i].HeaderCell.Clone();
							dataGridViewTextBoxColumn.HeaderText = sdv.Columns[i].HeaderText;
							dataGridViewTextBoxColumn.MinimumWidth = sdv.Columns[i].MinimumWidth;
							dataGridViewTextBoxColumn.Resizable = sdv.Columns[i].Resizable;
						}
						catch (Exception projectError2)
						{
							ProjectData.SetProjectError(projectError2);
							ProjectData.ClearProjectError();
						}
						try
						{
							dataGridViewTextBoxColumn.Name = sdv.Columns[i].Name;
							dataGridViewTextBoxColumn.Tag = RuntimeHelpers.GetObjectValue(sdv.Columns[i].Tag);
							dataGridViewTextBoxColumn.Visible = sdv.Columns[i].Visible;
							try
							{
								if (Operators.CompareString(Conversions.ToString(dataGridViewTextBoxColumn.Tag), "不打印", TextCompare: false) == 0)
								{
									dataGridViewTextBoxColumn.Visible = false;
								}
							}
							catch (Exception projectError3)
							{
								ProjectData.SetProjectError(projectError3);
								ProjectData.ClearProjectError();
							}
							dataGridViewTextBoxColumn.Width = sdv.Columns[i].Width;
						}
						catch (Exception projectError4)
						{
							ProjectData.SetProjectError(projectError4);
							ProjectData.ClearProjectError();
						}
						ddv.Columns.Add(dataGridViewTextBoxColumn);
					}
					else
					{
						DataGridViewColumn dataGridViewColumn = (DataGridViewColumn)sdv.Columns[i].Clone();
						dataGridViewColumn.Frozen = false;
						try
						{
							if (Operators.CompareString(Conversions.ToString(dataGridViewColumn.Tag), "不打印", TextCompare: false) == 0)
							{
								dataGridViewColumn.Visible = false;
							}
						}
						catch (Exception projectError5)
						{
							ProjectData.SetProjectError(projectError5);
							ProjectData.ClearProjectError();
						}
						ddv.Columns.Add(dataGridViewColumn);
					}
					try
					{
						ddv.Columns[i].ValueType = sdv.Columns[i].ValueType;
					}
					catch (Exception projectError6)
					{
						ProjectData.SetProjectError(projectError6);
						ProjectData.ClearProjectError();
					}
					if (Operators.CompareString(ddv.Columns[i].Name ?? "", "", TextCompare: false) == 0)
					{
						ddv.Columns[i].Name = "第" + Conversions.ToString(i) + "列名";
					}
					ddv.Columns[i].SortMode = DataGridViewColumnSortMode.NotSortable;
					ddv.Columns[i].AutoSizeMode = DataGridViewAutoSizeColumnMode.None;
				}
				int[] array = new int[sdv.ColumnCount - 1 + 1];
				int[] array2 = new int[sdv.ColumnCount - 1 + 1];
				int num3 = 0;
				int num4 = sdv.ColumnCount - 1;
				for (int j = num3; j <= num4; j++)
				{
					array[j] = j;
					array2[j] = sdv.Columns[j].DisplayIndex;
				}
				Array.Sort(array2, array);
				int num5 = 0;
				int num6 = sdv.ColumnCount - 1;
				for (int k = num5; k <= num6; k++)
				{
					ddv.Columns[array[k]].DisplayIndex = sdv.Columns[array[k]].DisplayIndex;
				}
				ddv.ColumnHeadersHeightSizeMode = sdv.ColumnHeadersHeightSizeMode;
				ddv.ColumnHeadersHeight = sdv.ColumnHeadersHeight;
				ddv.ColumnHeadersVisible = sdv.ColumnHeadersVisible;
				if (sdv.RowCount <= 0)
				{
					return;
				}
				int num7 = sdv.RowCount;
				if (sdv.AllowUserToAddRows && IsNullLastRow(sdv))
				{
					num7--;
				}
				ddv.RowCount = num7;
				ddv.AlternatingRowsDefaultCellStyle = sdv.AlternatingRowsDefaultCellStyle.Clone();
				ddv.DefaultCellStyle = sdv.DefaultCellStyle.Clone();
				ddv.RowsDefaultCellStyle = sdv.RowsDefaultCellStyle.Clone();
				ddv.ColumnHeadersDefaultCellStyle = sdv.ColumnHeadersDefaultCellStyle.Clone();
				int num8 = 0;
				int num9 = sdv.ColumnCount - 1;
				for (int l = num8; l <= num9; l++)
				{
					if (sdv.Columns[l].HasDefaultCellStyle)
					{
						ddv.Columns[l].DefaultCellStyle = sdv.Columns[l].DefaultCellStyle.Clone();
					}
				}
				columnCount = ddv.Columns.Count - 1;
				string[] array3 = new string[columnCount + 1];
				int num10 = 0;
				int num11 = columnCount;
				for (int m = num10; m <= num11; m++)
				{
					array3[m] = Versioned.TypeName(sdv.Columns[m]);
				}
				int num12 = 0;
				int num13 = num7 - 1;
				for (int n = num12; n <= num13; n++)
				{
					int num14 = 0;
					int num15 = columnCount;
					for (int num16 = num14; num16 <= num15; num16++)
					{
						if (Operators.CompareString(array3[num16], "DataGridViewImageColumn", TextCompare: false) == 0)
						{
							ddv.Rows[n].Cells[num16].Value = RuntimeHelpers.GetObjectValue(sdv.Rows[n].Cells[num16].Value);
							if (ddv.Rows[n].Cells[num16].Value != null)
							{
								try
								{
									DataGridViewImageCell dataGridViewImageCell = (DataGridViewImageCell)ddv.Rows[n].Cells[num16];
									dataGridViewImageCell.ImageLayout = ((DataGridViewImageCell)sdv.Rows[n].Cells[num16]).ImageLayout;
								}
								catch (Exception projectError7)
								{
									ProjectData.SetProjectError(projectError7);
									ProjectData.ClearProjectError();
								}
							}
						}
						else
						{
							ddv.Rows[n].Cells[num16].Value = Conversions.ToString(sdv.Rows[n].Cells[num16].FormattedValue) ?? "";
						}
						if (sdv.Rows[n].Cells[num16].HasStyle)
						{
							ddv.Rows[n].Cells[num16].Style = sdv.Rows[n].Cells[num16].Style.Clone();
						}
						try
						{
							ddv.Rows[n].Cells[num16].Tag = RuntimeHelpers.GetObjectValue(sdv.Rows[n].Cells[num16].Tag);
						}
						catch (Exception projectError8)
						{
							ProjectData.SetProjectError(projectError8);
							ProjectData.ClearProjectError();
						}
					}
					ddv.Rows[n].Height = sdv.Rows[n].Height;
					ddv.Rows[n].Visible = sdv.Rows[n].Visible;
					if (sdv.Rows[n].HasDefaultCellStyle)
					{
						ddv.Rows[n].DefaultCellStyle = sdv.Rows[n].DefaultCellStyle.Clone();
					}
					try
					{
						ddv.Rows[n].Tag = RuntimeHelpers.GetObjectValue(sdv.Rows[n].Tag);
					}
					catch (Exception projectError9)
					{
						ProjectData.SetProjectError(projectError9);
						ProjectData.ClearProjectError();
					}
				}
				ddv.GridColor = sdv.GridColor;
				ddv.Name = sdv.Name;
			}
		}

		public static void CopyDataGridView(DataGridView sdv, DataGridView ddv, int fromrow, int torow, bool isprintrowheadercolumn)
		{
			if (sdv == null || ddv == null)
			{
				return;
			}
			if (sdv.Equals(ddv))
			{
				MyMsgBox("在CopyDataGridView函数中发现要复制的DGV与目标DGV完全一样");
				return;
			}
			if (fromrow < 0)
			{
				fromrow = 0;
			}
			if (torow > checked(sdv.RowCount - 1) || torow < fromrow)
			{
				torow = checked(sdv.RowCount - 1);
			}
			ddv.AllowUserToAddRows = false;
			while (ddv.ColumnCount >= 1)
			{
				ddv.Columns.RemoveAt(0);
			}
			ddv.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.None;
			ddv.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.None;
			int num = 0;
			checked
			{
				int num2 = sdv.ColumnCount - 1;
				for (int i = num; i <= num2; i++)
				{
					if (Operators.CompareString(Versioned.TypeName(sdv.Columns[i]), "DataGridViewComboBoxColumn", TextCompare: false) == 0)
					{
						DataGridViewTextBoxColumn dataGridViewTextBoxColumn = new DataGridViewTextBoxColumn();
						try
						{
							dataGridViewTextBoxColumn.DefaultCellStyle = sdv.Columns[i].DefaultCellStyle.Clone();
							dataGridViewTextBoxColumn.AutoSizeMode = sdv.Columns[i].AutoSizeMode;
							dataGridViewTextBoxColumn.DisplayIndex = sdv.Columns[i].DisplayIndex;
						}
						catch (Exception projectError)
						{
							ProjectData.SetProjectError(projectError);
							ProjectData.ClearProjectError();
						}
						try
						{
							dataGridViewTextBoxColumn.HeaderCell = (DataGridViewColumnHeaderCell)sdv.Columns[i].HeaderCell.Clone();
							dataGridViewTextBoxColumn.HeaderText = sdv.Columns[i].HeaderText;
							dataGridViewTextBoxColumn.MinimumWidth = sdv.Columns[i].MinimumWidth;
							dataGridViewTextBoxColumn.Resizable = sdv.Columns[i].Resizable;
						}
						catch (Exception projectError2)
						{
							ProjectData.SetProjectError(projectError2);
							ProjectData.ClearProjectError();
						}
						try
						{
							dataGridViewTextBoxColumn.Name = sdv.Columns[i].Name;
							dataGridViewTextBoxColumn.Tag = RuntimeHelpers.GetObjectValue(sdv.Columns[i].Tag);
							dataGridViewTextBoxColumn.Visible = sdv.Columns[i].Visible;
							try
							{
								if (Operators.CompareString(Conversions.ToString(dataGridViewTextBoxColumn.Tag), "不打印", TextCompare: false) == 0)
								{
									dataGridViewTextBoxColumn.Visible = false;
								}
							}
							catch (Exception projectError3)
							{
								ProjectData.SetProjectError(projectError3);
								ProjectData.ClearProjectError();
							}
							dataGridViewTextBoxColumn.Width = sdv.Columns[i].Width;
						}
						catch (Exception projectError4)
						{
							ProjectData.SetProjectError(projectError4);
							ProjectData.ClearProjectError();
						}
						ddv.Columns.Add(dataGridViewTextBoxColumn);
					}
					else
					{
						DataGridViewColumn dataGridViewColumn = (DataGridViewColumn)sdv.Columns[i].Clone();
						dataGridViewColumn.Frozen = false;
						try
						{
							if (Operators.CompareString(Conversions.ToString(dataGridViewColumn.Tag), "不打印", TextCompare: false) == 0)
							{
								dataGridViewColumn.Visible = false;
							}
						}
						catch (Exception projectError5)
						{
							ProjectData.SetProjectError(projectError5);
							ProjectData.ClearProjectError();
						}
						ddv.Columns.Add(dataGridViewColumn);
					}
					try
					{
						ddv.Columns[i].ValueType = sdv.Columns[i].ValueType;
					}
					catch (Exception projectError6)
					{
						ProjectData.SetProjectError(projectError6);
						ProjectData.ClearProjectError();
					}
					if (Operators.CompareString(ddv.Columns[i].Name ?? "", "", TextCompare: false) == 0)
					{
						ddv.Columns[i].Name = "第" + Conversions.ToString(i) + "列名";
					}
					ddv.Columns[i].SortMode = DataGridViewColumnSortMode.NotSortable;
					ddv.Columns[i].AutoSizeMode = DataGridViewAutoSizeColumnMode.None;
				}
				int[] array = new int[sdv.ColumnCount - 1 + 1];
				int[] array2 = new int[sdv.ColumnCount - 1 + 1];
				int num3 = 0;
				int num4 = sdv.ColumnCount - 1;
				for (int j = num3; j <= num4; j++)
				{
					array[j] = j;
					array2[j] = sdv.Columns[j].DisplayIndex;
				}
				Array.Sort(array2, array);
				int num5 = 0;
				int num6 = sdv.ColumnCount - 1;
				for (int k = num5; k <= num6; k++)
				{
					ddv.Columns[array[k]].DisplayIndex = sdv.Columns[array[k]].DisplayIndex;
				}
				ddv.ColumnHeadersHeightSizeMode = sdv.ColumnHeadersHeightSizeMode;
				ddv.ColumnHeadersHeight = sdv.ColumnHeadersHeight;
				ddv.ColumnHeadersVisible = sdv.ColumnHeadersVisible;
				if (sdv.RowCount <= 0)
				{
					return;
				}
				int rowCount = torow - fromrow + 1;
				ddv.RowCount = rowCount;
				ddv.AlternatingRowsDefaultCellStyle = sdv.AlternatingRowsDefaultCellStyle.Clone();
				ddv.DefaultCellStyle = sdv.DefaultCellStyle.Clone();
				ddv.RowsDefaultCellStyle = sdv.RowsDefaultCellStyle.Clone();
				ddv.ColumnHeadersDefaultCellStyle = sdv.ColumnHeadersDefaultCellStyle.Clone();
				int num7 = 0;
				int num8 = sdv.ColumnCount - 1;
				for (int l = num7; l <= num8; l++)
				{
					if (sdv.Columns[l].HasDefaultCellStyle)
					{
						ddv.Columns[l].DefaultCellStyle = sdv.Columns[l].DefaultCellStyle.Clone();
					}
				}
				int num9 = fromrow;
				int num10 = torow;
				for (int m = num9; m <= num10; m++)
				{
					int num11 = 0;
					int num12 = ddv.Columns.Count - 1;
					for (int n = num11; n <= num12; n++)
					{
						if (Operators.CompareString(Versioned.TypeName(sdv.Columns[n]), "DataGridViewImageColumn", TextCompare: false) == 0)
						{
							ddv.Rows[m - fromrow].Cells[n].Value = RuntimeHelpers.GetObjectValue(sdv.Rows[m].Cells[n].Value);
							if (ddv.Rows[m - fromrow].Cells[n].Value != null)
							{
								try
								{
									DataGridViewImageCell dataGridViewImageCell = (DataGridViewImageCell)ddv.Rows[m - fromrow].Cells[n];
									dataGridViewImageCell.ImageLayout = ((DataGridViewImageCell)sdv.Rows[m].Cells[n]).ImageLayout;
								}
								catch (Exception projectError7)
								{
									ProjectData.SetProjectError(projectError7);
									ProjectData.ClearProjectError();
								}
							}
						}
						else
						{
							ddv.Rows[m - fromrow].Cells[n].Value = Conversions.ToString(sdv.Rows[m].Cells[n].FormattedValue) ?? "";
						}
						if (sdv.Rows[m].Cells[n].HasStyle)
						{
							ddv.Rows[m - fromrow].Cells[n].Style = sdv.Rows[m].Cells[n].Style.Clone();
						}
						try
						{
							ddv.Rows[m - fromrow].Cells[n].Tag = RuntimeHelpers.GetObjectValue(sdv.Rows[m].Cells[n].Tag);
						}
						catch (Exception projectError8)
						{
							ProjectData.SetProjectError(projectError8);
							ProjectData.ClearProjectError();
						}
					}
					ddv.Rows[m - fromrow].Height = sdv.Rows[m].Height;
					ddv.Rows[m - fromrow].Visible = sdv.Rows[m].Visible;
					if (sdv.Rows[m].HasDefaultCellStyle)
					{
						ddv.Rows[m - fromrow].DefaultCellStyle = sdv.Rows[m].DefaultCellStyle.Clone();
					}
					try
					{
						ddv.Rows[m - fromrow].Tag = RuntimeHelpers.GetObjectValue(sdv.Rows[m].Tag);
					}
					catch (Exception projectError9)
					{
						ProjectData.SetProjectError(projectError9);
						ProjectData.ClearProjectError();
					}
				}
				ddv.GridColor = sdv.GridColor;
				ddv.Name = sdv.Name;
				if (!isprintrowheadercolumn)
				{
					return;
				}
				try
				{
					if (ddv.Columns.Count <= 0)
					{
						return;
					}
					DataGridViewTextBoxColumn dataGridViewTextBoxColumn2 = new DataGridViewTextBoxColumn();
					dataGridViewTextBoxColumn2.HeaderCell = (DataGridViewColumnHeaderCell)sdv.TopLeftHeaderCell.Clone();
					if (sdv.TopLeftHeaderCell.HasStyle)
					{
						dataGridViewTextBoxColumn2.HeaderCell.Style = sdv.TopLeftHeaderCell.Style.Clone();
					}
					dataGridViewTextBoxColumn2.Width = sdv.RowHeadersWidth;
					if (Operators.CompareString(dataGridViewTextBoxColumn2.Name ?? "", "", TextCompare: false) == 0)
					{
						dataGridViewTextBoxColumn2.Name = "平平自创";
					}
					dataGridViewTextBoxColumn2.SortMode = DataGridViewColumnSortMode.NotSortable;
					ddv.Columns.Insert(0, dataGridViewTextBoxColumn2);
					rowCount = ddv.RowCount;
					int num13 = fromrow;
					int num14 = torow;
					for (int num15 = num13; num15 <= num14; num15++)
					{
						ddv.Rows[num15 - fromrow].Cells[0].Value = Conversions.ToString(sdv.Rows[num15].HeaderCell.FormattedValue) ?? "";
						if (sdv.Rows[num15].HeaderCell.Style.Font != null)
						{
							ddv.Rows[num15 - fromrow].Cells[0].Style.Font = (Font)sdv.Rows[num15].HeaderCell.Style.Font.Clone();
						}
						else if (sdv.RowHeadersDefaultCellStyle.Font != null)
						{
							ddv.Rows[num15 - fromrow].Cells[0].Style.Font = (Font)sdv.RowHeadersDefaultCellStyle.Font.Clone();
						}
						if (sdv.Rows[num15].HeaderCell.Style.Alignment != 0)
						{
							ddv.Rows[num15 - fromrow].Cells[0].Style.Alignment = sdv.Rows[num15].HeaderCell.Style.Alignment;
						}
						else
						{
							ddv.Rows[num15 - fromrow].Cells[0].Style.Alignment = sdv.RowHeadersDefaultCellStyle.Alignment;
						}
						if (sdv.Rows[num15].HeaderCell.Style.ForeColor.ToArgb() != 0)
						{
							ddv.Rows[num15 - fromrow].Cells[0].Style.ForeColor = sdv.Rows[num15].HeaderCell.Style.ForeColor;
						}
						else if (sdv.RowHeadersDefaultCellStyle.ForeColor.ToArgb() != 0)
						{
							ddv.Rows[num15 - fromrow].Cells[0].Style.ForeColor = sdv.RowHeadersDefaultCellStyle.ForeColor;
						}
						if (sdv.Rows[num15].HeaderCell.Style.BackColor.ToArgb() != 0)
						{
							ddv.Rows[num15 - fromrow].Cells[0].Style.BackColor = sdv.Rows[num15].HeaderCell.Style.BackColor;
						}
						else if (sdv.RowHeadersDefaultCellStyle.BackColor.ToArgb() != 0)
						{
							ddv.Rows[num15 - fromrow].Cells[0].Style.BackColor = sdv.RowHeadersDefaultCellStyle.BackColor;
						}
						if (sdv.Rows[num15].HeaderCell.Style.WrapMode != 0)
						{
							ddv.Rows[num15 - fromrow].Cells[0].Style.WrapMode = sdv.Rows[num15].HeaderCell.Style.WrapMode;
						}
						else if (sdv.RowHeadersDefaultCellStyle.WrapMode != 0)
						{
							ddv.Rows[num15 - fromrow].Cells[0].Style.WrapMode = sdv.RowHeadersDefaultCellStyle.WrapMode;
						}
					}
				}
				catch (Exception projectError10)
				{
					ProjectData.SetProjectError(projectError10);
					ProjectData.ClearProjectError();
				}
			}
		}

		public static void DelDGVAllUnvisibleCols(DataGridView dgv)
		{
			if (dgv == null)
			{
				return;
			}
			checked
			{
				try
				{
					int columnCount = dgv.ColumnCount;
					for (int i = columnCount - 1; i >= 0; i += -1)
					{
						if (!dgv.Columns[i].Visible)
						{
							dgv.Columns.RemoveAt(i);
						}
					}
				}
				catch (Exception projectError)
				{
					ProjectData.SetProjectError(projectError);
					ProjectData.ClearProjectError();
				}
			}
		}

		public static void AddDGVRowID(DataGridView dgv)
		{
			if (dgv.Columns.Count <= 0)
			{
				return;
			}
			DataGridViewTextBoxColumn dataGridViewTextBoxColumn = new DataGridViewTextBoxColumn();
			dataGridViewTextBoxColumn.HeaderText = "行号";
			dataGridViewTextBoxColumn.DefaultCellStyle = dgv.DefaultCellStyle.Clone();
			dataGridViewTextBoxColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
			dataGridViewTextBoxColumn.Width = 40;
			dataGridViewTextBoxColumn.Name = "游平自创";
			try
			{
				dgv.Columns.Insert(0, dataGridViewTextBoxColumn);
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				dataGridViewTextBoxColumn.Frozen = true;
				dgv.Columns.Insert(0, dataGridViewTextBoxColumn);
				ProjectData.ClearProjectError();
			}
			checked
			{
				try
				{
					int num = 1;
					int num2 = 0;
					int num3 = dgv.RowCount - 1;
					for (int i = num2; i <= num3; i++)
					{
						if (dgv.Rows[i].Visible)
						{
							dgv.Rows[i].Cells[0].Value = Conversions.ToString(num);
							num++;
						}
					}
				}
				catch (Exception projectError2)
				{
					ProjectData.SetProjectError(projectError2);
					ProjectData.ClearProjectError();
				}
			}
		}

		public static int GetDGVVisibleRows(DataGridView dgv)
		{
			if (dgv == null)
			{
				return 0;
			}
			int num = 0;
			int num2 = 0;
			checked
			{
				int num3 = dgv.RowCount - 1;
				for (int i = num2; i <= num3; i++)
				{
					if (dgv.Rows[i].Visible)
					{
						num++;
					}
				}
				return num;
			}
		}

		public static bool IsNullLastRow(DataGridView dgv)
		{
			checked
			{
				bool result;
				if (dgv == null)
				{
					result = false;
				}
				else if (dgv.RowCount <= 0)
				{
					result = false;
				}
				else
				{
					int index = dgv.RowCount - 1;
					bool flag = true;
					try
					{
						int num = 0;
						int num2 = dgv.ColumnCount - 1;
						for (int i = num; i <= num2; i++)
						{
							if (Operators.CompareString(Versioned.TypeName(dgv.Columns[i]), "DataGridViewImageColumn", TextCompare: false) != 0 && Operators.ConditionalCompareObjectNotEqual(Operators.ConcatenateObject(dgv.Rows[index].Cells[i].Value, ""), "", TextCompare: false))
							{
								flag = false;
								break;
							}
						}
						result = (flag ? true : false);
					}
					catch (Exception projectError)
					{
						ProjectData.SetProjectError(projectError);
						result = false;
						ProjectData.ClearProjectError();
					}
				}
				return result;
			}
		}

		public static void SetDGVSelectedRowsVisible(DataGridView sdgv, DataGridView ddgv, int baserows)
		{
			checked
			{
				if (sdgv != null && ddgv != null)
				{
					int num = 0;
					int num2 = ddgv.Rows.Count - 1;
					for (int i = num; i <= num2; i++)
					{
						ddgv.Rows[i].Visible = false;
					}
					List<int> dGVSelectedRows = GetDGVSelectedRows(sdgv);
					int num3 = 0;
					int num4 = dGVSelectedRows.Count - 1;
					for (int j = num3; j <= num4; j++)
					{
						ddgv.Rows[dGVSelectedRows[j] - baserows].Visible = true;
					}
				}
			}
		}

		public static void SetDGVSelectedColumnsVisible(DataGridView sdgv, DataGridView ddgv)
		{
			if (sdgv == null || ddgv == null)
			{
				return;
			}
			checked
			{
				bool[] array = new bool[sdgv.Columns.Count - 1 + 1];
				int num = 0;
				int num2 = sdgv.Columns.Count - 1;
				for (int i = num; i <= num2; i++)
				{
					array[i] = false;
				}
				List<int> dGVSelectedCols = GetDGVSelectedCols(sdgv);
				int num3 = 0;
				int num4 = dGVSelectedCols.Count - 1;
				for (int j = num3; j <= num4; j++)
				{
					array[dGVSelectedCols[j]] = true;
				}
				int num5 = 0;
				int num6 = ddgv.Columns.Count - 1;
				for (int k = num5; k <= num6; k++)
				{
					if (!array[k])
					{
						ddgv.Columns[k].Visible = false;
					}
				}
			}
		}

		public static List<int> GetDGVSelectedCols(DataGridView dgv)
		{
			if (dgv == null)
			{
				return null;
			}
			if (dgv.SelectedCells.Count <= 0)
			{
				return null;
			}
			checked
			{
				int num = dgv.RowCount - 1;
				int num2 = dgv.ColumnCount - 1;
				List<int> list = new List<int>();
				int num3 = 0;
				int num4 = num2;
				for (int i = num3; i <= num4; i++)
				{
					if (!dgv.Columns[i].Visible)
					{
						continue;
					}
					int num5 = 0;
					int num6 = num;
					for (int j = num5; j <= num6; j++)
					{
						if (dgv.Rows[j].Cells[i].Selected)
						{
							list.Add(i);
							break;
						}
					}
				}
				return list;
			}
		}

		public static List<int> GetDGVSelectedRows(DataGridView dgv)
		{
			if (dgv == null)
			{
				return null;
			}
			if (dgv.SelectedCells.Count <= 0)
			{
				return null;
			}
			checked
			{
				int num = dgv.RowCount - 1;
				int num2 = dgv.ColumnCount - 1;
				List<int> list = new List<int>();
				int num3 = 0;
				int num4 = num;
				for (int i = num3; i <= num4; i++)
				{
					if (!dgv.Rows[i].Visible)
					{
						continue;
					}
					int num5 = 0;
					int num6 = num2;
					for (int j = num5; j <= num6; j++)
					{
						if (dgv.Rows[i].Cells[j].Selected)
						{
							list.Add(i);
							break;
						}
					}
				}
				return list;
			}
		}

		public static void SetDGVSelectedRowsAndColumnsVisible(DataGridView sdgv, DataGridView ddgv, int baserows)
		{
			SetDGVSelectedRowsVisible(sdgv, ddgv, baserows);
			SetDGVSelectedColumnsVisible(sdgv, ddgv);
		}

		public static int GetDGVSelectedMinRowIndex(DataGridView dgv)
		{
			if (dgv == null)
			{
				return -1;
			}
			if (dgv.RowCount <= 0)
			{
				return -1;
			}
			if (dgv.SelectedCells.Count <= 0)
			{
				return -1;
			}
			checked
			{
				int num = dgv.RowCount - 1;
				int num2 = dgv.ColumnCount - 1;
				int num3 = 0;
				int num4 = num;
				for (int i = num3; i <= num4; i++)
				{
					int num5 = 0;
					int num6 = num2;
					for (int j = num5; j <= num6; j++)
					{
						if (dgv.Rows[i].Cells[j].Selected)
						{
							return i;
						}
					}
				}
				return -1;
			}
		}

		public static int GetDGVSelectedMaxRowIndex(DataGridView dgv)
		{
			if (dgv == null)
			{
				return -1;
			}
			if (dgv.RowCount <= 0)
			{
				return -1;
			}
			if (dgv.SelectedCells.Count <= 0)
			{
				return -1;
			}
			checked
			{
				int num = dgv.RowCount - 1;
				int num2 = dgv.ColumnCount - 1;
				for (int i = num; i >= 0; i += -1)
				{
					int num3 = 0;
					int num4 = num2;
					for (int j = num3; j <= num4; j++)
					{
						if (dgv.Rows[i].Cells[j].Selected)
						{
							return i;
						}
					}
				}
				return -1;
			}
		}

		public static DataGridView ConvertDataGridToDGV(DataGrid myd, bool autoresizewidth, bool autoresizeheight)
		{
			DataGridView dataGridView = new DataGridView();
			int count = myd.BindingContext[RuntimeHelpers.GetObjectValue(myd.DataSource), myd.DataMember].Count;
			if (count <= 0)
			{
				return null;
			}
			int num = 0;
			checked
			{
				try
				{
					while (true)
					{
						Conversions.ToString(myd[0, num]);
						num++;
					}
				}
				catch (Exception projectError)
				{
					ProjectData.SetProjectError(projectError);
					ProjectData.ClearProjectError();
				}
				int num2 = 0;
				int num3 = count - 1;
				for (int i = num2; i <= num3; i++)
				{
					int num4 = 0;
					int num5 = num - 1;
					for (int j = num4; j <= num5; j++)
					{
					}
				}
				if (num <= 0)
				{
					return null;
				}
				dataGridView.RowCount = count;
				dataGridView.ColumnCount = num;
				if (myd.TableStyles.Count <= 0)
				{
					DataGridTableStyle table = new DataGridTableStyle((CurrencyManager)myd.BindingContext[RuntimeHelpers.GetObjectValue(myd.DataSource), myd.DataMember]);
					myd.TableStyles.Add(table);
				}
				int num6 = 0;
				int num7 = num - 1;
				for (int k = num6; k <= num7; k++)
				{
					dataGridView.Columns[k].HeaderText = myd.TableStyles[0].GridColumnStyles[k].HeaderText ?? "";
					dataGridView.Columns[k].DefaultCellStyle.Alignment = ConvertAlignment(myd.TableStyles[0].GridColumnStyles[k].Alignment);
					dataGridView.Columns[k].Width = myd.TableStyles[0].GridColumnStyles[k].Width;
				}
				dataGridView.ColumnHeadersDefaultCellStyle.Font = myd.HeaderFont;
				dataGridView.ColumnHeadersDefaultCellStyle.ForeColor = myd.HeaderForeColor;
				dataGridView.ColumnHeadersDefaultCellStyle.BackColor = myd.HeaderBackColor;
				int num8 = 0;
				int num9 = count - 1;
				for (int l = num8; l <= num9; l++)
				{
					int num10 = 0;
					int num11 = num - 1;
					for (int m = num10; m <= num11; m++)
					{
						dataGridView.Rows[l].Cells[m].Value = Operators.ConcatenateObject(myd[l, m], "");
					}
				}
				dataGridView.RowHeadersWidth = myd.RowHeaderWidth;
				dataGridView.AlternatingRowsDefaultCellStyle.BackColor = myd.AlternatingBackColor;
				dataGridView.DefaultCellStyle.BackColor = myd.BackColor;
				dataGridView.DefaultCellStyle.Font = myd.Font;
				dataGridView.DefaultCellStyle.ForeColor = myd.ForeColor;
				dataGridView.GridColor = myd.GridLineColor;
				int num12 = 0;
				int num13 = num - 1;
				for (int n = num12; n <= num13; n++)
				{
					dataGridView.Columns[n].DefaultCellStyle.WrapMode = DataGridViewTriState.True;
				}
				if (autoresizewidth)
				{
					dataGridView.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.AllCells);
				}
				if (autoresizeheight)
				{
					dataGridView.AutoResizeRows(DataGridViewAutoSizeRowsMode.AllCells);
				}
				return dataGridView;
			}
		}

		private static DataGridViewContentAlignment ConvertAlignment(HorizontalAlignment ss)
		{
			DataGridViewContentAlignment result;
			switch (ss)
			{
				case HorizontalAlignment.Left:
					result = DataGridViewContentAlignment.MiddleLeft;
					break;
				case HorizontalAlignment.Right:
					result = DataGridViewContentAlignment.MiddleRight;
					break;
				case HorizontalAlignment.Center:
					result = DataGridViewContentAlignment.MiddleCenter;
					break;
				default:
					result = DataGridViewContentAlignment.MiddleLeft;
					break;
			}
			return result;
		}

		private static bool IsColumNameExists(DataGridView dd, string tt)
		{
			if (dd == null)
			{
				return false;
			}
			if (Operators.CompareString(tt ?? "", "", TextCompare: false) == 0)
			{
				return false;
			}
			string[] array = Strings.Split(tt, ";");
			int num = 0;
			checked
			{
				int num2 = array.Length - 1;
				for (int i = num; i <= num2; i++)
				{
					try
					{
						_ = dd.Columns[array[i]].DisplayIndex;
					}
					catch (Exception projectError)
					{
						ProjectData.SetProjectError(projectError);
						bool result = false;
						ProjectData.ClearProjectError();
						return result;
					}
				}
				return true;
			}
		}

		public static void CreateHz(DataGridView dgv, int srows, string myhzcolumns, Font hzfont, Color hzforecolor, Color hzbackcolor, StringAlignment SumNumberAlign)
		{
			if (dgv.AllowUserToAddRows)
			{
				dgv.AllowUserToAddRows = false;
			}
			checked
			{
				if (dgv.RowCount > srows)
				{
					dgv.Rows.RemoveAt(dgv.RowCount - 1);
				}
				if (!IsColumNameExists(dgv, myhzcolumns))
				{
					myhzcolumns = "";
				}
				if (Operators.CompareString(myhzcolumns ?? "", "", TextCompare: false) == 0)
				{
					return;
				}
				string[] array = Strings.Split(myhzcolumns, ";");
				if (array.Length < 1)
				{
					return;
				}
				if (dgv.RowCount == srows)
				{
					dgv.Rows.Add();
				}
				decimal num = 0m;
				int num2 = 0;
				int num3 = array.Length - 1;
				string text;
				for (int i = num2; i <= num3; i++)
				{
					num = 0m;
					try
					{
						int num4 = 0;
						int num5 = srows - 1;
						for (int j = num4; j <= num5; j++)
						{
							if (dgv.Rows[j].Visible)
							{
								text = Conversions.ToString(dgv.Rows[j].Cells[array[i]].Value);
								if (Versioned.IsNumeric(text))
								{
									num = decimal.Add(num, Conversions.ToDecimal(text));
								}
							}
						}
						if (Operators.CompareString(Versioned.TypeName(dgv.Columns[array[i]]), "DataGridViewCheckBoxColumn", TextCompare: false) == 0)
						{
							dgv.Rows[dgv.RowCount - 1].Cells[array[i]].Value = false;
						}
						else if (Operators.CompareString(Versioned.TypeName(dgv.Columns[array[i]]), "DataGridViewImageColumn", TextCompare: false) == 0)
						{
							dgv.Rows[dgv.RowCount - 1].Cells[array[i]].Value = null;
						}
						else if (decimal.Compare(new decimal(Convert.ToInt64(num)), num) == 0)
						{
							dgv.Rows[dgv.RowCount - 1].Cells[array[i]].Value = Conversions.ToString(num);
						}
						else
						{
							dgv.Rows[dgv.RowCount - 1].Cells[array[i]].Value = Conversions.ToString(num);
						}
					}
					catch (Exception projectError)
					{
						ProjectData.SetProjectError(projectError);
						if (Operators.CompareString(Versioned.TypeName(dgv.Columns[array[i]]), "DataGridViewCheckBoxColumn", TextCompare: false) == 0)
						{
							dgv.Rows[dgv.RowCount - 1].Cells[array[i]].Value = false;
						}
						else if (Operators.CompareString(Versioned.TypeName(dgv.Columns[array[i]]), "DataGridViewImageColumn", TextCompare: false) == 0)
						{
							dgv.Rows[dgv.RowCount - 1].Cells[array[i]].Value = null;
						}
						else
						{
							dgv.Rows[dgv.RowCount - 1].Cells[array[i]].Value = "";
						}
						ProjectData.ClearProjectError();
					}
				}
				if (hzfont != null)
				{
					dgv.Rows[dgv.RowCount - 1].DefaultCellStyle.Font = hzfont;
				}
				if (hzforecolor.ToArgb() != 0)
				{
					dgv.Rows[dgv.RowCount - 1].DefaultCellStyle.ForeColor = hzforecolor;
				}
				if (hzbackcolor.ToArgb() != 0)
				{
					dgv.Rows[dgv.RowCount - 1].DefaultCellStyle.BackColor = hzbackcolor;
				}
				text = GetDGVFirstColumnName(dgv);
				if (Operators.CompareString(text, "", TextCompare: false) != 0)
				{
					dgv.Rows[dgv.RowCount - 1].Cells[text].Value = "总计";
				}
				dgv.Rows[dgv.RowCount - 1].Cells[text].Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
				switch (SumNumberAlign)
				{
					case StringAlignment.Near:
						dgv.Rows[dgv.RowCount - 1].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;
						break;
					case StringAlignment.Center:
						dgv.Rows[dgv.RowCount - 1].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
						break;
					case StringAlignment.Far:
						dgv.Rows[dgv.RowCount - 1].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
						break;
				}
			}
		}

		public static void CreateFzHz(DataGridView dgv, string groupcolumn, string myhzcolumns, Font hzfont, Color hzforecolor, Color hzbackcolor, bool addrowid, bool addrowidnew, StringAlignment SumNumberAlign)
		{
			if (dgv.AllowUserToAddRows)
			{
				dgv.AllowUserToAddRows = false;
			}
			if (addrowid)
			{
				AddDGVRowID(dgv);
			}
			groupcolumn = groupcolumn ?? "";
			if (Operators.CompareString(groupcolumn, "", TextCompare: false) == 0)
			{
				return;
			}
			string[] array = Strings.Split(myhzcolumns, ";");
			if (array.Length < 1)
			{
				return;
			}
			int num = 1;
			int fromrow = 0;
			if (Operators.CompareString(Versioned.TypeName(dgv.Columns[groupcolumn]), "DataGridViewImageColumn", TextCompare: false) == 0)
			{
				return;
			}
			string left = Conversions.ToString(dgv.Rows[0].Cells[groupcolumn].FormattedValue) ?? "";
			checked
			{
				if (dgv.Rows[0].Visible && addrowid)
				{
					dgv.Rows[0].Cells[0].Value = Conversions.ToString(num);
					num++;
				}
				int num2 = dgv.RowCount;
				if (!IsColumNameExists(dgv, myhzcolumns))
				{
					myhzcolumns = "";
				}
				if (Operators.CompareString(myhzcolumns ?? "", "", TextCompare: false) != 0)
				{
					num2--;
				}
				for (int i = 1; i <= num2 - 1; i++)
				{
					if (Operators.CompareString(left, Conversions.ToString(dgv.Rows[i].Cells[groupcolumn].FormattedValue) ?? "", TextCompare: false) != 0)
					{
						left = Conversions.ToString(dgv.Rows[i].Cells[groupcolumn].FormattedValue) ?? "";
						if (addrowidnew)
						{
							num = 1;
						}
						int torow = i - 1;
						if (CreateHzRow(dgv, groupcolumn, myhzcolumns, hzfont, hzforecolor, hzbackcolor, fromrow, torow, SumNumberAlign))
						{
							num2 = dgv.RowCount;
							num2--;
							fromrow = i + 1;
							i++;
						}
						else
						{
							fromrow = i;
						}
					}
					if (dgv.Rows[i].Visible && addrowid)
					{
						dgv.Rows[i].Cells[0].Value = Conversions.ToString(num);
						num++;
					}
				}
				if (Operators.CompareString(myhzcolumns ?? "", "", TextCompare: false) == 0)
				{
					CreateHzRow(dgv, groupcolumn, myhzcolumns, hzfont, hzforecolor, hzbackcolor, fromrow, dgv.RowCount - 1, SumNumberAlign);
				}
				else
				{
					CreateHzRow(dgv, groupcolumn, myhzcolumns, hzfont, hzforecolor, hzbackcolor, fromrow, dgv.RowCount - 1 - 1, SumNumberAlign);
				}
			}
		}

		private static bool CreateHzRow(DataGridView dgv, string groupcolumn, string myhzcolumns, Font hzfont, Color hzforecolor, Color hzbackcolor, int fromrow, int torow, StringAlignment SumNumberAlign)
		{
			checked
			{
				int num = torow + 1;
				decimal num2 = 0m;
				if (Operators.CompareString(myhzcolumns ?? "", "", TextCompare: false) == 0)
				{
					dgv.Rows[torow].Cells[groupcolumn].Tag = "分组";
					return false;
				}
				string[] array = Strings.Split(myhzcolumns, ";");
				if (array.Length < 1)
				{
					return false;
				}
				int num3 = 0;
				for (int i = fromrow; i <= torow; i++)
				{
					if (dgv.Rows[i].Visible)
					{
						num3++;
					}
				}
				if (num3 == 0)
				{
					return false;
				}
				if (num >= dgv.RowCount)
				{
					dgv.Rows.Add();
				}
				else
				{
					dgv.Rows.Insert(num);
				}
				int num4 = 0;
				int num5 = array.Length - 1;
				string text;
				for (int j = num4; j <= num5; j++)
				{
					num2 = 0m;
					try
					{
						for (int k = fromrow; k <= torow; k++)
						{
							if (dgv.Rows[k].Visible)
							{
								text = Conversions.ToString(dgv.Rows[k].Cells[array[j]].Value);
								if (Versioned.IsNumeric(text))
								{
									num2 = decimal.Add(num2, Conversions.ToDecimal(text));
								}
							}
						}
						if (Operators.CompareString(Versioned.TypeName(dgv.Columns[array[j]]), "DataGridViewCheckBoxColumn", TextCompare: false) == 0)
						{
							dgv.Rows[num].Cells[array[j]].Value = false;
						}
						else if (Operators.CompareString(Versioned.TypeName(dgv.Columns[array[j]]), "DataGridViewImageColumn", TextCompare: false) == 0)
						{
							dgv.Rows[num].Cells[array[j]].Value = null;
						}
						else if (decimal.Compare(new decimal(Convert.ToInt64(num2)), num2) == 0)
						{
							dgv.Rows[num].Cells[array[j]].Value = Conversions.ToString(num2);
						}
						else
						{
							dgv.Rows[num].Cells[array[j]].Value = Conversions.ToString(num2);
						}
					}
					catch (Exception projectError)
					{
						ProjectData.SetProjectError(projectError);
						if (Operators.CompareString(Versioned.TypeName(dgv.Columns[array[j]]), "DataGridViewCheckBoxColumn", TextCompare: false) == 0)
						{
							dgv.Rows[num].Cells[array[j]].Value = false;
						}
						else if (Operators.CompareString(Versioned.TypeName(dgv.Columns[array[j]]), "DataGridViewImageColumn", TextCompare: false) == 0)
						{
							dgv.Rows[num].Cells[array[j]].Value = null;
						}
						else
						{
							dgv.Rows[num].Cells[array[j]].Value = "";
						}
						ProjectData.ClearProjectError();
					}
				}
				if (hzfont != null)
				{
					dgv.Rows[num].DefaultCellStyle.Font = hzfont;
				}
				if (hzforecolor.ToArgb() != 0)
				{
					dgv.Rows[num].DefaultCellStyle.ForeColor = hzforecolor;
				}
				if (hzbackcolor.ToArgb() != 0)
				{
					dgv.Rows[num].DefaultCellStyle.BackColor = hzbackcolor;
				}
				dgv.Rows[num].Cells[groupcolumn].Value = RuntimeHelpers.GetObjectValue(dgv.Rows[fromrow].Cells[groupcolumn].Value);
				dgv.Rows[num].Cells[groupcolumn].Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
				text = GetDGVFirstColumnName(dgv);
				if (Operators.CompareString(text, "", TextCompare: false) != 0)
				{
					dgv.Rows[num].Cells[text].Value = "小计";
				}
				dgv.Rows[num].Cells[text].Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
				dgv.Rows[num].Cells[groupcolumn].Tag = "分组";
				switch (SumNumberAlign)
				{
					case StringAlignment.Near:
						dgv.Rows[num].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;
						break;
					case StringAlignment.Center:
						dgv.Rows[num].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
						break;
					case StringAlignment.Far:
						dgv.Rows[num].DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
						break;
				}
				return true;
			}
		}

		public static string GetDGVFirstColumnName(DataGridView dgv)
		{
			string result = "";
			int num = -1;
			int num2 = 0;
			checked
			{
				int num3 = dgv.ColumnCount - 1;
				for (int i = num2; i <= num3; i++)
				{
					if (num == -1)
					{
						if (dgv.Columns[i].Visible)
						{
							num = dgv.Columns[i].DisplayIndex;
							result = dgv.Columns[i].Name;
						}
					}
					else if (dgv.Columns[i].Visible && dgv.Columns[i].DisplayIndex < num)
					{
						num = dgv.Columns[i].DisplayIndex;
						result = dgv.Columns[i].Name;
					}
				}
				return result;
			}
		}

		public static bool IsHzColumn(string myhzcolumns, string columname)
		{
			if (Operators.CompareString(myhzcolumns, "", TextCompare: false) == 0 || myhzcolumns == null)
			{
				return false;
			}
			string[] array = Strings.Split(myhzcolumns, ";");
			if (array.Length <= 0)
			{
				return false;
			}
			int num = 0;
			checked
			{
				int num2 = array.Length - 1;
				for (int i = num; i <= num2; i++)
				{
					if (Operators.CompareString(array[i], columname, TextCompare: false) == 0)
					{
						return true;
					}
				}
				return false;
			}
		}

		public static bool IsValidPrinterName(string printername)
		{
			bool result = false;
			try
			{
				IEnumerator enumerator = PrinterSettings.InstalledPrinters.GetEnumerator();
				while (enumerator.MoveNext())
				{
					string str = Conversions.ToString(enumerator.Current);
					str = Strings.Trim(str);
					if (Operators.CompareString(printername.ToLower(), str.ToLower(), TextCompare: false) == 0)
					{
						result = true;
						break;
					}
				}
			}
			finally
			{
				IEnumerator enumerator2 = null;
				if (enumerator2 is IDisposable)
				{
					(enumerator2 as IDisposable).Dispose();
				}
			}
			return result;
		}

		public static void CreatePaper(string printername, string papername, int width, int height)
		{
			PrinterSettings printerSettings = new PrinterSettings();
			if (!IsValidPrinterName(printername))
			{
				printername = printerSettings.PrinterName;
			}
			PaperSize printForm = definepaper.GetPrintForm(printername, papername);
			if (printForm != null)
			{
				if (checked((printForm.Width != (int)Math.Round(Convert.ToDouble(decimal.Multiply(new decimal(width), 10m)) / 2.54)) | (printForm.Height != (int)Math.Round(Convert.ToDouble(decimal.Multiply(new decimal(height), 10m)) / 2.54))))
				{
					definepaper.SetPrintForm(printername, papername, width, height);
				}
			}
			else
			{
				definepaper.SetPrintForm(printername, papername, width, height);
			}
		}

		public static bool IsValidPaper(string printername, string papername)
		{
			PrinterSettings printerSettings = new PrinterSettings();
			if (!IsValidPrinterName(printername))
			{
				printername = printerSettings.PrinterName;
			}
			return definepaper.GetPrintForm(printername, papername) != null;
		}

		public static int ConvertPixlsToTwips(float x, bool isx)
		{
			float num = (float)((double)G_ruler.ConvertToMM(x, isx) * 56.7);
			return checked((int)Math.Round(num));
		}

		public static float ConvertTwipsToPixls(float x, bool isx)
		{
			_ = (double)x / 56.7;
			return (float)((double)G_ruler.ConvertFromMM(x, isx) * 5.67);
		}

		public static float ConvertInchToCm(float xx)
		{
			return (float)((double)xx * 2.54);
		}

		public static float ConvertInchToMm(float xx)
		{
			return (float)((double)xx * 25.4);
		}

		public static float ConvertCmToInch(float xx)
		{
			return (float)((double)xx / 2.54);
		}

		public static float ConvertMmToInch(float xx)
		{
			return (float)((double)xx / 25.4);
		}

		public static string ConvertImageToString(string picturefile)
		{
			checked
			{
				string result;
				try
				{
					FileStream fileStream = new FileStream(picturefile, FileMode.Open, FileAccess.Read, FileShare.Read);
					byte[] array = new byte[(int)(fileStream.Length - 1) + 1];
					fileStream.Read(array, 0, (int)fileStream.Length);
					fileStream.Close();
					result = Convert.ToBase64String(array);
				}
				catch (Exception projectError)
				{
					ProjectData.SetProjectError(projectError);
					result = "";
					ProjectData.ClearProjectError();
				}
				return result;
			}
		}

		public static string ConvertImageToString(Image img)
		{
			string result;
			if (img == null)
			{
				result = "";
			}
			else
			{
				try
				{
					string tempFileName = MyProject.Computer.FileSystem.GetTempFileName();
					img.Save(tempFileName, ImageFormat.Png);
					string text = ConvertImageToString(tempFileName);
					try
					{
						MyProject.Computer.FileSystem.DeleteFile(tempFileName);
					}
					catch (Exception projectError)
					{
						ProjectData.SetProjectError(projectError);
						ProjectData.ClearProjectError();
					}
					result = text;
				}
				catch (Exception projectError2)
				{
					ProjectData.SetProjectError(projectError2);
					result = "";
					ProjectData.ClearProjectError();
				}
			}
			return result;
		}

		public static Image ConvertStringToImage(string picturestring)
		{
			Image result;
			if (Operators.CompareString(picturestring ?? "", "", TextCompare: false) == 0)
			{
				result = null;
			}
			else
			{
				try
				{
					byte[] buffer = Convert.FromBase64String(picturestring);
					MemoryStream stream = new MemoryStream(buffer);
					result = Image.FromStream(stream);
				}
				catch (Exception projectError)
				{
					ProjectData.SetProjectError(projectError);
					result = null;
					ProjectData.ClearProjectError();
				}
			}
			return result;
		}

		public static string ConvertIcoToString(Icon img)
		{
			checked
			{
				string result;
				try
				{
					MemoryStream memoryStream = new MemoryStream();
					img.Save(memoryStream);
					memoryStream.Position = 0L;
					byte[] array = new byte[(int)(memoryStream.Length - 1) + 1];
					memoryStream.Read(array, 0, (int)memoryStream.Length);
					memoryStream.Close();
					result = Convert.ToBase64String(array);
				}
				catch (Exception projectError)
				{
					ProjectData.SetProjectError(projectError);
					result = "";
					ProjectData.ClearProjectError();
				}
				return result;
			}
		}

		public static Icon ConvertStringToIcon(string picturestring)
		{
			Icon result;
			if (Operators.CompareString(picturestring ?? "", "", TextCompare: false) == 0)
			{
				result = null;
			}
			else
			{
				try
				{
					byte[] buffer = Convert.FromBase64String(picturestring);
					MemoryStream stream = new MemoryStream(buffer);
					result = new Icon(stream);
				}
				catch (Exception projectError)
				{
					ProjectData.SetProjectError(projectError);
					result = null;
					ProjectData.ClearProjectError();
				}
			}
			return result;
		}

		private static DataGridView ConvertListViewToDGV2(ListView lv)
		{
			if (lv == null)
			{
				return null;
			}
			DataGridView dataGridView = new DataGridView();
			dataGridView.AllowUserToAddRows = false;
			dataGridView.RowCount = lv.Items.Count;
			dataGridView.ColumnCount = lv.Columns.Count;
			try
			{
				dataGridView.DefaultCellStyle.Font = (Font)lv.Font.Clone();
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				ProjectData.ClearProjectError();
			}
			dataGridView.ForeColor = lv.ForeColor;
			dataGridView.DefaultCellStyle.ForeColor = lv.ForeColor;
			int num = 0;
			checked
			{
				int num2 = lv.Columns.Count - 1;
				for (int i = num; i <= num2; i++)
				{
					dataGridView.Columns[i].HeaderText = lv.Columns[i].Text;
					try
					{
						dataGridView.Columns[i].DefaultCellStyle.Font = (Font)lv.Font.Clone();
					}
					catch (Exception projectError2)
					{
						ProjectData.SetProjectError(projectError2);
						ProjectData.ClearProjectError();
					}
					dataGridView.Columns[i].Width = lv.Columns[i].Width;
					dataGridView.Columns[i].DisplayIndex = lv.Columns[i].DisplayIndex;
				}
				int num3 = 0;
				int num4 = lv.Items.Count - 1;
				for (int j = num3; j <= num4; j++)
				{
					CopyListViewItemToDGV(lv, lv.Items[j], dataGridView.Rows[j]);
				}
				return dataGridView;
			}
		}

		public static DataGridView ConvertListViewToDGV(ListView lv)
		{
			if (lv == null)
			{
				return null;
			}
			if (!lv.ShowGroups)
			{
				return ConvertListViewToDGV2(lv);
			}
			DataGridView dataGridView = new DataGridView();
			dataGridView.ColumnCount = lv.Columns.Count;
			dataGridView.AllowUserToAddRows = false;
			try
			{
				dataGridView.DefaultCellStyle.Font = (Font)lv.Font.Clone();
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				ProjectData.ClearProjectError();
			}
			dataGridView.ForeColor = lv.ForeColor;
			dataGridView.DefaultCellStyle.ForeColor = lv.ForeColor;
			int num = 0;
			checked
			{
				int num2 = lv.Columns.Count - 1;
				for (int i = num; i <= num2; i++)
				{
					dataGridView.Columns[i].HeaderText = lv.Columns[i].Text;
					try
					{
						dataGridView.Columns[i].DefaultCellStyle.Font = (Font)lv.Font.Clone();
					}
					catch (Exception projectError2)
					{
						ProjectData.SetProjectError(projectError2);
						ProjectData.ClearProjectError();
					}
					dataGridView.Columns[i].Width = lv.Columns[i].Width;
					dataGridView.Columns[i].DisplayIndex = lv.Columns[i].DisplayIndex;
				}
				bool flag = false;
				int num3 = 0;
				int num4 = lv.Items.Count - 1;
				for (int j = num3; j <= num4; j++)
				{
					if (lv.Items[j].Group == null)
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					dataGridView.RowCount++;
					DataGridViewRow currow = dataGridView.Rows[dataGridView.RowCount - 1];
					CopyListViewGroutItemToDGV(lv, "Default", HorizontalAlignment.Left, currow);
					int num5 = 0;
					int num6 = lv.Items.Count - 1;
					for (int k = num5; k <= num6; k++)
					{
						if (lv.Items[k].Group == null)
						{
							dataGridView.RowCount++;
							currow = dataGridView.Rows[dataGridView.RowCount - 1];
							CopyListViewItemToDGV(lv, lv.Items[k], currow);
						}
					}
				}
				int num7 = 0;
				int num8 = lv.Groups.Count - 1;
				for (int l = num7; l <= num8; l++)
				{
					if (lv.Groups[l].Items.Count > 0)
					{
						dataGridView.RowCount++;
						DataGridViewRow currow2 = dataGridView.Rows[dataGridView.RowCount - 1];
						CopyListViewGroutItemToDGV(lv, lv.Groups[l].Header, lv.Groups[l].HeaderAlignment, currow2);
						int num9 = 0;
						int num10 = lv.Groups[l].Items.Count - 1;
						for (int m = num9; m <= num10; m++)
						{
							dataGridView.RowCount++;
							currow2 = dataGridView.Rows[dataGridView.RowCount - 1];
							CopyListViewItemToDGV(lv, lv.Groups[l].Items[m], currow2);
						}
					}
				}
				return dataGridView;
			}
		}

		private static void CopyListViewGroutItemToDGV(ListView lv, string mygroupname, HorizontalAlignment alg, DataGridViewRow currow)
		{
			try
			{
				currow.DefaultCellStyle.Font = new Font(lv.Font, FontStyle.Bold);
				currow.DefaultCellStyle.ForeColor = Color.Black;
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				ProjectData.ClearProjectError();
			}
			switch (alg)
			{
				case HorizontalAlignment.Right:
					currow.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
					break;
				case HorizontalAlignment.Center:
					currow.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
					break;
				default:
					currow.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;
					break;
			}
			int num = 0;
			checked
			{
				int num2 = lv.Columns.Count - 1;
				for (int i = num; i <= num2; i++)
				{
					currow.Cells[i].Value = mygroupname;
					currow.Cells[i].Tag = "水平合并";
				}
			}
		}

		private static void CopyListViewItemToDGV(ListView lv, ListViewItem myitem, DataGridViewRow myrow)
		{
			string text = myitem.Text;
			if (lv.CheckBoxes)
			{
				text = ((!myitem.Checked) ? ("□ " + text) : ("■ " + text));
			}
			myrow.Cells[0].Value = text;
			try
			{
				myrow.Cells[0].Style.Font = (Font)myitem.Font.Clone();
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				ProjectData.ClearProjectError();
			}
			myrow.Cells[0].Style.ForeColor = myitem.ForeColor;
			myrow.Cells[0].Style.BackColor = myitem.BackColor;
			try
			{
				myrow.DefaultCellStyle.Font = (Font)myitem.Font.Clone();
			}
			catch (Exception projectError2)
			{
				ProjectData.SetProjectError(projectError2);
				ProjectData.ClearProjectError();
			}
			myrow.DefaultCellStyle.BackColor = myitem.BackColor;
			myrow.DefaultCellStyle.ForeColor = myitem.ForeColor;
			int num = 1;
			checked
			{
				int num2 = lv.Columns.Count - 1;
				for (int i = num; i <= num2; i++)
				{
					if (i >= myitem.SubItems.Count)
					{
						continue;
					}
					myrow.Cells[i].Value = myitem.SubItems[i].Text;
					if (!myitem.UseItemStyleForSubItems)
					{
						try
						{
							myrow.Cells[i].Style.Font = (Font)myitem.SubItems[i].Font.Clone();
						}
						catch (Exception projectError3)
						{
							ProjectData.SetProjectError(projectError3);
							ProjectData.ClearProjectError();
						}
						myrow.Cells[i].Style.ForeColor = myitem.SubItems[i].ForeColor;
						myrow.Cells[i].Style.BackColor = myitem.SubItems[i].BackColor;
					}
				}
			}
		}

		public static string SaveHashTableAsString(Hashtable hh)
		{
			string text = "\u0003";
			string text2 = "\a";
			if (hh == null)
			{
				return "";
			}
			string[,] array = mbsjmodule.ParaseVar(hh);
			string text3 = "";
			if (array == null)
			{
				return "";
			}
			int num = 0;
			checked
			{
				int num2 = array.GetLength(0) - 1;
				for (int i = num; i <= num2; i++)
				{
					text3 = ((i != 0) ? (text3 + text + array[i, 0] + text2 + array[i, 1]) : (array[i, 0] + text2 + array[i, 1]));
				}
				return text3;
			}
		}

		public static Hashtable RestoreHashTableFromString(string ss)
		{
			if (Operators.CompareString(ss, "", TextCompare: false) == 0)
			{
				return null;
			}
			string delimiter = "\u0003";
			string delimiter2 = "\a";
			string[] array = Strings.Split(ss, delimiter);
			Hashtable hashtable = new Hashtable();
			int num = 0;
			checked
			{
				int num2 = array.Length - 1;
				for (int i = num; i <= num2; i++)
				{
					string[] array2 = Strings.Split(array[i], delimiter2);
					hashtable.Add(array2[0], array2[1]);
				}
				return hashtable;
			}
		}

		public static Font GetDGVHeaderFont(DataGridViewColumn mycolumn)
		{
			DataGridView dataGridView = mycolumn.DataGridView;
			if (mycolumn.HeaderCell.Style.Font != null)
			{
				return mycolumn.HeaderCell.Style.Font;
			}
			if (dataGridView.ColumnHeadersDefaultCellStyle.Font == null)
			{
				return dataGridView.DefaultCellStyle.Font;
			}
			return dataGridView.ColumnHeadersDefaultCellStyle.Font;
		}

		public static Color GetDGVHeaderForeColor(DataGridViewColumn mycolumn)
		{
			DataGridView dataGridView = mycolumn.DataGridView;
			if (mycolumn.HeaderCell.Style.ForeColor.ToArgb() == 0)
			{
				if (dataGridView.ColumnHeadersDefaultCellStyle.ForeColor.ToArgb() == 0)
				{
					return dataGridView.DefaultCellStyle.ForeColor;
				}
				return dataGridView.ColumnHeadersDefaultCellStyle.ForeColor;
			}
			return mycolumn.HeaderCell.Style.ForeColor;
		}

		public static bool GetDGVHeaderMulline(DataGridViewColumn mycolumn)
		{
			DataGridView dataGridView = mycolumn.DataGridView;
			if (mycolumn.HeaderCell.Style.WrapMode == DataGridViewTriState.NotSet)
			{
				if (dataGridView.ColumnHeadersDefaultCellStyle.WrapMode == DataGridViewTriState.NotSet)
				{
					return GetMulline(dataGridView.DefaultCellStyle.WrapMode);
				}
				return GetMulline(dataGridView.ColumnHeadersDefaultCellStyle.WrapMode);
			}
			return GetMulline(mycolumn.HeaderCell.Style.WrapMode);
		}

		public static Color GetDGVHeaderBackColor(DataGridViewColumn mycolumn)
		{
			DataGridView dataGridView = mycolumn.DataGridView;
			if (mycolumn.HeaderCell.Style.BackColor.ToArgb() == 0)
			{
				if (dataGridView.ColumnHeadersDefaultCellStyle.BackColor.ToArgb() == 0)
				{
					return dataGridView.DefaultCellStyle.BackColor;
				}
				return dataGridView.ColumnHeadersDefaultCellStyle.BackColor;
			}
			return mycolumn.HeaderCell.Style.BackColor;
		}

		public static Font GetDGVCellFont(DataGridViewCell mycell)
		{
			DataGridView dataGridView = mycell.DataGridView;
			int rowIndex = mycell.RowIndex;
			DataGridViewRow dataGridViewRow = dataGridView.Rows[mycell.RowIndex];
			DataGridViewColumn dataGridViewColumn = dataGridView.Columns[mycell.ColumnIndex];
			Font result;
			try
			{
				result = ((dataGridViewRow.Cells[dataGridViewColumn.Index].Style.Font != null) ? dataGridViewRow.Cells[dataGridViewColumn.Index].Style.Font : ((dataGridViewRow.DefaultCellStyle.Font != null) ? dataGridViewRow.DefaultCellStyle.Font : ((checked(rowIndex + 1) % 2 == 0) ? ((dataGridView.AlternatingRowsDefaultCellStyle.Font != null) ? dataGridView.AlternatingRowsDefaultCellStyle.Font : ((dataGridView.RowsDefaultCellStyle.Font != null) ? dataGridView.RowsDefaultCellStyle.Font : ((dataGridViewColumn.DefaultCellStyle.Font != null) ? dataGridViewColumn.DefaultCellStyle.Font : dataGridView.DefaultCellStyle.Font))) : ((dataGridView.RowsDefaultCellStyle.Font != null) ? dataGridView.RowsDefaultCellStyle.Font : ((dataGridViewColumn.DefaultCellStyle.Font != null) ? dataGridViewColumn.DefaultCellStyle.Font : dataGridView.DefaultCellStyle.Font)))));
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				result = dataGridView.DefaultCellStyle.Font;
				ProjectData.ClearProjectError();
			}
			dataGridView = null;
			return result;
		}

		public static Color GetDGVCellForeColor(DataGridViewCell mycell)
		{
			DataGridView dataGridView = mycell.DataGridView;
			int rowIndex = mycell.RowIndex;
			DataGridViewRow dataGridViewRow = dataGridView.Rows[mycell.RowIndex];
			DataGridViewColumn dataGridViewColumn = dataGridView.Columns[mycell.ColumnIndex];
			if (dataGridViewRow.Cells[dataGridViewColumn.Index].Style.ForeColor.ToArgb() == 0)
			{
				if (dataGridViewRow.DefaultCellStyle.ForeColor.ToArgb() == 0)
				{
					if (checked(rowIndex + 1) % 2 == 0)
					{
						if (dataGridView.AlternatingRowsDefaultCellStyle.ForeColor.ToArgb() == 0)
						{
							if (dataGridView.RowsDefaultCellStyle.ForeColor.ToArgb() == 0)
							{
								if (dataGridViewColumn.DefaultCellStyle.ForeColor.ToArgb() == 0)
								{
									return dataGridView.DefaultCellStyle.ForeColor;
								}
								return dataGridViewColumn.DefaultCellStyle.ForeColor;
							}
							return dataGridView.RowsDefaultCellStyle.ForeColor;
						}
						return dataGridView.AlternatingRowsDefaultCellStyle.ForeColor;
					}
					if (dataGridView.RowsDefaultCellStyle.ForeColor.ToArgb() == 0)
					{
						if (dataGridViewColumn.DefaultCellStyle.ForeColor.ToArgb() == 0)
						{
							return dataGridView.DefaultCellStyle.ForeColor;
						}
						return dataGridViewColumn.DefaultCellStyle.ForeColor;
					}
					return dataGridView.RowsDefaultCellStyle.ForeColor;
				}
				return dataGridViewRow.DefaultCellStyle.ForeColor;
			}
			return dataGridViewRow.Cells[dataGridViewColumn.Index].Style.ForeColor;
		}

		public static Color GetDGVCellBackColor(DataGridViewCell mycell)
		{
			DataGridView dataGridView = mycell.DataGridView;
			int rowIndex = mycell.RowIndex;
			DataGridViewRow dataGridViewRow = dataGridView.Rows[mycell.RowIndex];
			DataGridViewColumn dataGridViewColumn = dataGridView.Columns[mycell.ColumnIndex];
			if (dataGridViewRow.Cells[dataGridViewColumn.Index].Style.BackColor.ToArgb() == 0)
			{
				if (dataGridViewRow.DefaultCellStyle.BackColor.ToArgb() == 0)
				{
					if (checked(rowIndex + 1) % 2 == 0)
					{
						if (dataGridView.AlternatingRowsDefaultCellStyle.BackColor.ToArgb() == 0)
						{
							if (dataGridView.RowsDefaultCellStyle.BackColor.ToArgb() == 0)
							{
								if (dataGridViewColumn.DefaultCellStyle.BackColor.ToArgb() == 0)
								{
									return dataGridView.DefaultCellStyle.BackColor;
								}
								return dataGridViewColumn.DefaultCellStyle.BackColor;
							}
							return dataGridView.RowsDefaultCellStyle.BackColor;
						}
						return dataGridView.AlternatingRowsDefaultCellStyle.BackColor;
					}
					if (dataGridView.RowsDefaultCellStyle.BackColor.ToArgb() == 0)
					{
						if (dataGridViewColumn.DefaultCellStyle.BackColor.ToArgb() == 0)
						{
							return dataGridView.DefaultCellStyle.BackColor;
						}
						return dataGridViewColumn.DefaultCellStyle.BackColor;
					}
					return dataGridView.RowsDefaultCellStyle.BackColor;
				}
				return dataGridViewRow.DefaultCellStyle.BackColor;
			}
			return dataGridViewRow.Cells[dataGridViewColumn.Index].Style.BackColor;
		}

		public static bool GetDGVCellMulline(DataGridViewCell mycell)
		{
			DataGridView dataGridView = mycell.DataGridView;
			int rowIndex = mycell.RowIndex;
			DataGridViewRow dataGridViewRow = dataGridView.Rows[mycell.RowIndex];
			DataGridViewColumn dataGridViewColumn = dataGridView.Columns[mycell.ColumnIndex];
			if (dataGridViewRow.Cells[dataGridViewColumn.Index].Style.WrapMode == DataGridViewTriState.NotSet)
			{
				if (dataGridViewRow.DefaultCellStyle.WrapMode == DataGridViewTriState.NotSet)
				{
					if (checked(rowIndex + 1) % 2 == 0)
					{
						if (dataGridView.AlternatingRowsDefaultCellStyle.WrapMode == DataGridViewTriState.NotSet)
						{
							if (dataGridView.RowsDefaultCellStyle.WrapMode == DataGridViewTriState.NotSet)
							{
								if (dataGridViewColumn.DefaultCellStyle.WrapMode == DataGridViewTriState.NotSet)
								{
									return GetMulline(dataGridView.DefaultCellStyle.WrapMode);
								}
								return GetMulline(dataGridViewColumn.DefaultCellStyle.WrapMode);
							}
							return GetMulline(dataGridView.RowsDefaultCellStyle.WrapMode);
						}
						return GetMulline(dataGridView.AlternatingRowsDefaultCellStyle.WrapMode);
					}
					if (dataGridView.RowsDefaultCellStyle.WrapMode == DataGridViewTriState.NotSet)
					{
						if (dataGridViewColumn.DefaultCellStyle.WrapMode == DataGridViewTriState.NotSet)
						{
							return GetMulline(dataGridView.DefaultCellStyle.WrapMode);
						}
						return GetMulline(dataGridViewColumn.DefaultCellStyle.WrapMode);
					}
					return GetMulline(dataGridView.RowsDefaultCellStyle.WrapMode);
				}
				return GetMulline(dataGridViewRow.DefaultCellStyle.WrapMode);
			}
			return GetMulline(dataGridViewRow.Cells[dataGridViewColumn.Index].Style.WrapMode);
		}

		public static Margins GetDGVCellPadding(DataGridViewCell mycell)
		{
			Margins margins = new Margins();
			DataGridView dataGridView = mycell.DataGridView;
			int rowIndex = mycell.RowIndex;
			DataGridViewRow dataGridViewRow = dataGridView.Rows[mycell.RowIndex];
			DataGridViewColumn dataGridViewColumn = dataGridView.Columns[mycell.ColumnIndex];
			if (dataGridViewRow.Cells[dataGridViewColumn.Index].Style.Padding.All == 0)
			{
				if (dataGridViewRow.DefaultCellStyle.Padding.All == 0)
				{
					if (checked(rowIndex + 1) % 2 == 0)
					{
						if (dataGridView.AlternatingRowsDefaultCellStyle.Padding.All == 0)
						{
							if (dataGridView.RowsDefaultCellStyle.Padding.All == 0)
							{
								if (dataGridViewColumn.DefaultCellStyle.Padding.All == 0)
								{
									margins.Left = dataGridView.DefaultCellStyle.Padding.Left;
									margins.Top = dataGridView.DefaultCellStyle.Padding.Top;
									margins.Right = dataGridView.DefaultCellStyle.Padding.Right;
									margins.Bottom = dataGridView.DefaultCellStyle.Padding.Bottom;
								}
								else
								{
									margins.Left = dataGridViewColumn.DefaultCellStyle.Padding.Left;
									margins.Top = dataGridViewColumn.DefaultCellStyle.Padding.Top;
									margins.Right = dataGridViewColumn.DefaultCellStyle.Padding.Right;
									margins.Bottom = dataGridViewColumn.DefaultCellStyle.Padding.Bottom;
								}
							}
							else
							{
								margins.Left = dataGridView.RowsDefaultCellStyle.Padding.Left;
								margins.Top = dataGridView.RowsDefaultCellStyle.Padding.Top;
								margins.Right = dataGridView.RowsDefaultCellStyle.Padding.Right;
								margins.Bottom = dataGridView.RowsDefaultCellStyle.Padding.Bottom;
							}
						}
						else
						{
							margins.Left = dataGridView.AlternatingRowsDefaultCellStyle.Padding.Left;
							margins.Top = dataGridView.AlternatingRowsDefaultCellStyle.Padding.Top;
							margins.Right = dataGridView.AlternatingRowsDefaultCellStyle.Padding.Right;
							margins.Bottom = dataGridView.AlternatingRowsDefaultCellStyle.Padding.Bottom;
						}
					}
					else if (dataGridView.RowsDefaultCellStyle.Padding.All == 0)
					{
						if (dataGridViewColumn.DefaultCellStyle.Padding.All == 0)
						{
							margins.Left = dataGridView.DefaultCellStyle.Padding.Left;
							margins.Top = dataGridView.DefaultCellStyle.Padding.Top;
							margins.Right = dataGridView.DefaultCellStyle.Padding.Right;
							margins.Bottom = dataGridView.DefaultCellStyle.Padding.Bottom;
						}
						else
						{
							margins.Left = dataGridViewColumn.DefaultCellStyle.Padding.Left;
							margins.Top = dataGridViewColumn.DefaultCellStyle.Padding.Top;
							margins.Right = dataGridViewColumn.DefaultCellStyle.Padding.Right;
							margins.Bottom = dataGridViewColumn.DefaultCellStyle.Padding.Bottom;
						}
					}
					else
					{
						margins.Left = dataGridView.RowsDefaultCellStyle.Padding.Left;
						margins.Top = dataGridView.RowsDefaultCellStyle.Padding.Top;
						margins.Right = dataGridView.RowsDefaultCellStyle.Padding.Right;
						margins.Bottom = dataGridView.RowsDefaultCellStyle.Padding.Bottom;
					}
				}
				else
				{
					margins.Left = dataGridViewRow.DefaultCellStyle.Padding.Left;
					margins.Top = dataGridViewRow.DefaultCellStyle.Padding.Top;
					margins.Right = dataGridViewRow.DefaultCellStyle.Padding.Right;
					margins.Bottom = dataGridViewRow.DefaultCellStyle.Padding.Bottom;
				}
			}
			else
			{
				margins.Left = dataGridViewRow.Cells[dataGridViewColumn.Index].Style.Padding.Left;
				margins.Top = dataGridViewRow.Cells[dataGridViewColumn.Index].Style.Padding.Top;
				margins.Right = dataGridViewRow.Cells[dataGridViewColumn.Index].Style.Padding.Right;
				margins.Bottom = dataGridViewRow.Cells[dataGridViewColumn.Index].Style.Padding.Bottom;
			}
			return margins;
		}

		public static DataGridViewCellStyle GetDGVCellStyle(DataGridViewCell mycell)
		{
			DataGridView dataGridView = mycell.DataGridView;
			int rowIndex = mycell.RowIndex;
			DataGridViewRow dataGridViewRow = dataGridView.Rows[mycell.RowIndex];
			DataGridViewColumn dataGridViewColumn = dataGridView.Columns[mycell.ColumnIndex];
			if (dataGridViewRow.Cells[dataGridViewColumn.Index].Style.Alignment == DataGridViewContentAlignment.NotSet)
			{
				if (dataGridViewRow.DefaultCellStyle.Alignment == DataGridViewContentAlignment.NotSet)
				{
					if (checked(rowIndex + 1) % 2 == 0)
					{
						if (dataGridView.AlternatingRowsDefaultCellStyle.Alignment == DataGridViewContentAlignment.NotSet)
						{
							if (dataGridView.RowsDefaultCellStyle.Alignment == DataGridViewContentAlignment.NotSet)
							{
								if (dataGridViewColumn.DefaultCellStyle.Alignment == DataGridViewContentAlignment.NotSet)
								{
									return dataGridView.DefaultCellStyle;
								}
								return dataGridViewColumn.DefaultCellStyle;
							}
							return dataGridView.RowsDefaultCellStyle;
						}
						return dataGridView.AlternatingRowsDefaultCellStyle;
					}
					if (dataGridView.RowsDefaultCellStyle.Alignment == DataGridViewContentAlignment.NotSet)
					{
						if (dataGridViewColumn.DefaultCellStyle.Alignment == DataGridViewContentAlignment.NotSet)
						{
							return dataGridView.DefaultCellStyle;
						}
						return dataGridViewColumn.DefaultCellStyle;
					}
					return dataGridView.RowsDefaultCellStyle;
				}
				return dataGridViewRow.DefaultCellStyle;
			}
			return dataGridViewRow.Cells[dataGridViewColumn.Index].Style;
		}

		public static StringAlignment GetHAlignment(DataGridViewContentAlignment mytt)
		{
			switch (mytt)
			{
				default:
					return StringAlignment.Near;
				case DataGridViewContentAlignment.TopRight:
				case DataGridViewContentAlignment.MiddleRight:
				case DataGridViewContentAlignment.BottomRight:
					return StringAlignment.Far;
				case DataGridViewContentAlignment.NotSet:
				case DataGridViewContentAlignment.TopLeft:
				case DataGridViewContentAlignment.MiddleLeft:
				case DataGridViewContentAlignment.BottomLeft:
					return StringAlignment.Near;
				case DataGridViewContentAlignment.TopCenter:
				case DataGridViewContentAlignment.MiddleCenter:
				case DataGridViewContentAlignment.BottomCenter:
					return StringAlignment.Center;
			}
		}

		public static StringAlignment GetVAlignment(DataGridViewContentAlignment mytt, bool IsDGVCellValignmentCenter)
		{
			if (IsDGVCellValignmentCenter)
			{
				return StringAlignment.Center;
			}
			switch (mytt)
			{
				default:
					return StringAlignment.Center;
				case DataGridViewContentAlignment.NotSet:
				case DataGridViewContentAlignment.TopLeft:
				case DataGridViewContentAlignment.TopCenter:
				case DataGridViewContentAlignment.TopRight:
					return StringAlignment.Near;
				case DataGridViewContentAlignment.MiddleLeft:
				case DataGridViewContentAlignment.MiddleCenter:
				case DataGridViewContentAlignment.MiddleRight:
					return StringAlignment.Center;
				case DataGridViewContentAlignment.BottomLeft:
				case DataGridViewContentAlignment.BottomCenter:
				case DataGridViewContentAlignment.BottomRight:
					return StringAlignment.Far;
			}
		}

		public static bool GetMulline(DataGridViewTriState mytt)
		{
			switch (mytt)
			{
				case DataGridViewTriState.NotSet:
				case DataGridViewTriState.False:
					return false;
				default:
					return true;
			}
		}

		public static Font GetDGVColumnHeaderFont(DataGridView dgv, string colname)
		{
			if (dgv == null)
			{
				return null;
			}
			DataGridViewColumn dataGridViewColumn;
			try
			{
				dataGridViewColumn = dgv.Columns[colname];
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				Font result = null;
				ProjectData.ClearProjectError();
				return result;
			}
			if (dataGridViewColumn == null)
			{
				return null;
			}
			return (dataGridViewColumn.HeaderCell.Style.Font != null) ? dataGridViewColumn.HeaderCell.Style.Font : ((dgv.ColumnHeadersDefaultCellStyle.Font != null) ? dgv.ColumnHeadersDefaultCellStyle.Font : dgv.DefaultCellStyle.Font);
		}

		public static Color GetDGVColumnHeaderForeColor(DataGridView dgv, string colname)
		{
			if (dgv == null)
			{
				return Color.Black;
			}
			DataGridViewColumn dataGridViewColumn;
			try
			{
				dataGridViewColumn = dgv.Columns[colname];
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				Color black = Color.Black;
				ProjectData.ClearProjectError();
				return black;
			}
			if (dataGridViewColumn == null)
			{
				return Color.Black;
			}
			return (dataGridViewColumn.HeaderCell.Style.ForeColor.ToArgb() != 0) ? dataGridViewColumn.HeaderCell.Style.ForeColor : ((dgv.ColumnHeadersDefaultCellStyle.ForeColor.ToArgb() != 0) ? dgv.ColumnHeadersDefaultCellStyle.ForeColor : dgv.DefaultCellStyle.ForeColor);
		}

		public static Color GetDGVColumnHeaderBackColor(DataGridView dgv, string colname)
		{
			if (dgv == null)
			{
				return Color.White;
			}
			DataGridViewColumn dataGridViewColumn;
			try
			{
				dataGridViewColumn = dgv.Columns[colname];
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				Color white = Color.White;
				ProjectData.ClearProjectError();
				return white;
			}
			if (dataGridViewColumn == null)
			{
				return Color.White;
			}
			return (dataGridViewColumn.HeaderCell.Style.BackColor.ToArgb() != 0) ? dataGridViewColumn.HeaderCell.Style.BackColor : ((dgv.ColumnHeadersDefaultCellStyle.BackColor.ToArgb() != 0) ? dgv.ColumnHeadersDefaultCellStyle.BackColor : dgv.DefaultCellStyle.BackColor);
		}

		public static Font GetDGVColumnFont(DataGridView dgv, string colname)
		{
			if (dgv == null)
			{
				return null;
			}
			DataGridViewColumn dataGridViewColumn;
			try
			{
				dataGridViewColumn = dgv.Columns[colname];
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				Font result = null;
				ProjectData.ClearProjectError();
				return result;
			}
			if (dataGridViewColumn == null)
			{
				return null;
			}
			return (dgv.RowsDefaultCellStyle.Font != null) ? dgv.RowsDefaultCellStyle.Font : ((dataGridViewColumn.DefaultCellStyle.Font != null) ? dataGridViewColumn.DefaultCellStyle.Font : dgv.DefaultCellStyle.Font);
		}

		public static Color GetDGVColumnForeColor(DataGridView dgv, string colname)
		{
			if (dgv == null)
			{
				return Color.Black;
			}
			DataGridViewColumn dataGridViewColumn;
			try
			{
				dataGridViewColumn = dgv.Columns[colname];
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				Color black = Color.Black;
				ProjectData.ClearProjectError();
				return black;
			}
			if (dataGridViewColumn == null)
			{
				return Color.Black;
			}
			return (dgv.RowsDefaultCellStyle.ForeColor.ToArgb() != 0) ? dgv.RowsDefaultCellStyle.ForeColor : ((dataGridViewColumn.DefaultCellStyle.ForeColor.ToArgb() != 0) ? dataGridViewColumn.DefaultCellStyle.ForeColor : dgv.DefaultCellStyle.ForeColor);
		}

		public static Color GetDGVColumnBackColor(DataGridView dgv, string colname)
		{
			if (dgv == null)
			{
				return Color.Black;
			}
			DataGridViewColumn dataGridViewColumn;
			try
			{
				dataGridViewColumn = dgv.Columns[colname];
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				Color black = Color.Black;
				ProjectData.ClearProjectError();
				return black;
			}
			if (dataGridViewColumn == null)
			{
				return Color.Black;
			}
			return (dgv.RowsDefaultCellStyle.BackColor.ToArgb() != 0) ? dgv.RowsDefaultCellStyle.BackColor : ((dataGridViewColumn.DefaultCellStyle.BackColor.ToArgb() != 0) ? dataGridViewColumn.DefaultCellStyle.BackColor : dgv.DefaultCellStyle.BackColor);
		}

		public static bool GetDGVColumnMulLine(DataGridView dgv, string colname)
		{
			if (dgv == null)
			{
				return false;
			}
			DataGridViewColumn dataGridViewColumn;
			try
			{
				dataGridViewColumn = dgv.Columns[colname];
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				bool result = false;
				ProjectData.ClearProjectError();
				return result;
			}
			if (dataGridViewColumn == null)
			{
				return false;
			}
			return (dgv.RowsDefaultCellStyle.WrapMode != 0) ? GetMulline(dgv.RowsDefaultCellStyle.WrapMode) : ((dataGridViewColumn.DefaultCellStyle.WrapMode != 0) ? GetMulline(dataGridViewColumn.DefaultCellStyle.WrapMode) : GetMulline(dgv.DefaultCellStyle.WrapMode));
		}

		public static ContentAlignment GetDGVColumnAlignment(DataGridView dgv, string colname)
		{
			if (dgv == null)
			{
				return ContentAlignment.MiddleLeft;
			}
			DataGridViewColumn dataGridViewColumn;
			try
			{
				dataGridViewColumn = dgv.Columns[colname];
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				ContentAlignment result1 = ContentAlignment.MiddleLeft;
				ProjectData.ClearProjectError();
				return result1;
			}
			if (dataGridViewColumn == null)
			{
				return ContentAlignment.MiddleLeft;
			}
			DataGridViewCellStyle dataGridViewCellStyle = ((dgv.RowsDefaultCellStyle.Alignment != 0) ? dgv.RowsDefaultCellStyle : ((dataGridViewColumn.DefaultCellStyle.Alignment != 0) ? dataGridViewColumn.DefaultCellStyle : dgv.DefaultCellStyle));

			ContentAlignment result;
			DataGridViewContentAlignment alignment = dataGridViewCellStyle.Alignment;
			if (alignment == DataGridViewContentAlignment.BottomCenter)
			{
				result = ContentAlignment.BottomCenter;
			}
			else if (alignment == DataGridViewContentAlignment.BottomLeft)
			{
				result = ContentAlignment.BottomLeft;
			}
			else if (alignment == DataGridViewContentAlignment.BottomRight)
			{
				result = ContentAlignment.BottomRight;
			}
			else if (alignment == DataGridViewContentAlignment.MiddleCenter)
			{
				result = ContentAlignment.MiddleCenter;
			}
			else if (alignment == DataGridViewContentAlignment.MiddleLeft)
			{
				result = ContentAlignment.MiddleLeft;
			}
			else if (alignment == DataGridViewContentAlignment.MiddleRight)
			{
				result = ContentAlignment.MiddleRight;
			}
			else if (alignment == DataGridViewContentAlignment.NotSet)
			{
				result = ContentAlignment.MiddleLeft;
			}
			else if (alignment == DataGridViewContentAlignment.TopCenter)
			{
				result = ContentAlignment.TopCenter;
			}
			else if (alignment == DataGridViewContentAlignment.TopLeft)
			{
				result = ContentAlignment.TopLeft;
			}
			else if (alignment == DataGridViewContentAlignment.TopRight)
			{
				result = ContentAlignment.TopRight;
			}
			else
			{
				result = ContentAlignment.MiddleLeft;
			}
			return result;
		}

		public static string EncryptionString(string ss)
		{
			byte[] bytes = Encoding.Unicode.GetBytes(ss);
			MemoryStream memoryStream = new MemoryStream();
			CryptoStream cryptoStream = new CryptoStream(memoryStream, new TripleDESCryptoServiceProvider
			{
				Key = G_mykey,
				IV = G_myiv
			}.CreateEncryptor(), CryptoStreamMode.Write);
			cryptoStream.Write(bytes, 0, bytes.Length);
			cryptoStream.Close();
			string result = Convert.ToBase64String(memoryStream.ToArray());
			memoryStream.Dispose();
			return result;
		}

		public static string DecryptionString(string ss)
		{
			TripleDESCryptoServiceProvider tripleDESCryptoServiceProvider = new TripleDESCryptoServiceProvider();
			MemoryStream memoryStream = new MemoryStream();
			tripleDESCryptoServiceProvider.Key = G_mykey;
			tripleDESCryptoServiceProvider.IV = G_myiv;
			CryptoStream cryptoStream = new CryptoStream(memoryStream, tripleDESCryptoServiceProvider.CreateDecryptor(), CryptoStreamMode.Write);
			byte[] array = Convert.FromBase64String(ss);
			cryptoStream.Write(array, 0, array.Length);
			cryptoStream.Close();
			string @string = Encoding.Unicode.GetString(memoryStream.ToArray());
			memoryStream.Dispose();
			return @string;
		}

		public static Bitmap getDGVCheckBoxCellImage(DataGridViewCell dgvcell, Color mybkcolor)
		{
			Bitmap result;
			if (dgvcell == null)
			{
				result = null;
			}
			else
			{
				CheckBox checkBox = new CheckBox();
				Control control = checkBox;
				Size size = new Size(14, 14);
				control.Size = size;
				checkBox.BackColor = mybkcolor;
				if (dgvcell.FormattedValue != null)
				{
					if (Operators.CompareString(Versioned.TypeName(RuntimeHelpers.GetObjectValue(dgvcell.FormattedValue)), "Boolean", TextCompare: false) == 0)
					{
						if (Conversions.ToBoolean(dgvcell.FormattedValue))
						{
							checkBox.Checked = true;
						}
						else
						{
							checkBox.Checked = false;
						}
					}
					else
					{
						switch (Conversions.ToInteger(dgvcell.FormattedValue))
						{
							case 0:
								checkBox.Checked = false;
								break;
							case 1:
								checkBox.Checked = true;
								break;
							default:
								checkBox.CheckState = CheckState.Indeterminate;
								break;
						}
					}
				}
				else
				{
					checkBox.Checked = false;
				}
				try
				{
					Bitmap bitmap = new Bitmap(14, 14);
					Graphics graphics = Graphics.FromImage(bitmap);
					Brush brush = new SolidBrush(mybkcolor);
					Graphics graphics2 = graphics;
					Brush brush2 = brush;
					Rectangle rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
					graphics2.FillRectangle(brush2, rect);
					if (bitmap.Height < checkBox.Height)
					{
						checkBox.Height = bitmap.Height;
					}
					if (bitmap.Width < checkBox.Width)
					{
						checkBox.Width = bitmap.Width;
					}
					Control control2 = checkBox;
					Bitmap bitmap2 = bitmap;
					rect = checked(new Rectangle((int)Math.Round((double)(bitmap.Width - checkBox.Width) / 2.0), (int)Math.Round((double)(bitmap.Height - checkBox.Height) / 2.0), checkBox.Width, checkBox.Height));
					control2.DrawToBitmap(bitmap2, rect);
					graphics.Dispose();
					checkBox.Dispose();
					result = bitmap;
				}
				catch (Exception projectError)
				{
					ProjectData.SetProjectError(projectError);
					result = null;
					ProjectData.ClearProjectError();
				}
			}
			return result;
		}
	}
}