cpl/desk/theme.c

/*
 * COPYRIGHT:       See COPYING in the top level directory
 * PROJECT:         ReactOS Display Control Panel
 * FILE:            dll/cpl/desk/theme.c
 * PURPOSE:         Handling themes and visual effects
 *
 * PROGRAMMERS:     Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
 *                  Ismael Ferreras Morezuelas (swyterzone+reactos@gmail.com)
 */

#include "desk.h"

#include <shlwapi.h>
#include <uxtheme.h>
#include <uxundoc.h>
#include <vssym32.h>

static const WCHAR g_CPColors[] = L"Control Panel\\Colors";
static const WCHAR g_CPANewSchemes[] = L"Control Panel\\Appearance\\New Schemes";
static const WCHAR g_CPMetrics[] = L"Control Panel\\Desktop\\WindowMetrics";
static const WCHAR g_SelectedStyle[] = L"SelectedStyle";

/******************************************************************************/

/* This is the list of names for the colors stored in the registry */
static const WCHAR *g_RegColorNames[NUM_COLORS] = {
    L"Scrollbar",             /* 00 = COLOR_SCROLLBAR */
    L"Background",            /* 01 = COLOR_DESKTOP */
    L"ActiveTitle",           /* 02 = COLOR_ACTIVECAPTION  */
    L"InactiveTitle",         /* 03 = COLOR_INACTIVECAPTION */
    L"Menu",                  /* 04 = COLOR_MENU */
    L"Window",                /* 05 = COLOR_WINDOW */
    L"WindowFrame",           /* 06 = COLOR_WINDOWFRAME */
    L"MenuText",              /* 07 = COLOR_MENUTEXT */
    L"WindowText",            /* 08 = COLOR_WINDOWTEXT */
    L"TitleText",             /* 09 = COLOR_CAPTIONTEXT */
    L"ActiveBorder",          /* 10 = COLOR_ACTIVEBORDER */
    L"InactiveBorder",        /* 11 = COLOR_INACTIVEBORDER */
    L"AppWorkSpace",          /* 12 = COLOR_APPWORKSPACE */
    L"Hilight",               /* 13 = COLOR_HIGHLIGHT */
    L"HilightText",           /* 14 = COLOR_HIGHLIGHTTEXT */
    L"ButtonFace",            /* 15 = COLOR_BTNFACE */
    L"ButtonShadow",          /* 16 = COLOR_BTNSHADOW */
    L"GrayText",              /* 17 = COLOR_GRAYTEXT */
    L"ButtonText",            /* 18 = COLOR_BTNTEXT */
    L"InactiveTitleText",     /* 19 = COLOR_INACTIVECAPTIONTEXT */
    L"ButtonHilight",         /* 20 = COLOR_BTNHIGHLIGHT */
    L"ButtonDkShadow",        /* 21 = COLOR_3DDKSHADOW */
    L"ButtonLight",           /* 22 = COLOR_3DLIGHT */
    L"InfoText",              /* 23 = COLOR_INFOTEXT */
    L"InfoWindow",            /* 24 = COLOR_INFOBK */
    L"ButtonAlternateFace",   /* 25 = COLOR_ALTERNATEBTNFACE */
    L"HotTrackingColor",      /* 26 = COLOR_HOTLIGHT */
    L"GradientActiveTitle",   /* 27 = COLOR_GRADIENTACTIVECAPTION */
    L"GradientInactiveTitle", /* 28 = COLOR_GRADIENTINACTIVECAPTION */
    L"MenuHilight",           /* 29 = COLOR_MENUHILIGHT */
    L"MenuBar",               /* 30 = COLOR_MENUBAR */
};

/******************************************************************************/

VOID
SchemeSetMetric(IN COLOR_SCHEME *scheme, int id, int value)
{
    switch (id)
    {
        case SIZE_BORDER_WIDTH: scheme->ncMetrics.iBorderWidth = value; break;
        case SIZE_SCROLL_WIDTH: scheme->ncMetrics.iScrollWidth = value; break;
        case SIZE_SCROLL_HEIGHT: scheme->ncMetrics.iScrollHeight = value; break;
        case SIZE_CAPTION_WIDTH: scheme->ncMetrics.iCaptionWidth = value; break;
        case SIZE_CAPTION_HEIGHT: scheme->ncMetrics.iCaptionHeight = value; break;
        case SIZE_SM_CAPTION_WIDTH: scheme->ncMetrics.iSmCaptionWidth = value; break;
        case SIZE_SM_CAPTION_HEIGHT: scheme->ncMetrics.iSmCaptionHeight = value; break;
        case SIZE_MENU_WIDTH: scheme->ncMetrics.iMenuWidth = value; break;
        case SIZE_MENU_HEIGHT: scheme->ncMetrics.iMenuHeight = value; break;
        case SIZE_ICON: scheme->iIconSize = value; break;
        case SIZE_ICON_SPACE_X: scheme->icMetrics.iHorzSpacing = value; break;
        case SIZE_ICON_SPACE_Y: scheme->icMetrics.iVertSpacing = value; break;
    }
}

