How to move and change the size of shapes using mouse in C#

Question

I'm looking for the method for moving and changing the size of shape using mouse #C. That shape made by mouse location (Point start, end) on pictureBox named "captureDesign". I wanted to ask for a little bit of help. I searched many similar case of question, but I couldn't solve it yet. IF possible, please let me know to how.

Here is my code. It's not everything, for example, I omitted the contents about the mode selection for shape using Button_click.

I studied the similar case. But I haven't noticed it yet. How can I associate startPt (@MouseDown) and endPt (@MouseUp) with MyMove to make the move successful? MyMove code is written in upper link. I need it change. Actually I need to code for change the size but, first of all, I want to move that using mouse.

namespace Pilot
{
    enum DrawMode { LINE, RECTANGLE, CIRCLE, NUMBER };

    public partial class mainForm : Form
    {
        #region define
        private bool _isCaptionShow = false;
        private ScreenPicture sp;

        private IContainer components = null;

        Bitmap bitmap;


        private DrawMode drawMode;
        private Graphics g;
        private Pen pen = new Pen(Color.Red, 7);
        Point startPt, endPt, currPt, prevPt, addPt;
        private int numberCount = 0;

        int rectWidth, rectHeight;
        Font font = new Font("Arial", 12);

        private bool selectMode = false;

        private void selectModeButton_CheckedChanged(object sender, EventArgs e)
        {
            if (selectModeButton.Checked == true)
                selectMode = true;
            else
                selectMode = false;
        }


        MyMove m;
        Point deltaStart;
        Point deltaEnd;
        bool dragging = false;

        #region Contents on PictureBox "captureDesign;" when mouse clicked.
        private void captureDesign_MouseDown(object sender, MouseEventArgs e)
        {
            startPt = new Point(e.X, e.Y);
            prevPt = startPt;
            currPt = startPt;

            
            if (selectMode)
            {
                if (e.Button == MouseButtons.Left && m.IsPointOnLine(e.Location, 5))
                {
                    dragging = true;
                    deltaStart = new Point(startPt.X- e.Location.X, startPt.Y - e.Location.Y);
                    
                }
            }
        }

        #region Contents on PictureBox captureDesign when Mouse dropped.
        private void captureDesign_MouseUp(object sender, MouseEventArgs e)
        {
            g = captureDesign.CreateGraphics();
            endPt = new Point(e.X, e.Y);

            m = new MyMove(pen, startPt, endPt);

            #region calculate between start Point ~ end Point to width, height
            if (endPt.X < startPt.X) 
            {
                rectWidth = Math.Abs(endPt.X - startPt.X);
                addPt.X = endPt.X;
            }
            else 
            {
                rectWidth = Math.Abs(endPt.X - startPt.X);
                addPt.X = startPt.X;
            }

            if (endPt.Y < startPt.Y)  
            {
                rectHeight = Math.Abs(endPt.Y - startPt.Y);
                addPt.Y = endPt.Y;
            }
            else
            {
                rectHeight = Math.Abs(endPt.Y - startPt.Y);
                addPt.Y = startPt.Y;
            }
            #endregion

            if (selectMode)  
            {
                deltaEnd = new Point(endPt.X - e.Location.X, endPt.Y - e.Location.Y); 
            }
            else  //No selectMode
            {
                #region draw the shape in case of drawMode
                switch (drawMode)
                {
                    case DrawMode.LINE:
                        if (arrowCheck.Checked == true)
                        {
                            pen.StartCap = LineCap.ArrowAnchor;
                        }
                        else
                            //g.DrawLine(pen, startPt, endPt);
                            g.DrawLine(m.mpen, m.mStart, m.mEnd);
                        break;
                    case DrawMode.RECTANGLE:
                        //g.DrawRectangle(pen, new Rectangle(startPt, new Size(endPt.X - startPt.X, endPt.Y - startPt.Y)));
                        g.DrawRectangle(pen, new Rectangle(addPt, new Size(rectWidth, rectHeight)));
                        

                        break;
                    case DrawMode.CIRCLE:
                        g.DrawEllipse(pen, new Rectangle(addPt, new Size(rectWidth, rectHeight)));
                        break;

                    case DrawMode.NUMBER:
                        numberCount++;
                        g.DrawString(numberCount.ToString(), font, Brushes.White, endPt);
                        break;
                }

                #endregion
               
            }
        }

