Simple Runtime Control Sizing and Dragging Class

 Private Sub ShowNewSelection(ByVal sender As Object)
        Try
            Dim pickselect As New pickbox()
            pickselect .SelectControl(sender, New EventArgs)
        Catch ex As Exception
 
        End Try
    End Sub

    /// [summary]
    /// This class implements sizing and moving functions for
    ///	runtime editing of graphic controls
    /// [/summary]
    public class PickBox
    {
        //////////////////////////////////////////////////////////////////
        // PRIVATE CONSTANTS AND VARIABLES
        //////////////////////////////////////////////////////////////////

        private const int BOX_SIZE = 8;
        private Color BOX_COLOR = Color.White;
        // private ContainerControl m_container;
        private Label[] lbl = new Label[8];
        private int startl;
        private int startt;
        private int startw;
        private int starth;
        private int startx;
        private int starty;
        private bool dragging;
        private bool moved;
        private Cursor[] arrArrow = new Cursor[] {Cursors.SizeNWSE, Cursors.SizeNS,
			Cursors.SizeNESW, Cursors.SizeWE, Cursors.SizeNWSE, Cursors.SizeNS,
			Cursors.SizeNESW, Cursors.SizeWE};
 
        private const int MIN_SIZE = 20;
 
        //
        // Constructor creates 8 sizing handles & wires mouse events
        // to each that implement sizing functions
        //
        public PickBox()
        {
            for (int i = 0; i < 8; i++)
            {
                lbl[i] = new Label();
                lbl[i].TabIndex = i;
                lbl[i].FlatStyle = 0;
                lbl[i].BorderStyle = BorderStyle.FixedSingle;
                lbl[i].BackColor = BOX_COLOR;
                lbl[i].Cursor = arrArrow[i];
                lbl[i].Text = "";
                lbl[i].BringToFront();
                lbl[i].MouseDown += new MouseEventHandler(this.lbl_MouseDown);
                lbl[i].MouseMove += new MouseEventHandler(this.lbl_MouseMove);
                lbl[i].MouseUp += new MouseEventHandler(this.lbl_MouseUp);
            }
        }
 
        //////////////////////////////////////////////////////////////////
        // PUBLIC METHODS
        //////////////////////////////////////////////////////////////////

        //
        // Wires a Click event handler to the passed Control
        // that attaches a pick box to the control when it is clicked
        //
        public void WireControl(Control ctl)
        {
            ctl.Click += new EventHandler(this.SelectControl);
        }
 
        private Hashtable SelectedControlCursors = new Hashtable();
 
        private List[Control] _SelectedControls = new List[Control]();
        /// [summary]
        /// Get the current selected controls.
        /// [/summary]
        public List[Control] SelectedControls
        {
            get
            {
                return _SelectedControls;
            }
        }
 
        /// [summary]
        /// Deselect all controls.
        /// [/summary]
        public void ClearSelection()
        {
            while (SelectedControls.Count > 0)
            {
                RemoveControl(SelectedControls[0]);
            }
            HideHandles();
        }
 
        /// [summary]
        /// Return true if the current selection has no controls.
        /// [/summary]
        private bool IsEmptySelection
        {
            get
            {
                return SelectedControls.Count == 0;
            }
        }
 
        /////////////////////////////////////////////////////////////////
        // PRIVATE METHODS
        /////////////////////////////////////////////////////////////////

        /// [summary]
        /// Add or remove a control from the current selection.
        /// [/summary]
        private void AddOrRemoveControl(Control c)
        {
            if (SelectedControls.Contains(c))
                RemoveControl(c);
            else
                AddControl(c);
        }
 
        private void AddControl(Control c)
        {
            //Add event handlers for moving the current selected controls around.
            c.MouseDown += new MouseEventHandler(this.ctl_MouseDown);
            c.MouseMove += new MouseEventHandler(this.ctl_MouseMove);
            c.MouseUp += new MouseEventHandler(this.ctl_MouseUp);
 
            // Remove click handler
            c.Click -= new EventHandler(this.SelectControl);
 
            // Register the current cursor of the added control for restoring it later.
            SelectedControlCursors.Add(c, c.Cursor);
 
            // Change cursor of the control to the "moving" cursor.
            c.Cursor = Cursors.SizeAll;
 
            // Add to current selection
            SelectedControls.Add(c);
        }
 
        private void RemoveControl(Control c)
        {
            // Restore cursor of the control.
            c.Cursor = (Cursor)SelectedControlCursors[c];
            SelectedControlCursors.Remove(c);
 
            //Remove event any pre-existing event handlers appended by this class
            c.MouseDown -= new MouseEventHandler(this.ctl_MouseDown);
            c.MouseMove -= new MouseEventHandler(this.ctl_MouseMove);
            c.MouseUp -= new MouseEventHandler(this.ctl_MouseUp);
 
            // Restore click handler
            c.Click += new EventHandler(this.SelectControl);
 
            // Remove from current selection
            SelectedControls.Remove(c);
        }
 
        /// [summary]
        /// Get the current selection boundary, on an empty rectangle if the current
        /// selection is also empty.
        /// [/summary]
        private Rectangle GetSelectionBounds()
        {
            if (SelectedControls.Count == 0)
            {
                return Rectangle.Empty;
            }
 
            int l = int.MaxValue;
            int r = int.MinValue;
            int t = int.MaxValue;
            int b = int.MinValue;
            foreach (Control c in SelectedControls)
            {
                l = Math.Min(l, c.Left);
                r = Math.Max(r, c.Right);
                t = Math.Min(t, c.Top);
                b = Math.Max(b, c.Bottom);
            }
            return new Rectangle(l, t, r - l, b - t);
        }
 
        //
        // Attaches a pick box to the sender Control
        //
        private void SelectControl(object sender, EventArgs e)
        {
            Control c = (Control)sender;
            
            AddOrRemoveControl(c);
 
            if (IsEmptySelection)
            {
                HideHandles();
                return;
            }
 
            //Add sizing handles to Control's container (Form or PictureBox)
            Control container = SelectedControls[0].Parent;
            for (int i = 0; i < 8; i++)
            {
                if (lbl[i].Parent == null) container.Controls.Add(lbl[i]);
                lbl[i].BringToFront();
            }
 
            //Position sizing handles around Control
            MoveHandles();
 
            //Display sizing handles
            ShowHandles();
        }
 
        private void ShowHandles()
        {
            if (!IsEmptySelection)
            {
                for (int i = 0; i < 8; i++)
                {
                    lbl[i].Visible = true;
                }
            }
        }
 
        private void HideHandles()
        {
            for (int i = 0; i < 8; i++)
            {
                lbl[i].Visible = false;
            }
        }
 
        private void MoveHandles()
        {
            Rectangle bounds = GetSelectionBounds();
 
            int sX = bounds.Left - BOX_SIZE;
            int sY = bounds.Top - BOX_SIZE;
            int sW = bounds.Width + BOX_SIZE;
            int sH = bounds.Height + BOX_SIZE;
            int hB = BOX_SIZE / 2;
            int[] arrPosX = new int[] {sX+hB, sX + sW / 2, sX + sW-hB, sX + sW-hB,
			sX + sW-hB, sX + sW / 2, sX+hB, sX+hB};
            int[] arrPosY = new int[] {sY+hB, sY+hB, sY+hB, sY + sH / 2, sY + sH-hB,
			sY + sH-hB, sY + sH-hB, sY + sH / 2};
            for (int i = 0; i < 8; i++)
                lbl[i].SetBounds(arrPosX[i], arrPosY[i], BOX_SIZE, BOX_SIZE);
        }
 
        /////////////////////////////////////////////////////////////////
        // MOUSE EVENTS THAT IMPLEMENT SIZING OF THE PICKED CONTROL
        /////////////////////////////////////////////////////////////////

        //
        // Store control position and size when mouse button pushed over
        // any sizing handle
        //
        private void lbl_MouseDown(object sender, MouseEventArgs e)
        {
            dragging = true;
            Rectangle bounds = GetSelectionBounds();
            startl = bounds.Left;
            startt = bounds.Top;
            startw = bounds.Width;
            starth = bounds.Height;
            HideHandles();
        }
 
        //
        // Size the picked control in accordance with sizing handle being dragged
        //	0   1   2
        //  7       3
        //  6   5   4
        //
        private void lbl_MouseMove(object sender, MouseEventArgs e)
        {
            Rectangle bounds = GetSelectionBounds();
            int l = bounds.Left;
            int w = bounds.Width;
            int t = bounds.Top;
            int h = bounds.Height;
            if (dragging)
            {
                switch (((Label)sender).TabIndex)
                {
                    case 0: // Dragging top-left sizing box
                        l = startl + e.X < startl + startw - MIN_SIZE ? startl + e.X : startl + startw - MIN_SIZE;
                        t = startt + e.Y < startt + starth - MIN_SIZE ? startt + e.Y : startt + starth - MIN_SIZE;
                        w = startl + startw - bounds.Left;
                        h = startt + starth - bounds.Top;
                        break;
                    case 1: // Dragging top-center sizing box
                        t = startt + e.Y < startt + starth - MIN_SIZE ? startt + e.Y : startt + starth - MIN_SIZE;
                        h = startt + starth - bounds.Top;
                        break;
                    case 2: // Dragging top-right sizing box
                        w = startw + e.X > MIN_SIZE ? startw + e.X : MIN_SIZE;
                        t = startt + e.Y < startt + starth - MIN_SIZE ? startt + e.Y : startt + starth - MIN_SIZE;
                        h = startt + starth - bounds.Top;
                        break;
                    case 3: // Dragging right-middle sizing box
                        w = startw + e.X > MIN_SIZE ? startw + e.X : MIN_SIZE;
                        break;
                    case 4: // Dragging right-bottom sizing box
                        w = startw + e.X > MIN_SIZE ? startw + e.X : MIN_SIZE;
                        h = starth + e.Y > MIN_SIZE ? starth + e.Y : MIN_SIZE;
                        break;
                    case 5: // Dragging center-bottom sizing box
                        h = starth + e.Y > MIN_SIZE ? starth + e.Y : MIN_SIZE;
                        break;
                    case 6: // Dragging left-bottom sizing box
                        l = startl + e.X < startl + startw - MIN_SIZE ? startl + e.X : startl + startw - MIN_SIZE;
                        w = startl + startw - bounds.Left;
                        h = starth + e.Y > MIN_SIZE ? starth + e.Y : MIN_SIZE;
                        break;
                    case 7: // Dragging left-middle sizing box
                        l = startl + e.X < startl + startw - MIN_SIZE ? startl + e.X : startl + startw - MIN_SIZE;
                        w = startl + startw - bounds.Left;
                        break;
                }
                l = (l < 0) ? 0 : l;
                t = (t < 0) ? 0 : t;
 
                ChangeSelectionBounds(l, t, w, h);
            }
        }
 
        /// [summary]
        /// Change the current selection bounds (therefore, changing positions and sizes of each control
        /// in the selection).
        /// [/summary]
        private void ChangeSelectionBounds(int l, int t, int w, int h)
        {
            Rectangle oldB = GetSelectionBounds();
 
            int deltaX = l - oldB.Left;
            int deltaY = t - oldB.Top;
            int deltaW = w - oldB.Width;
            int deltaH = h - oldB.Height;
 
            // Change location and size of each select control.
            foreach(Control c in SelectedControls)
            {
                c.SetBounds(c.Left + deltaX, c.Top + deltaY, c.Width + deltaW, c.Height + deltaH);
            }
        }
 
        //
        // Display sizing handles around picked control once sizing has completed
        //
        private void lbl_MouseUp(object sender, MouseEventArgs e)
        {
            dragging = false;
            MoveHandles();
            ShowHandles();
        }
 
        /////////////////////////////////////////////////////////////////
        // MOUSE EVENTS THAT MOVE THE PICKED CONTROL AROUND THE FORM
        /////////////////////////////////////////////////////////////////

        //
        // Get mouse pointer starting position on mouse down and hide sizing handles
        //
        private void ctl_MouseDown(object sender, MouseEventArgs e)
        {
            dragging = true;
            moved = false;
            startx = e.X;
            starty = e.Y;
            HideHandles();
        }
 
        //
        // Reposition the dragged control
        // (Updated for global reposition -on each selected control)
        //
        private void ctl_MouseMove(object sender, MouseEventArgs e)
        {
            if (dragging)
            {
                int deltaX = e.X - startx;
                int deltaY = e.Y - starty;
 
                Rectangle bounds = GetSelectionBounds();
                Control parent = SelectedControls[0].Parent;
 
                if (bounds.Left + deltaX < 0)
                    deltaX = bounds.Left * -1;
                if (bounds.Top + deltaY < 0)
                    deltaY = bounds.Top * -1;
                if (bounds.Right + deltaX > parent.ClientRectangle.Width)
                    deltaX = parent.ClientRectangle.Width - bounds.Right;
                if (bounds.Bottom + deltaY > parent.ClientRectangle.Height)
                    deltaY = parent.ClientRectangle.Height - bounds.Bottom;
 
                foreach (Control c in SelectedControls)
                {
                    c.Location = new Point(c.Left + deltaX, c.Top + deltaY);
                }
 
                if (deltaX != 0 || deltaY != 0)
                {
                    moved = true;
                }
            }
        }
 
        //
        // Display sizing handles around picked control once dragging has completed
        //
        private void ctl_MouseUp(object sender, MouseEventArgs e)
        {
            if (dragging && !moved) RemoveControl((Control)sender);
 
            dragging = false;
            moved = false;
            MoveHandles();
            ShowHandles();
        }
    }