Simple Form Fading





0/5 (0 vote)
Enable forms to be faded in and out
Introduction
This article will show you how you can add fading to your forms. The code can be used at any time regardless of what the current opacity of the form is.
Using the code
The code can be implemented by either adding Fade.cs to your project, or by adding a reference to Fade.dll.
To use the code, add a using
statement to include the Fader namespace.
using Fader;
Calling the method is then a simple task. The syntax for the fading methods is:
Fade.direction(form);
The direction is either In
or Out
, and the form is the one to fade. We will now look at the In
and Out
methods in more detail.
While both methods can be called in the same way, by just supplying the target form, each is overloaded allowing their behavior to be modified. The In
method can be called by passing one property as such:
Fade.In(this); // Fade the current form in, starting at its current opacity
or it can be called with its overloaded method which is called with an additional boolean value.
Fade.In(this, true); // Fade the current form in, starting at an opacity of 0
The boolean value in this overload is FromHidden
which sets the opacity of the form to 0 before fading in. This allows the method to be used in the Form_Load
event without having to manually set the opacity to 0.
As with the In
method, the Out
method can also be called using either one or two properties. Calling the method using only the Form
property is done in the same way as the In
method:
Fade.Out(this); // Fade the current form out, starting at its current opacity
The overloaded method accepts the Exit
boolean value which closes the application once the fade out has finished.
Fade.Out(this, true); // Fade the current form out then exit the application
Development
I originally attempted to carry out the fading process within a loop using System.Threading.Thread.Sleep()
. This worked perfectly for fading forms out, however it did not work for fading the form in. I then turned to using the Windows Forms timers. The timers used are created programmatically within the In
and Out
methods and disposed once the fading is complete.
The Fade
class three private global variables which are used to pass the properties from the public In
and Out
methods to the private FadeIn
and FadeOut
methods which are used as the event handlers for the timers.
Using timers worked well, however there was an issue with the fading in. Due to Windows adding its own effect to forms when they are shown, the fading is somewhat overshadowed. To overcome this, there is a 1 second delay before the fade in begins to allow the built in effect to pass. The form's opacity is set to 0 before the delay to hide it during the built in effect. This is the code for the In
method accepting only the form
public static void In(Form Form)
{
frmTarget = Form; // Set global variable
Form.Opacity = Form.Opacity - (Form.Opacity % 0.05); // Make opacity a multiple of 0.05
Timer newTimer = new Timer(); // Create new timer for fade in event
newTimer.Interval = 1; // Set timer interval
if (blnFromHidden) { newTimer.Interval = 1000; } // Delay for calling from Form_Load
newTimer.Tick += new EventHandler(FadeIn); // Add event handler to tick event
newTimer.Start(); // Start fade in event
}
The fading works by adding 0.05 to the opacity on the Tick
event of the timer. Because of this, the opacity needs to be a multiple of 0.05. This is achieved by subtracting the remainder of the opacity divided by 0.05. The timer is then created with an interval of 1 millisecond. The code then checks to see if blnFromHidden
is set to true. This is set in the overloaded method which also sets the form's opacity to 0.
public static void In(Form Form, bool FromHidden) // Overloaded method
{
if (FromHidden)
{
Form.Opacity = 0; // Ensure form is hidden before beginning fade in
blnFromHidden = true;
}
In(Form);
}
If blnFromHidden
is true, the timer interval is set to 1000. This is where the 1 second delay comes from. Once the timer interval is set, the Tick
event is set to the FadeIn
method and the timer is started.
private static void FadeIn(object sender, EventArgs e)
{
(sender as Timer).Interval = 1; // Remove delay if applicable
if (frmTarget.Opacity != 1)
{
frmTarget.Opacity += 0.05; // Increase form opacity if it is not yet 100%
}
else
{
(sender as Timer).Stop(); // Stop timer when form opacity is 100%
(sender as Timer).Dispose(); // Free up resources
}
}
The FadeIn
method first sets the interval to 1. This ensures that the second long delay is only applied once. If the opacity isn't 1, it is increased by 0.05, if it is 1, the timer is stopped and, disposed.
The Out
method works in a similar way to the In
method but without the delay.
public static void Out(Form Form)
{
frmTarget = Form; // Set global variable
Form.Opacity = Form.Opacity - (Form.Opacity % 0.05); // Make opacity a multiple of 0.05
Timer newTimer = new Timer(); // Create new timer for fade out event
newTimer.Interval = 1; // Set timer interval
newTimer.Tick += new EventHandler(FadeOut); // Add event handler to tick event
newTimer.Start(); // Start fade out event
}
public static void Out(Form Form, bool Exit)
{
blnExit = Exit; // Set global variable
Out(Form);
}
When the form has been hidden and the timer has been stopped, if blnExit
is true, the application will exit.
private static void FadeOut(object sender, EventArgs e)
{
if (frmTarget.Opacity != 0)
{
frmTarget.Opacity -= 0.05; // Decrease form opacity if it is not yet 0%
}
else
{
(sender as Timer).Stop(); // Stop timer when form opacity is 0%
(sender as Timer).Dispose(); // Free up resources
if (blnExit)
{
Application.Exit(); // Exit application after form is hidden
}
}
}
Plans for improvement
To further improve this feature, I plan to add the ability to change the speed of the fade to allow the fading to be customised slightly.