/*++

Copyright (C) Microsoft Corporation, 1998 - 1999
All rights reserved.

Module Name:

    findloc.cxx

Abstract:

    This module provides all the functions for browsing the
    physical location tree stored in an Active Directory

Author:

    Lazar Ivanov (LazarI)   23-Nov-1998
    Steve Kiraly (SteveKi)  24-Nov-1998
    Lazar Ivanov (LazarI)   Nov-28-2000 - redesign the tokenizer
    Weihai Chen  (WeihaiC)  Mar-28-2001 - use DS search to enumerate location data

Revision History:

--*/

#include "precomp.hxx"
#pragma hdrstop

#include "dsinterf.hxx"
#include "findloc.hxx"
#include "physloc.hxx"

enum
{
    kDSIconIndex = 1,
};

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

    Utility functions

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

/*++

Name:

    vRecursiveGetSel

Description:

    Finds the selecton string denoted by parent nodes
    of the current treeview item, then appends
    string of the current item

Arguments:

    hTree - handle to treeview control
    pItem - pointer to current item
    strSel - reference to string to fill in
    hStop - tree item to stop recursing

Return Value:

    None

Notes:


--*/

VOID
vRecursiveGetSel (
    IN  HWND hTree,
    IN  const TVITEM *pItem,
    OUT TString &strSel,
    IN  HTREEITEM hStop
    )
{
    TVITEM tvParent;
    TCHAR szItem[TPhysicalLocation::kMaxPhysicalLocation];
    TStatusB bStatus;

    tvParent.mask = TVIF_TEXT|TVIF_HANDLE;
    tvParent.pszText = szItem;
    tvParent.cchTextMax = TPhysicalLocation::kMaxPhysicalLocation;

    //
    // If we're at the root, init the string
    //
    if ((tvParent.hItem = TreeView_GetParent (hTree, pItem->hItem))==hStop)
    {
        bStatus DBGCHK = strSel.bUpdate (pItem->pszText);
    }
    else
    {
        //
        // Get the string denoted by my parent nodes, then append my string
        //
        TreeView_GetItem (hTree, &tvParent);
        vRecursiveGetSel (hTree, &tvParent, strSel, hStop);
        bStatus DBGCHK = strSel.bCat (pItem->pszText);
    }

    //
    // Append a slash
    //
    bStatus DBGCHK = strSel.bCat (gszSlash);
}

/*++

Name:

    Tokenize

Description:

    Replace any valid separators with NULL in the dest string

Arguments:

    LPTSTR pszDest      - where to put the dest string
    UNIT nMaxLength     - size of the buffer of dest
    LPCTSTR pszSrc      - source string
    LPTSTR *pszStart    - start markup
    LPTSTR *pszEnd      - end markup

Return Value:

    None

--*/

VOID
Tokenize(
    OUT LPTSTR pszDest,
    IN  UINT nMaxLength,
    IN  LPCTSTR pszSrc,
    OUT LPTSTR *pszStart,
    OUT LPTSTR *pszEnd
    )
{
    ASSERT(pszDest);
    ASSERT(nMaxLength);
    ASSERT(pszSrc);
    ASSERT(pszStart);
    ASSERT(pszEnd);

    // make a copy
    lstrcpyn(pszDest, pszSrc, nMaxLength);

    // replace all the valid separators with zeros
    int i, iLen = lstrlen(pszDest);
    for( i=0; i<iLen; i++ )
    {
        if( TEXT('\\') == pszDest[i] || TEXT('/')  == pszDest[i] )
        {
            pszDest[i] = 0;
        }
    }

    // initialize the walk pointers
    *pszStart = pszDest;
    *pszEnd = pszDest + iLen;
}

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

    TLocData methods

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

/*++

Name:

    TLocData constructor

Description:

    Creates the TLocData, the TLocData is the data that is shared between
    the UI thread and the background thread.  To ensure the data's life time
    refrence counting is used.

Arguments:

    pszClassName
    pszWindowName          - the class name and window name of toplevel window
                             where the message will be posted when data is ready
    uMsgDataReady          - the user message posted, which should be posted
    bFindPhysicalLocation  - should expand default

Return Value:

    None

Notes:

--*/

TLocData::
TLocData(
    IN LPCTSTR pszClassName,
    IN LPCTSTR pszPropertyName,
    IN UINT    uMsgDataReady,
    IN BOOL    bFindPhysicalLocation
    ) :
       _uMsgDataReady(uMsgDataReady),
       _bFindPhysicalLocation(bFindPhysicalLocation),
       _bIsDataReady(FALSE),
       _strWindowClass( pszClassName ),
       _strPropertyName( pszPropertyName )
{
    _bValid = _strWindowClass.bValid() && _strPropertyName.bValid();
}

/*++

Name:

    TLocData destructor

Description:

    Deletes the linked list nodes

Arguments:

    None

Return Value:

    None

Notes:


--*/

TLocData::
~TLocData(
     VOID
     )
{
    //
    // Free the locations list
    //
    TLoc *pLoc;
    while( !_LocationList_bEmpty() )
    {
        pLoc = _LocationList_pHead();
        pLoc->_Location_vDelinkSelf();
        delete pLoc;
    }
}

/*++

Name:

    bValid

Description:

    Class valid check routine.

Arguments:

    None

Return Value:

    TRUE  - class is valid and usable,
    FALSE - class is not usable.

Notes:

--*/

BOOL
TLocData::
bValid(
    VOID
    ) const
{
    return _bValid;
}

