Code Bucket …

using System;
using System.ComponentModel;
using Microsoft.Xna.Framework;

namespace Incah.Core.Geo
{
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public struct Area
	{
		public static readonly Area Zero = new Area();

		public Area(Position position, Size size)
			: this()
		{
			Position = position;
			Size = size;
		}

		public Area(Position top_left, Position bottom_right)
			: this()
		{
			Position = top_left;
			Size = new Size(
				bottom_right.Horizontal - top_left.Horizontal,
				bottom_right.Vertical - top_left.Vertical
			);
		}

		public Area(int top, int left, int bottom, int right)
			: this()
		{
			Position = new Position(left, top);
			Size = new Size(
				right - left,
				bottom - top
			);
		}

		[Category("Dimensions")]
		public Position Position
		{
			get;
			set;
		}

		[Category("Dimensions")]
		public Size Size
		{
			get;
			set;
		}

		public int Top
		{
			get
			{
				return Position.Vertical;
			}
		}

		public int Bottom
		{
			get
			{
				return Position.Vertical + Size.Height;
			}
		}

		public int Left
		{
			get
			{
				return Position.Horizontal;
			}
		}

		public int Right
		{
			get
			{
				return Position.Horizontal + Size.Width;
			}
		}

		public int HorizontalCenter
		{
			get
			{
				return Position.Horizontal + (Size.Width / 2);
			}
		}

		public int VerticalCenter
		{
			get
			{
				return Position.Vertical + (Size.Height / 2);
			}
		}

		public Position TopLeftCorner
		{
			get
			{
				return new Position(Left, Top);
			}
		}

		public Position TopRightCorner
		{
			get
			{
				return new Position(Right, Top);
			}
		}

		public Position BottomLeftCorner
		{
			get
			{
				return new Position(Left, Bottom);
			}
		}

		public Position BottomRightCorner
		{
			get
			{
				return new Position(Right, Bottom);
			}
		}

		public Position TopCenter
		{
			get
			{
				return new Position(HorizontalCenter, Top);
			}
		}

		public Position BottomCenter
		{
			get
			{
				return new Position(HorizontalCenter, Bottom);
			}
		}

		public Position LeftCenter
		{
			get
			{
				return new Position(Left, VerticalCenter);
			}
		}

		public Position RightCenter
		{
			get
			{
				return new Position(Right, VerticalCenter);
			}
		}

		public Position Center
		{
			get
			{
				return new Position(HorizontalCenter, VerticalCenter);
			}
		}

		public Position AlignmentPoint(Alignment alignment)
		{
			return Position + alignment.Align(Size);
		}

		public int AlignmentPoint(HorizontalAlignment alignment)
		{
			return Position.Horizontal + alignment.Align(Size.Width);
		}

		public int AlignmentPoint(VerticalAlignment alignment)
		{
			return Position.Vertical + alignment.Align(Size.Height);
		}

		[Browsable(false)]
		public bool IsInverted
		{
			get
			{
				return Size.Width < 0
					|| Size.Height < 0;
			}
		}

		public bool Intersects(Area area)
		{
			return Top <= area.Bottom
				&& Bottom >= area.Top
				&& Left <= area.Right
				&& Right >= area.Left;
		}

		public bool Contains(Area area)
		{
			return Top <= area.Top
				&& Bottom >= area.Bottom
				&& Left <= area.Left
				&& Right >= area.Right;
		}

		public bool Contains(Position position)
		{
			return Top <= position.Vertical
				&& Bottom >= position.Vertical
				&& Left <= position.Horizontal
				&& Right >= position.Horizontal;
		}

		public static Area Intersection(Area a, Area b)
		{
			Area area = new Area(
				Math.Max(a.Top, b.Top),
				Math.Max(a.Left, b.Left),
				Math.Min(a.Bottom, b.Bottom),
				Math.Min(a.Right, b.Right)
			);

			return area.IsInverted
				? Zero
				: area;
		}

		public static Area Intersection(params Area[] areas)
		{
			if (areas.Length == 0)
				return Zero;

			Area area = areas[0];

			for (int index = 1; index < areas.Length; ++index)
			{
				area = Intersection(area, areas[index]);
				if (area.IsInverted)
					return Zero;
			}

			return area;
		}

		public static Area Union(Area a, Area b)
		{
			return new Area(
				Math.Min(a.Top, b.Top),
				Math.Min(a.Left, b.Left),
				Math.Max(a.Bottom, b.Bottom),
				Math.Max(a.Right, b.Right)
			);
		}

		public static Area Union(params Area[] areas)
		{
			if (areas.Length == 0)
				return Zero;

			Area area = areas[0];

			for (int index = 1; index < areas.Length; ++index)
				area = Union(area, areas[index]);

			return area;
		}

		[Browsable(false)]
		public bool IsZero
		{
			get
			{
				return Position.IsZero
					&& Size.IsZero;
			}
		}

		public static Area FromRectangle(Rectangle rect)
		{
			return new Area(
				rect.Top,
				rect.Left,
				rect.Bottom,
				rect.Right
			);
		}

		public Rectangle ToRectangle()
		{
			return new Rectangle(
				Position.Horizontal,
				Position.Vertical,
				Size.Width,
				Size.Height
			);
		}

		public override string ToString()
		{
			return string.Format("{0} @ {1}", Size, Position);
		}
	}
}