更改屏幕的滤色器以与多个显示器一起使用

Question

我已经编写了一个程序来更改屏幕的滤色器，类似于 Flux 的方式（执行此操作的代码在主要问题中）。但是，我的几个用户说它不会影响另一个 screen/s 有两个或更多显示器。我将如何修改代码以使其生效？

Answer 1

你可以通过

获取所有连接的显示器
将您的获取/设置函数应用于图形（或其 Hdc）。
正在注册 MonitorInfoInvalidated 事件以重新申请，如果监视器信息失效。

如果您已经对 Windows.Forms dll 有依赖性，或者不介意接受这个依赖性，您可以使用它的 Screen class for this as @HansPassant pointed out in his . In this case you would register an eventhandler for the SystemEvents.DisplaySettingsChanged to trigger re-applying your get/set functions, and you would use interop calls to CreateDC and DeleteDC to get/release a device context handle (IntPtr) from the Screen.DeviceName 属性。下面的代码显示了一个围绕这个 class 的包装器，它有助于做到这一点：

/// <summary>
/// This is an alternative that uses the Windows.Forms Screen class.
/// </summary>
public static class FormsScreens
{
    public static void ForAllScreens(Action<Screen, IntPtr> actionWithHdc)
    {
        foreach (var screen in Screen.AllScreens)
            screen.WithHdc(actionWithHdc);

    }

    public static void WithHdc(this Screen screen, Action<Screen, IntPtr> action)
    {
        var hdc = IntPtr.Zero;
        try
        {
            hdc = CreateDC(null, screen.DeviceName, null, IntPtr.Zero);
            action(screen, hdc);
        }
        finally
        {
            if (!IntPtr.Zero.Equals(hdc))
                DeleteDC(hdc);
        }
    }

    private const string GDI32 = @"gdi32.dll";

    [DllImport(GDI32, EntryPoint = "CreateDC", CharSet = CharSet.Auto)]
    static extern IntPtr CreateDC(string lpszDriver, string lpszDevice, string lpszOutput, IntPtr lpInitData);

    [DllImport(GDI32, CharSet = CharSet.Auto)]
    private static extern bool DeleteDC([In] IntPtr hdc);
}

如果您不想对 Windows.Forms dll 产生新的依赖，下面的 ConnectedMonitors class 提供了相同类型的功能：

/// <summary>
/// This is the version that is not dependent on Windows.Forms dll.
/// </summary>
public static class ConnectedMonitors
{
    private static readonly bool _isSingleMonitor = GetSystemMetrics(SM_CMONITORS) == 0;
    private static Lazy<List<MonitorInfo>> _monitors = new Lazy<List<MonitorInfo>>(GetMonitors, true);

    public static event Action MonitorInfoInvalidated;

    public class MonitorInfo
    {
        public readonly IntPtr MonitorHandle;
        public readonly IntPtr DeviceContextHandle;
        public readonly string DeviceName;
        public readonly bool IsPrimary;
        public readonly Rectangle Bounds;
        public readonly Rectangle WorkArea;

        public void WithMonitorHdc(Action<MonitorInfo, IntPtr> action)
        {
            var hdc = DeviceContextHandle;
            var shouldDeleteDC = IntPtr.Zero.Equals(hdc);
            try
            {
                if (shouldDeleteDC)
                    hdc = CreateDC(null, DeviceName, null, IntPtr.Zero);
                action(this, hdc);
            }
            finally
            {
                if (shouldDeleteDC && !IntPtr.Zero.Equals(hdc))
                    DeleteDC(hdc);
            }
        }

        internal MonitorInfo(
            IntPtr hMonitor, 
            IntPtr hDeviceContext, 
            string deviceName,
            bool isPrimary,
            Rectangle bounds,
            Rectangle workArea)
        {
            this.MonitorHandle = hMonitor;
            this.DeviceContextHandle = hDeviceContext;
            this.DeviceName = deviceName;
            this.IsPrimary = isPrimary;
            this.Bounds = bounds;
            this.WorkArea = workArea;
        }
    }

