CPF/CPF.ReoGrid/Rendering/WPFGraphics.cs

using System;
using System.Collections.Generic;
using CPF.Drawing;
using CPF.ReoGrid.Common;
using CPF.ReoGrid.Drawing;
using CPF.ReoGrid.Graphics;

namespace CPF.ReoGrid.Rendering
{
	internal class WPFGraphics : IGraphics
	{
		public ResourcePoolManager ResourcePoolManager
		{
			get
			{
				return this.resourceManager;
			}
		}

		public DrawingContext PlatformGraphics
		{
			get
			{
				return this.g;
			}
			set
			{
				this.g = value;
				bool flag = value != null;
				if (flag)
				{
					this.reset = value.Transform;
				}
			}
		}

		public void DrawLine(CPFPen p, float x1, float y1, float x2, float y2)
		{
			this.DrawLine(p, new Point(ref x1, ref y1), new Point(ref x2, ref y2));
		}

		public void DrawLine(CPFPen p, Point startPoint, Point endPoint)
		{
			DrawingContext drawingContext = this.g;
			Stroke stroke = p.Stroke;
			drawingContext.DrawLine(stroke, p.Brush, startPoint, endPoint);
		}

		public void DrawLine(Point startPoint, Point endPoint, Color color)
		{
			CPFPen pen = this.resourceManager.GetPen(color);
			DrawingContext drawingContext = this.g;
			Stroke stroke = pen.Stroke;
			Brush brush = pen.Brush;
			Point point = startPoint;
			Point point2 = endPoint;
			drawingContext.DrawLine(stroke, brush, point, point2);
		}

		public void DrawLine(float x1, float y1, float x2, float y2, Color color)
		{
			CPFPen pen = this.resourceManager.GetPen(color);
			this.DrawLine(pen, x1, y1, x2, y2);
		}

		public void DrawLine(float x1, float y1, float x2, float y2, Color color, float width, LineStyles style)
		{
			CPFPen pen = this.resourceManager.GetPen(color, width, this.ToWPFDashStyle(style));
			bool flag = pen != null;
			if (flag)
			{
				DrawingContext drawingContext = this.g;
				Stroke stroke = pen.Stroke;
				Brush brush = pen.Brush;
				Point point = new Point(ref x1, ref y1);
				Point point2 = new Point(ref x2, ref y2);
				drawingContext.DrawLine(stroke, brush, point, point2);
			}
		}

		public void DrawLine(Point startPoint, Point endPoint, Color color, float width, LineStyles style)
		{
			CPFPen pen = this.resourceManager.GetPen(color, width, this.ToWPFDashStyle(style));
			bool flag = pen != null;
			if (flag)
			{
				DrawingContext drawingContext = this.g;
				Stroke stroke = pen.Stroke;
				drawingContext.DrawLine(stroke, pen.Brush, startPoint, endPoint);
			}
		}

		public void DrawLines(Point[] points, int start, int length, Color color, float width, LineStyles style)
		{
			bool flag = !color.IsTransparent && length > 1;
			if (flag)
			{
				CPFPen pen = this.resourceManager.GetPen(color, width, this.ToWPFDashStyle(style));
				bool flag2 = pen != null;
				if (flag2)
				{
					PathGeometry pathGeometry = new PathGeometry();
					bool flag3 = points != null && points.Length > 1;
					if (flag3)
					{
						pathGeometry.BeginFigure(points[0].X, points[0].Y);
						for (int i = 1; i < points.Length; i++)
						{
							pathGeometry.LineTo(points[i].X, points[i].Y);
						}
						pathGeometry.EndFigure(false);
					}
					DrawingContext drawingContext = this.g;
					Brush brush = pen.Brush;
					Stroke stroke = pen.Stroke;
					drawingContext.DrawPath(brush, stroke, pathGeometry);
				}
			}
		}

		public void DrawRectangle(CPFPen p, Rect rect)
		{
			DrawingContext drawingContext = this.g;
			Brush brush = p.Brush;
			Stroke stroke = p.Stroke;
			drawingContext.DrawRectangle(brush, stroke, rect);
		}

		public void DrawRectangle(CPFPen p, float x, float y, float w, float h)
		{
			DrawingContext drawingContext = this.g;
			Brush brush = p.Brush;
			Stroke stroke = p.Stroke;
			Rect rect = new Rect(ref x, ref y, ref w, ref h);
			drawingContext.DrawRectangle(brush, stroke, rect);
		}

		public void DrawRectangle(Rect rect, Color color)
		{
			CPFPen pen = this.resourceManager.GetPen(color);
			bool flag = pen != null;
			if (flag)
			{
				DrawingContext drawingContext = this.g;
				Brush brush = pen.Brush;
				Stroke stroke = pen.Stroke;
				Rect rect2 = rect;
				drawingContext.DrawRectangle(brush, stroke, rect2);
			}
		}

