windows-server-2003/shell/ext/dsui/dsuiext/browse.cpp

#include "pch.h"
#include "helpids.h"
#include <atlbase.h>
#pragma hdrstop


/*-----------------------------------------------------------------------------
/ Constants and other helpers
/----------------------------------------------------------------------------*/

//                                                                                    
// Page size used for paging the result sets (better performance)
//
#define PAGE_SIZE                  128

WCHAR c_szQueryNormal[]            = L"(&(objectClass=*)(!showInAdvancedViewOnly=TRUE))";
WCHAR c_szQueryAll[]               = L"(objectClass=*)";
WCHAR c_szShowInAdvancedViewOnly[] = L"showInAdvancedViewOnly";
WCHAR c_szObjectClass[]            = L"objectClass";
WCHAR c_szADsPath[]                = L"ADsPath";
WCHAR c_szName[]                   = L"name";
WCHAR c_szRDN[]                    = L"rdn";
WCHAR c_szLDAPPrefix[]             = L"LDAP://";


/*-----------------------------------------------------------------------------
/ CBrowseDlg class definition
/----------------------------------------------------------------------------*/

class CBrowseDlg
{
private:
    
    // a UNICODE version of the structure
    DSBROWSEINFOW _bi;         

    // an IADsPathname object for usto use
    IADsPathname* _pPathCracker;
    
    // server being referenced (cracked out of the pszRoot path);
    LPWSTR _pServer;          

    // browse information (initialized during startup)
    WCHAR _szFilter[INTERNET_MAX_URL_LENGTH];
    WCHAR _szNameAttribute[MAX_PATH];

public:
    CBrowseDlg(PDSBROWSEINFOW pbi);
    ~CBrowseDlg();

private:
    HRESULT _GetPathCracker(void);
    LPCWSTR _GetSelectedPath(HWND hDlg) const;
    LPCWSTR GetSelectedObjectClass(HWND hDlg) const;
    int _SetSelectedPath(HWND hDlg, LPCWSTR pszADsPath);
    HRESULT _BuildNodeString(LPCWSTR pszADsPath, LPCWSTR pszClass, LPWSTR *ppszResult);
    HRESULT _ExpandNode(LPWSTR pszRootPath, HWND hwndTree, HTREEITEM hParentItem);
    HRESULT _ExpandNode(IADs *pRootObject, HWND hwndTree, HTREEITEM hParentItem);
    HRESULT _EnumerateNode(IADsContainer *pDsContainer, HWND hwndTree, HTREEITEM hParentItem, LPDWORD pdwAdded);
    HRESULT _SearchNode(IDirectorySearch *pDsSearch, HWND hwndTree, HTREEITEM hParentItem, LPDWORD pdwAdded);
    HRESULT _AddTreeNode(IADs *pDsObject, LPCWSTR pObjectPath, HWND hwndTree, HTREEITEM hParentItem, HTREEITEM* phitem);    
    HRESULT _AddTreeNode(LPCWSTR pszPath, LPCWSTR pszClass, LPCWSTR pszName, HWND hwndTree, HTREEITEM hParentItem, HTREEITEM* phitem);
    HRESULT _AddTreeNode(LPDOMAINDESC pDomainDesc, HWND hwndTree, HTREEITEM hParentItem, HTREEITEM* phitem);
    BOOL _OnInitDlg(HWND hDlg);
    BOOL _OnNotify(HWND hDlg, int idCtrl, LPNMHDR pnmh);
    void _OnOK(HWND hDlg);
    HRESULT _OpenObject(LPCWSTR pszPath, REFIID riid, void **ppv);
    HRESULT _GetClassInfo(LPCLASSCACHEGETINFO pCacheInfo, LPCLASSCACHEENTRY* ppCacheEntry);

    BOOL _DlgProc(HWND, UINT, WPARAM, LPARAM);
    static INT_PTR CALLBACK s_DlgProc(HWND, UINT, WPARAM, LPARAM);

    friend STDMETHODIMP_(int) DsBrowseForContainerW(PDSBROWSEINFOW pbi);
};


/*-----------------------------------------------------------------------------
/ Helper function to create an IADsPathname "path cracker" object
/----------------------------------------------------------------------------*/

HRESULT CreatePathCracker(IADsPathname **ppPath)
{
    HRESULT hr;

    TraceEnter(TRACE_BROWSE, "CreatePathCracker");
    TraceAssert(ppPath != NULL);

    hr =  CoCreateInstance(CLSID_Pathname,
                             NULL,
                             CLSCTX_INPROC_SERVER,
                             IID_PPV_ARG(IADsPathname, ppPath));

    TraceLeaveResult(hr);
}


/*-----------------------------------------------------------------------------
/ DsBrowseForContainer API implementation
/----------------------------------------------------------------------------*/

STDMETHODIMP_(int)
DsBrowseForContainerA(PDSBROWSEINFOA pbi)
{
    return -1;
}

STDMETHODIMP_(int)
DsBrowseForContainerW(PDSBROWSEINFOW pbi)
{
    TraceEnter(TRACE_BROWSE, "DsBrowseForContainerW");

    if (pbi == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return -1;
    }

    if (pbi->pszRoot == NULL)
        pbi->pszRoot = L"LDAP:";

    HRESULT hresCoInit = CoInitialize(NULL);

    CBrowseDlg dlg(pbi);
    int nResult = (int)DialogBoxParam(GLOBAL_HINSTANCE,
                                    MAKEINTRESOURCE(IDD_DSBROWSEFORCONTAINER),
                                    pbi->hwndOwner,
                                    CBrowseDlg::s_DlgProc,
                                    (LPARAM)&dlg);
    if (SUCCEEDED(hresCoInit))
        CoUninitialize();

    return nResult;
}


/*-----------------------------------------------------------------------------
/ CBrowseDlg class implementation
/----------------------------------------------------------------------------*/

CBrowseDlg::CBrowseDlg(PDSBROWSEINFOW pbi) : 
    _pPathCracker(NULL),
    _pServer(NULL)
{
    TraceEnter(TRACE_BROWSE, "CBrowseDlg::CBrowseDlg");

    CopyMemory(&_bi, pbi, min(SIZEOF(_bi), pbi->cbStruct));         // copies bounded from user passed to our member 

    StrCpyNW(_szFilter, (_bi.dwFlags & DSBI_INCLUDEHIDDEN) ? c_szQueryAll:c_szQueryNormal, ARRAYSIZE(_szFilter));
    Trace(TEXT("_szFilter: %s"), _szFilter);

    _szNameAttribute[0] = L'\0';

    TraceLeaveVoid();
}


CBrowseDlg::~CBrowseDlg()
{
    LocalFreeStringW(&_pServer);
    DoRelease(_pPathCracker);
}


HRESULT
CBrowseDlg::_GetPathCracker(void)
{
    HRESULT hr = S_OK;

    if (_pPathCracker == NULL)
        hr = CreatePathCracker(&_pPathCracker);

    if (SUCCEEDED(hr) && _pPathCracker)
        _pPathCracker->SetDisplayType(ADS_DISPLAY_FULL);       // ensure we are set to full

    return hr;
}


