Changing Display Settings Programmatically

BOOL EnumDisplaySettings(
    LPCTSTR lpszDeviceName,  // display device
    DWORD iModeNum,          // graphics mode
    [In, Out] LPDEVMODE lpDevMode  // graphics mode settings
);

using System;
using System.Runtime.InteropServices;
public class DisplaySettingsExample
{
    [DllImport("User32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool EnumDisplaySettings(
        [param: MarshalAs(UnmanagedType.LPTStr)]
        string lpszDeviceName,
        [param: MarshalAs(UnmanagedType.U4)]
        int iModeNum,
        [In, Out]
        ref DEVMODE lpDevMode);
    public static void Main(string[] args)
    {
        string deviceName = null;  // Specify the display device (null for the default)
        int modeNum = 0;           // Specify the graphics mode number
        DEVMODE devMode = new DEVMODE();
        devMode.dmSize = (ushort)Marshal.SizeOf(typeof(DEVMODE));  // Initialize the structure size
        bool result = EnumDisplaySettings(deviceName, modeNum, ref devMode);
        if (result)
        {
            Console.WriteLine("Graphics Mode Settings:");
            Console.WriteLine("Width: " + devMode.dmPelsWidth);
            Console.WriteLine("Height: " + devMode.dmPelsHeight);
            // ... other settings ...
        }
        else
        {
            int error = Marshal.GetLastWin32Error();
            Console.WriteLine("EnumDisplaySettings failed with error code: " + error);
        }
    }
[StructLayout(LayoutKind.Sequential)]
public struct DEVMODE
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
    public string dmDeviceName;
    public ushort dmSpecVersion;
    public ushort dmDriverVersion;
    public ushort dmSize;
    public ushort dmDriverExtra;
    public uint dmFields;
    // ... other members ...
    public int dmPelsWidth;
    public int dmPelsHeight;
}

typedef struct DEVMODE {
    BCHAR dmDeviceName[CCHDEVICENAME];
    WORD dmSpecVersion;
    WORD dmDriverVersion;
    WORD dmSize;
    WORD dmDriverExtra;
    DWORD dmFields;
    union {
        struct {
            short dmOrientation;
            short dmPaperSize;
            short dmPaperLength;
            short dmPaperWidth;
            short dmScale;
            short dmCopies;
            short dmDefaultSource;
            short dmPrintQuality;
        };
        POINTL dmPosition;
        DWORD dmDisplayOrientation;
        DWORD dmDisplayFixedOutput;
    };
    short dmColor;
    short dmDuplex;
    short dmYResolution;
    short dmTTOption;
    short dmCollate;
    BYTE dmFormName[CCHFORMNAME];
    WORD dmLogPixels;
    DWORD dmBitsPerPel;
    DWORD dmPelsWidth;
    DWORD dmPelsHeight;
    union {
        DWORD dmDisplayFlags;
        DWORD dmNup;
    };
    DWORD dmDisplayFrequency;
    #if(WINVER >= 0x0400)
        DWORD dmICMMethod;
        DWORD dmICMIntent;
        DWORD dmMediaType;
        DWORD dmDitherType;
        DWORD dmReserved1;
        DWORD dmReserved2;
        #if (WINVER >= 0x0500) || (_WIN32_WINNT >= 0x0400)
            DWORD dmPanningWidth;
            DWORD dmPanningHeight;
        #endif
    #endif / WINVER >= 0x0400 /
} DEVMODE;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct DEVMODE
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
    public string dmDeviceName;
    [MarshalAs(UnmanagedType.U2)]
    public UInt16 dmSpecVersion;
    [MarshalAs(UnmanagedType.U2)]
    public UInt16 dmDriverVersion;
    [MarshalAs(UnmanagedType.U2)]
    public UInt16 dmSize;
    [MarshalAs(UnmanagedType.U2)]
    public UInt16 dmDriverExtra;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmFields;
    public POINTL dmPosition;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmDisplayOrientation;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmDisplayFixedOutput;
    [MarshalAs(UnmanagedType.I2)]
    public Int16 dmColor;
    [MarshalAs(UnmanagedType.I2)]
    public Int16 dmDuplex;
    [MarshalAs(UnmanagedType.I2)]
    public Int16 dmYResolution;
    [MarshalAs(UnmanagedType.I2)]
    public Int16 dmTTOption;
    [MarshalAs(UnmanagedType.I2)]
    public Int16 dmCollate;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
    public string dmFormName;
    [MarshalAs(UnmanagedType.U2)]
    public UInt16 dmLogPixels;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmBitsPerPe
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmPelsWidth;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmPelsHeight;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmDisplayFlags;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmDisplayFrequency;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmICMMethod;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmICMIntent;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmMediaType;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmDitherType;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmReserved1;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmReserved2;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmPanningWidth;
    [MarshalAs(UnmanagedType.U4)]
    public UInt32 dmPanningHeight;
}