int
SchemeGetMetric(IN COLOR_SCHEME *scheme, int id)
{
    switch (id)
    {
        case SIZE_BORDER_WIDTH: return scheme->ncMetrics.iBorderWidth;
        case SIZE_SCROLL_WIDTH: return scheme->ncMetrics.iScrollWidth;
        case SIZE_SCROLL_HEIGHT: return scheme->ncMetrics.iScrollHeight;
        case SIZE_CAPTION_WIDTH: return scheme->ncMetrics.iCaptionWidth;
        case SIZE_CAPTION_HEIGHT: return scheme->ncMetrics.iCaptionHeight;
        case SIZE_SM_CAPTION_WIDTH: return scheme->ncMetrics.iSmCaptionWidth;
        case SIZE_SM_CAPTION_HEIGHT: return scheme->ncMetrics.iSmCaptionHeight;
        case SIZE_MENU_WIDTH: return scheme->ncMetrics.iMenuWidth;
        case SIZE_MENU_HEIGHT: return scheme->ncMetrics.iMenuHeight;
        case SIZE_ICON: return scheme->iIconSize;
        case SIZE_ICON_SPACE_X: return scheme->icMetrics.iHorzSpacing;
        case SIZE_ICON_SPACE_Y: return scheme->icMetrics.iVertSpacing;
    }
    return 0;
}

PLOGFONTW
SchemeGetFont(IN COLOR_SCHEME *scheme, int id)
{
    switch (id)
    {
        case FONT_CAPTION: return &scheme->ncMetrics.lfCaptionFont;
        case FONT_SMCAPTION: return &scheme->ncMetrics.lfSmCaptionFont;
        case FONT_MENU: return &scheme->ncMetrics.lfMenuFont;
        case FONT_STATUS: return &scheme->ncMetrics.lfStatusFont;
        case FONT_MESSAGE: return &scheme->ncMetrics.lfMessageFont;
        case FONT_ICON: return &scheme->icMetrics.lfFont;
    }
    return NULL;
}

/*
 * LoadCurrentScheme: Populates the passed scheme based on the current system settings
 */
BOOL
LoadCurrentScheme(OUT COLOR_SCHEME *scheme)
{
    INT i, Result;
    HKEY hKey;
    BOOL ret;
#if (WINVER >= 0x0600)
    OSVERSIONINFO osvi;
#endif

    /* Load colors */
    for (i = 0; i < NUM_COLORS; i++)
    {
        scheme->crColor[i] = (COLORREF)GetSysColor(i);
    }

    /* Load non client metrics */
    scheme->ncMetrics.cbSize = sizeof(NONCLIENTMETRICSW);

#if (WINVER >= 0x0600)
    /* Size of NONCLIENTMETRICSA/W depends on current version of the OS.
     * see:
     *  https://msdn.microsoft.com/en-us/library/windows/desktop/ff729175%28v=vs.85%29.aspx
     */
    if (GetVersionEx(&osvi))
    {
        /* Windows XP and earlier */
        if (osvi.dwMajorVersion <= 5)
            scheme->ncMetrics.cbSize -= sizeof(scheme->ncMetrics.iPaddedBorderWidth);
    }
#endif

    ret = SystemParametersInfoW(SPI_GETNONCLIENTMETRICS,
                                sizeof(NONCLIENTMETRICSW),
                                &scheme->ncMetrics,
                                0);
    if (!ret) return FALSE;

    /* Load icon metrics */
    scheme->icMetrics.cbSize = sizeof(ICONMETRICSW);
    ret = SystemParametersInfoW(SPI_GETICONMETRICS,
                                sizeof(ICONMETRICSW),
                                &scheme->icMetrics,
                                0);
    if (!ret) return FALSE;

    /* Load flat menu style */
    ret = SystemParametersInfoW(SPI_GETFLATMENU,
                                0,
                                &scheme->bFlatMenus,
                                0);
    if (!ret) return FALSE;

    /* Effects */
    /* Use the following transition effect for menus and tooltips */
    ret = SystemParametersInfoW(SPI_GETMENUANIMATION,
                                0,
                                &scheme->Effects.bMenuAnimation,
                                0);
    if (!ret) return FALSE;

    ret = SystemParametersInfoW(SPI_GETMENUFADE,
                                0,
                                &scheme->Effects.bMenuFade,
                                0);
    if (!ret) return FALSE;

    /* FIXME: XP seems to use grayed checkboxes to reflect differences between menu and tooltips settings
     * Just keep them in sync for now:
     */
    scheme->Effects.bTooltipAnimation  = scheme->Effects.bMenuAnimation;
    scheme->Effects.bTooltipFade       = scheme->Effects.bMenuFade;

    /* Use the following transition effect for menus and tooltips */
    ret = SystemParametersInfoW(SPI_GETFONTSMOOTHING,
                                0,
                                &scheme->Effects.bFontSmoothing,
                                0);
    if (!ret) return FALSE;

    ret = SystemParametersInfoW(SPI_GETFONTSMOOTHINGTYPE,
                                0,
                                &scheme->Effects.uiFontSmoothingType,
                                0);
    if (!ret) return FALSE;

    /* Show shadows under menus */
    ret = SystemParametersInfoW(SPI_GETDROPSHADOW,
                                0,
                                &scheme->Effects.bDropShadow,
                                0);
    if (!ret) return FALSE;

    /* Show content of windows during dragging */
    ret = SystemParametersInfoW(SPI_GETDRAGFULLWINDOWS,
                                0,
                                &scheme->Effects.bDragFullWindows,
                                0);
    if (!ret) return FALSE;

    /* Hide underlined letters for keyboard navigation until the Alt key is pressed */
    ret = SystemParametersInfoW(SPI_GETKEYBOARDCUES,
                                0,
                                &scheme->Effects.bKeyboardCues,
                                0);
    if (!ret) return FALSE;

    /* Read the icon size from registry */
    Result = RegOpenKeyW(HKEY_CURRENT_USER, g_CPMetrics, &hKey);
    if(Result == ERROR_SUCCESS)
    {
        scheme->iIconSize = SHRegGetIntW(hKey, L"Shell Icon Size", 32);
        RegCloseKey(hKey);
    }

    return TRUE;
}