/*++

Name:

    TLocData::vNotifyUIDataIsReady

Description:

    Notify the UI the background work is done

Arguments:

    None

Return Value:

    None

Notes:

--*/

VOID
TLocData::
vNotifyUIDataIsReady(
    VOID
    )
{
    //
    // Check if the data is ready first
    //
    if( _bIsDataReady )
    {
        for (HWND hWnd = FindWindow(_strWindowClass, NULL); hWnd; hWnd = GetWindow(hWnd, GW_HWNDNEXT))
        {
            TCHAR szBuffer[MAX_PATH];

            if( !GetClassName(hWnd, szBuffer, COUNTOF(szBuffer)) )
            {
                continue;
            }

            //
            // check again ensure that class name is same
            // if we obtained this handle from GetWindow( ... )
            //
            if( !_tcsicmp( szBuffer, _strWindowClass ) )
            {
                HANDLE hProp = GetProp( hWnd, _strPropertyName );

                //
                // Just verify who we are?
                //
                if( hProp == reinterpret_cast<HANDLE>(this) )
                {
                    //
                    // Apropriate window found - post the message
                    //
                    PostMessage( hWnd, _uMsgDataReady, 0, reinterpret_cast<LPARAM>(this) );
                    break;
                }
            }
        }
    }
}

/*++

Name:

    TLocData::FindLocationsThread

Description:

    static thread procedure, invokes the real worker proc

Arguments:

    pData - TLocData object pointer to call

Return Value:

    None

Notes:

--*/

VOID
TLocData::
FindLocationsThread (
    IN TLocData *pData
    )
{
    //
    // Explore the locations (this is a
    // slow resource access operation)
    //
    pData->vDoTheWork();

    //
    // Data is consistent to be used here
    //
    pData->_bIsDataReady = TRUE;

    //
    // Notify UI we are ready
    //
    pData->vNotifyUIDataIsReady();

    //
    // Unhook from data
    //
    pData->cDecRef();
}

/*++

Name:

    TLocData::vRefZeroed

Description:

    Called when ref count reaches zero. Deletes the object

Arguments:

    None

Return Value:

    None

Notes:

--*/

VOID
TLocData::
vRefZeroed(
    VOID
    )
{
    //
    // No more clients - just kill myself, game over
    //
    delete this;
}

/*++

Name:

    TLocData::bSearchLocations

Description:

    Opens the Active Directory and searches the configuration
    container to find the location property of each Subnet.

Arguments:

    ds    - The active directory object

Return Value:

    TRUE  - on success
    FALSE - on failure

Notes:

--*/
BOOL
TLocData::
bSearchLocations(
    IN  TDirectoryService &ds
    )
{
    static const DWORD kMaxPageSize = 10000;
    static ADS_SEARCHPREF_INFO prefInfo[3];
    static LPWSTR ppszPropertyName[] = {
        const_cast<LPWSTR>(gszLocation)
    };

    TString           strConfig;
    TString           strSubnet;
    ADS_SEARCH_HANDLE hSearch = NULL;
    ADS_SEARCH_COLUMN column;
    IDirectorySearch* pDsSearch = NULL;
    TStatusB          bStatus;
    TStatusH          hResult;
    DWORD             cItems;

    //
    // Set search preferences
    //

    //
    // one level search
    //
    prefInfo[0].dwSearchPref = ADS_SEARCHPREF_SEARCH_SCOPE;
    prefInfo[0].vValue.dwType = ADSTYPE_INTEGER;
    prefInfo[0].vValue.Integer = ADS_SCOPE_ONELEVEL;

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

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

    //
    // Get the configuration path
    //
    bStatus DBGCHK = ds.GetConfigurationContainer (strConfig);

    if (bStatus)
    {
        TString strLDAPPrefix;

        //
        // Append config path to the subnet string
        //
        bStatus DBGCHK = strSubnet.bUpdate( gszLdapPrefix )        &&
                         strSubnet.bCat( gszSubnetContainter )     &&
                         strSubnet.bCat( gszComma )                &&
                         strSubnet.bCat( strConfig );

        if(bStatus)
        {
            //
            // Get container interface for the subnets object
            //
            hResult DBGCHK = ds.ADsGetObject ( const_cast<LPTSTR>(static_cast<LPCTSTR>(strSubnet)),
                                               IID_IDirectorySearch,
                                               reinterpret_cast<LPVOID*>(&pDsSearch));
            if (SUCCEEDED(hResult))
            {
                //
                // Search for the subnet objects
                //

                hResult DBGCHK = pDsSearch->SetSearchPreference(prefInfo, ARRAYSIZE(prefInfo));
            }

            if (SUCCEEDED (hResult))
            {
                hResult DBGCHK = pDsSearch->ExecuteSearch(L"(Objectclass=*)",
                                                          ppszPropertyName,
                                                          ARRAYSIZE (ppszPropertyName),
                                                          &hSearch);
            }

            for (cItems = 0 ; cItems < kMaxPageSize && SUCCEEDED (hResult); cItems++)
            {
                hResult DBGCHK = pDsSearch->GetNextRow(hSearch);

                if (hResult == S_ADS_NOMORE_ROWS)
                {
                    //
                    // we have more data so lets continue
                    //
                    hResult DBGCHK = S_OK;
                    break;
                }

                //
                // Get the Name and display it in the list.
                //
                hResult DBGCHK = pDsSearch->GetColumn( hSearch, ppszPropertyName[0], &column );

                if (SUCCEEDED(hResult))
                {
                    switch (column.dwADsType)
                    {
                    case ADSTYPE_CASE_IGNORE_STRING:

                        if (column.pADsValues->CaseIgnoreString && column.pADsValues->CaseIgnoreString[0])
                        {
                            //
                            // This subnet has a location property
                            //
                            TLoc *pLoc = new TLoc();

                            if( VALID_PTR(pLoc) )
                            {
                                pLoc->strLocation.bUpdate( column.pADsValues->CaseIgnoreString );
                                _LocationList_vAppend(pLoc);
                            }
                            else
                            {
                                hResult DBGCHK = E_OUTOFMEMORY;
                                break;
                            }
                        }
                        break;

                    default:
                        hResult DBGCHK = E_INVALIDARG;
                        break;
                    }

                    pDsSearch->FreeColumn(&column);
                }
                else if (hResult == E_ADS_COLUMN_NOT_SET)
                {
                    //
                    // The location data is not available for this subnet, ignore
                    //
                    hResult DBGCHK = S_OK;
                }
            }

            if (hSearch)
            {
                pDsSearch->CloseSearchHandle (hSearch);
            }

            if (pDsSearch)
            {
                pDsSearch->Release();
            }
        }
    }

    //
    // Make this final check
    //
    if(bStatus)
    {
        bStatus DBGCHK = SUCCEEDED(hResult);
    }

    return bStatus;
}

