Fading Forms In and Out

	public new double Opacity
	{
		get { return base.Opacity; }
		set
		{
			if(Opacity<1&&value==1)
			{
				TransparencyKey = Color.Transparent;	
			}
 
			if (Opacity == 1 && value < 1)
			{
				base.Opacity = value;
				TransparencyKey = Color.Empty;
			}
			else
			{
					base.Opacity = value;
			}
		}
	}

public new double Opacity
{
  get 
  {
    if (base.Opacity >= .999) return 1;
    else return base.Opacity; 
  }
  set
  {
    if (value == 1)
    {
      base.Opacity=.999;
    }
    else
    {
      base.Opacity = value;
    }
  }
}

using System;
using System.ComponentModel;
using System.Windows.Forms;
 
namespace Test
{
   /// <summary>
   /// A form that fades in and out.
   /// </summary>
   public class FadeForm : Form
   {
      #region WindowsMessageCodes
      private const int WMSysCommand = 0x112;
      private const int WMCommand = 0x111;
      private const int SCMinimize = 0xF020;
      private const int SCRestore = 0xF120;
      private const int SCClose = 0xF060;
      #endregion
 
      #region Variables
      /// <summary>
      /// WindowsMessage that is being held until the end of a transition.
      /// </summary>
      private Message _HeldMessage = new Message();
 
      /// <summary>
      /// Timer to aid in fade effects.
      /// </summary>
      private System.Windows.Forms.Timer _Timer;
      #endregion
 
      #region Properties
      #region ActiveOpacity
      private double _ActiveOpacity = 1;
      /// <summary>
      /// Gets or sets the opacity that the form will transition to when the form gets focus which must be a positive number.
      /// </summary>
      /// <exception cref="ArgumentOutOfRangeException">Thrown if this property is not set to a positive value.</exception>
      [Category("Custom")]
      [Description("The opacity that the form will transition to when the form gets focus which must be a positive number.")]
      [RefreshProperties(RefreshProperties.All)]
      public double ActiveOpacity
      {
         get { return _ActiveOpacity; }
         set
         {
            if (value >= 0)
               _ActiveOpacity = value;
            else
               throw new ArgumentOutOfRangeException("value", Properties.Resources.ErrorActiveOpacity);
            
            if (ContainsFocus)
               TargetOpacity = _ActiveOpacity;
         }
      }
      #endregion
 
      #region FadeTime
      private double _FadeTime = 0.35;
      /// <summary>
      /// Gets or sets the time it takes to fade from 0 to 1 or the other way around.
      /// </summary>
      /// <exception cref="ArgumentOutOfRangeException">Thrown if this property is not set to a positive value between 0 and 1.</exception>
      [Category("Custom")]
      [Description("The time it takes to fade from 0 to 1 or the other way around.")]
      public double FadeTime
      {
         get { return _FadeTime; }
         set
         {
            if (value > 0 && value < 1)
               _FadeTime = value;
            else
               throw new ArgumentOutOfRangeException("value", Properties.Resources.ErrorFadeTime);
         }
      }
      #endregion
 
      #region InactiveOpacity
      private double _InactiveOpacity = .85;
      /// <summary>
      /// Gets or sets the opacity that the form will transition to when the form doesn't have focus.
      /// </summary>
      /// <exception cref="ArgumentOutOfRangeException">Thrown if this property is not set to a value greater than or equal to 0.</exception>
      [Category("Custom")]
      [Description("The opacity that the form will transition to when the form doesn't have focus.")]
      [RefreshProperties(RefreshProperties.All)]
      public double InactiveOpacity
      {
         get { return _InactiveOpacity; }
         set
         {
            if (value >= 0)
               _InactiveOpacity = value;
            else
               throw new ArgumentOutOfRangeException("value", Properties.Resources.ErrorInactiveOpacity);
            
            if (!ContainsFocus && WindowState != FormWindowState.Minimized)
               TargetOpacity = _InactiveOpacity;
         }
      }
      #endregion
 
      #region MinimizedOpacity
      private double _MinimizedOpacity;
      /// <summary>
      /// Gets or sets the opacity that the form will transition to when the form is minimized.
      /// </summary>
      /// <exception cref="ArgumentOutOfRangeException">Thown if this property is not set to a value greater than or equal to 0.</exception>
      [Category("Custom")]
      [Description("The opacity that the form will transition to when the form is minimized.")]
      [RefreshProperties(RefreshProperties.All)]
      public double MinimizedOpacity
      {
         get { return _MinimizedOpacity; }
         set
         {
            if (value >= 0)
               _MinimizedOpacity = value;
            else
               throw new ArgumentOutOfRangeException("value", Properties.Resources.ErrorMinimizedOpacity);
            
            if (!ContainsFocus && WindowState != FormWindowState.Minimized)
               TargetOpacity = InactiveOpacity;
         }
      }
      #endregion
 