        #region 
        private void captureDesign_MouseMove(object sender, MouseEventArgs e)
        {
            if (dragging && deltaStart != null && deltaEnd != null)
            {
                m.mStart = new Point(deltaStart.X + e.Location.X, deltaStart.Y + e.Location.Y);
                m.mEnd = new Point(deltaEnd.X + e.Location.X, deltaEnd.Y + e.Location.Y);
            }
        }
}

    public class MyMove
    {
        public Pen mpen { get; set; }
        public Point mStart { get; set; }
        public Point mEnd { get; set; }

        public MyMove(Pen p, Point p1, Point p2)
        {
            mpen = p;
            mStart = p1;
            mEnd = p2;
        }

        public float slope
        {
            get
            {
                return (((float)mEnd.Y - (float)mStart.Y) / ((float)mEnd.X - (float)mStart.X));
            }
            
        }

        public float YIntercept
        {
            get
            {
                return mStart.Y - slope * mStart.X;
            }              
        }

        public bool IsPointOnLine(Point p, int cushion)
        {
            float temp = (slope * p.X + YIntercept);
            if (temp >= (p.Y-cushion) && temp <=(p.Y+cushion))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

    }

Answer 1

1ST ANSWER
Everything happens on MouseMove(object sender, MouseEventArgs e).
Here is a sample

private void Form1_MouseMove(object sender, MouseEventArgs e)
{
    //If we are not allowed to draw, simply return and disregard the rest of the code
    if (!_canDraw) return;

    //The x-value of our rectangle should be the minimum between the start x-value and the current x-position
    int x = Math.Min(_startX, e.X);
    //The y-value of our rectangle should also be the minimum between the start y-value and current y-value
    int y = Math.Min(_startY, e.Y);

    //The width of our rectangle should be the maximum between the start x-position and current x-position minus
    //the minimum of start x-position and current x-position
    int width = Math.Max(_startX, e.X) - Math.Min(_startX, e.X);

    //For the hight value, it's basically the same thing as above, but now with the y-values:
    int height = Math.Max(_startY, e.Y) - Math.Min(_startY, e.Y);
    _rect = new Rectangle(x, y, width, height);
    
    //Refresh the form and draw the rectangle
    Refresh();
}

protected override void OnPaint(PaintEventArgs e)
{
    //Create a new 'pen' to draw our rectangle with, give it the color red and a width of 2
    using (Pen pen = new Pen(Color.Red, 2))
    {
        //Draw the rectangle on our form with the pen
        e.Graphics.DrawRectangle(pen, _rect);
    }
}

You can further study the detail here, C# Tutorial - Drawing rectangles with the mouse.

2ND ANSWER (UPDATE)
I achieve the solution you want but I use a third party library MoveGraphLibrary. You can further read this article Moveable Resizable Objects.

Sample Code
GRAPHICAL OBJECT

public class Rectangle : GraphicalObject
{
    protected RectangleF rc;
    protected Resizing resize;
    protected float wMin, wMax, hMin, hMax;
    protected int radius;
    protected int halfstrip;
    protected SolidBrush brush;

    int minsize = 25;

    // -------------------------------------------------
    public Rectangle(RectangleF rect, RectRange range, int rad, int half, Color color)
    {
        rc = new RectangleF(rect.X, rect.Y, Math.Max(minsize, rect.Width), Math.Max(minsize, rect.Height));
        if (range == null)
        {
            wMin = wMax = rc.Width;
            hMin = hMax = rc.Height;
        }
        else
        {
            wMin = Math.Max(minsize, Math.Min(rc.Width, range.MinWidth));
            wMax = Math.Max(rc.Width, range.MaxWidth);
            hMin = Math.Max(minsize, Math.Min(rc.Height, range.MinHeight));
            hMax = Math.Max(rc.Height, range.MaxHeight);
        }
        RectRange realrange = new RectRange(wMin, wMax, hMin, hMax);
        resize = realrange.Resizing;

        radius = rad;
        halfstrip = half;
        brush = new SolidBrush(color);
    }
    // -------------------------------------------------