    public static void CaptureScreen(MonitorInfo mi, string fileName)
    {
        CaptureScreen(mi).Save(fileName);
    }

    public static Bitmap CaptureScreen(MonitorInfo mi)
    {
        Bitmap screenBmp = default(Bitmap);
        mi.WithMonitorHdc((m, hdc) =>
        {
            screenBmp = new Bitmap(m.Bounds.Width, m.Bounds.Height, PixelFormat.Format32bppArgb);
            using (var destGraphics = Graphics.FromImage(screenBmp))
            {
                var monitorDC = new HandleRef(null, hdc);
                var destDC = new HandleRef(null, destGraphics.GetHdc());
                var result = BitBlt(destDC, 0, 0, m.Bounds.Width, m.Bounds.Height, monitorDC, 0, 0, unchecked((int)BITBLT_SRCCOPY));
                if (result == 0)
                    throw new Win32Exception();
            }
        });
        return screenBmp;
    }

    public static IEnumerable<MonitorInfo> Monitors
    {
        get { return _monitors.Value; }
    }

    private static List<MonitorInfo> GetMonitors()
    {
        // Get info on all monitors
        var cb = new EnumMonitorsCallback();
        EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, cb.Callback, IntPtr.Zero);

        // Register for events invalidating monitor info.
        SystemEvents.DisplaySettingsChanging += OnDisplaySettingsChanging;
        SystemEvents.UserPreferenceChanged += OnUserPreferenceChanged;

        // Return result.
        return cb.Monitors;
    }

    private class EnumMonitorsCallback
    {
        public List<MonitorInfo> Monitors = new List<MonitorInfo>();

        public bool Callback(IntPtr hMonitor, IntPtr hdcMonitor, ref RECT lprcMonitor, IntPtr lparam)
        {
            // Get its info
            var info = new MONITORINFOEX();
            info.Size = Marshal.SizeOf(typeof(MONITORINFOEX));
            GetMonitorInfo(hMonitor, ref info);

            // Decode the info
            var isPrimary = (hMonitor == (IntPtr)PRIMARY_MONITOR) || ((info.Flags & MONITORINFOF_PRIMARY) != 0);
            var bounds = Rectangle.FromLTRB(info.Monitor.Left, info.Monitor.Top, info.Monitor.Right, info.Monitor.Bottom);
            var workArea = Rectangle.FromLTRB(info.WorkArea.Left, info.WorkArea.Top, info.WorkArea.Right, info.WorkArea.Bottom);
            var deviceName = info.DeviceName.TrimEnd('[=11=]');

            // Create info for this monitor and add it.
            Monitors.Add(new MonitorInfo(hMonitor, hdcMonitor, deviceName, isPrimary, bounds, workArea));
            return true;
        }
    }

    private static void OnDisplaySettingsChanging(object sender, EventArgs e)
    {
        InvalidateInfo();
    }

    private static void OnUserPreferenceChanged(object sender, UserPreferenceChangedEventArgs e)
    {
        InvalidateInfo();
    }

    private static void InvalidateInfo()
    {
        SystemEvents.DisplaySettingsChanging -= OnDisplaySettingsChanging;
        SystemEvents.UserPreferenceChanged -= OnUserPreferenceChanged;
        var cur = _monitors;
        _monitors = new Lazy<List<MonitorInfo>>(GetMonitors, true);
        var notifyInvalidated = MonitorInfoInvalidated;
        if (notifyInvalidated != null)
            notifyInvalidated();
    }

    #region Interop

    private const string USER32 = @"user32.dll";
    private const string GDI32 = @"gdi32.dll";
    private const int PRIMARY_MONITOR = unchecked((int)0xBAADF00D);
    private const int MONITORINFOF_PRIMARY = 0x00000001;
    private const int SM_CMONITORS = 80;
    private const int BITBLT_SRCCOPY = 0x00CC0020;
    private const int BITBLT_CAPTUREBLT = 0x40000000;
    private const int BITBLT_CAPTURE = BITBLT_SRCCOPY | BITBLT_CAPTUREBLT;

    [StructLayout(LayoutKind.Sequential)]
    private struct RECT
    {
        public int Left;
        public int Top;
        public int Right;
        public int Bottom;
    }

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
    private struct MONITORINFOEX
    {
        public int Size;
        public RECT Monitor;
        public RECT WorkArea;
        public uint Flags;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
        public string DeviceName;
    }

    delegate bool EnumMonitorsDelegate(IntPtr hMonitor, IntPtr hdcMonitor, ref RECT lprcMonitor, IntPtr dwData);

    [DllImport(USER32, CharSet=CharSet.Auto)]
    private static extern bool EnumDisplayMonitors(IntPtr hdc, IntPtr lprcClip, EnumMonitorsDelegate lpfnEnum, IntPtr dwData);

    [DllImport(USER32, CharSet = CharSet.Auto)]
    private static extern bool GetMonitorInfo(IntPtr hMonitor, ref MONITORINFOEX lpmi);

    [DllImport(USER32, CharSet = CharSet.Auto)]
    private static extern int GetSystemMetrics(int nIndex);

    [DllImport(GDI32, EntryPoint = "CreateDC", CharSet = CharSet.Auto)]
    static extern IntPtr CreateDC(string lpszDriver, string lpszDevice, string lpszOutput, IntPtr lpInitData);

    [DllImport(GDI32, CharSet = CharSet.Auto)]
    private static extern bool DeleteDC([In] IntPtr hdc);

    [DllImport(GDI32, CharSet = CharSet.Auto)]
    public static extern int BitBlt(HandleRef hDC, int x, int y, int nWidth, int nHeight,
                                    HandleRef hSrcDC, int xSrc, int ySrc, int dwRop);
    #endregion
}

