WPF window 位于 top/left 下，任务栏处于最大化状态

Question

我正在开发 WPF 应用程序，我遇到了一个问题，即当 WindowStyle=None 和 WindowState = WindowState.Maximized 应用程序位于任务栏顶部或左侧时。

当任务栏放在底部或右侧时一切正常。

我知道 window 的 Left 和 Top 属性，但在 Maximized 状态下它们被忽略了。

还有 Microsoft.Windows.Shell.WindowСhrome 可以拖动、双击最大化和恢复、捕捉和取消捕捉。（需要添加为dll引用）

我想实现我的应用程序不会隐藏或进入任务栏，并且可以正常工作 WindowСhrome 提供的行为。

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)
        {

        }

    }
}

问题截图如下：

Answer 1

更好的方法是使用 User32.dll
中的几个本机方法（摘自 this blog post）

工作原理：

为 Window 消息 (WindowProc) 添加挂钩，以便您可以从系统接收 window 消息。

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.
您将收到 (0x24 = WM_GETMINMAXINFO) window 大小即将更改的信号

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.
您获取 window 当前所在的监视器 (MonitorFromWindow) 并更新边界。

An application can override the defaults by setting the members of this structure.
系统会处理剩下的事情。

因此，无论如何调整 Window 的大小（拖动到屏幕顶部、windows 键 + 箭头、最大化按钮等），它都将保持在您的工作区边界内。

本地方法和类型：
_{（只需将此 class 复制到您的项目中）}

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);
        }
    }
}

你的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();
    }
}

WPF window 位于 top/left 下，任务栏处于最大化状态

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

c#

wpf

xaml

maximize-window

window-chrome