    // -------------------------------------------------        RectAround
    new public RectangleF RectAround
    {
        get { return (rc); }
    }
    // -------------------------------------------------        Radius
    public int Radius
    {
        get { return (radius); }
        set
        {
            radius = Math.Abs(value);
            DefineCover();
        }
    }
    // -------------------------------------------------        HalfStrip
    public int HalfStrip
    {
        get { return (halfstrip); }
        set
        {
            halfstrip = Math.Abs(value);
            DefineCover();
        }
    }
    // -------------------------------------------------        Color
    public Color Color
    {
        get { return (brush.Color); }
        set { brush.Color = value; }
    }
    // -------------------------------------------------
    public void Draw(Graphics grfx)
    {
        grfx.FillRectangle(brush, rc);
    }
    // -------------------------------------------------        Resizing
    public Resizing Resizing
    {
        get { return (resize); }
        set
        {
            resize = value;
            DefineCover();
        }
    }
    // -------------------------------------------------        DefineCover
    public override void DefineCover()
    {
        cover = new Cover(rc, resize, radius, halfstrip);
    }
    // -------------------------------------------------
    public override void Move(int dx, int dy)
    {
        rc.X += dx;
        rc.Y += dy;
    }
    // -------------------------------------------------        MoveNode
    public override bool MoveNode(int iNode, int dx, int dy, Point ptM, MouseButtons catcher)
    {
        bool bRet = false;

        if (catcher == MouseButtons.Left)
        {
            float wNew, hNew;
            switch (resize)
            {
                case Resizing.Any:
                    if (iNode == 8)
                    {
                        Move(dx, dy);
                    }
                    else if (iNode == 0)        //LT corner
                    {
                        hNew = rc.Height - dy;
                        if (hMin <= hNew && hNew <= hMax)
                        {
                            MoveBorder_Top(dy);
                            bRet = true;
                        }
                        wNew = rc.Width - dx;
                        if (wMin <= wNew && wNew <= wMax)
                        {
                            MoveBorder_Left(dx);
                            bRet = true;
                        }
                    }
                    else if (iNode == 1)        // RT corner
                    {
                        hNew = rc.Height - dy;
                        if (hMin <= hNew && hNew <= hMax)
                        {
                            MoveBorder_Top(dy);
                            bRet = true;
                        }
                        wNew = rc.Width + dx;
                        if (wMin <= wNew && wNew <= wMax)
                        {
                            MoveBorder_Right(dx);
                            bRet = true;
                        }
                    }
                    else if (iNode == 2)        // RB corner
                    {
                        wNew = rc.Width + dx;
                        if (wMin <= wNew && wNew <= wMax)
                        {
                            MoveBorder_Right(dx);
                            bRet = true;
                        }
                        hNew = rc.Height + dy;
                        if (hMin <= hNew && hNew <= hMax)
                        {
                            MoveBorder_Bottom(dy);
                            bRet = true;
                        }
                    }
                    else if (iNode == 3)        // LB corner
                    {
                        hNew = rc.Height + dy;
                        if (hMin <= hNew && hNew <= hMax)
                        {
                            MoveBorder_Bottom(dy);
                            bRet = true;
                        }
                        wNew = rc.Width - dx;
                        if (wMin <= wNew && wNew <= wMax)
                        {
                            MoveBorder_Left(dx);
                            bRet = true;
                        }
                    }
                    else if (iNode == 4)     // on left side
                    {
                        wNew = rc.Width - dx;
                        if (wMin <= wNew && wNew <= wMax)
                        {
                            MoveBorder_Left(dx);
                            bRet = true;
                        }
                    }
                    else if (iNode == 5)   // on right side
                    {
                        wNew = rc.Width + dx;
                        if (wMin <= wNew && wNew <= wMax)
                        {
                            MoveBorder_Right(dx);
                            bRet = true;
                        }
                    }
                    else if (iNode == 6)      // on top
                    {
                        hNew = rc.Height - dy;
                        if (hMin <= hNew && hNew <= hMax)
                        {
                            MoveBorder_Top(dy);
                            bRet = true;
                        }
                    }
                    else if (iNode == 7)   // on bottom
                    {
                        hNew = rc.Height + dy;
                        if (hMin <= hNew && hNew <= hMax)
                        {
                            MoveBorder_Bottom(dy);
                            bRet = true;
                        }
                    }
                    break;

                case Resizing.NS:
                    if (iNode == 2)
                    {
                        Move(dx, dy);
                    }
                    else if (iNode == 0)      // on top
                    {
                        hNew = rc.Height - dy;
                        if (hMin <= hNew && hNew <= hMax)
                        {
                            MoveBorder_Top(dy);
                            bRet = true;
                        }
                    }
                    else if (iNode == 1)   // on bottom
                    {
                        hNew = rc.Height + dy;
                        if (hMin <= hNew && hNew <= hMax)
                        {
                            MoveBorder_Bottom(dy);
                            bRet = true;
                        }
                    }
                    break;

                case Resizing.WE:
                    if (iNode == 2)
                    {
                        Move(dx, dy);
                    }
                    else if (iNode == 0)     // on left side
                    {

                        wNew = rc.Width - dx;
                        if (wMin <= wNew && wNew <= wMax)
                        {
                            MoveBorder_Left(dx);
                            bRet = true;
                        }
                    }
                    else if (iNode == 1)   // on right side
                    {
                        wNew = rc.Width + dx;
                        if (wMin <= wNew && wNew <= wMax)
                        {
                            MoveBorder_Right(dx);
                            bRet = true;
                        }
                    }
                    break;

                case Resizing.None:
                    Move(dx, dy);
                    break;
            }
        }
        return (bRet);
    }
    // -------------------------------------------------        MoveBorder_Top
    private void MoveBorder_Top(int dy)
    {
        rc.Y += dy;
        rc.Height -= dy;
    }
    // -------------------------------------------------        MoveBorder_Bottom
    private void MoveBorder_Bottom(int dy)
    {
        rc.Height += dy;
    }
    // -------------------------------------------------        MoveBorder_Left
    private void MoveBorder_Left(int dx)
    {
        rc.X += dx;
        rc.Width -= dx;
    }
    // -------------------------------------------------        MoveBorder_Right
    private void MoveBorder_Right(int dx)
    {
        rc.Width += dx;
    }