/*
 * LoadSchemeFromReg: Populates the passed scheme with values retrieved from registry
 */
BOOL
LoadSchemeFromReg(OUT COLOR_SCHEME *scheme, IN PTHEME_SELECTION pSelectedTheme)
{
    INT i;
    WCHAR strValueName[10], strSchemeKey[MAX_PATH];
    HKEY hkScheme = NULL;
    DWORD dwType, dwLength;
    UINT64 iSize;
    BOOL Ret = TRUE;
    LONG result;

    wsprintf(strSchemeKey, L"%s\\%s\\Sizes\\%s",
             g_CPANewSchemes,
             pSelectedTheme->Color->StyleName,
             pSelectedTheme->Size->StyleName);

    result = RegOpenKeyW(HKEY_CURRENT_USER, strSchemeKey, &hkScheme);
    if (result != ERROR_SUCCESS) return FALSE;

    scheme->bFlatMenus = SHRegGetIntW(hkScheme, L"FlatMenus", 0);

    for (i = 0; i < NUM_COLORS; i++)
    {
        wsprintf(strValueName, L"Color #%d", i);
        dwLength = sizeof(COLORREF);
        result = RegQueryValueExW(hkScheme,
                                  strValueName,
                                  NULL,
                                  &dwType,
                                  (LPBYTE)&scheme->crColor[i],
                                  &dwLength);
        if (result != ERROR_SUCCESS || dwType != REG_DWORD)
        {
            /* Failed to read registry value, initialize with current setting for now */
            scheme->crColor[i] = GetSysColor(i);
        }
    }

    for (i = 0; i < NUM_FONTS; i++)
    {
        PLOGFONTW lpfFont = SchemeGetFont(scheme, i);

        wsprintf(strValueName, L"Font #%d", i);
        dwLength = sizeof(LOGFONT);
        result = RegQueryValueExW(hkScheme,
                                  strValueName,
                                  NULL,
                                  &dwType,
                                  (LPBYTE)lpfFont,
                                  &dwLength);
        if (result != ERROR_SUCCESS || dwType != REG_BINARY ||
            dwLength != sizeof(LOGFONT))
        {
            /* Failed to read registry value */
            Ret = FALSE;
        }
    }

    for (i = 0; i < NUM_SIZES; i++)
    {
        wsprintf(strValueName, L"Size #%d", i);
        dwLength = sizeof(UINT64);
        result = RegQueryValueExW(hkScheme,
                                  strValueName,
                                  NULL,
                                  &dwType,
                                  (LPBYTE)&iSize,
                                  &dwLength);
        if (result != ERROR_SUCCESS || dwType != REG_QWORD ||
            dwLength != sizeof(UINT64))
        {
            /* Failed to read registry value, initialize with current setting for now */
        }
        else
        {
            SchemeSetMetric(scheme, i, (int)iSize);
        }
    }

    RegCloseKey(hkScheme);

    return Ret;
}

/*
 * ApplyScheme: Applies the selected scheme and stores its id in the registry if needed
 */