您的用例的使用示例，使用略微修改的 SetLCDbrightness 方法：

private bool SetLCDbrightness(IntPtr hdc, Color c)
{
    short red = c.R;
    short green = c.G;
    short blue = c.B;

    unsafe
    {
        short* gArray = stackalloc short[3 * 256];
        short* idx = gArray;
        short brightness = 0;
        for (int j = 0; j < 3; j++)
        {
            if (j == 0) brightness = red;
            if (j == 1) brightness = green;
            if (j == 2) brightness = blue;
            for (int i = 0; i < 256; i++)
            {
                int arrayVal = i * (brightness);
                if (arrayVal > 65535) arrayVal = 65535;
                *idx = (short)arrayVal;
                idx++;
            }
        }
        // For some reason, this always returns false?
        bool retVal = SetDeviceGammaRamp(hdc, gArray);
    }
    return false;
}

被称为：

// ConnectedMonitors variant
public void SetBrightness(Color c)
{
    foreach (var monitor in ConnectedMonitors.Monitors)
        monitor.WithMonitorHdc((m, hdc) => SetLCDbrightness(hdc, c));
}

// Variant using the Windows.Forms Screen class
public void SetBrightness(Color c)
{
    var setBrightness = new Action<Screen, IntPtr>((s, hdc) => SetLCDbrightness(hdc, c));
    FormsScreens.ForAllScreens(setBrightness);
}

请注意，它允许进行一些其他有趣的操作，例如截图：

var n = 0;
foreach (var m in ConnectedMonitors.Monitors)
    ConnectedMonitors.CaptureScreen(m, string.Format(@"c:\temp\screen{0}.bmp", n++));

Answer 2

当机器有多个显示适配器时，您的代码无法工作，这种情况并不少见。所以 GetDC() 不正确，您需要改为调用 CreateDC()，将屏幕名称（如 @"\.\DISPLAY1"）作为第一个参数传递，其余为空。使用 DeleteDC() 进行清理。

使用 Screen.DeviceName property to get the device name, Screen.AllScreens() 枚举监视器。你可能应该订阅 SystemEvents.DisplaySettingsChanged 事件来检测用户是否启用了监视器，我没有硬件来检查这个。

更改屏幕的滤色器以与多个显示器一起使用

Change colour filter of screen to work with multiple monitors

c#

graphics

interop

multiple-monitors

gdi