LPCWSTR CBrowseDlg::_GetSelectedPath(HWND hDlg) const
{
    LPCWSTR pszResult = NULL;
    HWND hwndTree;
    HTREEITEM hti = NULL;

    TraceEnter(TRACE_BROWSE, "CBrowseDlg::_GetSelectedPath");
    TraceAssert(hDlg != NULL);

    hwndTree = GetDlgItem(hDlg, DSBID_CONTAINERLIST);

    if (hwndTree != NULL)
    {
        hti = TreeView_GetSelection(hwndTree);
    }

    if (hti != NULL)
    {
        TV_ITEM tvi;
        tvi.mask = TVIF_PARAM | TVIF_HANDLE;
        tvi.hItem = hti;

        if (TreeView_GetItem(hwndTree, &tvi))
        {
            pszResult = (LPCWSTR)tvi.lParam;
        }
    }

    TraceLeaveValue(pszResult);
}


LPCWSTR CBrowseDlg::GetSelectedObjectClass(HWND hDlg) const
{
    LPCWSTR pszResult = NULL;
    HWND hwndTree;
    HTREEITEM hti = NULL;

    TraceEnter(TRACE_BROWSE, "CBrowseDlg::GetSelectedObjectClass");
    TraceAssert(hDlg != NULL);

    hwndTree = GetDlgItem(hDlg, DSBID_CONTAINERLIST);

    if (hwndTree != NULL)
        hti = TreeView_GetSelection(hwndTree);

    if (hti != NULL)
    {
        TV_ITEM tvi;
        tvi.mask = TVIF_PARAM | TVIF_HANDLE;
        tvi.hItem = hti;

        if (TreeView_GetItem(hwndTree, &tvi))
        {
            LPCWSTR pszPathAndClass = (LPWSTR)tvi.lParam;
            pszResult = (LPCWSTR)ByteOffset(tvi.lParam, StringByteSizeW(pszPathAndClass));
        }
    }

    TraceLeaveValue(pszResult);
}


int CBrowseDlg::_SetSelectedPath(HWND hDlg, LPCWSTR pszADsPath)
{
    int nResult = -1;
    HRESULT hr;
    BSTR bstrPath = NULL;
    UINT nPathLength;
    HWND hwndTree;
    HTREEITEM hItem;
    TV_ITEM tvi;
    tvi.mask = TVIF_HANDLE | TVIF_PARAM;
    
    TraceEnter(TRACE_BROWSE, "CBrowseDlg::_SetSelectedPath");

    // Run the path through a path cracker to get a known format
    hr = _GetPathCracker();
    FailGracefully(hr, "Unable to create ADsPathname object");

    hr = _pPathCracker->Set(CComBSTR(pszADsPath), ADS_SETTYPE_FULL);
    FailGracefully(hr, "Unable to parse path");

    hr = _pPathCracker->Retrieve(ADS_FORMAT_WINDOWS, &bstrPath);
    FailGracefully(hr, "Unable to build ADS Windows path");

    nPathLength = lstrlenW(bstrPath);
    Trace(TEXT("bstrPath: %s (%d)"), bstrPath, nPathLength);

    hwndTree = GetDlgItem(hDlg, DSBID_CONTAINERLIST);
    hItem = TreeView_GetChild(hwndTree, NULL);

    while (hItem != NULL)
    {
        LPWSTR pszCompare;
        UINT nCompareLength;

        tvi.hItem = hItem;
        TreeView_GetItem(hwndTree, &tvi);

        pszCompare = (LPWSTR)tvi.lParam;
        nCompareLength = lstrlenW(pszCompare);

        Trace(TEXT("Comparing against: %s"), pszCompare);

        // Does bstrPath contain pszCompare?
        if (2 == CompareStringW(LOCALE_SYSTEM_DEFAULT,
                                NORM_IGNORECASE,
                                bstrPath,
                                min(nCompareLength, nPathLength),
                                pszCompare,
                                nCompareLength))
        {
            TraceMsg("Current item, contains bstrPath");
            
            TreeView_SelectItem(hwndTree, hItem);

            if (nCompareLength == nPathLength)
            {
                TraceMsg("... and it was an exact match");
                TreeView_Expand(hwndTree, hItem, TVE_EXPAND);
                nResult = 0;
                break;
            }
            else
            {
                TraceMsg("... checking children for match");
                TreeView_Expand(hwndTree, hItem, TVE_EXPAND);
                hItem = TreeView_GetChild(hwndTree, hItem);
            }
        }
        else
        {
            TraceMsg("Checking sibling as no match found");
            hItem = TreeView_GetNextSibling(hwndTree, hItem);
        }
    }

exit_gracefully:

    if (bstrPath != NULL)
        SysFreeString(bstrPath);

    TraceLeaveValue(nResult);
}


HRESULT CBrowseDlg::_BuildNodeString(LPCWSTR pszADsPath, LPCWSTR pszClass, LPWSTR *ppszResult)
{
    HRESULT hr = S_OK;
    INT cbPath, cbClass;

    TraceEnter(TRACE_BROWSE, "CBrowseDlg::_BuildNodeString");
    TraceAssert(pszADsPath != NULL);
    TraceAssert(pszClass != NULL);
    TraceAssert(ppszResult != NULL);

    cbPath = StringByteSizeW(pszADsPath);
    cbClass = StringByteSizeW(pszClass);

    *ppszResult = (LPWSTR)LocalAlloc(LPTR, cbPath+cbClass);

    if (!*ppszResult)
        ExitGracefully(hr, E_OUTOFMEMORY, "Failed to allocate node string");

    StrCpy(*ppszResult, pszADsPath);                                   // StrCpy OK, b/c of buffer alloc above
    StrCpy((*ppszResult) + lstrlen(pszADsPath)+1, pszClass);           // StrCpy OK, b/c of buffer alloc above

exit_gracefully:

    TraceLeaveResult(hr);
}


HRESULT CBrowseDlg::_GetClassInfo(LPCLASSCACHEGETINFO pccgi, LPCLASSCACHEENTRY* ppCacheEntry)
{
    // set our server and cred information

    pccgi->pServer = _pServer;

    if (_bi.dwFlags & DSBI_HASCREDENTIALS)
    {
        TraceMsg("Passing credential information to ClassCache API");            
        pccgi->pUserName = (LPWSTR)_bi.pUserName;
        pccgi->pPassword = (LPWSTR)_bi.pPassword;
    }

    // adjust the flags based on the settings for the dialog

    pccgi->dwFlags |= CLASSCACHE_CONTAINER|CLASSCACHE_TREATASLEAF|CLASSCACHE_ICONS|CLASSCACHE_DSAVAILABLE;

    if (_bi.dwFlags & DSBI_DONTSIGNSEAL)
    {
        TraceMsg("Setting the CLASSCACHE_DONTSIGNSEAL flag");
        pccgi->dwFlags |= CLASSCACHE_DONTSIGNSEAL;
    }

    if (_bi.dwFlags & DSBI_SIMPLEAUTHENTICATE)
    {
        TraceMsg("Setting the CLASSCACHE_SIMPLEAUTHENTICATE flag");
        pccgi->dwFlags |= CLASSCACHE_SIMPLEAUTHENTICATE;
    }
    
    return ClassCache_GetClassInfo(pccgi, ppCacheEntry);
}

