Properly maximizing WPF window with WindowStyle=None

Properly Maximizing WPF Window with WindowStyle=None

Learn how to achieve a true maximized state for WPF windows with WindowStyle set to None, avoiding common issues like overlapping the taskbar and incorrect sizing.

WPF applications often require custom window chrome for a unique look and feel. This is typically achieved by setting WindowStyle="None" and AllowsTransparency="True". However, this approach introduces a challenge: the default maximize behavior no longer respects the taskbar, causing the window to expand beyond the screen's work area. This article provides a robust solution to properly maximize such windows, ensuring they fit perfectly within the available screen space, just like standard windows.

The Problem with WindowStyle=None and Maximization

When you set WindowStyle="None" in WPF, you're essentially telling the operating system to treat your window as a borderless, chromeless canvas. While this gives you complete control over the window's appearance, it also means you lose the default behaviors associated with standard windows, including how they interact with the taskbar during maximization. A standard maximized window automatically resizes to fill the screen's 'work area' (the screen area excluding the taskbar). A WindowStyle="None" window, when simply maximized by setting WindowState="Maximized", will expand to the full screen dimensions, often obscuring the taskbar and potentially other system UI elements.

flowchart TD
    A[User Clicks Maximize] --> B{WindowStyle = None?}
    B -- Yes --> C[Window.WindowState = Maximized]
    C --> D[Window covers Taskbar & System UI]
    B -- No --> E[OS Handles Maximization]
    E --> F[Window respects Taskbar & Work Area]

Default maximization behavior with and without WindowStyle=None

Implementing a Custom Maximization Logic

To correctly maximize a WindowStyle="None" window, we need to manually calculate the available screen work area and adjust the window's Width, Height, Left, and Top properties accordingly. This involves using the System.Windows.Forms.Screen class, which provides information about display devices, including the work area. We'll also need to handle the WindowState property to toggle between normal and maximized states.

using System.Windows;
using System.Windows.Forms;

namespace MyWPFApp
{
    public partial class MainWindow : Window
    {
        private WindowState _lastWindowState;

        public MainWindow()
        {
            InitializeComponent();
            _lastWindowState = WindowState.Normal;
        }

        private void MaximizeRestoreWindow()
        {
            if (WindowState == WindowState.Normal || WindowState == WindowState.Minimized)
            {
                // Get the screen the window is currently on
                Screen currentScreen = Screen.FromHandle(new System.Windows.Interop.WindowInteropHelper(this).Handle);

                // Set window properties to match the screen's working area
                this.MaxHeight = currentScreen.WorkingArea.Height;
                this.MaxWidth = currentScreen.WorkingArea.Width;
                this.Left = currentScreen.WorkingArea.Left;
                this.Top = currentScreen.WorkingArea.Top;
                this.Width = currentScreen.WorkingArea.Width;
                this.Height = currentScreen.WorkingArea.Height;

                WindowState = WindowState.Maximized;
                _lastWindowState = WindowState.Maximized;
            }
            else
            {
                // Restore to normal state (you might want to store previous normal size/position)
                WindowState = WindowState.Normal;
                _lastWindowState = WindowState.Normal;
                // Reset MaxHeight/MaxWidth if you want to allow resizing beyond screen bounds in normal state
                this.MaxHeight = double.PositiveInfinity;
                this.MaxWidth = double.PositiveInfinity;
            }
        }

        // Example usage (e.g., from a button click event)
        private void MaximizeButton_Click(object sender, RoutedEventArgs e)
        {
            MaximizeRestoreWindow();
        }
    }
}

C# code for custom maximize/restore logic in a WPF window.

Handling Multiple Monitors and DPI Scaling

The provided solution correctly identifies the screen the window is currently on using Screen.FromHandle. This is crucial for multi-monitor setups, as it ensures the window maximizes to the work area of the specific monitor it resides on. For DPI scaling, WPF's layout system generally handles scaling automatically. However, when manually setting Left, Top, Width, and Height based on System.Windows.Forms.Screen properties, it's important to be aware that System.Windows.Forms operates in physical pixels, while WPF operates in device-independent units (DIPs). WPF automatically converts these values, but if you encounter subtle sizing issues on high-DPI displays, you might need to explicitly account for the DPI scale factor using PresentationSource.FromVisual(this).CompositionTarget.TransformFromDevice to convert between physical pixels and DIPs.

1. Add System.Windows.Forms Reference

In your WPF project, right-click 'References' -> 'Add Reference...' -> 'Assemblies' -> 'Framework' and select System.Windows.Forms.

2. Modify XAML for WindowStyle=None

Set WindowStyle="None" and AllowsTransparency="True" on your Window element in XAML. You'll also need to design your custom title bar with maximize/restore buttons.

3. Implement Maximize/Restore Logic

Copy the C# code provided above into your window's code-behind file. Hook up the MaximizeRestoreWindow() method to your custom maximize button's click event.

4. Consider Dragging and Resizing

For a full custom chrome experience, you'll also need to implement custom dragging (by handling MouseDown on your title bar) and resizing (by handling MouseMove on window edges/corners). These are separate concerns but often go hand-in-hand with WindowStyle=None.