/*++

Name:

    TLocData::vDoTheWork

Description:

    Opens the Active Directory and searches the configuration
    container to find the location property of each Subnet.

Arguments:

    None

Return Value:

    None

Notes:

--*/

VOID
TLocData::
vDoTheWork(
    VOID
    )
{
    TStatusB bStatus;

    TDirectoryService ds;
    bStatus DBGCHK = ds.bValid();

    //
    // Lookup for the DS name first
    //
    if( bStatus )
    {
        bStatus DBGCHK = ds.bGetDirectoryName( _strDSName );
    }

    //
    // Enumerate the subnet objects
    //
    if( bStatus )
    {
        bStatus DBGCHK = bSearchLocations (ds);
    }

    //
    // Find out the exact location of the current machine
    //
    if( bStatus )
    {
        TPhysicalLocation physLoc;

        if (_bFindPhysicalLocation && physLoc.Discover())
        {
            physLoc.GetExact (_strDefault);
        }
    }
}

/******************************************************************************
TLocData::TLoc
******************************************************************************/

TLocData::
TLoc::
TLoc(
    VOID
    )
{
}

TLocData::
TLoc::
~TLoc(
    VOID
    )
{
}

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

TLocTree methods

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

/*++

Name:

    TLocTree constructor

Description:

    Creates the imagelist for the tree control and inserts the
    root string that describes the choices.

Arguments:

    None

Return Value:

    None

Notes:

--*/

TLocTree::
TLocTree(
   IN HWND hwnd
   )
{
    HICON                 hIcon;
    TCHAR                 szIconLocation[MAX_PATH];
    INT                   iIconIndex;
    TStatusB              bStatus;

    _hwndTree = hwnd;
    _iGlobe = 0;
    _iSite = 0;

    _bWaitData = TRUE;
    _hCursorWait = LoadCursor(NULL, IDC_WAIT);
    _DefProc = NULL;

    //
    // Create the simple imagelist
    // If this fails, the tree items just won't have icons
    //
    bStatus DBGCHK = Shell_GetImageLists( NULL, &_hIml );

    if (_hIml)
    {
        IDsDisplaySpecifier  *pDisplay = NULL;

        //
        // Use IDsDisplaySpecifier::GetIcon to find path to the icons
        // for sites and subnets.
        //
        if (SUCCEEDED(CoCreateInstance(CLSID_DsDisplaySpecifier,
                                       NULL,
                                       CLSCTX_INPROC_SERVER,
                                       IID_IDsDisplaySpecifier,
                                       reinterpret_cast<LPVOID *>(&pDisplay))))
        {
            _iGlobe = Shell_GetCachedImageIndex (gszDSIconFile,
                                                 kDSIconIndex,
                                                 0);

            pDisplay->GetIconLocation (gszSiteIconClass,
                                       DSGIF_GETDEFAULTICON,
                                       szIconLocation,
                                       MAX_PATH,
                                       &iIconIndex);

            _iSite = Shell_GetCachedImageIndex (szIconLocation,
                                                 iIconIndex,
                                                 0);
            pDisplay->Release();

            TreeView_SetImageList (_hwndTree, _hIml, TVSIL_NORMAL);
        }
    }

    //
    // Subclass tree control to handle WM_SETCURSOR message
    //
    _DefProc = reinterpret_cast<WNDPROC>( GetWindowLongPtr( _hwndTree, GWLP_WNDPROC ) );
    SetWindowLongPtr( _hwndTree, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this) );
    SetWindowLongPtr( _hwndTree, GWLP_WNDPROC,  reinterpret_cast<LONG_PTR>(&TLocTree::ThunkProc) );
}

/*++

Name:

    TLocTree destructor

Description:

    Destroys the image list

Arguments:

    None

Return Value:

    None

Notes:

--*/

TLocTree::
~TLocTree(
    VOID
    )
{
    //
    // Unsubclass here
    //
    SetWindowLongPtr( _hwndTree, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(_DefProc) );
    SetWindowLongPtr( _hwndTree, GWLP_USERDATA, 0 );

    //
    // No longer need the shared image list
    //
    if (_hIml)
    {
        TreeView_SetImageList (_hwndTree, NULL, TVSIL_NORMAL);
    }
}

/*++

Name:

    TLocTree::vResetTree

Description:

    Resets the tree content

Arguments:

    None

Return Value:

    None

Notes:

--*/