HRESULT CBrowseDlg::_OpenObject(LPCWSTR pszPath, REFIID riid, void **ppv)
{
    return OpenDsObject(pszPath,
                        (_bi.dwFlags & DSBI_HASCREDENTIALS) ? (LPWSTR)_bi.pUserName:NULL,
                        (_bi.dwFlags & DSBI_HASCREDENTIALS) ? (LPWSTR)_bi.pPassword:NULL,
                        riid, ppv,
                        (_bi.dwFlags & DSBI_SIMPLEAUTHENTICATE),
                        (_bi.dwFlags & DSBI_DONTSIGNSEAL));
}


HRESULT CBrowseDlg::_ExpandNode(LPWSTR pszRootPath, HWND hwndTree, HTREEITEM hParentItem)
{
    HRESULT hr = S_OK;
    IADs *pRootObject = NULL;
    HCURSOR hcur = SetCursor(LoadCursor(NULL, IDC_WAIT));

    TraceEnter(TRACE_BROWSE, "CBrowseDlg::_ExpandNode");
    TraceAssert(pszRootPath != NULL);
    TraceAssert(hwndTree != NULL);

    Trace(TEXT("Scope is: %s"), pszRootPath);

    hr = _OpenObject(pszRootPath, IID_PPV_ARG(IADs, &pRootObject));
    if (SUCCEEDED(hr))
    {
        hr = _ExpandNode(pRootObject, hwndTree, hParentItem);
        DoRelease(pRootObject);
    }

    SetCursor(hcur);
    TraceLeaveResult(hr);
}


HRESULT CBrowseDlg::_ExpandNode(IADs *pRootObject, HWND hwndTree, HTREEITEM hParentItem)
{
    HRESULT hr = S_OK;
    LPCLASSCACHEENTRY pCacheEntry = NULL;
    IADsContainer *pDsContainer = NULL;
    IDirectorySearch *pDsSearch = NULL;
    BOOL fIsContainer = TRUE;
    ULONG cAdded = 0;
    TV_ITEM tvi;
    BSTR bstrADsPath = NULL;
    BSTR bstrClass = NULL;
    HCURSOR hcur = SetCursor(LoadCursor(NULL, IDC_WAIT));
    CLASSCACHEGETINFO ccgi = { 0 };

    TraceEnter(TRACE_BROWSE, "CBrowseDlg::_ExpandNode");
    TraceAssert(pRootObject != NULL);
    TraceAssert(hwndTree != NULL);

    //
    // The IDirectorySearch method is better, but doesn't work for all objects
    // (e.g. "LDAP:") so try enumerating if IDirectorySearch isn't supported.
    //

    hr = pRootObject->get_Class(&bstrClass);
    FailGracefully(hr, "Failed to get class from object");

    hr = pRootObject->get_ADsPath(&bstrADsPath);
    FailGracefully(hr, "Failed to get class from object");

    ccgi.pPath = bstrADsPath;
    ccgi.pObjectClass = bstrClass;

    if (SUCCEEDED(_GetClassInfo(&ccgi, &pCacheEntry)))
    {
        fIsContainer = _IsClassContainer(pCacheEntry, _bi.dwFlags & DSBI_IGNORETREATASLEAF);
        ClassCache_ReleaseClassInfo(&pCacheEntry);
    }

    if (fIsContainer)
    {
        if (SUCCEEDED(pRootObject->QueryInterface(IID_PPV_ARG(IDirectorySearch, &pDsSearch))))
        {
            hr = _SearchNode(pDsSearch, hwndTree, hParentItem, &cAdded);
            DoRelease(pDsSearch);
        }
        else if (SUCCEEDED(pRootObject->QueryInterface(IID_PPV_ARG(IADsContainer, &pDsContainer))))
        {
            hr = _EnumerateNode(pDsContainer, hwndTree, hParentItem, &cAdded);
            DoRelease(pDsContainer);
        }
        else
        {
            TraceMsg("No IDsSearch, no IDsContainer - were screwed");
        }
    }

    // If we did not add anything we should update this item to let
    // the user know something happened.
    if (cAdded == 0)
    {
        tvi.mask = TVIF_CHILDREN | TVIF_HANDLE;
        tvi.hItem = hParentItem;
        tvi.cChildren = 0;
        TreeView_SetItem(hwndTree, &tvi);
    }

exit_gracefully:

    SysFreeString(bstrADsPath);
    SysFreeString(bstrClass);

    TraceLeaveResult(hr);
}


HRESULT CBrowseDlg::_EnumerateNode(IADsContainer *pDsContainer, HWND hwndTree, HTREEITEM hParentItem, LPDWORD pdwAdded)
{
    HRESULT hr = S_OK;
    IEnumVARIANT *pEnum = NULL;
    VARIANT aVariant[8];
    ULONG cAdded = 0;

    TraceEnter(TRACE_BROWSE, "CBrowseDlg::_EnumerateNode");
    TraceAssert(pDsContainer != NULL);
    TraceAssert(hwndTree != NULL);

    hr = ADsBuildEnumerator(pDsContainer, &pEnum);
    FailGracefully(hr, "Unable to build container enumerator object");

    //
    // Enumerate the given container
    //
    for (;;)
    {
        ULONG cFetched = 0;
        ULONG i;

        //
        // Get a bunch of child containers and add them to the tree.
        //
        ADsEnumerateNext(pEnum, ARRAYSIZE(aVariant), aVariant, &cFetched);

        if (cFetched == 0)
            break;

        for (i = 0; i < cFetched; i++)
        {
            IADs *pDsObject;

            TraceAssert(V_VT(&aVariant[i]) == VT_DISPATCH);
            TraceAssert(V_DISPATCH(&aVariant[i]));

            if (SUCCEEDED(V_DISPATCH(&aVariant[i])->QueryInterface(IID_IADs,
                                                       (LPVOID*)&pDsObject)))
            {
                hr = _AddTreeNode(pDsObject, NULL, hwndTree, hParentItem, NULL);
                if (SUCCEEDED(hr))
                    cAdded++;

                DoRelease(pDsObject);
            }

            VariantClear(&aVariant[i]);
        }
    }

    hr = S_OK;

exit_gracefully:

    DoRelease(pEnum);

    if (pdwAdded != NULL)
        *pdwAdded = cAdded;

    TraceLeaveResult(hr);
}


