Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

wpf 记录窗体位置,下次打开是还是在原来位置显示,但是dpi设置150%时,代开位置就不对了

  1. User

    wpf 记录窗体位置,下次打开是还是在原来位置显示,但是dpi设置150%时,代开位置就不对了

  2. Assistant

    在 WPF 中,如果你希望保存窗体的位置并在下次打开时保持该位置,你需要考虑 DPI 设置对窗口位置的影响。高 DPI 设置(如 150%)会导致你保存的屏幕坐标和实际显示的位置不匹配。为了解决这个问题,你可以按以下步骤进行:

    1. 保存窗口位置:在窗口关闭时保存其位置。可以使用 Window.Location 属性保存位置。

    2. 转换 DPI:当你下次打开窗口时,你需要根据当前的 DPI 设置转换保存的位置。使用屏幕的 DPI 信息来进行缩放。

    以下是一个简单的示例代码,展示如何保存和恢复窗口位置,并考虑 DPI 的影响:

    using System;
    using System.Drawing;
    using System.Windows;
    using System.Windows.Forms; // 需要添加对System.Windows.Forms.dll的引用,使用 DPI 信息
    
    namespace WpfApp
    {
        public partial class MainWindow : Window
        {
            public MainWindow()
            {
                InitializeComponent();
                this.Loaded += MainWindow_Loaded;
                this.Closing += MainWindow_Closing;
            }
    
            private void MainWindow_Loaded(object sender, RoutedEventArgs e)
            {
                // 恢复窗口位置
                double savedX = Properties.Settings.Default.WindowPositionX;
                double savedY = Properties.Settings.Default.WindowPositionY;
    
                if (savedX != 0 || savedY != 0)
                {
                    // 计算 DPI 缩放比例
                    float dpiX = Graphics.FromHwnd(IntPtr.Zero).DpiX;
                    double scalingFactor = dpiX / 96.0; // 假设96是100%缩放的DPI
    
                    this.Left = savedX * scalingFactor;
                    this.Top = savedY * scalingFactor;
                }
            }
    
            private void MainWindow_Closing(object sender, System.ComponentModel.CancelEventArgs e)
            {
                // 保存窗口位置
                Properties.Settings.Default.WindowPositionX = this.Left;
                Properties.Settings.Default.WindowPositionY = this.Top;
                Properties.Settings.Default.Save();
            }
        }
    }
    

    在上面的代码中,我们在窗口关闭时保存位置,并在窗口加载时恢复该位置。需要注意的是,我们使用 Graphics.FromHwnd(IntPtr.Zero).DpiX 来获取当前的 DPI 设置,并使用它来计算出一个缩放因子,以确保窗口在高 DPI 下的位置正确显示。

    此外,不要忘记在 Properties.Settings 中添加相应的设置(WindowPositionX 和 WindowPositionY),以确保能够保存和加载这些值。

    希望这些信息能帮助到你!

  3. User

    假设96是100%缩放的DPI 是什么意思, 所有都是96吗

  4. Assistant

    在计算机图形和屏幕分辨率中,DPI(每英寸点数)是用来衡量屏幕分辨率的一个标准,尤其是在处理图形和文本时。DPI 值越高,显示的内容就越细腻、越清晰。一般情况下,DPI 值可以影响操作系统和应用程序在不同分辨率下的显示效果。

    96 DPI 和 100% 缩放

    • 96 DPI:这是 Windows 操作系统上默认的 DPI 设置,对于 100% 的缩放比例。换句话说,96 DPI 意味着每英寸显示 96 个像素,因此这是标准的计算机显示设置。

    • 更高的 DPI 值:当操作系统或用户设置更高的 DPI(如 120 DPI, 144 DPI 或 150 DPI 等)时,用户界面元素(如窗口、按钮、文本等)会被放大,以使其在高分辨率屏幕上看起来不会太小。此时,DPI 被认为是在不同的缩放比例下的标准。例如:

      • 120 DPI 经常表示 125% 的缩放。
      • 144 DPI 经常表示 150% 的缩放。
      • 192 DPI 经常表示 200% 的缩放。

    小结

    不是说所有显示器的 DPI 都是 96,而是 96 DPI 被用作 100% 缩放的参照标准。在 WPF 应用程序中,当调整 DPI 设置或缩放比例时,需要考虑这一点以确保界面元素正确放大或缩小。因此,当计算屏幕位置时,使用与 96 DPI 相比较的其他 DPI 设置,建议以 96 为基准进行缩放计算。

    实际应用

    在你的代码中:

    • 如果 DPI 为 96,缩放因子为 1(96/96)。
    • 如果 DPI 为 120,缩放因子为 1.25(120/96)。
    • 如果 DPI 为 144,缩放因子为 1.5(144/96)。

    这样,无论用户的 DPI 设置如何,通过相应的缩放因子来调整元素位置,就能够在不同的 DPI 设置下得到一致的体验。

  5. User

    protected override void WndProc(ref Message m) { try {if (m.Msg == WM_MOVING) { var rc = (WinRect)Marshal.PtrToStructure(m.LParam, typeof(WinRect));

                    // Update MoveSum
                    m_MoveSum.X += rc.Left - m_MovePrevPos.X;
                    m_MoveSum.Y += rc.Top - m_MovePrevPos.Y;
    
                    // Convert WinRect into edge list
                    var moveRect = rc.ToRectangle();
                    moveRect.Location = m_MoveSum;
                    // Move other windows
                    if (Global.SysConfig.FollowMainMove && m_OriginalForm.FormType == typeof(MainForm))
                    {
                        var frms = Forms.Where(frm => frm != m_OriginalForm && frm.FormType != typeof(OrderQueuePopupForm));
                        foreach (var lockedWindows in frms)
                        {
                            var otherRect = new Rect(lockedWindows.Bounds.X * Global.dpixRatio, lockedWindows.Bounds.Y * Global.dpiyRatio, Math.Round(lockedWindows.Bounds.Width * Global.dpixRatio, MidpointRounding.AwayFromZero), Math.Round(lockedWindows.Bounds.Height * Global.dpiyRatio, MidpointRounding.AwayFromZero));
                            otherRect.Offset(moveRect.Location.X - m_MovePrevPos.X, moveRect.Location.Y - m_MovePrevPos.Y);
                            lockedWindows.SetBounds(otherRect.X, otherRect.Y, otherRect.Width, otherRect.Height);
                            if (moveone)
                            {
                                lockedWindows.Activate();
                            }
                        }
                        moveone = false;
                    }跟随移动的窗体 位置会越走越远
    
  6. Assistant

    在您的代码中,您试图跟随主窗体移动其他窗口。但是,由于在计算移动时可能存在不正确的坐标和位置转换,您可能会遇到“位置会越走越远”的问题。以下是一些可能导致此问题的原因以及解决方案:

    可能的原因

    1. 坐标转换不当:您在计算移动过程中的位置时,可能在某些地方未能正确调整 DPI 相关的缩放因子。

    2. 移动累积:每次窗口移动时,您可能会重复计算并累加移动的量,这可能会导致最终偏移的位置越来越远。

    3. 右则和底边的问题:获取窗口边界信息时,可能会包含边框或标题栏的高度,导致计算错误。

    解决方案建议

    您可以尝试下面建议来解决这个问题:

    1. 检查 DPI 缩放:确保在计算和设置窗口位置时使用正确的 DPI 缩放因子。确认 Global.dpixRatio 和 Global.dpiyRatio 都是根据当前显示器 DPI 得出的。

    2. 移动偏移计算:确保计算移动的方式是基于窗口的当前状态,而不是累积的状态。

    3. 避免重复累积:确保 m_MovePrevPos 在窗口移动开始时正确设置,并在每次移动后更新。

    调整代码示例

    下面是一个示例调整,确保窗口位置的移动更加准确:

    protected override void WndProc(ref Message m)
    {
        try
        {
            if (m.Msg == WM_MOVING)
            {
                var rc = (WinRect)Marshal.PtrToStructure(m.LParam, typeof(WinRect));
    
                // Calculate movement delta
                var deltaX = rc.Left - m_MovePrevPos.X;
                var deltaY = rc.Top - m_MovePrevPos.Y;
    
                // Update MoveSum
                m_MoveSum.X += deltaX;
                m_MoveSum.Y += deltaY;
    
                // Convert WinRect into edge list
                var moveRect = rc.ToRectangle();
                moveRect.Location = new Point(m_MoveSum.X, m_MoveSum.Y);
                
                // Move other windows
                if (Global.SysConfig.FollowMainMove && m_OriginalForm.FormType == typeof(MainForm))
                {
                    var frms = Forms.Where(frm => frm != m_OriginalForm && frm.FormType != typeof(OrderQueuePopupForm));
                    foreach (var lockedWindows in frms)
                    {
                        var otherRect = new Rect(
                            lockedWindows.Bounds.X * Global.dpixRatio, 
                            lockedWindows.Bounds.Y * Global.dpiyRatio, 
                            Math.Round(lockedWindows.Bounds.Width * Global.dpixRatio, MidpointRounding.AwayFromZero), 
                            Math.Round(lockedWindows.Bounds.Height * Global.dpiyRatio, MidpointRounding.AwayFromZero));
    
                        // Update the position based on delta movement
                        otherRect.Offset(deltaX, deltaY);
                        lockedWindows.SetBounds(otherRect.X, otherRect.Y, otherRect.Width, otherRect.Height);
    
                        // Activate window if necessary
                        if (moveone)
                        {
                            lockedWindows.Activate();
                        }
                    }
                    moveone = false;
                }
                
                // Update previous position for next move
                m_MovePrevPos.X = rc.Left;
                m_MovePrevPos.Y = rc.Top;
            }
        }
        catch (Exception ex)
        {
            // 处理异常(记录、日志等)
        }
    }
    

    关键点

    • 使用 deltaX 和 deltaY 来计算从上一个位置的变化量。
    • m_MovePrevPos 应在每次移动结束后更新,以便为下次移动提供正确的基准。
    • 确保在通过 SetBounds 设置其他窗口时使用正确的 DPI 缩放。
    • 如果可能,考虑添加一些额外的调试输出,以帮助您观察窗口的实际位置变化,便于识别潜在问题。

    通过这些调整,希望您能够使跟随功能在不同 DPI 设置下工作得更加准确。

  7. User

    还是不行

  8. Assistant

    如果您仍然遇到窗口跟随移动的定位问题,即使已经调整了代码,可能需要进一步检查一些细节和逻辑。以下是您可以考虑的步骤和改进建议:

    分析和改进步骤

    1. DPI 获取和转换: 确保您在获取当前 DPI 值时正确使用了方法。可以使用以下代码片段来安全地获取 DPI 设置:

      using System.Windows.Forms; // Ensure you are using System.Windows.Forms
      
      float dpiX = 96.0f; // Default DPI value
      using (Graphics graphics = Graphics.FromHwnd(IntPtr.Zero)) {
          dpiX = graphics.DpiX; // Get current DPI
      }
      

      这将帮助您确保 dpixRatio 和 dpiyRatio 是从实际的 DPI 获取的。

    2. 计算移动偏移: 请确保您的 deltaX 和 deltaY 是正确计算的,并且在调用 SetBounds 时提供合适的位置。特别是在高 DPI 显示器上,这些值需要正确缩放。

    3. 使用屏幕坐标: 确保移动窗口的位置使用的是屏幕坐标。您可能需要使用 Control 类中的方法将窗口的坐标转换为屏幕坐标。

    4. 检查移动逻辑: 确保您在 WndProc 中处理 WM_MOVING 消息时,避免每次调用都依赖于 m_MovePrevPos。可以尝试以下代码示例:

      protected override void WndProc(ref Message m)
      {
          if (m.Msg == WM_MOVING)
          {
              var rc = (WinRect)Marshal.PtrToStructure(m.LParam, typeof(WinRect));
              var newPosX = rc.Left; // Get new Left coordinate
              var newPosY = rc.Top; // Get new Top coordinate
      
              var deltaX = newPosX - m_MoveSum.X; // Calculate the change in position
              var deltaY = newPosY - m_MoveSum.Y;
      
              // Update m_MoveSum to the new position
              m_MoveSum.X = newPosX;
              m_MoveSum.Y = newPosY;
      
              // Move other windows
              if (Global.SysConfig.FollowMainMove && m_OriginalForm.FormType == typeof(MainForm))
              {
                  var frms = Forms.Where(frm => frm != m_OriginalForm && frm.FormType != typeof(OrderQueuePopupForm));
                  foreach (var lockedWindow in frms)
                  {
                      var otherRect = lockedWindow.Bounds;
      
                      // Here we apply DPI scaling only if necessary
                      var scaledX = otherRect.X * Global.dpixRatio;
                      var scaledY = otherRect.Y * Global.dpiyRatio;
                      var scaledWidth = Math.Round(otherRect.Width * Global.dpixRatio, MidpointRounding.AwayFromZero);
                      var scaledHeight = Math.Round(otherRect.Height * Global.dpiyRatio, MidpointRounding.AwayFromZero);
      
                      // Update other window position by adding delta
                      otherRect = new Rectangle(
                          (int)(scaledX + deltaX),
                          (int)(scaledY + deltaY),
                          (int)scaledWidth,
                          (int)scaledHeight
                      );
      
                      lockedWindow.SetBounds(otherRect.X, otherRect.Y, otherRect.Width, otherRect.Height);
                  }
              }
      
              // Update previous position (where you want to track the last position)
              m_MovePrevPos.X = newPosX;
              m_MovePrevPos.Y = newPosY;
          }
          base.WndProc(ref m); // Don't forget to call base WndProc
      }
      

    更深入的调试

    • 调试信息:在代码中添加调试输出以追踪 m_MovePrevPos、m_MoveSum 和其他相关值,确保它们的更新符合预期。

    • 测试不同的 DPI 设置:在不同的屏幕分辨率和 DPI 设置下测试应用程序,确保显示和位置保持一致。

    • 确保其他状态:在移动窗口之前,请检查所有相关状态和属性,确保没有其他代码片段影响窗口的位置信息。

    其他注意事项

    • 使用 Try-Catch 块捕获潜在的异常情况,可以帮助您追踪问题根源。
    • 尽量避免并发修改同一窗口的状态,确保在一个地方管理位置计算和更新。

    通过反复测试和审视这些点,您应该能够逐步找到并解决问题。请与我们分享更多关于代码的上下文或具体的行为,便于提供更详细的建议。

  9. User

    public void SetBounds(double left, double top, double width, double height) { // SetWindowPos(Handle, IntPtr.Zero, left, top, width, height, 0); MoveWindow(Handle, (int)left, (int)top, (int)width, (int)height, true);

    } [DllImport("user32")] static extern bool SetWindowPos( IntPtr hWnd, IntPtr hWndInsertAfter, int x, int y, int cx, int cy, uint uFlags); [DllImport("user32.dll", EntryPoint = "MoveWindow")] public static extern bool MoveWindow(IntPtr hWnd, int X, int Y, int nWidth, int nHeight, bool bRepaint);

  10. Assistant

    在您提供的 SetBounds 方法中,您通过 MoveWindow 函数修改窗口的位置和大小,以及通过 SetWindowPos 来调整窗口的位置,确保它们符合要求。要确保这一过程在 DPI 设置的影响下正确工作,以下是一些优化和注意事项。

    代码说明

    首先,我们回顾您的 SetBounds 方法:

    public void SetBounds(double left, double top, double width, double height)
    {
        // 使用 MoveWindow 设定窗口的位置和大小
        MoveWindow(Handle, (int)left, (int)top, (int)width, (int)height, true);
    }
    

    使用 DPI 进行正确位置设置

    在计算左(left)、上(top)、宽度(width)和高度(height)时,确保考虑到当前系统的 DPI 设置。您可以使用以下步骤为窗口坐标和尺寸进行 DPI 适配:

    1. 获取当前 DPI: 使用 Graphics 对象获取屏幕的 DPI 设置。

    2. 进行缩放计算: 在调用 MoveWindow 之前,将参数乘以 DPI 缩放因子。

    示例改进

    以下是一个经过修改的 SetBounds 方法示例,其中考虑了 DPI 缩放:

    public void SetBounds(double left, double top, double width, double height)
    {
        // 获取当前屏幕 DPI
        float dpiX;
        using (Graphics graphics = Graphics.FromHwnd(IntPtr.Zero))
        {
            dpiX = graphics.DpiX; // 获取当前 DPI
        }
    
        // 计算缩放因子,假定96是默认DPI(100%缩放)
        float scalingFactor = dpiX / 96.0f;
    
        // 转换为屏幕坐标
        int newX = (int)(left * scalingFactor);
        int newY = (int)(top * scalingFactor);
        int newWidth = (int)(width * scalingFactor);
        int newHeight = (int)(height * scalingFactor);
    
        // 调用 MoveWindow
        MoveWindow(Handle, newX, newY, newWidth, newHeight, true);
    }
    

    关键点

    • 获取 DPI:使用 Graphics.FromHwnd(IntPtr.Zero) 安全地获取当前 DPI 值,而不是假设值。
    • 缩放应用:在设置 left、top、width 和 height 之前应用 DPI 缩放,以确保在高 DPI 环境下它们的正确性。

    调试和错误检查

    确保在程序运行时检查以下几点:

    1. DPI 设置:在多种屏幕和 DPI 设置下进行测试,以验证结果是否一致。
    2. 输出和调试:必要时添加调试输出,以便跟踪各个窗口的实际位置变化。
    3. 异常处理:在调用 MoveWindow 后,检查返回值以确认窗口的位置和大小已成功更新。

    通过这种方式,您应该能在各种 DPI 设置下获得更好的窗口稳定性,并解决“跟随移动的窗体位置会越走越远”的问题。

  11. User

    if (m.Msg == WM_ENTERSIZEMOVE) { // Reset move tracking var currRect = new WinRect(); GetWindowRect(Handle, ref currRect); m_MoveSum = new Point(currRect.Left, currRect.Top); m_MovePrevPos = new Point(currRect.Left, currRect.Top); moveone = true; } else if (m.Msg == WM_MOVING) { var rc = (WinRect)Marshal.PtrToStructure(m.LParam, typeof(WinRect));

    // Update MoveSum
    m_MoveSum.X += rc.Left - m_MovePrevPos.X;
    m_MoveSum.Y += rc.Top - m_MovePrevPos.Y;
    
    // Convert WinRect into edge list
    var moveRect = rc.ToRectangle();
    moveRect.Location = m_MoveSum;
    // Move other windows
    if (Global.SysConfig.FollowMainMove && m_OriginalForm.FormType == typeof(MainForm))
    {
        var frms = Forms.Where(frm => frm != m_OriginalForm && frm.FormType != typeof(OrderQueuePopupForm));
        foreach (var lockedWindows in frms)
        {
            var otherRect = new Rect(lockedWindows.Bounds.X* Global.dpixRatio , lockedWindows.Bounds.Y * Global.dpiyRatio, Math.Round(lockedWindows.Bounds.Width * Global.dpixRatio, MidpointRounding.AwayFromZero), Math.Round(lockedWindows.Bounds.Height * Global.dpiyRatio, MidpointRounding.AwayFromZero));
            otherRect.Offset(moveRect.Location.X - m_MovePrevPos.X, moveRect.Location.Y - m_MovePrevPos.Y);
            lockedWindows.SetBounds(otherRect.X, otherRect.Y, otherRect.Width, otherRect.Height);
            if (moveone)
            {
                lockedWindows.Activate();
            }
        }
        moveone = false;
    }
    
  12. Assistant

    在您的代码中,您使用 WM_ENTERSIZEMOVE 和 WM_MOVING 消息来追踪窗口的位置并在移动时同步其他窗口。这是一个很常见的用法,但在处理 DPI 和偏移量时,注意一些重要细节来确保位置跟随行为是准确的。

    关键问题与解决方案

    1. DPI 缩放及位置计算: 您需要确保 moveRect.Location 的坐标在高 DPI 设置下是经过正确转换的。您可能需要在 moveRect.Location 计算时考虑 DPI。

    2. 移动偏移量的计算: m_MoveSum.X 和 m_MoveSum.Y 的更新逻辑应基于每次 WM_MOVING 消息传递时的相对位置变化。确保 m_MovePrevPos 的更新是基于当前窗口移动的实际位置。

    3. 激活状态: 检查 activate 逻辑的触发时机,确保每个窗口在何时被激活是合适的,特别是在窗口被移动时,避免不必要的激活。

    代码改进示例

    下面是一个改进版本,详细解释了每个部分:

    if (m.Msg == WM_ENTERSIZEMOVE)
    {
        // 重置移动追踪
        var currRect = new WinRect();
        GetWindowRect(Handle, ref currRect);
        m_MoveSum = new Point(currRect.Left, currRect.Top);
        m_MovePrevPos = new Point(currRect.Left, currRect.Top);
        moveone = true;
    }
    else if (m.Msg == WM_MOVING)
    {
        var rc = (WinRect)Marshal.PtrToStructure(m.LParam, typeof(WinRect));
    
        // 计算位置偏移
        var deltaX = rc.Left - m_MovePrevPos.X; // 当前左边界相对于上一个位置的变化
        var deltaY = rc.Top - m_MovePrevPos.Y; // 当前上边界相对于上一个位置的变化
    
        // 更新 MoveSum 以进行记录
        m_MoveSum.X += deltaX;
        m_MoveSum.Y += deltaY;
    
        // 将 WinRect 转换为可移动矩形
        var moveRect = rc.ToRectangle();
        moveRect.Location = new Point(m_MoveSum.X, m_MoveSum.Y);
    
        // 移动其他窗口
        if (Global.SysConfig.FollowMainMove && m_OriginalForm.FormType == typeof(MainForm))
        {
            var frms = Forms.Where(frm => frm != m_OriginalForm && frm.FormType != typeof(OrderQueuePopupForm));
            foreach (var lockedWindows in frms)
            {
                var otherRect = new Rect(
                    lockedWindows.Bounds.X * Global.dpixRatio, 
                    lockedWindows.Bounds.Y * Global.dpiyRatio, 
                    Math.Round(lockedWindows.Bounds.Width * Global.dpixRatio, MidpointRounding.AwayFromZero), 
                    Math.Round(lockedWindows.Bounds.Height * Global.dpiyRatio, MidpointRounding.AwayFromZero)
                );
    
                // 更新位置基于 Deltas
                otherRect.Offset(deltaX, deltaY); // 使用相对变化而非绝对位置变化
    
                // 设置窗口新位置
                lockedWindows.SetBounds(otherRect.X, otherRect.Y, otherRect.Width, otherRect.Height);
    
                // 仅在必要时激活窗口
                if (moveone)
                {
                    lockedWindows.Activate();
                }
            }
            moveone = false; // 执行后避免重复激活
        }
    
        // 更新 m_MovePrevPos 为当前正在移动的位置
        m_MovePrevPos.X = rc.Left; // 更新为当前位置以便于下一次移动时获取上一次位置
        m_MovePrevPos.Y = rc.Top;
    }
    

    代码改进说明

    • 位置获取和偏移计算:

      • 确保 deltaX 和 deltaY 拿到正确的相对移动变化,用于更新其他窗体的位置。
    • DPI 缩放:

      • 在修改 otherRect 的位置时确保乘以 DPI 缩放比。
    • 窗口激活:

      • 确保 moveone 逻辑仅在第一次移动时进行激活,即当窗口首次被移动时生效,随后设为 false,避免多次激活引起的問題。

    结论

    通过上述改进,您可以更好地控制窗口的位置随着主窗口的移动而同步,避免“越走越远”问题。同时,注意 DPI 的影响确保在各种显示设置下的正确响应。如果问题仍然存在,请考虑逐步调试并检查各窗口的边界信息,确保在不同 DPI 环境中的实际表现是一致的。

  13. User

    就往下移动时不跟,其他会跟

  14. Assistant

    如果您的窗口在向下移动时不同步而其他方向都能正确跟随,可能是因为在处理窗口位置时某些计算或条件忽略了向下移动的情况。以下是几个可能的原因及其解决方案,帮助您确保窗口在所有方向(包括向下移动)都能够正确跟随。

    可能的原因

    1. 移动信息的计算:

      • 您的 deltaY 计算可能在向下移动时没有正确更新,导致移动未被正确应用。
    2. 位置更新逻辑:

      • 位置信息在某些情况下未正确设置或更新,可能是条件语句的影响。
    3. DPI 适配:

      • 确保在不同的 DPI 设置下,坐标和大小的计算是正确的,尤其是垂直方向。

    解决方案

    在分析代码后,这里有一些调试和改进的建议:

    1. 调试位移计算

    确保每次处理 WM_MOVING 消息时,您获取并计算出正确的 deltaX 和 deltaY。在使用 deltaY 时,尤其要注意。

    else if (m.Msg == WM_MOVING)
    {
        var rc = (WinRect)Marshal.PtrToStructure(m.LParam, typeof(WinRect));
    
        // 计算位置偏移量
        var deltaX = rc.Left - m_MovePrevPos.X; // 水平移动
        var deltaY = rc.Top - m_MovePrevPos.Y; // 垂直移动
    
        // 更新总移动量
        m_MoveSum.X += deltaX;
        m_MoveSum.Y += deltaY;
    
        // ...
    }
    

    这里您已正确计算了 deltaX 和 deltaY。接下来,确保 m_MovePrevPos 被合适地更新,以便于下一次计算变动量。

    2. 更新位置与调用 SetBounds

    确保更新其他窗口的位置对 deltaY 的应用没有被遗漏:

    foreach (var lockedWindows in frms)
    {
        var otherRect = new Rect(
            lockedWindows.Bounds.X * Global.dpixRatio, 
            lockedWindows.Bounds.Y * Global.dpiyRatio, 
            Math.Round(lockedWindows.Bounds.Width * Global.dpixRatio, MidpointRounding.AwayFromZero), 
            Math.Round(lockedWindows.Bounds.Height * Global.dpiyRatio, MidpointRounding.AwayFromZero)
        );
    
        // 更新位置
        otherRect.Offset(deltaX, deltaY); // 将 deltaX, deltaY 应用于位置更新
        
        // 更新窗口位置
        lockedWindows.SetBounds(otherRect.X, otherRect.Y, otherRect.Width, otherRect.Height);
    }
    

    3. 处理 m_MovePrevPos 更新

    确保在每次移动后更新 m_MovePrevPos 以反映当前窗口的真实位置,保证下次的 deltaY 是有效的:

    // 更新 m_MovePrevPos
    m_MovePrevPos.X = rc.Left; // 更新为当前位置
    m_MovePrevPos.Y = rc.Top;
    

    4. 检查条件逻辑

    如果有任何条件可能导致在特定方向时不处理移动逻辑,确保这些条件不会错误地排除向下移动的情况。确保在所有方向上的移动都有对应的逻辑处理。

    进一步的步骤

    • 调试信息:在关键位置添加调试输出,比如 deltaY 的值、窗口位置等,帮助跟踪每次移动时的状态。
    • 多种场景测试:在不同的 DPI、屏幕和窗口状态中进行尝试,以确保一致的移动表现。

    最后总结

    通过仔细检查 deltaY 是否正确更新并应用到其他窗口上,并确保无条件漏掉向下移动的情况,您能解决向下移动时的不同步问题。如果这些步骤仍然未能解决问题,请考虑详细调试相应的变量和条件,也可以提供更详细的上下文代码,以便进一步分析。

  15. User

    往上移动 跟随的多, 往下移动跟随的少

  16. Assistant

    如果在您的 WPF 应用程序中,上移窗口时其他窗口跟随得很好,而下移时却有问题,可能与坐标计算、窗口更新或消息处理逻辑的某些细节有关。我们逐步分析问题,并提供可能的解决方案。

    问题诊断

    1. 坐标计算: 在处理窗口移动时,确保您正确计算了相对变化(deltaY)以及是否使用这些变化来更新跟随窗口的位置。

    2. DPI 缩放: 确保在更新其他窗口位置时使用 DPI 缩放,特别是在高度和位置变化的情况下。

    3. 窗口状态管理: 确保临时变量(如 m_MovePrevPos 和 m_MoveSum)在每次移动后被正确更新,避免影响后续计算。

    代码示例及改进

    1. 更新 WM_MOVING 处理:

    确保在 WM_MOVING 中,deltaY 的变化被正确计算和应用。

    else if (m.Msg == WM_MOVING)
    {
        var rc = (WinRect)Marshal.PtrToStructure(m.LParam, typeof(WinRect));
    
        // 计算当前位置的变化量
        var deltaX = rc.Left - m_MovePrevPos.X; // 横向变化
        var deltaY = rc.Top - m_MovePrevPos.Y; // 纵向变化
    
        // 更新总移动量
        m_MoveSum.X += deltaX;
        m_MoveSum.Y += deltaY;
    
        // 将 WinRect 转换为 rectangle,用于计算
        var moveRect = rc.ToRectangle();
        moveRect.Location = m_MoveSum;
    
        // 移动其他窗口
        if (Global.SysConfig.FollowMainMove && m_OriginalForm.FormType == typeof(MainForm))
        {
            var frms = Forms.Where(frm => frm != m_OriginalForm && frm.FormType != typeof(OrderQueuePopupForm));
    
            foreach (var lockedWindow in frms)
            {
                // 以 DPI 缩放为基础的其他窗口位置
                var otherRect = new Rect(
                    lockedWindow.Bounds.X * Global.dpixRatio, 
                    lockedWindow.Bounds.Y * Global.dpiyRatio, 
                    Math.Round(lockedWindow.Bounds.Width * Global.dpixRatio, MidpointRounding.AwayFromZero), 
                    Math.Round(lockedWindow.Bounds.Height * Global.dpiyRatio, MidpointRounding.AwayFromZero)
                );
    
                // 更新其他窗口基于变化量 (delta)
                otherRect.Offset(deltaX, deltaY); 
                
                lockedWindow.SetBounds(otherRect.X, otherRect.Y, otherRect.Width, otherRect.Height);
                
                if (moveone)
                {
                    lockedWindow.Activate();
                }
            }
            moveone = false; // 避免重复激活 
        }
    
        // 更新之前的位置,准备下次计算
        m_MovePrevPos.X = rc.Left;
        m_MovePrevPos.Y = rc.Top; 
    }
    

    2. 调试建议

    • 打印坐标信息:在更新窗口位置之前,尝试打印 deltaX 和 deltaY,以便跟踪它们的变化。这可以帮助你确保在移动向下时,deltaY 是正值(或负值,根据计算方法)。

    • 更新顺序:确保在更新 m_MovePrevPos 之前完成所有位置计算(如 Offset)。如果更新顺序错误,可能会导致后续的计算错误。

    3. 日志输出示例

    可以在移动逻辑中添加一些日志输出以帮助调试:

    Console.WriteLine($"deltaX: {deltaX}, deltaY: {deltaY}");
    Console.WriteLine($"Moving window from ({m_MovePrevPos.X}, {m_MovePrevPos.Y}) to ({rc.Left}, {rc.Top})");
    

    4. 适配不同场景

    确保在多种 DPI 设置和不同的显示分辨率下进行测试,以验证它们能正常工作。尤其是在进行窗口操作时观察显示是否仍然一致。

    总结

    通过仔细观察和更新坐标计算,确保计算出每次移动的方向和距离的准确性,您应该能解决“向下移动跟随的少”问题。如果在执行这些步骤后问题仍然存在,欢迎提供更多的代码上下文和实施细节,以便我们进行更深入的分析。

  17. User

    var rc = (WinRect)Marshal.PtrToStructure(m.LParam, typeof(WinRect)); 这个是啥

  18. Assistant

    在您的代码中,WinRect 是一个结构体,通常用于表示窗口的矩形边界(即窗口的位置和大小)。在 WPF 或 Win32 API 中,表示窗口和图形元素的矩形区域通常使用这样的结构体。具体来说,Marshal.PtrToStructure 方法从非托管内存中提取结构体数据。

    以下是对这段代码及其相关概念的详细解释:

    含义

    1. Marshal.PtrToStructure:

      • Marshal 类是 .NET 的一部分,提供了用于与非托管代码及数据进行交互的功能。
      • PtrToStructure 方法将非托管内存(通常是指针)转换为托管引用类型,允许您在 C# 代码中使用这些数据。您可以将指向某种类型的内存区域转换为 C# 中的等效结构体。
    2. m.LParam:

      • m 是一个 Message 结构,这通常在处理 Windows 消息时使用。在 Windows 消息的上下文中,LParam 是指向某个数据结构(在这种情况下是窗口的矩形边界)的指针。
      • 把指针 m.LParam 转换为 WinRect 类型意味着您希望在 WM_MOVING 或类似的消息处理中获取当前窗口的位置信息。
    3. WinRect:

      • WinRect 通常会定义为一个结构体,包含窗口的边界信息,例如 Left、Top、Right 和 Bottom 属性。其结构可能类似于以下代码:
      [StructLayout(LayoutKind.Sequential)]
      public struct WinRect
      {
          public int Left;
          public int Top;
          public int Right;
          public int Bottom;
      
          public Rectangle ToRectangle()
          {
              return new Rectangle(Left, Top, Right - Left, Bottom - Top);
          }
      }
      

    使用示例

    该结构体通常在处理窗口位置和大小时使用,特别是在窗口移动和调整大小时。您可以通过 WinRect 获取窗口的当前坐标,并相应地更新其他窗口的位置。

    潜在问题

    1. 非托管内存安全: 处理非托管内存时,请确保消息有效且类型匹配。如果 m.LParam 指向的内存不符合 WinRect 结构的布局,可能会导致数据损坏或访问冲突。

    2. 跨平台的使用: 这个概念主要用于 Windows 平台。如果您在其他平台(如 Linux 或 macOS)上运行 WPF 应用,未来要考虑的底层实现差异。

    3. DPI 考虑: 当使用 WinRect 的数据时,确保在高 DPI 设置下进行适当的缩放。例如,在调用 UI 更新时应用 DPI 比例。

    总结

    通过 Marshal.PtrToStructure(m.LParam, typeof(WinRect)),您将获得窗口当前的位置和大小信息,该信息对于处理窗口移动逻辑、调整大小以及同步其他窗口的位置非常重要。确保您定义的 WinRect 结构正确匹配 Windows API 的 Expectation,并正确处理 DPI 和非托管内存的细节,将使得程序在不同分辨率和 DPI 设置下更稳定。

wpf 记录窗体位置,下次打开是还是在原来位置显示,但是dpi设置150%时,代开位置就不对了 · The Chat Archive