Introduction
First, let me clear one thing up. A screensaver is nothing more than a standard Windows executable with the .scr extension instead of the standard .exe extension. It has the same file format as an EXE, and of course, you can make a .NET screensaver. You could take any old application you have on your computer, and give it a .scr extension, and you would have a perfectly valid Windows screensaver. However, you probably wouldn't want to do that. That's because screensavers do have certain responsibilities:
When Windows runs a screensaver, it will pass certain arguments to it. These arguments are "/s" (show the screensaver), "/p" (preview the screensaver in the small little monitor on the screensaver selection dialog), and "/c" (show the screensaver's options, or configure it). Windows expects your application to read these arguments in your screensaver's Main method, and act on them accordingly.
A screensaver usually takes up the whole screen. Thus, you must have some sort of exit signal built into the screensaver. Traditionally, a screensaver will exit if a key is pressed, or if the mouse is moved.
A screensaver also will stay on top of all other windows, and it will hide the cursor.
Reading the arguments
The only place you can read the arguments in a C# application is in the automatically generated Main() method. Go to the Solution Explorer. There should be a code file called "Program.cs". Open it up in the code editor. It might look like this:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
namespace YourApplicationNamespace
{
static class Program
{
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new YourApplicationMainForm());
}
}
}
All we are concerned with in that is the Main method:
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new YourApplicationMainForm());
}
By default, the Main() method will take no arguments. You must edit it so it will take an argument of "string[] args"; that way, you will be able to read the arguments passed to your application:
static void Main(string[] args)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new YourApplicationMainForm());
}
The args parameter will now hold all the arguments passed to your application. Now, you must interpret those arguments. Only one argument should be passed to a screensaver, the argument that tells the screensaver what Windows wants it to do. We could read the arguments easily with a simple if statement, like so:
if (args[0].ToLower().Trim().Substring(0,2) == "/s")
{
}
else if (args[0].ToLower().Trim().Substring(0,2) == "/p")
{
}
else if (args[0].ToLower().Trim().Substring(0,2) == "/c")
{
}
However, it is possible for no arguments to be passed to a screensaver. Thus, we should probably add another if statement:
if (args.Length > 0)
{
if (args[0].ToLower().Trim().Substring(0,2) == "/s")
{
}
else if (args[0].ToLower().Trim().Substring(0,2) == "/p")
{
}
else if (args[0].ToLower().Trim().Substring(0,2) == "/c")
{
}
}
else
{
}
That way, you won't get an index out of range exception if you try to reference the first argument passed and there is nothing there.
At this stage, we must modify our Main method to look like this:
static void Main(string[] args)
{
if (args.Length > 0)
{
if (args[0].ToLower().Trim().Substring(0,2) == "/s")
{
}
else if (args[0].ToLower().Trim().Substring(0,2) == "/p")
{
}
else if (args[0].ToLower().Trim().Substring(0,2) == "/c")
{
}
}
else
{
}
}
Setting up the screensaver
At this point, if we try to run our application, it would run through like a console application with no code, because we never invoke Application.Run() anywhere in our Main. After we do a few things here, that will be taken care of. Now, I have made several screensavers in C# that support multiple monitors, and I will explain to you the structure I use to make them. I'm not saying my way is the best, but it works, and it's organized. To have multiple monitor support, instead of simply making a main form and stretching it to fill up all the screens, I make the screensaver so it will show a different main form on every screen (by the way, whenever I refer to the main form in the code, I will call it "MainForm"). To do this, the System.Windows.Forms.Screen class comes in handy. Take a look at this code:
foreach (Screen screen in Screen.AllScreens)
{
MainForm screensaver = new MainForm(screen.Bounds);
screensaver.Show();
}
The foreach loop you see is looping through all the screens (monitors) on the current computer. I then create a new main form for that monitor, passing it the bounds of that screen, and showing it. But, wait a minute, that will not work because there is no constructor method in our main form that takes an argument. So, let us make one. I added this exact constructor to my main form:
public MainForm(Rectangle Bounds)
{
InitializeComponent();
this.Bounds = Bounds;
Cursor.Hide();
}
As you can see, it takes an argument of System.Drawing.Rectangle (that's what bounds are), and in the constructor, it would set the form's bounds to the one passed in the constructor. It would also hide the cursor, because like I said, screensavers hide the cursor.
So, to run the screensaver, we could create a method like so:
void ShowScreenSaver()
{
foreach (Screen screen in Screen.AllScreens)
{
MainForm screensaver = new MainForm(screen.Bounds);
screensaver.Show();
}
}
Typically, I will make a method like that to show the screensaver, and put that in the class my main method is in (Program). So, your Program class would now look like:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
namespace YourApplicationNamespace
{
static class Program
{
[STAThread]
static void Main(string[] args)
{
if (args.Length > 0)
{
if (args[0].ToLower().Trim().Substring(0,2) == "/s")
{
}
else if (args[0].ToLower().Trim().Substring(0,2) == "/p")
{
}
else if (args[0].ToLower().Trim().Substring(0,2) == "/c")
{
}
}
else
{
}
}
static void ShowScreenSaver()
{
foreach (Screen screen in Screen.AllScreens)
{
MainForm screensaver = new MainForm(screen.Bounds);
screensaver.Show();
}
}
}
}
(Note: we must make the ShowScreenSaver() method static when we put it in the Program class, as it is a static class.)
Now, let's modify our Main() method so it will actually use that method if our application was passed /s, or if it was passed nothing.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
namespace YourApplicationNamespace
{
static class Program
{
[STAThread]
static void Main(string[] args)
{
if (args.Length > 0)
{
if (args[0].ToLower().Trim().Substring(0,2) == "/s")
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
ShowScreenSaver();
Application.Run();
}
else if (args[0].ToLower().Trim().Substring(0,2) == "/p")
{
}
else if (args[0].ToLower().Trim().Substring(0,2) == "/c")
{
}
}
else
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
ShowScreenSaver();
Application.Run();
}
}
static void ShowScreenSaver()
{
foreach (Screen screen in Screen.AllScreens)
{
MainForm screensaver = new MainForm(screen.Bounds);
screensaver.Show();
}
}
}
}
Guess what, we now have a working screensaver. Working, but not complete. We still need to make our main() method allow for /p and /c. We will now set it up for a /c (configure) argument as that is quite easy. Do you want the user to be able to choose some of the options in the screensaver? If so, simply create a form where the user can configure the options, and have your application so it will store those options in the application's settings, an ini file, the Registry, or wherever. Now, we only need to modify the part of our main method that handles /c:
else if (args[0].ToLower().Trim().Substring(0,2) == "/c")
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new ConfigureForm());
}
(In this code, I referred to the configuration form as "ConfigureForm", but that can be changed.) Notice, I am using an Application.Run() call to start the application, and all I am doing is pass it the configuration form as the application's main form.
On the other hand, if you don't have any options the user can set, we can do something very easy, like so:
else if (args[0].ToLower().Trim().Substring(0,2) == "/c")
{
MessageBox.Show("This screensaver has no options that you can set",
"My Cool Screen Saver",
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
That will show a message telling the user the screensaver has no configurable options. Then, since we never invoked Appliction.Run(), the application will exit once the main method has run through, like a console application.
Now, we can handle the /p (preview) argument. The preview is when Windows wants your screensaver to preview itself in the little computer monitor on the screensaver dialog. There are two ways we can go about this. Generally, I choose to screw the preview all together. By the way, if you don't want a preview, you are done. You don't need any code in the section that handles the preview, so when Windows calls your application to preview, it will start, run through, and since the Application.Run() was never called, it will close in an inconceivably small amount of time like it never even ran. That was easy. However, if you so desire for your screensaver to have a preview, I will teach you how to do it.
Setting up the preview
This is a bit tricky. It takes a few APIs to do it. Windows will not automatically do some voodoo magic to make your application show perfectly in the preview window, you have to do it on your own. It does, however, lend you some help. When Windows passes your application the /p command, it will also pass another argument: the handle to the preview window on the Select screensaver dialog. With that, we can use a few APIs to make it the parent of our screensaver's main form. This is how it will work:
- The main function will see the first argument is /p. It then knows the second argument is the handle to the preview window.
- The main function will run the application with
MainForm as the main form using Application.Run(). It will also pass the main form the handle to the preview window.
- The main form will configure itself so that it will show inside the preview window.
- They all live happily ever after.
Let's start to implement that. First, let me refresh your (and my) mind of what the section of our main routine that handles /p looks like:
else if (args[0].ToLower().Trim().Substring(0,2) == "/p")
{
}
As it is now, it is set up in a way where there will be no preview since there is no code except for that lonely little comment. We must modify that to look like this:
else if (args[0].ToLower().Trim().Substring(0,2) == "/p")
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm(new IntPtr(long.Parse(args[1]))));
}
Looks like that comment's not so lonely anymore. Anyway, that should be all you need to do to the Main function. However, see the line:
Application.Run(new MainForm(new IntPtr(long.Parse(args[1]))));
That is passing MainForm the handle to the preview window in the form of an IntPtr. However, we have no constructor made for that form that will accept an IntPtr. Well, time to make one. Guess what, you don't have to do any work again because all you have to do is use this code I've already written:
public MainForm(IntPtr PreviewHandle)
{
InitializeComponent();
SetParent(this.Handle, PreviewHandle);
SetWindowLong(this.Handle, -16,
new IntPtr(GetWindowLong(this.Handle, -16) | 0x40000000));
Rectangle ParentRect;
GetClientRect(PreviewHandle, out ParentRect);
this.Size = ParentRect.Size;
this.Location = new Point(0, 0);
IsPreviewMode = true;
}
In case you haven't figured out, I am making a real screensaver as I am writing this tutorial. Anyway, that is exactly what you should use. But wait a minute, that is going to throw a whole bunch of errors at you if you try to use it right now. That's because there are four APIs I'm using in there that aren't in your code yet. Here they are:
#region Preview API's
[DllImport("user32.dll")]
static extern IntPtr SetParent(IntPtr hWndChild, IntPtr hWndNewParent);
[DllImport("user32.dll")]
static extern int SetWindowLong(IntPtr hWnd, int nIndex, IntPtr dwNewLong);
[DllImport("user32.dll", SetLastError = true)]
static extern int GetWindowLong(IntPtr hWnd, int nIndex);
[DllImport("user32.dll")]
static extern bool GetClientRect(IntPtr hWnd, out Rectangle lpRect);
#endregion
I believe I did a fairly good job of explaining exactly what is going on, so I'll move on. Oh, and about that variable in the constructor I gave you, called IsPreviewMode. That is to let the application know weather or not it is in preview mode when it's running. If you are making a screensaver as you are reading this, make a global boolean called IsPreviewMode. You will need a variable like that because when you are in preview mode, you want to disable any mouse or key events that will make the screensaver exit. For example, if you had a key down event that had code in it to exit the application, you would want to put an if statement around that to make sure your application is not in preview mode. Why? When your screensaver is previewing in the preview window on the Select screensaver dialog, any time you move your mouse over the preview window, press a key, or click the preview window, you certainly don't want the preview to go away, and that is what will happen if we don't take these precautions. You can also use the IsPreviewMode variable to make it so that certain code won't run through when in preview mode, and certain code will run through in preview mode that won't run in standard mode. That can be very useful.
Putting it all together
OK, this is about what your Program.cs file should look like at this point:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
namespace YourApplicationNamespace
{
static class Program
{
[STAThread]
static void Main(string[] args)
{
if (args.Length > 0)
{
if (args[0].ToLower().Trim().Substring(0, 2) == "/s")
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
ShowScreensaver();
Application.Run();
}
else if (args[0].ToLower().Trim().Substring(0, 2) == "/p")
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm(new IntPtr(long.Parse(args[1]))));
}
else if (args[0].ToLower().Trim().Substring(0, 2) == "/c")
{
}
else
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
ShowScreensaver();
Application.Run();
}
}
else
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
ShowScreensaver();
Application.Run();
}
}
static void ShowScreensaver()
{
foreach (Screen screen in Screen.AllScreens)
{
MainForm screensaver = new MainForm(screen.Bounds);
screensaver.Show();
}
}
}
}
And just to be clear, these are the two new constructors you should have in your MainForm (you will only have the top one if you chose not to do a preview):
public Form1(Rectangle Bounds)
{
InitializeComponent();
this.Bounds = Bounds;
Cursor.Hide();
}
public Form1(IntPtr PreviewHandle)
{
InitializeComponent();
SetParent(this.Handle, PreviewHandle);
SetWindowLong(this.Handle, -16,
new IntPtr(GetWindowLong(this.Handle, -16) | 0x40000000));
Rectangle ParentRect;
GetClientRect(PreviewHandle, out ParentRect);
this.Size = ParentRect.Size;
this.Location = new Point(0, 0);
IsPreviewMode = true;
}
Now, with what we have thus far, we are pretty good to go, but there's still one more thing we need to do. We absolutely have to add in functions that will make the screensaver exit when a key is pressed, the screensaver is clicked, or if the mouse is moved significantly over the screensaver. All you really have to do is something like this:
#region User Input
private void Form1_KeyDown(object sender, KeyEventArgs e)
{
if (!IsPreviewMode)
{
Application.Exit();
}
}
private void Form1_Click(object sender, EventArgs e)
{
if (!IsPreviewMode)
{
Application.Exit();
}
}
Point OriginalLocation = new Point(int.MaxValue, int.MaxValue);
private void Form1_MouseMove(object sender, MouseEventArgs e)
{
if (!IsPreviewMode)
{
if (OriginalLocation.X == int.MaxValue &
OriginalLocation.Y == int.MaxValue)
{
OriginalLocation = e.Location;
}
if (Math.Abs(e.X - OriginalLocation.X) > 20 |
Math.Abs(e.Y - OriginalLocation.Y) > 20)
{
Application.Exit();
}
}
}
#endregion
Now, you obviously can't just copy/paste that because you have to make those functions event handlers. Anyway, that won't be hard at all. Note that I used an Application.Exit() call instead of a this.close() because, though I call it MainForm, it really isn't a "Main Form" because if it is closed, the application will still keep on running. To fix that, we simply use the Application.Exit() call. Now, there's only one thing you have left to do: change the extension of your build application from .exe to .scr, and if you want to use it as a screensaver on your computer, copy it into the system32 directory and set it as your screensaver.
I said I was making a real screensaver as I was writing this tutorial, and it's only fair I give it to you as an example. Download it from the link at the top. The screensaver I made shows a fake, but highly authentic blue screen of death, like the BSOD screensaver on SysInternals. Anyway, that's not the point. The point is that it demonstrates everything I have said. It also has a preview.
