Scaling Windows - The DPI Arms Race
by Brett Howse on April 15, 2014 2:00 PM EST- Posted in
- Operating Systems
- Windows
- Microsoft
- Windows 8.1
- High DPI
Windows 8.1 - More DPI Changes
When Microsoft launched Windows 8.1, it continued to refine the scaling functionality. To assist with people using a tablet such as the Microsoft Surface as a desktop replacement, Windows 8.1 now has the ability to have independent DPI settings per display. This was sorely needed, as anyone who used a Surface Pro (a 1920x1080 pixel 10.6” display) and then connected it to an external 1080p monitor that was two to three times the size of the tablet display complained bitterly about what a terrible experience this was. The Surface Pro’s on-device screen is set at 150% scaling which is necessary to make that resolution work on a 10” screen, but on a 24” monitor all on-screen elements are enormous.
Having two independent DPI settings is not without its challenges. Applications are initially scaled at the DPI setting of whichever monitor they are opened on. With any multi-monitor system, the operating system has to be able to deal with a person moving an application from one monitor to the other. If the application is scaled at the initial DPI, how to you keep it from becoming too large or too small when moved? The solution is once again DPI Virtualization, and once again it’s a solution that works but it’s not ideal.
If the initial monitor is a lower DPI, the application will be scaled up when moved to the higher DPI display, and if it moves from a High DPI monitor to a low DPI display, it will be scaled down. Just like with the Windows Vista DPI Virtualization, this method can result in applications that aren’t as sharp as they should be, as well as quirks with user elements. To get around these issues, Microsoft has expanded the DPI API to allow for per-monitor DPI-aware applications.
Applications that are per-monitor DPI-aware are expected to automatically re-scale themselves when moved between displays. They can do this because the operating system will send a WM_DPICHANGED message to the application when most of the application’s area has moved to a display with a different DPI level. The message sent to the application includes a recommended DPI level, but the application can choose whatever value it wants.
Windows 8.1 also improves several other key elements of DPI settings, continuing the tweaks made since the days of Windows XP where you had to reboot for a DPI change.
| High DPI Windows Features | |||||
| Feature | Windows XP | Windows Vista | Windows 7 | Windows 8 | Windows 8.1 |
| DPI Virtualization of DPI-unaware apps | No | Yes | Yes | Yes | Yes |
| DPI Virtualization of System DPI-aware apps | No | No | No | No | Yes |
| API to declare DPI awareness level | No | Yes | Yes | Yes | Yes |
| API to declare per-monitor DPI awareness | No | No | No | No | Yes |
| APIs to retrieve system metrics and DPI | Yes | Yes | Yes | Yes | Yes |
| Window notification of DPI change | No | No | No | No | Yes |
| APIs to retrieve monitor DPI | No | No | No | No | Yes |
| Requires reboot for monitor DPI change | N/A | N/A | N/A | N/A | No |
| Requires a reboot/log off for system DPI change | Reboot | Reboot | Log off | Log off | Log off |
| Per user DPI setting | No | No | Yes | Yes | Yes |
| Auto configuration of DPI at first logon | No | No | Yes | Yes | Yes |
| Viewing distance incorporated in default DPI calculation | No | No | No | No | Yes |
All of this DPI talk has focused 100% on the desktop environment. That is because the Modern environment for Windows has the luxury of being built with no legacy applications to deal with, so it can actually work in a manner similar to Apps on iOS and Android.
Windows 8.1 - Windows Store Apps
Love it or hate it, the Modern environment for Windows came at a time when High DPI devices already existed. This allowed it to be architected with support for native scaling for all applications. Windows Store apps are automatically scaled by Windows based on physical screen size, resolution, and device form factor at a ratio of 100%, 140%, and 180%. Windows Store apps encourage the use of scalable vector graphics if possible, or multiple copies of bitmap images to allow crisp images regardless of the scaling used.
Windows Store apps, and even Windows itself, scales not only the DPI of the application, but also how much content the application can display based on the physical screen size. Larger displays, much like in the desktop world, are often used to see and do more on the screen rather than just make everything larger as on a phone, and the Windows Runtime allows for all of this.
Windows Store apps require far less work from the developer in order to achieve this scaling. The app doesn’t have to be DPI aware, because by default all applications automatically are. Instead, things such as XAML layouts and SVG graphics allow the apps to be rescaled completely by the operating system.
Here is Adobe Touch, a Windows Store app version of Adobe Reader. It’s perfectly at home even at 3200x1800 on a 13.3” display. All of the UI elements are correctly sized and of course still usable by touch.
Facebook
Twitter
RSS
114 Comments
View All Comments
Antronman - Tuesday, April 15, 2014 - link
4k display on a notebook would have to be achieved with top-end mobile graphics.The display would likely need a 30Hz refresh rate to avoid screen tears. It would really only be something practical for 2D artists who do a lot of their work on the go.
As far as scaling, I imagine it would work exactly the same as on an external monitor.
darthrevan13 - Wednesday, April 16, 2014 - link
Being a week before the Toshiba Satellite P55t no one has any answer but looking at their 65L9300U UHDTV with 60hz and real HDMI 2.0 that launched not too much time ago things aren't looking so bright because when put on a lower resolution things get a little blurry. The scaler is hardware based (to keep up with the enormous resolution and refresh rate) not software based so until someone makes a silicon that viably handles 4K, 1080p and 720p you'll be stuck.B3an - Friday, April 18, 2014 - link
I don't know why people like you think that 4k is hard to do. An average GPU can easily handle 4k @ 60hz. It's only for gaming that requires something more powerful.B3an - Tuesday, April 15, 2014 - link
Brett - nice article. One thing i wanted to point out though is that the workaround you mention for Chrome does not work. Turning on HiDPI still has issues. The UI is messed up and pixelated, and text still isn't rendered correctly - the spacing of the letters is messed up. You can also see this in your text screenshot, look at the word "committing", the two M's are too close together. With other letters some are too far apart (depends on the word). Chrome is just screwed up, it's best you FF or IE. FF has small issues though but the text atleast renders correctly.Tujan - Wednesday, April 16, 2014 - link
Perhaps the ideas about a notebook,or a tablet concerning the displays are somewhat different than a standalone monitor with different manufactured possibilities. That is a Hi ppi on a notebook is not 'exactly' a PNP device. It may even be moreso (not pnp) presently when graphics cards,and monitors have several different plugs available HDMI,Display Port,VGA,DVI ect. . At least more presently,the high PPI for purposes of updating applications might be considered something other than PNP - to that requiring a driver from the manufacturer. Or that would provide a foundation for its feature set.I say this not necesarily as a priority. But in a role model that would consist of running with the display driver,and would as well become consistant with the programming coordinates.
The System wide DPI thing as with XP,this was one example of a the difference in application independent resolutions. The application itself,the system menus,title bars,start menus,desktop fonts as well as default texting was something wich was system wide among ALL applications.
You also said that Apple applications are PPI aware. And that exactly takes the coding to create applications for the PPI in use.
Then that the 'SetProcessDPIAwareness',a setting in the Windows newer application programming base is something that can do pretty much the same.
Funny thing about VLC,is that I'm wanting to ask what file type the video was which had anything to do with the DPI.
And with this,most of the modern day programing I'm suspecting is the standardization of,and off of the XML type 'Webbies coding. And this is a complete modernized code based from the W3C,type and formerly HTML type standards. Then those standards would be instilled to the screen programming.
Thus not C+,C++,python etc.
With the Adobe,the picture there,it isn't said if the screen was a 24"4K,or a 12" hi PPI screen.
I'll wrap my comment up with what I noted at the first, is the monitors they are PNP (are they not ). Or are they just 'not exactly pnp'. There is video drivers but not a monitor driver.I'm just looking to show where you would 'map the platte',for /from .
So where am I going ? With Windows code base as XML - the webbies. There is still the matrix of the PNP monitor. That perhaps isn't pnp- or shouldn't be. Now there are graphics drivers for other programming (Try OpenGL) . That are plenty more than just page elements.
Windows also has some apps which is Dirx capable. That is perhaps a solution. But I suspect there is some fantastic code that needs to run independent DPI/PPI. That is requiring the metrics to do so. With whichever/whatever operating system is being used. Or what monitor is being used.
Try running for example,a legacy 640x480 dimension ,that scales in leisure on that 4K monitor. You can of course turn on ,and turn off whichever monitor pixel you want. But look,it scales in inches. The application.
Try running a legacy 800x600 resolution to the same. See it is the 'monitor',that is stuck in its resolution . It is somewhat might be the same,as having a virtual op.sys.run in a virtual window for a different second virtualize op.sys. .
You can run virtualized monitors,in application space,that scales to suffice the viewing logistics.
MOst of this article has put across the independent applications space. But not yet the independent resolution of a the application in the monitors dynamic space. And everybody needs those numbers.
I would say the monitors must be able to use independant low resolution in dynamic space .
Just saying.
P.S.Thanks for the charts.
Tujan - Wednesday, April 16, 2014 - link
mean if you need 96 ppi . You have it . If you need 640x480 in 24 inches . You have x amount of dots/pionts per inch to address. Either use those pixels. Or dont use them. You may in fact have a window doing x amount of hrz. . Then another window doing a different hrz . Just to make things easier to understand .Pinkynator - Wednesday, April 16, 2014 - link
I have a reasonable idea: don't invent custom DPI.If an old 23-24" monitor is 1920x1080 (that's 96 DPI, IIRC), a new model should be 3840x2160 (which should then be double, 192 DPI, and that's more than enough for a desktop monitor for anyone in the world not to notice individual pixels).
Don't have a high-DPI app? Just scale assets in both dimensions by exactly 2. Your toolbar icons don't get blurry due to resizing. Fonts don't get blurry, either.
Have a high-DPI app? Okay then, let the app give Windows its new high-res icons and let it render fonts with greater accuracy.
Movies and games? They can render at 1920x1080 and will look exactly the same as they previously used to. No blurring because of resizing algorithms: every pixel gets quadrupled, plain and simple.
With this "solution", everything looks just like it used to (no compatibility issues whatsoever), except when app developers explicitly decide to make things look better - and handling a straight-up 2x scale is a lot easier than today.
"But wait!", I hear you cry, "I like my 125 DPI on this screen! It shows more of the UI!"
Let me know how that goes in a few years, when your vision starts deteriorating due to aging, and you find even 96 DPI to be a wee bit too small.
DarkXale - Wednesday, April 16, 2014 - link
I really recommend you actually, you know, read the article?Pinkynator - Wednesday, April 16, 2014 - link
I did. You didn't understand what I wrote :)You're not looking at the big picture. Handling DPI issues is insanely hard on legacy systems, which is why the only painless solution is to quadruple everything - based on 96 DPI. Then you get 192 DPI (or 288 DPI) "for free".
Everything else is going to be hacks. We're still not truly in the era of high-DPI Windows machines, so there's STILL time to just unhack everything and go for easily-dealt-with multiples of 96.
UsernameAlreadyExists - Wednesday, April 16, 2014 - link
>"Handling DPI issues is insanely hard on legacy systems, which is why the only painless solution is to quadruple everything"And this here is the reason for the Retina display (and also the rather crazy current iPhone resolution), as the iPhone apps do not handle scaling at all. This was probably the cause for the rather low resolution with the last Symbian phones, 4x would have required 25% more pixels than iPhone 4, and would have been too expensive at the time of their release.
However, I think going forward and just breaking things is the correct way. Winforms have their problems, but XAML makes rather many things easy. (The paradigm shift is rather big though)