regtreeoptions.cpp File Reference

#include "precomp.h"

Include dependency graph for regtreeoptions.cpp:

Go to the source code of this file.

Macros
#define	HKEY_GRAYED   HKEY_REGTREEOPTION_GRAYED
#define	MAXVALUEDATA   100

Enumerations
enum	{   TYPE_CHECK = 0 , TYPE_RADIO , TYPE_GROUP , TYPE_INVALID ,   STATEIMAGESPERTYPE = 4 , STATE_CHECKOFF = TYPE_CHECK * STATEIMAGESPERTYPE , STATE_CHECKON , STATE_RADIOOFF = TYPE_RADIO * STATEIMAGESPERTYPE ,   STATE_RADIOON , STATE_GROUP = TYPE_GROUP * STATEIMAGESPERTYPE }

Functions
	C_ASSERT ((STATE_CHECKON &1) &&(STATE_RADIOON &1) &&STATE_RADIOON< STATE_GROUP)
static HBITMAP	CreatDibBitmap (HDC hDC, UINT cx, UINT cy, UINT bpp)
static HIMAGELIST	CreateStateImages (UINT ImageSize)
static DWORD	NormalizeRegType (DWORD Type)
static DWORD	GetRegDWORD (HKEY hKey, LPCWSTR Name, PDWORD Data)
static DWORD	GetRegDWORD (HKEY hKey, LPCWSTR Name, DWORD Default)
static HRESULT	GetRegString (HKEY hKey, LPCWSTR Name, LPWSTR Buffer, DWORD cchBuffer)
static int	AddIconFromRegistry (HIMAGELIST hIL, HKEY hKey, LPCWSTR Name)
static HRESULT	GetDefaultValue (HKEY hKey, DWORD &Type, LPVOID Data, DWORD &Size)
static HRESULT	GetSetState (HKEY hKey, DWORD &Type, LPBYTE Data, DWORD &Size, BOOL Set)
static HRESULT	GetCheckState (HKEY hKey, BOOL UseDefault=FALSE)
static HRESULT	SaveCheckState (HKEY hKey, BOOL Checked)
static void	WalkTree (WALK_TREE_CMD Command, HWND hTree, HTREEITEM hTI)

Macro Definition Documentation

HKEY_GRAYED

#define HKEY_GRAYED   HKEY_REGTREEOPTION_GRAYED

Definition at line 10 of file regtreeoptions.cpp.

MAXVALUEDATA

#define MAXVALUEDATA   100

Definition at line 11 of file regtreeoptions.cpp.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
TYPE_CHECK
TYPE_RADIO
TYPE_GROUP
TYPE_INVALID
STATEIMAGESPERTYPE
STATE_CHECKOFF
STATE_CHECKON
STATE_RADIOOFF
STATE_RADIOON
STATE_GROUP

Definition at line 13 of file regtreeoptions.cpp.

     {
    TYPE_CHECK = 0,
    TYPE_RADIO,
    TYPE_GROUP,
    TYPE_INVALID,
    STATEIMAGESPERTYPE = 4,
    STATE_CHECKOFF = TYPE_CHECK * STATEIMAGESPERTYPE,
    STATE_CHECKON,
    STATE_RADIOOFF = TYPE_RADIO * STATEIMAGESPERTYPE,
    STATE_RADIOON,
    STATE_GROUP    = TYPE_GROUP * STATEIMAGESPERTYPE,
};

Function Documentation

AddIconFromRegistry()

static int AddIconFromRegistry ( HIMAGELIST  hIL, HKEY  hKey, LPCWSTR  Name  )

static

Definition at line 141 of file regtreeoptions.cpp.

{
    WCHAR Path[MAX_PATH + 42];
    if (GetRegString(hKey, Name, Path, _countof(Path)) > 0) // Will %expand% for us
    {
        int idx = PathParseIconLocationW(Path);
        HICON hIcon = NULL;
        if (ExtractIconExW(Path, idx * -1, NULL, &hIcon, 1)) // Note: Index/Id is opposite of DefaultIcon style
        {
            idx = ImageList_AddIcon(hIL, hIcon);
            DestroyIcon(hIcon);
            if (idx != -1)
                return idx;
        }
    }
    return I_IMAGENONE;
}

Referenced by CRegTreeOptions::AddItemsFromRegistry().

C_ASSERT()

C_ASSERT

(

)

CreatDibBitmap()

static HBITMAP CreatDibBitmap ( HDC  hDC, UINT  cx, UINT  cy, UINT  bpp  )

