.NET Shape Control

//////////////////////////////////////////////////////////////////////////////////////
//
// Some vectors which we need if we size the shape too small and the cursor exceeds the area of the shape
// then we should know when to start resizing again
//
protected Vector2d m_MouseOverflowRightDown;
protected Vector2d m_MouseOverflowLeftTop;
protected Vector2d m_MouseOverflowRightTop;
protected Vector2d m_MouseOverflowLeftBottom;
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
//
// Grab points which we need to indicate that the user can resize the object
//
protected RectangleF m_LeftGrabPoint;
protected RectangleF m_TopGrabPoint;
protected RectangleF m_RightGrabPoint;
protected RectangleF m_BottomGrabPoint;

protected RectangleF m_LeftTopGrabPoint;
protected RectangleF m_RightTopGrabPoint;
protected RectangleF m_RightBottomGrabPoint;
protected RectangleF m_LeftBottomGrabPoint;
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
//
// A variable which helps us to keep the right resize direction
//
protected ResizeDirection m_ResizeDirection = ResizeDirection.None;
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
//
// This should be located somewhere in the mouse down...
//
#region Start resizing
if (m_LeftGrabPoint.Contains(e.Location))
{
   Cursor.Current = Cursors.SizeWE;
   m_ResizeDirection = ResizeDirection.Left;
}
else if (m_LeftTopGrabPoint.Contains(e.Location))
{
   Cursor.Current = Cursors.SizeNWSE;
   m_ResizeDirection = ResizeDirection.LeftTop;
}
else if (m_TopGrabPoint.Contains(e.Location))
{
   Cursor.Current = Cursors.SizeNS;
   m_ResizeDirection = ResizeDirection.Top;
}
else if (m_RightTopGrabPoint.Contains(e.Location))
{
   Cursor.Current = Cursors.SizeNESW;
   m_ResizeDirection = ResizeDirection.RightTop;
}
else if (m_RightGrabPoint.Contains(e.Location))
{
   Cursor.Current = Cursors.SizeWE;
   m_ResizeDirection = ResizeDirection.Right;
}
else if (m_RightBottomGrabPoint.Contains(e.Location))
{
   Cursor.Current = Cursors.SizeNWSE;
   m_ResizeDirection = ResizeDirection.RightBottom;
}
else if (m_BottomGrabPoint.Contains(e.Location))
{
   Cursor.Current = Cursors.SizeNS;
   m_ResizeDirection = ResizeDirection.Bottom;
}
else if (m_LeftBottomGrabPoint.Contains(e.Location))
{
   Cursor.Current = Cursors.SizeNESW;
   m_ResizeDirection = ResizeDirection.LeftBottom;
}
else
{
   Cursor.Current = Cursors.Default;
   m_ResizeDirection = ResizeDirection.None;
}
#endregion


