WPF window is under top/left placed taskbar in Maximized state

Question

I am working on WPF application and I faced problem that when WindowStyle=Noneand WindowState = WindowState.Maximized the application goes under top or left placed taskbar.

When taskbar is placed bottom or right all works normal.

I know about Left and Top properties of window, but they are ignored in Maximized state.

Also there is Microsoft.Windows.Shell.WindowСhrome that gives ability to drag, double click to maximize and restore, snap and unsnap. (it is need to be added as dll reference)

I want to achieve that my application don't hide or go under taskbar and works correctly with behavior that WindowСhrome provide.

MainWindow.xaml

    <Window x:Class="WpfAppTestFullScreen.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        mc:Ignorable="d"
        WindowStyle="None"
        Title="MainWindow" Height="350" Width="525"
        Left="100" Top="100">
    <WindowChrome.WindowChrome>
        <WindowChrome CaptionHeight="{Binding ActualHeight,ElementName=topBarGrid}"/>
    </WindowChrome.WindowChrome>
    <Grid x:Name="mainGrid" Background="Yellow">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"></RowDefinition>
            <RowDefinition Height="*"></RowDefinition>
        </Grid.RowDefinitions>
        <Grid x:Name="topBarGrid" Grid.Row="0" >
            <Border BorderBrush="Black" BorderThickness="1" >
                <DockPanel x:Name="panelForWindowControls"
                           VerticalAlignment="Stretch"
                           DockPanel.Dock="Right"
                           LastChildFill="False"
                           >
                    <Button Name="buttonExit"
                            Width="43" Height="28"
                            Margin="0" Click="buttonExit_Click"
                            DockPanel.Dock="Right" Content="x"
                            WindowChrome.IsHitTestVisibleInChrome="True"
                     />
                    <Button Name="buttonMax"
                            Width="43" Height="28"
                            Margin="0" Click="buttonMax_Click"
                            DockPanel.Dock="Right" Content="[]"
                            WindowChrome.IsHitTestVisibleInChrome="True"
                            />

                    <Button Name="buttonMin" 
                            Width="43" Height="28"
                            Margin="0" Click="buttonMin_Click"
                            DockPanel.Dock="Right" Content="_"
                            WindowChrome.IsHitTestVisibleInChrome="True"
                            />
                </DockPanel>
            </Border>
        </Grid>
        <Grid x:Name="bodyGrid"  Grid.Row="1">
            <Button Content="FullScreen" x:Name="FullScreenButton" 
                Height="50" Width="200" 
                HorizontalAlignment="Center"  VerticalAlignment="Center"
                Click="FullScreenButton_Click" />
        </Grid>
    </Grid>
</Window>

MainWindow.xaml.cs

    using System.Windows;


namespace WpfAppTestFullScreen
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            MaxHeight = SystemParameters.MaximizedPrimaryScreenHeight;
            MaxWidth = SystemParameters.MaximizedPrimaryScreenWidth;
        }


        private void FullScreenButton_Click(object sender, RoutedEventArgs e)
        {
            if (WindowState == WindowState.Maximized)
            {
                WindowState = WindowState.Normal;
            }
            else
            {
                WindowState = WindowState.Maximized;
            }
        }

        private void buttonMax_Click(object sender, RoutedEventArgs e)
        {
            if (WindowState == WindowState.Maximized)
            {
                WindowState = WindowState.Normal;
            }
            else
            {
                WindowState = WindowState.Maximized;
            }
        }

        private void buttonMin_Click(object sender, RoutedEventArgs e)
        {
            WindowState = (WindowState == WindowState.Minimized) ? WindowState.Normal : WindowState.Minimized;
        }
        private void buttonExit_Click(object sender, RoutedEventArgs e)
        {

        }

    }
}

Here is screenshot of problem:

Answer 1

A better approach would be to use a couple of native methods from the User32.dll
(taken from this blog post)

How it works:

• Add a hook for WindowMessages (WindowProc) so you can receive window messages from the system.

  Every window has an associated window procedure — a function that processes all messages sent or posted to all windows of the class. All aspects of a window's appearance and behavior depend on the window procedure's response to these messages.

• You will get signaled (0x24 = WM_GETMINMAXINFO) that the window size is about to be changed

  Sent to a window when the size or position of the window is about to change. An application can use this message to override the window's default maximized size and position, or its default minimum or maximum tracking size.

• You get the monitor that the window is currently located on (MonitorFromWindow) and update the bounds.

  An application can override the defaults by setting the members of this structure.

• The system will take care of the rest.

So, no matter how the Window is resized (drag to top of screen, windows key + arrows, maximize button, etc.) it will stay within the boundary of your workarea.

Native Methods and Types:
_{(just copy this class into your project)}

public static class Native
{

    [DllImport("user32")]
    internal static extern bool GetMonitorInfo(IntPtr hMonitor, MONITORINFO lpmi);

    [DllImport("user32")]
    internal static extern IntPtr MonitorFromWindow(IntPtr handle, int flags);

    public static void WmGetMinMaxInfo(IntPtr hwnd, IntPtr lParam, int minWidth, int minHeight)
    {
        MINMAXINFO mmi = (MINMAXINFO)Marshal.PtrToStructure(lParam, typeof(MINMAXINFO));

        // Adjust the maximized size and position to fit the work area of the correct monitor
        int MONITOR_DEFAULTTONEAREST = 0x00000002;
        IntPtr monitor = Native.MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);