VOID
ApplyScheme(IN COLOR_SCHEME *scheme, IN PTHEME_SELECTION pSelectedTheme)
{
    INT i, Result;
    HKEY hKey;
    WCHAR clText[16], *StyleName;
    INT ColorList[NUM_COLORS];

    /* Apply system colors  */
    for (i = 0; i < NUM_COLORS; i++)
        ColorList[i] = i;
    SetSysColors(NUM_COLORS, ColorList, scheme->crColor);

    /* Save colors to registry */
    Result = RegCreateKeyW(HKEY_CURRENT_USER, g_CPColors, &hKey);
    if (Result == ERROR_SUCCESS)
    {
        for (i = 0; i < NUM_COLORS; i++)
        {
            wsprintf(clText,
                     L"%d %d %d",
                     GetRValue(scheme->crColor[i]),
                     GetGValue(scheme->crColor[i]),
                     GetBValue(scheme->crColor[i]));

            RegSetValueExW(hKey,
                           g_RegColorNames[i],
                           0,
                           REG_SZ,
                           (BYTE *)clText,
                           (lstrlen(clText) + 1) * sizeof(WCHAR));
        }
        RegCloseKey(hKey);
    }

    /* Apply non client metrics */
    SystemParametersInfoW(SPI_SETNONCLIENTMETRICS,
                          sizeof(NONCLIENTMETRICS),
                          &scheme->ncMetrics,
                          SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);

    /* Apply icon metrics */
    SystemParametersInfoW(SPI_SETICONMETRICS,
                          sizeof(ICONMETRICS),
                          &scheme->icMetrics,
                          SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);

    /* Effects, save only when needed: */
    /* FIXME: XP seems to use grayed checkboxes to reflect differences between menu and tooltips settings
     * Just keep them in sync for now.
     */

#define SYS_CONFIG(__uiAction, __uiParam, __pvParam) \
    SystemParametersInfoW(__uiAction, __uiParam, __pvParam, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE)

    scheme->Effects.bTooltipAnimation  = scheme->Effects.bMenuAnimation;
    scheme->Effects.bTooltipFade       = scheme->Effects.bMenuFade;

    /* Use the following transition effect for menus and tooltips */
    SYS_CONFIG(SPI_SETMENUANIMATION,             0, IntToPtr(scheme->Effects.bMenuAnimation));
    SYS_CONFIG(SPI_SETMENUFADE,                  0, IntToPtr(scheme->Effects.bMenuFade));

    /* Use the following method to smooth edges of screen fonts */
    SYS_CONFIG(SPI_SETFONTSMOOTHING,             scheme->Effects.bFontSmoothing, 0);
    SYS_CONFIG(SPI_SETFONTSMOOTHINGTYPE,         0, IntToPtr(scheme->Effects.uiFontSmoothingType));

    /*
     * Refresh and redraw all the windows, otherwise the font smoothing changes
     * only appear after any future partial region invalidation.
     * Not everyone listens for this WM_SETTINGCHANGE, including the shell and most third party programs.
     */
    InvalidateRect(NULL, NULL, TRUE);

    /* Use large icons */
    //SYS_CONFIG(SPI_GETDRAGFULLWINDOWS,   (PVOID) g->SchemeAdv.Effects.bMenuFade);

    /* Show shadows under menus */
    SYS_CONFIG(SPI_SETDROPSHADOW,                0, IntToPtr(scheme->Effects.bDropShadow));

    /* Show window contents while dragging */
    SYS_CONFIG(SPI_SETDRAGFULLWINDOWS,           scheme->Effects.bDragFullWindows, 0);

    /* Hide underlined letters for keyboard navigation until I press the Alt key */
    SYS_CONFIG(SPI_SETKEYBOARDCUES,              0, IntToPtr(scheme->Effects.bKeyboardCues));

    SYS_CONFIG(SPI_SETFLATMENU,                  0, IntToPtr(scheme->bFlatMenus));

    // SYS_CONFIG(SPI_SETACTIVEWINDOWTRACKING,   0, IntToPtr(scheme->Effects.bActiveWindowTracking));
    // SYS_CONFIG(SPI_SETCOMBOBOXANIMATION,      0, IntToPtr(scheme->Effects.bComboBoxAnimation));
    // SYS_CONFIG(SPI_SETLISTBOXSMOOTHSCROLLING, 0, IntToPtr(scheme->Effects.bListBoxSmoothScrolling));
    // SYS_CONFIG(SPI_SETGRADIENTCAPTIONS,       0, IntToPtr(scheme->Effects.bGradientCaptions));
    // SYS_CONFIG(SPI_SETACTIVEWNDTRKZORDER,     0, IntToPtr(scheme->Effects.bActiveWndTrkZorder));
    // SYS_CONFIG(SPI_SETHOTTRACKING,            0, IntToPtr(scheme->Effects.bHotTracking));
    // SYS_CONFIG(SPI_SETSELECTIONFADE,          0, IntToPtr(scheme->Effects.bSelectionFade));
    SYS_CONFIG(SPI_SETTOOLTIPANIMATION,          0, IntToPtr(scheme->Effects.bTooltipAnimation));
    SYS_CONFIG(SPI_SETTOOLTIPFADE,               0, IntToPtr(scheme->Effects.bTooltipFade));
    // SYS_CONFIG(SPI_SETCURSORSHADOW,           0, IntToPtr(scheme->Effects.bCursorShadow));
    // SYS_CONFIG(SPI_SETUIEFFECTS,              0, IntToPtr(scheme->Effects.bUiEffects));

#undef SYS_CONFIG

    /* Save SchemeId in the registry */
    if (pSelectedTheme->Theme != NULL && pSelectedTheme->ThemeActive == FALSE)
    {
        StyleName = pSelectedTheme->Color->StyleName;
        SHSetValueW(HKEY_CURRENT_USER,
                    g_CPANewSchemes,
                    g_SelectedStyle,
                    REG_SZ,
                    StyleName,
                    (lstrlenW(StyleName) + 1) * sizeof(WCHAR));
    }
}

static THEME*
CreateTheme(LPCWSTR pszName, LPCWSTR pszDisplayName)
{
    PTHEME pTheme;

    pTheme = (PTHEME) malloc(sizeof(THEME));
    if (pTheme == NULL) return NULL;

    pTheme->DisplayName = _wcsdup(pszDisplayName);
    if (pTheme->DisplayName == NULL)
    {
        free(pTheme);
        return NULL;
    }

    pTheme->ColoursList = NULL;
    pTheme->NextTheme = NULL;
    pTheme->SizesList = NULL;

    if (pszName == NULL)
    {
        pTheme->ThemeFileName = NULL;
        return pTheme;
    }

    pTheme->ThemeFileName = _wcsdup(pszName);
    if (pTheme->ThemeFileName == NULL)
    {
        free(pTheme->DisplayName);
        free(pTheme);
        return NULL;
    }

    return pTheme;
}

