我正在尝试使用C#编程以编程方式更改Windows 10的显示比例。让我也说一下，我不是在创建一个自动强制用户屏幕更改分辨率/缩放比例的应用程序。它只是一个工具，让我能够从托盘中切换比例，因为这是我经常进行测试的事情。因此，特意为此操作而设计。
所以，我能够追踪到当用户通过下面看到的官方对话框手动执行此操作时设置了哪些注册表条目（HKEY_CURRENT_USER\Control Panel\Desktop）：
但是，显然直接与注册表一起工作意味着我需要重新启动机器才能生效。
我知道可以使用Pinvoke来更改屏幕分辨率：Setting my Display Resolution
我想知道是否有办法为给定屏幕更改此“%”？ 例如...上面的屏幕显示150％，我想能够通过全范围的100-500％以编程方式更改它。
我使用WinDbg来查看该应用程序所做的调用。我发现，只要执行了特定的函数 - user32!_imp_NtUserDisplayConfigSetDeviceInfo，新的DPI设置就会在我的计算机上生效。
DisplayConfigSetDeviceInfo() (bp user32!DisplayConfigSetDeviceInfo)上设置一个断点。((user32!DISPLAYCONFIG_DEVICE_INFO_HEADER *)0x55df8fba30) : 0x55df8fba30 [Type: DISPLAYCONFIG_DEVICE_INFO_HEADER *]
[+0x000] type : -4 [Type: DISPLAYCONFIG_DEVICE_INFO_TYPE]
[+0x004] size : 0x18 [Type: unsigned int]
[+0x008] adapterId [Type: _LUID]
[+0x010] id : 0x0 [Type: unsigned int]
0:003> dx -r1 (*((user32!_LUID *)0x55df8fba38))
(*((user32!_LUID *)0x55df8fba38)) [Type: _LUID]
[+0x000] LowPart : 0xcbae [Type: unsigned long]
[+0x004] HighPart : 0 [Type: long]
DisplayConfigSetDeviceInfo()的DISPLAYCONFIG_DEVICE_INFO_HEADER结构体成员的值如下：type : -4
size : 0x18
adapterId : LowPart : 0xcbae HighPart :0
typedef enum
{
DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME = 1,
DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME = 2,
DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_PREFERRED_MODE = 3,
DISPLAYCONFIG_DEVICE_INFO_GET_ADAPTER_NAME = 4,
DISPLAYCONFIG_DEVICE_INFO_SET_TARGET_PERSISTENCE = 5,
DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_BASE_TYPE = 6,
DISPLAYCONFIG_DEVICE_INFO_GET_SUPPORT_VIRTUAL_RESOLUTION = 7,
DISPLAYCONFIG_DEVICE_INFO_SET_SUPPORT_VIRTUAL_RESOLUTION = 8,
DISPLAYCONFIG_DEVICE_INFO_GET_ADVANCED_COLOR_INFO = 9,
DISPLAYCONFIG_DEVICE_INFO_SET_ADVANCED_COLOR_STATE = 10,
DISPLAYCONFIG_DEVICE_INFO_FORCE_UINT32 = 0xFFFFFFFF
} DISPLAYCONFIG_DEVICE_INFO_TYPE;
DisplayConfigSetDeviceInfo()作为参数的DISPLAYCONFIG_DEVICE_INFO_HEADER结构体的字节；当从系统设置应用程序更改DPI缩放时（尝试设置150%的DPI缩放）。DisplayConfigSetDeviceInfo()。
然后，我将我的DPI缩放改回100%，并运行了我的代码。果然，在运行代码后，DPI缩放确实发生了变化！BYTE buf[] = { 0xFC,0xFF,0xFF,0xFF,0x18,0x00,0x00,0x00,0xAE,0xCB,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00 };
DISPLAYCONFIG_DEVICE_INFO_HEADER* packet = (DISPLAYCONFIG_DEVICE_INFO_HEADER*)buf;
DisplayConfigSetDeviceInfo(packet);
BYTE buf[] = { 0xFC,0xFF,0xFF,0xFF,0x18,0x00,0x00,0x00,0xAE,0xCB,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00 };
SetDPIScaling(monitor_LUID, DPIScale_percent)。
如果我们检查@Dodge回答中提到的注册表项，我们就会知道这些整数被存储为DWORD，并且由于我的计算机是小端字节序，这意味着最后4个字节（第21到24个字节）被用于它们。因此，要发送负数，我们必须使用DWORD的二进制补码，并将字节写成小端字节序。
我还在研究Windows如何生成用于存储DPI缩放值的监视器ID。对于任何监视器，用户选择的DPI缩放值存储在：
HKEY_CURRENT_USER\Control Panel\Desktop\PerMonitorSettings\
*MonitorID*
DELA0BC9DRXV68A0LWL_21_07E0_33^7457214C9330EFC0300669BF736A5297。
我能够弄清楚监视器ID的结构。我用四个不同的显示器验证了我的理论。HKEY_CURRENT_USER\Control Panel\Desktop\PerMonitorSettings\ DELA0BC9DRXV68A0LWL_21_07E0_33^7457214C9330EFC0300669BF736A5297），如下所示（很抱歉添加了图片，无法找到一种简洁地表示信息的方法）。
如果构建监视器标识所需的某些数据不存在，则操作系统使用备用方法。根据我在我的Windows 10机器上观察到的情况，构建监视器标识所需的每个数据的备用方法在上面的列表中给出。我手动编辑了我的DELL显示器的EDID（link1 link2，link3 - 注意 - 链接3中建议的方法可能会损坏您的系统，只有确定后才继续；链接1是最推荐的），删除了上面提到的所有6个项目，操作系统为我构建的监视器标识（没有MD5后缀）是@@@0000810309452_00_0000_85，当我甚至删除了第12字节的序列号时，构建的监视器标识是@@@00000_00_0000_A4。
DisplayConfigGetDeviceInfo()和DisplayConfigSetDeviceInfo()中使用的id参数是源ID，而不是目标ID。DisplayConfigGetDeviceInfo与另一个未记录的参数：-7来构建它，如此处所述 - https://dev59.com/gVsW5IYBdhLWcg3wO1GN#76786955
C++ API 获取/设置 DPI。我成功地反向工程了系统设置应用程序，并设计出了一个 API。它的代码在我的 GitHub 存储库中 https://github.com/lihas/windows-DPI-scaling-sample。
由于我在之前回答此问题时已经解释了很多术语，因此在本答案中我省略了很多解释（https://dev59.com/gVsW5IYBdhLWcg3wO1GN#57397039）。
使用 adapterID 和 sourceID 调用 DPIScalingInfo()。
DpiHelper::DPIScalingInfo DpiHelper::GetDPIScalingInfo(LUID adapterID, UINT32 sourceID)
调用SetDPIScaling()函数，并传入适配器ID、源ID和所需设置的百分比DPI缩放值。例如，如果要将某个源的DPI缩放设置为175％，请在最后一个参数中传入175。
bool DpiHelper::SetDPIScaling(LUID adapterID, UINT32 sourceID, UINT32 dpiPercentToSet)
这个仓库中的DpiHelper.h文件有这两种方法的详细文档。
还要阅读DpiHelper.h和仓库中的README文档。 我已经将该仓库中的所有代码发布到公共领域，因此您可以按照任何方式使用它。
我还创建了一个MFC应用程序，该应用程序使用此辅助库来获取/设置DPI缩放。 这将帮助您了解如何使用DpiHelper类。
这是它的外观。
我使用了WinDbg Preview（MS Store）和Ghidra进行反向工程。当我因缺乏IDA Pro许可证而放弃时，有人建议我使用Ghidra。从那时起，我一直是它的粉丝。
非常感谢Ghidra！！！
SPI_SETLOGICALDPIOVERRIDE
从 Microsoft doc 中了解更多：SPI_SETLOGICALDPIOVERRIDE Do not use.
0x009F
使用方法：
SystemParametersInfo(SPI_SETLOGICALDPIOVERRIDE, relativeIndex, (LPVOID)0, 1);
relativeIndex变量使用什么值，您必须了解操作系统希望如何指定DPI缩放值（在此处解释）。relativeIndex表示您要超过或低于推荐的DPI缩放值多少步。例如，如果推荐的DPI缩放值为125％，而您想将缩放设置为150％，则relativeIndex将为1（超过125％的一步），如果您想将缩放设置为100％，则relativeIndex将为-1（低于125％的一步）。100,125,150,175,200,225,250,300,350, 400, 450, 500
SPI_GETLOGICALDPIOVERRIDE参数。SystemParametersInfo(SPI_GETLOGICALDPIOVERRIDE, 0, (LPVOID)&dpi, 1);
#include <iostream>
#include <Windows.h>
using namespace std;
static const UINT32 DpiVals[] = { 100,125,150,175,200,225,250,300,350, 400, 450, 500 };
/*Get default DPI scaling percentage.
The OS recommented value.
*/
int GetRecommendedDPIScaling()
{
int dpi = 0;
auto retval = SystemParametersInfo(SPI_GETLOGICALDPIOVERRIDE, 0, (LPVOID)&dpi, 1);
if (retval != 0)
{
int currDPI = DpiVals[dpi * -1];
return currDPI;
}
return -1;
}
void SetDpiScaling(int percentScaleToSet)
{
int recommendedDpiScale = GetRecommendedDPIScaling();
if (recommendedDpiScale > 0)
{
int index = 0, recIndex = 0, setIndex = 0 ;
for (const auto& scale : DpiVals)
{
if (recommendedDpiScale == scale)
{
recIndex = index;
}
if (percentScaleToSet == scale)
{
setIndex = index;
}
index++;
}
int relativeIndex = setIndex - recIndex;
SystemParametersInfo(SPI_SETLOGICALDPIOVERRIDE, relativeIndex, (LPVOID)0, 1);
}
}
int main()
{
for (;;)
{
int n = 0, dpiToSet = 0;
cout << R"(
1. Show Recommended DPI
2. Set DPI
Anything else to exit
)";
cin >> n;
switch (n)
{
case 1:
cout << "recommened scaling: " << GetRecommendedDPIScaling() << "%" << endl;
break;
case 2:
cout << "enter scaling to set in percentage" << endl;
cin >> dpiToSet;
SetDpiScaling(dpiToSet);
break;
default:
exit(0);
break;
}
}
return 0;
}
源代码：https://github.com/lihas/windows-DPI-scaling-sample。
这是一个示例运行。
优点和缺点
相对于我之前的方法（https://dev59.com/gVsW5IYBdhLWcg3wO1GN#58066736, https://dev59.com/gVsW5IYBdhLWcg3wO1GN#57397039）
优点
缺点
在多显示器设置中无法设置非主显示器的 DPI 缩放。虽然您可以使用其他操作系统 API 来获取当前应用的 DPI 缩放，但它本身并不返回。在寻找同样问题的解决方案时，我发现了您的问题并找到了一个可能的解决方案。
我发现在注册表中通过Computer\HKEY_CURRENT_USER\Control Panel\Desktop\PerMonitorSettings\*monitorId*\DpiValue可以设置每个显示器的百分比值。该值的含义似乎取决于屏幕的大小和dpi。有关详细信息，请参见此Reddit帖子。
对于我的24英寸1080p屏幕，0表示100％，1表示125％。 此Technet文章似乎解释了这些值。
不幸的是，仅更改注册表值还不足以解决问题。但是，您可以通过更改分辨率来刷新dpi。
以下代码设置dpi，然后将分辨率调低再恢复高来触发dpi更新。
using System;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using Microsoft.Win32;
namespace SetDpiScale
{
public partial class Form1 : Form
{
public enum DMDO
{
DEFAULT = 0,
D90 = 1,
D180 = 2,
D270 = 3
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
struct DEVMODE
{
public const int DM_PELSWIDTH = 0x80000;
public const int DM_PELSHEIGHT = 0x100000;
private const int CCHDEVICENAME = 32;
private const int CCHFORMNAME = 32;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCHDEVICENAME)]
public string dmDeviceName;
public short dmSpecVersion;
public short dmDriverVersion;
public short dmSize;
public short dmDriverExtra;
public int dmFields;
public int dmPositionX;
public int dmPositionY;
public DMDO dmDisplayOrientation;
public int dmDisplayFixedOutput;
public short dmColor;
public short dmDuplex;
public short dmYResolution;
public short dmTTOption;
public short dmCollate;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCHFORMNAME)]
public string dmFormName;
public short dmLogPixels;
public int dmBitsPerPel;
public int dmPelsWidth;
public int dmPelsHeight;
public int dmDisplayFlags;
public int dmDisplayFrequency;
public int dmICMMethod;
public int dmICMIntent;
public int dmMediaType;
public int dmDitherType;
public int dmReserved1;
public int dmReserved2;
public int dmPanningWidth;
public int dmPanningHeight;
}
[DllImport("user32.dll", CharSet = CharSet.Auto)]
static extern int ChangeDisplaySettings([In] ref DEVMODE lpDevMode, int dwFlags);
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
ChangeDPI(0); // 100%
}
private void button2_Click(object sender, EventArgs e)
{
ChangeDPI(1); // 125%
}
void ChangeDPI(int dpi)
{
RegistryKey key = Registry.CurrentUser.OpenSubKey("Control Panel", true);
key = key.OpenSubKey("Desktop", true);
key = key.OpenSubKey("PerMonitorSettings", true);
key = key.OpenSubKey("*monitor id where to change the dpi*", true); // my second monitor here
key.SetValue("DpiValue", dpi);
SetResolution(1920, 1080); // this sets the resolution on primary screen
SetResolution(2560, 1440); // returning back to my primary screens default resolution
}
private static void SetResolution(int w, int h)
{
long RetVal = 0;
DEVMODE dm = new DEVMODE();
dm.dmSize = (short)Marshal.SizeOf(typeof(DEVMODE));
dm.dmPelsWidth = w;
dm.dmPelsHeight = h;
dm.dmFields = DEVMODE.DM_PELSWIDTH | DEVMODE.DM_PELSHEIGHT;
RetVal = ChangeDisplaySettings(ref dm, 0);
}
}
}
除了Sahil Singh的答案，我们还可以在以下位置找到MonitorIDs：HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\GraphicsDrivers\ScaleFactors中的subkeys。
stdafx.h:
#pragma once
#include "targetver.h"
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
// Windows Header Files
#include <windows.h>
// reference additional headers your program requires here
#ifdef __cplusplus
extern "C" {
#endif
extern __declspec(dllexport) void PrintDpiInfo();
extern __declspec(dllexport) void SetDPIScaling(INT32 adapterIDHigh, UINT32 adapterIDlow, UINT32 sourceID, UINT32 dpiPercentToSet);
extern __declspec(dllexport) void RestoreDPIScaling();
#ifdef __cplusplus
}
#endif
DpiHelper.cpp:
// DpiHelper.cpp : Defines the exported functions for the DLL application.
//
#include "stdafx.h"
#include "DpiHelper.h"
#include <memory>
#include <cassert>
#include <string>
#include <map>
bool DpiHelper::GetPathsAndModes(std::vector<DISPLAYCONFIG_PATH_INFO>& pathsV, std::vector<DISPLAYCONFIG_MODE_INFO>& modesV, int flags)
{
UINT32 numPaths = 0, numModes = 0;
auto status = GetDisplayConfigBufferSizes(flags, &numPaths, &numModes);
if (ERROR_SUCCESS != status)
{
return false;
}
std::unique_ptr<DISPLAYCONFIG_PATH_INFO[]> paths(new DISPLAYCONFIG_PATH_INFO[numPaths]);
std::unique_ptr<DISPLAYCONFIG_MODE_INFO[]> modes(new DISPLAYCONFIG_MODE_INFO[numModes]);
status = QueryDisplayConfig(flags, &numPaths, paths.get(), &numModes, modes.get(), nullptr);
if (ERROR_SUCCESS != status)
{
return false;
}
for (unsigned int i = 0; i < numPaths; i++)
{
pathsV.push_back(paths[i]);
}
for (unsigned int i = 0; i < numModes; i++)
{
modesV.push_back(modes[i]);
}
return true;
}
DpiHelper::DpiHelper()
{
}
DpiHelper::~DpiHelper()
{
}
DpiHelper::DPIScalingInfo DpiHelper::GetDPIScalingInfo(LUID adapterID, UINT32 sourceID)
{
DPIScalingInfo dpiInfo = {};
DpiHelper::DISPLAYCONFIG_SOURCE_DPI_SCALE_GET requestPacket = {};
requestPacket.header.type = (DISPLAYCONFIG_DEVICE_INFO_TYPE)DpiHelper::DISPLAYCONFIG_DEVICE_INFO_TYPE_CUSTOM::DISPLAYCONFIG_DEVICE_INFO_GET_DPI_SCALE;
requestPacket.header.size = sizeof(requestPacket);
assert(0x20 == sizeof(requestPacket));//if this fails => OS has changed somthing, and our reverse enginnering knowledge about the API is outdated
requestPacket.header.adapterId = adapterID;
requestPacket.header.id = sourceID;
auto res = ::DisplayConfigGetDeviceInfo(&requestPacket.header);
if (ERROR_SUCCESS == res)
{//success
if (requestPacket.curScaleRel < requestPacket.minScaleRel)
{
requestPacket.curScaleRel = requestPacket.minScaleRel;
}
else if (requestPacket.curScaleRel > requestPacket.maxScaleRel)
{
requestPacket.curScaleRel = requestPacket.maxScaleRel;
}
std::int32_t minAbs = abs((int)requestPacket.minScaleRel);
if (DpiHelper::CountOf(DpiVals) >= (size_t)(minAbs + requestPacket.maxScaleRel + 1))
{//all ok
dpiInfo.current = DpiVals[minAbs + requestPacket.curScaleRel];
dpiInfo.recommended = DpiVals[minAbs];
dpiInfo.maximum = DpiVals[minAbs + requestPacket.maxScaleRel];
dpiInfo.bInitDone = true;
}
else
{
//Error! Probably DpiVals array is outdated
return dpiInfo;
}
}
else
{
//DisplayConfigGetDeviceInfo() failed
return dpiInfo;
}
return dpiInfo;
}
std::wstring GetTargetName(LUID adapterLUID, UINT32 sourceId)
{
std::vector<DISPLAYCONFIG_PATH_INFO> pathsV;
std::vector<DISPLAYCONFIG_MODE_INFO> modesV;
int flags = QDC_ONLY_ACTIVE_PATHS;
if (false == DpiHelper::GetPathsAndModes(pathsV, modesV, flags))
{
wprintf(L"DpiHelper::GetPathsAndModes() failed\r\n");
}
for (const auto& path : pathsV)
{
if (adapterLUID.LowPart == path.targetInfo.adapterId.LowPart
&& adapterLUID.HighPart == path.targetInfo.adapterId.HighPart
&& sourceId == path.sourceInfo.id)
{
DISPLAYCONFIG_TARGET_DEVICE_NAME deviceName;
deviceName.header.size = sizeof(deviceName);
deviceName.header.type = DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME;
deviceName.header.adapterId = adapterLUID;
deviceName.header.id = path.targetInfo.id;
if (ERROR_SUCCESS != DisplayConfigGetDeviceInfo(&deviceName.header))
{
wprintf(L"DisplayConfigGetDeviceInfo() failed\r\n");
}
else
{
std::wstring nameString = deviceName.monitorFriendlyDeviceName;
if (DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL == deviceName.outputTechnology)
{
nameString += L"(internal display)";
}
return nameString;
}
}
}
return L"N/A";
}
void printOne(LUID adapterLUID, UINT32 sourceID) {
wprintf(L"GPU=%ld.%u,Desktop_Index_In_GPU=%d,Monitor=%ls\r\n"
,adapterLUID.HighPart
, adapterLUID.LowPart
, sourceID
, GetTargetName(adapterLUID, sourceID).data());
}
bool DpiHelper::SetDPIScaling(LUID adapterID, UINT32 sourceID, UINT32 dpiPercentToSet)
{
wprintf(L"setting dpi scale to %d: ", dpiPercentToSet);
printOne(adapterID, sourceID);
DPIScalingInfo dPIScalingInfo = GetDPIScalingInfo(adapterID, sourceID);
if (dpiPercentToSet == dPIScalingInfo.current)
{
return true;
}
if (dpiPercentToSet < dPIScalingInfo.mininum)
{
dpiPercentToSet = dPIScalingInfo.mininum;
}
else if (dpiPercentToSet > dPIScalingInfo.maximum)
{
dpiPercentToSet = dPIScalingInfo.maximum;
}
int idx1 = -1, idx2 = -1;
int i = 0;
for (const auto& val : DpiVals)
{
if (val == dpiPercentToSet)
{
idx1 = i;
}
if (val == dPIScalingInfo.recommended)
{
idx2 = i;
}
i++;
}
if ((idx1 == -1) || (idx2 == -1))
{
//Error cannot find dpi value
return false;
}
int dpiRelativeVal = idx1 - idx2;
DpiHelper::DISPLAYCONFIG_SOURCE_DPI_SCALE_SET setPacket = {};
setPacket.header.adapterId = adapterID;
setPacket.header.id = sourceID;
setPacket.header.size = sizeof(setPacket);
assert(0x18 == sizeof(setPacket));//if this fails => OS has changed somthing, and our reverse enginnering knowledge about the API is outdated
setPacket.header.type = (DISPLAYCONFIG_DEVICE_INFO_TYPE)DpiHelper::DISPLAYCONFIG_DEVICE_INFO_TYPE_CUSTOM::DISPLAYCONFIG_DEVICE_INFO_SET_DPI_SCALE;
setPacket.scaleRel = (UINT32)dpiRelativeVal;
auto res = ::DisplayConfigSetDeviceInfo(&setPacket.header);
if (ERROR_SUCCESS == res)
{
return true;
}
else
{
return false;
}
return true;
}
#define MAX_ID 10
LUID GpuId[MAX_ID];
UINT32 DesktopIndexInGpu[MAX_ID];
UINT32 oldDPI[MAX_ID];
void PrintDpiInfo() {
std::vector<DISPLAYCONFIG_PATH_INFO> pathsV;
std::vector<DISPLAYCONFIG_MODE_INFO> modesV;
int flags = QDC_ONLY_ACTIVE_PATHS;
if (false == DpiHelper::GetPathsAndModes(pathsV, modesV, flags))
{
wprintf(L"DpiHelper::GetPathsAndModes() failed");
}
int i = 0;
for (const auto& path : pathsV)
{
//get display name
auto adapterLUID = path.targetInfo.adapterId;
auto sourceID = path.sourceInfo.id;
std::wstring monitor_name = GetTargetName(adapterLUID, sourceID);
printOne(adapterLUID, sourceID);
DpiHelper::DPIScalingInfo dpiInfo = DpiHelper::GetDPIScalingInfo(adapterLUID, sourceID);
GpuId[i] = adapterLUID;
DesktopIndexInGpu[i] = sourceID;
oldDPI[i] = dpiInfo.current;
wprintf(L"Available DPI:\r\n");
int curdpi = 0;
for (const auto& dpi : DpiVals)
{
if ((dpi >= dpiInfo.mininum) && (dpi <= dpiInfo.maximum))
wprintf(L" %d\r\n",dpi);
}
wprintf(L" current DPI: %d\r\n",dpiInfo.current);
i++;
if (i >= MAX_ID) {
wprintf(L"To many desktops\r\n");
break;
}
}
}
void SetDPIScaling(INT32 adapterIDHigh, UINT32 adapterIDlow, UINT32 sourceID, UINT32 dpiPercentToSet) {
LUID adapterId;
adapterId.HighPart = adapterIDHigh;
adapterId.LowPart = adapterIDlow;
DpiHelper::SetDPIScaling(adapterId, sourceID, dpiPercentToSet);
}
void RestoreDPIScaling()
{
wprintf(L"Now restore DPI settings...\r\n");
for (int i = 0;i < MAX_ID;i++) {
if (GpuId[i].LowPart == 0 && GpuId[i].HighPart==0) break;
DpiHelper::SetDPIScaling(GpuId[i], DesktopIndexInGpu[i], oldDPI[i]);
}
}
DpiHelper.h与参考答案相同。在Visual Studio中创建一个C++ Dll项目，添加/放置上述代码，并在下面的C#应用程序中使用该dll。
一个C#控制台应用程序，根据命令行参数设置DPI，并在按任意键时恢复它们：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace DispSetEx
{
class Program
{
[DllImport("DpiHelper.dll")]
static public extern void PrintDpiInfo();
[DllImport("DpiHelper.dll")]
static public extern int SetDPIScaling(Int32 adapterIDHigh, UInt32 adapterIDlow, UInt32 sourceID, UInt32 dpiPercentToSet);
[DllImport("DpiHelper.dll")]
static public extern void RestoreDPIScaling();
static void Main(string[] args)
{
if ((args.Length % 3) != 0)
{
Console.WriteLine("wrong parameters");
return;
}
//print the DPI info, you need to set the command line parameters
//according to this
PrintDpiInfo();
//commandline parameters should be of groups of three
//each groups's tree paramters control a desktop's setting
//in each group:
//GPUIdhigh.GPUIdlow DesktopIndexInGPU DPIScalingValue
//for example:
// 0.1234 0 100 //set the DPI scaling to 100 for desktop 0 on GPU 0.1234
// 0.4567 0 125 //set the DPI scaling to 125 for desktop 0 on GPU 0.5678
// 0.4567 1 150 //set the DPI scaling to 150 for desktop 1 on GPU 0.5678
//in most cases GPUIdhigh is 0.
//you can use the monitor name to identify which is which easily
//you need to set the command line parameters according to the result of PrintDpiInfo
//e.g. you should only set the DPI scaling to a value that is supported by
//that desktop.
for (int i = 0; i < args.Length / 3; i++)
{
string[] sa = args[i * 3].Split(new char[] { '.' });
Int32 adapterHigh = Int32.Parse(sa[0]);
UInt32 adapterLow = UInt32.Parse(sa[1]);
UInt32 source = UInt32.Parse(args[i * 3 + 1]);
UInt32 dpiscale = UInt32.Parse(args[i * 3 + 2]);
SetDPIScaling(adapterHigh, adapterLow, source,dpiscale);
}
Console.WriteLine("Press any key to resotre the settings...");
Console.ReadKey();
RestoreDPIScaling();
}
}
}
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\GraphicsDrivers\ScaleFactors\DELA0BC9DRXV68A0LWL_21_07E0_33^7457214C9330EFC0300669BF736A5297, (REG_DWORD) DpiValue
例如（DELA0BC9DRXV68A0LWL_21_07E0_33^7457214C9330EFC0300669BF736A5297），我们可以使用另一个未记录的参数DisplayConfigGetDeviceInfo。monitorUniqueName，它形成了监视器键名中"^"之前的部分，其后面的部分仅是前者的MD5哈希。std::wstring DpiHelper::GetDisplayUniqueName(LUID adapterID, UINT32 targetID)
{
_DISPLAYCONFIG_GET_MONITOR_INTERNAL_INFO mi = {};
mi.header.adapterId = adapterID;
mi.header.id = targetID;
mi.header.size = sizeof(mi);
mi.header.type = (DISPLAYCONFIG_DEVICE_INFO_TYPE)-7;
LONG res = ::DisplayConfigGetDeviceInfo(&mi.header);
if (ERROR_SUCCESS == res)
{
return std::wstring(mi.monitorUniqueName);
}
return std::wstring();
}
使用的结构体定义可以在此处找到 - https://github.com/lihas/WindowsUndocumentedLib
生成此独特字符串的示例应用程序可以在此处找到 - https://github.com/lihas/windows-DPI-scaling-sample
DpiValue注册数据中设置的值是相对于推荐的DPI缩放比例的，所以如果推荐的缩放比例为250%，而您想将新的缩放比例设置为225%，则将DpiValue设置为0xffffffff，即DWORD(-1)，同样地，对于300%，它将是1。Computer\HKEY_CURRENT_USER\Control Panel\Desktop\PerMonitorSettings\下创建具有此结果和字符串的regkey，并设置DpiValue数据。然后注销当前用户并重新登录（或执行重启）。