CRegTreeOptions Class Reference

#include <regtreeoptions.h>

Inheritance diagram for CRegTreeOptions:

Collaboration diagram for CRegTreeOptions:

Public Member Functions
	CRegTreeOptions ()
	~CRegTreeOptions ()
void	AddItemsFromRegistry (HKEY hKey, HTREEITEM hParent, HTREEITEM hInsertAfter)
HRESULT	GetSetState (HKEY hKey, DWORD &Type, LPBYTE Data, DWORD &Size, BOOL Set)
HRESULT	GetCheckState (HKEY hKey, BOOL UseDefault=FALSE)
HRESULT	SaveCheckState (HKEY hKey, BOOL Checked)
void	WalkTree (WALK_TREE_CMD Command, HWND hTree, HTREEITEM hTI)
STDMETHOD()	InitTree (HWND hTV, HKEY hKey, LPCSTR SubKey, char const *pUnknown) override
STDMETHOD()	WalkTree (WALK_TREE_CMD Command) override
STDMETHOD()	ToggleItem (HTREEITEM hTI) override
STDMETHOD()	ShowHelp (HTREEITEM hTI, unsigned long Unknown) override
Public Member Functions inherited from ATL::CComObjectRootEx< CComMultiThreadModelNoCS >
	~CComObjectRootEx ()
ULONG	InternalAddRef ()
ULONG	InternalRelease ()
void	Lock ()
void	Unlock ()
HRESULT	_AtlInitialConstruct ()
Public Member Functions inherited from ATL::CComObjectRootBase
	CComObjectRootBase ()
	~CComObjectRootBase ()
void	SetVoid (void *)
HRESULT	_AtlFinalConstruct ()
HRESULT	FinalConstruct ()
void	InternalFinalConstructAddRef ()
void	InternalFinalConstructRelease ()
void	FinalRelease ()

Private Attributes
HWND	m_hTree
HIMAGELIST	m_hIL

Additional Inherited Members
Static Public Member Functions inherited from ATL::CComObjectRootBase
static void WINAPI	ObjectMain (bool)
static const struct _ATL_CATMAP_ENTRY *	GetCategoryMap ()
static HRESULT WINAPI	InternalQueryInterface (void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject)
Public Attributes inherited from ATL::CComObjectRootBase
LONG	m_dwRef

Detailed Description

Definition at line 10 of file regtreeoptions.h.

Constructor & Destructor Documentation

CRegTreeOptions()

CRegTreeOptions::CRegTreeOptions

(

)

Definition at line 409 of file regtreeoptions.cpp.

{
    m_hTree = NULL;
    m_hIL = NULL;
}

~CRegTreeOptions()

CRegTreeOptions::~CRegTreeOptions

(

)

Definition at line 415 of file regtreeoptions.cpp.

{
    if (m_hIL && m_hTree)
        ImageList_Destroy(TreeView_SetImageList(m_hTree, NULL, TVSIL_NORMAL));
}

Member Function Documentation

AddItemsFromRegistry()

void CRegTreeOptions::AddItemsFromRegistry	(	HKEY	hKey,
		HTREEITEM	hParent,
		HTREEITEM	hInsertAfter
	)

Definition at line 421 of file regtreeoptions.cpp.