static

Definition at line 28 of file regtreeoptions.cpp.

{
    BITMAPINFO bi;
    PVOID pvBits;
 
    ZeroMemory(&bi, sizeof(bi));
    bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
    bi.bmiHeader.biWidth = cx;
    bi.bmiHeader.biHeight = cy;
    bi.bmiHeader.biPlanes = 1;
    bi.bmiHeader.biBitCount = bpp;
    bi.bmiHeader.biCompression = BI_RGB;
    return CreateDIBSection(hDC, &bi, DIB_RGB_COLORS, &pvBits, NULL, 0);
}

Referenced by CreateStateImages().

CreateStateImages()

static HIMAGELIST CreateStateImages ( UINT  ImageSize )

static

Definition at line 43 of file regtreeoptions.cpp.

{
    enum { bpp = 32 };
    UINT Failed = FALSE, State;
    HIMAGELIST hIL = ImageList_Create(ImageSize, ImageSize, ILC_MASK | bpp, 8, 0);
    if (!hIL)
        return hIL;
 
    INT BorderSize = max(1, min(ImageSize / 16, 4));
    RECT Rect;
    HDC hDC = CreateCompatibleDC(NULL);
 
    HBITMAP hbmMask = CreateBitmap(ImageSize, ImageSize, 1, 1, NULL);
    Failed |= hbmMask == NULL;
 
    HBITMAP hbmData = CreatDibBitmap(hDC, ImageSize, ImageSize, bpp);
    Failed |= hbmData == NULL;
 
    const HGDIOBJ hbmOld = SelectObject(hDC, hbmMask);
    Failed |= hbmOld == NULL;
 
    // Create the check images
    SetRect(&Rect, 0, 0, ImageSize, ImageSize);
    FillRect(hDC, &Rect, HBRUSH(GetStockObject(WHITE_BRUSH)));
    InflateRect(&Rect, -BorderSize, -BorderSize);
    FillRect(hDC, &Rect, HBRUSH(GetStockObject(BLACK_BRUSH)));
 
    SelectObject(hDC, hbmData);
    State = DFCS_BUTTONCHECK | DFCS_FLAT | DFCS_MONO;
    DrawFrameControl(hDC, &Rect, DFC_BUTTON, State);
    Failed |= ImageList_Add(hIL, hbmData, hbmMask) < 0;
    DrawFrameControl(hDC, &Rect, DFC_BUTTON, State | DFCS_CHECKED);
    Failed |= ImageList_Add(hIL, hbmData, hbmMask) < 0;
    DrawFrameControl(hDC, &Rect, DFC_BUTTON, State | DFCS_INACTIVE);
    Failed |= ImageList_Add(hIL, hbmData, hbmMask) < 0;
    DrawFrameControl(hDC, &Rect, DFC_BUTTON, State | DFCS_CHECKED | DFCS_INACTIVE);
    Failed |= ImageList_Add(hIL, hbmData, hbmMask) < 0;
 
    // Create the radio images
    SelectObject(hDC, hbmMask);
    SetRect(&Rect, 0, 0, ImageSize, ImageSize);
    FillRect(hDC, &Rect, HBRUSH(GetStockObject(WHITE_BRUSH)));
    InflateRect(&Rect, -BorderSize, -BorderSize);
    DrawFrameControl(hDC, &Rect, DFC_BUTTON, DFCS_BUTTONRADIOMASK | DFCS_FLAT | DFCS_MONO);
 
    SelectObject(hDC, hbmData);
    State = DFCS_BUTTONRADIOIMAGE | DFCS_FLAT | DFCS_MONO;
    DrawFrameControl(hDC, &Rect, DFC_BUTTON, State);
    Failed |= ImageList_Add(hIL, hbmData, hbmMask) < 0;
    DrawFrameControl(hDC, &Rect, DFC_BUTTON, State | DFCS_CHECKED);
    Failed |= ImageList_Add(hIL, hbmData, hbmMask) < 0;
    DrawFrameControl(hDC, &Rect, DFC_BUTTON, State | DFCS_INACTIVE);
    Failed |= ImageList_Add(hIL, hbmData, hbmMask) < 0;
    DrawFrameControl(hDC, &Rect, DFC_BUTTON, State | DFCS_CHECKED | DFCS_INACTIVE);
    Failed |= ImageList_Add(hIL, hbmData, hbmMask) < 0;
 
    SelectObject(hDC, hbmOld);
    DeleteObject(hbmMask);
    DeleteObject(hbmData);
    DeleteDC(hDC);
    if (Failed)
    {
        ImageList_Destroy(hIL);
        hIL = NULL;
    }
    return hIL;
}