		public void DrawRectangle(float x, float y, float width, float height, Color color)
		{
			CPFPen pen = this.resourceManager.GetPen(color);
			DrawingContext drawingContext = this.g;
			Brush brush = pen.Brush;
			Stroke stroke = pen.Stroke;
			Rect rect = new Rect(ref x, ref y, ref width, ref height);
			drawingContext.DrawRectangle(brush, stroke, rect);
		}

		public void FillRectangle(HatchStyles style, Color hatchColor, Color bgColor, Rect rect)
		{
		}

		public void FillRectangle(HatchStyles style, Color hatchColor, Color bgColor, float x, float y, float width, float height)
		{
		}

		public void FillRectangle(Rect rect, Color color)
		{
			this.g.FillRectangle(this.resourceManager.GetBrush(color), rect);
		}

		public void FillRectangle(float x, float y, float width, float height, Color color)
		{
			this.g.FillRectangle(this.resourceManager.GetBrush(color), new Rect(ref x, ref y, ref width, ref height));
		}

		public void FillRectangle(Brush b, float x, float y, float width, float height)
		{
			this.g.FillRectangle(b, new Rect(ref x, ref y, ref width, ref height));
		}

		public void FillRectangleLinear(Color color1, Color color2, float angle, Rect rect)
		{
			Point[] intersectionPoints = this.GetIntersectionPoints(rect, angle);
			LinearGradientBrush fillBrush = new LinearGradientBrush(new GradientStop[]
			{
				new GradientStop(color1, 0f),
				new GradientStop(color2, 1f)
			}, intersectionPoints[0], intersectionPoints[1], Matrix.Identity);
			this.g.FillRectangle(fillBrush, rect);
		}

		private Vector VectorFromAngle(float angle)
		{
			angle = (float)((double)angle * 0.005555555555555556 * 3.141592653589793);
			return new Vector((float)Math.Cos((double)angle), (float)Math.Sin((double)angle));
		}

		private Point[] GetIntersectionPoints(Rect rect, float angle)
		{
			Point[] array = new Point[2];
			bool flag = angle % 360f == 0f;
			if (flag)
			{
				array[0] = rect.Location;
				Point[] array2 = array;
				int num = 1;
				float num2 = rect.X + rect.Width;
				float num3 = rect.Y;
				array2[num] = new Point(ref num2, ref num3);
			}
			else
			{
				bool flag2 = (angle - 90f) % 360f == 0f;
				if (flag2)
				{
					array[0] = rect.Location;
					Point[] array3 = array;
					int num4 = 1;
					float num2 = rect.X;
					float num3 = rect.Y + rect.Height;
					array3[num4] = new Point(ref num2, ref num3);
				}
				else
				{
					bool flag3 = (angle - 180f) % 360f == 0f;
					if (flag3)
					{
						Point[] array4 = array;
						int num5 = 0;
						float num2 = rect.X + rect.Width;
						float num3 = rect.Y;
						array4[num5] = new Point(ref num2, ref num3);
						array[1] = rect.Location;
					}
					else
					{
						bool flag4 = (angle - 270f) % 360f == 0f;
						if (flag4)
						{
							Point[] array5 = array;
							int num6 = 0;
							float num2 = rect.X;
							float num3 = rect.Y + rect.Height;
							array5[num6] = new Point(ref num2, ref num3);
							array[1] = rect.Location;
						}
					}
				}
			}
			return array;
		}

		public void DrawRectangle(Rect rect, Color color, float width, LineStyles lineStyle)
		{
			CPFPen pen = this.resourceManager.GetPen(color, width, this.ToWPFDashStyle(lineStyle));
			bool flag = pen != null;
			if (flag)
			{
				DrawingContext drawingContext = this.g;
				Brush brush = pen.Brush;
				Stroke stroke = pen.Stroke;
				drawingContext.DrawRectangle(brush, stroke, rect);
			}
		}

		public void DrawAndFillRectangle(Rect rect, Color lineColor, Color fillColor)
		{
			this.g.FillRectangle(this.resourceManager.GetBrush(fillColor), rect);
			CPFPen pen = this.resourceManager.GetPen(lineColor);
			DrawingContext drawingContext = this.g;
			Brush brush = pen.Brush;
			Stroke stroke = pen.Stroke;
			Rect rect2 = rect;
			drawingContext.DrawRectangle(brush, stroke, rect2);
		}

