drawingutil.cs

C#自定义查询控件

// Disclaimer and Copyright Information
// DrawingUtil.cs : 
//
// All rights reserved.
//
// Written by Pardesi Services, LLC
// Version 1.0
//
// Distribute freely, except: don't remove our name from the source or
// documentation (don't take credit for my work), mark your changes (don't
// get me blamed for your possible bugs), don't alter or remove this
// notice.
// No warrantee of any kind, express or implied, is included with this
// software; use at your own risk, responsibility for damages (if any) to
// anyone resulting from the use of this software rests entirely with the
// user.
//
// Send bug reports, bug fixes, enhancements, requests, flames, etc. to
// [e-mail]
///////////////////////////////////////////////////////////////////////////////
//

using System;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;

namespace CommonComponent.CommonChart
{
	/// <summary>
	/// Summary description for DrawingUtil.
	/// </summary>
	public class DrawingUtil
	{
		internal DrawingUtil()
		{
			//
			// TODO: Add constructor logic here
			//
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="hatchType"></param>
		/// <param name="clrHatch"></param>
		/// <param name="clrBg"></param>
		/// <returns></returns>
		internal static HatchBrush CreateHatchBrush(HatchType hatchType, Color clrHatch, Color clrBg)
		{
			HatchStyle hatchStyle;
			switch (hatchType)
			{
				case HatchType.Cross:
					hatchStyle = HatchStyle.Cross;
					break;
				case HatchType.DashedHorizontal:
					hatchStyle = HatchStyle.DashedHorizontal;
					break;
				case HatchType.DashedVertical:
					hatchStyle = HatchStyle.DashedVertical;
					break;
				case HatchType.DiagonalBrick:
					hatchStyle = HatchStyle.DiagonalBrick;
					break;
				case HatchType.DiagonalCross:
					hatchStyle = HatchStyle.DiagonalCross;
					break;
				case HatchType.DottedDiamond:
					hatchStyle = HatchStyle.DottedDiamond;
					break;
				case HatchType.DottedGrid:
					hatchStyle = HatchStyle.DottedGrid;
					break;
				case HatchType.HorizontalBrick:
					hatchStyle = HatchStyle.HorizontalBrick;
					break;
				case HatchType.LargeConfetti:
					hatchStyle = HatchStyle.LargeConfetti;
					break;
				case HatchType.OutlinedDiamond:
					hatchStyle = HatchStyle.OutlinedDiamond;
					break;
				case HatchType.Plaid:
					hatchStyle = HatchStyle.Plaid;
					break;
				case HatchType.Shingle:
					hatchStyle = HatchStyle.Shingle;
					break;
				case HatchType.SmallConfetti:
					hatchStyle = HatchStyle.SmallConfetti;
					break;
				case HatchType.SolidDiamond:
					hatchStyle = HatchStyle.SolidDiamond;
					break;
				case HatchType.Sphere:
					hatchStyle = HatchStyle.Sphere;
					break;
				case HatchType.Wave:
					hatchStyle = HatchStyle.Wave;
					break;
				case HatchType.Weave:
					hatchStyle = HatchStyle.Weave;
					break;
				case HatchType.ZigZag:
					hatchStyle = HatchStyle.ZigZag;
					break;
				case HatchType.LargeCheckerBoard:
					hatchStyle = HatchStyle.LargeCheckerBoard;
					break;
				default:
					hatchStyle = HatchStyle.Cross;
					break;
			}
			HatchBrush obBrush = null;
			try
			{
				obBrush = new HatchBrush(hatchStyle, clrHatch, clrBg);
			}
			catch (Exception ex)
			{
				Trace.WriteLine(ex.Message);
				return null;
			}
			return obBrush;

		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="colorMain"></param>
		/// <param name="gradientFactor"></param>
		/// <returns></returns>
		internal static LinearGradientBrush GetLinearGradientBrush(Rectangle rect, Color colorMain, short gradientFactor, LinearGradientMode mode)
		{
			// Create a color lighter than the main color.
			Color lightColor;
			LinearGradientBrush lgBrush = null;
			try
			{
				lightColor = ColorUtil.GetDarkColor(colorMain, gradientFactor);
				lgBrush = new LinearGradientBrush(rect, colorMain, lightColor, mode);
			}
			catch (Exception ex)
			{
				Trace.WriteLine(ex.Message);
				return null;
			}
			return lgBrush;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="colorMain"></param>
		/// <param name="gradientFactor"></param>
		/// <returns></returns>
		internal static PathGradientBrush GetPathGradientBrush(PointF[] points, Color colorMain, short gradientFactor, LinearGradientMode mode)
		{
			// Create a color lighter than the main color.
			Color lightColor;
			PathGradientBrush obBrush = null;
			try
			{
				lightColor = ColorUtil.GetDarkColor(colorMain, gradientFactor);
				// Get bounding rectangle for path gradient brush.
				obBrush = new PathGradientBrush(points);
				obBrush.CenterColor = colorMain;
			}
			catch (Exception ex)
			{
				Trace.WriteLine(ex.Message);
				return null;
			}
			return obBrush;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="colorMain"></param>
		/// <param name="gradientFactor"></param>
		/// <returns></returns>
		internal static LinearGradientBrush GetLinearGradientBrush(Rectangle rect, Color color1, Color color2, LinearGradientMode mode)
		{
			// Create a color lighter than the main color.
			LinearGradientBrush lgBrush = null;
			try
			{
				lgBrush = new LinearGradientBrush(rect, color1, color2, mode);
			}
			catch (Exception ex)
			{
				Trace.WriteLine(ex.Message);
				return null;
			}
			return lgBrush;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="rect"></param>
		/// <param name="color1"></param>
		/// <param name="color2"></param>
		/// <returns></returns>
		internal static PathGradientBrush GetCircularGradientBrush(Rectangle rect, Color color1, Color color2, CGradientType type)
		{
			PathGradientBrush obBrush = null;
			GraphicsPath path = null;
			PointF ptCenter;
			try
			{
				ptCenter = new PointF();
				path = new GraphicsPath();
				path.AddEllipse(rect.X, rect.Y, rect.Width, rect.Height);
				ptCenter.X = rect.Width/2.0F;
				ptCenter.Y = rect.Height/2.0F;
				obBrush = new PathGradientBrush(path);
				obBrush.CenterPoint = ptCenter;
				switch (type)
				{
					case CGradientType.InsideOut:
						obBrush.CenterColor = color1;
						Color[] colors2 = {color2};
						obBrush.SurroundColors = colors2;
						break;
					case CGradientType.OutsideIn:
						obBrush.CenterColor = color2;
						Color[] colors1 = {color1};
						obBrush.SurroundColors = colors1;
						break;
				}
			}
			catch (Exception ex)
			{
				Trace.WriteLine(ex.Message);
				return null;
			}
			return obBrush;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="rect"></param>
		/// <param name="color"></param>
		/// <param name="gradFactor"></param>
		/// <param name="type"></param>
		/// <returns></returns>
		internal static PathGradientBrush GetCircularGradientBrush(Rectangle rect, Color color, short gradFactor, CGradientType type)
		{
			Color lightColor = ColorUtil.GetDarkColor(color, gradFactor);
			return GetCircularGradientBrush(rect, color, lightColor, type);
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="obGraphics"></param>
		/// <param name="iLeftX"></param>
		/// <param name="iLeftY"></param>
		/// <param name="iWidth"></param>
		/// <param name="iHeight"></param>
		/// <param name="dThickness"></param>
		/// <param name="faceColor"></param>
		/// <returns></returns>
		internal bool DrawBar(Graphics obGraphics, int iLeftX, int iLeftY, float iWidth, float iHeight, double dThickness, Color faceColor, short gradient, bool bGradientColor)
		{
			Brush faceBrush = null;
			PointF [] faceRect = null;
			try
			{
				if (bGradientColor)
				{
					Rectangle rect = new Rectangle();
					rect.X = iLeftX;
					rect.Y = iLeftY;
					rect.Width = (int)iWidth;
					rect.Height = (int)iHeight;
					faceBrush = GetLinearGradientBrush(rect, faceColor, gradient, LinearGradientMode.Horizontal);
				}
				else
				{
					faceBrush = new SolidBrush(faceColor);
				}

				faceRect = new PointF[4];

				faceRect[0].X = iLeftX;
				faceRect[0].Y = iLeftY;
				faceRect[1].X = faceRect[0].X + iWidth;
				faceRect[1].Y = faceRect[0].Y;
				faceRect[2].X = faceRect[1].X;
				faceRect[2].Y = faceRect[1].Y + iHeight;
				faceRect[3].X = faceRect[2].X - iWidth;
				faceRect[3].Y = faceRect[2].Y;

				Trace.WriteLine(faceRect[0] + "," + faceRect[1] + "," + faceRect[2] + "," + faceRect[3]);
				obGraphics.FillPolygon(faceBrush, faceRect);
			}
			catch (Exception ex)
			{
				Trace.WriteLine(ex.Message);
				return false;
			}
			finally
			{
				if (null !=  faceBrush)
				{
					faceBrush.Dispose();
				}
				faceBrush = null;
			}

			return true;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="obGraphics"></param>
		/// <param name="obPen"></param>
		/// <param name="rect"></param>
		internal static void DrawRectangle(Graphics obGraphics, Pen obPen, RectangleF rect)
		{
			obGraphics.DrawRectangle(obPen, rect.X, rect.Y, rect.Width, rect.Height);
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="obGraphics"></param>
		/// <param name="strImgFile"></param>
		/// <returns></returns>
		internal static SizeF GetImageSize(string strImgFile)
		{
			SizeF retSize;
			if (null == strImgFile || strImgFile.Length == 0)
			{
				throw new ArgumentNullException("ImageFilePath", "No file path supplie for image");
			}
			try
			{
				Image obImg = Image.FromFile(strImgFile);
				retSize = new SizeF(obImg.Width, obImg.Height);
			}
			catch (Exception ex)
			{
				Trace.WriteLine(ex.Message);
				throw ex;
			}
			return retSize;
		}
	}
}