        if (monitor != IntPtr.Zero)
        {

            Native.MONITORINFO monitorInfo = new Native.MONITORINFO();
            Native.GetMonitorInfo(monitor, monitorInfo);
            Native.RECT rcWorkArea = monitorInfo.rcWork;
            Native.RECT rcMonitorArea = monitorInfo.rcMonitor;
            mmi.ptMaxPosition.x = Math.Abs(rcWorkArea.left - rcMonitorArea.left);
            mmi.ptMaxPosition.y = Math.Abs(rcWorkArea.top - rcMonitorArea.top);
            mmi.ptMaxSize.x = Math.Abs(rcWorkArea.right - rcWorkArea.left);
            mmi.ptMaxSize.y = Math.Abs(rcWorkArea.bottom - rcWorkArea.top);
            mmi.ptMinTrackSize.x = minWidth;
            mmi.ptMinTrackSize.y = minHeight;
        }

        Marshal.StructureToPtr(mmi, lParam, true);
    }


    /// <summary>
    /// POINT aka POINTAPI
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct POINT
    {
        /// <summary>
        /// x coordinate of point.
        /// </summary>
        public int x;
        /// <summary>
        /// y coordinate of point.
        /// </summary>
        public int y;

        /// <summary>
        /// Construct a point of coordinates (x,y).
        /// </summary>
        public POINT(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct MINMAXINFO
    {
        public POINT ptReserved;
        public POINT ptMaxSize;
        public POINT ptMaxPosition;
        public POINT ptMinTrackSize;
        public POINT ptMaxTrackSize;
    };

    /// <summary>
    /// </summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
    public class MONITORINFO
    {
        /// <summary>
        /// </summary>            
        public int cbSize = Marshal.SizeOf(typeof(MONITORINFO));

        /// <summary>
        /// </summary>            
        public RECT rcMonitor = new RECT();

        /// <summary>
        /// </summary>            
        public RECT rcWork = new RECT();

        /// <summary>
        /// </summary>            
        public int dwFlags = 0;
    }


    /// <summary> Win32 </summary>
    [StructLayout(LayoutKind.Sequential, Pack = 0)]
    public struct RECT
    {
        /// <summary> Win32 </summary>
        public int left;
        /// <summary> Win32 </summary>
        public int top;
        /// <summary> Win32 </summary>
        public int right;
        /// <summary> Win32 </summary>
        public int bottom;

        /// <summary> Win32 </summary>
        public static readonly RECT Empty = new RECT();

        /// <summary> Win32 </summary>
        public int Width
        {
            get { return Math.Abs(right - left); }  // Abs needed for BIDI OS
        }
        /// <summary> Win32 </summary>
        public int Height
        {
            get { return bottom - top; }
        }

        /// <summary> Win32 </summary>
        public RECT(int left, int top, int right, int bottom)
        {
            this.left = left;
            this.top = top;
            this.right = right;
            this.bottom = bottom;
        }


        /// <summary> Win32 </summary>
        public RECT(RECT rcSrc)
        {
            this.left = rcSrc.left;
            this.top = rcSrc.top;
            this.right = rcSrc.right;
            this.bottom = rcSrc.bottom;
        }

        /// <summary> Win32 </summary>
        public bool IsEmpty
        {
            get
            {
                // BUGBUG : On Bidi OS (hebrew arabic) left > right
                return left >= right || top >= bottom;
            }
        }
        /// <summary> Return a user friendly representation of this struct </summary>
        public override string ToString()
        {
            if (this == RECT.Empty) { return "RECT {Empty}"; }
            return "RECT { left : " + left + " / top : " + top + " / right : " + right + " / bottom : " + bottom + " }";
        }

        /// <summary> Determine if 2 RECT are equal (deep compare) </summary>
        public override bool Equals(object obj)
        {
            if (!(obj is Rect)) { return false; }
            return (this == (RECT)obj);
        }

        /// <summary>Return the HashCode for this struct (not garanteed to be unique)</summary>
        public override int GetHashCode()
        {
            return left.GetHashCode() + top.GetHashCode() + right.GetHashCode() + bottom.GetHashCode();
        }


        /// <summary> Determine if 2 RECT are equal (deep compare)</summary>
        public static bool operator ==(RECT rect1, RECT rect2)
        {
            return (rect1.left == rect2.left && rect1.top == rect2.top && rect1.right == rect2.right && rect1.bottom == rect2.bottom);
        }

        /// <summary> Determine if 2 RECT are different(deep compare)</summary>
        public static bool operator !=(RECT rect1, RECT rect2)
        {
            return !(rect1 == rect2);
        }
    }
}

Your Window:

public partial class MainWindow : Window
{
    public MainWindow()
    {
        SourceInitialized += Window_SourceInitialized;

        InitializeComponent();
    }

    void Window_SourceInitialized(object sender, EventArgs e)
    {
        IntPtr handle = new WindowInteropHelper(this).Handle;
        HwndSource.FromHwnd(handle)?.AddHook(WindowProc);
    }

    private IntPtr WindowProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
    {
        switch (msg)
        {
            case 0x0024:
                Native.WmGetMinMaxInfo(hwnd, lParam, (int)MinWidth, (int)MinHeight);
                handled = true;
                break;
        }

        return (IntPtr)0;
    }

    private void FullScreenButton_Click(object sender, RoutedEventArgs e)
    {
        WindowState = WindowState == WindowState.Maximized ? WindowState.Normal : WindowState.Maximized;
    }

    private void buttonMax_Click(object sender, RoutedEventArgs e)
    {
        WindowState = WindowState == WindowState.Maximized ? WindowState.Normal : WindowState.Maximized;
    }

    private void buttonMin_Click(object sender, RoutedEventArgs e)
    {
        WindowState = WindowState == WindowState.Minimized ? WindowState.Normal : WindowState.Minimized;
    }

    private void buttonExit_Click(object sender, RoutedEventArgs e)
    {
        Close();
    }
}