		public void DrawAndFillRectangle(Rect rect, Color lineColor, Color fillColor, float width, LineStyles lineStyle)
		{
			CPFPen pen = this.resourceManager.GetPen(lineColor, width, this.ToWPFDashStyle(lineStyle));
			SolidColorBrush brush = this.resourceManager.GetBrush(fillColor);
			bool flag = pen != null && brush != null;
			if (flag)
			{
				this.g.FillRectangle(brush, rect);
				DrawingContext drawingContext = this.g;
				Brush brush2 = pen.Brush;
				Stroke stroke = pen.Stroke;
				drawingContext.DrawRectangle(brush2, stroke, rect);
			}
		}

		public void DrawImage(Image image, float x, float y, float width, float height)
		{
			DrawingContext drawingContext = this.g;
			Rect rect = new Rect(ref x, ref y, ref width, ref height);
			float num = 0f;
			float num2 = 0f;
			float num3 = (float)image.Width;
			float num4 = (float)image.Height;
			Rect rect2 = new Rect(ref num, ref num2, ref num3, ref num4);
			float num5 = 1f;
			drawingContext.DrawImage(image, rect, rect2, num5);
		}

		public void DrawImage(Image image, Rect bounds)
		{
			DrawingContext drawingContext = this.g;
			Rect rect = bounds;
			float num = 0f;
			float num2 = 0f;
			float num3 = (float)image.Width;
			float num4 = (float)image.Height;
			Rect rect2 = new Rect(ref num, ref num2, ref num3, ref num4);
			float num5 = 1f;
			drawingContext.DrawImage(image, rect, rect2, num5);
		}

		public void DrawText(string text, string fontName, float size, Color color, Rect rect)
		{
			this.DrawText(text, fontName, size, color, rect, ReoGridHorAlign.Left, ReoGridVerAlign.Top);
		}

		public void DrawText(string text, string fontName, float size, Color color, Rect rect, ReoGridHorAlign halign, ReoGridVerAlign valign)
		{
			bool flag = rect.Width > 0f && rect.Height > 0f && !string.IsNullOrEmpty(text);
			if (flag)
			{
				Font font = ResourcePoolManager.CreateFont(fontName, (double)size, FontStyles.Regular);
				Size size2 = DrawingFactory.Default.MeasureString(text, font, rect.Width);
				Point location = rect.Location;
				TextAlignment textAlignment = TextAlignment.Left;
				if (halign != ReoGridHorAlign.Center)
				{
					if (halign == ReoGridHorAlign.Right)
					{
						textAlignment = TextAlignment.Right;
					}
				}
				else
				{
					textAlignment = TextAlignment.Center;
				}
				if (valign != ReoGridVerAlign.Middle)
				{
					if (valign == ReoGridVerAlign.Bottom)
					{
						location.Y += rect.Height - size2.Height;
					}
				}
				else
				{
					location.Y += (rect.Height - size2.Height) / 2f;
				}
				AntialiasMode antialiasMode = this.g.AntialiasMode;
				this.g.AntialiasMode = AntialiasMode.AntiAlias;
				DrawingContext drawingContext = this.g;
				Brush fillBrush = color;
				float width = rect.Width;
				TextDecoration textDecoration = default(TextDecoration);
				float maxValue = float.MaxValue;
				TextTrimming textTrimming = TextTrimming.None;
				Stroke stroke = default(Stroke);
				drawingContext.DrawString(location, fillBrush, text, font, textAlignment, width, textDecoration, maxValue, textTrimming, stroke, null);
				this.g.AntialiasMode = antialiasMode;
			}
		}

		public void PushClip(Rect clipRect)
		{
			this.g.PushClip(clipRect);
		}

		public void PopClip()
		{
			this.g.PopClip();
		}

		public void PushTransform()
		{
			this.PushTransform(Matrix.Identity);
		}

		public void PushTransform(Matrix m)
		{
			Matrix transform = this.g.Transform;
			this.transformStack.Push(transform);
			m *= transform;
			this.g.Transform = m;
		}

		public Matrix PopTransform()
		{
			bool flag = this.transformStack.Count == 0;
			Matrix result;
			if (flag)
			{
				this.g.Transform = this.reset;
				result = this.reset;
			}
			else
			{
				Matrix matrix = this.transformStack.Pop();
				this.g.Transform = matrix;
				result = matrix;
			}
			return result;
		}

		public void TranslateTransform(float x, float y)
		{
			Matrix transform = this.g.Transform;
			transform.TranslatePrepend(x, y);
			this.g.Transform = transform;
		}

		public void ScaleTransform(float x, float y)
		{
			Matrix transform = this.g.Transform;
			transform.ScalePrepend(x, y);
			this.g.Transform = transform;
		}

		public void RotateTransform(float angle)
		{
			Matrix transform = this.g.Transform;
			transform.RotatePrepend(angle);
			this.g.Transform = transform;
		}

		public void ResetTransform()
		{
			this.g.Transform = this.reset;
		}