static PTHEME_STYLE
CreateStyle(LPCWSTR pszName, LPCWSTR pszDisplayName)
{
    PTHEME_STYLE pStyle;

    pStyle = (PTHEME_STYLE) malloc(sizeof(THEME_STYLE));
    if (pStyle == NULL) return NULL;

    pStyle->StyleName = _wcsdup(pszName);
    if (pStyle->StyleName == NULL)
    {
        free(pStyle);
        return NULL;
    }

    pStyle->DisplayName = _wcsdup(pszDisplayName);
    if (pStyle->DisplayName == NULL)
    {
        free(pStyle->StyleName);
        free(pStyle);
        return NULL;
    }

    pStyle->ChildStyle = NULL;
    pStyle->NextStyle = NULL;

    return pStyle;
}

static void
CleanupStyles(IN PTHEME_STYLE pStylesList)
{
    PTHEME_STYLE pStyle, pStyleOld;

    pStyle = pStylesList;
    while (pStyle)
    {
        if (pStyle->ChildStyle) CleanupStyles(pStyle->ChildStyle);
        if (pStyle->DisplayName) free(pStyle->DisplayName);
        if (pStyle->StyleName) free(pStyle->StyleName);

        pStyleOld = pStyle;
        pStyle = pStyle->NextStyle;
        free(pStyleOld);
    }
}

void
CleanupThemes(IN PTHEME pThemeList)
{
    PTHEME pTheme, pThemeOld;

    pTheme = pThemeList;
    while (pTheme)
    {
        CleanupStyles(pTheme->ColoursList);
        if (pTheme->SizesList) CleanupStyles(pTheme->SizesList);
        if (pTheme->DisplayName) free(pTheme->DisplayName);
        if (pTheme->ThemeFileName) free(pTheme->ThemeFileName);

        pThemeOld = pTheme;
        pTheme = pTheme->NextTheme;
        free(pThemeOld);
    }
}

static PTHEME_STYLE
FindStyle(IN PTHEME_STYLE pStylesList, IN PCWSTR StyleName)
{
    PTHEME_STYLE pStyle;

    for (pStyle = pStylesList; pStyle; pStyle = pStyle->NextStyle)
    {
        if (_wcsicmp(pStyle->StyleName, StyleName) == 0)
        {
            return pStyle;
        }
    }

    /* If we can't find the style requested, return the first one */
    return pStylesList;
}

/*
 * LoadSchemeSizes: Returns a list of sizes from the registry key of a scheme
 */
static PTHEME_STYLE
LoadSchemeSizes(IN HKEY hkScheme)
{
    HKEY hkSizes, hkSize;
    INT Result;
    INT iStyle;
    WCHAR wstrSizeName[5], wstrDisplayName[50];
    THEME_STYLE *List = NULL, *pCurrentStyle;

    Result = RegOpenKeyW(hkScheme, L"Sizes",  &hkSizes);
    if (Result != ERROR_SUCCESS) return NULL;

    iStyle = 0;
    while ((RegEnumKeyW(hkSizes, iStyle, wstrSizeName, 5) == ERROR_SUCCESS))
    {
        iStyle++;

        Result = RegOpenKeyW(hkSizes, wstrSizeName, &hkSize);
        if (Result != ERROR_SUCCESS) continue;

        Result = RegLoadMUIStringW(hkSize,
                                   L"DisplayName",
                                   wstrDisplayName,
                                   sizeof(wstrDisplayName),
                                   NULL,
                                   0,
                                   NULL);
        if (Result != ERROR_SUCCESS)
        {
            Result = RegLoadMUIStringW(hkSize,
                                       L"LegacyName",
                                       wstrDisplayName,
                                       sizeof(wstrDisplayName),
                                       NULL,
                                       0,
                                       NULL);
        }

        if (Result == ERROR_SUCCESS)
            pCurrentStyle = CreateStyle(wstrSizeName, wstrDisplayName);
        else
            pCurrentStyle = CreateStyle(wstrSizeName, wstrSizeName);

        if (pCurrentStyle  != NULL)
        {
            pCurrentStyle->NextStyle = List;
            List = pCurrentStyle;
        }

        RegCloseKey(hkSize);
    }

    RegCloseKey(hkSizes);
    return List;
}

/*
 * LoadClassicColorSchemes: Returns a list of classic theme colours from the registry key of a scheme
 */
