The programmer declares what the function he is going to write will do. He states his intention. I suggest something small that can be completed in less than 5 minutes.

When the programmer is finished, he declares he is done.

Each supporter in turn grades the function from 0 to 10, with 10 being the highest value and 0 being the lowest. For every point less than 10 that is given, the supporter must come up with a way of making it a 10.

1. The supporter then follows his grading with a statement of what he likes about the code as written.

2. The supporter then states what it would take to get a 10.

One of the supporters takes the role of the programmer, and the process begins again.

After everyone has had one turn at being the programmer, you can repeat the cycle, but this time the programmer starts with the code that he or she wrote before and tries to improve it for a couple of minutes to raise the grade.

Start off by setting up a Windows Forms application to work as a screen saver. Create a new C# Windows Forms application project called Extreme Screen Saver.

Change the name of the created form class to SaverForm.

Edit the constructor to take an integer parameter and store it in a member variable of the class called ScreenID.

private int screenID;
public SaverForm(int screen)
{
    InitializeComponent();
    screenID = screen;
}

Edit the Main method to use parameters to determine how to run the application. This is how Windows launches a screen saver.

It might help if you can draw a table for your partner (on a white board or a scrap of paper).

static void Main(string[] args)
{
    if (args.Length > 0)
    {
        // config
        if (args[0].ToLower().Trim().Substring(0,2) == "/c")
        {        }
        // saver
        else if (args[0].ToLower() == "/s")
        {        }
        // preview
        else if (args[0].ToLower() == "/p")
        {         }
    }
    else
    {         }
}

Create a static protected method in the SaverForm class called LaunchSaver. In this LaunchSaver method, add code to iterate through all the screens connected to the PC and create a new form to run in that screen.

static protected void LaunchSaver()
{
    for (int i = Screen.AllScreens.GetLowerBound(0);
        i <= Screen.AllScreens.GetUpperBound(0); i++)
    {
        System.Windows.Forms.Application.Run(new SaverForm(i));
    }
}

Back in the Main method, call this static method from the launch and default argument cases.

static void Main(string[] args)
{
    if (args.Length > 0)
    {
        if (args[0].ToLower().Trim().Substring(0,2) == "/c")
        {    }
        else if (args[0].ToLower() == "/s")
        {
            SaverForm.LaunchSaver();
        }
        else if (args[0].ToLower() == "/p")
        {    }
    }
    else
    {
        SaverForm.LaunchSaver();
    }
}

Compile and run the program. Close it, and then try renaming the created EXE file from eXtreme Screen Saver.exe to eXtreme Screen Saver.scr. You should be able to install this and run it as a screen saver.

Swap roles.

We will now set up the form to occupy the entire screen and respond to mouse and keyboard events to close down. In the design view for the Saver-Form, set the FormBorderStyle property to None.

Create an event handler for the Load event on the form. This can be done by double-clicking the form in design view. In this method, we need to set the Bounds of the form to those of the screen, hide the cursor, and set the form to display on top of all the other forms.

private void SaverForm_Load(object sender,
    System.EventArgs e)
{
    Bounds = Screen.AllScreens[screenID].Bounds;
    Cursor.Hide();
    TopMost = true;
}

In this Load method, we can also add handler code for the mouse and keyboard events. We want to handle these events and decide whether we are going to end running the screen saver. Start by adding an event handler for the MouseMove event. Call this method SaverForm_MouseEvent. In Visual Studio.NET, you can type MouseMove += and then pressing the Tab key should generate the handler skeleton.

private void SaverForm_Load(object sender,
    System.EventArgs e)
{
    ...
    MouseMove +=new MouseEventHandler(SaverForm_MouseEvent);
}

When the application first runs, it will get the mouse location through a mouse move event, so the first time we get the event, we just need to trap the position of the mouse in a member variable. After that, if the mouse moves, we need to close the application.

private Point initialMousePt;
private void SaverForm_MouseEvent(object sender,
    MouseEventArgs e)
{
    if (!initialMousePt.IsEmpty)
    {
        if (initialMousePt != new Point(e.X, e.Y))
            Close();
    }
    initialMousePt = new Point(e.X, e.Y);
}

We can use this same event handler for the mouse down event that occurs when a user clicks a mouse button. Add the method to the event in the Load method. Then change the MouseEvent method to also close the form when a click has occurred.

private void SaverForm_Load(object sender,
    System.EventArgs e)
{
    ...
    MouseMove +=new MouseEventHandler(SaverForm_MouseEvent);
    MouseDown +=new MouseEventHandler(SaverForm_MouseEvent);
}

private void SaverForm_MouseEvent(object sender,
    MouseEventArgs e)
{
    if (!initialMousePt.IsEmpty)
    {
        if (initialMousePt != new Point(e.X, e.Y))
            Close();
        if (e.Clicks > 0)
            Close();
    }
    initialMousePt = new Point(e.X, e.Y);
}

Now let’s do the same with a handler for the KeyDown event.

private void SaverForm_Load(object sender,
    System.EventArgs e)
{
    ...

    KeyDown +=new KeyEventHandler(SaverForm_KeyDown);
}

private void SaverForm_KeyDown(object sender,
    KeyEventArgs e)
{
    Close();
}

Compile and run the program. It is starting to work more like a screen saver. Rename the EXE file to an SCR file and test it. We now have a basic screen saver.

Swap roles.

The next thing to do is to add some drawing functionality so that the screen saver actually does something. We will start by adding a Paint event handler to the Form class. Again we can do this in the Form load method.