HRESULT CBrowseDlg::_SearchNode(IDirectorySearch *pDsSearch, HWND hwndTree, HTREEITEM hParentItem, LPDWORD pdwAdded)
{
    HRESULT hr = S_OK;
    ULONG cAdded = 0;
    ADS_SEARCH_HANDLE hSearch = NULL;
    ADS_SEARCH_COLUMN column;
    ADS_SEARCHPREF_INFO prefInfo[3];
    LPWSTR pszName = NULL;
    LPWSTR pszADsPath = NULL;
    LPWSTR pszObjectClass = NULL;
    LPWSTR aProperties[] = { _szNameAttribute, c_szObjectClass, c_szADsPath, c_szName, c_szRDN };
    LPWSTR *pProperties = aProperties;
    INT cProperties = ARRAYSIZE(aProperties);

    TraceEnter(TRACE_BROWSE, "CBrowseDlg::_SearchNode");
    TraceAssert(pDsSearch != NULL);
    TraceAssert(hwndTree != NULL);

    // Set the query prefernece to single level scope, and async retrevial
    // rather than waiting for all objects

    prefInfo[0].dwSearchPref = ADS_SEARCHPREF_SEARCH_SCOPE;
    prefInfo[0].vValue.dwType = ADSTYPE_INTEGER;
    prefInfo[0].vValue.Integer = ADS_SCOPE_ONELEVEL;

    prefInfo[1].dwSearchPref = ADS_SEARCHPREF_ASYNCHRONOUS;
    prefInfo[1].vValue.dwType = ADSTYPE_BOOLEAN;
    prefInfo[1].vValue.Boolean = TRUE;

    prefInfo[2].dwSearchPref = ADS_SEARCHPREF_PAGESIZE;         // paged results
    prefInfo[2].vValue.dwType = ADSTYPE_INTEGER;
    prefInfo[2].vValue.Integer = PAGE_SIZE;

    hr = pDsSearch->SetSearchPreference(prefInfo, ARRAYSIZE(prefInfo));
    FailGracefully(hr, "Failed to set search preferences");

    if (!_szNameAttribute[0])
    {
        TraceMsg("_szNameAttribute is NULL, so removing from query attributes");
        pProperties++;
        cProperties--;   
    }

    hr = pDsSearch->ExecuteSearch(_szFilter, pProperties, cProperties, &hSearch);
    FailGracefully(hr, "Failed in ExecuteSearch");

    for (;;)
    {
        LocalFreeStringW(&pszObjectClass);
        LocalFreeStringW(&pszADsPath);
        LocalFreeStringW(&pszName);

        ADsSetLastError(ERROR_SUCCESS, NULL, NULL);        // clear the ADSI previous errror

        hr = pDsSearch->GetNextRow(hSearch);
        FailGracefully(hr, "Failed in GetNextRow");

        if (hr == S_ADS_NOMORE_ROWS)
        {
            DWORD dwError;
            WCHAR wszError[64], wszName[64];

            hr = ADsGetLastError(&dwError, wszError, ARRAYSIZE(wszError), wszName, ARRAYSIZE(wszName));
            if (SUCCEEDED(hr) && (dwError != ERROR_MORE_DATA))
            {
                break;
            }
        }

        //
        // Get the columns for each of the properties we are interested in, if
        // we failed to get any of the base properties for the object then lets
        // just skip this entry as we cannot build a valid IDLIST for it.  The
        // properties that we request should be present on all objects.
        //

        if (FAILED(pDsSearch->GetColumn(hSearch, c_szObjectClass, &column)))
        {
            TraceMsg("Failed to get objectClass from search");
            continue;
        }

        hr = ObjectClassFromSearchColumn(&column, &pszObjectClass);
        pDsSearch->FreeColumn(&column);
        FailGracefully(hr, "Failed to get the object class from the property");

        if (FAILED(pDsSearch->GetColumn(hSearch, c_szADsPath, &column)))
        {
            TraceMsg("Failed to get ADsPath from search");
            continue;
        }

        hr = StringFromSearchColumn(&column, &pszADsPath);
        pDsSearch->FreeColumn(&column);
        FailGracefully(hr, "Failed to convert the ADsPath column to a string");

        // 
        // Try and read the name attribute from the query results, if that fails
        // then lets pass the ADsPath into the pathname API and get the 
        // LEAF name (RDN) back.
        //

        if (_szNameAttribute[0])
        {
            TraceMsg("Name attribute specified, therefore trying to decode that");
            hr = pDsSearch->GetColumn(hSearch, _szNameAttribute, &column);
        }
        
        if (!_szNameAttribute[0] || FAILED(hr))
        {
            TraceMsg("Either _szNameAttribute == NULL, or failed to read it");

            hr = pDsSearch->GetColumn(hSearch, c_szName, &column);
            if (FAILED(hr))
            {
                TraceMsg("'name' not returned as a column, so checking for RDN");
                hr = pDsSearch->GetColumn(hSearch, c_szRDN, &column);
            }
        }

        if (SUCCEEDED(hr))
        {
            //
            // so that succeeded and we have a search column that we can decode, so lets
            // do so and put that value into a string
            //

            hr = StringFromSearchColumn(&column, &pszName);
            pDsSearch->FreeColumn(&column);
            FailGracefully(hr, "Failed to convert the name column to a string");
        }
        else
        {
            BSTR bstrName;

            //
            // so now we attempt to use the path cracker as the string doesn't exist
            //

            TraceMsg("Failed to get the name, rdn etc, so using the path cracker");

            hr = _GetPathCracker();
            FailGracefully(hr, "Unable to create ADsPathname object");

            hr = _pPathCracker->Set(CComBSTR(pszADsPath), ADS_SETTYPE_FULL);
            FailGracefully(hr, "Unable to parse path");

            hr = _pPathCracker->SetDisplayType(ADS_DISPLAY_VALUE_ONLY);
            FailGracefully(hr, "Failed to set the display type for this value");

            hr = _pPathCracker->Retrieve(ADS_FORMAT_X500_DN, &bstrName);
            FailGracefully(hr, "Unable to retrieve requested path format");

            hr = LocalAllocStringW(&pszName, bstrName);
            SysFreeString(bstrName);
            FailGracefully(hr, "Failed to alloc clone of the name");
        }

        Trace(TEXT("class %s, name %s, ADsPath %s"), pszObjectClass, pszName, pszADsPath);

        hr = _AddTreeNode(pszADsPath, pszObjectClass, pszName, hwndTree, hParentItem, NULL);
        if (SUCCEEDED(hr))
            cAdded++;
    }
    hr = S_OK;

exit_gracefully:

    if (hSearch != NULL)
        pDsSearch->CloseSearchHandle(hSearch);

    LocalFreeStringW(&pszObjectClass);
    LocalFreeStringW(&pszADsPath);
    LocalFreeStringW(&pszName);

    if (pdwAdded != NULL)
        *pdwAdded = cAdded;

    TraceLeaveResult(hr);
}