Referenced by CRegTreeOptions::InitTree().

GetCheckState()

static HRESULT GetCheckState ( HKEY  hKey, BOOL  UseDefault = FALSE  )

static

Definition at line 289 of file regtreeoptions.cpp.

{
    BYTE CurrData[MAXVALUEDATA], CheckData[MAXVALUEDATA];
    DWORD CurrType, CheckType, CurrSize, CheckSize, Err, Checked;
 
    if (hKey == HKEY_GRAYED)
        return HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
 
    CheckSize = sizeof(CheckData);
    Err = SHRegGetValueW(hKey, NULL, L"CheckedValue", SRRF_RT_ANY, &CheckType, CheckData, &CheckSize);
    if (Err)
        return HRESULT_FROM_WIN32(Err);
 
    HRESULT hr = E_FAIL;
    if (!UseDefault)
    {
        CurrSize = sizeof(CurrData);
        hr = GetSetState(hKey, CurrType, CurrData, CurrSize, FALSE);
    }
    if (FAILED(hr))
    {
        CurrSize = sizeof(CurrData);
        hr = GetDefaultValue(hKey, CurrType, CurrData, CurrSize);
    }
    if (FAILED(hr))
    {
        return hr;
    }
 
    CurrType = NormalizeRegType(CurrType);
    CheckType = NormalizeRegType(CheckType);
    if (CurrType != CheckType)
    {
        return HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
    }
    else if (CheckType == REG_SZ)
    {
        *(LPWSTR)(&CheckData[sizeof(CheckData) - sizeof(WCHAR)]) = UNICODE_NULL;
        if (CheckSize <= sizeof(CheckData) - sizeof(WCHAR))
            *(LPWSTR)(&CheckData[CheckSize]) = UNICODE_NULL;
        Checked = !lstrcmpiW((LPWSTR)CheckData, (LPWSTR)CurrData);
    }
    else if (CheckType == REG_BINARY)
    {
        Checked = CheckSize == CurrSize && !memcmp(CheckData, CurrData, CurrSize);
    }
    else
    {
        return HRESULT_FROM_WIN32(ERROR_BAD_FORMAT);
    }
    return Checked ? S_OK : S_FALSE;
}

Referenced by CRegTreeOptions::AddItemsFromRegistry(), and WalkTree().

GetDefaultValue()

static HRESULT GetDefaultValue ( HKEY  hKey, DWORD &  Type, LPVOID  Data, DWORD &  Size  )

static

Definition at line 159 of file regtreeoptions.cpp.

{
    DWORD Err = SHRegGetValueW(hKey, NULL, L"DefaultValue", SRRF_RT_ANY, &Type, Data, &Size);
    return HRESULT_FROM_WIN32(Err);
}

Referenced by GetCheckState(), and GetSetState().

GetRegDWORD() [1/2]

static DWORD GetRegDWORD ( HKEY  hKey, LPCWSTR  Name, DWORD  Default  )

static

Definition at line 127 of file regtreeoptions.cpp.

{
    DWORD Data = Default, Size = sizeof(Data);
    DWORD Err = SHRegGetValueW(hKey, NULL, Name, SRRF_RT_DWORD, NULL, &Data, &Size);
    return Err ? Default : Data;
}

GetRegDWORD() [2/2]

static DWORD GetRegDWORD ( HKEY  hKey, LPCWSTR  Name, PDWORD  Data  )

inlinestatic

Definition at line 121 of file regtreeoptions.cpp.

{
    DWORD Size = sizeof(*Data);
    return SHRegGetValueW(hKey, NULL, Name, SRRF_RT_DWORD, NULL, Data, &Size);
}

Referenced by CRegTreeOptions::AddItemsFromRegistry(), and GetSetState().

GetRegString()

static HRESULT GetRegString ( HKEY  hKey, LPCWSTR  Name, LPWSTR  Buffer, DWORD  cchBuffer  )

static

Definition at line 134 of file regtreeoptions.cpp.

{
    DWORD Size = cchBuffer * sizeof(*Buffer);
    DWORD Err = SHRegGetValueW(hKey, NULL, Name, SRRF_RT_REG_SZ, NULL, Buffer, &Size);
    return Err ? HRESULT_FROM_WIN32(Err) : Size / sizeof(*Buffer);
}

Referenced by AddIconFromRegistry(), and GetSetState().

