lyfz_repos/铂金版源码/LYFZ.PhotoSelectSystem/其它/C#多功能画图板源码/code/GraDrawTool.cs

///
using System;
using System.Collections;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
using System.Reflection;
using System.IO;


using GraEditor.Elements;//Elements include Line,Lines,Rectangle,Ellipse,Text,Image

// Namespace DrawTool, include GraDrawTool,DrawEnvMgr,GraDrawToolMgr,LineDrawTool,LinesDrawTool,
//FrameRectDrawTool, FillRectDrawTool, FrameEllipseDrawTool,FillEllipseDrawTool,ImageDrawTool,TextDrawTool,SelectDrawTool,GraDrawType
namespace GraEditor.DrawTools
{
	

	//Save Global pen, brush and font. We use these object when we draw graph element on canvas
	public class  DrawEnvMgr
	{

		protected  DrawEnvMgr()
		{
            this.pen = new Pen(Color.Red, 1);             //设置默认的画笔
            this.brush = new SolidBrush(Color.Red);//设置默认刷
            this.font = new Font("宋体", 30);            //设置默认字体
		}

		private static DrawEnvMgr instance;// instance of DrawEnvMgr

		//Get instance of DrawEnvMgr
		public static  DrawEnvMgr Instance
		{
			get                           
			{
				if(instance == null)
					instance = new DrawEnvMgr();
				return instance;
			}
		}

	
		protected Pen  pen; //protected pen variable to save pen object
		
		//Pen property of DrawEnvMgr
		public  Pen   Pen
		{
			get { return pen; }
			
		}

		protected SolidBrush  brush;//protected solidbrush variable to save brush object

		//Brush property of DrawEnvMgr
		public  Brush   Brush
		{
			get { return brush; }
		}

		//Set pen and brush color
		public Color  Color          
		{
			get { return pen.Color; }
			set
			{
				pen.Color = value;
				brush.Color = value;
			}
		}

		//Pen width property of DrawEnvMgr
		public int PenWidth 
		{
			get { return (int)pen.Width; }
			set { pen.Width = value; }    
		}

		protected  Font  font; //private font variable to save font

		//Font property of DrawEnvMgr
		public     Font  Font
		{
			get { return font ; }
			set { font = value; }
		}
	}

	//Specify how many draw type is included
	public enum  GraDrawType 
	{
        Select, Line, Arrow,MobileViews, Lines, Freehand, Erase, FrameRect, FillRect, FrameEllipse, FillEllipse, Text, Image
	}


	//Abstract class for drawing operation. 
	//SelectDrawTool(), LineDrawTool(), LinesDrawTool(), ImageDrawTool(), ImageDrawTool(), RectDrawTool(), 
	//EllipseDrawTool() and TextDrawTool() are inherit from it.
	public abstract class GraDrawTool
	{
		/// <summary>
		/// 
		/// </summary>
		/// 
		public GraDrawTool()
		{
		}

		//Abstract variable.
		public abstract  GraDrawType  Type 
		{
			get;
		}

		private GraDrawToolMgr  drawToolMgr;//Private drawToolMgr variable of GraDrawTool

		//DrawTool Mgr property of GraDrawTool
		public  GraDrawToolMgr  DrawToolMgr
		{
			get { return drawToolMgr; }
			set { drawToolMgr = value;}
		}

		protected  bool  isDrawing;     //When you are drawing,isDrawing is true. Else isDrawing is false
		private    ToolBarButton tblBtn;//Save the ToolBar button
		
		//Toolbar button property of GraDrawTool
		public     ToolBarButton TblBtn
		{
			get { return tblBtn; } 
			set { tblBtn = value ;}
		}

		private  Cursor  oldCursor;
		protected Cursor  toolCursor;

		public static event EventHandler ActiveStateChanged;
		public void OnActiveStateChanged()
		{
			if(ActiveStateChanged != null)
				ActiveStateChanged(this,EventArgs.Empty);
		}

		private bool  isActive;//When the ToolBar button is pushdown, isActive is true. Else isActive is false
    
		//Active property of GraDrawTool
		public virtual bool  IsActive
		{
			get { return isActive; }
			set                     
			{
				this.isActive = value;
				tblBtn.Pushed = this.isActive;

				OnActiveStateChanged();

				if(this.toolCursor != null)
				{
				
					if(this.isActive)
					{
						this.oldCursor = Canvas.Instance.MainView.Cursor;
						Canvas.Instance.MainView.Cursor = this.toolCursor;
					}
					else
						Canvas.Instance.MainView.Cursor = this.oldCursor;
				}
			}
		}

		public  virtual string  Tip
		{
			get { return "";}
		}
		
		public static  int gridSize = 5;//Set the small distance you can draw. If mouse moves smaller distance than gridSize, we think it do not move


		public  Cursor  CreateCursor(byte[] resoures)
		{
            System.IO.Stream stream = new MemoryStream(resoures);
            return new Cursor(stream);
		}

		//Round calculation of mouse movement.Mouse must move at least 6 pixel every time.
		public static  Point GetRoundPoint(Point pt) 
		{
			int x = (pt.X+gridSize/2)/gridSize*gridSize;
			int y = (pt.Y+gridSize/2)/gridSize*gridSize;

			return new Point(x,y); 
		}

		public static  Point RegularEndPt(Point ptStart, Point ptEnd)
		{
			int sx = Math.Abs(ptEnd.X - ptStart.X);
			int sy = Math.Abs(ptEnd.Y - ptStart.Y);
			int s = Math.Max(sx,sy);
			int x =0;
			int y =0;
			if(ptEnd.X > ptStart.X)
				x = ptStart.X + s;
			else
				x = ptStart.X - s;

			if(ptEnd.Y > ptStart.Y)
				y = ptStart.Y + s;
			else
				y = ptStart.Y - s;

			return new Point(x,y);
		}


		public static Rectangle  CreateValidRect(Point pt1, Point pt2)
		{
			int x = Math.Min(pt1.X,pt2.X);//Judge whether the current x position is at the right of the start point or not
			int y = Math.Min(pt1.Y,pt2.Y);//Judge whether the current y position is under the start point or no
			int w = Math.Abs(pt2.X - pt1.X);//calculate the width of rectangle
			int h = Math.Abs(pt2.Y - pt1.Y);//calculate the height of rectangle

			return new Rectangle(new Point(x,y),new Size(w,h));
		}

		public abstract void  OnMouseDown(MouseEventArgs e);//abstract OnMouseDown event

		public abstract void OnMouseMove(MouseEventArgs e);//abstract OnMouseMove event

		public abstract void OnMouseUp(MouseEventArgs e);//abstract OnMouseUp event
        
		public virtual  void OnDoubleClick(EventArgs e)//abstract OnDoubleClick event
		{

		}
        public virtual void OnKeyDown(KeyEventArgs e)
        {
            
        }
        public virtual void OnKeyUp(KeyEventArgs e)
        {
          
        }
	}

