Why Can’t You Bind the Size of a Windows Form to ApplicationSettings?

As developers working with Windows Forms, we often seek ways to enhance user experience by maintaining application states. One common question that arises when using ApplicationSettings with Windows Forms is: Why can’t you bind the size of a Windows Form directly to ApplicationSettings?

This limitation can be frustrating, particularly when other properties seem to bind effortlessly. However, there is a way to tackle this issue and ensure that your application’s window state and size are saved between sessions. Let’s explore the root of the issue and examine the solution in clearer detail.

Understanding the Restriction

When you attempt to bind a Windows Form size directly to ApplicationSettings, you may notice that the Size property is missing from the Property Binding list. This is because the form’s size cannot be simply bound; it often requires more context due to the need to save the form’s state when it’s maximized or minimized.

Why Explicit Handling is Necessary

• Restoring State: Directly binding to size would not account for possible changes in the form’s state (e.g., whether it is minimized or maximized).
• Usage of Additional Properties: When a form is not in its normal state, the size needs to be retrieved from the RestoreBounds, which does not get updated through simple binding.

The Solution: Implementing a RestorableForm Class

To effectively work around this limitation, a subclass of Form can be created—let’s call it RestorableForm. This class will handle the application’s window size and state seamlessly, implementing the necessary overrides and bindings.

Step-by-Step Implementation

1. Inherit from the RestorableForm instead of the standard Form.

2. Add a Binding to WindowRestoreState.

   • This binding will capture and save the window’s position and state.

3. Invoke Settings Save on Application Close.

   • Call Properties.Settings.Default.Save() when closing the window to ensure all settings are stored.

Example Code

Here’s a concise implementation of the RestorableForm class:

using System;
using System.Windows.Forms;
using System.ComponentModel;
using System.Drawing;

namespace Utilities
{
    public class RestorableForm : Form, INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        private WindowRestoreStateInfo windowRestoreState;

        [Browsable(false)] 
        [SettingsBindable(true)] 
        public WindowRestoreStateInfo WindowRestoreState
        {
            get { return windowRestoreState; }
            set
            {
                windowRestoreState = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("WindowRestoreState"));
            }
        }

        protected override void OnClosing(CancelEventArgs e)
        {
            WindowRestoreState = new WindowRestoreStateInfo
            {
                Bounds = WindowState == FormWindowState.Normal ? Bounds : RestoreBounds,
                WindowState = WindowState
            };
            base.OnClosing(e);
        }

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
            if (WindowRestoreState != null)
            {
                Bounds = ConstrainToScreen(WindowRestoreState.Bounds);
                WindowState = WindowRestoreState.WindowState;
            }
        }

        private Rectangle ConstrainToScreen(Rectangle bounds)
        {
            // Constrain logic here...
        }

        public class WindowRestoreStateInfo
        {
            public Rectangle Bounds { get; set; }
            public FormWindowState WindowState { get; set; }
        }
    }
}

Key Points in the Code

• Property Handling: The WindowRestoreState property captures both position and state.
• Loading and Saving States: The overridden methods take care of restoring position and handling window state upon closing.
• Screen Constraints: The ConstrainToScreen method ensures that the form fits within the display, which is critical when restoring its size and position.

References for Further Learning

For more information on the components used in the RestorableForm class, you might find these links valuable:

• SettingsBindableAttribute
• INotifyPropertyChanged

Conclusion

Binding the Size of a Windows Form directly to ApplicationSettings presents challenges, but with the RestorableForm class, you can ensure that your application remembers its state across sessions. By implementing explicit state handling, you empower users to have a more consistent and personalized experience when using your application.

With this approach, you can effectively manage your Windows Forms size and state and create user-friendly applications that feel responsive and intuitive.