using System;
using System.Drawing;
using System.Windows.Forms;

namespace GoldPrinter
{
	public class DrawGrid : GoldGrid, IDraw, IDisposable
	{
		private Graphics _graphics;

		private Rectangle _rectangle;

		private Brush _brush;

		private Pen _pen;

		public Graphics Graphics
		{
			get
			{
				return this._graphics;
			}
			set
			{
				this._graphics = value;
			}
		}

		public Rectangle Rectangle
		{
			get
			{
				return this._rectangle;
			}
			set
			{
				this._rectangle = value;
			}
		}

		public Pen Pen
		{
			get
			{
				return this._pen;
			}
			set
			{
				if (value != null)
				{
					this._pen = value;
				}
			}
		}

		public Brush Brush
		{
			get
			{
				return this._brush;
			}
			set
			{
				if (value != null)
				{
					this._brush = value;
				}
			}
		}

		public DrawGrid()
		{
			this._pen = new Pen(Color.Black);
			this._brush = Brushes.Black;
		}

		public DrawGrid(int rows, int cols)
		{
			base.Initialize(rows, cols);
		}

		public override void Dispose()
		{
			base.Dispose();
			this._graphics.Dispose();
		}

		public void DrawGridLine()
		{
			this.DrawGridLine(this._graphics, this._rectangle, this.Pen, base.GridText, base.PreferredRowHeight, base.ColsWidth, base.Line, base.Border, new PointF(1f, 1f), base.Merge);
		}

		public void DrawGridText()
		{
			this.DrawGridText(this._graphics, this._rectangle, this.Brush, base.GridText, base.PreferredRowHeight, base.ColsWidth, base.ColsAlignString, base.Font, new PointF(1f, 1f), base.Merge);
		}

		public void DrawGridBorder()
		{
			this.DrawGridBorder(this._graphics, this._rectangle, this.Pen, base.Border);
		}

		public void Draw()
		{
			this.DrawGridLine();
			this.DrawGridText();
			this.DrawGridBorder();
		}

		protected void DrawGridLine(Graphics g, Rectangle p_rec, Pen p_pen, int p_rows, int p_cols, int p_rowHeight, int[] p_arrColsWidth, GridLineFlag p_gridLineFlag, GridBorderFlag p_gridBorderFlag, PointF p_scaleXY)
		{
			Rectangle rectangle = new Rectangle(p_rec.X, p_rec.Y, p_rec.Width, p_rec.Height);
			this.TransGrid(g, rectangle, p_scaleXY);
			if (p_gridLineFlag != GridLineFlag.None)
			{
				int width = rectangle.Width;
				int height = rectangle.Height;
				if (p_gridLineFlag == GridLineFlag.Horizontal || p_gridLineFlag == GridLineFlag.Both)
				{
					int num = rectangle.X;
					int num2 = rectangle.Y;
					int x = num + width;
					for (int i = 1; i < p_rows; i++)
					{
						num2 += p_rowHeight;
						int y = num2;
						g.DrawLine(p_pen, num, num2, x, y);
					}
				}
				if (p_gridLineFlag == GridLineFlag.Vertical || p_gridLineFlag == GridLineFlag.Both)
				{
					int[] array = new int[p_cols];
					int num = rectangle.X;
					int num2 = rectangle.Y;
					int y = num2 + height;
					for (int j = 0; j < p_cols - 1; j++)
					{
						num += p_arrColsWidth[j];
						int x = num;
						g.DrawLine(p_pen, num, num2, x, y);
					}
				}
			}
			if (p_gridBorderFlag != GridBorderFlag.None)
			{
				this.DrawGridBorder(g, rectangle, p_pen, p_gridBorderFlag);
			}
			this.ResetTransGrid();
		}

		protected void DrawGridLine(Graphics g, Rectangle p_rec, Pen p_pen, string[,] arrStrGrid, int p_rowHeight, int[] p_arrColsWidth, GridLineFlag p_gridLineFlag, GridBorderFlag p_gridBorderFlag, PointF p_scaleXY)
		{
			int length = arrStrGrid.GetLength(0);
			int length2 = arrStrGrid.GetLength(1);
			this.DrawGridLine(g, p_rec, p_pen, length, length2, p_rowHeight, p_arrColsWidth, p_gridLineFlag, p_gridBorderFlag, p_scaleXY);
		}