VOID
TLocTree::
vResetTree(
   VOID
   )
{
    //
    // Delete all items and start waiting
    // new data
    //
    TreeView_DeleteAllItems( _hwndTree );
    _bWaitData = TRUE;
}

/*++

Name:

    TLocTree::vBuildTree

Description:

    Build the tree control from a ready data

Arguments:

    pLocData - Where to get data from

Return Value:

    None

Notes:

--*/

VOID
TLocTree::
vBuildTree(
    IN const TLocData *pLocData
    )
{
    //
    // Check to reset the data
    //
    if( !_bWaitData )
    {
        vResetTree( );
    }

    if( !pLocData->_LocationList_bEmpty() )
    {
        //
        // Build the tree and Fill the tree with the data.
        //
        vInsertRootString( pLocData );
        vFillTree( pLocData );
    }

    //
    // Stop waiting data
    //
    _bWaitData = FALSE;
}

/*++

Name:

    TLocTree::vInsertRootString

Description:

    Inserts the root string in the tree control


Arguments:

    None

Return Value:

    None

Notes:

--*/

VOID
TLocTree::
vInsertRootString(
   IN const TLocData *pLocData
   )
{
    TVINSERTSTRUCT        tviStruct;
    TString               strRoot;
    TStatusB              bStatus;
    TDirectoryService     ds;
    TString               strDSName;

    //
    // Insert the Root-level string that describes the control
    // This will be a combination of "Entire " + <directory name>
    //
    tviStruct.hParent               = NULL;
    tviStruct.hInsertAfter          = TVI_ROOT;
    tviStruct.item.mask             = TVIF_TEXT|TVIF_IMAGE|TVIF_SELECTEDIMAGE;
    tviStruct.item.iImage           = _iGlobe;
    tviStruct.item.iSelectedImage   = _iGlobe;

    bStatus DBGCHK = strRoot.bLoadString( ghInst, IDS_LOCTREEROOT ) &&
                     strRoot.bCat( pLocData->_strDSName );

    tviStruct.item.pszText      = const_cast<LPTSTR>(static_cast<LPCTSTR>(strRoot));
    tviStruct.item.cchTextMax   = strRoot.uLen();

    _hRoot = TreeView_InsertItem (_hwndTree, &tviStruct);
}

/*++

Name:

    TLocTree::bInsertLocString

Description:

    Add the given location string to the tree control.
    Each level of the hierarchy is indicated by the '/'
    delimiter. Prevents duplicate entries at each level of
    the tree.

Arguments:

    strLoc - location string to insert, Must be '/' delimited

Return Value:

    TRUE  - on success
    FALSE - on failure

Notes:

--*/

BOOL
TLocTree::
bInsertLocString(
   IN const TString &strLoc
   ) const
{
    // Start at the root.
    // For each '/' delimited string in szLoc,
    // add a level to the tree and insert the
    // string as a child node of the current node.
    // At each level don't insert duplicates.
    //
    HTREEITEM       hCurrent, hChild;
    TVINSERTSTRUCT  tviItem;
    TVITEM*         pItem = &tviItem.item;
    DWORD           dwErr;
    TCHAR           szBuffer[512];
    LPTSTR          psz, pszMax;

    if (!_hwndTree)
    {
        return FALSE;
    }

    // tokenize the input string
    Tokenize(szBuffer, ARRAYSIZE(szBuffer), strLoc, &psz, &pszMax);

    // initialize the item to insert
    memset(pItem, 0, sizeof(TVITEM));
    pItem->mask = TVIF_TEXT|TVIF_IMAGE|TVIF_SELECTEDIMAGE;
    pItem->iImage = _iSite;
    pItem->iSelectedImage = _iSite;
    tviItem.hInsertAfter = TVI_SORT;

    hCurrent = _hRoot;
    while( hCurrent )
    {
        // find a valid token
        while( 0 == *psz && psz < pszMax )
        {
            psz++;
        }

        // if we've gone past the buffer break the loop
        if( psz >= pszMax )
        {
            break;
        }

        pItem->pszText  = psz;
        tviItem.hParent = hCurrent;

        // if the current name already exists at this level don't insert
        if( hChild = IsAChild(psz, hCurrent) )
        {
            hCurrent = hChild;
        }
        else
        {
            hCurrent = TreeView_InsertItem (_hwndTree, &tviItem);
        }

        // advance the token pointer
        psz += lstrlen(psz);
    }

    return hCurrent ? TRUE : FALSE;
}

/*++

Name:

    TLocTree::IsAChild

Description:

    Determines if szLoc exists at the level of the
    tree whose parent is hParent. If so, return
    the handle of the node containing szLoc

Arguments:

    szLoc   - string to search for
    hParent - parent node

Return Value:

    Handle to treeview item matching szLoc, or NULL if not found

Notes:

--*/

HTREEITEM
TLocTree::
IsAChild(
   IN LPCTSTR   szLoc,
   IN HTREEITEM hParent
   ) const
{
    TVITEM tvItem;
    HTREEITEM hItem;
    TCHAR szItemText[TPhysicalLocation::kMaxPhysicalLocation];
    BOOL bMatch = FALSE;

    tvItem.mask = TVIF_TEXT | TVIF_HANDLE;
    tvItem.pszText = szItemText;
    tvItem.cchTextMax = TPhysicalLocation::kMaxPhysicalLocation;

    hItem = TreeView_GetChild (_hwndTree, hParent);
    while (hItem && !bMatch)
    {
        tvItem.hItem = hItem;
        TreeView_GetItem (_hwndTree, &tvItem);
        bMatch = !_tcsicmp (szLoc, szItemText);

        if (bMatch)
        {
            break;
        }

        hItem = TreeView_GetNextSibling (_hwndTree, hItem);
    }

    if (!bMatch)
    {
        hItem = NULL;
    }

    return hItem;
}

