如何在保持其大小的同时自动将 WPF 窗口捕捉到屏幕边缘？

How to automatically snap a WPF window to an edge of the screen while retaining its size?

提问by B.K.

As the application starts, I'd like my WPF window to automatically snap to the right edge of the screen. Is there a way to do that? I also want to be able to retain its dimensions. So, unlike the snapping behavior that happens when you drag a window to the edge of the screen, causing the window to resize to either a portion of the screen or full screen, I want my window to simply snap to the edge at a certain location by default or if dragged by the user to a specific location afterwards, without resizing. I still want to retain the ability of the user to drag the window away from the edge.

当应用程序启动时，我希望我的 WPF 窗口自动对齐到屏幕的右边缘。有没有办法做到这一点？我也希望能够保留其尺寸。因此，与将窗口拖动到屏幕边缘时发生的对齐行为不同，导致窗口调整为屏幕的一部分或全屏，我希望我的窗口在某个位置简单地对齐到边缘默认情况下，或者如果用户随后将其拖动到特定位置，而无需调整大小。我仍然希望保留用户将窗口拖离边缘的能力。

Is there anything like that already implemented or would I have to create my own behavior schema? I tried numerous search keyword combinations, but couldn't find anything similar to what I'm doing. Some of the searches included disabling snapping behavior or providing snapping behavior, but nothing in the way I described above.

有没有类似的东西已经实现了，还是我必须创建自己的行为模式？我尝试了许多搜索关键字组合，但找不到与我正在做的事情相似的任何内容。一些搜索包括禁用捕捉行为或提供捕捉行为，但没有我上面描述的方式。

EDIT:

编辑：

I haven't been able to find a ready solution, so I wrote my own. This solution is based on BenVlodgi's suggestions, so I thank him for helping me out. This is a very rough implementation and still requires a lot of polishing and better code techniques, but it works and it's a good base for anyone wanting to try this. It's incredibly simple and works very well with WPF. The only limitation of this implementation is that I haven't tried getting it to work with two screens yet, but it's incredibly simple (I'm just not going to have time for it and I don't need that functionality at this point). So, here's the code and I hope that it helps someone out there:

我一直无法找到现成的解决方案，所以我自己写了一个。这个解决方案是基于 BenVlodgi 的建议，所以我感谢他帮助我。这是一个非常粗略的实现，仍然需要大量的完善和更好的代码技术，但它有效，对于任何想要尝试的人来说，这是一个很好的基础。它非常简单，并且与 WPF 配合得很好。这个实现的唯一限制是我还没有尝试让它在两个屏幕上工作，但它非常简单（我只是没有时间去做，我现在不需要那个功能） . 所以，这是代码，我希望它可以帮助那里的人：

public partial class MainWindow : Window
{
    // Get the working area of the screen.  It excludes any dockings or toolbars, which
    // is exactly what we want.
    private System.Drawing.Rectangle screen = 
                                 System.Windows.Forms.Screen.PrimaryScreen.WorkingArea;

    // This will be the flag for the automatic positioning.
    private bool dragging = false;

    //  The usual initialization routine
    public MainWindow()
    {
        InitializeComponent();
    }

    // Wait until window is lodaded, but prior to being rendered to set position.  This 
    // is done because prior to being loaded you'll get NaN for this.Height and 0 for
    // this.ActualHeight.
    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
        // Sets the initial position.
        SetInitialWindowPosition();
        // Sets the monitoring timer loop.
        InitializeWindowPositionMonitoring();
    }

    // Allows the window to be dragged where the are no other controls present.
    // PreviewMouseButton could be used, but then you have to do more work to ensure that if
    // you're pressing down on a button, it executes its routine if dragging was not performed.
    private void Window_MouseDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
    {
        // Set the dragging flag to true, so that position would not be reset automatically.
        if (e.ChangedButton == System.Windows.Input.MouseButton.Left)
        {
            dragging = true;
            this.DragMove();
        }
    }

    // Similar to MouseDown.  We're setting dragging flag to false to allow automatic 
    // positioning.
    private void Window_MouseUp(object sender, System.Windows.Input.MouseButtonEventArgs e)
    {
        if (e.ChangedButton == System.Windows.Input.MouseButton.Left)
        {
            dragging = false;
        }
    }

    // Sets the initial position of the window.  I made mine static for now, but later it can
    // be modified to be whatever the user chooses in the settings.
    private void SetInitialWindowPosition()
    {
        this.Left = screen.Width - this.Width;
        this.Top = screen.Height / 2 - this.Height / 2;
    }

    // Setup the monitoring routine that automatically positions the window based on its location
    // relative to the working area.
    private void InitializeWindowPositionMonitoring()
    {
        var timer = new System.Windows.Threading.DispatcherTimer();
        timer.Tick += delegate
        {
            // Check if window is being dragged (assuming that mouse down on any portion of the
            // window is connected to dragging).  This is a fairly safe assumption and held
            // true thus far.  Even if you're not performing any dragging, then the position
            // doesn't change and nothing gets reset.  You can add an extra check to see if
            // position has changed, but there is no significant performance gain.
            // Correct me if I'm wrong, but this is just O(n) execution, where n is the number of
            // ticks the mouse has been held down on that window.
            if (!dragging)
            {
                // Checking the left side of the window.
                if (this.Left > screen.Width - this.Width)
                {
                    this.Left = screen.Width - this.Width;
                }
                else if (this.Left < 0)
                {
                    this.Left = 0;
                }

                // Checking the top of the window.
                if (this.Top > screen.Height - this.Height)
                {
                    this.Top = screen.Height - this.Height;
                }
                else if (this.Top < 0)
                {
                    this.Top = 0;
                }
            }
        };

        // Adjust this based on performance and preference.  I set mine to 10 milliseconds.
        timer.Interval = new TimeSpan(0, 0, 0, 0, 10);
        timer.Start();
    }
}