static THEME_STYLE*
LoadClassicColorSchemes(VOID)
{
    INT Result;
    HKEY hkNewSchemes, hkScheme;
    INT iStyle;
    WCHAR wstrStyleName[5], wstrDisplayName[50];
    THEME_STYLE *List = NULL, *pCurrentStyle;

    Result = RegOpenKeyW(HKEY_CURRENT_USER, g_CPANewSchemes,  &hkNewSchemes);
    if (Result != ERROR_SUCCESS) return NULL;

    iStyle = 0;
    while ((RegEnumKeyW(hkNewSchemes, iStyle, wstrStyleName, 5) == ERROR_SUCCESS))
    {
        iStyle++;

        Result = RegOpenKeyW(hkNewSchemes, wstrStyleName,  &hkScheme);
        if (Result != ERROR_SUCCESS) continue;

        Result = RegLoadMUIStringW(hkScheme,
                                   L"DisplayName",
                                   wstrDisplayName,
                                   sizeof(wstrDisplayName),
                                   NULL,
                                   0,
                                   NULL);
        if (Result != ERROR_SUCCESS)
        {
            Result = RegLoadMUIStringW(hkScheme,
                                       L"LegacyName",
                                       wstrDisplayName,
                                       sizeof(wstrDisplayName),
                                       NULL,
                                       0,
                                       NULL);
        }

        if (Result == ERROR_SUCCESS)
            pCurrentStyle = CreateStyle(wstrStyleName, wstrDisplayName);
        else
            pCurrentStyle = CreateStyle(wstrStyleName, wstrStyleName);

        if (pCurrentStyle != NULL)
        {
            pCurrentStyle->NextStyle = List;
            pCurrentStyle->ChildStyle = LoadSchemeSizes(hkScheme);
            if(pCurrentStyle->ChildStyle == NULL)
                CleanupStyles(pCurrentStyle);
            else
                List = pCurrentStyle;
        }

        RegCloseKey(hkScheme);
    }

    RegCloseKey(hkNewSchemes);
    return List;
}

typedef HRESULT (WINAPI *ENUMTHEMESTYLE) (LPCWSTR, LPWSTR, DWORD, PTHEMENAMES);

static THEME_STYLE*
EnumThemeStyles(IN LPCWSTR pszThemeFileName, IN ENUMTHEMESTYLE pfnEnumTheme)
{
    DWORD index = 0;
    THEMENAMES names;
    THEME_STYLE *List = NULL, **ppPrevStyle, *pCurrentStyle;

    ppPrevStyle = &List;

    while (SUCCEEDED(pfnEnumTheme (pszThemeFileName, NULL, index++, &names)))
    {
        pCurrentStyle = CreateStyle(names.szName, names.szDisplayName);
        if(pCurrentStyle == NULL) break;

        *ppPrevStyle = pCurrentStyle;
        ppPrevStyle = &pCurrentStyle->NextStyle;
    }

    return List;
}

PTHEME LoadTheme(IN LPCWSTR pszThemeFileName,IN LPCWSTR pszThemeName)
{
    PTHEME pTheme = CreateTheme(pszThemeFileName, pszThemeName);
    if (pTheme == NULL)
        return NULL;

    pTheme->SizesList = EnumThemeStyles( pszThemeFileName, (ENUMTHEMESTYLE)EnumThemeSizes);
    pTheme->ColoursList = EnumThemeStyles( pszThemeFileName, (ENUMTHEMESTYLE)EnumThemeColors);
    if(pTheme->SizesList == NULL || pTheme->ColoursList == NULL)
    {
        CleanupThemes(pTheme);
        return NULL;
    }

    return pTheme;
}

BOOL CALLBACK
EnumThemeProc(IN LPVOID lpReserved,
              IN LPCWSTR pszThemeFileName,
              IN LPCWSTR pszThemeName,
              IN LPCWSTR pszToolTip,
              IN LPVOID lpReserved2,
              IN OUT LPVOID lpData)
{
    PTHEME *List, pTheme;

    List = (PTHEME*)lpData;
    pTheme = LoadTheme(pszThemeFileName, pszThemeName);
    if (pTheme == NULL) return FALSE;

    pTheme->NextTheme = *List;
    *List = pTheme;

    return TRUE;
}

/*
 * LoadThemes: Returns a list that contains tha classic theme and
 *             the visual styles of the system
 */
PTHEME
LoadThemes(VOID)
{
    HRESULT hret;
    PTHEME pClassicTheme;
    WCHAR strClassicTheme[40];
    WCHAR szThemesPath[MAX_PATH], *pszClassicTheme;
    int res;

    /* Insert the classic theme */
    res = LoadString(hApplet, IDS_CLASSIC_THEME, strClassicTheme, 40);
    pszClassicTheme = (res > 0 ? strClassicTheme : L"Classic Theme");
    pClassicTheme = CreateTheme(NULL, pszClassicTheme);
    if (pClassicTheme == NULL) return NULL;
    pClassicTheme->ColoursList = LoadClassicColorSchemes();

    /* Get path to themes folder */
    ZeroMemory(szThemesPath, sizeof(szThemesPath));
    hret = SHGetFolderPathW (NULL, CSIDL_RESOURCES, NULL, SHGFP_TYPE_DEFAULT, szThemesPath);
    if (FAILED(hret)) return pClassicTheme;
    lstrcatW (szThemesPath, L"\\Themes");

    /* Enumerate themes */
    hret = EnumThemes( szThemesPath, EnumThemeProc, &pClassicTheme->NextTheme);
    if (FAILED(hret))
    {
        pClassicTheme->NextTheme = NULL;
        if (pClassicTheme->ColoursList == NULL)
        {
            free(pClassicTheme->DisplayName);
            free(pClassicTheme);
            return NULL;
        }
    }

    return pClassicTheme;
}

/*
 * FindSelectedTheme: Finds the specified theme in the list of themes
 *                    or loads it if it was not loaded already.
 */
