Los valores superiores e inferiores de la ventana no se actualizan correctamente al maximizar una ventana en .NET 4

Question

Estoy intentando centrar una ventana en la ventana del propietario. También necesito que la ventana secundaria se mueva a lo largo de la ventana del propietario. Se puede encontrar una publicación cruzada en el foro de MSDN WPF here.

Para lograr esto me suscribo a los eventos LocationChanged y SizeChanged (y también el evento StateChanged) del propietario de la ventana de mi hijo. Cuando esos eventos se desencadenan, vuelvo a calcular la ubicación de la ventana secundaria. Lo hago en el código subyacente de la ventana secundaria.

El código es muy sencillo:

Top = Owner.Top + ((Owner.ActualHeight - ActualHeight)/2); 
Left = Owner.Left + ((Owner.ActualWidth - ActualWidth)/2); 

Si compilar y ejecutar el programa de ejemplo que he proporcionado verá que funciona cuando la ventana principal es tal y como son, y se trasladó alrededor. Entonces esa parte funciona

El problema surge cuando se maximiza la ventana del propietario. (Y después de maximizarlo, vuelve a la normalidad.) Debido a que me suscribo a tres eventos, entro a la función de reubicación tres veces. Después de imprimir los datos del propietario, obtengo resultados diferentes. Lo más molesto es que los valores Top y Left de la ventana del propietario están desactivados. Parece que obtiene los valores correctos superior e izquierdo cuando el estado cambia, pero los valores ActualWidth y ActualHeight son incorrectos. Cuando se desencadenan los eventos LocationChanged o SizeChanged, los valores ActualWidth y ActualHeight son correctos, pero los valores superior e izquierdo son incorrectos. Parece que estos son los valores anteriores. ¿Cómo puede ser esto? ¿Qué está causando esto? ¿Y hay una solución adecuada para esto?

Dado que el mismo código parece haber funcionado en .net 3.5, tengo la impresión de que algo cambió en .net 4. (O tuve un problema de sincronización extraño que hizo que el problema no apareciera). Pero no puedo encontrar ningún cambio documentado en esta parte.

.NET 3.5:

OnOwnerLocationChanged 
T: -8; L: -8; W: 640; H: 480 
OnOwnerStateChanged 
T: -8; L: -8; W: 640; H: 480 
OnOwnerSizeChanged 
T: -8; L: -8; W: 1936; H: 1066 

.NET 4.0:

OnOwnerLocationChanged 
T: -8; L: -8; W: 640; H: 480 
OnOwnerStateChanged 
T: 494; L: 33; W: 640; H: 480 
OnOwnerSizeChanged 
T: 494; L: 33; W: 1936; H: 1066 

Así que la pregunta principal sigue siendo: ¿por qué son los valores de izquierda del propietario superior e incorrecto?

Answer 1

El comment de Mataniko con respecto a los problemas de migración en .NET 4.0 era correcta. Dado que mi código estaba funcionando cuando el WindowState se configuró en Normal, podría conservarlo. Solo tenía que prever algo cuando el WindowState era Maximized.

Implementé la función nativa GetWindowRect() para lograr esto, ya que podría darme las dimensiones adecuadas.

[StructLayout(LayoutKind.Sequential)] 
public struct RECT 
{ 
    public int Left; 
    public int Top; 
    public int Right; 
    public int Bottom; 
} 

[DllImport("user32.dll")] 
[return: MarshalAs(UnmanagedType.Bool)] 
public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect); 

// Make sure RECT is actually OUR defined struct, not the windows rect. 
public static RECT GetWindowRectangle(Window window) 
{ 
    RECT rect; 
    GetWindowRect((new WindowInteropHelper(window)).Handle, out rect); 

    return rect; 
} 

continuación, cuando el Owner.WindowState es Maximized, utilizamos la función GetWindowRectangle para obtener las dimensiones reales. No nos importa un borde en este punto, pero si es necesario, puede incorporarse utilizando la función GetSystemMetrics.

if (Owner.WindowState == WindowState.Maximized) 
{ 
    var rect = GetWindowRectangle(Owner); 

    Top = rect.Top + ((rect.Bottom - ActualHeight)/2); 
    Left = rect.Left + ((rect.Right - ActualWidth)/2); 
} 

Answer 2

No sé si es un error en .NET 4.0 o el comportamiento previsto. Mi sospecha es que hay una condición de carrera entre los eventos registrados y los disparos reales. Aunque LocationChanged se activa primero, SizeChanged se registra primero con los valores todavía incorrectos de la ubicación. Puede solucionar esto fácilmente creando una variable local en la ventana secundaria que registra el Propietario arriba y la izquierda en el evento LocationChanged.

Ejemplo:

private Point _ownerLocation; 

private void OnOwnerLocationChanged(object sender, EventArgs e) 
    { 
     Console.WriteLine("OnOwnerLocationChanged"); 
     _ownerLocation = new Point(Owner.Top, Owner.Left); 
     SetLocationToOwner(); 
    } 

private void SetLocationToOwner() 
    { 
     if (IsVisible && (Owner != null)) 
     { 
      Console.WriteLine("T: {0}; L: {1}; W: {2}; H: {3}", Owner.Top, Owner.Left, Owner.ActualWidth, Owner.ActualHeight); 

      Top = _ownerLocation.X + ((Owner.ActualHeight - ActualHeight)/2); 
      Left = _ownerLocation.Y + ((Owner.ActualWidth - ActualWidth)/2); 
     } 
    } 

Answer 3

Ha intentado ..

int left, top, width, height; 
bool maximised; 

if (WindowState == FormWindowState.Maximized) 
{ 
    maximised = true; 
    left = RestoreBounds.X; 
    top = RestoreBounds.Y; 
    width = RestoreBounds.Width; 
    height = RestoreBounds.Height; 
} 
else 
{ 
    maximised = false; 
    left = Left; 
    top = Top; 
    width = Width; 
    height = Height; 
} 

Y para revertir (el orden es importante) ...

StartPosition = FormStartPosition.Manual; 
Location = new Point(left, top); 
Size = new Size(width, height); 

if (maximised) 
    WindowState = FormWindowState.Maximized;