Linkify Add-in for Visual Studio

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.Diagnostics;

namespace PH.Utility
{
  public enum ControlPositionFlags
  {
    /// <summary>restore the size of the form (default)</summary>
    Size = 1,

    /// <summary>restore the position of the form (default)</summary>
    Position = 2,

    Default = Size | Position,

    /*
    /// <summary>restore the monitor the form was on. Cannot be used together with ParentMonitor or AutoMonitor</summary>
    Monitor = 4,

    /// <summary>Restores the form on the same monitor as the parent</summary>
    ParentMonitor = 8,

    /// <summary>Restores the form on the same monitor as the parent if it was there when the position was saved. 
    /// Otherwise, restores the form on the monitor it was previously on (default)</summary>
    AutoParentMonitor = 16,

    /// <summary>If necessary, reposition the form so it is completely on screen</summary>
    AutoPosititon = 32,

    /// <summary>If necessary, reposition the form so it is completely on one monitor</summary>
    AutoPosititonMonitor = 64,

    /// <summary>Reposition form so that it is over the parent form</summary>
    OnParent = 128,
     */
  }


  /// <summary>
  /// Location class. Handles all the different ways to access coordinates 
  /// (pos, size, left/top/right/bottom, width, height)
  /// Unlike System.Drawing.Rectangle, it is a class and better suited to be used as 
  /// a member (or base class) by any class that needs to represent a location
  /// 
  /// TODO: support changing/changed virtual functions and events.
  /// TODO: Add constructors.
  /// </summary>
  [Serializable]
  public class Rect : ICloneable
  {
    private Size m_size;
    private Point m_loc;

    public Rect()
    {
      m_size = Size.Empty;
      m_loc = Point.Empty;
    }

    public Rect(Rectangle r)
    {
      m_size = r.Size;
      m_loc = r.Location;
    }

    public Size Size { get { return m_size; } set { m_size = value; } }
    public Point Location { get { return m_loc; } set {m_loc = value; } }

    public int Left 
    { 
      get { return m_loc.X; }
      set { m_loc.X = value; }
    }

    public int Top
    {
      get { return m_loc.Y; }
      set { m_loc.Y = value; }
    }

    public int Right
    {
      get { return m_loc.X + m_size.Width; }
      set { m_size.Width = value - m_loc.X; }
    }

    public int Bottom
    {
      get { return m_loc.Y + m_size.Height; }
      set { m_size.Height = value - m_loc.Y; }
    }

    public int Width
    {
      get { return m_size.Width; }
      set { m_size.Width = value; }
    }

    public int Height
    {
      get { return m_size.Height; }
      set { m_size.Height = value; }
    }

    public Rectangle Rectangle
    {
      get { return new Rectangle(m_loc, m_size);  }
      set 
      {
        m_loc = value.Location;
        m_size = value.Size;
      }
    }

    public bool IsEmpty { get { return m_size.IsEmpty;  } }

    #region ICloneable Members

    public object Clone()
    {
      return new Rect(Rectangle);
    }

    #endregion
  }

  [Serializable]
  public class ControlPosition : Rect
  {
    public ControlPosition()
    {
    }

    public ControlPosition(Control ctrl) : this()
    {
      Save(ctrl);
    }

    public void Save(Control ctrl)
    {
      Size = ctrl.Size;
      Location = ctrl.Location;
    }

    public void Restore(Control ctrl, ControlPositionFlags flags)
    {
      if (!IsEmpty)
      {
        if (0 != (flags & ControlPositionFlags.Size))
          ctrl.Size = Size;

        if (0 != (flags & ControlPositionFlags.Position))
        {
          ctrl.Location = Location;

          Form f = ctrl as Form;
          if (f != null)
            f.StartPosition = FormStartPosition.Manual;
        }
      }
    }

    public void Restore(Control ctrl)
    {
      Restore(ctrl, ControlPositionFlags.Default);
    }
  }
}