/*++

Name:

    TLocTree::uGetSelectedLocation

Description:

    Walks the tree control from the selected item to
    the root, building the slash-delimited location
    string name.

Arguments:

    strLoc - string to update

Return Value:

    TRUE  - on success
    FALSE - otherwise

Notes:

--*/

BOOL
TLocTree::
bGetSelectedLocation(
    OUT TString &strLoc
    ) const
{
    TVITEM    tvItem;
    TStatusB  status;
    TCHAR     szTemp[TPhysicalLocation::kMaxPhysicalLocation];

    tvItem.mask       = TVIF_TEXT|TVIF_HANDLE;
    tvItem.cchTextMax = TPhysicalLocation::kMaxPhysicalLocation;
    tvItem.pszText    = szTemp;

    //
    // Get the selected item
    //
    tvItem.hItem = TreeView_GetSelection (_hwndTree);

    if (tvItem.hItem == _hRoot)
    {
        status DBGCHK = strLoc.bUpdate(_T("\0"));
        return status;
    }

    status DBGCHK = TreeView_GetItem (_hwndTree, &tvItem);

    if (status)
    {
        vRecursiveGetSel (_hwndTree, &tvItem, strLoc, _hRoot);
    }

    return  status;
}

/*++

Name:

    TLocTree::vExpandTree

Description:

    Expands the tree view control to make visible the node
    corresponding to the given location string

Arguments:

    strExpand - slash-delimited location string to expand tree by

Return Value:

    None

Notes:

--*/

VOID
TLocTree::
vExpandTree(
    IN const TString &strExpand
    ) const
{
    if( strExpand.uLen() )
    {
        HTREEITEM   hParent, hItem;
        TCHAR       szBuffer[512];
        LPTSTR      psz, pszMax;

        // tokenize the input string
        Tokenize(szBuffer, ARRAYSIZE(szBuffer), strExpand, &psz, &pszMax);

        hParent = _hRoot;
        for( ;; )
        {
            // find a valid token
            while( 0 == *psz && psz < pszMax )
            {
                psz++;
            }

            // if we've gone past the buffer break the loop
            if( psz >= pszMax )
            {
                break;
            }

            if( hItem = IsAChild(psz, hParent) )
            {
                // a valid child - remember
                hParent = hItem;

                // advance to the next token
                psz += lstrlen(psz);
            }
            else
            {
                // not a child, bail out
                break;
            }
        }

        if (hParent)
        {
            TreeView_EnsureVisible(_hwndTree, hParent);
            TreeView_SelectItem(_hwndTree, hParent);
        }
    }
}

/*++

Name:

    vFillTree

Description:

    Walks through the linked list and adds strings to the TLocTree object

Arguments:

    pLocData - Where to get data from

Return Value:

    None

Notes:

--*/

VOID
TLocTree::
vFillTree(
    IN const TLocData *pLocData
    ) const
{
    TIter Iter;
    TLocData::TLoc *pLoc;

    TStatusB status = TRUE;
    for( pLocData->_LocationList_vIterInit(Iter), Iter.vNext(); Iter.bValid(); Iter.vNext() )
    {
        pLoc = pLocData->_LocationList_pConvert( Iter );
        status DBGCHK = bInsertLocString( pLoc->strLocation );
    }
}

/*++

Name:

    TLocTree::ThunkProc

Description:

    Thunk control proc (for subclassing)

Arguments:

    Standard window proc parameters

Return Value:

    None

Notes:

--*/

LRESULT CALLBACK
TLocTree::
ThunkProc(
    IN HWND hwnd,
    IN UINT uMsg,
    IN WPARAM wParam,
    IN LPARAM lParam
    )
{
    LRESULT lResult = 0;
    TLocTree *This = reinterpret_cast<TLocTree*>( GetWindowLongPtr( hwnd, GWLP_USERDATA ) );

    if( This )
    {
        if( WM_DESTROY == uMsg || WM_NCDESTROY == uMsg )
        {
            lResult = This->nHandleMessage( uMsg, wParam, lParam );

            SetWindowLongPtr( hwnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(This->_DefProc) );
            SetWindowLongPtr( hwnd, GWLP_USERDATA, 0 );
        }
        else
        {
            SPLASSERT( hwnd == This->_hwndTree );
            lResult = This->nHandleMessage( uMsg, wParam, lParam );

            if( !lResult )
            {
                //
                // Message is not handled go to
                // default processing
                //
                lResult = This->_DefProc( hwnd, uMsg, wParam, lParam );
            }
        }
    }

    return lResult;
}

/*++

Name:

    TLocTree::nHandleMessage

Description:

    Message handler function

Arguments:

    Standard window proc parameters

Return Value:

    None

Notes:

--*/

LRESULT
TLocTree::
nHandleMessage(
    IN UINT uMsg,
    IN WPARAM wParam,
    IN LPARAM lParam
    )
{
    //
    // assume message is processed
    //
    LRESULT lResult = 1;

    switch( uMsg )
    {
        case WM_SETCURSOR:
            {
                if( _bWaitData )
                {
                    //
                    // Set hourglass cursor
                    //
                    SetCursor( _hCursorWait );
                }
                else
                {
                    //
                    // Message is not processed - go default processing
                    //
                    lResult = 0;
                }
            }
            break;

        default:
            {
                //
                // Message is not processed - go default processing
                //
                lResult = 0;
            }
            break;
    }

    return lResult;
}

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

    TFindLocDlg functions

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