		protected void DrawGridMergeLine(Graphics g, Rectangle p_rec, Pen p_pen, string[,] arrStrGrid, int p_rowHeight, int[] p_arrColsWidth, GridLineFlag p_gridLineFlag, GridBorderFlag p_gridBorderFlag, PointF p_scaleXY, GridMergeFlag gridMergeFlag)
		{
			Rectangle rectangle = new Rectangle(p_rec.X, p_rec.Y, p_rec.Width, p_rec.Height);
			int length = arrStrGrid.GetLength(0);
			int length2 = arrStrGrid.GetLength(1);
			if (gridMergeFlag == GridMergeFlag.None)
			{
				this.DrawGridLine(g, rectangle, p_pen, length, length2, p_rowHeight, p_arrColsWidth, p_gridLineFlag, p_gridBorderFlag, p_scaleXY);
			}
			else if (p_gridLineFlag != GridLineFlag.None)
			{
				this.TransGrid(g, rectangle, p_scaleXY);
				int[] array = new int[length2];
				for (int i = 0; i < length; i++)
				{
					int num = rectangle.X;
					int num2 = rectangle.Y;
					for (int j = 0; j < length2; j++)
					{
						int x = num + p_arrColsWidth[j];
						num2 = rectangle.Y + p_rowHeight * i;
						int num3 = num2;
						if (i > 0)
						{
							if (gridMergeFlag == GridMergeFlag.Any)
							{
								if (arrStrGrid[i, j] == "" || arrStrGrid[i, j] != arrStrGrid[i - 1, j])
								{
									g.DrawLine(p_pen, num, num2, x, num3);
								}
							}
						}
						if (j > 0)
						{
							num3 += p_rowHeight;
							x = num;
							if (gridMergeFlag == GridMergeFlag.Any)
							{
								if (arrStrGrid[i, j] == "" || arrStrGrid[i, j] != arrStrGrid[i, j - 1])
								{
									g.DrawLine(p_pen, num, num2, x, num3);
								}
							}
						}
						num += p_arrColsWidth[j];
					}
				}
				if (p_gridBorderFlag != GridBorderFlag.None)
				{
					this.DrawGridBorder(g, rectangle, p_pen, p_gridBorderFlag);
				}
				this.ResetTransGrid();
			}
		}

		protected void DrawGridText(Graphics g, Rectangle p_rec, Brush p_brush, string[,] arrStrGrid, int p_rowHeight, int[] p_arrColsWidth, string alignment, Font p_font, PointF p_scaleXY)
		{
			try
			{
				Rectangle p_rec2 = new Rectangle(p_rec.X, p_rec.Y, p_rec.Width, p_rec.Height);
				Font font = p_font;
				if (font == null)
				{
					font = new Font("宋体", 12f);
				}
				int length = arrStrGrid.GetLength(0);
				int length2 = arrStrGrid.GetLength(1);
				int[] array = new int[length2];
				AlignFlag[] colsAlign = this.GetColsAlign(alignment);
				this.TransGrid(g, p_rec2, p_scaleXY);
				StringFormat stringFormat = new StringFormat();
				stringFormat.LineAlignment = StringAlignment.Center;
				stringFormat.FormatFlags = (StringFormatFlags.NoWrap | StringFormatFlags.LineLimit);
				for (int i = 0; i < length; i++)
				{
					int num = p_rec2.X;
					int y = p_rec2.Y + p_rowHeight * i;
					for (int j = 0; j < length2; j++)
					{
						int num2 = p_arrColsWidth[j];
						Rectangle r = new Rectangle(num, y, num2, p_rowHeight + 4);
						stringFormat.Alignment = StringAlignment.Near;
						if (colsAlign.Length > j)
						{
							if (colsAlign[j] == AlignFlag.Center)
							{
								stringFormat.Alignment = StringAlignment.Center;
							}
							else if (colsAlign[j] == AlignFlag.Right)
							{
								stringFormat.Alignment = StringAlignment.Far;
							}
						}
						g.DrawString(arrStrGrid[i, j], font, p_brush, r, stringFormat);
						num += num2;
					}
				}
				this.ResetTransGrid();
			}
			catch (Exception ex)
			{
				MessageBox.Show(ex.Message);
			}
			finally
			{
			}
		}