		public void DrawEllipse(Color color, Rect rectangle)
		{
			CPFPen pen = this.resourceManager.GetPen(color);
			bool flag = pen != null;
			if (flag)
			{
				DrawingContext drawingContext = this.g;
				Brush brush = pen.Brush;
				Stroke stroke = pen.Stroke;
				float num = rectangle.X + rectangle.Width / 2f;
				float num2 = rectangle.Y + rectangle.Height / 2f;
				Point point = new Point(ref num, ref num2);
				float width = rectangle.Width;
				float height = rectangle.Height;
				drawingContext.DrawEllipse(brush, stroke, point, width, height);
			}
		}

		public void DrawEllipse(Color color, float x, float y, float width, float height)
		{
			CPFPen pen = this.resourceManager.GetPen(color);
			bool flag = pen != null;
			if (flag)
			{
				DrawingContext drawingContext = this.g;
				Brush brush = pen.Brush;
				Stroke stroke = pen.Stroke;
				Point point = new Point(ref x, ref y);
				drawingContext.DrawEllipse(brush, stroke, point, width, height);
			}
		}

		public void DrawEllipse(CPFPen pen, Rect rectangle)
		{
			DrawingContext drawingContext = this.g;
			Brush brush = pen.Brush;
			Stroke stroke = pen.Stroke;
			Point location = rectangle.Location;
			float width = rectangle.Width;
			float height = rectangle.Height;
			drawingContext.DrawEllipse(brush, stroke, location, width, height);
		}

		public void FillEllipse(Brush b, Rect rectangle)
		{
			DrawingContext drawingContext = this.g;
			Point location = rectangle.Location;
			float width = rectangle.Width;
			float height = rectangle.Height;
			drawingContext.FillEllipse(b, location, width, height);
		}

		public void FillEllipse(Brush b, float x, float y, float width, float height)
		{
			DrawingContext drawingContext = this.g;
			Point point = new Point(ref x, ref y);
			drawingContext.FillEllipse(b, point, width, height);
		}

		public void DrawPolygon(Color color, float width, LineStyles style, params Point[] points)
		{
			this.DrawLines(points, 0, points.Length, color, width, style);
		}

		public void FillPolygon(Color color, params Point[] points)
		{
			bool flag = !color.IsTransparent;
			if (flag)
			{
				PathGeometry pathGeometry = new PathGeometry();
				bool flag2 = points != null && points.Length > 1;
				if (flag2)
				{
					pathGeometry.BeginFigure(points[0].X, points[0].Y);
					for (int i = 1; i < points.Length; i++)
					{
						pathGeometry.LineTo(points[i].X, points[i].Y);
					}
					pathGeometry.EndFigure(true);
				}
				this.g.FillPath(new SolidColorBrush(color), pathGeometry);
			}
		}

		public bool IsAntialias
		{
			get
			{
				return true;
			}
			set
			{
			}
		}

		public void Reset()
		{
			this.transformStack.Clear();
		}

		internal void SetPlatformGraphics(DrawingContext dc)
		{
			this.g = dc;
		}

		internal DashStyles ToWPFDashStyle(LineStyles style)
		{
			DashStyles result;
			switch (style)
			{
			default:
				result = DashStyles.Solid;
				break;
			case LineStyles.Dash:
				result = DashStyles.Dash;
				break;
			case LineStyles.Dot:
				result = DashStyles.Dot;
				break;
			case LineStyles.DashDot:
				result = DashStyles.DashDot;
				break;
			case LineStyles.DashDotDot:
				result = DashStyles.DashDotDot;
				break;
			}
			return result;
		}

		public void FillPath(Color color, PathGeometry graphicsPath)
		{
			SolidColorBrush brush = this.resourceManager.GetBrush(color);
			bool flag = brush != null;
			if (flag)
			{
				this.g.FillPath(brush, graphicsPath);
			}
		}

		public void DrawPath(Color color, PathGeometry graphicsPath)
		{
			CPFPen pen = this.resourceManager.GetPen(color);
			bool flag = pen != null;
			if (flag)
			{
				DrawingContext drawingContext = this.g;
				Brush brush = pen.Brush;
				Stroke stroke = pen.Stroke;
				drawingContext.DrawPath(brush, stroke, graphicsPath);
			}
		}

		public void FillEllipse(Color fillColor, Rect rect)
		{
			SolidColorBrush brush = this.resourceManager.GetBrush(fillColor);
			bool flag = brush != null;
			if (flag)
			{
				DrawingContext drawingContext = this.g;
				Brush fillBrush = brush;
				Point center = rect.Center;
				float width = rect.Width;
				float height = rect.Height;
				drawingContext.FillEllipse(fillBrush, center, width, height);
			}
		}

		protected ResourcePoolManager resourceManager = new ResourcePoolManager();

		private DrawingContext g = null;

		private Matrix reset;

		private Stack<Matrix> transformStack = new Stack<Matrix>();
	}
}