POINTL Structure

The DEVMODE's dmPosition member represents the location that displays the device in reference to the desktop area. It is always located at (0, 0). This member is of the structure POINTL which represents the coordinates (x and y) of a point. As you might expect, this structure is very simple. It is defined as follows.

typedef struct POINTL {
    LONG x;
    LONG y;
} POINTL;

We can marshal this structure easily as following.

using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
public struct POINTL
{
    [MarshalAs(UnmanagedType.I4)]
    public int x;
    [MarshalAs(UnmanagedType.I4)]
    public int y;
}

However, for code clarity, we have a workaround. You can omit the POINTL structure and replace the dmPosition member with two members, you can call them dmPositionX and dmPositionY, and that will work fine because you know that the size and layout (position of members) of structures are very important. And doing that will not break this rule.

ChangeDisplaySettings() Function

This function resides in user32.dll. It is used to change display settings to the mode specified, but only if the mode is valid.

The definition of this function is as follows.

LONG ChangeDisplaySettings(
    LPDEVMODE lpDevMode, // graphics mode
    DWORD dwFlags        // graphics mode options
);

This function accepts only two arguments:

• lpDevMode: A reference (In/Out) argument of the type DEVMODE represents the new settings (mode) that will be applied to the display device. After retrieving the current settings using the EnumDisplaySettings() function, you can change the desired members of the DEVMODE object and use this function to change the display device to the new settings. Again, this argument is In/Out argument, which means that it is used for input and output. DEVMODE's dmSize member is used for input and other members are used for output.
• dwflags: Indicates how the mode should be changed. Actually, in this example, we are not interested in this argument, so we will set it to zero. If you want more help on this argument, consult the MSDN documentation.

The return value of this function varies based on the success or failure of the settings change. This function can return one of several values including:

• DISP_CHANGE_SUCCESSFUL = 0:Indicates that the function succeeded.
• DISP_CHANGE_BADMODE = -2:The graphics mode is not supported.
• DISP_CHANGE_FAILED = -1:The display driver failed the specified graphics mode.
• DISP_CHANGE_RESTART = 1:The computer must be restarted for the graphics mode to work.

Consult MSDN documentation to know more about the ChangeDisplaySettings() return value. The last section of this lesson is devoted to this.

Another point of interest is that ChangeDisplaySettings() changes only the default display. If you want to change another display device, you can use the ChangeDisplaySettingsEx() function. It is very similar to ChangeDisplaySettings(). Consult MSDN documentation for more help.

Now, it is time to create the PInvoke method for the ChangeDisplaySettings() function.

using System;
using System.Runtime.InteropServices;
public static class User32
{
    [DllImport("User32.dll")]
    [return: MarshalAs(UnmanagedType.I4)]
    public static extern int ChangeDisplaySettings(
        [In, Out] ref DEVMODE lpDevMode,
        [param: MarshalAs(UnmanagedType.U4)] uint dwFlags
    );
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct DEVMODE
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
    public string dmDeviceName;
    public short dmSpecVersion;
    public short dmDriverVersion;
    public short dmSize;
    public short dmDriverExtra;
    public uint dmFields;
    public short dmOrientation;
    public short dmPaperSize;
    public short dmPaperLength;
    public short dmPaperWidth;
    // ... other fields ...
    public short dmDisplayFrequency;
    public short dmICMMethod;
    public short dmICMIntent;
    public short dmMediaType;
    public short dmDitherType;
    public short dmReserved1;
    public short dmReserved2;
    public uint dmPanningWidth;
    public uint dmPanningHeight;
}
public class Program
{
    public static void Main()
    {
        // Usage example
        DEVMODE devMode = new DEVMODE();
        // Initialize devMode fields here
        int result = User32.ChangeDisplaySettings(ref devMode, 0);
        Console.WriteLine("ChangeDisplaySettings result: " + result);
    }
}