HRESULT CBrowseDlg::_AddTreeNode(IADs *pDsObject, LPCWSTR pObjectPath, HWND hwndTree, HTREEITEM hParentItem, HTREEITEM* phitem)
{
    HRESULT hr = E_FAIL;
    BSTR bstrClass = NULL;
    BSTR bstrPath = NULL;
    BSTR bstrName = NULL;
    VARIANT var = {0};
    LPWSTR pszName = NULL;

    TraceEnter(TRACE_BROWSE, "CBrowseDlg::_AddTreeNode");
    TraceAssert(pDsObject != NULL);
    TraceAssert(hwndTree != NULL);

    // Do we want to include hidden objects?

    if (!(_bi.dwFlags & DSBI_INCLUDEHIDDEN))
    {
        if (SUCCEEDED(pDsObject->Get(CComBSTR(c_szShowInAdvancedViewOnly), &var)))
        {
            TraceAssert(V_VT(&var) == VT_BOOL);

            if (!V_BOOL(&var))
                ExitGracefully(hr, E_FAIL, "Hidden node");

            VariantClear(&var);
        }
    }

    // Get the path and class name
    if (!pObjectPath)
        pDsObject->get_ADsPath(&bstrPath);

    pDsObject->get_Class(&bstrClass);

    // Try to get the name property, if that fails then try RDN (for X5 connectivity)

    if (SUCCEEDED(pDsObject->Get(CComBSTR(c_szName), &var)) 
            || SUCCEEDED(pDsObject->Get(CComBSTR(c_szRDN), &var))
                || (_szNameAttribute[0] && SUCCEEDED(pDsObject->Get(CComBSTR(_szNameAttribute), &var))))
    {
        TraceAssert(V_VT(&var) == VT_BSTR);
        pszName = V_BSTR(&var);
    }
    else if (SUCCEEDED(pDsObject->get_Name(&bstrName)))
    {
        pszName = bstrName;
    }

    if (pszName != NULL)
    {
        hr = _AddTreeNode(pObjectPath ? pObjectPath : bstrPath, 
                           bstrClass, pszName, hwndTree, hParentItem, phitem);
    }                        

exit_gracefully:

    if (bstrPath)
        SysFreeString(bstrPath);

    SysFreeString(bstrClass);
    SysFreeString(bstrName);
    VariantClear(&var);

    TraceLeaveResult(hr);
}


HRESULT CBrowseDlg::_AddTreeNode(LPCWSTR pszPath, LPCWSTR pszClass, LPCWSTR pszName, HWND hwndTree, HTREEITEM hParentItem, HTREEITEM* phitem)
{
    HRESULT hr;
    BSTR bstrWinPath = NULL;
    LPCLASSCACHEENTRY pCacheEntry = NULL;
    TV_INSERTSTRUCT tvi;
    BSTR bstrName = NULL;
    BOOL fIsContainer = TRUE;
    long nElements;
    INT iResult = 0;
    HTREEITEM hitem = NULL;
    WCHAR szIconLocation[MAX_PATH];
    INT iIconResID = 0;
    CLASSCACHEGETINFO ccgi = { 0 };

    TraceEnter(TRACE_BROWSE, "CBrowseDlg::_AddTreeNode");
    TraceAssert(hwndTree != NULL);

    if (!pszPath  || !*pszPath || !pszClass || !*pszClass)
        ExitGracefully(hr, E_INVALIDARG, "Missing required string parameter");

    hr = _GetPathCracker();
    FailGracefully(hr, "Failed to get the path cracker");

    hr = _pPathCracker->Set(CComBSTR(pszPath), ADS_SETTYPE_FULL);
    FailGracefully(hr, "Failed to set the path into the cracker");

    //
    // we can get the name from the cracker       
    //

    if (!pszName || !*pszName)
    {
        _pPathCracker->SetDisplayType(ADS_DISPLAY_VALUE_ONLY);      // value only pls.

        hr = _pPathCracker->Retrieve(ADS_FORMAT_LEAF, &bstrName);
        FailGracefully(hr, "Failed to get leaf name");

        Trace(TEXT("bstrName: is %s"), bstrName);
        pszName = bstrName;
    }
    
    tvi.hParent = hParentItem;
    tvi.hInsertAfter = TVI_SORT;
    tvi.item.mask = TVIF_CHILDREN | TVIF_IMAGE | TVIF_SELECTEDIMAGE |
                    TVIF_STATE | TVIF_TEXT | TVIF_PARAM;
    tvi.item.state = 0;
    tvi.item.stateMask = (UINT)-1;
    tvi.item.cchTextMax = 0;
    tvi.item.cChildren = 1;
    tvi.item.pszText = (LPTSTR)pszName;
    tvi.item.iImage = 0;
    tvi.item.iSelectedImage = 0;
    tvi.item.lParam = 0;

    //
    // See if this object is a container, and get its image indexes
    // from the class cache.
    //

    ccgi.pPath = (LPWSTR)pszPath;
    ccgi.pObjectClass = (LPWSTR)pszClass;

    if (SUCCEEDED(_GetClassInfo(&ccgi, &pCacheEntry))) 
    {
        fIsContainer = _IsClassContainer(pCacheEntry, _bi.dwFlags & DSBI_IGNORETREATASLEAF);
        _GetIconLocation(pCacheEntry, DSGIF_DEFAULTISCONTAINER|DSGIF_GETDEFAULTICON, szIconLocation, ARRAYSIZE(szIconLocation), &iIconResID);
        ClassCache_ReleaseClassInfo(&pCacheEntry);
    }

    if (!fIsContainer)
        ExitGracefully(hr, E_FAIL, "Not a container");

    // 
    // If we have a callback function then call it taking a note of
    // the changes the caller wants to make to the node we are adding
    // to the tree, internally the LPARAM of this item still points at
    // the ADsPath/Class structure, but the display information has
    // been suitably modified.
    //

    if (_bi.pfnCallback)
    {
        DSBITEM dsbItem;

        dsbItem.cbStruct = SIZEOF(dsbItem);
        dsbItem.pszADsPath = pszPath;
        dsbItem.pszClass = pszClass;
        dsbItem.dwMask = DSBF_STATE | DSBF_DISPLAYNAME;
        dsbItem.dwState = 0;
        dsbItem.dwStateMask = DSBS_ROOT;
        StrCpyN(dsbItem.szDisplayName, pszName, ARRAYSIZE(dsbItem.szDisplayName));
        StrCpyN(dsbItem.szIconLocation, szIconLocation, ARRAYSIZE(dsbItem.szIconLocation));
        dsbItem.iIconResID = iIconResID;

        if (_bi.dwFlags & DSBI_CHECKBOXES)
        {
// handle the checked case properly;
            dsbItem.dwStateMask |= DSBS_CHECKED;
        }

        if ((hParentItem == TVI_ROOT) || !hParentItem)
        {
            dsbItem.dwState |= DSBS_ROOT;
        }

        iResult = _bi.pfnCallback(GetParent(hwndTree), DSBM_QUERYINSERT, (LPARAM)&dsbItem, _bi.lParam);

        //
        // iResult == TRUE then the user has modified the structure and we
        // should attempt to apply the changes they have made to the 
        // item we are about to add to the view.
        //

        if (iResult)
        {
            if ((dsbItem.dwMask & DSBF_STATE) &&
                (dsbItem.dwStateMask & DSBS_HIDDEN))
            {
                ExitGracefully(hr, E_FAIL, "Item is hidden, therefore skipping");
            }
                
            if ((_bi.dwFlags & DSBI_CHECKBOXES) &&
                    (dsbItem.dwMask & DSBF_STATE) &&
                    (dsbItem.dwStateMask & DSBS_CHECKED))
            {
// FEATURE: set the state image
            }

            if (dsbItem.dwMask & DSBF_ICONLOCATION)
            {
                StrCpyNW(szIconLocation, dsbItem.szIconLocation, ARRAYSIZE(szIconLocation));
                iIconResID = dsbItem.iIconResID;
            }

            if (dsbItem.dwMask & DSBF_DISPLAYNAME)
            {
                dsbItem.szDisplayName[DSB_MAX_DISPLAYNAME_CHARS-1] = TEXT('\0');
                tvi.item.pszText = dsbItem.szDisplayName;
            }
        }
    } 

    //
    // convert the icon location to an index that we can use in the tree view
    //

    Trace(TEXT("Icon location is: %s,%d"), szIconLocation, iIconResID);

    tvi.item.iImage = tvi.item.iSelectedImage = Shell_GetCachedImageIndex(szIconLocation, iIconResID, 0x0);
    Trace(TEXT("Index into the shell image list %d"), tvi.item.iImage);

    //
    // Make a copy of the path to store as the node data.
    // Try the path cracker first, so we get a known format.
    // If that fails, just make a copy of what we've got.
    //
    // The problem with the path cracker is that it just cannot cope
    // with names with no elements, therefore we have to work around
    // this by checking for no elements then looking at the retrieved
    // path to see if it terminates in a bogus way, if it does then
    // lets fix it in a local buffer before creating the tree view node.
    //

    hr = _pPathCracker->GetNumElements(&nElements);
    if (SUCCEEDED(hr))
    {
        _pPathCracker->SetDisplayType(ADS_DISPLAY_FULL);

        Trace(TEXT("nElements %d"), nElements);
        hr = _pPathCracker->Retrieve(ADS_FORMAT_WINDOWS, &bstrWinPath);
        if (SUCCEEDED(hr))
        {
            int cchWinPath = lstrlenW(bstrWinPath);

            Trace(TEXT("bstrWinPath %s (%d), nElements %d"), bstrWinPath, cchWinPath, nElements);
            if ((!nElements) &&
                 (cchWinPath >= 3) &&
                 (bstrWinPath[cchWinPath-1] == L'/') &&
                 (bstrWinPath[cchWinPath-2] == L'/') &&
                 (bstrWinPath[cchWinPath-3] == L':'))
            {
                LPWSTR pFixedWinPath = NULL;

                hr = LocalAllocStringW(&pFixedWinPath, bstrWinPath);
                if (SUCCEEDED(hr))
                {
                    pFixedWinPath[cchWinPath-2] = L'\0';
                    Trace(TEXT("pFixedWinPath %s"), pFixedWinPath);

                    hr = _BuildNodeString(pFixedWinPath, pszClass, (LPWSTR*)&tvi.item.lParam);
                    LocalFreeStringW(&pFixedWinPath);
                }
            }
            else
            {
                hr = _BuildNodeString(bstrWinPath, pszClass, (LPWSTR*)&tvi.item.lParam);
            }
        }
    }

    if (FAILED(hr))
        hr = _BuildNodeString(pszPath, pszClass, (LPWSTR*)&tvi.item.lParam);

    FailGracefully(hr, "Unable to build node data");

    //
    // finally lets add the item to the tree, if that fails then ensure we free the
    // structure hanging from the TVI.
    //

    hitem = TreeView_InsertItem(hwndTree, &tvi);
    if (!hitem)
    {
        LocalFreeStringW((LPWSTR*)&tvi.item.lParam);
        hr = E_FAIL;
    }

exit_gracefully:

    SysFreeString(bstrName);
    SysFreeString(bstrWinPath);

    if (phitem)
        *phitem = hitem;

    TraceLeaveResult(hr);
}