GetSetState()

static HRESULT GetSetState ( HKEY  hKey, DWORD &  Type, LPBYTE  Data, DWORD &  Size, BOOL  Set  )

static

Definition at line 165 of file regtreeoptions.cpp.

{
    HRESULT hr;
    UINT SysParam = GetRegDWORD(hKey, Set ? L"SPIActionSet" : L"SPIActionGet", DWORD(0));
    if (SysParam)
    {
        Size = sizeof(BOOL);
        Type = REG_DWORD;
        SHBoolSystemParametersInfo(SysParam, Data);
        return S_OK;
    }
 
#if 0 // TODO
    // learn.microsoft.com/en-us/windows/win32/api/shobjidl_core/nn-shobjidl_core-iregtreeitem
    CLSID clsid;
    if (SUCCEEDED(GetRegString(hKey, "CLSID", Temp, _countof(Temp))) && ..(Temp, &clsid))
    {
        IRegTreeItem *pRTI;
        if (SUCCEEDED(hr = IUnknown_QueryService(m_pUnkSite, clsid, IID_PPV_ARG(IRegTreeItem, &pti))) ||
            SUCCEEDED(hr = SHCoCreateInstance(NULL, &clsid, NULL, IID_PPV_ARG(IRegTreeItem, &pRTI))))
        {
            BOOL *boolptr = (BOOL*)Data;
            Size = sizeof(BOOL);
            Type = REG_DWORD;
            hr = Set ? pRTI->SetCheckState(*boolptr) : pRTI->GetCheckState(boolptr);
            pRTI->Release();
        }
        return hr;
    }
#endif
 
    DWORD Mask = ~DWORD(0), Offset = 0;
    BOOL HasMask = GetRegDWORD(hKey, L"Mask", &Mask) == ERROR_SUCCESS;
    BOOL HasOffset = GetRegDWORD(hKey, L"Offset", &Offset) == ERROR_SUCCESS;
 
    HKEY hValueKey = (HKEY)LongToHandle(GetRegDWORD(hKey, L"HKeyRoot", HandleToLong(HKEY_CURRENT_USER)));
    WCHAR SubKey[MAX_PATH], Name[100];
    hr = GetRegString(hKey, L"RegPath", SubKey, _countof(SubKey));
    if (FAILED(hr))
        return hr;
    hr = GetRegString(hKey, L"ValueName", Name, _countof(Name));
    if (FAILED(hr))
        return hr;
    DWORD Err, cb;
    if (Set)
        Err = RegCreateKeyExW(hValueKey, SubKey, 0, NULL, 0, KEY_READ | KEY_SET_VALUE, NULL, &hValueKey, NULL);
    else
        Err = RegOpenKeyExW(hValueKey, SubKey, 0, KEY_READ, &hValueKey);
    if (Err)
        return HRESULT_FROM_WIN32(Err);
 
    if (Set && (HasMask || HasOffset))
    {
        Err = SHRegGetValueW(hValueKey, NULL, Name, SRRF_RT_ANY, NULL, NULL, &cb);
        hr = HRESULT_FROM_WIN32(Err);
        if (Err == ERROR_FILE_NOT_FOUND)
        {
            DWORD DefaultData = 0;
            cb = sizeof(DefaultData);
            hr = GetDefaultValue(hKey, Type, &DefaultData, cb);
            if (SUCCEEDED(hr))
            {
                Err = SHSetValueW(hValueKey, NULL, Name, Type, &DefaultData, cb);
                hr = HRESULT_FROM_WIN32(Err);
            }
        }
 
        if (SUCCEEDED(hr))
        {
            Err = ERROR_OUTOFMEMORY;
            cb = max(cb, (Offset + 1) * sizeof(DWORD));
            if (PDWORD pBigData = (PDWORD)LocalAlloc(LPTR, cb)) // LPTR to zero extended data
            {
                Err = SHRegGetValueW(hValueKey, NULL, Name, SRRF_RT_ANY, &Type, pBigData, &cb);
                Size = cb;
                if (Err == ERROR_SUCCESS)
                {
                    pBigData[Offset] &= ~Mask;
                    pBigData[Offset] |= *((PDWORD)Data);
                    Err = SHSetValueW(hValueKey, NULL, Name, Type, pBigData, cb);
                }
                LocalFree(pBigData);
            }
            hr = HRESULT_FROM_WIN32(Err);
        }
    }
    else if (Set)
    {
        Err = SHSetValueW(hValueKey, NULL, Name, Type, Data, Size);
        hr = HRESULT_FROM_WIN32(Err);
    }
    else
    {
        if (Offset && HasOffset)
        {
            Size = sizeof(DWORD);
            Err = SHRegGetValueW(hValueKey, NULL, Name, SRRF_RT_ANY, NULL, NULL, &cb);
            if (Err == ERROR_SUCCESS)
            {
                Err = ERROR_OUTOFMEMORY;
                if (PDWORD pBigData = (PDWORD)LocalAlloc(LPTR, cb))
                {
                    Err = SHRegGetValueW(hValueKey, NULL, Name, SRRF_RT_ANY, &Type, pBigData, &cb);
                    if (Offset < cb / sizeof(DWORD) && Err == ERROR_SUCCESS)
                        *((PDWORD)Data) = pBigData[Offset];
                    else
                        *((PDWORD)Data) = 0; // Value not present or offset too large
                    LocalFree(pBigData);
                }
            }
        }
        else
        {
            Err = SHRegGetValueW(hValueKey, NULL, Name, SRRF_RT_ANY, &Type, Data, &Size);
        }
 
        hr = HRESULT_FROM_WIN32(Err);
        if (HasMask && SUCCEEDED(hr))
            *((PDWORD)Data) &= Mask;
    }
    RegCloseKey(hValueKey);
    return hr;
}