		protected void DrawGridMergeText(Graphics g, Rectangle p_rec, Brush p_brush, string[,] arrStrGrid, int p_rowHeight, int[] p_arrColsWidth, string alignment, Font p_font, PointF p_scaleXY, GridMergeFlag gridMergeFlag)
		{
			if (gridMergeFlag == GridMergeFlag.None)
			{
				this.DrawGridText(g, p_rec, p_brush, arrStrGrid, p_rowHeight, p_arrColsWidth, alignment, p_font, p_scaleXY);
			}
			else
			{
				try
				{
					Rectangle p_rec2 = new Rectangle(p_rec.X, p_rec.Y, p_rec.Width, p_rec.Height);
					Font font = p_font;
					if (font == null)
					{
						font = new Font("宋体", 12f);
					}
					int length = arrStrGrid.GetLength(0);
					int length2 = arrStrGrid.GetLength(1);
					int[] array = new int[length2];
					AlignFlag[] colsAlign = this.GetColsAlign(alignment);
					this.TransGrid(g, p_rec2, p_scaleXY);
					StringFormat stringFormat = new StringFormat();
					stringFormat.LineAlignment = StringAlignment.Center;
					stringFormat.FormatFlags = (StringFormatFlags.NoWrap | StringFormatFlags.LineLimit);
					CellRectangle mergeCell = new CellRectangle(p_rec2.X, p_rec2.Y, 0, p_rowHeight);
					for (int i = 0; i < length; i++)
					{
						for (int j = 0; j < length2; j++)
						{
							mergeCell = this.GetMergeCell(new Point(p_rec2.X, p_rec2.Y), arrStrGrid, p_rowHeight, p_arrColsWidth, i, j);
							Rectangle r = new Rectangle(mergeCell.Left, mergeCell.Top, mergeCell.Width, mergeCell.Height + 4);
							stringFormat.Alignment = StringAlignment.Near;
							if (colsAlign.Length > j)
							{
								if (colsAlign[j] == AlignFlag.Center)
								{
									stringFormat.Alignment = StringAlignment.Center;
								}
								else if (colsAlign[j] == AlignFlag.Right)
								{
									stringFormat.Alignment = StringAlignment.Far;
								}
							}
							g.DrawString(arrStrGrid[i, j], font, p_brush, r, stringFormat);
						}
					}
					this.ResetTransGrid();
				}
				catch (Exception ex)
				{
					MessageBox.Show(ex.Message);
				}
				finally
				{
				}
			}
		}

		protected void DrawGridBorder(Graphics g, Rectangle rec, Pen p_pen, GridBorderFlag p_gridBorderFlag)
		{
			if (p_gridBorderFlag != GridBorderFlag.None)
			{
				float width = 1f;
				int num = 0;
				switch (p_gridBorderFlag)
				{
				case GridBorderFlag.SingleBold:
					width = 2f;
					break;
				case GridBorderFlag.Double:
					g.DrawRectangle(p_pen, rec);
					num = 2;
					break;
				case GridBorderFlag.DoubleBold:
					g.DrawRectangle(p_pen, rec);
					width = 2f;
					num = 3;
					break;
				}
				Pen pen = (Pen)p_pen.Clone();
				pen.Width = width;
				Rectangle rect = rec;
				rect.X = rec.X - num;
				rect.Y = rec.Y - num;
				rect.Width = rec.Width + num * 2;
				rect.Height = rec.Height + num * 2;
				g.DrawRectangle(pen, rect);
				pen.Dispose();
			}
		}

		private void TransGrid(Graphics g, Rectangle p_rec, PointF p_scaleXY)
		{
			if (!p_scaleXY.IsEmpty)
			{
				g.ScaleTransform(p_scaleXY.X, p_scaleXY.Y);
			}
		}