Now, we are going to mix things together and talk about the implementation code. Get ready.

Retrieving Current Display Mode

The code that obtains the current display settings is very easy. We use the EnumDisplaySettings() function passing it ENUM_CURRENT_SETTINGS (-1) in the iModeNum parameter to get the current settings, and NULL in the lpszDeviceName parameter to indicate the current display device.

Here is the code.

Code abbreviated for clarity.

using System;
using System.Runtime.InteropServices;
public static class DisplaySettings
{
    private const int ENUM_CURRENT_SETTINGS = -1;
    [DllImport("User32.dll")]
    private static extern bool EnumDisplaySettings(
        string deviceName, int modeNum, ref DEVMODE devMode
    );
    public static void GetCurrentSettings()
    {
        DEVMODE mode = new DEVMODE();
        mode.dmSize = (ushort)Marshal.SizeOf(mode);
        if (EnumDisplaySettings(null, ENUM_CURRENT_SETTINGS, ref mode))
        {
            Console.WriteLine("Current Mode:\n\t" +
                "{0} by {1}, {2} bit, {3} degrees, {4} hertz",
                mode.dmPelsWidth, mode.dmPelsHeight,
                mode.dmBitsPerPel,
                mode.dmDisplayOrientation * 90,
                mode.dmDisplayFrequency);
        }
    }
}
public class Program
{
    public static void Main()
    {
        DisplaySettings.GetCurrentSettings();
    }
}

Enumerating Supported Display Modes

As a refresher, to get the current mode or even another supported mode of the display device, you make use of the EnumDisplaySettings() function. If you pass ENUM_CURRENT_SETTINGS (-1) in the iModeNum parameter, you get the current mode. On the other hand, you can enumerate through the list of supported modes by passing the mode index in this parameter. We start by 0 which indicates the first mode, and increment it every call to enumerate through the list of the supported modes. If the function returns FALSE, that means that the mode with the index specified is not found. Therefore, the previous mode was the last one. Here is the code.

Changing Display Mode

using System;
using System.Runtime.InteropServices;
public static class DisplaySettings
{
    [DllImport("User32.dll")]
    private static extern bool EnumDisplaySettings(
        string deviceName, int modeNum, ref DEVMODE devMode
    );
    public static void EnumerateSupportedModes()
    {
        DEVMODE mode = new DEVMODE();
        mode.dmSize = (ushort)Marshal.SizeOf(mode);
        int modeIndex = 0; // 0 = The first mode

        Console.WriteLine("Supported Modes:");
        while (EnumDisplaySettings(null, modeIndex, ref mode))
        {
            Console.WriteLine("\t{0} by {1}, {2} bit, {3} degrees, {4} hertz",
                mode.dmPelsWidth, mode.dmPelsHeight,
                mode.dmBitsPerPel,
                mode.dmDisplayOrientation * 90,
                mode.dmDisplayFrequency);
            modeIndex++; // Move to the next mode
        }
    }
}
public class Program
{
    public static void Main()
    {
        DisplaySettings.EnumerateSupportedModes();
    }
}

• Now, we are going to change the current display settings. This can be done through the ChangeDispalySettings() function.
• Changing Screen Resolution and Bit Count
• The following code example loads the current settings and changes only the resolution and the bit count. Actually, you are free to change all settings or few of them that is up to you. However, for the sake of simplicity, we are going to change the screen resolution and bit count in this section and the orientation in the next section.

using System;
using System.Runtime.InteropServices;

public static class DisplaySettings
{
    private const int ENUM_CURRENT_SETTINGS = -1;
    private const int DISP_CHANGE_SUCCESSFUL = 0;
    private const int DISP_CHANGE_BADMODE = -2;
    private const int DISP_CHANGE_RESTART = 1;

    [DllImport("User32.dll")]
    private static extern int ChangeDisplaySettings(
        ref DEVMODE devMode, int flags
    );

    [DllImport("User32.dll")]
    private static extern bool EnumDisplaySettings(
        string deviceName, int modeNum, ref DEVMODE devMode
    );