	//Manage draw tools, add new draw tool type
	public class   GraDrawToolMgr
	{
		
		protected  GraDrawToolMgr()
		{
			toolMap = new Hashtable(); //Use hash table to reach the draw tool, it is fast than using vector.toolMap(draw tool type)=draw tool.
		}

		private static GraDrawToolMgr  instance;//instance of GraDrawToolMgr
		
		//Return the instance of GraDrawToolMgr
		public static  GraDrawToolMgr  Instance
		{
			get                              
			{
				if(instance == null)
					instance = new GraDrawToolMgr();
				return instance;
			}
		}

		private  Hashtable   toolMap; // private hash table to save draw tool types

		//Return draw tool
		public   GraDrawTool  this[GraDrawType t]
		{
			get { return toolMap[t] as GraDrawTool; }
			set                                      
			{
				toolMap[t] = value;
			}
		}

		//Add draw tool to toolMap
		public void  AddDrawTool(GraDrawTool  drawTool) 
		{
			if(drawTool == null)
				return;

			drawTool.DrawToolMgr = this;
			toolMap[drawTool.Type] = drawTool;
		}

		private  GraDrawTool  activeDrawTool;//Save the current draw tool

		//Active draw tool property of GraDrawToolMgr
		public   GraDrawTool  ActiveDrawTool
		{
			get { return activeDrawTool; }
			
		}

		//Set the current draw tool
		public void SetActiveTool(GraDrawType t)
		{
			GraDrawTool clickDrawTool = this[t];//Get which Toolbar button is clicked
			if(this.activeDrawTool == clickDrawTool)//Reclick the same Toolbar button.Disable the last cliked Toolbar button
			{
				this.activeDrawTool.IsActive = false;
				this.activeDrawTool = null;
				return;
			}

			if(this.activeDrawTool != null)//Click a new Toolbar button
				this.activeDrawTool.IsActive = false;
			this.activeDrawTool = clickDrawTool;//Set the new clicked Toolbar button as current one
			this.activeDrawTool.IsActive = true;
		}
	}

	//It is inherited from GraDrawTool(). It is used for selecting actions.
	//When we use mouse to select an area, we use this class display some temporary rectangles before we decide the end point of select
	public class  SelectDrawTool : GraDrawTool
	{
		
		protected SelectDrawTool()
			:base()
		{
			this.isSelectRectVisible = false;//Do not display the rectangle frame
		}

		//Reset the select area
		public void ReSet()
		{
			this.selectRectGra = null;
			this.isSelectRectVisible = false;
		}

		//Specify select type
		public override GraDrawType Type
		{
			get
			{
				return GraDrawType.Select;
			}
		}

		private static SelectDrawTool  instance;//instance of SelectDrawTool

        //返回SelectDrawTool实例
		public  static SelectDrawTool  Instance
		{
			get                                 
			{
				if(instance == null)
					instance = new SelectDrawTool();
				return instance;
			}
		}

        //选择area.Size和选择位置
		public  Rectangle  SelectRect
		{
			get                      
			{ 
				if(selectRectGra == null)
					return Rectangle.Empty;
				else
					return selectRectGra.Rect;
			}
		}

		public event  EventHandler  StateChanged;
		public void   OnStateChanged()
		{
			if(StateChanged != null)
				StateChanged(this,EventArgs.Empty);
		}

        private RectGra selectRectGra;//私人RectGra变量，以便保存选择区域
		public  RectGra  SelectRectGra
		{
			get { return this.selectRectGra; }
            set {  this.selectRectGra=value; }
		}

		private Point   ptStart;
		private  Point    ptPre;//Temporary point use for round

		private bool  isSelectRectVisible;//Frame of select is visible or not
        /// <summary>
        /// 取消选区
        /// </summary>
        public void ClerSelected()
        {
            ClerSelectedRect();
            this.selectRectGra = null;
            OnStateChanged();
        }

        /// <summary>
        /// 取消所选操作
        /// </summary>
		private void ClerSelectedRect()
		{
			if(!this.isSelectRectVisible)
				return;

			Canvas.Instance.GraList.Remove(this.selectRectGra); //Remove the select object from GraList
			this.isSelectRectVisible = false;
			Canvas.Instance.Update();//Update the canvas
		}
        
		public override void OnMouseDown(MouseEventArgs e)
		{

            ptStart = new Point(e.X, e.Y);//开始点的选择		
            ptStart = GetRoundPoint(ptStart);//起点
            ptPre = ptStart;//临时使用点

            //在现在的位置转换成原始的，当你放大或坐标缩小
			ptStart = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptStart);
			

			if(e.Button == MouseButtons.Right)//right click mouse button
			{
				return;
			}

			this.ClerSelectedRect();//Cancel the selected operation
			this.isDrawing = true;  //Drawing status
			
			//Construct a pen object to draw the select frame
			using(Pen p = new Pen(Color.Black,1))
			{
                p.DashStyle = DashStyle.Dot;//选择框是虚线
				selectRectGra = new RectGra(p,null,
                    GraDrawMode.Frame, new Rectangle(ptStart, new Size(0, 0)));//使用selectRectGra保存选择区域的当前位置和大小
			}
            Canvas.Instance.GraList.Add(selectRectGra);//添加选择GraList
            this.isSelectRectVisible = true;//设置选择框可见
            Canvas.Instance.Update();//更新画布
		}

		public override void OnMouseMove(MouseEventArgs e)
		{
			if(!this.isDrawing)
				return;
			Point ptEnd = new Point(e.X,e.Y);//Save the current position of mouse
			ptEnd = GetRoundPoint(ptEnd);//Round the end point. The min mouse movement distance is 6.

			
			if(ptEnd == ptPre)//Movement distance < 6
				return;

			ptPre = ptEnd;//Save end point as a temporary point

			ptEnd = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptEnd);//Get current posion.Convert to orginal coordiante when zoom in or zoom out

