DisplayIds from the module don't match the Ids in display settings

[MartinGC94]

Ideally the display IDs used by this module would mirror the IDs listed in display settings for a consistent user experience. Unfortunately I haven't been able to determine the logic they use to set the IDs so I've had to invent my own logic. The logic simply sorts by display adapter and then gives a custom priority number based on the connector type and connection instance number, prioritizing typical "PC" connection types over others. See: https://github.com/MartinGC94/DisplayConfig/blob/main/src/DisplayConfig/API/DisplayConfig.cs#L152

Methods I've tried:
1: The following registry keys seem promising in providing the data but they are not readable by a standard user so it's not a viable solution:
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\GraphicsDrivers\Configuration
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\GraphicsDrivers\Connectivity

2: Sorting by the monitor UIDs listed in the device path like: \?\DISPLAY#LGD06B1#4&8bc03bf&0&UID8388688#{e6f07b5f-ee97-4a90-b076-33f57bf4eaa7} the order was completely out of wack on all my test systems.

3: Simply going in the order of the paths returned by QueryDisplayConfig. Disabled paths are put after the live paths so disabling or enabling a display would make the ID assignments inconsistent. This is obviously bad.

4: The registry key HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\monitor\Enum is readable but the order doesn't always line up with the settings app.

If someone happens to know the logic and can share it here I would be happy to try and implement it in the module. For now though, the custom priority logic I've come up with seems to get reasonably close on most systems.

[Rtw915]

Research Attempted to Retrieve Monitor Display IDs

In an effort to gather monitor-related information, I conducted a series of investigations, though the results were not as fruitful as anticipated. Below are the methods I explored:

1. Using WMI to Retrieve Monitor ID Information:
   I attempted to query the WmiMonitorID class in the root\wmi namespace to retrieve monitor-specific data:

   Get-CimInstance -Namespace root\wmi -ClassName WmiMonitorID | Select-Object *

