Move and Resize Controls on a Form at Runtime (With Mouse)

thank you for use from codes.
I test End() again, it worked good for me. use that like sample form.

Hi,

I downloaded the source and modified it with the End() in it, but also with your source code it never comes in the End() method.
What could it be that it doesn't enter the End() method?

Already thanks.

A great project..thanks so much for sharing! Is there a way to prevent control from going to 0 size and being lost, like setting a minimum width/height? Thanks.
Smile | :)

modified 22-May-14 20:14pm.

I'm using this on a display that is similar to a calendar. The user moves or resizes a label that represents a project. When it is finished I want the app to recognize where the edges of the control now are and update my DB that holds the start and end dates of the project.

But I am having trouble determining when the operation is over. I tried to add some code to the StopDragOrResizing(control) function but it seems to fire multiple times while the control is being resized or moved. I guess I would need something that would fire on MouseUp.

Any idea how I can make this happen?

Thanks,

hi ,
how could i remove this feature from the control ?

(like the dispose method like the init method ... is there ?)

Rose | [Rose]

mbs

hi i added a "end" method to class, use that. i will update article later.

internal class ControlMoverOrResizer
{
    private static bool _moving;
    private static Point _cursorStartPoint;
    private static bool _moveIsInterNal;
    private static bool _resizing;
    private static Size _currentControlStartSize;
    internal static bool MouseIsInLeftEdge { get; set; }
    internal static bool MouseIsInRightEdge { get; set; }
    internal static bool MouseIsInTopEdge { get; set; }
    internal static bool MouseIsInBottomEdge { get; set; }

    internal enum MoveOrResize
    {
        Move,
        Resize,
        MoveAndResize,
        None
    }

    internal static MoveOrResize WorkType { get; set; }

    internal static void Init(Control control)
    {
        Init(control, control);
    }

    internal static void Init(Control control, Control container)
    {
        _moving = false;
        _resizing = false;
        _moveIsInterNal = false;
        _cursorStartPoint = Point.Empty;
        MouseIsInLeftEdge = false;
        MouseIsInLeftEdge = false;
        MouseIsInRightEdge = false;
        MouseIsInTopEdge = false;
        MouseIsInBottomEdge = false;
        WorkType = MoveOrResize.MoveAndResize;
        control.MouseDown += (sender, e) => StartMovingOrResizing(control, e);
        control.MouseUp += (sender, e) => StopDragOrResizing(control);
        control.MouseMove += (sender, e) => MoveControl(container, e);
    }

    internal static void End()
    {
        WorkType = MoveOrResize.None;
    }

    private static void UpdateMouseEdgeProperties(Control control, Point mouseLocationInControl)
    {
        if (WorkType == MoveOrResize.Move)
        {
            return;
        }
        MouseIsInLeftEdge = Math.Abs(mouseLocationInControl.X) <= 2;
        MouseIsInRightEdge = Math.Abs(mouseLocationInControl.X - control.Width) <= 2;
        MouseIsInTopEdge = Math.Abs(mouseLocationInControl.Y ) <= 2;
        MouseIsInBottomEdge = Math.Abs(mouseLocationInControl.Y - control.Height) <= 2;
    }

    private static void UpdateMouseCursor(Control control)
    {
        if (WorkType == MoveOrResize.Move)
        {
            return;
        }
        if (MouseIsInLeftEdge )
        {
            if (MouseIsInTopEdge)
            {
                control.Cursor = Cursors.SizeNWSE;
            }
            else if (MouseIsInBottomEdge)
            {
                control.Cursor = Cursors.SizeNESW;
            }
            else
            {
                control.Cursor = Cursors.SizeWE;
            }
        }
        else if (MouseIsInRightEdge)
        {
            if (MouseIsInTopEdge)
            {
                control.Cursor = Cursors.SizeNESW;
            }
            else if (MouseIsInBottomEdge)
            {
                control.Cursor = Cursors.SizeNWSE;
            }
            else
            {
                control.Cursor = Cursors.SizeWE;
            }
        }
        else if (MouseIsInTopEdge || MouseIsInBottomEdge)
        {
            control.Cursor = Cursors.SizeNS;
        }
        else
        {
            control.Cursor = Cursors.Default;
        }
    }