/*++

Name:

    TFindLocDlg::bGenerateGUIDAsString

Description:

    This function will generate a GUID,
    convert it to string and return it

Arguments:

    pstrGUID - where to place the genearted GUID

Return Value:

    TRUE  on success
    FALSE on failure

Notes:

--*/

BOOL
TFindLocDlg::
bGenerateGUIDAsString(
    OUT TString *pstrGUID
    )
{
    static const TCHAR szRegFormat[] = _T("{%08lX-%04X-%04x-%02X%02X-%02X%02X%02X%02X%02X%02X}");

    //
    // Assume failue
    //
    TStatusB bStatus = FALSE;

    HRESULT hResult = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);

    if( SUCCEEDED(hResult) )
    {
        GUID guid;
        bStatus DBGCHK = SUCCEEDED(CoCreateGuid(&guid));

        if( bStatus )
        {
            //
            // Generate a registry format GUID string
            //
                bStatus DBGCHK = pstrGUID->bFormat( szRegFormat,
                        // first copy...
                        guid.Data1, guid.Data2, guid.Data3,
                        guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
                        guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7],
                        // second copy...
                        guid.Data1, guid.Data2, guid.Data3,
                        guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
                        guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
        }

        //
        // Uninitialize COM after we finish
        //
        CoUninitialize( );
    }

    return bStatus;
}

/*++

Name:

    TFindLocDlg constructor

Description:

    Constructs TFindLocDlg object

Arguments:

    flags - UI controlling flags (show/hide help button)

Return Value:

    None

Notes:

--*/

TFindLocDlg::
TFindLocDlg(
    IN ELocationUI flags
    ) :
        _pLocData(NULL),
        _pTree(NULL),
        _UIFlags(flags),
        _bValid(TRUE),
        _uMsgDataReady(0)
{
}

/*++

Name:

    TFindLocDlg destructor

Description:

    Releases refcount on the location object

Arguments:

    None

Return Value:

    None

Notes:

--*/

TFindLocDlg::
~TFindLocDlg(
    VOID
    )
{
    if (VALID_PTR(_pLocData))
    {
        _pLocData->cDecRef();
    }
}

/*++

Name:

    TFindLocDlg::bDoModal

Description:

    Invokes the browse location dialog

Arguments:

    hParent     - hwnd of parent window
    pstrDefault - default selection string, this is optional

Return Value:

    TRUE  - if dialog creation succeeds
    FALSE - otherwise

Notes:

    pstrDefault has NULL default value

--*/

BOOL
TFindLocDlg::
bDoModal(
   IN  HWND     hParent,
   OUT TString *pstrDefault OPTIONAL
   )
{
    TStatusB bStatus;
    bStatus DBGNOCHK = TRUE;

    if (pstrDefault)
    {
        bStatus DBGCHK = _strDefault.bUpdate( *pstrDefault );
    }

    //
    // Register the window message, this message is used to inform the
    // UI thread that the data fetched by the background thread is ready.
    //
    _uMsgDataReady = RegisterWindowMessage( _T("WM_BACKGROUNDTASKISREADY") );

    //
    // Check if we succeeded to register the message
    // and update the default location
    //
    if( _bValid && _uMsgDataReady && bStatus )
    {
        //
        // Check if data is not obtained from a previous call
        // of bDoModal() function - if not then start background
        // thread to explore locations from the directory
        // service
        //
        if( !_pLocData )
        {
            //
            // Generate the special property name
            //
            bStatus DBGCHK = bGenerateGUIDAsString( &_strPropertyName );

            if( bStatus )
            {
                _pLocData = new TLocData( _T("#32770"), _strPropertyName, _uMsgDataReady, _strDefault.bEmpty() );
                bStatus DBGCHK = VALID_PTR( _pLocData );

                if( bStatus )
                {
                    _pLocData->vIncRef( );

                    //
                    // Spin the background explorer thread here
                    //
                    bStatus DBGCHK = bStartTheBackgroundThread();
                }
                else
                {
                    delete _pLocData;
                    _pLocData = NULL;
                }
            }
        }

        //
        // Data is expected to be ready here or to be in
        // process of exploration in background
        //
        if( bStatus )
        {
            //
            // Everything looks fine - just show the UI
            //
            bStatus DBGCHK= (BOOL)DialogBoxParam( ghInst,
                                                  MAKEINTRESOURCE(DLG_BROWSE_LOC),
                                                  hParent,
                                                  MGenericDialog::SetupDlgProc,
                                                  reinterpret_cast<LPARAM>(this) );
        }
    }

    return bStatus;
}

/*++

Name:

    TFindLocDlg::uGetLocation

Description:

    Fills in the location string selected when the dialog was open.

Arguments:

    strLocation - TString to update

Return Value:

    TRUE  - on success,
    FALSE - otherwise

Notes:

--*/

BOOL
TFindLocDlg::
bGetLocation(
    OUT TString &strLocation
    )
{
    TStatusB bStatus;
    bStatus DBGCHK = strLocation.bUpdate ((LPCTSTR)_strSelLocation);
    return bStatus;
}

/*++

Name:

    TFindLocDlg::vDataIsReady

Description:

    Called when the background thread completes its work.
    Always stops the wait cursor.

Arguments:

    None

Return Value:

    None

Notes:


--*/