{
    for (DWORD Index = 0, cchName;;)
    {
        WCHAR Name[MAX_PATH], Temp[MAX_PATH];
        cchName = _countof(Name);
        if (RegEnumKeyExW(hKey, Index++, Name, &cchName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
            break;
 
        HKEY hItemKey, hCloseKey = NULL;
        if (RegOpenKeyExW(hKey, Name, 0, KEY_READ, &hItemKey) != ERROR_SUCCESS)
            continue;
 
        TVINSERTSTRUCT tvis;
        TVITEM &tvi = tvis.item;
        tvi.mask = TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
        tvi.lParam = (LPARAM)hItemKey;
        UINT Type = TYPE_INVALID;
        if (GetRegString(hItemKey, L"Type", Temp, _countof(Temp)) > 0)
        {
            if (!lstrcmpi(Temp, L"checkbox"))
                Type = TYPE_CHECK;
            if (!lstrcmpi(Temp, L"radio"))
                Type = TYPE_RADIO;
            if (!lstrcmpi(Temp, L"group"))
                Type = TYPE_GROUP;
        }
        BOOL Valid = Type != TYPE_INVALID;
 
        if (Type == TYPE_GROUP)
        {
            tvi.lParam = 0;
            hCloseKey = hItemKey;
            tvi.iImage = AddIconFromRegistry(m_hIL, hItemKey, L"Bitmap");
        }
        else if (Valid)
        {
            HRESULT hr = GetCheckState(hItemKey);
            Valid = SUCCEEDED(hr);
            tvi.iImage = (Type * STATEIMAGESPERTYPE) | (hr == S_OK);
        }
 
        if (Valid)
        {
            if (SUCCEEDED(SHLoadRegUIStringW(hItemKey, L"Text", Temp, _countof(Temp))))
                tvi.pszText = Temp;
            else
                tvi.pszText = Name;
#ifdef __REACTOS__ // Grayed is a ROS extension
            DWORD grayed = GetRegDWORD(hItemKey, L"Grayed", DWORD(FALSE));
            if (grayed)
            {
                tvi.lParam = (LPARAM)HKEY_GRAYED;
                hCloseKey = hItemKey;
                tvi.iImage += 2; // Use disabled state image
                if (grayed & 4)
                    tvi.iImage = (tvi.iImage & ~1) | ((grayed & 2) != 0); // Force a specific state
            }
#endif
            tvi.iSelectedImage = tvi.iImage;
            tvis.hParent = hParent;
            tvis.hInsertAfter = hInsertAfter;
            Valid = (tvi.hItem = TreeView_InsertItem(m_hTree, &tvis)) != NULL;
        }
 
        if (Valid && Type == TYPE_GROUP)
        {
            AddItemsFromRegistry(hItemKey, tvi.hItem, TVI_FIRST);
            TreeView_Expand(m_hTree, tvi.hItem, TVE_EXPAND);
        }
        if (!Valid)
            RegCloseKey(hItemKey);
        if (hCloseKey && hItemKey != hCloseKey)
            RegCloseKey(hCloseKey);
    }
    SendMessage(m_hTree, TVM_SORTCHILDREN, 0, (LPARAM)hParent);
}

Referenced by AddItemsFromRegistry(), and InitTree().

GetCheckState()

HRESULT CRegTreeOptions::GetCheckState	(	HKEY	hKey,
		BOOL	UseDefault = FALSE
	)

Definition at line 290 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 == (UINT)REG_GET_DIRECT)
    {
        Checked = *(BOOL*)CurrData;
    }
    else 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 AddItemsFromRegistry(), and WalkTree().

GetSetState()

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

Definition at line 166 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;
    }
 
    // learn.microsoft.com/en-us/windows/win32/api/shobjidl_core/nn-shobjidl_core-iregtreeitem
    WCHAR szTemp[42];
    CLSID clsid;
    if (SUCCEEDED(GetRegString(hKey, L"CLSID", szTemp, _countof(szTemp))) &&
        SUCCEEDED(CLSIDFromString(szTemp, &clsid)))
    {
        IRegTreeItem *pRTI;
        if (SUCCEEDED(hr = IUnknown_QueryService(m_pUnkSite, clsid, IID_PPV_ARG(IRegTreeItem, &pRTI))) ||
            SUCCEEDED(hr = SHCoCreateInstance(NULL, &clsid, NULL, IID_PPV_ARG(IRegTreeItem, &pRTI))))
        {
            BOOL *boolptr = (BOOL*)Data;
            Size = sizeof(BOOL);
            Type = REG_GET_DIRECT;
            hr = Set ? pRTI->SetCheckState(*boolptr) : pRTI->GetCheckState(boolptr);
            pRTI->Release();
        }
        return hr;
    }
 
    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().

InitTree()

HRESULT STDMETHODCALLTYPE CRegTreeOptions::InitTree ( HWND  hTV, HKEY  hKey, LPCSTR  SubKey, char const *  pUnknown  )

override

Definition at line 499 of file regtreeoptions.cpp.