    private static void StartMovingOrResizing(Control control, MouseEventArgs e)
    {
        if (_moving || _resizing || WorkType== MoveOrResize.None)
        {
            return;
        }
        if ((WorkType==MoveOrResize.Resize || WorkType== MoveOrResize.MoveAndResize) &&
            (MouseIsInRightEdge || MouseIsInLeftEdge || MouseIsInTopEdge || MouseIsInBottomEdge))
        {
            _resizing = true;
            _currentControlStartSize = control.Size;
        }
        else if (WorkType==MoveOrResize.Move || WorkType == MoveOrResize.MoveAndResize)
        {
            _moving = true;
            control.Cursor = Cursors.Hand;
        }
        _cursorStartPoint = new Point(e.X, e.Y);
        control.Capture = true;
    }

    private static void MoveControl(Control control, MouseEventArgs e)
    {
        if (WorkType == MoveOrResize.None)
        {
            control.Cursor = Cursors.Default;
            return;
        }
        if (!_resizing && ! _moving)
        {
            UpdateMouseEdgeProperties(control, new Point(e.X, e.Y));
            UpdateMouseCursor(control);
        }
        if (_resizing)
        {
            if (MouseIsInLeftEdge)
            {
                if (MouseIsInTopEdge)
                {
                    control.Width -= (e.X - _cursorStartPoint.X);
                    control.Left += (e.X - _cursorStartPoint.X);
                    control.Height -= (e.Y - _cursorStartPoint.Y);
                    control.Top += (e.Y - _cursorStartPoint.Y);
                }
                else if (MouseIsInBottomEdge)
                {
                    control.Width -= (e.X - _cursorStartPoint.X);
                    control.Left += (e.X - _cursorStartPoint.X);
                    control.Height = (e.Y - _cursorStartPoint.Y) + _currentControlStartSize.Height;
                }
                else
                {
                    control.Width -= (e.X - _cursorStartPoint.X);
                    control.Left += (e.X - _cursorStartPoint.X) ;
                }
            }
            else if (MouseIsInRightEdge)
            {
                if (MouseIsInTopEdge)
                {
                    control.Width = (e.X - _cursorStartPoint.X) + _currentControlStartSize.Width;
                    control.Height -= (e.Y - _cursorStartPoint.Y);
                    control.Top += (e.Y - _cursorStartPoint.Y);

                }
                else if (MouseIsInBottomEdge)
                {
                    control.Width = (e.X - _cursorStartPoint.X) + _currentControlStartSize.Width;
                    control.Height = (e.Y - _cursorStartPoint.Y) + _currentControlStartSize.Height;
                }
                else
                {
                    control.Width = (e.X - _cursorStartPoint.X)+_currentControlStartSize.Width;
                }
            }
            else if (MouseIsInTopEdge)
            {
                control.Height -= (e.Y - _cursorStartPoint.Y);
                control.Top += (e.Y - _cursorStartPoint.Y);
            }
            else if (MouseIsInBottomEdge)
            {
                control.Height = (e.Y - _cursorStartPoint.Y) + _currentControlStartSize.Height;
            }
            else
            {
                 StopDragOrResizing(control);
            }
        }
        else if (_moving)
        {
            _moveIsInterNal = !_moveIsInterNal;
            if (!_moveIsInterNal)
            {
                int x = (e.X - _cursorStartPoint.X) + control.Left;
                int y = (e.Y - _cursorStartPoint.Y) + control.Top;
                control.Location = new Point(x, y);
            }
        }
    }

    private static void StopDragOrResizing(Control control)
    {
        _resizing = false;
        _moving = false;
        control.Capture = false;
        UpdateMouseCursor(control);
    }

    #region Save And Load

    private static List<Control> GetAllChildControls(Control control, List<Control> list)
    {
        List<Control> controls = control.Controls.Cast<Control>().ToList();
        list.AddRange(controls);
        return controls.SelectMany(ctrl => GetAllChildControls(ctrl, list)).ToList();
    }

    internal static string GetSizeAndPositionOfControlsToString(Control container)
    {
        List<Control> controls = new List<Control>();
        GetAllChildControls(container, controls);
        CultureInfo cultureInfo = new CultureInfo("en");
        string info = string.Empty;
        foreach (Control control in controls)
        {
            info += control.Name + ":" + control.Left.ToString(cultureInfo) + "," + control.Top.ToString(cultureInfo) + "," +
                    control.Width.ToString(cultureInfo) + "," + control.Height.ToString(cultureInfo) + "*";
        }
        return info;
    }
    internal static void SetSizeAndPositionOfControlsFromString(Control container, string controlsInfoStr)
    {
        List<Control> controls = new List<Control>();
        GetAllChildControls(container, controls);
        string[] controlsInfo = controlsInfoStr.Split(new []{"*"},StringSplitOptions.RemoveEmptyEntries );
        Dictionary<string, string> controlsInfoDictionary = new Dictionary<string, string>();
        foreach (string controlInfo in controlsInfo)
        {
            string[] info = controlInfo.Split(new [] { ":" }, StringSplitOptions.RemoveEmptyEntries);
            controlsInfoDictionary.Add(info[0], info[1]);
        }
        foreach (Control control in controls)
        {
            string propertiesStr;
            controlsInfoDictionary.TryGetValue(control.Name, out propertiesStr);
            string[] properties = propertiesStr.Split(new [] { "," }, StringSplitOptions.RemoveEmptyEntries);
            if (properties.Length == 4)
            {
                control.Left = int.Parse(properties[0]);
                control.Top = int.Parse(properties[1]);
                control.Width = int.Parse(properties[2]);
                control.Height = int.Parse(properties[3]);
            }
        }
    }