VOID
TFindLocDlg::
vDataIsReady(
    VOID
    )
{
    //
    // Make sure the animation stops
    //
    vStopAnim();

    //
    // Fill in the tree control, and select the default string
    //
    _pTree->vBuildTree( _pLocData );

    if( !_pLocData->_LocationList_bEmpty() )
    {
        //
        // Expand the default location here
        //
        if (!_strDefault.bEmpty())
        {
            _pTree->vExpandTree(_strDefault);
        }
        else
        {
            _pTree->vExpandTree(_pLocData->_strDefault);
        }

        //
        // Enable the OK button
        //
        EnableWindow (GetDlgItem (_hDlg, IDOK), TRUE);
    }

    //
    // Place the focus in the tree control
    //
    PostMessage( _hDlg, WM_NEXTDLGCTL, reinterpret_cast<WPARAM>( GetDlgItem(_hDlg, IDC_LOCTREE) ), 1L );
}

/*++

Name:

    TFindLocDlg::vOnOK

Description:

    Called when the OK button is pressed.
    Updates current selection string

Arguments:

    None

Return Value:

    None

Notes:


--*/

VOID
TFindLocDlg::
vOnOK(
   VOID
   )
{
    //
    // Get the selected location and close the dialog
    //
    _pTree->bGetSelectedLocation (_strSelLocation);
    EndDialog (_hDlg, IDOK);
}

/*++

Name:

    TFindLocDlg::vOnDestroy

Description:

    Cleans up data allocated for current
    dialog window instance


Arguments:

    None

Return Value:

    None

Notes:


--*/

VOID
TFindLocDlg::
vOnDestroy(
    VOID
    )
{
    if (VALID_PTR(_pTree))
    {
        delete _pTree;
        _pTree = NULL;
    }
}

/*++

Name:

    TFindLocDlg::bHandleMessage


Description:

    Dispatches messages to appropriate handlers.


Arguments:

    uMsg - message value
    wParam, lParam - message params

Return Value:

    TRUE  - if message is handled,
    FALSE - otherwise

Notes:


--*/

BOOL
TFindLocDlg::
bHandleMessage(
    IN UINT     uMsg,
    IN WPARAM   wParam,
    IN LPARAM   lParam
    )
{
    BOOL bHandled = TRUE;

    //
    // Check our registered message first
    //
    if( _uMsgDataReady == uMsg && reinterpret_cast<LPARAM>(_pLocData) == lParam )
    {
        vDataIsReady( );
        bHandled = TRUE;
    }
    else
    {
        //
        // Standard message processing
        //
        switch (uMsg)
        {
            case WM_INITDIALOG:
                {
                    bHandled = bOnInitDialog();
                }
                break;

            case WM_COMMAND:
                {
                    //
                    // Handle WM_COMMAND messages
                    //
                    bHandled = bOnCommand( LOWORD(wParam) );
                }
                break;

            case WM_NOTIFY:
                {
                    //
                    // The only WM_NOTIFY source on the dialog is the TreeView
                    //
                    bHandled = bOnTreeNotify (reinterpret_cast<LPNMTREEVIEW>(lParam));
                }
                break;


            case WM_HELP:
            case WM_CONTEXTMENU:
                {
                    //
                    // Help messages
                    //
                    PrintUIHelp( uMsg, _hDlg, wParam, lParam );
                }
                break;

            case WM_DESTROY:
                {
                    vOnDestroy ();
                }
                break;

            case WM_CTLCOLORSTATIC:
                {
                    bHandled = bOnCtlColorStatic( reinterpret_cast<HDC>(wParam),
                                                  reinterpret_cast<HWND>(lParam) );
                }
                break;

            default:
                {
                    bHandled = FALSE;
                }
                break;

        }
    }

    return bHandled;
}

/*++

Name:

    TFindLocDlg::bOnInitDialog

Description:

    Instantiates the TLocTree object and attempts to
    initialize it if needed. Disable the OK button until
    the worker thread completes.

Arguments:

    None

Return Value:

    TRUE  - on success
    FALSE - on failure

Notes:

--*/

BOOL
TFindLocDlg::
bOnInitDialog(
   VOID
   )
{
    DWORD dwResult;
    TStatusB bStatus;

    _pTree = new TLocTree (GetDlgItem(_hDlg, IDC_LOCTREE));
    bStatus DBGCHK = VALID_PTR(_pTree);

    if( !bStatus )
    {
        delete _pTree;
        _pTree = NULL;
    }
    else
    {
        //
        // Set some special property value to us, so the
        // worker thread could recognize us
        //
        bStatus DBGCHK = SetProp( _hDlg, _strPropertyName, static_cast<HANDLE>(_pLocData) );

        if( bStatus )
        {
            //
            // Hide the help button as requested
            //
            if (!(_UIFlags & kLocationShowHelp))
            {
                ShowWindow (GetDlgItem(_hDlg, IDC_LOCATION_HELP), SW_HIDE);
            }

            //
            // Let the user know we're busy
            //
            EnableWindow (GetDlgItem (_hDlg, IDOK), FALSE);

            vStartAnim();

            //
            // Just verify if the data is ready
            //
            _pLocData->vNotifyUIDataIsReady();
        }
    }

    return bStatus;
}

/*++

Name:

    TFindLocDlg::bOnTreeNotify

Description:

    When the selection is changed on the tree control, update
    the static control that displays the currently selected location


Arguments:

    pTreeNotify - pointer to NMTREEVIEW struct

Return Value:

    TRUE  - if message is handled
    FALSE - otherwise

Notes:

--*/

