BCompat/config.c

#include <windows.h>
#include <windowsx.h>
#include <prsht.h>

#define MAX_FUNCTION_COUNT 8

struct ReportedVersion {
    LPCSTR name;
    DWORD major;
    DWORD minor;
    DWORD build;
    DWORD platform;
};
typedef struct ReportedVersion ReportedVersion;
struct FunctionVersion {
    LPCSTR name;
    LPCSTR functions[MAX_FUNCTION_COUNT];
};
typedef struct FunctionVersion FunctionVersion;

ReportedVersion reportedVersions[] = {
    { "Win32s", 1, 0, 0, VER_PLATFORM_WIN32s },
    { "Windows NT 3.1", 3, 10, 511, VER_PLATFORM_WIN32_NT },
    { "Windows NT 3.50", 3, 50, 807, VER_PLATFORM_WIN32_NT },
    { "Windows NT 3.51", 3, 51, 1057, VER_PLATFORM_WIN32_NT },
    { "Windows 95", 4, 0, 950, VER_PLATFORM_WIN32_WINDOWS },
    { "Windows NT 4.0", 4, 0, 1381, VER_PLATFORM_WIN32_NT },
    { "Windows 2000", 5, 0, 2195, VER_PLATFORM_WIN32_NT }
};
LPCSTR csdVersions[] = {
    "None",
    "Service Pack 1",
    "Service Pack 2",
    "Service Pack 3",
    "Service Pack 4",
    "Service Pack 5",
    "Service Pack 6"
};

BOOL reportedChanged;
BOOL functionChanged ;

INT_PTR CALLBACK GlobalPageProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    switch (uMsg) {
        case WM_INITDIALOG:
            reportedChanged = FALSE;
            functionChanged = FALSE;

            HWND reportedBox = GetDlgItem(hWnd, 1);
            for (int i = 0; i < ARRAYSIZE(reportedVersions); i++) {
                ListBox_AddString(reportedBox, reportedVersions[i].name);
            }
            HWND functionBox = GetDlgItem(hWnd, 2);
            for (int i = 0; i < ARRAYSIZE(csdVersions); i++) {
                ListBox_AddString(functionBox, csdVersions[i]);
            }

            HKEY key;
            if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\BCompat"), 0, KEY_READ, &key) == ERROR_SUCCESS) {
                DWORD size;
                DWORD major = 0;
                RegQueryValueEx(key, TEXT("ReportedMajor"), NULL, NULL, (LPBYTE) &major, &size);
                DWORD minor = 0;
                RegQueryValueEx(key, TEXT("ReportedMinor"), NULL, NULL, (LPBYTE) &minor, &size);
                DWORD build = 0;
                RegQueryValueEx(key, TEXT("ReportedBuild"), NULL, NULL, (LPBYTE) &build, &size);
                DWORD platform = 0;
                RegQueryValueEx(key, TEXT("ReportedPlatform"), NULL, NULL, (LPBYTE) &platform, &size);
                for (int i = 0; i < ARRAYSIZE(reportedVersions); i++) {
                    ReportedVersion version = reportedVersions[i];
                    if (major == version.major && minor == version.minor && build == version.build && platform == version.platform) {
                        ListBox_SetCurSel(reportedBox, i);
                    }
                }
                TCHAR csd[128];
                size = sizeof(csd);
                RegQueryValueEx(key, TEXT("ReportedServicePack"), NULL, NULL, (LPBYTE) &csd, &size);
                if (strlen(csd) == 0) {
                    strcpy(csd, "None");
                }
                for (int i = 0; i < ARRAYSIZE(csdVersions); i++) {
                    LPCSTR version = csdVersions[i];
                    if (strcmp(csd, version) == 0) {
                        ListBox_SetCurSel(reportedBox, i);
                    }
                }
                RegCloseKey(key);
            }
            break;
        case WM_COMMAND:
            switch (LOWORD(wParam)) {
                case 1:
                    switch (HIWORD(wParam)) {
                        case LBN_SELCHANGE:
                            PropSheet_Changed(GetParent(hWnd), hWnd);
                            reportedChanged = TRUE;
                            break;
                    }
                    break;
                case 2:
                    switch (HIWORD(wParam)) {
                        case LBN_SELCHANGE:
                            PropSheet_Changed(GetParent(hWnd), hWnd);
                            functionChanged = TRUE;
                            break;
                    }
                    break;
            }
            break;
        case WM_NOTIFY:
            switch (((NMHDR *)lParam)->code) {
                case PSN_APPLY:
                    if (reportedChanged) {
                        reportedChanged = FALSE;
                        ReportedVersion version = reportedVersions[ListBox_GetCurSel(GetDlgItem(hWnd, 1))];
                        HKEY key;
                        RegCreateKeyEx(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\BCompat"), 0, NULL, 0, KEY_WRITE, NULL, &key, NULL);
                        RegSetValueEx(key, "ReportedMajor", 0, REG_DWORD, (LPBYTE) &version.major, sizeof(DWORD));
                        RegSetValueEx(key, "ReportedMinor", 0, REG_DWORD, (LPBYTE) &version.minor, sizeof(DWORD));
                        RegSetValueEx(key, "ReportedBuild", 0, REG_DWORD, (LPBYTE) &version.build, sizeof(DWORD));
                        RegSetValueEx(key, "ReportedPlatform", 0, REG_DWORD, (LPBYTE) &version.platform, sizeof(DWORD));
                        RegCloseKey(key);
                    }
                    if (functionChanged) {
                        functionChanged = FALSE;
                        LPCSTR version = csdVersions[ListBox_GetCurSel(GetDlgItem(hWnd, 2))];
                        HKEY key;
                        RegCreateKeyEx(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\BCompat"), 0, NULL, 0, KEY_WRITE, NULL, &key, NULL);
                        if (strcmp(version, "None") == 0) {
                            version = "";
                        }
                        RegSetValueEx(key, "ReportedServicePack", 0, REG_SZ, (LPBYTE) version, strlen(version) + 1);
                        RegCloseKey(key);
                    }
            }
    }
    return FALSE;
}