HRESULT CBrowseDlg::_AddTreeNode(LPDOMAINDESC pDomainDesc, HWND hwndTree, HTREEITEM hParentItem, HTREEITEM* phitem)
{
    HRESULT hr;
    WCHAR szBuffer[INTERNET_MAX_URL_LENGTH];
    DWORD dwIndex;
    HTREEITEM hitem=NULL;

    TraceEnter(TRACE_BROWSE, "CBrowseDlg::_AddTreeNode");

    while (pDomainDesc)
    {
        StrCpyNW(szBuffer, c_szLDAPPrefix, ARRAYSIZE(szBuffer));

        if (_pServer)
        {
            StrCatBuffW(szBuffer, _pServer, ARRAYSIZE(szBuffer));
            StrCatBuffW(szBuffer, L"/", ARRAYSIZE(szBuffer));
        }

        StrCatBuffW(szBuffer, pDomainDesc->pszNCName, ARRAYSIZE(szBuffer));

        Trace(TEXT("Scope is: %s"), szBuffer);

        hr = _AddTreeNode(szBuffer,
                           pDomainDesc->pszObjectClass, NULL,
                           hwndTree, hParentItem,
                           &hitem);

        FailGracefully(hr, "Failed to add location node");        

        if (pDomainDesc->pdChildList)
        {
            hr = _AddTreeNode(pDomainDesc->pdChildList,
                               hwndTree, hitem,
                               NULL);

            FailGracefully(hr, "Failed to add children");
        }

        pDomainDesc = pDomainDesc->pdNextSibling;
    }

    hr = S_OK;

exit_gracefully:

    if (phitem)
        *phitem = hitem;

    TraceLeaveResult(hr);
}