    public PointF Location
    {
        get
        {
            return rc.Location;
        }
    }
}

MAIN FORM

public partial class Form1 : Form
{
    RectRange rr;

    // Variables use for Moving & Resizing
    NumericUpDown numericUD_Radius = new NumericUpDown();
    NumericUpDown numericUD_HalfStrip = new NumericUpDown();
    string[] strs = new string[] {"Circles' radius",
                                    "Half strip width"
                                   };
    Mover mover;
    Point ptMouse_Down;
    bool bShowCovers = false;
    RigidlyBoundRectangles rigidrectsView;
    List<Shapes.Rectangle> rects = new List<Shapes.Rectangle>();
    int radius, halfstrip;

    // Variables use for Drawing
    bool isMouseDown = false;

    public Form1()
    {
        InitializeComponent();

        lblXAxis.Text = $"X Axis: -";
        lblYAxis.Text = $"Y Axis: -";

        numericUD_Radius.Value = 6;
        numericUD_HalfStrip.Value = 3;

        mover = new Mover(panel1);

        SizeF[] sizefStrs = Auxi_Geometry.MeasureStrings(this, strs);
        rigidrectsView = new RigidlyBoundRectangles(new Control[] { numericUD_Radius, numericUD_HalfStrip });
        rigidrectsView.Add(Auxi_Geometry.RectangleToRectangleSide(numericUD_Radius.Bounds, Side.E, sizefStrs[0], 4), "Radius");
        rigidrectsView.Add(Auxi_Geometry.RectangleToRectangleSide(numericUD_HalfStrip.Bounds, Side.E, sizefStrs[1], 4), "Strip");
        rigidrectsView.AddUnionRectangle();

        radius = Convert.ToInt32(numericUD_Radius.Value);
        halfstrip = Convert.ToInt32(numericUD_HalfStrip.Value);

        rr = new RectRange(panel1.MinimumSize.Width, panel1.Size.Width, panel1.MinimumSize.Height, panel1.Size.Height);

        rects.Add(new Shapes.Rectangle(new RectangleF(100, 100, 300, 400), rr, radius, halfstrip, Color.Black));

        RenewMover();
    }