{
    UNREFERENCED_PARAMETER(pUnknown);
    m_hTree = hTV;
 
    m_hIL = CreateStateImages(GetSystemMetrics(SM_CXSMICON));
    HIMAGELIST hIL = TreeView_SetImageList(hTV, m_hIL, TVSIL_NORMAL);
    if (hIL)
        ImageList_Destroy(hIL);
 
    WCHAR Path[MAX_PATH];
    SHAnsiToUnicode(SubKey, Path, _countof(Path));
    if (RegOpenKeyExW(hKey, Path, 0, KEY_ENUMERATE_SUB_KEYS, &hKey) == ERROR_SUCCESS)
    {
        AddItemsFromRegistry(hKey, TVI_ROOT, TVI_ROOT);
        RegCloseKey(hKey);
    }
 
    TreeView_EnsureVisible(hTV, TreeView_GetRoot(hTV));
    return E_NOTIMPL;
}

SaveCheckState()

HRESULT CRegTreeOptions::SaveCheckState	(	HKEY	hKey,
		BOOL	Checked
	)

Definition at line 347 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().

ShowHelp()

HRESULT STDMETHODCALLTYPE CRegTreeOptions::ShowHelp ( HTREEITEM  hTI, unsigned long  Unknown  )

override

Definition at line 571 of file regtreeoptions.cpp.

{
    return E_NOTIMPL;
}

ToggleItem()

HRESULT STDMETHODCALLTYPE CRegTreeOptions::ToggleItem ( HTREEITEM  hTI )

override

Definition at line 531 of file regtreeoptions.cpp.

{
    TVITEM tvi;
    tvi.mask = TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
    tvi.hItem = hTI;
    if (!tvi.hItem || !TreeView_GetItem(m_hTree, &tvi))
        return E_INVALIDARG;
 
    if (tvi.iImage >= STATE_GROUP || (HKEY)tvi.lParam == HKEY_GRAYED)
        return S_FALSE;
 
    if (tvi.iImage <= max(STATE_CHECKOFF, STATE_CHECKON))
    {
        tvi.iImage ^= 1;
    }
    else
    {
        HTREEITEM hRadio = TreeView_GetChild(m_hTree, TreeView_GetParent(m_hTree, hTI));
        while (hRadio) // Turn off everyone in this group
        {
            tvi.hItem = hRadio;
            tvi.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE;
            if (TreeView_GetItem(m_hTree, &tvi) && tvi.iImage == STATE_RADIOON && hRadio != hTI)
            {
                tvi.iImage ^= 1;
                tvi.iSelectedImage = tvi.iImage;
                TreeView_SetItem(m_hTree, &tvi);
            }
            hRadio = TreeView_GetNextSibling(m_hTree, hRadio);
        }
        tvi.iImage = STATE_RADIOON;
    }
 
    tvi.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE;
    tvi.hItem = hTI;
    tvi.iSelectedImage = tvi.iImage;
    TreeView_SetItem(m_hTree, &tvi);
    return S_OK;
}

WalkTree() [1/2]

HRESULT STDMETHODCALLTYPE CRegTreeOptions::WalkTree ( WALK_TREE_CMD  Command )

override

Definition at line 521 of file regtreeoptions.cpp.

{
    for (HTREEITEM hTI = TreeView_GetRoot(m_hTree); hTI;)
    {
        WalkTree(Command, m_hTree, hTI);
        hTI = TreeView_GetNextSibling(m_hTree, hTI);
    }
    return S_OK;
}

WalkTree() [2/2]

void CRegTreeOptions::WalkTree	(	WALK_TREE_CMD	Command,
		HWND	hTree,
		HTREEITEM	hTI
	)

Definition at line 359 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 WalkTree().

Member Data Documentation

m_hIL

HIMAGELIST CRegTreeOptions::m_hIL

private

Definition at line 18 of file regtreeoptions.h.

Referenced by AddItemsFromRegistry(), CRegTreeOptions(), InitTree(), and ~CRegTreeOptions().

m_hTree

HWND CRegTreeOptions::m_hTree

private

Definition at line 17 of file regtreeoptions.h.

Referenced by AddItemsFromRegistry(), CRegTreeOptions(), InitTree(), ToggleItem(), WalkTree(), and ~CRegTreeOptions().

---

The documentation for this class was generated from the following files:

• dll/win32/browseui/regtreeoptions.h
• dll/win32/browseui/regtreeoptions.cpp