ChangeResolution.cpp

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <stdlib.h>
#include <tchar.h>
#include <windows.h>

using namespace std;

static void ShowHelp(char **argv)
{
    TCHAR szPath[_MAX_PATH];
    TCHAR szDir[_MAX_DIR];
    TCHAR szDrive[_MAX_DRIVE];
    TCHAR szFName[_MAX_FNAME];
    TCHAR szExt[_MAX_EXT];
    GetModuleFileName(NULL, szPath, MAX_PATH);
    _tsplitpath_s(szPath, szDrive, szDir, szFName, szExt);
    ::wcout << "Usage:" << ::endl;
    ::wcout << "  " << szFName << " [-d N] [-list] | [-name] | [-current] | [-displays] | WIDTH HEIGHT | NAME" << ::endl;
    ::wcout << ::endl;
    ::wcout << "Options:" << ::endl;
    ::wcout << "  -d N, --display N   Specify display number N (0: main, 1: second, ...)" << ::endl;
    ::wcout << "  -c, --current       Show the current resolution of the specified display" << ::endl;
    ::wcout << "  -l, --list          Show available resolutions for the specified display" << ::endl;
    ::wcout << "  -n, --name          Show defined resolution names" << ::endl;
    ::wcout << "  -D, --displays      Show all display numbers, device names, and current resolutions" << ::endl;
    ::wcout << "  WIDTH HEIGHT        Change the resolution of the specified display to WIDTH x HEIGHT" << ::endl;
    ::wcout << "  NAME                Change the resolution of the specified display to NAME" << ::endl;
    ::wcout << ::endl;
    ::wcout << "Examples:" << ::endl;
    ::wcout << "  " << szFName << " 1024 768           Change main display to 1024x768" << ::endl;
    ::wcout << "  " << szFName << " SXGA               Change main display to SXGA" << ::endl;
    ::wcout << "  " << szFName << " -d 1 1920 1080     Change second display to 1920x1080" << ::endl;
    ::wcout << "  " << szFName << " -d 2 --list        Show available resolutions for third display" << ::endl;
    ::wcout << "  " << szFName << " -d 1 --current     Show current resolution of second display" << ::endl;
    ::wcout << "  " << szFName << " --displays         Show all display numbers, device names, and current resolutions" << ::endl;
}

void ShowDisplays()
{
    int index = 0;
    DISPLAY_DEVICE dd;
    dd.cb = sizeof(dd);
    ::wcout << "Index | DeviceName | DeviceString | CurrentResolution" << ::endl;
    ::wcout << "------|------------|--------------|------------------" << ::endl;
    while (EnumDisplayDevices(NULL, index, &dd, 0)) {
        std::wstring deviceName = dd.DeviceName;
        DEVMODE dm = { 0 };
        dm.dmSize = sizeof(dm);
        std::wstring res = L"-";
        if (EnumDisplaySettingsEx(deviceName.c_str(), ENUM_CURRENT_SETTINGS, &dm, 0)) {
            res = std::to_wstring(dm.dmPelsWidth) + L"x" + std::to_wstring(dm.dmPelsHeight);
        }
        ::wcout << index << " | " << deviceName
            << " | " << dd.DeviceString
            << " | " << res << ::endl;
        index++;
        dd.cb = sizeof(dd);
    }
}

void ShowList()
{
	DEVMODE ExistDisplayMode;
	int i = 0;
	int	height = 0;
	int	width = 0;
	int lastH = 0;
	int lastW = 0;

	while (EnumDisplaySettings(NULL, i, &ExistDisplayMode))
	{
		height = ExistDisplayMode.dmPelsHeight;
		width = ExistDisplayMode.dmPelsWidth;
		if ((lastH != height) && (lastW != width))
		{
			::wcout << width << "x" << height << ::endl;
			lastW = width;
			lastH = height;
		}
		i++;
	}
}
void ShowName()
{
	DEVMODE ExistDisplayMode;
	/*
	int i = 0;
	while (EnumDisplaySettings(NULL, i, &ExistDisplayMode))
	{
		i++;
	}
	*/
	EnumDisplaySettings(NULL, 0, &ExistDisplayMode);
	int width = ExistDisplayMode.dmPelsWidth;
	int height = ExistDisplayMode.dmPelsHeight;

	::wcout << "Name    Resolution" << ::endl;
	::wcout << "======  ==========" << ::endl;
	::wcout << "CGA     320x200" << ::endl;
	::wcout << "EGA     640x350" << ::endl;
	::wcout << "DCGA    640x400" << ::endl;
	::wcout << "SVGA    800x600" << ::endl;
	::wcout << "XGA     1024x768" << ::endl;
	::wcout << "HD      1280x720" << ::endl;
	::wcout << "FWXGA   1366x768" << ::endl;
	::wcout << "SXGA    1280x1024" << ::endl;
	::wcout << "XGA++   1600x900" << ::endl;
	::wcout << "UXGA    1600x1200" << ::endl;
	::wcout << "FHD     1920x1080" << ::endl;
	::wcout << "WUXGA   1920x1200" << ::endl;
	::wcout << "WQHD    2560x1440" << ::endl;
	::wcout << "WQXGA   2560x1600" << ::endl;
	::wcout << "QSXGA   2560x2048" << ::endl;
	::wcout << "QHD+    3200x1800" << ::endl;
	::wcout << "WQSXGA  3200x2048" << ::endl;
	::wcout << "QUXGA   3200x2400" << ::endl;
	::wcout << "4K      3840x2160" << ::endl;
	::wcout << "WQUXGA  3840x2400" << ::endl;
	::wcout << "5K      5120x2880" << ::endl;
	::wcout << "8K      7680x4320" << ::endl;
	::wcout << "16K     17280x4320" << ::endl;
	::wcout << "------  ----------" << ::endl;
	::wcout << "MAX     " << width << "x" << height << ::endl;
}