    private void RenewMover()
    {
        mover.Clear();
        mover.Insert(0, rigidrectsView);

        for (int i = 0; i < rects.Count; i++)
        {
            mover.Add(rects[i]);
        }
    }

    private void panel1_Paint(object sender, PaintEventArgs e)
    {
        Graphics grfx = e.Graphics;

        GraphicalObject grobj;
        for (int i = mover.Count - 1; i >= 0; i--)
        {
            grobj = mover[i].Source;
            if (grobj is Shapes.Rectangle)
            {
                (grobj as Shapes.Rectangle).Draw(grfx);
            }

            if (bShowCovers)
            {
                mover[i].DrawCover(grfx);
            }
        }
    }

    private void panel1_MouseMove(object sender, MouseEventArgs e)
    {
        lblXAxis.Text = $"X Axis: {e.X}";
        lblYAxis.Text = $"Y Axis: {e.Y}";

        if (rbMoveOrResize.Checked && mover.Move(e.Location))
        {
            panel1.Invalidate();
        }
        else
        {
            if (isMouseDown)
            {
                var rectangle = rects.Last();
                var drawRectangle = new Shapes.Rectangle(new RectangleF(rectangle.Location.X,
                    rectangle.Location.Y,
                    e.X - rectangle.Location.X,
                    e.Y - rectangle.Location.Y),
                    rr, radius, halfstrip, Color.Black);

                rects.Remove(rects.Last());
                rects.Add(drawRectangle);

                RenewMover();
                panel1.Invalidate();
            }
        }
    }

    private void panel1_MouseLeave(object sender, EventArgs e)
    {
        lblXAxis.Text = $"X Axis: -";
        lblYAxis.Text = $"Y Axis: -";
    }

    private void panel1_MouseDown(object sender, MouseEventArgs e)
    {
        if (rbMoveOrResize.Checked)
        {
            ptMouse_Down = e.Location;
            mover.Catch(e.Location, e.Button);
        }
        else
        {
            isMouseDown = true;

            rects.Add(new Shapes.Rectangle(new RectangleF(e.Location.X, e.Location.Y, 0, 0), rr, radius, halfstrip, Color.Black));
        }
    }

    private void panel1_MouseUp(object sender, MouseEventArgs e)
    {
        if (rbMoveOrResize.Checked && mover.Release())
        {
            if (e.Button == MouseButtons.Left &&
                Auxi_Geometry.Distance(ptMouse_Down, e.Location) <= 3)
            {
                GraphicalObject grobj = mover[mover.ReleasedObject].Source;
                if (grobj is Shapes.Rectangle)
                {
                    PopupRectangle(grobj.ID);
                }
            }
        }
        else
        {
            isMouseDown = false;
        }
    }

    private void rb_CheckedChanged(object sender, EventArgs e)
    {
        bShowCovers = rbMoveOrResize.Checked;
        panel1.Invalidate();
    }

    private void PopupRectangle(long id)
    {
        for (int i = rects.Count - 1; i > 0; i--)
        {
            if (id == rects[i].ID)
            {
                Shapes.Rectangle elem = rects[i];
                rects.RemoveAt(i);
                rects.Insert(0, elem);
                RenewMover();
                panel1.Invalidate();
                break;
            }
        }
    }
}

SAMPLE OUTPUT