2. Using .NET Framework to Access Screen Information:
   I attempted to load the System.Windows.Forms.Screen assembly and utilized its AllScreens property to retrieve details about all screens connected to the system:

   [void] [System.Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms.Screen.AllScreens")
   [System.Windows.Forms.Screen]::AllScreens

3. Querying for Monitor Devices Using CIM:
   I queried the Win32_PNPEntity class, filtering for entities where the service was identified as "monitor":

   Get-CimInstance -ClassName Win32_PNPEntity | Where-Object { $_.Service -eq "monitor" }

4. Querying Desktop Monitors Using CIM:
   I queried the Win32_DesktopMonitor class to gather additional monitor information:

   Get-CimInstance -ClassName Win32_DesktopMonitor -Property *

5. Querying Video Controller Information:
   I explored video controller details through the Win32_VideoController class:

   Get-WmiObject -Class Win32_VideoController

6. Custom C# Code for Monitor Information:
   In addition to the PowerShell commands, I embedded custom C# code to query monitor properties such as device name, model, resolution, refresh rate, and bit depth. The code utilizes the EnumDisplayDevices and EnumDisplaySettings methods from the user32.dll library.

Here’s the embedded C# code

using System;
using System.Runtime.InteropServices;
using System.Collections.Generic;

namespace Resolution
{
    [Flags()]
    public enum DisplayDeviceStateFlags : int
    {
        AttachedToDesktop = 0x1,
        MultiDriver = 0x2,
        PrimaryDevice = 0x4,
        MirroringDriver = 0x8,
        VGACompatible = 0x10,
        Removable = 0x20,
        ModesPruned = 0x8000000,
        Remote = 0x4000000,
        Disconnect = 0x2000000
    }

    [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi)]
    public struct DISPLAY_DEVICE
    {
        [MarshalAs(UnmanagedType.U4)]
        public int cb;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst=32)]
        public string DeviceName;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst=128)]
        public string DeviceString;
        [MarshalAs(UnmanagedType.U4)]
        public DisplayDeviceStateFlags StateFlags;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst=128)]
        public string DeviceID;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst=128)]
        public string DeviceKey;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct DEVMODE1
    {
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
        public string dmDeviceName;
        public short dmSpecVersion;
        public short dmDriverVersion;
        public short dmSize;
        public short dmDriverExtra;
        public int dmFields;
        public short dmOrientation;
        public short dmPaperSize;
        public short dmPaperLength;
        public short dmPaperWidth;
        public short dmScale;
        public short dmCopies;
        public short dmDefaultSource;
        public short dmPrintQuality;
        public short dmColor;
        public short dmDuplex;
        public short dmYResolution;
        public short dmTTOption;
        public short dmCollate;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
        public string dmFormName;
        public short dmLogPixels;
        public short 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;
    }

    class User_32
    {
        [DllImport("user32.dll")]
        public static extern bool EnumDisplayDevices(string lpDevice, uint iDevNum, ref DISPLAY_DEVICE lpDisplayDevice, uint dwFlags);

        [DllImport("user32.dll")]
        public static extern int EnumDisplaySettings(string deviceName, int modeNum, ref DEVMODE1 devMode);

        public const int ENUM_CURRENT_SETTINGS = -1;
    }

    public class Displays
    {
        public static IList<string> GetAllDisplayInfo()
        {
            var displayInfoList = new List<string>();
            for(var x = 0U; x < 1024; ++x)
            {
                DISPLAY_DEVICE outVar = new DISPLAY_DEVICE();
                outVar.cb = (short)Marshal.SizeOf(outVar);
                if(User_32.EnumDisplayDevices(null, x, ref outVar, 0U) && (outVar.StateFlags & DisplayDeviceStateFlags.AttachedToDesktop) != 0)
                {
                    string displayID = outVar.DeviceName;
                    string displayModel = outVar.DeviceString;
                    string deviceID = outVar.DeviceID;
                    string resolution = GetCurrentResolution(displayID);
                    string refreshRate = GetRefreshRate(displayID);
                    string bitDepth = GetBitDepth(displayID);
                    string isPrimary = (outVar.StateFlags & DisplayDeviceStateFlags.PrimaryDevice) != 0 ? "Primary" : "Secondary";

                    displayInfoList.Add("Display ID: " + displayID);
                    displayInfoList.Add("Model: " + displayModel);
                    displayInfoList.Add("Device ID: " + deviceID);
                    displayInfoList.Add("Resolution: " + resolution);
                    displayInfoList.Add("Refresh Rate: " + refreshRate);
                    displayInfoList.Add("Bit Depth: " + bitDepth);
                    displayInfoList.Add("Primary Status: " + isPrimary);
                    displayInfoList.Add("------");
                }
            }
            return displayInfoList;
        }

        private static string GetCurrentResolution(string deviceName)
        {
            string returnValue = null;
            DEVMODE1 dm = GetDevMode1();
            if (0 != User_32.EnumDisplaySettings(deviceName, User_32.ENUM_CURRENT_SETTINGS, ref dm))
            {
                returnValue = dm.dmPelsWidth + "x" + dm.dmPelsHeight;
            }
            return returnValue;
        }

        private static string GetRefreshRate(string deviceName)
        {
            string returnValue = null;
            DEVMODE1 dm = GetDevMode1();
            if (0 != User_32.EnumDisplaySettings(deviceName, User_32.ENUM_CURRENT_SETTINGS, ref dm))
            {
                returnValue = dm.dmDisplayFrequency.ToString() + "Hz";
            }
            return returnValue;
        }

        private static string GetBitDepth(string deviceName)
        {
            string returnValue = null;
            DEVMODE1 dm = GetDevMode1();
            if (0 != User_32.EnumDisplaySettings(deviceName, User_32.ENUM_CURRENT_SETTINGS, ref dm))
            {
                returnValue = dm.dmBitsPerPel.ToString() + " bits";
            }
            return returnValue;
        }

        private static DEVMODE1 GetDevMode1()
        {
            DEVMODE1 dm = new DEVMODE1();
            dm.dmDeviceName = new String(new char[32]);
            dm.dmFormName = new String(new char[32]);
            dm.dmSize = (short)Marshal.SizeOf(dm);
            return dm;
        }
    }
}