bool ShowCurrent()
{
	DEVMODE deviceMode = { 0 };
	deviceMode.dmSize = sizeof(deviceMode);
	deviceMode.dmDriverExtra = 0;
	if (EnumDisplaySettingsEx(NULL, ENUM_CURRENT_SETTINGS, &deviceMode, 0))
	{
		::wcout << deviceMode.dmPelsWidth << "x" << deviceMode.dmPelsHeight << ::endl;
	}
	else
	{
		::wcerr << "Failed to get current resolution." << ::endl;
		return false;
	}
	return true;
}

bool GetDisplayDeviceName(int displayIndex, std::wstring &deviceName)
{
    DISPLAY_DEVICE dd;
    dd.cb = sizeof(dd);
    if (EnumDisplayDevices(NULL, displayIndex, &dd, 0)) {
        deviceName = dd.DeviceName;
        return true;
    }
    return false;
}

void ShowList(const std::wstring& deviceName)
{
    DEVMODE ExistDisplayMode;
    int i = 0;
    int height = 0;
    int width = 0;
    int lastH = 0;
    int lastW = 0;

    while (EnumDisplaySettings(deviceName.empty() ? NULL : deviceName.c_str(), i, &ExistDisplayMode))
    {
        height = ExistDisplayMode.dmPelsHeight;
        width = ExistDisplayMode.dmPelsWidth;
        if ((lastH != height) && (lastW != width))
        {
            ::wcout << width << "x" << height << ::endl;
            lastW = width;
            lastH = height;
        }
        i++;
    }
}

bool ShowCurrent(const std::wstring& deviceName)
{
    DEVMODE deviceMode = { 0 };
    deviceMode.dmSize = sizeof(deviceMode);
    deviceMode.dmDriverExtra = 0;
    if (EnumDisplaySettingsEx(deviceName.empty() ? NULL : deviceName.c_str(), ENUM_CURRENT_SETTINGS, &deviceMode, 0))
    {
        ::wcout << deviceMode.dmPelsWidth << "x" << deviceMode.dmPelsHeight << ::endl;
    }
    else
    {
        ::wcerr << "Failed to get current resolution." << ::endl;
        return false;
    }
    return true;
}

