my crop is working fine for first click only then after its showing crop but its sensitivity is very high and taking error image sometimes in my picturebox

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;

namespace CanonImageVB.Classes
{
    class UserRect
    {
     
        private PictureBox mPictureBox;
        public static Rectangle rect;
        public bool allowDeformingDuringMovement = false;
        private bool mIsClick = false;
        private bool mMove = false;
        private int oldX;
        private int oldY;
        private int sizeNodeRect = 5;
        private Bitmap mBmp = null;
        private PosSizableRect nodeSelected = PosSizableRect.None;
        private int angle = 30;
        public static int Width;
        public static int Height;
        public static int CurrX;
        public static int CurrY;
        //public static int gridSize;
        public static int SGridLine;
        private enum PosSizableRect
        {
            UpMiddle,
            LeftMiddle,
            LeftBottom,
            LeftUp,
            RightUp,
            RightMiddle,
            RightBottom,
            BottomMiddle,
            None

        };
      
        public UserRect(Rectangle r)
        {
            rect = r;
            mIsClick = false;
        }

        public void Draw(Graphics g)
        {
            Pen  p = new Pen(Color.Red, 4);
            g.DrawRectangle(p,rect);
            

            foreach (PosSizableRect pos in Enum.GetValues(typeof(PosSizableRect)))
            {
                g.DrawRectangle(p, GetRect(pos));
            }
           

            int gridSize = 30;
            int x = gridSize;
            Pen WPen = new Pen(System.Drawing.Color.White,3);
            Pen BPen = new Pen(System.Drawing.Color.Black, 3);
            int i = 0;

            int y = gridSize;
            int xx = 0, yy = 0;
            xx = 565 / 2;
            yy = 415 / 2;
            if (SGridLine == 1)
            {
                g.DrawLine(BPen, xx, 0, xx, 415);
                g.DrawLine(WPen, 0, yy,565, yy);
            }

            else if (SGridLine == 2)
            {
                while (x < 415)
                {
                    if (i % 2 == 0)
                    {
                        g.DrawLine(BPen, x, 0, x, 565);
                    }
                    else
                    {
                        g.DrawLine(WPen, x, 0, x, 565);
                    }
                    x += gridSize;
                    i = i + 1;
                }

                i = 0;
                while (y < 415)
                {
                    if (i % 2 == 0)
                    {
                        g.DrawLine(WPen, 0, y, 565, y);
                    }
                    else
                    {
                        g.DrawLine(BPen, 0, y, 565, y);
                    }
                    y += gridSize;
                    i = i + 1;
                }

            }

            

        }

        public void SetBitmapFile(string filename)
        {
            this.mBmp = new Bitmap(filename);
        }

        public void SetBitmap(Bitmap bmp)
        {
            this.mBmp = bmp;
        }

        public void SetPictureBox(PictureBox p)
        {
            this.mPictureBox = p;
            mPictureBox.MouseDown += new MouseEventHandler(mPictureBox_MouseDown);
            mPictureBox.MouseUp += new MouseEventHandler(mPictureBox_MouseUp);
            mPictureBox.MouseMove += new MouseEventHandler(mPictureBox_MouseMove);
            mPictureBox.Paint += new PaintEventHandler(mPictureBox_Paint);
        }
        public static Image AddGridlines(Image img, int gridSize, int SGridLine)
        {


            Graphics g = Graphics.FromImage(img);


            int x = gridSize;
            Pen WPen = new Pen(System.Drawing.Color.White,-100);
            Pen BPen = new Pen(System.Drawing.Color.Black, 3);
            int i = 0;

            int y = gridSize;
            int xx = 0, yy = 0;
            xx = img.Width / 2;
            yy = img.Height / 2;
            if (SGridLine == 1)
            {
                g.DrawLine(BPen, xx, 0, xx, img.Height);
                g.DrawLine(WPen, 0, yy, img.Width, yy);
            }
            else if (SGridLine == 2)
            {
                while (x < img.Width)
                {
                    if (i % 2 == 0)
                    {
                        g.DrawLine(BPen, x, 0, x, img.Height);
                    }
                    else
                    {
                        g.DrawLine(WPen, x, 0, x, img.Height);
                    }
                    x += gridSize;
                    i = i + 1;
                }

                i = 0;
                while (y < img.Height)
                {
                    if (i % 2 == 0)
                    {
                        g.DrawLine(WPen, 0, y, img.Width, y);
                    }
                    else
                    {
                        g.DrawLine(BPen, 0, y, img.Width, y);
                    }
                    y += gridSize;
                    i = i + 1;
                }

            }
            return img;

        }
     
        private void mPictureBox_Paint(object sender, PaintEventArgs e)
        {
            try
            {
                Draw(e.Graphics);
            }
            catch (Exception exp)
            {
                System.Console.WriteLine(exp.Message);
            } 
        }

        private void mPictureBox_MouseDown(object sender, MouseEventArgs e)
        {
            mIsClick = true;

            nodeSelected = PosSizableRect.None;
            nodeSelected = GetNodeSelectable(e.Location);

            if (rect.Contains(new Point(e.X, e.Y)))
            {
                mMove = true;
            }
            oldX = e.X;
            oldY = e.Y;
        }