Make sure that your window has the following:

确保您的窗口具有以下内容：

MouseDown="Window_MouseDown"
MouseUp="Window_MouseUp"
WindowStartupLocation="Manual" 
Loaded="Window_Loaded"

Also, this doesn't work well with Windows native components of the window, such as the top bar, so I disable the style and create my own (which is actually good for me, since I don't want the windows style for this):

此外，这不适用于窗口的 Windows 本机组件，例如顶部栏，所以我禁用了样式并创建了我自己的样式（这对我来说实际上很好，因为我不想要 Windows 样式） )：

WindowStyle="None"

采纳答案by BenVlodgi

There is no API calls you can make (as far as I've seen) to use the Windows snapping features, however you could just get the System.Windows.Forms.Screen.PrimaryScreen.WorkingAreaof the screen and set your Top, Left, Heightand WidthProperties of your Windowaccordingly.

有没有API调用就可以使（据我见过的）使用Windows捕捉功能，但是你可以只让System.Windows.Forms.Screen.PrimaryScreen.WorkingArea屏幕和设置您Top，Left，Height和Width你的属性Window相应。

Edit: The above suggestion does require Forms, which you probably don't want. I believe the WPF equivalent is System.Windows.SystemParameters.WorkArea

编辑：上述建议确实需要您可能不想要的表格。我相信 WPF 等价物是System.Windows.SystemParameters.WorkArea

回答by Torsten Huber

I don't like the polling approach, but it's been excessively difficult to find a better solution that is still simple in WPF, so I'm gonna post my own.

我不喜欢轮询方法，但是在 WPF 中找到一个仍然简单的更好的解决方案太难了，所以我要发布我自己的。

The solution that I found is actually quite simple, in that it reimplements the behaviour of the DragMove()method of the window, which gives you the option to change the window position while it's being dragged. The following code reimplements DragMove()by storing the distance between the top left corner of the window and the mouse cursor.

我发现的解决方案实际上非常简单，因为它重新实现了DragMove()窗口方法的行为，这使您可以选择在拖动窗口时更改窗口位置。以下代码DragMove()通过存储窗口左上角和鼠标光标之间的距离来重新实现。

public partial class MainWindow : Window
{
    // this is the offset of the mouse cursor from the top left corner of the window
    private Point offset = new Point();

    public MainWindow()
    {
        InitializeComponent();
    }

    private void OnMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        Point cursorPos = PointToScreen(Mouse.GetPosition(this));
        Point windowPos = new Point(this.Left, this.Top);
        offset = (Point)(cursorPos - windowPos);

        // capturing the mouse here will redirect all events to this window, even if
        // the mouse cursor should leave the window area
        Mouse.Capture(this, CaptureMode.Element);
    }

    private void OnMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
    {
        Mouse.Capture(null);
    }

    private void OnMouseMove(object sender, MouseEventArgs e)
    {
        if (Mouse.Captured == this && Mouse.LeftButton == MouseButtonState.Pressed)
        {
            Point cursorPos = PointToScreen(Mouse.GetPosition(this));
            double newLeft = cursorPos.X - offset.X;
            double newTop = cursorPos.Y - offset.Y;

            // here you can change the window position and implement
            // the snapping behaviour that you need

            this.Left = newLeft;
            this.Top = newTop;
        }
    }
}

Now you could implement the snapping / sticky window behaviour like this: The window will stick to the edge of the screen if it's within a range of 25 pixels (plus or minus).

现在您可以像这样实现捕捉/粘性窗口行为：如果窗口在 25 像素（正负）的范围内，它将粘在屏幕的边缘。

int snappingMargin = 25;

if (Math.Abs(SystemParameters.WorkArea.Left - newLeft) < snappingMargin)
    newLeft = SystemParameters.WorkArea.Left;
else if (Math.Abs(newLeft + this.ActualWidth - SystemParameters.WorkArea.Left - SystemParameters.WorkArea.Width) < snappingMargin)
    newLeft = SystemParameters.WorkArea.Left + SystemParameters.WorkArea.Width - this.ActualWidth;

if (Math.Abs(SystemParameters.WorkArea.Top - newTop) < snappingMargin)
    newTop = SystemParameters.WorkArea.Top;
else if (Math.Abs(newTop + this.ActualHeight - SystemParameters.WorkArea.Top - SystemParameters.WorkArea.Height) < snappingMargin)
    newTop = SystemParameters.WorkArea.Top + SystemParameters.WorkArea.Height - this.ActualHeight;

The downside of this approach is that the snapping will not work, if the window is being dragged on the title bar, because that doesn't fire the OnMouseLeftButtonDownevent (which I don't need, because my window is borderless). Maybe it will still help someone.

这种方法的缺点是，如果在标题栏上拖动窗口，则捕捉将不起作用，因为这不会触发OnMouseLeftButtonDown事件（我不需要，因为我的窗口是无边框的）。也许它仍然会帮助某人。