After executing this code, the following function call provides a list of all connected displays with their respective properties:

Add-Type $Code
[Resolution.Displays]::GetAllDisplayInfo()

---

Additional References:

For further insights on monitor information retrieval, you may find the following resources helpful:

1. [MSDN TechNet: Display Settings]
2. [Stack Overflow: Find Monitor Number and Resolution]
3. [Windows Display Control and Enumeration]
4. [Stack Overflow: Getting Monitor ID to Change Display Settings]
5. [How to get the Monitor number displayed in the system display settings]

[MartinGC94]

@Rtw915 Just to clarify your intent here, I understand that these are just things you've tried but none of them successfully gave the display IDs used by the settings app, correct?
-Edit: I edited your comment to have a collapsible section for the C# code.

[Rtw915]

Hi @MartinGC94, thanks for the edit!

You’re correct, I wasn’t able to retrieve the display IDs shown in the Windows Settings app. My intent was to share my research so that others have a larger foundation to build on. I still think EnumDisplayDevices is the most promising approach, but I haven't managed to implement a working version that directly matches the Settings app identifiers.

If you or anyone else has insights on how to refine this approach, I'd love to collaborate!

[Rtw915]

I tested this on several different workstations, and the results were consistently accurate!

$Code = @"
using System;
using System.Drawing;
using System.Threading;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Collections.Generic; 

namespace Resolution 
{
    [Flags()]
    public enum DisplayDeviceStateFlags : int
    {
        AttachedToDesktop = 0x1,
        MultiDriver = 0x2,
        PrimaryDevice = 0x4,
        MirroringDriver = 0x8,
        VGACompatible = 0x10,
        Removable = 0x20,
        ModesPruned = 0x8000000,
        Remote = 0x4000000,
        Disconnect = 0x2000000
    }

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct DISPLAY_DEVICE
    {
        [MarshalAs(UnmanagedType.U4)]
        public int cb;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
        public string DeviceName;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
        public string DeviceString;
        [MarshalAs(UnmanagedType.U4)]
        public DisplayDeviceStateFlags StateFlags;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
        public string DeviceID;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
        public string DeviceKey;
    }

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct DEVMODE
    {
        [MarshalAs(UnmanagedType.U4)]
        public int dmSize;
        [MarshalAs(UnmanagedType.U4)]
        public int dmPelsWidth;
        [MarshalAs(UnmanagedType.U4)]
        public int dmPelsHeight;
        [MarshalAs(UnmanagedType.U4)]
        public int dmBitsPerPel;
        [MarshalAs(UnmanagedType.U4)]
        public int dmFields;
    }

    public class User_32 
    { 
        [DllImport("user32.dll")]
        public static extern bool EnumDisplaySettings(string deviceName, int modeNum, ref DEVMODE devMode);

        [DllImport("user32.dll")]
        public static extern bool EnumDisplayDevices(string deviceName, uint iDevNum, ref DISPLAY_DEVICE lpDisplayDevice, uint dwFlags);
    }

    public class DisplayOverlay : Form
    {
        private System.Threading.Timer timer;
        private const int ENUM_CURRENT_SETTINGS = -1; // Correct constant

        public DisplayOverlay(int displayNumber)
        {
            this.FormBorderStyle = FormBorderStyle.None;
            this.WindowState = FormWindowState.Maximized;
            this.BackColor = Color.Black;
            this.Opacity = 0.5;  
            this.TopMost = true;
            this.ShowInTaskbar = false;

            Label label = new Label
            {
                Text = displayNumber.ToString(),
                Font = new Font("Arial", 200, FontStyle.Bold),
                ForeColor = Color.White,
                AutoSize = true,
                BackColor = Color.Transparent
            };

            DISPLAY_DEVICE displayDevice = new DISPLAY_DEVICE();
            displayDevice.cb = Marshal.SizeOf(typeof(DISPLAY_DEVICE));
            if (User_32.EnumDisplayDevices(null, (uint)(displayNumber - 1), ref displayDevice, 0))
            {
                Console.WriteLine("DeviceName: " + displayDevice.DeviceName + ", StateFlags: " + displayDevice.StateFlags);

                DEVMODE devMode = new DEVMODE();
                devMode.dmSize = (short)Marshal.SizeOf(typeof(DEVMODE));
                if (User_32.EnumDisplaySettings(displayDevice.DeviceName, ENUM_CURRENT_SETTINGS, ref devMode))
                {
                    Rectangle screenBounds = Screen.AllScreens[displayNumber - 1].Bounds;
                    label.Location = new Point((screenBounds.Width - label.Width) / 2,
                                               (screenBounds.Height - label.Height) / 2);
                }
            }

            this.Controls.Add(label);
        }