		private void ResetTransGrid()
		{
		}

		protected void DrawGridLine(Graphics g, Rectangle p_rec, Pen p_pen, string[,] arrStrGrid, int p_rowHeight, int[] p_arrColsWidth, GridLineFlag p_gridLineFlag, GridBorderFlag p_gridBorderFlag, PointF p_scaleXY, GridMergeFlag gridMergeFlag)
		{
			Rectangle rectangle = new Rectangle(p_rec.X, p_rec.Y, p_rec.Width, p_rec.Height);
			int length = arrStrGrid.GetLength(0);
			int length2 = arrStrGrid.GetLength(1);
			if (gridMergeFlag == GridMergeFlag.None)
			{
				this.DrawGridLine(g, rectangle, p_pen, length, length2, p_rowHeight, p_arrColsWidth, p_gridLineFlag, p_gridBorderFlag, p_scaleXY);
			}
			else if (p_gridLineFlag != GridLineFlag.None)
			{
				this.TransGrid(g, rectangle, p_scaleXY);
				int[] array = new int[length2];
				for (int i = 0; i < length; i++)
				{
					int num = rectangle.X;
					int num2 = rectangle.Y;
					for (int j = 0; j < length2; j++)
					{
						int x = num + p_arrColsWidth[j];
						num2 = rectangle.Y + p_rowHeight * i;
						int num3 = num2;
						if (i > 0)
						{
							switch (gridMergeFlag)
							{
							case GridMergeFlag.None:
								g.DrawLine(p_pen, num, num2, x, num3);
								break;
							case GridMergeFlag.Row:
								g.DrawLine(p_pen, num, num2, x, num3);
								break;
							case GridMergeFlag.Col:
								if (arrStrGrid[i, j] == "" || arrStrGrid[i, j] != arrStrGrid[i - 1, j])
								{
									g.DrawLine(p_pen, num, num2, x, num3);
								}
								break;
							case GridMergeFlag.Any:
								if (arrStrGrid[i, j] == "" || arrStrGrid[i, j] != arrStrGrid[i - 1, j])
								{
									g.DrawLine(p_pen, num, num2, x, num3);
								}
								break;
							}
						}
						if (j > 0)
						{
							num3 += p_rowHeight;
							x = num;
							switch (gridMergeFlag)
							{
							case GridMergeFlag.None:
								g.DrawLine(p_pen, num, num2, x, num3);
								break;
							case GridMergeFlag.Row:
								if (arrStrGrid[i, j] == "" || arrStrGrid[i, j] != arrStrGrid[i, j - 1])
								{
									g.DrawLine(p_pen, num, num2, x, num3);
								}
								break;
							case GridMergeFlag.Col:
								g.DrawLine(p_pen, num, num2, x, num3);
								break;
							case GridMergeFlag.Any:
								if (arrStrGrid[i, j] == "" || arrStrGrid[i, j] != arrStrGrid[i, j - 1])
								{
									g.DrawLine(p_pen, num, num2, x, num3);
								}
								break;
							}
						}
						num += p_arrColsWidth[j];
					}
				}
				if (p_gridBorderFlag != GridBorderFlag.None)
				{
					this.DrawGridBorder(g, rectangle, p_pen, p_gridBorderFlag);
				}
				this.ResetTransGrid();
			}
		}

