Disable DPI awareness for WPF application
None of the above truly disable the dpi scaling in WPF.
This is how dpi scaling is calculated in .net 4.6 by WPF: 1) HwndTarget which is the CompositionTarget used by all visuals. 2) UIElement which is the base class for visuals and the place where dpi scaling calculation results are stored.
WPF makes sure the global scaling is calculated once when first visual is prepared. This is controlled by a boolean on HwndTarget {private static bool _setDpi = true}. After calculating the dpi, the _setDpi field is set to false and dpi aware methods are shortcut using code like this {if (!HwndTarget._setDpi) return;}
A similar thing happens for every UIElement, which has the same pattern using {private static bool _setDpi = true} to allow calculation first time.
Next check comes from ProcessDpiAwareness which can be None, Process, or Monitor. In order to stop WPF from considering individual monitors you needs to set ProcessDpiAwareness to Process (int 1).
Finally when dpi is calculated the result is stored in 2 lists called DpiScaleXValues and DpiScaleYValues on UIElement. So you need to initialize these to correct values.
Here is a sample code I use for myself (only works for .net 4.6):
var setDpiHwnd = typeof(HwndTarget).GetField("_setDpi", BindingFlags.Static | BindingFlags.NonPublic);
setDpiHwnd?.SetValue(null, false);
var setProcessDpiAwareness = typeof(HwndTarget).GetProperty("ProcessDpiAwareness", BindingFlags.Static | BindingFlags.NonPublic);
setProcessDpiAwareness?.SetValue(null, 1, null);
var setDpi = typeof(UIElement).GetField("_setDpi", BindingFlags.Static | BindingFlags.NonPublic);
setDpi?.SetValue(null, false);
var setDpiXValues = (List<double>)typeof(UIElement).GetField("DpiScaleXValues", BindingFlags.Static | BindingFlags.NonPublic)?.GetValue(null);
setDpiXValues?.Insert(0, 1);
var setDpiYValues = (List<double>)typeof(UIElement).GetField("DpiScaleYValues", BindingFlags.Static | BindingFlags.NonPublic)?.GetValue(null);
setDpiYValues?.Insert(0, 1);
This blog article explains how to use a Decorator subclass to do just that.
In short, create a class like this:
namespace MyNamespace
{
public class DpiDecorator : Decorator
{
public DpiDecorator()
{
this.Loaded += (s, e) =>
{
Matrix m = PresentationSource.FromVisual(this).CompositionTarget.TransformToDevice;
ScaleTransform dpiTransform = new ScaleTransform(1 / m.M11, 1 / m.M22);
if (dpiTransform.CanFreeze)
dpiTransform.Freeze();
this.LayoutTransform = dpiTransform;
};
}
};
};
Then add something like xmlns:custom="clr-namespace:MyNamespace"
to your top-level window definition, then enclose your DPI-independent user-interface with <custom:DpiDecorator>
...</custom:DpiDecorator>
.
DPIAwareness
Just some ideas (not tried):
Are you running on XP? That option might not work on that platform.
- http://social.msdn.microsoft.com/Forums/en-US/vcgeneral/thread/5e60a54d-baf5-46e3-9eac-a959f2a0fba1/
What follows are probably just different ways to set the same DpiAwareness option:
look at the "compatibility mode" settings on your EXE...right click it's properties...and turn on "Disable display scaling"
create a manifest, and say you aren't aware
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3" > ... <asmv3:application> <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings"> <dpiAware>false</dpiAware> </asmv3:windowsSettings> </asmv3:application> ... </assembly>
call
SetProcessDPIAware
(think you have to call this early i.e. before Window is created)
http://msdn.microsoft.com/en-gb/library/windows/desktop/ms633543(v=vs.85).aspx
You can call IsProcessDPIAware
to check if your apps process has had the setting applied to it or not.
Finding out the DPI
Here's how you find out what DPI you are currently using:
Access CompositionTarget
via the PresentationSource
of your Window
to find out what DPI scaling it's using.....you can then use the values to do some scaling adjustments i.e. scale down your "stuff" (whose sizes/length/etc are specified in Device Independent Units), so that when its scaled up due to a higher DPI being in effect it doesn't explode the physical pixel usage (...this can be done in various ways e.g. ViewBox
, or calculations on widths, etc on elements ).
double dpiX, double dpiY;
PresentationSource presentationsource = PresentationSource.FromVisual(mywindow);
if (presentationsource != null) // make sure it's connected
{
dpiX = 96.0 * presentationsource.CompositionTarget.TransformToDevice.M11;
dpiY = 96.0 * presentationsource.CompositionTarget.TransformToDevice.M22;
}
- How do I convert a WPF size to physical pixels?
- http://wpftutorial.net/DrawOnPhysicalDevicePixels.html
Do Scaling Adjustments
use the
ViewBox
trick
See this answer I made before that allowed aCanvas
to use positions that were interpreted as "native" pixel no matter what the DPI scaling.
WPF for LCD screen Full HDaccess the
TransFormToDevice
scaling matrix on theCompositionTarget
, and from that calculate a new matrix that just undoes that scaling and use that inLayoutTransform
orRenderTransform
.use a method (maybe even put it in a Converter) that modifies a DIP (Device Independent Position) position/length on an explicit basis....you might do that if you want your Window Size to match a particular pixel size.