BOOL
FindOrAppendTheme(IN PTHEME pThemeList,
                  IN LPCWSTR pwszThemeFileName,
                  IN LPCWSTR pwszColorBuff,
                  IN LPCWSTR pwszSizeBuff,
                  OUT PTHEME_SELECTION pSelectedTheme)
{
    PTHEME pTheme;
    PTHEME pFoundTheme = NULL;

    ZeroMemory(pSelectedTheme, sizeof(THEME_SELECTION));

    for (pTheme = pThemeList; pTheme; pTheme = pTheme->NextTheme)
    {
        if (pTheme->ThemeFileName &&
           _wcsicmp(pTheme->ThemeFileName, pwszThemeFileName) == 0)
        {
            pFoundTheme = pTheme;
            break;
        }

        if (pTheme->NextTheme == NULL)
            break;
    }

    if (!pFoundTheme)
    {
        pFoundTheme = LoadTheme(pwszThemeFileName, pwszThemeFileName);
        if (!pFoundTheme)
            return FALSE;

        pTheme->NextTheme = pFoundTheme;
    }

    pSelectedTheme->ThemeActive = TRUE;
    pSelectedTheme->Theme = pFoundTheme;
    if (pwszColorBuff)
        pSelectedTheme->Color = FindStyle(pFoundTheme->ColoursList, pwszColorBuff);
    else
        pSelectedTheme->Color = pFoundTheme->ColoursList;

    if (pwszSizeBuff)
        pSelectedTheme->Size = FindStyle(pFoundTheme->SizesList, pwszSizeBuff);
    else
        pSelectedTheme->Size = pFoundTheme->SizesList;

    return TRUE;
}

/*
 * GetActiveTheme: Gets the active theme and populates pSelectedTheme
 *                 with entries from the list of loaded themes.
 */
BOOL
GetActiveTheme(IN PTHEME pThemeList, OUT PTHEME_SELECTION pSelectedTheme)
{
    WCHAR szThemeFileName[MAX_PATH];
    WCHAR szColorBuff[MAX_PATH];
    WCHAR szSizeBuff[MAX_PATH];
    HRESULT hret;

    /* Retrieve the name of the current theme */
    hret = GetCurrentThemeName(szThemeFileName,
                               MAX_PATH,
                               szColorBuff,
                               MAX_PATH,
                               szSizeBuff,
                               MAX_PATH);
    if (FAILED(hret))
        return FALSE;

    return FindOrAppendTheme(pThemeList, szThemeFileName, szColorBuff, szSizeBuff, pSelectedTheme);
}

/*
 * GetActiveTheme: Gets the active classic theme and populates pSelectedTheme
 *                 with entries from the list of loaded themes
 */
BOOL
GetActiveClassicTheme(IN PTHEME pThemeList, OUT PTHEME_SELECTION pSelectedTheme)
{
    INT Result;
    WCHAR szSelectedClassicScheme[5], szSelectedClassicSize[5];
    HKEY hkNewSchemes;
    DWORD dwType, dwDisplayNameLength;
    PTHEME_STYLE pCurrentStyle, pCurrentSize;

    ZeroMemory(pSelectedTheme, sizeof(THEME_SELECTION));

    /* Assume failure */
    szSelectedClassicScheme[0] = 0;
    szSelectedClassicSize[0] = 0;

    Result = RegOpenKeyW(HKEY_CURRENT_USER, g_CPANewSchemes, &hkNewSchemes);
    if (Result != ERROR_SUCCESS) return FALSE;

    dwType = REG_SZ;
    dwDisplayNameLength = sizeof(szSelectedClassicScheme);
    Result = RegQueryValueEx(hkNewSchemes, L"SelectedStyle", NULL, &dwType,
                             (LPBYTE)&szSelectedClassicScheme, &dwDisplayNameLength);
    if (Result == ERROR_SUCCESS)
    {
        dwType = REG_SZ;
        dwDisplayNameLength = sizeof(szSelectedClassicSize);
        Result = SHGetValue(hkNewSchemes, szSelectedClassicScheme, L"SelectedSize",
                            &dwType, szSelectedClassicSize, &dwDisplayNameLength);
    }

    RegCloseKey(hkNewSchemes);

    pCurrentStyle = FindStyle(pThemeList->ColoursList, szSelectedClassicScheme);
    pCurrentSize = FindStyle(pCurrentStyle->ChildStyle, szSelectedClassicSize);

    pSelectedTheme->Theme = pThemeList;
    pSelectedTheme->Color = pCurrentStyle;
    pSelectedTheme->Size = pCurrentSize;

    return TRUE;
}

BOOL
ActivateTheme(IN PTHEME_SELECTION pSelectedTheme)
{
    HTHEMEFILE hThemeFile = 0;
    HRESULT hret;

    if (pSelectedTheme->ThemeActive)
    {
        hret = OpenThemeFile(pSelectedTheme->Theme->ThemeFileName,
                             pSelectedTheme->Color->StyleName,
                             pSelectedTheme->Size->StyleName,
                             &hThemeFile,
                             0);

        if (!SUCCEEDED(hret)) return FALSE;
    }

    hret = ApplyTheme(hThemeFile, 0, 0);

    if (pSelectedTheme->ThemeActive)
    {
       CloseThemeFile(hThemeFile);
    }

    return SUCCEEDED(hret);
}