int main() {
    HMODULE instance = GetModuleHandle(NULL);

    PROPSHEETPAGE psp[1];

    PROPSHEETHEADER psh;

    psp[0].dwSize      = sizeof(PROPSHEETPAGE);
    psp[0].dwFlags     = PSP_USETITLE;
    psp[0].hInstance   = instance;
    psp[0].pszTemplate = MAKEINTRESOURCE(1);
    psp[0].pszIcon     = NULL;
    psp[0].pfnDlgProc  = GlobalPageProc;
    psp[0].pszTitle    = "Global";
    psp[0].lParam      = 0;
    psp[0].pfnCallback = NULL;
    /*psp[1].dwSize      = sizeof(PROPSHEETPAGE);
    psp[1].dwFlags     = PSP_USETITLE;
    psp[1].hInstance   = instance;
    psp[1].pszTemplate = MAKEINTRESOURCE(2);
    psp[1].pszIcon     = NULL;
    psp[1].pfnDlgProc  = AboutPageProc;
    psp[1].pszTitle    = "About";
    psp[1].lParam      = 0;
    psp[1].pfnCallback = NULL;*/

    psh.dwSize      = sizeof(PROPSHEETHEADER);
    psh.dwFlags     = PSH_PROPSHEETPAGE;
    psh.hwndParent  = NULL;
    psh.hInstance   = instance;
    psh.pszIcon     = NULL;
    psh.pszCaption  = "BCompat Settings";
    psh.nPages      = sizeof(psp) / sizeof(PROPSHEETPAGE);
    psh.nStartPage  = 0;
    psh.ppsp        = (LPCPROPSHEETPAGE) &psp;
    psh.pfnCallback = NULL;

    PropertySheet(&psh);
}