    #endregion
}

Thanks
i'll test it ASAP.

mbs

I was also originally having a lot of difficulties stopping the events once they were initialized for my controls in my app but I have come up with what I believe to be a pretty nice solution.

I am new to coding however dissecting this bit of code was a learning experience and in my opinion a must for new aspiring coders if they are wishing to learn Delegates, Events and Lambda expressions. I see here that the original poster added an End method which simply updates the WorkType enum but this doesn't actually stop the events from running in the background. I believe my way of stopping/shutting off this functionality by Unsubscribing from the events should be added to the original code as it's working beautifully in my WinForms app. This code was awesome to begin with and I'm thankful I found it here on Code Project. See my additions to the code below.

In order for your code to reference back to the original events you need an object that contains those events to reference back to. To accomplish this I took out ALL of the Static fields and made all of the fields Private except for the enum MoveOrResize and MoveOrResize WorkType. With this change I replaced the Static Init(Control control) function by adding a Class Constructor so that I would have the ability to new up each instance of the ControlMoverOrResizer class for each Control I wanted to add this functionality to. See below an example:

C#

internal enum MoveOrResize...

public MoveOrResize WorkType { get; set; }

// Constructor: Takes in a Control object
public ControlMoverOrResizer(Control control)
{
    Init(control, control);
}

The original code uses lambda expressions and as a newbie this was my first time ever seeing them. The way in which the events are subscribed leaves out a pointer to those events and once the events are Subscribed you are not provided with a way to Unsubscribe from them within the class.

First you must Declare the MouseEventHandlers globally within the ControlMoverOrResizer Class. I declared these just below the now private MouseEdge booleans like this:

C#

// Declare the Handlers globally so we can access them later in order to shut them off aka Unsubscribe the Event
private MouseEventHandler msDownHandler;
private MouseEventHandler msUpHandler;
private MouseEventHandler msMoveHandler;