BOOL
TFindLocDlg::
bOnTreeNotify(
   IN LPNMTREEVIEW pTreeNotify
   )
{
    TStatusB bStatus = TRUE;
    TString  strSel;

    switch (pTreeNotify->hdr.code)
    {
        case TVN_SELCHANGED:
            {
                bStatus DBGCHK = _pTree->bGetSelectedLocation (strSel);

                if (strSel.bEmpty())
                {
                    strSel.bLoadString (ghInst,IDS_NO_LOCATION);
                }

                bStatus DBGCHK = bSetEditText (_hDlg, IDC_CHOSEN_LOCATION, strSel);
            }
            break;

        default:
            {
                bStatus DBGNOCHK = FALSE;
            }
            break;
    }

    return bStatus;
}

/*++

Name:

    TFindLocDlg::vStartAnim

Description:

    Show the animation window


Arguments:

    None

Return Value:

    None

Notes:

--*/

VOID
TFindLocDlg::
vStartAnim(
    VOID
    )
{
    HWND hwndAni = GetDlgItem (_hDlg, IDC_BROWSELOC_ANIM);

    SetWindowPos (hwndAni,
                  HWND_TOP,
                  0,0,0,0,
                  SWP_NOMOVE|SWP_NOSIZE|SWP_SHOWWINDOW);

    Animate_Open(hwndAni, MAKEINTRESOURCE (IDA_SEARCH));
    Animate_Play(hwndAni, 0, -1, -1);
}

/*++

Name:

    TFindLocDlg::vStopAnim

Description:

    Hide the animation window


Arguments:

    None

Return Value:

    None

Notes:

--*/

VOID
TFindLocDlg::
vStopAnim(
    VOID
    )
{
    //
    // Call LockWindowUpdate() to prevent default drawing of the
    // animation control after stop playing - which is gray rect
    //
    LockWindowUpdate( _hDlg );

    HWND hwndAni = GetDlgItem (_hDlg, IDC_BROWSELOC_ANIM);

    SetWindowPos (hwndAni,
                  HWND_BOTTOM,
                  0,0,0,0,
                  SWP_NOMOVE|SWP_NOSIZE|SWP_HIDEWINDOW);


    Animate_Stop(hwndAni);

    //
    // Unlock window update - tree control will
    // repaint its content
    //
    LockWindowUpdate( NULL );
}

/*++

Name:
    TFindLocDlg::bOnCtlColorStatic

Description:
    Used to set background color of the animation window
    to the same color as the treeview window


Arguments:
    hdc - DC to set background color

Return Value:
    color value used to draw background

Notes:

--*/

BOOL
TFindLocDlg::
bOnCtlColorStatic(
    IN HDC hdc,
    IN HWND hStatic
    )
{
    //
    // Assume default processing of this message
    //
    BOOL bResult = FALSE;

    if (hStatic == GetDlgItem (_hDlg, IDC_BROWSELOC_ANIM))
    {
        //
        // We process this message only to have
        // opportunity to patch the animation control
        // dc just before paint.
        //
        // We do not return a brush here!
        // (which means that we return a NULL brush)
        //
        // We should just return TRUE here to prevent the
        // default message processing of this msg, which will
        // revert the backgound color to gray.
        //
        SetBkColor(hdc, GetSysColor(COLOR_WINDOW));

        //
        // Message is processed. Do not perform default
        // processing!
        //
        bResult = TRUE;
    }

    return bResult;
}

/*++

Name:

    TFindLocDlg::bStartTheBackgroundThread

Description:

    Starts the background thread for reading the subnet locations


Arguments:

    None

Return Value:

    TRUE  - on success
    FALSE - on failure

Notes:


--*/

BOOL
TFindLocDlg::
bStartTheBackgroundThread(
    VOID
    )
{
    TStatusB bStatus;

    DWORD dwThreadID;
    HANDLE hThread;

    //
    // You want to make sure the data is protected for the worker thread.
    //
    _pLocData->vIncRef();

    //
    // Spin the background thread here
    //
    hThread = TSafeThread::Create ( NULL,
                                    0,
                                    (LPTHREAD_START_ROUTINE)TLocData::FindLocationsThread,
                                    _pLocData,
                                    0,
                                    &dwThreadID );
    if( hThread )
    {
        //
        // We don't need this handle any more.
        // Just leave the thread running untill
        // it stops
        //
        CloseHandle( hThread );
    }
    else
    {
        //
        // Ensure the data is release if the thread creation fails.
        //
        _pLocData->cDecRef();
    }

    bStatus DBGCHK = !!hThread;

    return bStatus;
}

/*++

Name:

    TFindLocDlg::bOnCommand

Description:

    Handles WM_COMMAND messages

Arguments:

    None

Return Value:

    TRUE  - on success
    FALSE - on failure

Notes:

--*/

BOOL
TFindLocDlg::
bOnCommand(
    IN UINT uCmdID
    )
{
    //
    // Assume message is handled
    //
    BOOL bHandled = TRUE;

    switch (uCmdID)
    {
        case IDOK:
            vOnOK ();
            break;

        case IDCANCEL:
            EndDialog (_hDlg, 0);
            break;

        case IDC_LOCATION_HELP:
            PrintUIHtmlHelp (_hDlg,
                             gszHtmlPrintingHlp,
                             HH_DISPLAY_TOPIC,
                             reinterpret_cast<ULONG_PTR>(gszLocationHtmFile));
            break;

        default:
            {
                bHandled = FALSE;
            }
            break;
    }

    return bHandled;
}