BOOL CBrowseDlg::_OnInitDlg(HWND hDlg)
{
    HRESULT hr;
    HWND hwndTree;
    IADs *pRoot = NULL;
    IDsBrowseDomainTree* pDsDomains = NULL;
    BSTR bstrServer = NULL;
    LPDOMAINTREE pDomainTree = NULL;
    HTREEITEM hitemRoot = NULL;

    TraceEnter(TRACE_BROWSE, "CBrowseDlg::_OnInitDlg");
    TraceAssert(hDlg != NULL);

    if (_bi.pszCaption != NULL)
        SetWindowText(hDlg, _bi.pszCaption);

    if (_bi.pszTitle == NULL)
    {
        RECT rc;
        LONG yPos;
        HWND hwnd;

        // Get the position of the title window and hide it
        hwnd = GetDlgItem(hDlg, DSBID_BANNER);
        GetWindowRect(hwnd, &rc);
        yPos = rc.top;
        ShowWindow(hwnd, SW_HIDE);

        // Get the position of the tree control and adjust it
        // to cover the title window.
        hwnd = GetDlgItem(hDlg, DSBID_CONTAINERLIST);

        GetWindowRect(hwnd, &rc);
        rc.top = yPos;

        MapWindowPoints(NULL, hDlg, (LPPOINT)&rc, 2);
        MoveWindow(hwnd, 
                   rc.left, rc.top,
                   rc.right - rc.left, rc.bottom - rc.top,
                   FALSE);
    }
    else
    {
        SetDlgItemText(hDlg, DSBID_BANNER, _bi.pszTitle);
    }

    hwndTree = GetDlgItem(hDlg, DSBID_CONTAINERLIST);
    TraceAssert(hwndTree != NULL);

    // Update the TreeView style according to what the caller wants
    if (_bi.dwFlags & (DSBI_NOBUTTONS | DSBI_NOLINES | DSBI_NOLINESATROOT | DSBI_CHECKBOXES))
    {
        DWORD dwStyle = GetWindowLong(hwndTree, GWL_STYLE);
        dwStyle &= ~(_bi.dwFlags & (DSBI_NOBUTTONS | DSBI_NOLINES | DSBI_NOLINESATROOT));
        dwStyle |= (_bi.dwFlags & DSBI_CHECKBOXES);
        SetWindowLong(hwndTree, GWL_STYLE, dwStyle);
    }

    if (_bi.dwFlags & DSBI_CHECKBOXES)
    {
        // load and set the state imagelist (unchecked and checked squares)
    }

    //
    // ensure we set the shared image list for the tree, this comes from shell32.
    //

    HIMAGELIST himlSmall;
    Shell_GetImageLists(NULL, &himlSmall);
    TreeView_SetImageList(hwndTree, himlSmall, TVSIL_NORMAL);

    TraceAssert(_bi.pszRoot != NULL);
    Trace(TEXT("pszRoot is: %s"), _bi.pszRoot);

    //
    // if we have a callback function then we need to call it to get the information we need
    // to browse the DS namespace.
    //

    if (_bi.pfnCallback) 
    {
        DSBROWSEDATA dbd = { 0 };

        dbd.pszFilter = _szFilter;
        dbd.cchFilter = ARRAYSIZE(_szFilter);
        dbd.pszNameAttribute = _szNameAttribute;
        dbd.cchNameAttribute = ARRAYSIZE(_szNameAttribute);

        TraceMsg("Calling callback to see if it can provide enumeration information");

        if (_bi.pfnCallback(hDlg, DSBM_GETBROWSEDATA, (LPARAM)&dbd, _bi.lParam))
        {
            Trace(TEXT("szFilter after DSBM_GETBROWSEDATA: %s"), _szFilter[0] ? _szFilter:TEXT("<not specified>"));

            Trace(TEXT("szNameAttribute after DSBM_GETBROWSEDATA: %s"), _szNameAttribute[0] ? _szNameAttribute:TEXT("<not specified>"));

            if (!_szFilter[0])
                ExitGracefully(hr, E_FAIL, "szFilter returned was NULL");
        }
    }


    //
    // Bind to the root object (make sure it's a valid object)
    //

    hr = _OpenObject(_bi.pszRoot, IID_PPV_ARG(IADs, &pRoot));
    FailGracefully(hr, "Unable to bind to root object");

    // attempt to decode the root path we have been given, if this includes a server
    // name then lets store that so that we can call the cache codes.  internally
    // we preserver this.

    hr = _GetPathCracker();
    FailGracefully(hr, "Failed to get the path cracker API");

    hr = _pPathCracker->Set(CComBSTR(_bi.pszRoot), ADS_SETTYPE_FULL);
    FailGracefully(hr, "Unable to put the path into the path cracker");

    if (SUCCEEDED(_pPathCracker->Retrieve(ADS_FORMAT_SERVER, &bstrServer)))
    {
        Trace(TEXT("Root path contains a server: %s"), bstrServer);
        hr = LocalAllocStringW(&_pServer, bstrServer);
        FailGracefully(hr, "Failed to allocate copy of ADsPath");
    }

    // DSBI_ENTIREDIRECTORY contains 2 bits which means that 
    // "if (_bi.dwFlags & DSBI_ENTIREDIRECTORY)" gives a false
    // positive when a client calls with only DSBI_NOROOT set. This
    // causes the entire directory to be displayed when it shouldn't.

    //if (_bi.dwFlags & DSBI_ENTIREDIRECTORY)
    if (_bi.dwFlags & (DSBI_ENTIREDIRECTORY & ~DSBI_NOROOT))
    {
        TV_ITEM tvi;
        LPDOMAINDESC pDomain;

        if (!(_bi.dwFlags & DSBI_NOROOT))
        {
            hr = _AddTreeNode(pRoot, _bi.pszRoot, hwndTree, NULL, &hitemRoot);
            FailGracefully(hr, "Failed when adding in root node");

            tvi.mask = TVIF_STATE|TVIF_HANDLE;
            tvi.hItem = hitemRoot;
            tvi.stateMask = -1;
            TreeView_GetItem(hwndTree, &tvi);
            tvi.state |= TVIS_EXPANDEDONCE;
            TreeView_SetItem(hwndTree, &tvi);
        }

        hr = CoCreateInstance(CLSID_DsDomainTreeBrowser, NULL,CLSCTX_INPROC_SERVER, IID_PPV_ARG(IDsBrowseDomainTree, &pDsDomains));
        FailGracefully(hr, "Failed to get IDsDomainTreeBrowser");

        LPCWSTR pUserName = (_bi.dwFlags & DSBI_HASCREDENTIALS) ? _bi.pUserName:NULL;
        LPCWSTR pPassword = (_bi.dwFlags & DSBI_HASCREDENTIALS) ? _bi.pPassword:NULL;

        hr = pDsDomains->SetComputer(_pServer, pUserName, pPassword);
        FailGracefully(hr, "Failed to SetComputer");

        hr = pDsDomains->GetDomains(&pDomainTree, 
            DBDTF_RETURNFQDN);/*|
            DBDTF_RETURNINOUTBOUND);
            DBDTF_RETURNMIXEDDOMAINS |
            DBDTF_RETURNEXTERNAL     );*/
        FailGracefully(hr, "Failed to GetDomains");

        _AddTreeNode(pDomainTree->aDomains, hwndTree, hitemRoot, NULL);
        FailGracefully(hr, "Failed to _AddTreeNode");
    }
    else if (_bi.dwFlags & DSBI_NOROOT)
    {
        // Skip root node and add its children as toplevel nodes
        hr = _ExpandNode(pRoot, hwndTree, NULL);
    }
    else
    {
        // Add the root node
        hr = _AddTreeNode(pRoot, _bi.pszRoot, hwndTree, NULL, &hitemRoot);
    }

exit_gracefully:

    if (SUCCEEDED(hr))
    {
        //
        // Set the selected path to expand the tree, this can either be NULL, or
        // a ADSI path.  If we fail to do that and we have a root node then
        // lets expand the root node to at least have something highlighted / expanded.
        //

        if (!(_bi.dwFlags & DSBI_EXPANDONOPEN) || (-1 == _SetSelectedPath(hDlg, _bi.pszPath)))
        {
            if (!(_bi.dwFlags & DSBI_NOROOT))
            {
                TraceMsg("Failed to select node, therefore expanding root");
                _SetSelectedPath(hDlg, _bi.pszRoot);
            }
        }

        if (_bi.pfnCallback)
            _bi.pfnCallback(hDlg, BFFM_INITIALIZED, 0, _bi.lParam);
    }
    else
    {
        // SetLastError(???);
        EndDialog(hDlg, -1);
    }

    DoRelease(pRoot);
    DoRelease(pDsDomains);

    SysFreeString(bstrServer);

    TraceLeaveValue(TRUE);
}