        private void mPictureBox_MouseUp(object sender, MouseEventArgs e)
        {
            mIsClick = false;
            mMove = false;
        }
        Point pt;
        private void mPictureBox_MouseMove(object sender, MouseEventArgs e)
        {
         
           ChangeCursor(e.Location);

            if (mIsClick == false)
            {
                return;
            }

            Rectangle backupRect = rect;

            switch (nodeSelected)
            {
                case PosSizableRect.LeftUp:
                    rect.X += e.X - oldX;
                    rect.Width -= e.X - oldX;

                    rect.Y += e.Y - oldY;
                    rect.Height -= e.Y - oldY;
                    break;
                case PosSizableRect.LeftMiddle:
                    rect.X += e.X - oldX;
                    rect.Width -= e.X - oldX;
                    break;
                case PosSizableRect.LeftBottom:
                    rect.Width -= e.X - oldX;
                    rect.X += e.X - oldX;
                    rect.Height += e.Y - oldY;
                    break;
                case PosSizableRect.BottomMiddle:
                    rect.Height += e.Y - oldY;
                    break;
                case PosSizableRect.RightUp:
                    rect.Width += e.X - oldX;
                    rect.Y += e.Y - oldY;
                    rect.Height -= e.Y - oldY;
                    break;
                case PosSizableRect.RightBottom:
                    rect.Width += e.X - oldX;
                    rect.Height += e.Y - oldY;
                    break;
                case PosSizableRect.RightMiddle:
                    rect.Width += e.X - oldX;
                    break;

                case PosSizableRect.UpMiddle:
                    rect.Y += e.Y - oldY;
                    rect.Height -= e.Y - oldY;
                    break;

                default:

                    if (mMove)
                    {

                        rect.X = rect.X + e.X - oldX;

                        rect.Y = rect.Y + e.Y - oldY;

                    }
                    break;
            }
            oldX = e.X;
            oldY = e.Y;

            if (rect.Width < 50 || rect.Height < 50)
            {
                rect = backupRect;
            }

            TestIfRectInsideArea();

            mPictureBox.Invalidate();
            Width = rect.Width;
            Height = rect.Height;
            CurrX = rect.X;
            CurrY = rect.Y;
           
        }

        private void TestIfRectInsideArea()
        {
            // Test if rectangle still inside the area.
            if (rect.X < 0) rect.X = 0;
            if (rect.Y < 0) rect.Y = 0;
            if (rect.Width <= 0) rect.Width = 1;
            if (rect.Height <= 0) rect.Height = 1;

            if (rect.X + rect.Width > mPictureBox.Width)
            {
                rect.Width = mPictureBox.Width - rect.X ; // -1 to be still show 
                if (allowDeformingDuringMovement == false)
                {
                    mIsClick = false;
                }
            }
            if (rect.Y + rect.Height > mPictureBox.Height)
            {
                rect.Height = mPictureBox.Height - rect.Y ;// -1 to be still show 
                if (allowDeformingDuringMovement == false)
                {
                    mIsClick = false;
                }
            }
        }

        private Rectangle CreateRectSizableNode(int x, int y)
        {
            return new Rectangle(x - sizeNodeRect / 2, y - sizeNodeRect / 2, sizeNodeRect, sizeNodeRect);
        }

        private Rectangle GetRect(PosSizableRect p)
        {
            switch (p)
            {
                case PosSizableRect.LeftUp:
                    return CreateRectSizableNode(rect.X, rect.Y);

                case PosSizableRect.LeftMiddle:
                    return CreateRectSizableNode(rect.X, rect.Y + +rect.Height / 2);

                case PosSizableRect.LeftBottom:
                    return CreateRectSizableNode(rect.X, rect.Y + rect.Height);

                case PosSizableRect.BottomMiddle:
                    return CreateRectSizableNode(rect.X + rect.Width / 2, rect.Y + rect.Height);

                case PosSizableRect.RightUp:
                    return CreateRectSizableNode(rect.X + rect.Width, rect.Y);

                case PosSizableRect.RightBottom:
                    return CreateRectSizableNode(rect.X + rect.Width, rect.Y + rect.Height);

                case PosSizableRect.RightMiddle:
                    return CreateRectSizableNode(rect.X + rect.Width, rect.Y + rect.Height / 2);

                case PosSizableRect.UpMiddle:
                    return CreateRectSizableNode(rect.X + rect.Width / 2, rect.Y);
                default:
                    return new Rectangle();
            }
        }

        private PosSizableRect GetNodeSelectable(Point p)
        {
            foreach (PosSizableRect r in Enum.GetValues(typeof(PosSizableRect)))
            {
                if (GetRect(r).Contains(p))
                {
                    return r;
                }
            }
            return PosSizableRect.None;
        }

        private void ChangeCursor(Point p)
        {
            mPictureBox.Cursor = GetCursor(GetNodeSelectable(p));
        }

        /// <summary>
        /// Get cursor for the handle
        /// </summary>
        /// <param name="p"></param>
        /// <returns></returns>
        private Cursor GetCursor(PosSizableRect p)
        {
            switch (p)
            {
                case PosSizableRect.LeftUp:
                    return Cursors.SizeNWSE;

                case PosSizableRect.LeftMiddle:
                    return Cursors.SizeWE;

                case PosSizableRect.LeftBottom:
                    return Cursors.SizeNESW;

                case PosSizableRect.BottomMiddle:
                    return Cursors.SizeNS;

                case PosSizableRect.RightUp:
                    return Cursors.SizeNESW;

                case PosSizableRect.RightBottom:
                    return Cursors.SizeNWSE;

                case PosSizableRect.RightMiddle:
                    return Cursors.SizeWE;

                case PosSizableRect.UpMiddle:
                    return Cursors.SizeNS;
                default:
                    return Cursors.Default;
            }
        }

    }
}