			if((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
			{
				ptEnd = RegularEndPt(ptStart,ptEnd);
			}

            //设置选择区域的位置和大小
			selectRectGra.Rect = CreateValidRect(ptStart,ptEnd);
			Canvas.Instance.Update();//Update canvas
		}

		public override void OnMouseUp(MouseEventArgs e)
		{

			if(this.isDrawing)
			{
				this.isDrawing = false;//Disable the drawing status
				Rectangle r = this.selectRectGra.Rect;
				if(r.Width <5 || r.Height <5)
				{
					ClerSelectedRect();
					this.selectRectGra = null;
				}
				else
					OnStateChanged();
			}
			
		}
        /// <summary>
        /// 全选
        /// </summary>
        public void AllSelectedRect()
        {
            ptStart = new Point(0, 0);//开始点的选择		
            ptStart = GetRoundPoint(ptStart);//起点
            ptPre = ptStart;//临时使用点

            //在现在的位置转换成原始的，当你放大或坐标缩小
            ptStart = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptStart);
            this.ClerSelectedRect();//Cancel the selected operation
            this.isDrawing = true;  //Drawing status

            //Construct a pen object to draw the select frame
            using (Pen p = new Pen(Color.Black, 1))
            {
                p.DashStyle = DashStyle.Dot;//选择框是虚线
                selectRectGra = new RectGra(p, null,
                    GraDrawMode.Frame, new Rectangle(ptStart, new Size(0, 0)));//使用selectRectGra保存选择区域的当前位置和大小
            }
            Canvas.Instance.GraList.Add(selectRectGra);//添加选择GraList
            this.isSelectRectVisible = true;//设置选择框可见



            Point ptEnd = new Point(Canvas.Instance.Size.Width-3, Canvas.Instance.Size.Height-3);//Save the current position of mouse
            ptEnd = GetRoundPoint(ptEnd);//回合结束点。最小鼠标移动距离为6。


            if (ptEnd == ptPre)//Movement distance < 6
                return;

            ptPre = ptEnd;//Save end point as a temporary point

           // ptEnd = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptEnd);//获取当前posion.Convert到原单coordiante时，放大或缩小

            if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
            {
                ptEnd = RegularEndPt(ptStart, ptEnd);
            }

            //设置选择区域的位置和大小
            selectRectGra.Rect = CreateValidRect(ptStart, ptEnd);
            Canvas.Instance.Update();//更新画布
            OnMouseUp(null);
           
        }
		private Bitmap  copyImage;//Save the select area as a picture
		public  Bitmap  CopyImage
		{
			get { return this.copyImage; }
		}




        /// <summary>
        /// 删除选择区域的图像
        /// </summary>
        public void ClearRectGra()
        {
            if (this.selectRectGra == null) { return; }
	
            Color c = Canvas.Instance.BackColor;//Background color
            Brush b = new SolidBrush(c);
            Pen p = new Pen(c);
            EraseRectGra rGra = new EraseRectGra(p, b, GraDrawMode.Frame | GraDrawMode.Fill,
                this.selectRectGra.Rect);//Set the select area with background color

            b.Dispose();//Dispose the brush object
            p.Dispose();//Dispose the pen object

            Canvas.Instance.AddGra(rGra);

            this.selectRectGra = null;
            OnStateChanged();
        }
		public void  Cut() 
		{

			if(!this.CreateCopyImage())
				return;
//			
			Color c = Canvas.Instance.BackColor;//Background color
			Brush b = new SolidBrush(c);
			Pen  p = new Pen(c);
			EraseRectGra rGra = new EraseRectGra(p,b,GraDrawMode.Frame | GraDrawMode.Fill,
				this.selectRectGra.Rect);//Set the select area with background color

			b.Dispose();//Dispose the brush object
			p.Dispose();//Dispose the pen object

			Canvas.Instance.AddGra(rGra);

			this.selectRectGra = null;
			OnStateChanged();
		}

		private bool   CreateCopyImage()
		{
			if(this.selectRectGra == null)
				return false;;

			this.ClerSelectedRect();//Cancel the select area

			Canvas canvas = Canvas.Instance;//Get instance of canvas

			
			Rectangle destRect = new Rectangle(new Point(0,0),this.selectRectGra.Rect.Size);//Paste the cut area to this rectangle area
			Rectangle souRect = this.selectRectGra.Rect;//Save position and size of select area in souRect
			souRect = canvas.MainView.ConvertCanvasToViewBitmapRect(souRect);//Convert to orginal coordinate when you zoom in or zoom out
			this.copyImage = new Bitmap(destRect.Width,destRect.Height);//construct a image 
			
			//construct a graphic object from copyImage
			using(Graphics g = Graphics.FromImage(this.copyImage))
			{
				//Draw the graph on destination area
				g.DrawImage(MainView.ViewBitmap,destRect,
					souRect.X,souRect.Y,souRect.Width,souRect.Height,GraphicsUnit.Pixel);

			}
	
			this.copyImage.MakeTransparent(Canvas.Instance.BackColor);// Make the copyImage transparent

			return true;

		}

		//Copy operation
		public void  Copy() 
		{
			if(!this.CreateCopyImage())
				return ;
			
			this.selectRectGra = null;
			OnStateChanged();

		}



        private Point contextMenuMousePos; //弹出菜单的位置
        /// <summary>
        /// 弹出菜单的位置
        /// </summary>
		public  Point  ContextMenuMousePos
		{
			get { return contextMenuMousePos; } 
			set { contextMenuMousePos = value; }

		}

		//Paste operation
		public void Paste( )
		{
			this.ClerSelectedRect();//Cancel the select area
			if(this.copyImage == null)//Not did cut or copy operation
				return;
			
			//Convert the paste position.Convert to orginal coordinate when you zoom in or zoom out
			Point pastePos = Canvas.Instance.MainView.ConvertViewToCanvasPt(this.contextMenuMousePos);
	
			//Save select area as a image into imGra
			ImageGra imGra = new ImageGra(this.copyImage.Clone() as Image,
				new Rectangle(pastePos,new Size(this.copyImage.Width,this.copyImage.Height)));

			//Canvas.Instance.GraList.Add(imGra);//Add to GraList
			//Canvas.Instance.Update();//Update canvas
			Canvas.Instance.AddGra(imGra);

		}

