simple image control

 public partial class ImagePanel : UserControl
    {
        private const float REGION_BORDER_SIZE = 1.0f;

        private Image m_image;
        private float m_zoomRate;
        PointF m_displayLocation;
        private bool m_isInMoving;
        private PointF m_mouseDownPoint;
        private List<RectangleF> m_regions;
        private bool m_isDrawing;
        private bool m_isDraging;
        private PointF m_currentMousePoint;
        private Color m_penColor;

        public ImagePanel()
        {
            InitializeComponent();

            m_zoomRate = 1.0f;
            m_displayLocation = new PointF(0.0f, 0.0f);
            m_isInMoving = false;
            m_mouseDownPoint = new PointF(0.0f, 0.0f);
            m_isDrawing = false;
            m_isDraging = false;
            m_currentMousePoint = new PointF(0.0f, 0.0f);
            m_penColor = Color.Red;
            m_regions = new List<RectangleF>();
        }

        public Image Image
        {
            get
            {
                return m_image;
            }
            set
            {
                m_image = value;
                Reset();
            }
        }

        public void StartDraw()
        {
            m_isDrawing = true;
            this.Cursor = Cursors.Cross;
        }

        public void EndDraw()
        {
            m_isDrawing = false;

            if (m_zoomRate > 1.0f)
            {
                this.Cursor = Cursors.NoMove2D;
            }
            else
            {
                this.Cursor = Cursors.Default;
            }
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            Painting();
        }

        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);

            Painting();
        }

        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);

            if (m_isDraging)
            {
                m_currentMousePoint = new PointF((float)e.X, (float)e.Y);
                Painting();
            }
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);

            if (m_isDrawing)
            {
                m_isDraging = true;
                m_mouseDownPoint = new PointF((float)e.X, (float)e.Y);
            }
            else
            {
                if (m_zoomRate > 1.0f)
                {
                    if (e.Button == MouseButtons.Left)
                    {
                        m_mouseDownPoint = e.Location;
                        m_isInMoving = true;
                    }
                }
            }
        }

        protected override void OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp(e);

            if (m_isDrawing)
            {
                m_isDraging = false;

                RectangleF objRect = new RectangleF();
                if ((float)e.X > m_mouseDownPoint.X)
                {
                    objRect.X = (m_mouseDownPoint.X - m_displayLocation.X) / m_zoomRate;
                }
                else
                {
                    objRect.X = ((float)e.X - m_displayLocation.X) / m_zoomRate;
                }
                if ((float)e.Y > m_mouseDownPoint.Y)
                {
                    objRect.Y = (m_mouseDownPoint.Y - m_displayLocation.Y) / m_zoomRate;
                }
                else
                {
                    objRect.Y = ((float)e.Y - m_displayLocation.Y) / m_zoomRate;
                }
                objRect.Width = Math.Abs(e.X - m_mouseDownPoint.X) / m_zoomRate;
                objRect.Height = Math.Abs(e.Y - m_mouseDownPoint.Y) / m_zoomRate;
                m_regions.Add(objRect);

                Painting();
            }
            else
            {
                if (m_isInMoving)
                {
                    m_displayLocation.X = m_displayLocation.X + (float)e.X - m_mouseDownPoint.X;
                    m_displayLocation.Y = m_displayLocation.Y + (float)e.Y - m_mouseDownPoint.Y;

                    if ((float)m_image.Width / (float)m_image.Height > (float)this.Width / (float)this.Height)
                    {
                        if (m_displayLocation.X > 0.0f)
                        {
                            m_displayLocation.X = 0.0f;
                        }
                        else if (m_displayLocation.X < (float)this.Width - (float)this.Width * m_zoomRate)
                        {
                            m_displayLocation.X = (float)this.Width - (float)this.Width * m_zoomRate;
                        }

                        if ((m_displayLocation.Y > 0.0f) && ((float)m_image.Height * m_zoomRate > (float)this.Height))
                        {
                            m_displayLocation.Y = 0.0f;
                        }
                        else if ((m_displayLocation.Y < (float)this.Height - (int)((float)this.Height * m_zoomRate)) &&
                            ((float)m_image.Height * m_zoomRate > (float)this.Height))
                        {
                            m_displayLocation.Y = (float)this.Height - (float)this.Height * m_zoomRate;
                        }
                    }
                    else
                    {
                        if ((m_displayLocation.X > 0.0f) && ((float)m_image.Width * m_zoomRate > (float)this.Width))
                        {
                            m_displayLocation.X = 0.0f;
                        }
                        else if ((m_displayLocation.X < (float)this.Width - (float)this.Width * m_zoomRate) &&
                            ((float)m_image.Width * m_zoomRate > (float)this.Width))
                        {
                            m_displayLocation.X = (float)this.Width - (float)this.Width * m_zoomRate;
                        }

                        if (m_displayLocation.Y > 0.0f)
                        {
                            m_displayLocation.Y = 0.0f;
                        }
                        else if (m_displayLocation.Y < (float)this.Height - (float)this.Height * m_zoomRate)
                        {
                            m_displayLocation.Y = (float)this.Height - (float)this.Height * m_zoomRate;
                        }
                    }

                    m_isInMoving = false;
                    Painting();
                }
            }
        }

        public void ZoomOut()
        {
            if (m_zoomRate < 3.5f)
            {
                m_zoomRate += 0.1f;

                if (m_isDrawing)
                {
                    this.Cursor = Cursors.Cross;
                }
                else
                {
                    if (m_zoomRate > 1.0f)
                    {
                        this.Cursor = Cursors.NoMove2D;
                    }
                    else
                    {
                        this.Cursor = Cursors.Default;
                    }
                }

                if (m_zoomRate == 1.0f)
                {
                    m_displayLocation.X = 0.0f;
                    m_displayLocation.Y = 0.0f;
                }
                else
                {
                    float fltAdjustLocationX = (float)this.Width * 0.1f / 2.0f;
                    float fltAdjustLocationY = (float)this.Height * 0.1f / 2.0f;
                    m_displayLocation.X = m_displayLocation.X - fltAdjustLocationX;
                    m_displayLocation.Y = m_displayLocation.Y - fltAdjustLocationY;
                }

                if (m_zoomRate > 1.0f)
                {
                    if (m_displayLocation.X > 0.0f)
                    {
                        m_displayLocation.X = 0.0f;
                    }
                    else if (m_displayLocation.X < (float)this.Width - (float)this.Width * m_zoomRate)
                    {
                        m_displayLocation.X = (float)this.Width - (float)this.Width * m_zoomRate;
                    }

                    if (m_displayLocation.Y > 0.0f)
                    {
                        m_displayLocation.Y = 0.0f;
                    }
                    else if (m_displayLocation.Y < (float)this.Height - (float)this.Height * m_zoomRate)
                    {
                        m_displayLocation.Y = (float)this.Height - (float)this.Height * m_zoomRate;
                    }
                }

                Painting();
            }
        }

        public void ZoomIn()
        {
            if (m_zoomRate > 0.8f)
            {
                m_zoomRate -= 0.1f;

                if (m_isDrawing)
                {
                    this.Cursor = Cursors.Cross;
                }
                else
                {
                    if (m_zoomRate > 1.0f)
                    {
                        this.Cursor = Cursors.NoMove2D;
                    }
                    else
                    {
                        this.Cursor = Cursors.Default;
                    }
                }

                if (m_zoomRate == 1.0f)
                {
                    m_displayLocation.X = 0.0f;
                    m_displayLocation.Y = 0.0f;
                }
                else
                {
                    float fltAdjustLocationX = (float)this.Width * 0.1f / 2.0f;
                    float fltAdjustLocationY = (float)this.Height * 0.1f / 2.0f;
                    m_displayLocation.X = m_displayLocation.X + fltAdjustLocationX;
                    m_displayLocation.Y = m_displayLocation.Y + fltAdjustLocationY;
                }

                if (m_zoomRate > 1.0f)
                {
                    if (m_displayLocation.X > 0.0f)
                    {
                        m_displayLocation.X = 0.0f;
                    }
                    else if (m_displayLocation.X < (float)this.Width - (float)this.Width * m_zoomRate)
                    {
                        m_displayLocation.X = (float)this.Width - (float)this.Width * m_zoomRate;
                    }

                    if (m_displayLocation.Y > 0.0f)
                    {
                        m_displayLocation.Y = 0.0f;
                    }
                    else if (m_displayLocation.Y < (float)this.Height - (float)this.Height * m_zoomRate)
                    {
                        m_displayLocation.Y = (float)this.Height - (float)this.Height * m_zoomRate;
                    }
                }

                Painting();
            }
        }

        public void Rotate()
        {
            m_image.RotateFlip(RotateFlipType.Rotate90FlipXY);
            m_regions.Clear();

            Painting();
        }

        public void Invert()
        {
            m_image.RotateFlip(RotateFlipType.RotateNoneFlipX);

            //for (int intIndex = 0; intIndex < m_regions.Count; intIndex++)
            //{
            //    float fltX = m_regions[intIndex].Y;
            //    float fltY = (float)this.m_image.Width - m_regions[intIndex].X - m_regions[intIndex].Width;
            //    float fltWidth = m_regions[intIndex].Height;
            //    float fltHeight = m_regions[intIndex].Width;
            //    m_regions[intIndex] = new RectangleF(fltX, fltY, fltWidth, fltHeight);
            //}
            m_regions.Clear();

            Painting();
        }

        public void ResetRegions()
        {
            if (m_regions.Count > 0)
            {
                m_regions.Clear();
                Painting();
            }
        }

        public void Reset()
        {
            m_zoomRate = 1.0f;
            m_displayLocation = new PointF(0.0f, 0.0f);
            m_mouseDownPoint = new PointF(0.0f, 0.0f);
            m_regions.Clear();
            Painting();
        }

        private void Painting()
        {
            using (Graphics objGraphics = this.CreateGraphics())
            {
                objGraphics.SmoothingMode = SmoothingMode.AntiAlias;


                if (m_regions != null)
                {
                    if (m_image != null)
                    {
                        float fltWidth = (float)this.Width;
                        float fltHeight = (float)this.Height;
                        if ((float)m_image.Width / (float)m_image.Height < (float)this.Width / (float)this.Height)
                        {
                            fltWidth = (float)m_image.Width * (float)fltHeight / (float)m_image.Height;
                        }
                        else
                        {
                            fltHeight = (float)m_image.Height * (float)fltWidth / (float)m_image.Width;
                        }

                        if (fltWidth * m_zoomRate > (float)this.Width)
                        {
                            if (m_displayLocation.X > 0.0f)
                            {
                                m_displayLocation.X = 0.0f;
                            }
                            else if (m_displayLocation.X < (float)this.Width - fltWidth * m_zoomRate)
                            {
                                m_displayLocation.X = (float)this.Width - fltWidth * m_zoomRate;
                            }
                        }
                        else
                        {
                            m_displayLocation.X = ((float)this.Width - fltWidth * m_zoomRate) / 2;
                        }

                        if (fltHeight * m_zoomRate > (float)this.Height)
                        {
                            if (m_displayLocation.Y > 0.0f)
                            {
                                m_displayLocation.Y = 0.0f;
                            }
                            else if (m_displayLocation.Y < (float)this.Height - fltHeight * m_zoomRate)
                            {
                                m_displayLocation.Y = (float)this.Height - fltHeight * m_zoomRate;
                            }
                        }
                        else
                        {
                            m_displayLocation.Y = ((float)this.Height - fltHeight * m_zoomRate) / 2;
                        }

                        objGraphics.Clear(this.BackColor);
                        objGraphics.DrawImage(m_image, new RectangleF(m_displayLocation.X, m_displayLocation.Y,
                            fltWidth * m_zoomRate, fltHeight * m_zoomRate));
                    }

                    if (m_isDraging)
                    {
                        RectangleF objRect = new RectangleF();

                        if (m_currentMousePoint.X < m_mouseDownPoint.X)
                        {
                            objRect.X = m_currentMousePoint.X;
                            objRect.Width = m_mouseDownPoint.X - m_currentMousePoint.X;
                        }
                        else
                        {
                            objRect.X = m_mouseDownPoint.X;
                            objRect.Width = m_currentMousePoint.X - m_mouseDownPoint.X;
                        }

                        if (m_currentMousePoint.Y < m_mouseDownPoint.Y)
                        {
                            objRect.Y = m_currentMousePoint.Y;
                            objRect.Height = m_mouseDownPoint.Y - m_currentMousePoint.Y;
                        }
                        else
                        {
                            objRect.Y = m_mouseDownPoint.Y;
                            objRect.Height = m_currentMousePoint.Y - m_mouseDownPoint.Y;
                        }

                       // objGraphics.DrawEllipse(new Pen(m_penColor, REGION_BORDER_SIZE * m_zoomRate), objRect);
                        objGraphics.DrawRectangle(new Pen(m_penColor, REGION_BORDER_SIZE * m_zoomRate),
                            objRect.X, objRect.Y, objRect.Width, objRect.Height);
                    }

                    for (int intIndex = 0; intIndex < m_regions.Count; intIndex++)
                    {
                        RectangleF objRect = new RectangleF();
                        objRect.X = m_regions[intIndex].X * m_zoomRate + m_displayLocation.X;
                        objRect.Y = m_regions[intIndex].Y * m_zoomRate + m_displayLocation.Y;
                        objRect.Width = m_regions[intIndex].Width * m_zoomRate;
                        objRect.Height = m_regions[intIndex].Height * m_zoomRate;
                        //objGraphics.DrawEllipse(new Pen(m_penColor, REGION_BORDER_SIZE * m_zoomRate), objRect);
                        objGraphics.DrawRectangle(new Pen(m_penColor, REGION_BORDER_SIZE * m_zoomRate),
                            objRect.X, objRect.Y, objRect.Width, objRect.Height);
                    }
                }
            }
        }
    }