static BOOL ParseArgs(int argc, char **argv, int *width, int *height, int *displayIndex)
{
    char *arg = NULL;
    int n = 0;
    string str;
    *displayIndex = 0;

    int argOffset = 0;
    if (argc > 2 && (strcmp(argv[1], "-d") == 0 || strcmp(argv[1], "--display") == 0)) {
        *displayIndex = atoi(argv[2]);
        argOffset = 2;
    }

    if (width == NULL || height == NULL) {
        return FALSE;
    }
    if (argc == 1 + argOffset) {
        ShowHelp(argv);
        exit(0);
    }
    else if (argc == 2 + argOffset) {
        arg = argv[1 + argOffset];
        str = arg;
        string p = argv[1 + argOffset];
        transform(p.begin(), p.end(), p.begin(), toupper);

        std::wstring deviceName;
        GetDisplayDeviceName(*displayIndex, deviceName);

        if (p == "-?" || p == "/?" || p == "-H" || p == "/H" || p == "--HELP" || p == "/HELP") {
            ShowHelp(argv);
            exit(0);
        }
        else if (p == "-L" || p == "/L" || p == "--LIST" || p == "/LIST") {
            ShowList(deviceName);
            exit(0);
        }
        else if (p == "-N" || p == "/N" || p == "--NAME" || p == "/NAME") {
            ShowName();
            exit(0);
        }
        else if (p == "-C" || p == "/C" || p == "--CURRENT" || p == "/CURRENT" || p == "--NOW" || p == "/NOW") {
            ShowCurrent(deviceName);
            exit(0);
        }
        else if (p == "-D" || p == "--DISPLAYS") {
            ShowDisplays();
            exit(0);
        }
        else if (p == "CGA") { *width = 320; *height = 200; }
        else if (p == "EGA") { *width = 640; *height = 350; }
        else if (p == "DCGA") { *width = 640; *height = 400; }
        else if (p == "VGA") { *width = 640; *height = 480; }
        else if (p == "SVGA") { *width = 800; *height = 600; }
        else if (p == "XGA") { *width = 1024; *height = 768; }
        else if ((p == "HD") || (p == "HD720") || (p == "720P") || (p == "HD720P")) { *width = 1280; *height = 720; }
        else if (p == "FWXGA") { *width = 1366; *height = 768; }
        else if (p == "SXGA") { *width = 1280; *height = 1024; }
        else if (p == "XGA++") { *width = 1600; *height = 900; }
        else if (p == "UXGA") { *width = 1600; *height = 1200; }
        else if ((p == "FHD") || (p == "FULLHD") || (p == "FULL-HD") || (p == "HD1080") || (p == "1080P")) { *width = 1920; *height = 1080; }
        else if (p == "WUXGA") { *width = 1920; *height = 1200; }
        else if (p == "WQHD") { *width = 2560; *height = 1440; }
        else if (p == "WQXGA") { *width = 2560; *height = 1600; }
        else if (p == "QSXGA") { *width = 2560; *height = 2048; }
        else if (p == "QHD+") { *width = 3200; *height = 1800; }
        else if (p == "WQSXGA") { *width = 3200; *height = 2048; }
        else if (p == "QUXGA") { *width = 3200; *height = 2400; }
        else if ((p == "4K") || (p == "QFHD")) { *width = 3840; *height = 2160; }
        else if (p == "WQUXGA") { *width = 3840; *height = 2400; }
        else if (p == "5K") { *width = 5120; *height = 2880; }
        else if (p == "8K") { *width = 7680; *height = 4320; }
        else if (p == "16K") { *width = 17280; *height = 4320; }
        else if (p == "MAX") {
            DEVMODE ExistDisplayMode;
            int i = 0;
            std::wstring deviceName;
            if (!GetDisplayDeviceName(*displayIndex, deviceName)) return FALSE;
            while (EnumDisplaySettings(deviceName.c_str(), i, &ExistDisplayMode)) {
                i++;
            }
            *width = ExistDisplayMode.dmPelsWidth;
            *height = ExistDisplayMode.dmPelsHeight;
        }
        else {
            return FALSE;
        }
    }
    else if (argc == 3 + argOffset) {
        arg = argv[1 + argOffset];
        n = atoi(arg);
        if (n <= 0) return FALSE;
        *width = n;

        arg = argv[2 + argOffset];
        n = atoi(arg);
        if (n <= 0) return FALSE;
        *height = n;
    }
    else {
        return FALSE;
    }
    return TRUE;
}

int main(int argc, char **argv)
{
    int newWidth = 0;
    int newHeight = 0;
    int displayIndex = 0;

    if (!ParseArgs(argc, argv, &newWidth, &newHeight, &displayIndex)) {
        ::wcerr << "Invalid Argument(s)." << ::endl << ::endl;
        return EXIT_FAILURE;
    }

    std::wstring deviceName;
    if (!GetDisplayDeviceName(displayIndex, deviceName)) {
        ::wcerr << "Invalid display index." << ::endl;
        return EXIT_FAILURE;
    }

    DEVMODE deviceMode = { 0 };
    deviceMode.dmSize = sizeof(deviceMode);
    deviceMode.dmDriverExtra = 0;
    if (EnumDisplaySettingsEx(deviceName.c_str(), ENUM_CURRENT_SETTINGS, &deviceMode, 0)) {
        if ((deviceMode.dmPelsWidth != newWidth) || (deviceMode.dmPelsHeight != newHeight)) {
            deviceMode.dmPelsWidth = newWidth;
            deviceMode.dmPelsHeight = newHeight;
            if (ChangeDisplaySettingsEx(deviceName.c_str(), &deviceMode, NULL, 0, NULL) == DISP_CHANGE_SUCCESSFUL) {
                ::wcout << "Succeeded: " << newWidth << "x" << newHeight << ::endl;
            }
            else {
                ::wcerr << "Failed: " << newWidth << "x" << newHeight << ::endl;
                return EXIT_FAILURE;
            }
        }
        else {
            ::wcout << "Already Same Resolution: " << newWidth << "x" << newHeight << ::endl;
        }
    }
    else {
        ::wcerr << "Failed to get current resolution." << ::endl;
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}