        public void ShowForDuration(int durationMs)
        {
            timer = new System.Threading.Timer(CloseOverlay, null, durationMs, Timeout.Infinite);
            Application.Run(this);
        }

        private void CloseOverlay(object state)
        {
            this.Invoke(new Action(() => { this.Close(); }));
        }

        public static void ShowOverlays(int durationMs)
        {
            List<int> displayIndexes = new List<int>();

            // Gather all attached screens and their positions
            List<Screen> attachedScreens = new List<Screen>();
            foreach (var screen in Screen.AllScreens)
            {
                if ((screen.DeviceName != null) && (screen.Bounds.Width > 0 && screen.Bounds.Height > 0))
                {
                    attachedScreens.Add(screen);
                }
            }

            // Sort the screens by their physical positions
            attachedScreens.Sort((a, b) =>
            {
                if (a.Bounds.Top == b.Bounds.Top)
                    return a.Bounds.Left.CompareTo(b.Bounds.Left);  // Sort by X position if Y is the same
                return a.Bounds.Top.CompareTo(b.Bounds.Top);  // Otherwise, sort by Y position
            });

            // Correctly match the display order from EnumDisplayDevices
            for (uint i = 0; i < 1024; i++)
            {
                DISPLAY_DEVICE displayDevice = new DISPLAY_DEVICE();
                displayDevice.cb = Marshal.SizeOf(typeof(DISPLAY_DEVICE));
                if (User_32.EnumDisplayDevices(null, i, ref displayDevice, 0))
                {
                    if ((displayDevice.StateFlags & DisplayDeviceStateFlags.AttachedToDesktop) != 0)
                    {
                        foreach (var screen in attachedScreens)
                        {
                            if (screen.DeviceName == displayDevice.DeviceName)
                            {
                                Console.WriteLine("Matched Device: " + screen.DeviceName + " at screen index " + Array.IndexOf(Screen.AllScreens, screen));
                                int screenIndex = Array.IndexOf(Screen.AllScreens, screen);                                
                                displayIndexes.Add(screenIndex);
                            }
                        }
                    }
                }
            }

            foreach (var index in displayIndexes)
            {
                Console.WriteLine("Detected screen index: " + index);
            }

            Thread[] threads = new Thread[displayIndexes.Count];
            for (int i = 0; i < displayIndexes.Count; i++)
            {
                int currentScreenIndex = displayIndexes[i];
                Console.WriteLine("Launching overlay on screen index: " + currentScreenIndex);  

                threads[i] = new Thread(() =>
                {
                    DisplayOverlay overlay = new DisplayOverlay(currentScreenIndex + 1);
                    overlay.StartPosition = FormStartPosition.Manual;
                    overlay.Location = Screen.AllScreens[currentScreenIndex].Bounds.Location;
                    overlay.ShowForDuration(durationMs);
                });
                threads[i].Start();
            }
        }
    }
}
"@

Add-Type -TypeDefinition $Code -ReferencedAssemblies "System.Windows.Forms", "System.Drawing"

# Start overlays on each display for 10 seconds (10000 milliseconds)
[Resolution.DisplayOverlay]::ShowOverlays(10000)

I might have just gotten lucky. Please let me know your results.

[MartinGC94]

Where'd you get that code from? I find it curious that you didn't trim it down to the bare essentials. From what I can tell, this only works with displays that are a part of the desktop which makes it a dealbreaker. Even if that wasn't the case though, it doesn't seem accurate to me:

It mixes up displays 3 and 4.