Simple Magnifier

Download source - 220.94 KB

Introduction

This is a fun little gadget for your desktop: a simple magnifier.

Background

I believe, many of you have already seen at least one magnifier application. I tried a few including the one which is built-in at the OS, however, I didn't like them one way or another. So, I decided to implement a simple one for my own usage.

Well, I've been using it quite sometime by now and it really works great. I thought you may find it interesting as well.

A Few Words About the Code

As I mentioned earlier, the program in fact is a simple application. However, it still demonstrates a few interesting points: First of all, it shows how to capture a screen image, double buffering, moving a Windows form programmatically, and serializing/deserializing configuration information through XmlSerializer. Second of all, the little application is designed to be a fun application in my mind, so it doesn't follow conventional Windows programming steps. Instead, I've used a very small borderless window as the main form. It has only 3 buttons (actually, hot spots) to do all functionality it provides. The first one instantiates a magnifier form, the second one to do the configuration, and finally, the third one is to exit from application.

Here is a screenshot of the application:

The configuration section provides quite a few things to play with:

Some of the code snippets are also shown below:

// Make the window (the form) elliptical
GraphicsPath gp = new GraphicsPath();
gp.AddEllipse(ClientRectangle);
Region = new Region(gp);
 
//--- Double Buffering --- 

protected override void OnPaintBackground(PaintEventArgs e)
{
    if (mConfiguration.DoubleBuffered)
    {
        // Do not paint background (required for double buffering)!
    }
    else
    {
        base.OnPaintBackground(e);
    }
} 

protected override void  OnPaint(PaintEventArgs e)
{
    if (mBufferImage == null)
    {
        mBufferImage = new Bitmap(Width, Height);
    }
    Graphics bufferGrf = Graphics.FromImage(mBufferImage);

    Graphics g;

    if (mConfiguration.DoubleBuffered)
    {
        g = bufferGrf;
    }
    else
    {
        g = e.Graphics;
    }

    if (mScreenImage != null)
    {
        Rectangle dest = new Rectangle(0, 0, Width, Height);
        int w = (int)(Width / mConfiguration.ZoomFactor);
        int h = (int)(Height / mConfiguration.ZoomFactor);
        int x = Left - w / 2 + Width / 2;
        int y = Top - h / 2 + Height / 2;

        g.DrawImage(
            mScreenImage,
            dest,
            x, y,
            w, h,
            GraphicsUnit.Pixel);
    }

    if (mImageMagnifier != null)
    {
        g.DrawImage(mImageMagnifier, 0, 0, Width, Height);
    }

    if (mConfiguration.DoubleBuffered)
    {
        e.Graphics.DrawImage(mBufferImage, 0, 0, Width, Height);
    }      
} 
//--- XML Serialization --- 
public class XmlUtility
{
    public static void Serialize(Object data, string fileName)
    {
        Type type = data.GetType();
        XmlSerializer xs = new XmlSerializer(type);
        XmlTextWriter xmlWriter = new XmlTextWriter(fileName, System.Text.Encoding.UTF8);
        xmlWriter.Formatting = Formatting.Indented;
        xs.Serialize(xmlWriter, data);
        xmlWriter.Close();
    }

    public static Object Deserialize(Type type, string fileName)
    {
        XmlSerializer xs = new XmlSerializer(type);

        XmlTextReader xmlReader = new XmlTextReader(fileName);
        Object data = xs.Deserialize(xmlReader);

        xmlReader.Close();

        return data;
    }        
}