      #region TargetOpacity
      private double _TargetOpacity;
      /// <summary>
      /// Gets or sets the opacity the form is transitioning to.
      /// </summary>
      [Category("Custom")]
      [Description("The opacity the form is transitioning to.")]
      public double TargetOpacity
      {
         get { return _TargetOpacity; }
         set
         {
            _TargetOpacity = value;
            if (!_Timer.Enabled)
               _Timer.Start();
         }
      }
      #endregion
      #endregion
 
      #region Constructor
      /// <summary>
      /// Constructor
      /// </summary>
      [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Mobility", "CA1601:DoNotUseTimersThatPreventPowerStateChanges", Scope = "member", Target = "FadeForm.FadeForm..ctor()")]
      public FadeForm()
      {
         this._Timer = new System.Windows.Forms.Timer();
         this.SuspendLayout();
         this._Timer.Interval = 25;
         this._Timer.Tick += new System.EventHandler(this._Timer_Tick);
      }
      #endregion
 
      #region DisableFade
      /// <summary>
      /// Turns off opacitiy fading.
      /// </summary>
      public void DisableFade()
      {
         ActiveOpacity = 1;
         InactiveOpacity = 1;
         MinimizedOpacity = 1;
      }
      #endregion
 
      #region EnableFadeDefaults
      /// <summary>
      /// Turns on opacitiy fading.
      /// </summary>
      public void EnableFadeDefaults()
      {
         ActiveOpacity = 1;
         InactiveOpacity = .85;
         MinimizedOpacity = 0;
         FadeTime = .35;
      }
      #endregion
 
      #region WndProc
      /// <summary>
      /// Intercepts WindowMessages before they are processed.
      /// </summary>
      /// <param name="m">Windows Message</param>
      [System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.LinkDemand, Flags = System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode)]
      protected override void WndProc(ref Message m)
      {
         if (m.Msg == WMSysCommand || m.Msg == WMCommand)
         {
            //Fade to zero on minimze
            if (m.WParam == (IntPtr)SCMinimize)
            {
               if (_HeldMessage.WParam != (IntPtr)SCMinimize)
               {
                  _HeldMessage = m;
                  TargetOpacity = MinimizedOpacity;
               }
               else
               {
                  _HeldMessage = new Message();
                  TargetOpacity = ActiveOpacity;
               }
               return;
            }
 
           //Fade in if the window is restored from the taskbar
            else if (m.WParam == (IntPtr)SCRestore
                && this.WindowState == FormWindowState.Minimized)
            {
               base.WndProc(ref m);
               TargetOpacity = ActiveOpacity;
               return;
            }
 
           //Fade out if the window is closed.
            else if (m.WParam == (IntPtr)SCClose)
            {
               _HeldMessage = m;
               TargetOpacity = MinimizedOpacity;
               return;
            }
         }
 
         base.WndProc(ref m);
      }
      #endregion
 
      #region _Timer
      /// <summary>
      /// Called when the timer ticks.
      /// </summary>
      /// <param name="sender">Unused.</param>
      /// <param name="e">Unused.</param>
      private void _Timer_Tick(object sender, EventArgs e)
      {
         //Performs fade increment.
         double fadeChangePerTick = _Timer.Interval * 1.0 / 1000 / FadeTime;
 
         //Check to see if it is time to stop the timer
         if (Math.Abs(TargetOpacity - this.Opacity) < fadeChangePerTick)
         {
            //There is an ugly black flash if you set the Opacity to 1.0
            if (TargetOpacity == 1) this.Opacity = .999;
            else this.Opacity = TargetOpacity;
            //Process held Windows Message.
            base.WndProc(ref _HeldMessage);
            _HeldMessage = new Message();
            //Stop the timer to save processor.
            _Timer.Stop();
         }
         else if (TargetOpacity > this.Opacity) this.Opacity += fadeChangePerTick;
         else if (TargetOpacity < this.Opacity) this.Opacity -= fadeChangePerTick;
      }
      #endregion
 
      #region Activated
      /// <summary>
      /// Called when the form is activated.
      /// </summary>
      /// <param name="e">Unused.</param>
      protected override void OnActivated(EventArgs e)
      {
         base.OnActivated(e);
 
         //Fade in the form when it gaines focus.
         TargetOpacity = ActiveOpacity;
      }
      #endregion
 
      #region OnDeactivate
      /// <summary>
      /// Called when the form is deactivating.
      /// </summary>
      /// <param name="e">Unused.</param>
      protected override void OnDeactivate(EventArgs e)
      {
         base.OnDeactivate(e);
 
         //Fade out the form when it losses focus.
         this.TargetOpacity = InactiveOpacity;
      }
      #endregion
 
      #region OnLoad
      /// <summary>
      /// Called when the form is loading.
      /// </summary>
      /// <param name="e">Unused.</param>
      protected override void OnLoad(EventArgs e)
      {
         base.OnLoad(e);
         
         //Causes the form to fade in.
         this.Opacity = MinimizedOpacity;
         TargetOpacity = ActiveOpacity;
      }
      #endregion
   }
}

chris175 wrote:

Also I am noticing while resizing the window there is "black" space. This is just a minor issue.