Save and restore the state of a Windows Form in .NET 2.0

class FormState
{
  private Form _parent;
  private RegistryKey _reg_key;
  public FormState(Form parent)
  { 
    this._parent = parent;
    this._reg_key 
      = Application.UserAppDataRegistry.CreateSubKey(
        "FormState\\\\" + this._form.Name)
...

using System;
using System.Drawing;
using System.Windows.Forms;
using System.IO;
using System.IO.IsolatedStorage;
 
/// <summary>
/// Create an instance of this class in the constructor of a form. 
/// Will save and restore window state, size, and position.
/// Uses DesktopBounds (instead of just Form.Location/Size) 
/// to place window correctly on a multi screen desktop.
/// </summary>
public class FormStateMaintainer
{
    private Form formToRemember;
    private string windowStateFileName = @"undefined.xml";
 
    /// <summary>
    /// The location of the form
    /// </summary>
    public Point Location { get; set; }
 
    /// <summary>
    /// The size of the form
    /// </summary>
    public Size Size  { get; set; }
 
    /// <summary>
    /// The FormWindowState of the form
    /// </summary>
    public FormWindowState State { get; set; }
 
    /// <summary>
    /// Initializes an instance of the FormStateMaintainer class.
    /// </summary>
    /// <param name="form">
    /// The form to store settings for.
    /// </param>
    public FormStateMaintainer(Form form)
    {
        formToRemember = form;
        windowStateFileName = string.Format("{0}.xml", form.Name);
        formToRemember.Load += new EventHandler(On_Load);
        formToRemember.FormClosed += new FormClosedEventHandler(On_FormClosed);
    }
 
    /// <summary>
    /// Default constructor must exist for serialization to work
    /// </summary>
    public FormStateMaintainer()
    {
        Location = new Point(0, 0);
        Size = new Size(800, 600);
        State = FormWindowState.Normal;
    }
 
    void formToRemember_LocationChanged(object sender, EventArgs e)
    {
        RememberParameters();
    }
 
    void formToRemember_SizeChanged(object sender, EventArgs e)
    {
        RememberParameters();
    }
 
    void RememberParameters()
    {
        if (formToRemember.WindowState == FormWindowState.Normal)
        {
            Location = formToRemember.DesktopBounds.Location;
            Size = formToRemember.DesktopBounds.Size;
        }
        if (formToRemember.WindowState != FormWindowState.Minimized)
        {
            State = formToRemember.WindowState;
        }
    }
 
    IsolatedStorageFile GetMyIsolatedStorageFile()
    {
        return IsolatedStorageFile.GetUserStoreForDomain();
    }
 
    private void On_Load(object sender, EventArgs e)
    {
        formToRemember.Load -= new EventHandler(On_Load);
 
        // create X,Y defaults from the form itself, in case the xml is missing
        int X = formToRemember.DesktopBounds.X;
        int Y = formToRemember.DesktopBounds.Y;
 
        IsolatedStorageFile isoStore = GetMyIsolatedStorageFile();
        string[] foundFilenames = isoStore.GetFileNames(windowStateFileName);
        System.Diagnostics.Debug.Assert(foundFilenames.Length <= 1);
        if (foundFilenames.Length == 1)
        {
            using (IsolatedStorageFileStream strm = new IsolatedStorageFileStream(windowStateFileName,
                FileMode.Open, FileAccess.Read, FileShare.Read, isoStore))
            {
                // Load the state from xml
                using (TextReader tr = new StreamReader(strm))
                {
                    System.Xml.Serialization.XmlSerializer x =
                        new System.Xml.Serialization.XmlSerializer(this.GetType());
                    FormStateMaintainer loadedState = (FormStateMaintainer)x.Deserialize(tr);
                    Location = loadedState.Location;
                    Size = loadedState.Size;
                    State = loadedState.State;
                    X = Location.X;
                    Y = Location.Y;
                }
            }
        }
 
        // In case of multi screen desktops, check if we got the screen the form was on when closed.
        Rectangle boundsNow = Screen.GetWorkingArea(new Point(X, Y));
 
        if (X > boundsNow.X + boundsNow.Width)
        {
            // screen to the right is missing
            X = boundsNow.X + boundsNow.Width - Size.Width;
        }
        else if (X + Size.Width < boundsNow.X)
        {
            // screen to the left is missing
            X = boundsNow.X;
        }
 
        if (Y > boundsNow.Y + boundsNow.Height)
        {
            Y = boundsNow.Y + boundsNow.Height - Size.Height;
        }
        else if (Y + Size.Height < boundsNow.Y)
        {
            Y = boundsNow.Y;
        }
 
        Location = new Point(X, Y);
        formToRemember.DesktopBounds = new Rectangle(Location,Size);
        formToRemember.WindowState = State;
 
        // now we can watch for changes (not before, since we ourselves were changing the size/state!)
        formToRemember.SizeChanged += new EventHandler(formToRemember_SizeChanged);
        formToRemember.LocationChanged += new EventHandler(formToRemember_LocationChanged);
    }
 
    private void On_FormClosed(object sender, FormClosedEventArgs e)
    {
        formToRemember.FormClosed -= new FormClosedEventHandler(On_FormClosed);
        formToRemember.SizeChanged -= new EventHandler(formToRemember_SizeChanged);
        formToRemember.LocationChanged -= new EventHandler(formToRemember_LocationChanged);
 
        IsolatedStorageFile isoStore = GetMyIsolatedStorageFile();
        using (IsolatedStorageFileStream strm = new IsolatedStorageFileStream(windowStateFileName,
            FileMode.Create, FileAccess.Write, FileShare.None, isoStore))
        {
            // Save the state as xml
            using (TextWriter tw = new StreamWriter(strm))
            {
                System.Xml.Serialization.XmlSerializer x = 
                    new System.Xml.Serialization.XmlSerializer(this.GetType());
                x.Serialize(tw,this);
            }
        }
    }
}
 

Stein-Tore Erdal wrote:

I've changed the code a bit so it now handles that (using Screen.GetBounds()).

if (X > screen_bounds.X + screen_bounds.Width)
{
    X = screen_bounds.X;
    Y = screen_bounds.Y;
}

// If a screen or area to the right of the primary screen
// is missing
if (X > screen_bounds.X + screen_bounds.Width 
// or a screen to the left of the primary screen is missing
// (X co-ordinates to the left of the primary screen are negative)
||  X < screen_bounds.X
// or area to the bottom of the screen is missing
||  Y > screenBounds.Y + screenBounds.Height)
{
    X = screen_bounds.X;
    Y = screen_bounds.Y;
}