Next I set these events to the Delegates in the same manner as seyyed hamed monem did in the original code however I am not Subscribing these events just yet. The events are now pointers to their corresponding Delegate (From what I know this is true however I could be slightly incorrect as I'm still learning this stuff). I accomplish this within the Init(Control control, Control container) method like this:

C#

msDownHandler = (sender, e) => StartMovingOrResizing(control, e);
msUpHandler = (sender, e) => StopDragOrResizing(control);
msMoveHandler = (sender, e) => MoveControl(container, e);

Also within the same Init() method I now Subscribe the events to the handlers like this:

C#

control.MouseDown += msDownHandler; // Uses StartMovingOrResizing
control.MouseUp += msUpHandler;     // Uses StopDragOrResizing
control.MouseMove += msMoveHandler; // Uses MoveControl

Lastly I created a method that can be used just like the Init() method only it turns off the events for the control provided to it. I struggled with a name for this method but ended up simply calling it StopMove():

C#

internal void StopMove(Control control)
{
     // Unsubscribe from these events using the original Handler
     control.MouseDown -= msDownHandler;
     control.MouseUp -= msUpHandler;
     control.MouseMove -= msMoveHandler;
}

So now you have both a way to turn the functionality On and Off.

Turn On:

C#

// Global reference to moverResizer
ControlMoverOrResizer moverResizer;

// Using the Class Constructor pass in a Control object to create a new instance of a ControlMoverOrResizer object
moverResizer = new ControlMoverOrResizer(Control);

Turn Off:

C#

moverResizer.StopMove(Control);

I hope this helps! And please... let me know if I'm wrong about the terminology I used to describe items such as the Events, Delegates and Handlers. Other improvements suggestions are of course welcome.

modified 3-Mar-16 18:35pm.

I am attempting to add sizing handle to the selected control on the form. Any idea on this? Would like to do that on your sample code. Thanks.

hi,
sorry, i am doing a ponderous project this days and unfortunately i have not enough time for that. Frown | :(

To add little triangle - sizing handle on the bottom left handle OnPaint event for your desired control. Replace picAvatar with your control name.

C#

private void picAvatar_Paint(object sender, PaintEventArgs e)
        {
            Rectangle rect = new Rectangle(0, 0, this.picAvatar.Width, this.picAvatar.Height);
            ControlPaint.DrawSizeGrip(e.Graphics, SystemColors.Control, rect.Width - 10, rect.Height - 10, 10, 10);
        }

Running both your sample application and the source code, I observed the application is not working well for textbox and label control. For textbox, you can only resize to the top and left, meanwhile for label control, it is not resizing at all? How can resizing on all edges be achieved for textbox and label controls. Thanks.

Sorry, I have got it working for both textbox and label control. The code is okay and does not need any change. For the label control, set the autosize property to false and set the bordersize to FixedSingle and it will be resizable. For the textbox, set the bordersize to FixedSingle and it will be resizable as well. Thumbs up for a job well done.

thanks

Did not work for me, so I had to change the method UpdateMouseEdgeProperties and set the comparison number (right and bottom borders)to a larger value.
Thanks anyway. Thumbs Up | :thumbsup:

(If it is the case, sorry about my english)

The problem is that when the border is set to Fixed3D, both the MouseIsInRightEdge and MouseIsInBottomEdge calculate incorrectly. I didn't want to have to always change the border to FixedSingle, so I added the following code to calculate correctly in either case (there may be a better way since it looks rather kludgy, but it works):

MouseIsInRightEdge = Math.Abs(mouseLocationInControl.X - control.Width) <= 2 + (1 + (control.Width - control.ClientSize.Width) / 2);
MouseIsInBottomEdge = Math.Abs(mouseLocationInControl.Y - control.Height) <= 2 + (1 + (control.Height - control.ClientSize.Height) / 2);

I haven't fully tested it, but it seems to work for any control that allows a 3D border.

After the Move And Resize how could I save the situation of the Controls?

hi, add this methods to ControlMoverOrResizer class and use them.
call GetSizeAndPositionOfControlsToString method and save result string in file or registery or ....
then load that string and call SetSizeAndPositionOfControlsFromString method. Smile | :)

i not test them completly.
good luck

C#

#region Save And Load

private static List<Control> GetAllChildControls(Control control, List<Control> list)
{
    List<Control> controls = control.Controls.Cast<Control>().ToList();
    list.AddRange(controls);
    return controls.SelectMany(ctrl => GetAllChildControls(ctrl, list)).ToList();
}

internal static string GetSizeAndPositionOfControlsToString(Control container)
{
    List<Control> controls = new List<Control>();
    GetAllChildControls(container, controls);
    CultureInfo cultureInfo = new CultureInfo("en");
    string info = string.Empty;
    foreach (Control control in controls)
    {
        info += control.Name + ":" + control.Left.ToString(cultureInfo) + "," + control.Top.ToString(cultureInfo) + "," +
                control.Width.ToString(cultureInfo) + "," + control.Height.ToString(cultureInfo) + "*";
    }
    return info;
}
internal static void SetSizeAndPositionOfControlsFromString(Control container, string controlsInfoStr)
{
    List<Control> controls = new List<Control>();
    GetAllChildControls(container, controls);
    string[] controlsInfo = controlsInfoStr.Split(new []{"*"},StringSplitOptions.RemoveEmptyEntries );
    Dictionary<string, string> controlsInfoDictionary = new Dictionary<string, string>();
    foreach (string controlInfo in controlsInfo)
    {
        string[] info = controlInfo.Split(new [] { ":" }, StringSplitOptions.RemoveEmptyEntries);
        controlsInfoDictionary.Add(info[0], info[1]);
    }
    foreach (Control control in controls)
    {
        string propertiesStr;
        controlsInfoDictionary.TryGetValue(control.Name, out propertiesStr);
        string[] properties = propertiesStr.Split(new [] { "," }, StringSplitOptions.RemoveEmptyEntries);
        if (properties.Length == 4)
        {
            control.Left = int.Parse(properties[0]);
            control.Top = int.Parse(properties[1]);
            control.Width = int.Parse(properties[2]);
            control.Height = int.Parse(properties[3]);
        }
    }
}

#endregion

Move and Resize Controls on a Form at Runtime (With Mouse)

Introduction

Background

Using the Code

Points of Interest

History

License

Comments and Discussions