BOOL CBrowseDlg::_OnNotify(HWND hDlg, int idCtrl, LPNMHDR pnmh)
{
    LPNM_TREEVIEW pnmtv = (LPNM_TREEVIEW)pnmh;
    LPWSTR pszClass;
    HRESULT hr;
    
    switch (pnmh->code)
    {
    case TVN_DELETEITEM:
        LocalFree((HLOCAL)pnmtv->itemOld.lParam);
        break;

    case TVN_ITEMEXPANDING:
        if ((pnmtv->action == TVE_EXPAND) &&
            !(pnmtv->itemNew.state & TVIS_EXPANDEDONCE))
        {
            if (pnmtv->itemNew.hItem == NULL)
            {
                pnmtv->itemNew.hItem = TreeView_GetSelection(pnmh->hwndFrom);
            }

            // Whether we succeed or not, mark the node as having been
            // expanded once.
            pnmtv->itemNew.mask = TVIF_STATE;
            pnmtv->itemNew.stateMask = TVIS_EXPANDEDONCE;
            pnmtv->itemNew.state = TVIS_EXPANDEDONCE;

            if (!pnmtv->itemNew.lParam ||
                 FAILED(_ExpandNode((LPWSTR)pnmtv->itemNew.lParam,
                                   pnmh->hwndFrom, pnmtv->itemNew.hItem)))
            {
                // Mark this node as having no children
                pnmtv->itemNew.mask |= TVIF_CHILDREN;
                pnmtv->itemNew.cChildren = 0;
            }

            TreeView_SetItem(pnmh->hwndFrom, &pnmtv->itemNew);
        }
        break;

    case TVN_ITEMEXPANDED:
    {
        pszClass = (LPWSTR)ByteOffset(pnmtv->itemNew.lParam, StringByteSizeW((LPWSTR)pnmtv->itemNew.lParam));
        if (!pszClass)
            return FALSE;

        // Switch to the "open" image

        if ((pnmtv->action == TVE_EXPAND) || (pnmtv->action == TVE_COLLAPSE))
        {
            //
            // handle the expand and colapse of the icon in the tree, assuming that
            // we show the correct state of corse (for those who don't have open states).
            //

            CLASSCACHEGETINFO ccgi = { 0 };
            ccgi.dwFlags = CLASSCACHE_ICONS|(DSGIF_ISOPEN << CLASSCACHE_IMAGEMASK_BIT);
            ccgi.pPath = (LPWSTR)pnmtv->itemNew.lParam;
            ccgi.pObjectClass = pszClass;

            LPCLASSCACHEENTRY pCacheEntry = NULL;
            if (SUCCEEDED(_GetClassInfo(&ccgi, &pCacheEntry)))
            {
                WCHAR szIconLocation[MAX_PATH];
                INT iIconResID;
                
                hr = _GetIconLocation(pCacheEntry, DSGIF_DEFAULTISCONTAINER|DSGIF_ISOPEN, szIconLocation, ARRAYSIZE(szIconLocation), &iIconResID);
                ClassCache_ReleaseClassInfo(&pCacheEntry);

                if (SUCCEEDED(hr))
                {
                    pnmtv->itemNew.mask = TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
                    pnmtv->itemNew.iImage = pnmtv->itemNew.iSelectedImage = Shell_GetCachedImageIndex(szIconLocation, iIconResID, 0x0);
                    TreeView_SetItem(pnmh->hwndFrom, &pnmtv->itemNew);
                }
            }
        }

        break;
    }

    case TVN_SELCHANGED:
    {
        if (_bi.pfnCallback)
            _bi.pfnCallback(hDlg, BFFM_SELCHANGED, (LPARAM)_GetSelectedPath(hDlg), _bi.lParam);

        break;
    }
    
    default:
        return FALSE;
    }

    return TRUE;
}


void CBrowseDlg::_OnOK(HWND hDlg)
{
    int nResult = -1;
    LPCWSTR pszADsPath;
    LPCWSTR pszObjectClass;
    BSTR bstrPath = NULL;
    DWORD dwFormat = _pServer ? ADS_FORMAT_X500:ADS_FORMAT_X500_NO_SERVER;
    
    TraceEnter(TRACE_BROWSE, "CBrowseDlg::_OnNotify");
    TraceAssert(hDlg != NULL);

    pszADsPath = _GetSelectedPath(hDlg);
    pszObjectClass = GetSelectedObjectClass(hDlg);

    if (!pszADsPath || !pszObjectClass)
        ExitGracefully(nResult, -1, "Failed to get selected object");

    // Honor the return type if they gave us one.

    if ((_bi.dwFlags & DSBI_RETURN_FORMAT) && _bi.dwReturnFormat)
    {
        TraceMsg("Caller specified a dwReturnFormat");
        dwFormat = _bi.dwReturnFormat;
    }

    // CBrowseDlg uses ADS_FORMAT_WINDOWS internally, so no need to convert if 
    // that's what they want.

    if (dwFormat != ADS_FORMAT_WINDOWS)
    {
        HRESULT hr;

        hr = _GetPathCracker();
        FailGracefully(hr, "Unable to create ADsPathname object");

        hr = _pPathCracker->Set(CComBSTR(pszADsPath), ADS_SETTYPE_FULL);
        FailGracefully(hr, "Unable to parse path");

        hr = _pPathCracker->Retrieve(dwFormat, &bstrPath);
        FailGracefully(hr, "Unable to retrieve requested path format");

        pszADsPath = bstrPath;
    }

    // return the object class to the caller

    StrCpyNW(_bi.pszPath, pszADsPath, _bi.cchPath);

    if ((_bi.dwFlags & DSBI_RETURNOBJECTCLASS) && _bi.pszObjectClass)
    {
        Trace(TEXT("Returning objectClass: %s"), pszObjectClass);
        StrCpyNW(_bi.pszObjectClass, pszObjectClass, _bi.cchObjectClass);
    }

    nResult = IDOK;

exit_gracefully:

    SysFreeString(bstrPath);
    EndDialog(hDlg, nResult);

    TraceLeaveVoid();
}


BOOL CBrowseDlg::_DlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_NOTIFY:
            return _OnNotify(hDlg, (int)wParam, (LPNMHDR)lParam);

        case BFFM_ENABLEOK:
            EnableWindow(GetDlgItem(hDlg, IDOK), (BOOL)wParam);
            break;

        case BFFM_SETSELECTIONA:
        case BFFM_SETSELECTIONW:
            _SetSelectedPath(hDlg, (LPCWSTR)lParam); // lParam points to an ADSI path, which we require to be UNICODE
            break;

        case WM_COMMAND:
            switch (GET_WM_COMMAND_ID(wParam, lParam))
            {
            case IDOK:
                _OnOK(hDlg);
                break;

            case IDCANCEL:
                EndDialog(hDlg, IDCANCEL);
                break;

            default:
                // Message not handled
                return FALSE;
            }
            break;

        case WM_INITDIALOG:
            return _OnInitDlg(hDlg);

        case WM_HELP:
        case WM_CONTEXTMENU:
        {
            // check to see if we have a callback, if so then lets call so that they 
            // can display help on this object.

            if (!_bi.pfnCallback)
                return FALSE;

            _bi.pfnCallback(hDlg,
                            (uMsg == WM_HELP) ? DSBM_HELP:DSBM_CONTEXTMENU,
                            (uMsg == WM_HELP) ? lParam:(LPARAM)wParam,
                            _bi.lParam);
            break;
        }

        default:
            return FALSE;           // not handled
    }
    return TRUE;
}


INT_PTR CALLBACK CBrowseDlg::s_DlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    CBrowseDlg *pbd = (CBrowseDlg *)GetWindowLongPtr(hDlg, DWLP_USER);

    if (uMsg == WM_INITDIALOG)
    {
        SetWindowLongPtr(hDlg, DWLP_USER, lParam);
        pbd = (CBrowseDlg *)lParam;
    }

    if (pbd != NULL)
        return (INT_PTR)pbd->_DlgProc(hDlg, uMsg, wParam, lParam);

    return FALSE;
}