{"id":43,"date":"2010-03-08T19:18:00","date_gmt":"2010-03-08T19:18:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/davidrickard\/2010\/03\/08\/saving-window-size-and-location-in-wpf-and-winforms\/"},"modified":"2010-03-08T19:18:00","modified_gmt":"2010-03-08T19:18:00","slug":"saving-window-size-and-location-in-wpf-and-winforms","status":"publish","type":"post","link":"https:\/\/engy.us\/blog\/2010\/03\/08\/saving-window-size-and-location-in-wpf-and-winforms\/","title":{"rendered":"Saving window size and location in WPF and WinForms"},"content":{"rendered":"

A common user interface tweak is to save the size and location of a window and restore that state when the program starts up again. That way, the users don’t need to re-do their work of resizing and moving the windows to where they want them. However I’ve found that there isn’t really a convenient way to do with in C#. Many solutions focus on recording the window width, height, x and y coordinates and current state (maximized, restored, etc), then applying all those values again on startup. But then you have to deal with edge cases: What if the user has changed resolutions since your program last ran? What if it was present on a monitor that’s now disconnected?<\/p>\n

Fortunately, there are a couple of native Windows functions that can do all this work for us: SetWindowPlacement<\/a> and GetWindowPlacement<\/a>. MSDN has a sample<\/a> demonstrating how to PInvoke to these functions in a WPF project, but it’s got a few issues with it. For one, it’s trying to store the placement as a custom type in settings, which can cause strange errors every time you open your Settings file. Here’s my take on it:<\/p>\n

using <\/span>System;\nusing <\/span>System.IO;\nusing <\/span>System.Runtime.InteropServices;\nusing <\/span>System.Text;\nusing <\/span>System.Xml;\nusing <\/span>System.Xml.Serialization;\n\nnamespace WindowPlacementExample<\/span><\/span>\n{\n    \/\/ RECT structure required by WINDOWPLACEMENT structure\n    <\/span>[Serializable<\/span>]\n    [StructLayout<\/span>(LayoutKind<\/span>.Sequential)]\n    public struct <\/span>RECT\n    <\/span>{\n        public int <\/span>Left;\n        public int <\/span>Top;\n        public int <\/span>Right;\n        public int <\/span>Bottom;\n\n        public <\/span>RECT(int <\/span>left, int <\/span>top, int <\/span>right, int <\/span>bottom)\n        {\n            this<\/span>.Left = left;\n            this<\/span>.Top = top;\n            this<\/span>.Right = right;\n            this<\/span>.Bottom = bottom;\n        }\n    }\n\n    \/\/ POINT structure required by WINDOWPLACEMENT structure\n    <\/span>[Serializable<\/span>]\n    [StructLayout<\/span>(LayoutKind<\/span>.Sequential)]\n    public struct <\/span>POINT\n    <\/span>{\n        public int <\/span>X;\n        public int <\/span>Y;\n\n        public <\/span>POINT(int <\/span>x, int <\/span>y)\n        {\n            this<\/span>.X = x;\n            this<\/span>.Y = y;\n        }\n    }\n\n    \/\/ WINDOWPLACEMENT stores the position, size, and state of a window\n    <\/span>[Serializable<\/span>]\n    [StructLayout<\/span>(LayoutKind<\/span>.Sequential)]\n    public struct <\/span>WINDOWPLACEMENT\n    <\/span>{\n        public int <\/span>length;\n        public int <\/span>flags;\n        public int <\/span>showCmd;\n        public <\/span>POINT <\/span>minPosition;\n        public <\/span>POINT <\/span>maxPosition;\n        public <\/span>RECT <\/span>normalPosition;\n    }\n\n    public static class <\/span>WindowPlacement\n    <\/span>{\n        private static <\/span>Encoding <\/span>encoding = new <\/span>UTF8Encoding<\/span>();\n        private static <\/span>XmlSerializer <\/span>serializer = new <\/span>XmlSerializer<\/span>(typeof<\/span>(WINDOWPLACEMENT<\/span>));\n\n        [DllImport<\/span>(\"user32.dll\"<\/span>)]\n        private static extern bool <\/span>SetWindowPlacement(IntPtr <\/span>hWnd, [In<\/span>] ref <\/span>WINDOWPLACEMENT <\/span>lpwndpl);\n\n        [DllImport<\/span>(\"user32.dll\"<\/span>)]\n        private static extern bool <\/span>GetWindowPlacement(IntPtr <\/span>hWnd, out <\/span>WINDOWPLACEMENT <\/span>lpwndpl);\n\n        private const int <\/span>SW_SHOWNORMAL = 1;\n        private const int <\/span>SW_SHOWMINIMIZED = 2;\n\n        public static void <\/span>SetPlacement(IntPtr <\/span>windowHandle, string <\/span>placementXml)\n        {\n            if <\/span>(string<\/span>.IsNullOrEmpty(placementXml))\n            {\n                return<\/span>;\n            }\n\n            WINDOWPLACEMENT <\/span>placement;\n            byte<\/span>[] xmlBytes = encoding.GetBytes(placementXml);\n\n            try\n            <\/span>{\n                using <\/span>(MemoryStream <\/span>memoryStream = new <\/span>MemoryStream<\/span>(xmlBytes))\n                {\n                    placement = (WINDOWPLACEMENT<\/span>)serializer.Deserialize(memoryStream);\n                }\n\n                placement.length = Marshal<\/span>.SizeOf(typeof<\/span>(WINDOWPLACEMENT<\/span>));\n                placement.flags = 0;\n                placement.showCmd = (placement.showCmd == SW_SHOWMINIMIZED ? SW_SHOWNORMAL : placement.showCmd);\n                SetWindowPlacement(windowHandle, ref <\/span>placement);\n            }\n            catch <\/span>(InvalidOperationException<\/span>)\n            {\n                \/\/ Parsing placement XML failed. Fail silently.\n            <\/span>}\n        }\n\n        public static string <\/span>GetPlacement(IntPtr <\/span>windowHandle)\n        {\n            WINDOWPLACEMENT <\/span>placement = new <\/span>WINDOWPLACEMENT<\/span>();\n            GetWindowPlacement(windowHandle, out <\/span>placement);\n\n            using <\/span>(MemoryStream <\/span>memoryStream = new <\/span>MemoryStream<\/span>())\n            {\n                using <\/span>(XmlTextWriter <\/span>xmlTextWriter = new <\/span>XmlTextWriter<\/span>(memoryStream, Encoding<\/span>.UTF8))\n                {\n                    serializer.Serialize(xmlTextWriter, placement);\n                    byte<\/span>[] xmlBytes = memoryStream.ToArray();\n                    return <\/span>encoding.GetString(xmlBytes);\n                }\n            }\n        }\n    }\n}<\/pre>\n
To get the placement of an existing window, you give it the native handle for the window, and get back a string of XML that represents the placement for the window. You save this string somewhere, then when the program starts back up again, apply it with SetPlacement. The above code works for both WinForms and WPF. And in both cases you can open your Properties\/Settings.settings file and add a new setting to store the string:<\/p>\n
\"image\"<\/a> <\/p>\n
This will store the window state locally, per-user. Of course you could also store the string wherever you wanted to.<\/p>\n
What I like about this approach is that the WindowPlacement class does the XML serialization for you and gives you a nice, tidy string containing all the placement data.<\/p>\n
But where in the program code should we hook in to save and re-apply the window placements? The answer is a bit different between WinForms and WPF.<\/p>\n
WPF:<\/strong><\/p>\n
You might benefit by throwing a couple of extension methods on the WindowPlacement class to make things a bit easier:<\/p>\n
public static void <\/span>SetPlacement(this <\/span>Window <\/span>window, string <\/span>placementXml)\n{\n    WindowPlacement<\/span>.SetPlacement(new <\/span>WindowInteropHelper<\/span>(window).Handle, placementXml);\n}\n\npublic static string <\/span>GetPlacement(this <\/span>Window <\/span>window)\n{\n    return <\/span>WindowPlacement<\/span>.GetPlacement(new <\/span>WindowInteropHelper<\/span>(window).Handle);\n}<\/pre>\n
To save the window placement, just handle the Closing event on the Window:<\/p>\n
private void <\/span>Window_Closing(object <\/span>sender, CancelEventArgs <\/span>e)\n{\n    Settings<\/span>.Default.MainWindowPlacement = this<\/span>.GetPlacement();\n    Settings<\/span>.Default.Save();\n}<\/pre>\n
To restore, you’ll need to hook in on SourceInitialized:<\/p>\n
protected override void <\/span>OnSourceInitialized(EventArgs <\/span>e)\n{\n    base<\/span>.OnSourceInitialized(e);\n    this<\/span>.SetPlacement(Settings<\/span>.Default.MainWindowPlacement);\n}<\/pre>\n
WinForms:<\/strong><\/p>\n
This one is a bit more straightforward. Save on the FormClosing event and restore the window state in the Load event handler. The Form’s native handle is accessible from its Handle property.<\/p>\n
Now we have a robust and relatively painless way of persisting window sizes and positions, and we only need to keep track of one string per window.<\/p>\n","protected":false},"excerpt":{"rendered":"
A common user interface tweak is to save the size and location of a window and restore that state when the program starts up again. That way, the users don’t need to re-do their work of resizing and moving the windows to where they want them. However I’ve found that there isn’t really a convenient … <\/p>\n
Continue reading “Saving window size and location in WPF and WinForms”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"spay_email":"","jetpack_publicize_message":"","jetpack_is_tweetstorm":false},"categories":[1],"tags":[],"jetpack_featured_media_url":"","jetpack_publicize_connections":[],"jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/pahBcK-H","jetpack-related-posts":[{"id":120,"url":"https:\/\/engy.us\/blog\/2020\/01\/01\/implementing-a-custom-window-title-bar-in-wpf\/","url_meta":{"origin":43,"position":0},"title":"Implementing a Custom Window Title Bar in WPF","date":"January 1, 2020","format":false,"excerpt":"There are several good reasons for wanting custom window chrome in WPF, such as fitting in additional UI or implementing a Dark theme. However the actual implementation is kind of tricky, since it is now your job to provide a bunch of features that you used to get for free.\u2026","rel":"","context":"With 12 comments","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":174,"url":"https:\/\/engy.us\/blog\/2021\/12\/11\/aws-cognito-authentication-in-electron\/","url_meta":{"origin":43,"position":1},"title":"AWS Cognito Authentication in Electron","date":"December 11, 2021","format":false,"excerpt":"The AWS Cognito authentication service as of this writing does not officially support the Electron platform. But there is a Javascript SDK for Cognito, as part of AWS Amplify. Others have tried using it on Electron but have run into issues. I ran into several more than what are described\u2026","rel":"","context":"Similar post","img":{"alt_text":"","src":"https:\/\/i2.wp.com\/engy.us\/blog\/wp-content\/uploads\/2021\/12\/image.png?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":88,"url":"https:\/\/engy.us\/blog\/2018\/10\/20\/dark-theme-in-wpf\/","url_meta":{"origin":43,"position":2},"title":"Dark Theme in WPF","date":"October 20, 2018","format":false,"excerpt":"In a recent Windows 10 update a toggle switch was added to allow the user to specify that they wanted \"Dark\" themes in apps: I decided to add support for this to VidCoder. But no updates to WPF were made to make this easy. WPF does having theming support where\u2026","rel":"","context":"With 5 comments","img":{"alt_text":"","src":"https:\/\/i2.wp.com\/engy.us\/blog\/wp-content\/uploads\/2018\/10\/VidCoderDarkExample.png?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":51,"url":"https:\/\/engy.us\/blog\/2015\/07\/17\/installing-net-framework-4-5-automatically-with-inno-setup\/","url_meta":{"origin":43,"position":3},"title":"Installing .NET Framework 4.7 automatically with Inno Setup","date":"July 17, 2015","format":false,"excerpt":"In this guide I will walk through how to get the .NET framework to download and install on-the-fly in an Inno Setup installer. It works in 3 steps: Detect if the desired .NET framework is installed Download the .NET Framework bootstrap installer with Inno Download Plugin Run the bootstrap installer\u2026","rel":"","context":"In \".net framework 4.5 inno setup\"","img":{"alt_text":"","src":"https:\/\/i0.wp.com\/engy.us\/blog\/wp-content\/uploads\/2015\/07\/7028.InstallingFramework2-1.png?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":146,"url":"https:\/\/engy.us\/blog\/2021\/02\/28\/installing-net-5-runtime-automatically-with-inno-setup\/","url_meta":{"origin":43,"position":4},"title":"Installing .NET 5 Runtime Automatically with Inno Setup","date":"February 28, 2021","format":false,"excerpt":"In this guide I will walk through how to get the .NET 5 runtime to download and install on-the-fly in an Inno Setup installer. It works in 3 steps: Detect if the desired .NET runtime is installedDownload the .NET Runtime bootstrap installer with Inno Download PluginRun the bootstrap installer in\u2026","rel":"","context":"With 2 comments","img":{"alt_text":"","src":"https:\/\/i0.wp.com\/engy.us\/blog\/wp-content\/uploads\/2021\/02\/image.png?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":159,"url":"https:\/\/engy.us\/blog\/2021\/05\/25\/how-to-use-individual-code-signing-certificates-to-get-rid-of-smartscreen-warnings\/","url_meta":{"origin":43,"position":5},"title":"How to Use Individual Code Signing Certificates to get rid of SmartScreen warnings","date":"May 25, 2021","format":false,"excerpt":"The problem Windows SmartScreen has for a while been trying to keep malware at bay. One of the ways of doing that is putting up a big scary warning when you try to run anything they haven't validated as safe: You have to click \"More info\" then \"Run anyway\" to\u2026","rel":"","context":"With 5 comments","img":{"alt_text":"","src":"https:\/\/i2.wp.com\/engy.us\/blog\/wp-content\/uploads\/2021\/05\/image.png?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]}],"_links":{"self":[{"href":"https:\/\/engy.us\/blog\/wp-json\/wp\/v2\/posts\/43"}],"collection":[{"href":"https:\/\/engy.us\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/engy.us\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/engy.us\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/engy.us\/blog\/wp-json\/wp\/v2\/comments?post=43"}],"version-history":[{"count":0,"href":"https:\/\/engy.us\/blog\/wp-json\/wp\/v2\/posts\/43\/revisions"}],"wp:attachment":[{"href":"https:\/\/engy.us\/blog\/wp-json\/wp\/v2\/media?parent=43"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/engy.us\/blog\/wp-json\/wp\/v2\/categories?post=43"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/engy.us\/blog\/wp-json\/wp\/v2\/tags?post=43"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
\n<\/a><\/p>\n