//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
//
//...and this shoul be located somewhere in the mouse move
//
if (m_MouseDown &&
    e.Button == MouseButtons.Left &&
    m_ResizeDirection != ResizeDirection.None)
{
   Resize(m_ResizeDirection, delta);
}
// If the mouse only hovers over the shape and hits a grab point
// then we indicate a possible resize by changing the current cursor
else if (Selected && m_ResizeDirection == ResizeDirection.None)
{
   #region Indicate a possible resize

   if (m_LeftGrabPoint.Contains(e.Location))
   {
      Cursor.Current = Cursors.SizeWE;
   }
   else if (m_LeftTopGrabPoint.Contains(e.Location))
   {
      Cursor.Current = Cursors.SizeNWSE;
   }
   else if (m_TopGrabPoint.Contains(e.Location))
   {
      Cursor.Current = Cursors.SizeNS;
   }
   else if (m_RightTopGrabPoint.Contains(e.Location))
   {
      Cursor.Current = Cursors.SizeNESW;
   }
   else if (m_RightGrabPoint.Contains(e.Location))
   {
      Cursor.Current = Cursors.SizeWE;
   }
   else if (m_RightBottomGrabPoint.Contains(e.Location))
   {
      Cursor.Current = Cursors.SizeNWSE;
   }
   else if (m_BottomGrabPoint.Contains(e.Location))
   {
      Cursor.Current = Cursors.SizeNS;
   }
   else if (m_LeftBottomGrabPoint.Contains(e.Location))
   {
      Cursor.Current = Cursors.SizeNESW;
   }
   else
   {
      Cursor.Current = Cursors.Default;
   }

   #endregion
}
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
//
// In the mouse up there should then be something like this
//
m_ResizeDirection = ResizeDirection.None;
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
//
// The Resize() method which is used above
//
protected virtual void Resize(ResizeDirection direction, Vector2d delta)
{
   RectangleF currentBounds = BorderBounds;
   RectangleF newBounds = new RectangleF();

   #region Resize

   switch (direction)
   {
      case ResizeDirection.Left:
         newBounds.X = currentBounds.X + (int)delta.X;
         newBounds.Y = currentBounds.Y;
         newBounds.Width = currentBounds.Width + (int)delta.X * (-1);
         newBounds.Height = currentBounds.Height;
         break;
      case ResizeDirection.Top:
         newBounds.X = currentBounds.X;
         newBounds.Y = currentBounds.Y + (int)delta.Y;
         newBounds.Width = currentBounds.Width;
         newBounds.Height = currentBounds.Height + (int)delta.Y * (-1);
         break;
      case ResizeDirection.Right:
         newBounds.X = currentBounds.X;
         newBounds.Y = currentBounds.Y;
         newBounds.Width = currentBounds.Width + (int)delta.X;
         newBounds.Height = currentBounds.Height;
         break;
      case ResizeDirection.Bottom:
         newBounds.X = currentBounds.X;
         newBounds.Y = currentBounds.Y;
         newBounds.Width = currentBounds.Width;
         newBounds.Height = currentBounds.Height + (int)delta.Y;
         break;
      case ResizeDirection.LeftTop:
         newBounds.X = currentBounds.X + (int)delta.X;
         newBounds.Y = currentBounds.Y;
         newBounds.Width = currentBounds.Width + (int)delta.X * (-1);
         newBounds.Height = currentBounds.Height;
         newBounds.X = newBounds.X;
         newBounds.Y = newBounds.Y + (int)delta.Y;
         newBounds.Width = newBounds.Width;
         newBounds.Height = newBounds.Height + (int)delta.Y * (-1);
         break;
      case ResizeDirection.RightTop:
         newBounds.X = currentBounds.X;
         newBounds.Y = currentBounds.Y;
         newBounds.Width = currentBounds.Width + (int)delta.X;
         newBounds.Height = currentBounds.Height;
         newBounds.X = newBounds.X;
         newBounds.Y = newBounds.Y + (int)delta.Y;
         newBounds.Width = newBounds.Width;
         newBounds.Height = newBounds.Height + (int)delta.Y * (-1);
         break;
      case ResizeDirection.RightBottom:
         newBounds.X = currentBounds.X;
         newBounds.Y = currentBounds.Y;
         newBounds.Width = currentBounds.Width + (int)delta.X;
         newBounds.Height = currentBounds.Height;
         newBounds.X = newBounds.X;
         newBounds.Y = newBounds.Y;
         newBounds.Width = newBounds.Width;
         newBounds.Height = newBounds.Height + (int)delta.Y;
         break;
      case ResizeDirection.LeftBottom:
         newBounds.X = currentBounds.X + (int)delta.X;
         newBounds.Y = currentBounds.Y;
         newBounds.Width = currentBounds.Width + (int)delta.X * (-1);
         newBounds.Height = currentBounds.Height;
         newBounds.X = newBounds.X;
         newBounds.Y = newBounds.Y;
         newBounds.Width = newBounds.Width;
         newBounds.Height = newBounds.Height + (int)delta.Y;
         break;
      case ResizeDirection.None:
      default:
         break;
   }

   #endregion

   #region Handle mouse overflow

   float x = BorderBounds.X;
   float y = BorderBounds.Y;
   float w = BorderBounds.Width;
   float h = BorderBounds.Height;

   //
   // Look if the shape has at least its minimum size and prevent the shape
   // from resizing if the cursor overflowed the shape.
   //
   if (m_ResizeDirection == ResizeDirection.Right ||
       m_ResizeDirection == ResizeDirection.Bottom ||
       m_ResizeDirection == ResizeDirection.RightBottom)
   {
      if (newBounds.Size.Width >= MinSize.Width && m_MouseOverflowRightDown.X >= 0)
         w = newBounds.Width;
      else
         m_MouseOverflowRightDown.X += delta.X;

      if (newBounds.Size.Height >= MinSize.Height && m_MouseOverflowRightDown.Y >= 0)
         h = newBounds.Height;
      else
         m_MouseOverflowRightDown.Y += delta.Y;
   }

   if (m_ResizeDirection == ResizeDirection.Left ||
       m_ResizeDirection == ResizeDirection.Top ||
       m_ResizeDirection == ResizeDirection.LeftTop)
   {
      if (newBounds.Size.Width >= MinSize.Width && m_MouseOverflowLeftTop.X <= 0)
      {
         x = newBounds.X;
         w = newBounds.Width;
      }
      else
         m_MouseOverflowLeftTop.X += delta.X;

      if (newBounds.Size.Height >= MinSize.Height && m_MouseOverflowLeftTop.Y <= 0)
      {
         y = newBounds.Y;
         h = newBounds.Height;
      }
      else
         m_MouseOverflowLeftTop.Y += delta.Y;
   }

   if (m_ResizeDirection == ResizeDirection.LeftBottom)
   {
      if (newBounds.Size.Width >= MinSize.Width && m_MouseOverflowLeftBottom.X <= 0)
      {
         x = newBounds.X;
         w = newBounds.Width;
      }
      else
         m_MouseOverflowLeftBottom.X += delta.X;

      if (newBounds.Size.Height >= MinSize.Height && m_MouseOverflowLeftBottom.Y >= 0)
      {
         y = newBounds.Y;
         h = newBounds.Height;
      }
      else
         m_MouseOverflowLeftBottom.Y += delta.Y;
   }

   if (m_ResizeDirection == ResizeDirection.RightTop)
   {
      if (newBounds.Size.Width >= MinSize.Width && m_MouseOverflowRightTop.X >= 0)
      {
         w = newBounds.Width;
      }
      else
         m_MouseOverflowRightTop.X += delta.X;

      if (newBounds.Size.Height >= MinSize.Height && m_MouseOverflowRightTop.Y <= 0)
      {
         y = newBounds.Y;
         h = newBounds.Height;
      }
      else
         m_MouseOverflowRightTop.Y += delta.Y;
   }

   #endregion
}
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
//
// This enum contains the different resize directions
//
[Flags()]
public enum ResizeDirection : byte
{
   /// <summary>
   /// No resize.
   /// </summary>
   None = 0,
   /// <summary>
   /// Resize to the left direction.
   /// </summary>
   Left = 2,
   /// <summary>
   /// Resize to the top direction.
   /// </summary>
   Top = 4,
   /// <summary>
   /// Resize to the right direction.
   /// </summary>
   Right = 8,
   /// <summary>
   /// Resize to the bottom direction.
   /// </summary>
   Bottom = 16,
   /// <summary>
   /// Resize to the left top direction.
   /// </summary>
   LeftTop = Left | Top,
   /// <summary>
   /// Resize to the right top direction.
   /// </summary>
   RightTop = Right | Top,
   /// <summary>
   /// Resize to the right bottom direction.
   /// </summary>
   RightBottom = Right | Bottom,
   /// <summary>
   /// Resize to the left bottom direction.
   /// </summary>
   LeftBottom = Left | Bottom
}
//////////////////////////////////////////////////////////////////////////////////////