BOOL
LoadSchemeFromTheme(OUT PCOLOR_SCHEME scheme, IN PTHEME_SELECTION pSelectedTheme)
{
    HTHEMEFILE hThemeFile = 0;
    HRESULT hret;
    HTHEME hTheme;
    int i;

    hret = OpenThemeFile(pSelectedTheme->Theme->ThemeFileName,
                         pSelectedTheme->Color->StyleName,
                         pSelectedTheme->Size->StyleName,
                         &hThemeFile,
                         0);

    if (!SUCCEEDED(hret)) return FALSE;

    hTheme = OpenThemeDataFromFile(hThemeFile, hCPLWindow, L"WINDOW", 0);
    if (hTheme == NULL) return FALSE;

    /* Load colors */
    for (i = 0; i < NUM_COLORS; i++)
    {
        scheme->crColor[i] = GetThemeSysColor(hTheme,i);
    }

    /* Load sizes */
    /* I wonder why GetThemeSysInt doesn't work here */
    scheme->ncMetrics.iBorderWidth = GetThemeSysSize(hTheme, SM_CXFRAME);
    scheme->ncMetrics.iScrollWidth = GetThemeSysSize(hTheme, SM_CXVSCROLL);
    scheme->ncMetrics.iScrollHeight = GetThemeSysSize(hTheme, SM_CYHSCROLL);
    scheme->ncMetrics.iCaptionWidth = GetThemeSysSize(hTheme, SM_CXSIZE);
    scheme->ncMetrics.iCaptionHeight = GetThemeSysSize(hTheme, SM_CYSIZE);
    scheme->ncMetrics.iSmCaptionWidth = GetThemeSysSize(hTheme, SM_CXSMSIZE);
    scheme->ncMetrics.iSmCaptionHeight = GetThemeSysSize(hTheme, SM_CYSMSIZE);
    scheme->ncMetrics.iMenuWidth = GetThemeSysSize(hTheme, SM_CXMENUSIZE);
    scheme->ncMetrics.iMenuHeight = GetThemeSysSize(hTheme, SM_CYMENUSIZE);

    /* Load fonts */
    GetThemeSysFont(hTheme, TMT_CAPTIONFONT, &scheme->ncMetrics.lfCaptionFont);
    GetThemeSysFont(hTheme, TMT_SMALLCAPTIONFONT, &scheme->ncMetrics.lfSmCaptionFont);
    GetThemeSysFont(hTheme, TMT_MENUFONT, &scheme->ncMetrics.lfMenuFont );
    GetThemeSysFont(hTheme, TMT_STATUSFONT, &scheme->ncMetrics.lfStatusFont);
    GetThemeSysFont(hTheme, TMT_MSGBOXFONT, &scheme->ncMetrics.lfMessageFont);
    GetThemeSysFont(hTheme, TMT_ICONTITLEFONT, &scheme->icMetrics.lfFont);

    scheme->bFlatMenus = GetThemeSysBool(hTheme, TMT_FLATMENUS);

    CloseThemeData(hTheme);

    return TRUE;
}

BOOL
DrawThemePreview(IN HDC hdcMem, IN PCOLOR_SCHEME scheme, IN PTHEME_SELECTION pSelectedTheme, IN PRECT prcWindow)
{
    HBRUSH hbrBack;
    HRESULT hres;

    hbrBack = CreateSolidBrush(scheme->crColor[COLOR_DESKTOP]);

    FillRect(hdcMem, prcWindow, hbrBack);
    DeleteObject(hbrBack);

    InflateRect(prcWindow, -10, -10);

    hres = DrawNCPreview(hdcMem,
                         DNCP_DRAW_ALL,
                         prcWindow,
                         pSelectedTheme->Theme->ThemeFileName,
                         pSelectedTheme->Color->StyleName,
                         pSelectedTheme->Size->StyleName,
                         &scheme->ncMetrics,
                         scheme->crColor);

    return SUCCEEDED(hres);
}

BOOL ActivateThemeFile(LPCWSTR pwszFile)
{
    PTHEME pThemes;
    THEME_SELECTION selection;
    COLOR_SCHEME scheme;
    BOOL ret = FALSE;

    pThemes = LoadThemes();
    if (!pThemes)
        return FALSE;

    LoadCurrentScheme(&scheme);

    if (pwszFile)
    {
        ret = FindOrAppendTheme(pThemes, pwszFile, NULL, NULL, &selection);
        if (!ret)
            goto cleanup;

        ret = LoadSchemeFromTheme(&scheme, &selection);
        if (!ret)
            goto cleanup;
    }
    else
    {
        ret = GetActiveClassicTheme(pThemes, &selection);
        if (!ret)
            goto cleanup;

        ret = LoadSchemeFromReg(&scheme, &selection);
        if (!ret)
            goto cleanup;
    }

    ret = ActivateTheme(&selection);
    if (!ret)
        goto cleanup;

    ApplyScheme(&scheme, &selection);

    ret = TRUE;

cleanup:
    CleanupThemes(pThemes);

    return ret;
}

/* TODO: */
INT_PTR CALLBACK
ThemesPageProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    LPNMHDR lpnm;

    switch (uMsg)
    {
        case WM_INITDIALOG:
            break;

        case WM_COMMAND:
            break;

        case WM_NOTIFY:
            lpnm = (LPNMHDR)lParam;
            switch (lpnm->code)
            {
                case PSN_APPLY:
                    SendMessage(HWND_BROADCAST, WM_SETTINGCHANGE, 0, (LPARAM)TEXT(""));
                    return TRUE;
            }
            break;

        case WM_DESTROY:
            break;
    }

    return FALSE;
}