		protected void DrawGridText(Graphics g, Rectangle p_rec, Brush p_brush, string[,] arrStrGrid, int p_rowHeight, int[] p_arrColsWidth, string alignment, Font p_font, PointF p_scaleXY, GridMergeFlag gridMergeFlag)
		{
			if (gridMergeFlag == GridMergeFlag.None)
			{
				this.DrawGridText(g, p_rec, p_brush, arrStrGrid, p_rowHeight, p_arrColsWidth, alignment, p_font, p_scaleXY);
			}
			else
			{
				try
				{
					Rectangle p_rec2 = new Rectangle(p_rec.X, p_rec.Y, p_rec.Width, p_rec.Height);
					Font font = p_font;
					if (font == null)
					{
						font = new Font("宋体", 12f);
					}
					int length = arrStrGrid.GetLength(0);
					int length2 = arrStrGrid.GetLength(1);
					int[] array = new int[length2];
					AlignFlag[] colsAlign = this.GetColsAlign(alignment);
					this.TransGrid(g, p_rec2, p_scaleXY);
					StringFormat stringFormat = new StringFormat();
					stringFormat.LineAlignment = StringAlignment.Center;
					stringFormat.FormatFlags = StringFormatFlags.LineLimit;
					CellRectangle mergeCell = new CellRectangle(p_rec2.X, p_rec2.Y, 0, p_rowHeight);
					for (int i = 0; i < length; i++)
					{
						for (int j = 0; j < length2; j++)
						{
							mergeCell = this.GetMergeCell(new Point(p_rec2.X, p_rec2.Y), arrStrGrid, p_rowHeight, p_arrColsWidth, i, j, gridMergeFlag);
							Rectangle r = new Rectangle(mergeCell.Left, mergeCell.Top, mergeCell.Width, mergeCell.Height + 4);
							stringFormat.Alignment = StringAlignment.Near;
							if (colsAlign.Length > j)
							{
								if (colsAlign[j] == AlignFlag.Center)
								{
									stringFormat.Alignment = StringAlignment.Center;
								}
								else if (colsAlign[j] == AlignFlag.Right)
								{
									stringFormat.Alignment = StringAlignment.Far;
								}
							}
							g.DrawString(arrStrGrid[i, j], font, p_brush, r, stringFormat);
						}
					}
					this.ResetTransGrid();
				}
				catch (Exception ex)
				{
					MessageBox.Show(ex.Message);
				}
				finally
				{
				}
			}
		}

		protected virtual CellRectangle GetMergeCell(Point GridLocation, string[,] arrStrGrid, int rowHeight, int[] ArrColWidth, int rowSel, int colSel, GridMergeFlag gridMergeFlag)
		{
			CellRectangle result = new CellRectangle(0, 0, 0, 0);
			int length = arrStrGrid.GetLength(0);
			int length2 = arrStrGrid.GetLength(1);
			int num = 1;
			int num2 = 1;
			int num3 = rowSel;
			int num4 = rowSel;
			int num5 = colSel;
			int num6 = colSel;
			if (gridMergeFlag == GridMergeFlag.Any || gridMergeFlag == GridMergeFlag.Col || gridMergeFlag == GridMergeFlag.ColDependOnBeforeGroup)
			{
				for (int i = rowSel - 1; i >= 0; i--)
				{
					if (!(arrStrGrid[rowSel, colSel] == arrStrGrid[i, colSel]))
					{
						break;
					}
					num++;
					num3--;
				}
				for (int i = rowSel + 1; i < length; i++)
				{
					if (!(arrStrGrid[rowSel, colSel] == arrStrGrid[i, colSel]))
					{
						break;
					}
					num++;
					num4++;
				}
			}
			if (gridMergeFlag == GridMergeFlag.Any || gridMergeFlag == GridMergeFlag.Row)
			{
				for (int j = colSel - 1; j >= 0; j--)
				{
					if (!(arrStrGrid[rowSel, colSel] == arrStrGrid[rowSel, j]))
					{
						break;
					}
					num2++;
					num5--;
				}
				for (int j = colSel + 1; j < length2; j++)
				{
					if (!(arrStrGrid[rowSel, colSel] == arrStrGrid[rowSel, j]))
					{
						break;
					}
					num2++;
					num6++;
				}
			}
			int num7 = GridLocation.X;
			int cellTop = GridLocation.Y + num3 * rowHeight;
			int num8 = 0;
			for (int k = num5 - 1; k >= 0; k--)
			{
				num7 += ArrColWidth[k];
			}
			for (int k = num5; k <= num6; k++)
			{
				num8 += ArrColWidth[k];
			}
			int cellHeight = num * rowHeight;
			result = new CellRectangle(num7, cellTop, num8, cellHeight);
			return result;
		}
	}
}