		//Active property of SelectDrawTool
		public override bool IsActive
		{
			get
			{
				return base.IsActive;//Return the IsActive of GraDrawTool
			}
			set
			{
				base.IsActive = value;

				//Cancel select operation without doing cut,move or paste
				if(!base.IsActive && this.selectRectGra != null)
				{
					this.ClerSelectedRect();//Cancel the select area
				}
			}
		}


	}

	//It inherit from GraDrawTool(). It is used for drawing rectangle actions.
	//When we mouse to draw a rectangle, we need display some temporary rectangle before we decide the end point of the rectangle.
	public abstract class  RectDrawTool : GraDrawTool
	{
		
		public RectDrawTool(GraDrawMode drawMode)//Get the draw mode:frame or solid
			:base()
		{
			this.drawMode = drawMode;
			this.toolCursor = Cursors.Cross;
		}

		protected  GraDrawMode  drawMode;//protected drawMode variable to save the draw mode

		
		public override string Tip
		{
			get
			{
				return "Pressed 'Shift' key to draw a quare";
			}
		}

		private  RectGra  rectGra;//Save the rectangle
		private  Point    ptStart;//Start postion for drawing
		private  Point    ptPre;  ////Temporary point use for round

		public override void OnMouseDown(MouseEventArgs e)
		{
			this.isDrawing = true;//Drawing status

			ptStart = new Point(e.X,e.Y);//Get new start point
			ptStart = GetRoundPoint(ptStart);//Round the start point
			ptPre = ptStart;//Temporary point use for round

			//Convert the start position to original coordinate when you zoom in or zoom out
			ptStart = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptStart);
			
			//Construct a temporary rectangle to display
			rectGra = new RectGra(DrawEnvMgr.Instance.Pen,DrawEnvMgr.Instance.Brush,
				drawMode,new Rectangle(ptStart,new Size(0,0)));

			//Canvas.Instance.GraList.Add(rectGra);//Add to GraList
			//Canvas.Instance.Update();//Update canvas
			Canvas.Instance.AddGra(rectGra);

		}

		public override void OnMouseMove(MouseEventArgs e)
		{
			if(!this.isDrawing)//Not drawing
				return;
			Point ptEnd = new Point(e.X,e.Y);//Get end point of temporary rectangle
			ptEnd = GetRoundPoint(ptEnd);//Round the end point. The min mouse movement distance is 6.

			

			if(ptEnd == ptPre)//Movement distance < 6
				return;

			ptPre = ptEnd;//Save end point as a temporary point

			//Convert the end position to ordinal coordinate when you zoom in or zoom out
			ptEnd = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptEnd);
			if((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
			{
				ptEnd = RegularEndPt(ptStart,ptEnd);
			}

			rectGra.Rect = CreateValidRect(ptStart,ptEnd);
			Canvas.Instance.Update();//Update canvas
		}

		public override void OnMouseUp(MouseEventArgs e)
		{
			this.isDrawing = false;//Not Drawing
			
		}

	}

	//It inherits from RecaDrawTool(). It is used for drawing frame rectangle. 
	//When we use mouse to draw a rectangle, we need display some temporary rectangle before we decide the end point of the rectangle.
	public class  FrameRectDrawTool : RectDrawTool
	{
		/// <summary>
		///
		/// </summary>
		public FrameRectDrawTool()
			:base(GraDrawMode.Frame)
		{

		}

		//Specify the draw type: frame rectangle
		public override GraDrawType Type
		{
			get
			{
				return GraDrawType.FrameRect;
			}
		}
	}

	//It inherit from RecaDrawTool(). It is used for drawing solid rectangle. 
	//When we use mouse to draw a rectangle, we need display some temporary rectangle before we decide the end point of the rectangle.
	public class  FillRectDrawTool : RectDrawTool
	{
		
		public FillRectDrawTool()
			:base(GraDrawMode.Fill)
		{

		}

		//Specify the draw type: solid rectangle
		public override GraDrawType Type
		{
			get
			{
				return GraDrawType.FillRect;
			}
		}
	}


	//It inherit from GraDrawTool(). It is used for drawing rectangle actions.
	//When we mouse to draw a rectangle, we need display some temporary rectangle before we decide the end point of the rectangle.
	public abstract class  EllipseDrawTool : GraDrawTool
	{
		
		public EllipseDrawTool(GraDrawMode drawMode)//Get the draw mode:frame or solid
			:base()
		{
			this.drawMode = drawMode;
		}

		protected  GraDrawMode  drawMode;//protected drawMode variable to save the draw mode

		private  EllipseGra  ellipseGra;//Save the rectangle
		private  Point    ptStart;//Start postion for drawing
		private  Point    ptPre;  ////Temporary point use for round

		public override string Tip
		{
			get
			{
				return "Pressed 'Shift' key to draw a circle";
			}
		}


		public override void OnMouseDown(MouseEventArgs e)
		{
			this.isDrawing = true;//Drawing status

			ptStart = new Point(e.X,e.Y);//Get new start point
			ptStart = GetRoundPoint(ptStart);//Round the start point
			ptPre = ptStart;//Temporary point use for round

			//Convert the start position to original coordinate when you zoom in or zoom out
			ptStart = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptStart);
			
			//Construct a temporary rectangle to display
			ellipseGra = new EllipseGra(DrawEnvMgr.Instance.Pen,DrawEnvMgr.Instance.Brush,
				drawMode,new Rectangle(ptStart,new Size(0,0)));

			//Canvas.Instance.GraList.Add(ellipseGra);//Add to GraList
			//Canvas.Instance.Update();//Update canvas
			Canvas.Instance.AddGra(ellipseGra);

		}

		public override void OnMouseMove(MouseEventArgs e)
		{
			if(!this.isDrawing)//Not drawing
				return;
			Point ptEnd = new Point(e.X,e.Y);//Get end point of temporary rectangle
			ptEnd = GetRoundPoint(ptEnd);//Round the end point. The min mouse movement distance is 6.

		
			if(ptEnd == ptPre)//Movement distance < 6
				return;

			ptPre = ptEnd;//Save end point as a temporary point

			//Convert the end position to orginal coordinate when you zoom in or zoom out
			ptEnd = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptEnd);
			
			if((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
			{
				ptEnd = RegularEndPt(ptStart,ptEnd);
			}

			ellipseGra.Rect = CreateValidRect(ptStart,ptEnd);
			Canvas.Instance.Update();//Update canvas
		}

		public override void OnMouseUp(MouseEventArgs e)
		{
			this.isDrawing = false;//Not Drawing
			
		}

	}

	//It inherit from RecaDrawTool(). It is used for drawing frame rectangle. 
	//When we use mouse to draw a rectangle, we need display some temporary rectangle before we decide the end point of the rectangle.
	public class  FrameEllipseDrawTool : EllipseDrawTool
	{
		/// <summary>
		///
		/// </summary>
		public FrameEllipseDrawTool()
			:base(GraDrawMode.Frame)
		{
            this.toolCursor = Cursors.Cross;
		}

		//Specify the draw type: frame rectangle
		public override GraDrawType Type
		{
			get
			{
				return GraDrawType.FrameEllipse;
			}
		}
	}

	//It inherit from RecaDrawTool(). It is used for drawing solid rectangle. 
	//When we use mouse to draw a rectangle, we need display some temporary rectangle before we decide the end point of the rectangle.
	public class  FillEllipseDrawTool : EllipseDrawTool
	{
		
		public FillEllipseDrawTool()
			:base(GraDrawMode.Fill)
		{
            this.toolCursor = Cursors.Cross;
		}

		//Specify the draw type: solid rectangle
		public override GraDrawType Type
		{
			get
			{
				return GraDrawType.FillEllipse;
			}
		}
	}


	//It inherit from GraDrawTool(). It is used for insert image actions.
	//When we mouse to draw a rectangle, we need display some temporary rectangle before we decide the end point of the rectangle.
	public  class  ImageDrawTool : GraDrawTool
	{
		
		public ImageDrawTool()//Get the draw mode:frame or solid
			:base()
		{
			this.toolCursor = Cursors.Cross;
		}	

		public override GraDrawType Type
		{
			get
			{
				return GraDrawType.Image;
			}
		}



		private  RectGra  rectGra;//Save the rectangle
		private  Point    ptStart;//Start postion for drawing
		private  Point    ptPre;  ////Temporary point use for round

		public override void OnMouseDown(MouseEventArgs e)
		{
			this.isDrawing = true;//Drawing status

			ptStart = new Point(e.X,e.Y);//Get new start point
			ptStart = GetRoundPoint(ptStart);//Round the start point
			ptPre = ptStart;//Temporary point use for round

			//Convert the start position to original coordinate when you zoom in or zoom out
			ptStart = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptStart);
			
			//Construct a temporary rectangle to display
			rectGra = new RectGra(Pens.DarkBlue,null,
				GraDrawMode.Frame,new Rectangle(ptStart,new Size(0,0)));

			Canvas.Instance.GraList.Add(rectGra);//Add to GraList
			Canvas.Instance.Update();//Update canvas

		}

		public override void OnMouseMove(MouseEventArgs e)
		{
			if(!this.isDrawing)//Not drawing
				return;

			Point ptEnd = new Point(e.X,e.Y);//Get end point of temporary rectangle
			ptEnd = GetRoundPoint(ptEnd);//Round the end point. The min mouse movement distance is 6.

			if((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
			{
				ptEnd = RegularEndPt(ptStart,ptEnd);
			}

			if(ptEnd == ptPre)//Movement distance < 6
				return;

			ptPre = ptEnd;//Save end point as a temporary point

			//Convert the end position to original coordinate when you zoom in or zoom out
			ptEnd = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptEnd);
			
			
			rectGra.Rect = CreateValidRect(ptStart,ptEnd);
			Canvas.Instance.Update();//Update canvas
		}

		public override void OnMouseUp(MouseEventArgs e)
		{
			if(!this.isDrawing)
				return;

			this.isDrawing = false;//Not Drawing
			if(rectGra.Rect.Width <5 && rectGra.Rect.Height <5)
				return;

			Canvas.Instance.GraList.Remove(rectGra);

			OpenFileDialog dlg = new OpenFileDialog();
            dlg.Filter = "位图文件(*.bmp;*.jpg;*.gif;*.png)|*.bmp;*.jpg;*.gif;*.png|Bitmap files (*.bmp)|*.bmp|Jpg files (*.jpg)|*.jpg|All files (*.*)|*.*";
			dlg.FilterIndex = 1 ;
			dlg.RestoreDirectory = true ;
			if(dlg.ShowDialog() == DialogResult.OK)
			{
				
				Bitmap bmp = new Bitmap(dlg.FileName);
				if(bmp != null)
				{
					ImageGra imageGra = new ImageGra(bmp,rectGra.Rect);
					//Canvas.Instance.GraList.Add(imageGra);//Add to GraList
					//Canvas.Instance.Update();//Update canvas
					Canvas.Instance.AddGra(imageGra);

				}
				
			}

			this.rectGra = null;


			
		}

	}


	//It inherit from GraDrawTool(). It is used for insert text actions.
	//When we mouse to draw a rectangle, we need display some temporary rectangle before we decide the end point of the rectangle.
	public  class  TextDrawTool : GraDrawTool
	{
		
		protected  TextDrawTool( )//Get the draw mode:frame or solid
			:base()
		{
			this.toolCursor = Cursors.Cross;
            
		}	

		private static TextDrawTool instance;
		public static TextDrawTool  Instance
		{
			get
			{
				if(instance == null)
					instance = new TextDrawTool();

				return instance;
			}
		}

			public override GraDrawType Type
		{
			get
			{
				return GraDrawType.Text;
			}
		}


		public override string Tip
		{
			get
			{
                return "按“Enter”键停止，点击“ESC”键取消";
			}
		}

		public override bool IsActive
		{
			get
			{
				return base.IsActive;
			}
			set
			{
				base.IsActive = value;
				if(!base.IsActive)
				{
					if(this.textBox != null)
					{
						this.EndTextEditing(true);
					}

				}
			}
		}



        private RectGra rectGra;//保存矩形
		private  Point    ptStart;//Start postion for drawing
		private  Point    ptEnd;
		private  Point    ptPre;  ////Temporary point use for round

		private Point   ptStartView;
		private Point   ptEndView;

		public override void OnMouseDown(MouseEventArgs e)
		{
			if(this.isJustEditing)
			{
				Point pt = new Point(e.X,e.Y);
				if(!textBox.Bounds.Contains(pt))
					this.EndTextEditing(true);

				return ;

			}

			this.isDrawing = true;//Drawing status

			ptStartView = new Point(e.X,e.Y);//Get new start point
			ptStartView = GetRoundPoint(ptStartView);//Round the start point
			ptPre = ptStartView;//Temporary point use for round

			//Convert the start position to original coordinate when you zoom in or zoom out
			ptStart = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptStartView);
			
			//Construct a temporary rectangle to display
			rectGra = new RectGra(Pens.DarkBlue,null,
				GraDrawMode.Frame,new Rectangle(ptStart,new Size(0,0)));
            
			Canvas.Instance.GraList.Add(rectGra);//Add to GraList
			Canvas.Instance.Update();//Update canvas
//
		}

		public override void OnMouseMove(MouseEventArgs e)
		{
            if (this.isJustEditing)//是否只需编辑
				return;

            if (!this.isDrawing)//没有图纸
				return;

			ptEndView = new Point(e.X,e.Y);//Get end point of temporary rectangle
            ptEndView = GetRoundPoint(ptEndView);//回合结束点。最小鼠标移动距离为6。
			if(ptEndView == ptPre)//Movement distance < 6
				return;

			ptPre = ptEndView;//Save end point as a temporary point

            //结束位置转换成原始的，当你放大或坐标缩小
			ptEnd = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptEndView);
			
			
			rectGra.Rect = CreateValidRect(ptStart,ptEnd);
			Canvas.Instance.Update();//Update canvas
		}

        /// <summary>
        /// 是否只需编辑
        /// </summary>
		private  bool  isJustEditing;
		private  TextBox  textBox;

		public override void OnMouseUp(MouseEventArgs e)
		{
			if(this.isJustEditing)
				return;

			if(!this.isDrawing)
				return;

			this.isDrawing = false;//Not Drawing
			if(rectGra.Rect.Width <5 && rectGra.Rect.Height <5)
				return;

			Canvas.Instance.GraList.Remove(rectGra);

			textBox = new TextBox();
			textBox.Multiline = true;
			textBox.BackColor = Canvas.Instance.BackColor;
			textBox.ForeColor = DrawEnvMgr.Instance.Color;
            
			Rectangle viewRect = CreateValidRect(ptStartView,ptEndView);
			
			float s = Canvas.Instance.MainView.ViewMatrix.Elements[0];
			textBox.Bounds = viewRect;
			Font f =DrawEnvMgr.Instance.Font;
			textBox.Font = new Font(f.Name,f.Size*s);
			
			
			Canvas.Instance.MainView.Controls.Add(textBox);
			textBox.Focus();
			textBox.KeyDown +=new KeyEventHandler(textBox_KeyDown);

            this.isJustEditing = true;
			//FontDialog  dlg = new FontDialog(); //instantiating a new fontdialog box
			//dlg.Font = DrawEnvMgr.Instance.Font;
			//if(DialogResult.OK == dlg.ShowDialog())
			//{
			//	DrawEnvMgr.Instance.Font = dlg.Font; // assigning the font selected by the user to DrawEnvMgr.Instance.Font 
			//}

			
		}

        /// <summary>
        /// 完成输入
        /// </summary>
        /// <param name="isValid"></param>
		public  void  EndTextEditing(bool  isValid)
		{
			if(this.textBox == null)
				return;

			this.isJustEditing = false;
			Canvas.Instance.MainView.Controls.Remove(textBox);

			if(isValid && !(textBox.Text == null || textBox.Text.Length == 0))
			{

				TextGra textGra = new TextGra(textBox.Text,DrawEnvMgr.Instance.Font,
					DrawEnvMgr.Instance.Brush,rectGra.Rect);
				//Canvas.Instance.GraList.Add(textGra);//Add to GraList
				//Canvas.Instance.Update();//Update canvas
				Canvas.Instance.AddGra(textGra);
				this.rectGra = null;
				
			}
			
			this.textBox = null;
			Canvas.Instance.Update();


		}

		private void textBox_KeyDown(object sender, KeyEventArgs e)
		{
			if(this.textBox == null)
				return;

			//Click 'Enter' when you complete input text
			if(e.KeyCode == Keys.Enter)
			{
			
				//this.EndTextEditing(true);
				

			}
			else if(e.KeyCode == Keys.Escape)
			{
				this.EndTextEditing(false);
			}


		}

		
	}

	//It inherit from GraDrawTool(). It is used for drawing line actions.
	//When we mouse to draw a line, we need display some temporary lines before we decide the end point of the line
     
	public class  LineDrawTool : GraDrawTool
	{
		
		public LineDrawTool()
			:base()
		{
			//this.toolCursor = Cursors.Cross;
            Bitmap cursorBmp = new Bitmap(GraEditor.Properties.Resources.pen, new Size(64, 64));
            this.toolCursor = new Cursor(cursorBmp.GetHicon());
		}

		//Specify the draw type: line
		public override GraDrawType Type
		{
			get
			{
				return GraDrawType.Line;
			}
		}

		public override string Tip
		{
			get
			{
                return "按下“shift'键绘制水平或垂直线";
			}
		}


		private  LineGra  lineGra;//Save the start point,end point,color and width of line

		private  Point  ptStart;
		private  Point ptPre;//Temporary point use for round

		public override void OnMouseDown(MouseEventArgs e)
		{

			this.isDrawing = true;//Drawing status

			ptStart = new Point(e.X,e.Y);//Start point
			ptStart = GetRoundPoint(ptStart);//Round point
			ptPre = ptStart;//Temporary point use for round

			//Convert the start position to original coordinate when you zoom in or zoom out
			Point pt = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptStart);
           
			//Construct a temporary line to display
			lineGra = new LineGra(DrawEnvMgr.Instance.Pen,
				pt,pt);
            
			//Canvas.Instance.GraList.Add(lineGra);//Add to GraList
			//Canvas.Instance.Update();//Update canvas
			Canvas.Instance.AddGra(lineGra);

		}

	

		public override void OnMouseMove(MouseEventArgs e)
		{
			if(!this.isDrawing)//Drawing Status=false
				return;
			Point ptEnd = new Point(e.X,e.Y);//Temporary end point
			ptEnd = GetRoundPoint(ptEnd);//Round the end point. The min mouse movement distance is 6.

			if((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
			{
				int sx = Math.Abs(ptEnd.X - ptStart.X);
				int sy = Math.Abs(ptEnd.Y - ptStart.Y);
				if(sy < sx)
					ptEnd.Y = ptStart.Y;
				else
					ptEnd.X = ptStart.X;
			}

			if( ptEnd == ptPre)//Movement distance < 6
				return;

			ptPre = ptEnd;//Save end point as a temporary point

			//Convert the end position to original coordinate when you zoom in or zoom out
			ptEnd = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptEnd);
			
			lineGra.EndPt = ptEnd;//Set the end point to LineGra
			Canvas.Instance.Update();//Update canvas 

		}

		public override void OnMouseUp(MouseEventArgs e)
		{
			this.isDrawing = false;//Drawing status = false
			
		}

	}

    public class ArrowDrawTool : GraDrawTool
    {

        public ArrowDrawTool()
            : base()
        {
           // this.toolCursor = Cursors.Cross;
            Bitmap cursorBmp = new Bitmap(GraEditor.Properties.Resources.pen, new Size(64, 64));
            this.toolCursor = new Cursor(cursorBmp.GetHicon());
        }

        //Specify the draw type: line
        public override GraDrawType Type
        {
            get
            {
                return GraDrawType.Arrow;
            }
        }

        public override string Tip
        {
            get
            {
                return "按下“shift'键绘制水平或垂箭头";
            }
        }


        private ArrowGra arrowGra;//Save the start point,end point,color and width of line

        private Point ptStart;
        private Point ptPre;//Temporary point use for round

        public override void OnMouseDown(MouseEventArgs e)
        {

            this.isDrawing = true;//Drawing status

            ptStart = new Point(e.X, e.Y);//Start point
            ptStart = GetRoundPoint(ptStart);//Round point
            ptPre = ptStart;//Temporary point use for round

            //Convert the start position to original coordinate when you zoom in or zoom out
            Point pt = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptStart);

            //Construct a temporary line to display
            AdjustableArrowCap lineArrow = new AdjustableArrowCap(4f, 4f, true);
            //Pen pen = new Pen(DrawEnvMgr.Instance.Pen.Color, DrawEnvMgr.Instance.Pen.Width);
           // pen.CustomEndCap = lineArrow;
            arrowGra = new ArrowGra(DrawEnvMgr.Instance.Pen,
                pt, pt);

            arrowGra.PenExt.Pen.CustomEndCap = lineArrow;
            //Canvas.Instance.GraList.Add(lineGra);//Add to GraList
            //Canvas.Instance.Update();//Update canvas
            Canvas.Instance.AddGra(arrowGra);

        }



        public override void OnMouseMove(MouseEventArgs e)
        {
            if (!this.isDrawing)//Drawing Status=false
                return;
            Point ptEnd = new Point(e.X, e.Y);//Temporary end point
            ptEnd = GetRoundPoint(ptEnd);//Round the end point. The min mouse movement distance is 6.

            if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
            {
                int sx = Math.Abs(ptEnd.X - ptStart.X);
                int sy = Math.Abs(ptEnd.Y - ptStart.Y);
                if (sy < sx)
                    ptEnd.Y = ptStart.Y;
                else
                    ptEnd.X = ptStart.X;
            }

            if (ptEnd == ptPre)//Movement distance < 6
                return;

            ptPre = ptEnd;//Save end point as a temporary point

            //Convert the end position to original coordinate when you zoom in or zoom out
            ptEnd = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptEnd);

            arrowGra.EndPt = ptEnd;//Set the end point to LineGra
            Canvas.Instance.Update();//Update canvas 

        }

        public override void OnMouseUp(MouseEventArgs e)
        {
            this.isDrawing = false;//Drawing status = false

        }

    }
    /// <summary>
    /// 平移视图
    /// </summary>
    public class MobileViewsDrawTool : GraDrawTool
    {
        Bitmap cursorBmp64 = new Bitmap(GraEditor.Properties.Resources.hand_48, new Size(64, 64));
        Bitmap cursorBmp56= new Bitmap(GraEditor.Properties.Resources.hand_48, new Size(60, 60));
        public MobileViewsDrawTool()
            : base()
        {
           // this.toolCursor = new Cursor(GraEditor.Properties.Resources.hand_48.GetHicon());// Cursors.SizeAll;
           
            this.toolCursor = new Cursor(cursorBmp64.GetHicon());
        }

        //Specify the draw type: line
        public override GraDrawType Type
        {
            get
            {
                return GraDrawType.MobileViews;
            }
        }

        public override string Tip
        {
            get
            {
                return "按下左键移动视图";
            }
        }


     //   private ArrowGra arrowGra;//Save the start point,end point,color and width of line

        private Point ptStart;
        private Point ptPre;//临时使用的点

        public override void OnMouseDown(MouseEventArgs e)
        {

            this.isDrawing = true;//Drawing status

            ptStart = new Point(e.X, e.Y);//Start point
            ptStart = GetRoundPoint(ptStart);//Round point
            ptPre = ptStart;//Temporary point use for round
            
            Canvas.Instance.MainView.Cursor = new Cursor(cursorBmp56.GetHicon());
        }



        public override void OnMouseMove(MouseEventArgs e)
        {
            if (!this.isDrawing)//Drawing Status=false
                return;
            Point ptEnd = new Point(e.X, e.Y);//Temporary end point
            ptEnd = GetRoundPoint(ptEnd);//Round the end point. The min mouse movement distance is 6.

            int mSpeed = 30;
            /// <summary>
            /// 移动步长值
            /// </summary>
            int moveAmount = 10;
            if (e.Button == MouseButtons.Left)
            {
                if (ptStart.Y > ptEnd.Y + mSpeed)
                {//向右

                    if (Canvas.Instance.MainView.VerticalScroll.Value + moveAmount >= Canvas.Instance.MainView.VerticalScroll.Maximum)
                    {
                        Canvas.Instance.MainView.VerticalScroll.Value = Canvas.Instance.MainView.VerticalScroll.Maximum;
                    }
                    else
                    {
                        Canvas.Instance.MainView.VerticalScroll.Value += moveAmount;
                    }
                }
                else if (ptStart.Y < ptEnd.Y - mSpeed)
                {
                    //向左
                    if (Canvas.Instance.MainView.VerticalScroll.Value - moveAmount <= 0)
                    {
                        Canvas.Instance.MainView.VerticalScroll.Value = 0;
                    }
                    else
                    {
                        Canvas.Instance.MainView.VerticalScroll.Value -= moveAmount;
                    }
                }

                if (ptStart.X > ptEnd.X + mSpeed)
                //向下
                {
                    if (Canvas.Instance.MainView.HorizontalScroll.Value + moveAmount >= Canvas.Instance.MainView.HorizontalScroll.Maximum)
                    {
                        Canvas.Instance.MainView.HorizontalScroll.Value = Canvas.Instance.MainView.HorizontalScroll.Maximum;
                    }
                    else
                    {
                        Canvas.Instance.MainView.HorizontalScroll.Value += moveAmount;
                    }


                }
                else if (ptStart.X < ptEnd.X - mSpeed)
                {//向上
                    if (Canvas.Instance.MainView.HorizontalScroll.Value - moveAmount <= 0)
                    {
                        Canvas.Instance.MainView.HorizontalScroll.Value = 0;
                    }
                    else
                    {
                        Canvas.Instance.MainView.HorizontalScroll.Value -= moveAmount;

                    }
                }


            }
        }

        public override void OnMouseUp(MouseEventArgs e)
        {
            this.isDrawing = false;//Drawing status = false
            Canvas.Instance.MainView.Cursor = new Cursor(cursorBmp64.GetHicon());
        }

    }
	//It inherit from GraDrawTool(). It is used for drawing lines actions.
	//When we mouse to draw a line, we need display some temporary lines before we decide the end point of the line
	public class  LinesDrawTool : GraDrawTool
	{
		
		public LinesDrawTool()
			:base()
		{
			this.ptList = new ArrayList();
			//this.toolCursor = Cursors.Cross;
            Bitmap cursorBmp = new Bitmap(GraEditor.Properties.Resources.pen, new Size(64, 64));
            this.toolCursor = new Cursor(cursorBmp.GetHicon());
		}

		//Specify the draw type: line
		public override GraDrawType Type
		{
			get
			{
				return GraDrawType.Lines;
			}
		}

		public override string Tip
		{
			get
			{
                return "双击鼠标左键，完成画线";
			}
		}


		private  LinesGra  linesGra;//Save the start point,end point,color and width of line
		
		private  ArrayList  ptList;

        private Point ptStart;

		public override void OnMouseDown(MouseEventArgs e)
		{
			 ptStart = new Point(e.X,e.Y);//Start point
			ptStart = GetRoundPoint(ptStart);//Round point
			//Point ptPre = ptStart;//Temporary point use for round
			//Convert the start position to orginal coordinate when you zoom in or zoom out
			Point pt = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptStart);

			if( !this.isDrawing)
			{
				//start creating lines graph element
				
				this.isDrawing = true;//Drawing status
				ptList.Clear();
				ptList.Add(pt);

			
				//Construct a temporary line to display
				linesGra = new LinesGra(DrawEnvMgr.Instance.Pen,
					new Point[]{pt});
				
				Canvas.Instance.GraList.Add(linesGra);//Add to GraList
				Canvas.Instance.IsModified = true;
			}
			else
			{
				ptList.Add(pt);
				Point[] pts = ptList.ToArray(typeof(Point)) as Point[];
				linesGra.Pts = pts;
			}

			Canvas.Instance.Update();//Update canvas

		}

		private Point ptPre;//Temproary point use for round

		public override void OnMouseMove(MouseEventArgs e)
		{
			if(!this.isDrawing)//Drawing Status=false
				return;
			Point ptEnd = new Point(e.X,e.Y);//Temproary end point
			ptEnd = GetRoundPoint(ptEnd);//Round the end point. The min mouse movement distance is 6.
            if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
            {
                int sx = Math.Abs(ptEnd.X - ptStart.X);
                int sy = Math.Abs(ptEnd.Y - ptStart.Y);
                if (sy < sx)
                    ptEnd.Y = ptStart.Y;
                else
                    ptEnd.X = ptStart.X;
            }
			if( ptEnd == ptPre)//Movement distance < 6
				return;

			ptPre = ptEnd;//Save end point as a temproary point

			//Convert the end position to orginal coordinate when you zoom in or zoom out
			ptEnd = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptEnd);

			if(ptList.Count > 1)
				ptList.RemoveAt(ptList.Count-1);

			ptList.Add(ptEnd);

			Point[] pts = ptList.ToArray(typeof(Point)) as Point[];
			
			linesGra.Pts = pts;//Set the end point to LineGra
			Canvas.Instance.Update();//Update canvas 

		}


		public override void OnMouseUp(MouseEventArgs e)
		{
			//Do nothing
            
		}

		public override void OnDoubleClick(EventArgs e)
		{
			this.isDrawing = false;//Drawing status = false
			
		}

        public override void OnKeyUp(KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Escape||e.KeyCode== Keys.Enter)
            {
                this.isDrawing = false;
                Point ptEnd = new Point(ptStart.X, ptStart.Y);//Temproary end point
                ptEnd = GetRoundPoint(ptEnd);
                ptEnd = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptEnd);
                if (ptList.Count > 1)
                    ptList.RemoveAt(ptList.Count - 1);
                ptList.Add(ptEnd);
                Point[] pts = ptList.ToArray(typeof(Point)) as Point[];

                linesGra.Pts = pts;//Set the end point to LineGra
                Canvas.Instance.Update();//Update canvas 
            }
            //base.OnKeyUp(e);
        }
	}

    //它从GraDrawTool继承（）。它是用于绘制线条的操作。
    //当我们的鼠标擦除
	public class  EraseDrawTool : GraDrawTool
	{
		
		public EraseDrawTool()
			:base()
		{
			this.ptList = new ArrayList();
           // this.toolCursor = CreateCursor(GraEditor.Properties.Resources.EraseCursor);
            Bitmap cursorBmp = new Bitmap(GraEditor.Properties.Resources.draw_2562, new Size(64, 64));
            
            this.toolCursor = new Cursor(cursorBmp.GetHicon());
			//Cursor
		}

		//Specify the draw type: line
		public override GraDrawType Type
		{
			get
			{
				return GraDrawType.Erase;
			}
		}

			
		private  ArrayList  ptList;
		private  Point  ptStart;
		private  Point  ptStartView;
		private Point ptPreView;//Temporary point use for round

		public override void OnMouseDown(MouseEventArgs e)
		{
			ptStartView = new Point(e.X,e.Y);//Start point
			ptStart = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptStartView);

			if( !this.isDrawing)
			{
				//start creating lines graph element
				Color eraseColor=Canvas.Instance.BackColor;
				float sx = Canvas.Instance.MainView.ViewMatrix.Elements[0];
                float w = sx * 10;
				this.erasePen = new Pen(eraseColor,w);

				
				this.isDrawing = true;//Drawing status
				ptList.Clear();
				ptList.Add(ptStart);

				ptPreView = ptStartView;
                 

			}

		}

		private Pen erasePen;

		public override void OnMouseMove(MouseEventArgs e)
		{
			if(!this.isDrawing)//Drawing Status=false
				return;
			Point ptCurView = new Point(e.X,e.Y);//Temporary end point

			//Convert the end position to original coordinate when you zoom in or zoom out
			Point ptCur = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptCurView);


			ptList.Add(ptCur);
			
			using(Graphics g = Canvas.Instance.MainView.CreateGraphics())
			{
				Rectangle rc = new Rectangle(new Point(0,0),Canvas.Instance.Size);
				rc = Canvas.Instance.MainView.ConvertCanvasToViewBitmapRect(rc);
				Region r = new Region(rc);
				Region old = g.Clip;
				g.Clip = r;
				g.DrawLine(this.erasePen,ptPreView,ptCurView);
				g.Clip = old;
			}

			ptPreView = ptCurView;
			

		}


		public override void OnMouseUp(MouseEventArgs e)
		{
			if(this.isDrawing)
			{
				this.isDrawing = false;//Drawing status = false

				Point[] pts = ptList.ToArray(typeof(Point)) as Point[];
				EraseLinesGra linesGra = new EraseLinesGra(this.erasePen,pts);
				Canvas.Instance.GraList.Add(linesGra);
				Canvas.Instance.IsModified = true;
			}
		}


	}

	public class  FreehandDrawTool : GraDrawTool
	{
		
		public FreehandDrawTool()
			:base()
		{
			this.ptList = new ArrayList();
			//this.toolCursor = Cursors.Cross;
            Bitmap cursorBmp = new Bitmap(GraEditor.Properties.Resources.Freehand, new Size(64, 64));

            this.toolCursor = new Cursor(cursorBmp.GetHicon());
			//Cursor
		}

		//Specify the draw type: line
		public override GraDrawType Type
		{
			get
			{
				return GraDrawType.Freehand;
			}
		}

			
		private  ArrayList  ptList;
		private  Point  ptStart;
		private  Point  ptStartView;
		private Point ptPreView;//Temporary point use for round

		public override void OnMouseDown(MouseEventArgs e)
		{
			ptStartView = new Point(e.X,e.Y);//Start point
			ptStart = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptStartView);

			if( !this.isDrawing)
			{
				//start creating lines graph element
				
				this.isDrawing = true;//Drawing status
				ptList.Clear();
				ptList.Add(ptStart);

				ptPreView = ptStartView;
                 

			}

		}

		

		public override void OnMouseMove(MouseEventArgs e)
		{
			if(!this.isDrawing)//Drawing Status=false
				return;
			Point ptCurView = new Point(e.X,e.Y);//Temporary end point

			//Convert the end position to orginal coordinate when you zoom in or zoom out
			Point ptCur = Canvas.Instance.MainView.ConvertViewToCanvasPt(ptCurView);


			ptList.Add(ptCur);
			
			Pen p = DrawEnvMgr.Instance.Pen;
			using(Graphics g = Canvas.Instance.MainView.CreateGraphics())
			{
				Rectangle rc = new Rectangle(new Point(0,0),Canvas.Instance.Size);
				rc = Canvas.Instance.MainView.ConvertCanvasToViewBitmapRect(rc);
				Region r = new Region(rc);
				Region old = g.Clip;
				g.Clip = r;
				g.DrawLine(p,ptPreView,ptCurView);
				g.Clip = old;
			}

			ptPreView = ptCurView;
			

		}


		public override void OnMouseUp(MouseEventArgs e)
		{
			if(this.isDrawing)
			{
				this.isDrawing = false;//Drawing status = false

				Point[] pts = ptList.ToArray(typeof(Point)) as Point[];
				FreehandLinesGra linesGra = new FreehandLinesGra(DrawEnvMgr.Instance.Pen,pts);
				Canvas.Instance.GraList.Add(linesGra);
				Canvas.Instance.IsModified = true;
			}
		}


	}
}