moving a child window outside the bounding box of the parent window

[HaLo2FrEeEk]

I have an application that has 2 forms, a child and a parent. I want to make sure that the parent window can never be inside the child window in any way, so the code will need to check if any part of the parent window's bounding box is within the child window's bounding box. How can I accomplish this?

I tried this code:

if ((Owner.Top > this.Top) && (Owner.Top < this.Bottom + 10) && ((Owner.Left > this.Left) && (Owner.Left < this.Right + 10)))
{
    Owner.Top = this.Bottom + 10;
}

But that only checks if the top left corner of the parent window is within the child window, not the whole thing. Is there any way to check the entire bounding box and see if there is any overlap?

As you can see with the code I'm using, if the parent is found to be within the child window, it puts it it at the bottom of the child window, plus 10 pixels. This poses a problem if the child window is moved to the bottom of the screen, which would cause the parent window to be pushed off the screen, so I'll also need to be able to check if the parent window is close to the screen border and perhaps put it above the child window instead of below.

There should also be something in place just in case the child window is expanded to the entire size of the screen, giving no room for the parent window, then it should allow the parent window to overlap the child window.

[GaryTexmo]

Bounding box checking is fairly standard... Using this image...

You have containment...
IF

• Bx >= Ax AND // Left > Left
• Bx + Bw <= Ax + Aw AND // Right < Right
• By >= Ay AND // Top > Top
• By + Bh <= Ay + Ah // Bottom < Bottom

You have intersection...
IF

• Bx <= Ax + Aw AND // Left < Right
• Bx + Bw >= Ax AND // Right > Left
• By <= Ay + Ah AND // Top < Bottom
• By + Bh >= Ay // Bottom > Top

While this is easy enough to code, fortunately, Microsoft provides us a Rectangle class which will actually do the calculation for us in the System.Drawing namespace.

Here's a demo program...

    class Program
    {
        static void Main(string[] args)
        {
            RectangleObject A = new RectangleObject("A", 5, 5, 10, 10);
            RectangleObject B = new RectangleObject("B", 7, 7, 10, 10);
            RectangleObject C = new RectangleObject("C", 7, 7, 5, 5);
            RectangleObject D = new RectangleObject("D", 20, 20, 10, 10);
 
            List<RectangleObject> rectList = new List<RectangleObject>();
            rectList.AddRange(new RectangleObject[] { A, B, C, D });
 
            foreach (RectangleObject r1 in rectList)
            {
                foreach (RectangleObject r2 in rectList)
                {
                    if (r1 != r2)
                    {
                        if (r1.Contains(r2))
                        {
                            Console.WriteLine(r1 + " contains " + r2);
                        }
                        else
                        {
                            Console.WriteLine(r1 + " does not contain " + r2);
                        }
 
                        if (r1.IntersectsWith(r2))
                        {
                            Console.WriteLine(r1 + " intersects with " + r2);
                        }
                        else
                        {
                            Console.WriteLine(r1 + " does not intersect with " + r2);
                        }
                    }
                }
            }
        }
 
        public class RectangleObject
        {
            public Rectangle Rectangle { get; set; }
            public string Name { get; set; }
 
            public RectangleObject(string name, int x, int y, int width, int height)
            {
                Name = name;
                Rectangle = new Rectangle(x, y, width, height);
            }
 
            public bool IntersectsWith(RectangleObject rectObj)
            {
                return Rectangle.IntersectsWith(rectObj.Rectangle);
            }
 
            public bool Contains(RectangleObject rectObj)
            {
                return Rectangle.Contains(rectObj.Rectangle);
            }
 
            public override string ToString()
            {
                return this.Name + ":" + string.Format("({0}, {1})-({2}, {3})", Rectangle.Left, Rectangle.Top, Rectangle.Right, Rectangle.Bottom);
            }
        }
    }

Note: I only made the class so I could name the objects for easier reference :)

Also, and this is just as a fun suggestion, instead of putting it at a fixed position you could always place it a little more intelligently. You can get the vector between the two center points of the forms, then place the form along that vector at a position that puts the child form outside the parent form. What distance would that be? Well, imagine a circle contains each of your forms, what's the minimum radius of that circle? The longest distance from the center to the top-left or top-right corners. Then add that distance to the center distance of the other form and place it there. You can be a little more precise if you want to compare the lines that center vector intersects with (which is also more fun!) but the circle method is typically the simplest.

Aaaanyway, I digress. Hope that all helps!

[HaLo2FrEeEk]

Ok, so I used this code to determine whether the child form contains or intersects with the parent form:

public void moveParentBox()
{
    Rectangle ownerRect = new Rectangle(Owner.Location, Owner.Size);
    Rectangle thisRect = new Rectangle(this.Location, this.Size);
 
    if (thisRect.Contains(ownerRect))
    {
        Owner.BackColor = Color.Red;
    } else if (thisRect.IntersectsWith(ownerRect))
    {
        Owner.BackColor = Color.Blue;
    }
    else
    {
        Owner.BackColor = Color.FromName("Control");
    }
}

And it seems to work. If I move the parent form partially within the child form, the background turns blue, if the parent form is fully within the child form, it turns red. If both return false the background color is reset. Since I don't need to detect each event by itself, only whether any part of the parent form is within the child form, I could condense it to this:

public void moveParentBox()
{
    Rectangle ownerRect = new Rectangle(Owner.Location, Owner.Size);
    Rectangle thisRect = new Rectangle(this.Location, this.Size);
 
    if (thisRect.Contains(ownerRect) || thisRect.IntersectsWith(ownerRect))
    {
        Owner.BackColor = Color.Red;
    }
    else
    {
        Owner.BackColor = Color.FromName("Control");
    }
}