Referenced by GetCheckState(), and SaveCheckState().

NormalizeRegType()

static DWORD NormalizeRegType ( DWORD  Type )

inlinestatic

Definition at line 111 of file regtreeoptions.cpp.

{
    switch (Type)
    {
        case REG_EXPAND_SZ: return REG_SZ;
        case REG_DWORD: return REG_BINARY;
        default: return Type;
    }
}

Referenced by GetCheckState().

SaveCheckState()

static HRESULT SaveCheckState ( HKEY  hKey, BOOL  Checked  )

static

Definition at line 342 of file regtreeoptions.cpp.

{
    BYTE Data[MAXVALUEDATA];
    DWORD Type = REG_DWORD, Size = sizeof(Data);
    *((PDWORD)Data) = Checked;
    LPCWSTR Name = Checked ? L"CheckedValue" : L"UncheckedValue";
    DWORD Err = SHRegGetValueW(hKey, NULL, Name, SRRF_RT_ANY, &Type, Data, &Size);
    if (Err == ERROR_FILE_NOT_FOUND)
        Err = ERROR_SUCCESS;
    return Err ? HRESULT_FROM_WIN32(Err) : GetSetState(hKey, Type, Data, Size, TRUE);
}

Referenced by WalkTree().

WalkTree()

static void WalkTree ( WALK_TREE_CMD  Command, HWND  hTree, HTREEITEM  hTI  )

static

Definition at line 354 of file regtreeoptions.cpp.

{
    for (HTREEITEM hChildTI = TreeView_GetChild(hTree, hTI); hChildTI;)
    {
        WalkTree(Command, hTree, hChildTI);
        hChildTI = TreeView_GetNextSibling(hTree, hChildTI);
    }
 
    TVITEM tvi;
    tvi.mask = TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
    tvi.hItem = hTI;
    if (!TreeView_GetItem(hTree, &tvi))
        return;
 
    HKEY hKey = (HKEY)tvi.lParam;
    UINT State = tvi.iImage;
    switch (Command)
    {
        case WALK_TREE_SAVE:
            if (State == STATE_CHECKON || State == STATE_RADIOON)
                SaveCheckState(hKey, TRUE);
            else if (State == STATE_CHECKOFF)
                SaveCheckState(hKey, FALSE);
            break;
 
        case WALK_TREE_DESTROY:
            if (hKey && hKey != HKEY_GRAYED)
            {
                RegCloseKey(hKey);
                tvi.lParam = 0;
                tvi.mask = TVIF_PARAM;
                TreeView_SetItem(hTree, &tvi);
            }
            break;
 
        case WALK_TREE_DEFAULT:
        case WALK_TREE_REFRESH:
            if (State < STATE_GROUP)
            {
                HRESULT hr = GetCheckState(hKey, Command == WALK_TREE_DEFAULT);
                if (SUCCEEDED(hr))
                {
                    tvi.iImage = tvi.iSelectedImage = (tvi.iImage & ~1) | (hr == S_OK);
                    TreeView_SetItem(hTree, &tvi);
                }
            }
            break;
    }
}

Referenced by DECLARE_INTERFACE_(), and WalkTree().