/// <summary>
/// Speichert die Größe und Position des Fensters
/// </summary>
/// <param name="win">Das Fenster.</param>
private static void SaveSizeAndPosition(Window win)
{
if (win == null)
{
return;
}
Debug.Assert(string.IsNullOrEmpty(win.Name) == false, string.Format("Name property of the window is not set. ({0})", win.GetType().Name));
// Registry-Schlüssel holen bzw. erzeugen, unter dem die Daten gespeichert werden
var key = Registry.CurrentUser.CreateSubKey(AppContext.RegistryPath + win.Name);
if (key == null)
{
throw new ApplicationException(string.Format("Could not create registry key '{0}'.", AppContext.RegistryPath + win.Name));
}
// Aktuelles Display ermitteln
var screen = WpfScreen.GetScreenFrom(win);
// Fensterposition und -größe ermitteln und auf absolute Werte des aktuellen Displays umrechnen
var boundaryRect = win.RestoreBounds;
if (boundaryRect != Rect.Empty) // Empty kommt in seltenen Fällen vor! Dann nix speichern
{
boundaryRect.Offset(-screen.WorkingArea.Left, -screen.WorkingArea.Top);
// Und in die Registry schreiben
using (CultureHelper.UseSpecificCulture("en-US"))
{
key.SetValue("Bounds", boundaryRect.ToString().Replace(';', ','));
key.SetValue("Display", screen.DeviceName);
}
}
}
/// <summary>
/// Liefert den Bildschirm zu einem Fenster
/// </summary>
/// <param name="window">Das Fenster.</param>
/// <returns>Der Bildschirm</returns>
public static WpfScreen GetScreenFrom(Window window)
{
var windowInteropHelper = new WindowInteropHelper(window);
var screen = Screen.FromHandle(windowInteropHelper.Handle);
var wpfScreen = new WpfScreen(screen);
return(wpfScreen);
}
/// <summary>
/// Liefert den Bildschirm zu einem Bildschirmpunkt
/// </summary>
/// <param name="point">Der Punkt.</param>
/// <returns>Der Bildschirm</returns>
public static WpfScreen GetScreenFrom(Point point)
{
var x = (int)Math.Round(point.X);
var y = (int)Math.Round(point.Y);
// are x,y device-independent-pixels ??
var drawingPoint = new System.Drawing.Point(x, y);
var screen = Screen.FromPoint(drawingPoint);
var wpfScreen = new WpfScreen(screen);
return(wpfScreen);
}
/// <summary>
/// Stellt die letzte bekannte Position und Größe eines Fensters wieder her.
/// Sorgt dafür, dass beim Schließen des Fensters, diese Angaben in der Registry gespeichert werden.
/// Um effizient zu funktionieren, empfiehlt es sich <c>WindowStartupLocation</c> auf den Wert <c>Manual</c> zu setzen.
/// </summary>
/// <param name="win">Das Fenster.</param>
public static void RestoreSizeAndPosition(this Window win)
{
if (win == null)
{
return;
}
Debug.Assert(string.IsNullOrEmpty(win.Name) == false, string.Format("Name property of the window is not set. ({0})", win.GetType().Name));
// Callback einrichten, der dafür sorgt, dass die Daten beim Schließen des Fensters gespeichert werden
win.Closing += delegate(object sender, CancelEventArgs e)
{
var window = sender as Window;
SaveSizeAndPosition(window);
};
// Zugriff auf den Schlüssel in der Registry. Ist dieser noch nicht vorhanden, wird kommentarlos abgebrochen.
var key = Registry.CurrentUser.OpenSubKey(AppContext.RegistryPath + win.Name);
if (key == null)
{
return;
}
using (CultureHelper.UseSpecificCulture("en-US"))
{
var bk = key.GetValue("Bounds");
if (bk == null || bk.ToString() == "Empty")
{
return;
}
var bounds = Rect.Parse(bk.ToString());
var screenName = (string)key.GetValue("Display");
var screen = WpfScreen.GetScreenName(screenName) ?? WpfScreen.Primary;
win.Top = bounds.Top + screen.WorkingArea.Top;
win.Left = bounds.Left + screen.WorkingArea.Left;
// Die Fenstergröße nur bei manuell vergrößerbaren Fenstern speichern
if (win.SizeToContent == SizeToContent.Manual)
{
win.Width = bounds.Width;
win.Height = bounds.Height;
}
}
}