private void SaverForm_Load(object sender,
    System.EventArgs e)
{
    ...
    Paint +=new PaintEventHandler(SaverForm_Paint);
}

private void SaverForm_Paint(object sender,
    PaintEventArgs e)
{
}

In the Paint event method, we will add some code to draw the text eXtreme .NET in the center of the screen. We will use the TranslateTransform method to shift the drawn text to the center of the screen.

You need to add the System.Drawing.Drawing2D namespace to this class file because we need to use the MatrixOrder enumerated type from there.

private void SaverForm_Paint(object sender,
    PaintEventArgs e)
{
    Graphics gc = e.Graphics;
    Point screenCenter = new Point(
        (int)(gc.VisibleClipBounds.Width/2),
        (int)(gc.VisibleClipBounds.Height/2));

    gc.TranslateTransform(screenCenter.X,
        screenCenter.Y,
        MatrixOrder.Append);

    int fntSize = 12;
    Font fnt = new Font(FontFamily.GenericSansSerif,fntSize);
    Brush brsh = Brushes.Red;
    StringFormat format = new
        StringFormat(StringFormat.GenericTypographic);
    format.Alignment = StringAlignment.Center;
    format.LineAlignment = StringAlignment.Center;

    SizeF size = gc.MeasureString("eXtreme .NET", fnt);

    RectangleF rect = new RectangleF(
        0 - size.Width/2,
        0 - size.Height/2,
        size.Width,
        size.Height);

    gc.DrawString("eXtreme .NET", fnt, brsh, rect, format);
}

Add a timer control to the form and use the timer event to redraw the screen so that we can add some animation to the text. You do that in the design view. The timer control can be dragged from the toolbox onto the form and then double-clicked to generate the event handler method. Make sure you set the Enabled property of the timer to true so that it raises the events.

In the timer event handler, we will call Invalidate.

private void timer1_Tick(object sender,
    System.EventArgs e)
{
    Invalidate();
}

Next animate the text. We will make the text grow and shrink on the screen using the ScaleTransform method of the Graphics object. To do this, we need some class member variables to represent the current scale and the amount to change the scaling. We can manipulate these in the timer tick event.

private float scale = 1;
private float scaleChange = 0.1F;

private void SaverForm_Paint(object sender,
    PaintEventArgs e)
{
    Graphics gc = e.Graphics;
    Point screenCenter = new Point(
        (int)(gc.VisibleClipBounds.Width/2),
        (int)(gc.VisibleClipBounds.Height/2));

    gc.ScaleTransform(scale,
        scale, MatrixOrder.Append);
    gc.TranslateTransform(screenCenter.X,
        screenCenter.Y,
        MatrixOrder.Append);
    ...
}

private void timer1_Tick(object sender,
    System.EventArgs e)
{
    scale+= scaleChange;
    if (scale < 1)
    {
        scaleChange = 0.1F;
    }
    if (scale > 20)
    {
        scaleChange = -0.1F;
    }
    Invalidate();
}

Compile and run the program. You may want to decrease the Interval property on the timer to make the animation more viewable.

Swap roles.

We will use some of the built-in double buffering provided by the .NET Framework to remove the screen flicker. We will also add some more movement to the text animation. Before we add the double buffer in the constructor of our Form class, we need to set the style of the form to use WMPaint, the UserPaint style, and DoubleBuffer.

public SaverForm(int screen)
{
    InitializeComponent();
    screenID = screen;
    this.SetStyle(
        ControlStyles.AllPaintingInWmPaint|
        ControlStyles.UserPaint|
        ControlStyles.DoubleBuffer, true);
}

Now let’s add rotation to the text animation so that it spins around as it grows and shrinks. We will use two class member variables to indicate the current angle of the text and the next amount by which to change the angle. We can vary this in our timer tick event method. In the Paint event method, we will use the RotateTransform method to rotate the text around the origin.

private float angle = 0;
private float angleChange = 5;

private void SaverForm_Paint(object sender,
    PaintEventArgs e)
{
    Graphics gc = e.Graphics;

    Point screenCenter = new Point(
        (int)(gc.VisibleClipBounds.Width/2),
        (int)(gc.VisibleClipBounds.Height/2));

    gc.RotateTransform(angle, MatrixOrder.Append);
    gc.ScaleTransform(scale,
        scale, MatrixOrder.Append);
    . . .
}

private void timer1_Tick(object sender,
    System.EventArgs e)
{
    angle+=angleChange;
    scale+= scaleChange;
    if (scale < 1)
    {
        scaleChange = 0.1F;
        angleChange = 5F;
    }
    if (scale > 20)
    {
        scaleChange = -0.1F;
        angleChange = -5F;
    }
    Invalidate();
}

Compile and run the program. The animation should look much smoother. Try it as a screen saver by renaming the EXE file.

Extend the screen saver to display a preview.

In the preceding exercise, you have created an entry point in the code that will get called when the program is run with the /p argument. Extend the code to draw the animation in the preview window provided.

Hint: The second argument in the command-line arguments is a handle to a window (hWnd) in which to draw the screen saver preview.

Extend the screen saver to display a settings box.

Carry on from the screen saver exercise again, and this time add functionality to display a configuration dialog box so that the user can alter the settings on the screen saver. The entry point is already created in the Main method when a /c parameter is passed to the application.

The settings to be altered are the speed of the animation, the angle of rotation, the text color, and finally the ability to customize the text.