Now, I didn't get your second part. I think I understand the concept, but I can't seem to visualize the results you're going for with it. Can you help me better understand?

Also, thanks a ton for that rectangle tip, I wouldn't have found that out myself, I would have done it the hard way.

[GaryTexmo]

Glad you got it working! Bounding boxes are great... I've used them a lot, love 'em ;)

For that second part, it was more a way to move your window in a way that it would be a little more natural. How much do you know about vectors and vector math?

If nothing, here's the wikipedia: http://en.wikipedia.org/wiki/Euclidean_vector
(Note: That article makes it look a lot more complicated than it really is... but hopefully you can get something from it. Damn wiki elitists, making everything confusing ><)

This is a little more complex than I want to write up here... let me do a little example program using spheres when I get some time and I'll post it so you can see what I'm getting at.

I'll get back to you :)

[GaryTexmo]

Ok, here we go... it's a fair bit of code and I can't guarantee the best coding practices since I just threw it together, but it should be sufficient to get the idea ;)

Just drop the code into a new project with a windows form... ie, replace the code file generated by Visual Studio. My form size was 500x500, but you can do whatever you want I suppose.

    public partial class Form1 : Form
    {
        private List<Circle> m_objList = new List<Circle>();
        private Circle m_circleGettingMoved = null;
        private Vector m_offset = null;
 
        public Form1()
        {
            InitializeComponent();
 
            m_objList.Add(new Circle(new Vector(100, 100), 50, Color.Purple));
            m_objList.Add(new Circle(new Vector(250, 150), 25, Color.Green));
        }
 
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
 
            Graphics g = e.Graphics;
            foreach (Circle obj in m_objList)
            {
                obj.Draw(g);
            }
        }
 
        private void Form1_MouseMove(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left && m_circleGettingMoved != null)
            {
                m_circleGettingMoved.Position = new Vector(e.X + m_offset.X, e.Y + m_offset.Y);
                this.Invalidate();
            }
        }
 
        private void Form1_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                if (m_circleGettingMoved == null)
                {
                    Vector mousePoint = new Vector(e.Location.X, e.Location.Y);
                    foreach (Circle circle in m_objList)
                    {
                        float dist = Vector.Distance(mousePoint, circle.Position);
                        if (dist <= circle.Radius)
                        {
                            m_circleGettingMoved = circle;
                            m_offset = new Vector(circle.Position.X - e.X, circle.Position.Y - e.Y);
                            break;
                        }
                    }
                }
            }
        }
 
        private void Form1_MouseUp(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left && m_circleGettingMoved != null)
            {
                Circle moveCircle = m_circleGettingMoved;
 
                foreach (Circle circle in m_objList)
                {
                    if (circle != m_circleGettingMoved)
                    {
                        int totalDist = circle.Radius + moveCircle.Radius;
                        if (Vector.Distance(circle.Position, moveCircle.Position) < totalDist)
                        {
                            Vector line = new Vector(moveCircle.Position.X - circle.Position.X, moveCircle.Position.Y - circle.Position.Y);
                            line.Normalize();
                            Vector newPos = new Vector(
                                circle.Position.X + totalDist * line.X,
                                circle.Position.Y + totalDist * line.Y);
 
                            moveCircle.Position.X = newPos.X;
                            moveCircle.Position.Y = newPos.Y;
                            this.Invalidate();
                        }
                    }
                }
 
                m_circleGettingMoved = null;
            }
        }
    }
 
    public class Vector
    {
        public float X { get; set; }
        public float Y { get; set; }
 
        public Vector(float x, float y)
        {
            X = x;
            Y = y;
        }
 
        public static float Distance(Vector A, Vector B)
        {
            return (float)(Math.Sqrt((A.X - B.X) * (A.X - B.X) + (A.Y - B.Y) * (A.Y - B.Y)));
        }
 
        public float Length()
        {
            return (float)(Math.Sqrt((X * X) + (Y * Y)));
        }
 
        public void Normalize()
        {
            float absLength = Math.Abs(Length());
            X = X / absLength;
            Y = Y / absLength;
        }
 
        public override string ToString()
        {
            return string.Format("(X={0}, Y={1})", X, Y);
        }
    }
 
    public interface IDrawableObject
    {
        Vector Position { get; set; }
        void Draw(Graphics g);
    }
 
    public class Circle : IDrawableObject
    {
        private Vector m_center;
 
        public Vector Center
        {
            get { return Position; }
            set { Position = value; }
        }
 
        public int Radius { get; set; }
 
        public Color Color
        {
            get { return m_pen.Color; }
            set { m_pen.Color = value; }
        }
 
        private Pen m_pen = new Pen(Color.Black);
 
        public Circle(Vector center, int radius, Color color)
        {
            Center = center;
            Radius = radius;
            m_pen.Color = color;
        }
 
        #region IDrawableObject Members
 
        public void Draw(Graphics g)
        {
            if (g != null)
            {
                g.DrawEllipse(m_pen, m_center.X - Radius, m_center.Y - Radius, Radius * 2, Radius * 2);
            }
        }
 
        public Vector Position
        {
            get
            {
                return m_center;
            }
            set
            {
                m_center = value;
            }
        }
 
        #endregion
    }

I did this with circles and I'll leave it to you to figure out how to do it with rectangles. If you don't care about them meeting at the edges, you can just pretend the radius is the max of the width or the height, really.

Just run the code and click/hold to drag the circles around. Release the circle to stop dragging. If the circle overlaps the other, it will move outside along the direction between the centers.

This is a cheezy gdi implementation, so try not to judge me too harshly ;) Let me know if you have any questions!

*Edit: Oops! I just realized you'll need to manually hook up the events as well. They're appropriately named though so make sure you put the form events to the correct one.