    public static void GetCurrentSettings()
    {
        DEVMODE mode = new DEVMODE();
        mode.dmSize = (ushort)Marshal.SizeOf(mode);

        if (EnumDisplaySettings(null, ENUM_CURRENT_SETTINGS, ref mode))
        {
            Console.WriteLine("Current Mode:\n\t" +
                "{0} by {1}, {2} bit, {3} degrees, {4} hertz",
                mode.dmPelsWidth, mode.dmPelsHeight,
                mode.dmBitsPerPel,
                mode.dmDisplayOrientation * 90,
                mode.dmDisplayFrequency);
        }
    }

    public static void ChangeDisplaySettings(int width, int height, int bitCount)
    {
        DEVMODE originalMode = new DEVMODE();
        originalMode.dmSize = (ushort)Marshal.SizeOf(originalMode);

        // Retrieving current settings to edit them
        EnumDisplaySettings(null, ENUM_CURRENT_SETTINGS, ref originalMode);

        // Making a copy of the current settings to allow resetting to the original mode
        DEVMODE newMode = originalMode;

        // Changing the settings
        newMode.dmPelsWidth = (uint)width;
        newMode.dmPelsHeight = (uint)height;
        newMode.dmBitsPerPel = (uint)bitCount;

        // Capturing the operation result
        int result = ChangeDisplaySettings(ref newMode, 0);
        if (result == DISP_CHANGE_SUCCESSFUL)
        {
            Console.WriteLine("Succeeded.\n");
            // Inspecting the new mode
            GetCurrentSettings();
            Console.WriteLine();
            // Waiting for seeing the results
            Console.ReadKey(true);
            ChangeDisplaySettings(ref originalMode, 0);
        }
        else if (result == DISP_CHANGE_BADMODE)
        {
            Console.WriteLine("Mode not supported.");
        }
        else if (result == DISP_CHANGE_RESTART)
        {
            Console.WriteLine("Restart required.");
        }
        else
        {
            Console.WriteLine("Failed. Error code = {0}", result);
        }
    }
}
public class Program
{
    public static void Main()
    {
        int width = 800;
        int height = 600;
        int bitCount = 16;

        DisplaySettings.ChangeDisplaySettings(width, height, bitCount);
    }
}

Changing Screen Orientation

Now we are going to change the screen orientation clockwise and anti-clockwise.

static void Main()
{
    // 0 degrees ( DMDO_DEFAULT = 0 )
    Console.WriteLine("Press any key to rotate the screen . . .");
    Console.ReadKey(true);
    Console.WriteLine();
    RotateScreen(true); // 90 degrees ( DMDO_90 = 1 )
    Console.WriteLine("Press any key to rotate the screen . . .");
    Console.ReadKey(true);
    Console.WriteLine();
    RotateScreen(true); // 180 degrees ( DMDO_180 = 2 )
    Console.WriteLine("Press any key to rotate the screen . . .");
    Console.ReadKey(true);
    Console.WriteLine();
    RotateScreen(true); // 270 degrees
	Console.WriteLine("Press any key to rotate the screen . . .");
    Console.ReadKey(true);
    Console.WriteLine();
    RotateScreen(true); // 0 degrees ( DMDO_DEFAULT = 0 )
}
public static void RotateScreen(bool clockwise)
{
    // Retrieving current settings
    // ...
    // Rotating the screen
    if (clockwise)
    {
        if (newMode.dmDisplayOrientation == DMDO_DEFAULT) // Fixed syntax error here
        {
            newMode.dmDisplayOrientation--;
        }
        else
        {
            newMode.dmDisplayOrientation = DMDO_270;
        }
        // Swapping width and height
        uint temp = newMode.dmPelsWidth;
        newMode.dmPelsWidth = newMode.dmPelsHeight;
        newMode.dmPelsHeight = temp;

        // Capturing the operation result
        // ...
    }
}

Sample Application

The code sample is a simple application used to change display settings and to rotate the screen.

This is a snapshot of the application.

The sample code is attached to the article.

References

• EnumDisplaySettings() Function
• ChangeDisplaySettings() Function
• ChangeDisplaySettingsEx() Function
• DEVMODE Structure
• POINTL Structure