//+----------------------------------------------------------------------------
//
// File:     pb.cpp 
//
// Module:   CMDIAL32.DLL
//
// Synopsis: Handle the phone book dialog and call cmpbk32.dll.
//
// Copyright (c) 1998-1999 Microsoft Corporation
//
// Author:   fengsun Created Header   1/14/98
//
//+----------------------------------------------------------------------------

#include "cmmaster.h"

#define MAX_PB_WAIT 30000       // max miliiseconds to wait for PB mutex     

//+----------------------------------------------------------------------------
//
// Function:  ExtendArray
//
// Synopsis:  Increase the array for one element as the size nSize
//            Reallocate and copy *ppvArray and increase *pnCount
//
// Arguments: void **ppvArray - the point to the array pointer
//            size_t nSize - the size of one element
//            UINT *pnCount - the number of element currently in the array
//
// Returns:   
//
// History:   feng sun Created Header    1/14/98
//
//+----------------------------------------------------------------------------
static void ExtendArray(IN OUT void **ppvArray, size_t nSize, IN OUT UINT *pnCount) 
{
    void *pvTmp;

    if (NULL != ppvArray && NULL != pnCount)
    {
        pvTmp = CmMalloc(nSize*(*pnCount+1));
        if (NULL != pvTmp)
        {
            CopyMemory(pvTmp,*ppvArray,nSize*(*pnCount));
            CmFree(*ppvArray);
            *ppvArray = pvTmp;
            (*pnCount)++;
        }
    }
}


//+---------------------------------------------------------------------------
//
//  struct ServiceInfo
//
//  Synopsis:   Save the information of a service under .cms [Service Types]
//
//  History:    fengsun created     1/14/97
//
//----------------------------------------------------------------------------

typedef struct tagServiceInfo 
{
    DWORD_PTR dwPB;
    UINT nServiceString;  
    PPBFS pFilter;
    PPBFS pFilterA;
    PPBFS pFilterB;
    LPTSTR pszFile;
} ServiceInfo;


class CPhoneBookInfo 
{
    public:
        CPhoneBookInfo();
        ~CPhoneBookInfo();
        BOOL Load(LPCTSTR pszFile, BOOL fHasValidTopLevelPBK, BOOL fHasValidReferencedPBKs);
        void LoadServiceTypes(HWND hwndDlg, UINT nIdServiceType, LPCTSTR pszServiceType);
        void LoadCountries(HWND hwndDlg, UINT nIdCountry, DWORD dwCountryId);
        void LoadRegions(HWND hwndDlg, UINT nIdRegion, LPCTSTR pszRegionName);
        void LoadNumbers(HWND hwndDlg,
                         UINT nIdNumberA,
                         UINT nIdNumberB,
                         UINT nIdMore,
                         LPCTSTR pszPhoneNumber,
                         LPCTSTR pszPhoneBookFile);
        //BOOL GetDisp(DWORD dwCookie, LPTSTR pszDisp, DWORD *pdwDisp);
        BOOL GetDesc(DWORD dwCookie, LPTSTR pszDesc, DWORD *pdwDesc);
        BOOL HasMoreNumbers();
        BOOL GetCanonical(DWORD dwCookie, LPTSTR pszCanonical, DWORD *pdwCanonical);
        BOOL GetNonCanonical(DWORD dwCookie, LPTSTR pszNonCanonical, DWORD *pdwNonCanonical);
        LPCTSTR GetFile(DWORD dwCookie);
        BOOL GetDUN(DWORD dwCookie, LPTSTR pszDUN, DWORD *pdwDUN);
    private:
        BOOL LoadFile(LPCTSTR pszFile, PPBFS pFilterA, PPBFS pFilterB);
        BOOL ServiceCB(LPCTSTR pszSvc,
                       PPBFS pFilter,
                       PPBFS pFilterA,
                       PPBFS pFilterB,
                       DWORD dwPB,
                       LPCTSTR pszFile);
        void LoadRegionsCB(unsigned int nIdx, DWORD_PTR dwParam);
        void LoadNumbersCB(unsigned int nIdx, DWORD_PTR dwParam);
        void LoadCountriesA(HWND hwndDlg, UINT nIdCountry, DWORD dwCountryId);
        void LoadCountriesW(HWND hwndDlg, UINT nIdCountry, DWORD dwCountryId);

        CPBMap m_Map;
        UINT m_nServiceString;
        LPTSTR *m_ppszServiceString;
        UINT m_nServiceInfo;            // the number of elements in m_psiServiceInfo
        ServiceInfo *m_psiServiceInfo;  // a array to save the information of all the services
                                        // under [Service Types]
        UINT m_nIdServiceType;
        UINT m_nIdCountry;
        UINT m_nIdRegion;
        UINT *m_pnRegionIdx;
        UINT m_nRegionIdx;
        typedef struct {
            CPhoneBookInfo *pInfo;
            PPBFS pFilterA;
            PPBFS pFilterB;
            DWORD dwPB;
            LPCSTR pszFile;
        } SCBS;
        friend BOOL WINAPI _ServiceCB(LPCSTR pszSvc, PPBFS pFilter, DWORD_PTR dwParam);

        friend BOOL WINAPI _ReferenceCB(LPCSTR pszFile,
                                        LPCSTR pszURL,
                                        PPBFS pFilterA,
                                        PPBFS pFilterB,
                                        DWORD_PTR dwParam);
        friend void WINAPI _LoadRegionsCB(unsigned int nIdx, DWORD_PTR dwParam);
        friend void WINAPI _LoadNumbersCB(unsigned int nIdx, DWORD_PTR dwParam);
};


LPCTSTR CPhoneBookInfo::GetFile(DWORD dwCookie) 
{
    DWORD dwParam;

    CMTRACE(TEXT("CPhoneBookInfo::GetFile"));

    DWORD_PTR dwPB = m_Map.PBFromCookie(dwCookie, &dwParam);

    if (dwPB == CPBMAP_ERROR) 
    {
        return (TEXT(""));
    }

    MYDBGASSERT(dwParam < m_nServiceInfo);
    
    return (m_psiServiceInfo[dwParam].pszFile);
}

/*
BOOL CPhoneBookInfo::GetDisp(DWORD dwCookie, LPTSTR pszDisp, DWORD *pdwDisp) 
{

    MYDBG(("CPhoneBookInfo::GetDisp"));

    return (PhoneBookGetPhoneDisp(m_Map.PBFromCookie(dwCookie),m_Map.IdxFromCookie(dwCookie),pszDisp,pdwDisp));
}
*/

BOOL CPhoneBookInfo::GetDesc(DWORD dwCookie, LPTSTR pszDesc, DWORD *pdwDesc) 
{
#ifdef UNICODE
    BOOL bReturn = FALSE;
    DWORD dwSize = *pdwDesc;
    LPSTR pszAnsiDesc = (LPSTR)CmMalloc(dwSize);

    if (pszAnsiDesc)
    {
        bReturn = PhoneBookGetPhoneDesc(m_Map.PBFromCookie(dwCookie), m_Map.IdxFromCookie(dwCookie), pszAnsiDesc, pdwDesc);

        MYVERIFY(0 != MultiByteToWideChar(CP_ACP, 0, pszAnsiDesc, -1, pszDesc, dwSize));

        CmFree(pszAnsiDesc);
    }

    return bReturn;

#else
    return (PhoneBookGetPhoneDesc(m_Map.PBFromCookie(dwCookie),m_Map.IdxFromCookie(dwCookie),pszDesc,pdwDesc));
#endif
    
}


BOOL CPhoneBookInfo::GetCanonical(DWORD dwCookie, LPTSTR pszCanonical, DWORD *pdwCanonical) 
{

#ifdef UNICODE
    BOOL bReturn = FALSE;
    DWORD dwSize = *pdwCanonical;
    LPSTR pszAnsiCanonical = (LPSTR)CmMalloc(dwSize);

    if (pszAnsiCanonical)
    {
        bReturn = PhoneBookGetPhoneCanonical(m_Map.PBFromCookie(dwCookie), m_Map.IdxFromCookie(dwCookie), 
            pszAnsiCanonical, pdwCanonical);

        MYVERIFY(0 != MultiByteToWideChar(CP_ACP, 0, pszAnsiCanonical, -1, pszCanonical, dwSize));

        CmFree(pszAnsiCanonical);
    }

    return bReturn;

#else
    return (PhoneBookGetPhoneCanonical(m_Map.PBFromCookie(dwCookie), m_Map.IdxFromCookie(dwCookie), 
        pszCanonical, pdwCanonical));
#endif

}

BOOL CPhoneBookInfo::GetNonCanonical(DWORD dwCookie, LPTSTR pszNonCanonical, DWORD *pdwNonCanonical) 
{

#ifdef UNICODE
    BOOL bReturn = FALSE;
    DWORD dwSize = *pdwNonCanonical;
    LPSTR pszAnsiNonCanonical = (LPSTR)CmMalloc(dwSize);

    if (pszAnsiNonCanonical)
    {
        bReturn = PhoneBookGetPhoneNonCanonical(m_Map.PBFromCookie(dwCookie), m_Map.IdxFromCookie(dwCookie), 
            pszAnsiNonCanonical, pdwNonCanonical);

        MYVERIFY(0 != MultiByteToWideChar(CP_ACP, 0, pszAnsiNonCanonical, -1, pszNonCanonical, dwSize));

        CmFree(pszAnsiNonCanonical);
    }

    return bReturn;

#else
    return (PhoneBookGetPhoneNonCanonical(m_Map.PBFromCookie(dwCookie),m_Map.IdxFromCookie(dwCookie),pszNonCanonical,pdwNonCanonical));
#endif

}

BOOL CPhoneBookInfo::GetDUN(DWORD dwCookie, LPTSTR pszDUN, DWORD *pdwDUN) 
{

#ifdef UNICODE
    BOOL bReturn = FALSE;
    DWORD dwSize = *pdwDUN;
    LPSTR pszAnsiDUN = (LPSTR)CmMalloc(dwSize);

    if (pszAnsiDUN)
    {
        bReturn = PhoneBookGetPhoneDUN(m_Map.PBFromCookie(dwCookie), m_Map.IdxFromCookie(dwCookie), 
            pszAnsiDUN, pdwDUN);

        MYVERIFY(0 != MultiByteToWideChar(CP_ACP, 0, pszAnsiDUN, -1, pszDUN, dwSize));

        CmFree(pszAnsiDUN);
    }

    return bReturn;

#else
    return (PhoneBookGetPhoneDUN(m_Map.PBFromCookie(dwCookie), m_Map.IdxFromCookie(dwCookie), 
        pszDUN, pdwDUN));
#endif

}


CPhoneBookInfo::CPhoneBookInfo() 
{

    m_nServiceString = 0;
    m_ppszServiceString = NULL;
    m_nServiceInfo = 0;
    m_psiServiceInfo = NULL;
    m_pnRegionIdx = NULL;
    m_nRegionIdx = 0;
}


CPhoneBookInfo::~CPhoneBookInfo() 
{

    while (m_nServiceString) 
    {
        CmFree(m_ppszServiceString[--m_nServiceString]);
    }
    
    CmFree(m_ppszServiceString);
    m_ppszServiceString = NULL;
    
    while (m_nServiceInfo) 
    {
        PhoneBookFreeFilter(m_psiServiceInfo[m_nServiceInfo-1].pFilter);
        PhoneBookFreeFilter(m_psiServiceInfo[m_nServiceInfo-1].pFilterA);
        PhoneBookFreeFilter(m_psiServiceInfo[m_nServiceInfo-1].pFilterB);
        CmFree(m_psiServiceInfo[m_nServiceInfo-1].pszFile);
        m_nServiceInfo--;
    }
    
    CmFree(m_psiServiceInfo);
    m_psiServiceInfo = NULL;
    CmFree(m_pnRegionIdx);
    m_pnRegionIdx = NULL;
    m_nRegionIdx = 0;
}

BOOL PhoneBookParseInfoWrapper(LPCTSTR pszFile, PhoneBookParseInfoStruct* piInfo)
{
#ifdef UNICODE
    BOOL bReturn;

    LPSTR pszAnsiFile = WzToSzWithAlloc(pszFile);

    if (NULL == pszAnsiFile)
    {
        return FALSE;
    }
    else
    {
        bReturn = PhoneBookParseInfo(pszAnsiFile, piInfo);
        CmFree(pszAnsiFile);
    }

    return bReturn;
#else
    return PhoneBookParseInfo(pszFile, piInfo);
#endif

}

BOOL CPhoneBookInfo::Load(LPCTSTR pszFile, BOOL fHasValidTopLevelPBK, BOOL fHasValidReferencedPBKs) 
{
    PhoneBookParseInfoStruct iInfo;
    BOOL bRes = FALSE;

    CMTRACE(TEXT("CPhoneBookInfo::Load"));

    CmFree(m_pnRegionIdx);
    m_pnRegionIdx = NULL;
    m_nRegionIdx = 0;
    if (!pszFile) 
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return (FALSE);
    }
    ZeroMemory(&iInfo,sizeof(iInfo));
    iInfo.dwSize = sizeof(iInfo);

    if (fHasValidTopLevelPBK) 
    {
        if (!PhoneBookParseInfoWrapper(pszFile,&iInfo)) 
        {
            return (FALSE);
        }
        bRes = LoadFile(pszFile,iInfo.pFilterA,iInfo.pFilterB);
        PhoneBookFreeFilter(iInfo.pFilterA);
        PhoneBookFreeFilter(iInfo.pFilterB);
        if (!bRes) 
        {
            return (FALSE);
        }
    }

    if (fHasValidReferencedPBKs) 
    {
        iInfo.pfnRef = _ReferenceCB;
        iInfo.dwRefParam = (DWORD_PTR) this;
        if (!PhoneBookParseInfoWrapper(pszFile,&iInfo)) 
        {
            return (FALSE);
        }
        PhoneBookFreeFilter(iInfo.pFilterA);
        PhoneBookFreeFilter(iInfo.pFilterB);
    }
    
    return (TRUE);
}


void CPhoneBookInfo::LoadServiceTypes(HWND hwndDlg, UINT nIdServiceType, LPCTSTR pszServiceType) 
{
    UINT nIdx;
    UINT nTmpIdx;

    CMTRACE(TEXT("CPhoneBookInfo::LoadServiceTypes"));

    CmFree(m_pnRegionIdx);
    m_pnRegionIdx = NULL;
    m_nRegionIdx = 0;
    m_nIdServiceType = nIdServiceType;
    SendDlgItemMessageU(hwndDlg, nIdServiceType, CB_RESETCONTENT,0,0);

    for (nIdx=0; nIdx < m_nServiceString; nIdx++) 
    { 
        nTmpIdx = (UINT) SendDlgItemMessageU(hwndDlg, nIdServiceType, CB_ADDSTRING, 0, (LPARAM) m_ppszServiceString[nIdx]);
        SendDlgItemMessageU(hwndDlg, nIdServiceType, CB_SETITEMDATA, nTmpIdx, nIdx);
    }
    
    if (SendDlgItemMessageU(hwndDlg, nIdServiceType, CB_GETCOUNT, 0, 0) > 1) 
    {
        LPTSTR pszDesc = NULL;

        EnableWindow(GetDlgItem(hwndDlg, nIdServiceType), TRUE);

        //
        // If the service type is empty, select the first type as a default
        //

        if ((!pszServiceType) || pszServiceType[0] == '\0')
        {
            pszDesc = CmStrCpyAlloc(m_ppszServiceString[0]); 
        }
        else
        {
            pszDesc = CmStrCpyAlloc(pszServiceType);
        }
            
        //
        // Search for the specified default and if found, make it the current
        // selection. Previously, we did this in the loop above, but 16-bit 
        // combos, don't remember the CURSEL when strings are added.
        //

        nTmpIdx = (UINT) SendDlgItemMessageU(hwndDlg, 
                                             nIdServiceType, 
                                             CB_FINDSTRINGEXACT,
                                             (WPARAM) -1,
                                             (LPARAM) pszDesc);
        if (nTmpIdx == CB_ERR) 
        {
            nTmpIdx = 0;
        }

        SendDlgItemMessageU(hwndDlg, nIdServiceType, CB_SETCURSEL, nTmpIdx, 0);

        CmFree(pszDesc);
    } 
    else 
    {
        EnableWindow(GetDlgItem(hwndDlg, nIdServiceType), FALSE);
    }
}


typedef struct tagLoadCountriesCBStruct 
{
    DWORD_PTR dwPB;
    HWND hwndDlg;
    UINT nId;
    DWORD dwCountryId;
} LoadCountriesCBStruct;


//
//  Note: this function and its mirror function _LoadCountriesCBW must stay in sync
//
static void WINAPI _LoadCountriesCBA(unsigned int nIdx, DWORD_PTR dwParam) 
{
    LoadCountriesCBStruct *pParam = (LoadCountriesCBStruct *) dwParam;
    CHAR szCountry[256];
    UINT nTmpIdx;
    DWORD dwCountryId = PhoneBookGetCountryId(pParam->dwPB, nIdx);
    DWORD dwLen;

    szCountry[0] = '\0';

    dwLen = sizeof(szCountry) / sizeof(CHAR);
    PhoneBookGetCountryNameA(pParam->dwPB, nIdx, szCountry, &dwLen);
    wsprintfA(szCountry + lstrlenA(szCountry), " (%u)", dwCountryId);

    nTmpIdx = (UINT) SendDlgItemMessageA(pParam->hwndDlg, pParam->nId, CB_FINDSTRINGEXACT, (WPARAM) -1, (LPARAM)szCountry);
    
    if (nTmpIdx != CB_ERR) 
    {
        return;
    }
    
    nTmpIdx = (UINT) SendDlgItemMessageA(pParam->hwndDlg, pParam->nId, CB_ADDSTRING, 0, (LPARAM) szCountry);
    
    SendDlgItemMessageA(pParam->hwndDlg, pParam->nId, CB_SETITEMDATA, nTmpIdx, dwCountryId);
    
    if (pParam->dwCountryId && (dwCountryId == pParam->dwCountryId)) 
    {
        SendDlgItemMessageA(pParam->hwndDlg, pParam->nId, CB_SETCURSEL, nTmpIdx, 0);
    }
}

//
//  Note: this function and its mirror function _LoadCountriesCBA must stay in sync
//
static void WINAPI _LoadCountriesCBW(unsigned int nIdx, DWORD_PTR dwParam) 
{
    LoadCountriesCBStruct *pParam = (LoadCountriesCBStruct *) dwParam;
    WCHAR szCountry[256];
    UINT nTmpIdx;
    DWORD dwCountryId = PhoneBookGetCountryId(pParam->dwPB, nIdx);
    DWORD dwLen;

    szCountry[0] = L'\0';

    dwLen = sizeof(szCountry) / sizeof(WCHAR);
    PhoneBookGetCountryNameW(pParam->dwPB, nIdx, szCountry, &dwLen);
    wsprintfW(szCountry + lstrlenW(szCountry), L" (%u)", dwCountryId);

    nTmpIdx = (UINT) SendDlgItemMessageW(pParam->hwndDlg, pParam->nId, CB_FINDSTRINGEXACT, (WPARAM) -1, (LPARAM)szCountry);
    
    if (nTmpIdx != CB_ERR) 
    {
        return;
    }
    
    nTmpIdx = (UINT) SendDlgItemMessageW(pParam->hwndDlg, pParam->nId, CB_ADDSTRING, 0, (LPARAM) szCountry);

    SendDlgItemMessageW(pParam->hwndDlg, pParam->nId, CB_SETITEMDATA, nTmpIdx, dwCountryId);
    
    if (pParam->dwCountryId && (dwCountryId == pParam->dwCountryId)) 
    {
        SendDlgItemMessageW(pParam->hwndDlg, pParam->nId, CB_SETCURSEL, nTmpIdx, 0);
    }
}


void CPhoneBookInfo::LoadCountries(HWND hwndDlg, UINT nIdCountry, DWORD dwCountryId) 
{
    CMTRACE(TEXT("CPhoneBookInfo::LoadCountries"));

    if (OS_NT51)
    {
        return LoadCountriesW(hwndDlg, nIdCountry, dwCountryId);
    }
    else
    {
        return LoadCountriesA(hwndDlg, nIdCountry, dwCountryId);
    }
}

//
//  Note: this function and its mirror function LoadCountriesW must stay in sync
//
void CPhoneBookInfo::LoadCountriesA(HWND hwndDlg, UINT nIdCountry, DWORD dwCountryId) 
{
    UINT nIdx;
    DWORD_PTR nServiceType;

    CMTRACE(TEXT("CPhoneBookInfo::LoadCountriesA"));

    CmFree(m_pnRegionIdx);
    m_pnRegionIdx = NULL;
    m_nRegionIdx = 0;
    m_nIdCountry = nIdCountry;
    SendDlgItemMessageA(hwndDlg, nIdCountry, CB_RESETCONTENT, 0, 0);
    
    nIdx = (UINT) SendDlgItemMessageA(hwndDlg, m_nIdServiceType, CB_GETCURSEL, 0, 0);

    if (nIdx == CB_ERR) 
    {
        return;
    }
    
    nServiceType = SendDlgItemMessageA(hwndDlg, m_nIdServiceType, CB_GETITEMDATA, nIdx, 0);
    MYDBGASSERT(nServiceType<m_nServiceInfo);
    
    for (nIdx=0; nIdx < m_nServiceInfo; nIdx++) 
    {
        if (m_psiServiceInfo[nIdx].nServiceString == nServiceType) 
        {
            LoadCountriesCBStruct sParam = {m_Map.GetPBByIdx(m_psiServiceInfo[nIdx].dwPB),
                                            hwndDlg,
                                            nIdCountry,
                                            dwCountryId?dwCountryId:PhoneBookGetCurrentCountryId()};

            PhoneBookEnumCountries(m_Map.GetPBByIdx(m_psiServiceInfo[nIdx].dwPB),
                                   _LoadCountriesCBA,
                                   m_psiServiceInfo[nIdx].pFilter,
                                   (DWORD_PTR) &sParam);
        }
    }
    
    if ((SendDlgItemMessageA(hwndDlg,nIdCountry,CB_GETCURSEL,0,0) == CB_ERR) &&
        (SendDlgItemMessageA(hwndDlg,nIdCountry,CB_GETCOUNT,0,0) != 0)) 
    {
        SendDlgItemMessageA(hwndDlg,nIdCountry,CB_SETCURSEL,0,0);
    }
}


//
//  Note: this function and its mirror function LoadCountriesA must stay in sync
//
void CPhoneBookInfo::LoadCountriesW(HWND hwndDlg, UINT nIdCountry, DWORD dwCountryId) 
{
    UINT nIdx;
    DWORD_PTR nServiceType;

    CMTRACE(TEXT("CPhoneBookInfo::LoadCountriesW"));

    CmFree(m_pnRegionIdx);
    m_pnRegionIdx = NULL;
    m_nRegionIdx = 0;
    m_nIdCountry = nIdCountry;
    SendDlgItemMessageW(hwndDlg, nIdCountry, CB_RESETCONTENT, 0, 0);
    
    nIdx = (UINT) SendDlgItemMessageW(hwndDlg, m_nIdServiceType, CB_GETCURSEL, 0, 0);

    if (nIdx == CB_ERR) 
    {
        return;
    }
    
    nServiceType = SendDlgItemMessageW(hwndDlg, m_nIdServiceType, CB_GETITEMDATA, nIdx, 0);
    MYDBGASSERT(nServiceType<m_nServiceInfo);
    
    for (nIdx=0; nIdx < m_nServiceInfo; nIdx++) 
    {
        if (m_psiServiceInfo[nIdx].nServiceString == nServiceType) 
        {
            LoadCountriesCBStruct sParam = {m_Map.GetPBByIdx(m_psiServiceInfo[nIdx].dwPB),
                                            hwndDlg,
                                            nIdCountry,
                                            dwCountryId?dwCountryId:PhoneBookGetCurrentCountryId()};

            PhoneBookEnumCountries(m_Map.GetPBByIdx(m_psiServiceInfo[nIdx].dwPB),
                                   _LoadCountriesCBW,
                                   m_psiServiceInfo[nIdx].pFilter,
                                   (DWORD_PTR) &sParam);
        }
    }
    
    if ((SendDlgItemMessageW(hwndDlg,nIdCountry,CB_GETCURSEL,0,0) == CB_ERR) &&
        (SendDlgItemMessageW(hwndDlg,nIdCountry,CB_GETCOUNT,0,0) != 0)) 
    {
        SendDlgItemMessageW(hwndDlg,nIdCountry,CB_SETCURSEL,0,0);
    }
}


typedef struct tagLoadRegionsCBStruct 
{
    CPhoneBookInfo *pPhoneBook;
    DWORD_PTR dwPB;
    HWND hwndDlg;
    UINT nId;
    LPCSTR pszRegionName;
    UINT nServiceInfo;
} LoadRegionsCBStruct;


void CPhoneBookInfo::LoadRegionsCB(unsigned int nIdx, DWORD_PTR dwParam) 
{
    UINT nTmpIdx;

    LoadRegionsCBStruct *pParam = (LoadRegionsCBStruct *) dwParam;
    CHAR szRegionName[256];
    DWORD dwLen;

    dwLen = sizeof(szRegionName) / sizeof(CHAR);
    PhoneBookGetRegionNameA(pParam->dwPB, nIdx, szRegionName, &dwLen);
    ExtendArray((void **) &m_pnRegionIdx, sizeof(*m_pnRegionIdx)*m_nServiceInfo, &m_nRegionIdx);
    
    for (nTmpIdx = 0; nTmpIdx < m_nServiceInfo; nTmpIdx++) 
    {
        m_pnRegionIdx[m_nServiceInfo*(m_nRegionIdx-1) + nTmpIdx] = UINT_MAX;
    }
    
    nTmpIdx = (UINT) SendDlgItemMessageA(pParam->hwndDlg, pParam->nId, CB_FINDSTRINGEXACT, 0, (LPARAM) szRegionName);
    
    if (nTmpIdx == CB_ERR) 
    {
        nTmpIdx = (UINT) SendDlgItemMessageA(pParam->hwndDlg, pParam->nId, CB_ADDSTRING, 0, (LPARAM) szRegionName);
        
        SendDlgItemMessageA(pParam->hwndDlg, pParam->nId, CB_SETITEMDATA, nTmpIdx, m_nRegionIdx - 1);

        if (pParam->pszRegionName && (lstrcmpA(szRegionName, pParam->pszRegionName) == 0)) 
        {
            SendDlgItemMessageA(pParam->hwndDlg, pParam->nId, CB_SETCURSEL, nTmpIdx, 0);
        }

        m_pnRegionIdx[m_nServiceInfo*(m_nRegionIdx-1) + pParam->nServiceInfo] = nIdx;

    } 
    else 
    {
        DWORD_PTR dwTmp = SendDlgItemMessageA(pParam->hwndDlg, pParam->nId, CB_GETITEMDATA, nTmpIdx, 0);
        m_pnRegionIdx[m_nServiceInfo*dwTmp + pParam->nServiceInfo] = nIdx;
    }
}

static void WINAPI _LoadRegionsCB(unsigned int nIdx, DWORD_PTR dwParam) 
{

    ((LoadRegionsCBStruct *) dwParam)->pPhoneBook->LoadRegionsCB(nIdx,dwParam);
}


void CPhoneBookInfo::LoadRegions(HWND hwndDlg, UINT nIdRegion, LPCTSTR pszRegionName) 
{
    UINT nIdx;
    DWORD dwServiceType;
    DWORD dwCountryID;

    CMTRACE(TEXT("CPhoneBookInfo::LoadRegions"));

    CmFree(m_pnRegionIdx);
    m_pnRegionIdx = NULL;
    m_nRegionIdx = 0;
    m_nIdRegion = nIdRegion;
    SendDlgItemMessageU(hwndDlg,nIdRegion,CB_RESETCONTENT,0,0);
    
    nIdx = (UINT) SendDlgItemMessageU(hwndDlg,m_nIdServiceType,CB_GETCURSEL,0,0);
    if (nIdx == CB_ERR) 
    {
        return;
    }
    
    dwServiceType = (DWORD)SendDlgItemMessageU(hwndDlg,m_nIdServiceType,CB_GETITEMDATA,nIdx,0);
    MYDBGASSERT(dwServiceType<m_nServiceInfo);
    
    nIdx = (UINT) SendDlgItemMessageU(hwndDlg,m_nIdCountry,CB_GETCURSEL,0,0);
    if (nIdx == CB_ERR) 
    {
        return;
    }
    
    dwCountryID = (DWORD)SendDlgItemMessageU(hwndDlg,m_nIdCountry,CB_GETITEMDATA,nIdx,0);
    for (nIdx=0;nIdx<m_nServiceInfo;nIdx++) 
    {
        if (m_psiServiceInfo[nIdx].nServiceString == dwServiceType) 
        {

#ifdef UNICODE
            LPSTR pszAnsiRegionName = WzToSzWithAlloc(pszRegionName);

            if (NULL == pszAnsiRegionName)
            {
                return;
            }
#endif
            LoadRegionsCBStruct sParam = {this,
                                          m_Map.GetPBByIdx(m_psiServiceInfo[nIdx].dwPB),
                                          hwndDlg,
                                          nIdRegion,
#ifdef UNICODE
                                          pszAnsiRegionName,
#else
                                          pszRegionName,
#endif
                                          nIdx};

            PhoneBookEnumRegions(sParam.dwPB,
                                 _LoadRegionsCB,
                                 dwCountryID,
                                 m_psiServiceInfo[nIdx].pFilter,
                                 (DWORD_PTR) &sParam);
#ifdef UNICODE
            CmFree(pszAnsiRegionName);
#endif
        }
    }
    
    if (SendDlgItemMessageU(hwndDlg,nIdRegion,CB_GETCOUNT,0,0) != 0)
    {
        EnableWindow(GetDlgItem(hwndDlg,nIdRegion),TRUE); /* 10763 */
        EnableWindow(GetDlgItem(hwndDlg, IDC_PHONEBOOK_REGION_STATIC), TRUE);
    }
    else
    {
        EnableWindow(GetDlgItem(hwndDlg,nIdRegion),FALSE);
        EnableWindow(GetDlgItem(hwndDlg, IDC_PHONEBOOK_REGION_STATIC), FALSE);
    }

    if ((SendDlgItemMessageU(hwndDlg,nIdRegion,CB_GETCURSEL,0,0) == CB_ERR) &&
        (SendDlgItemMessageU(hwndDlg,nIdRegion,CB_GETCOUNT,0,0) != 0)) 
    {
        SendDlgItemMessageU(hwndDlg,nIdRegion,CB_SETCURSEL,0,0);
    }
}


typedef struct tagLoadNumbersCBStruct 
{
    CPhoneBookInfo *pPhoneBook;
    DWORD_PTR dwPB;
    HWND hwndDlg;
    UINT nIdA;
    UINT nIdB;
    UINT nIdMore;
    PPBFS pFilterA;
    PPBFS pFilterB;
    LPCSTR pszPhoneNumber;
    LPCSTR pszPhoneBookFile;
} LoadNumbersCBStruct;


void CPhoneBookInfo::LoadNumbersCB(unsigned int nIdx, DWORD_PTR dwParam) 
{
    UINT nTmpIdx;

    LoadNumbersCBStruct *pParam = (LoadNumbersCBStruct *) dwParam;
    CHAR szPhoneNumber[256];
    DWORD dwType = PhoneBookGetPhoneType(pParam->dwPB, nIdx);
    UINT nId;
    UINT nOtherId;
    DWORD dwLen;
    BOOL bMatch = FALSE;
    DWORD dwCookie = m_Map.ToCookie(pParam->dwPB, nIdx);
    LPSTR pszAnsiPhoneBookFile;

#ifdef UNICODE
    pszAnsiPhoneBookFile = WzToSzWithAlloc(GetFile(dwCookie));

    if (NULL == pszAnsiPhoneBookFile)
    {
        CMASSERTMSG(FALSE, TEXT("CPhoneBookInfo::LoadNumbersCB -- Insufficient memory for Wide to Ansi conversion."));
        goto exit;
    }
#else
    pszAnsiPhoneBookFile = GetFile(dwCookie);
#endif


    if (PhoneBookMatchFilter(pParam->pFilterA,dwType)) 
    {
        nId = pParam->nIdA;
        nOtherId = pParam->nIdB;
    } 
    else if (PhoneBookMatchFilter(pParam->pFilterB,dwType)) 
    {
        nId = pParam->nIdB;
        nOtherId = pParam->nIdA;
    } 
    else 
    {
        goto exit;
    }
    
    if (pParam->pszPhoneNumber && pParam->pszPhoneBookFile) 
    {
        dwLen = sizeof(szPhoneNumber) / sizeof(TCHAR);

        PhoneBookGetPhoneCanonical(pParam->dwPB, nIdx, szPhoneNumber, &dwLen);

        if ((lstrcmpA(szPhoneNumber, pParam->pszPhoneNumber) == 0) &&
            (lstrcmpA(pszAnsiPhoneBookFile, pParam->pszPhoneBookFile) == 0)) 
        {
            bMatch = TRUE;
        }
    }
    
    if (GetDlgItem(pParam->hwndDlg,nId)) 
    {

        dwLen = sizeof(szPhoneNumber) / sizeof(TCHAR);

        PhoneBookGetPhoneDisp(pParam->dwPB, nIdx, szPhoneNumber, &dwLen);
        nTmpIdx = (UINT) SendDlgItemMessageA(pParam->hwndDlg, nId, LB_FINDSTRINGEXACT, (WPARAM) -1, 
            (LPARAM) szPhoneNumber);

        if (nTmpIdx != LB_ERR) 
        {
            goto exit;
        }

        nTmpIdx = (UINT) SendDlgItemMessageA(pParam->hwndDlg, nId, LB_ADDSTRING, 0, (LPARAM) szPhoneNumber);

        DWORD_PTR dwSet = SendDlgItemMessageA(pParam->hwndDlg, nId, LB_SETITEMDATA, nTmpIdx, (LPARAM) dwCookie);

#ifdef DEBUG
        if (LB_ERR == dwSet)
        {
            CMTRACE(TEXT("PBDlgProc() LB_SETITEMDATA failed"));
        }
#endif

    } 
    else 
    {
        EnableWindow(GetDlgItem(pParam->hwndDlg,pParam->nIdMore),TRUE);
    
        if (bMatch) 
        {
            SendMessageA(pParam->hwndDlg, WM_COMMAND, pParam->nIdMore, 0);
        }
    }

exit:

#ifdef UNICODE
    CmFree(pszAnsiPhoneBookFile);
#endif

    return;
}

static void WINAPI _LoadNumbersCB(unsigned int nIdx, DWORD_PTR dwParam) 
{
    ((LoadNumbersCBStruct *) dwParam)->pPhoneBook->LoadNumbersCB(nIdx,dwParam);
}


void CPhoneBookInfo::LoadNumbers(HWND hwndDlg,
                                 UINT nIdNumberA,
                                 UINT nIdNumberB,
                                 UINT nIdMore,
                                 LPCTSTR pszPhoneNumber,
                                 LPCTSTR pszPhoneBookFile) 
{
    UINT nIdx;
    DWORD dwServiceType;
    DWORD dwCountryID;
    DWORD dwRegionIdx = UINT_MAX;

    CMTRACE(TEXT("CPhoneBookInfo::LoadNumbers"));

    LPSTR pszAnsiPhoneNumber = NULL;
    LPSTR pszAnsiPhoneBookFile = NULL;

#ifdef UNICODE
    pszAnsiPhoneNumber = WzToSzWithAlloc(pszPhoneNumber);

    if (NULL == pszAnsiPhoneNumber)
    {
        CMTRACE(TEXT("CPhoneBookInfo::LoadNumbers -- Insufficient Memory to convert from Wide to MBCS for pszPhoneNumber"));
        goto exit;
    }

    pszAnsiPhoneBookFile = WzToSzWithAlloc(pszPhoneBookFile);

    if (NULL == pszAnsiPhoneBookFile)
    {
        CMTRACE(TEXT("CPhoneBookInfo::LoadNumbers -- Insufficient Memory to convert from Wide to MBCS for pszPhoneBookFile"));
        goto exit;
    }

#else
    pszAnsiPhoneNumber = (LPSTR)pszPhoneNumber;
    pszAnsiPhoneBookFile = (LPSTR)pszPhoneBookFile;
#endif


    SendDlgItemMessageA(hwndDlg, nIdNumberA, LB_RESETCONTENT, 0, 0);
    SendDlgItemMessageA(hwndDlg, nIdNumberB, LB_RESETCONTENT, 0, 0);

#if 0
//  EnableWindow(GetDlgItem(hwndDlg,nIdMore),FALSE); Note: More button is now obsolete
#endif
    
    //
    // Get the current service type
    //

    nIdx = (UINT) SendDlgItemMessageA(hwndDlg, m_nIdServiceType, CB_GETCURSEL, 0, 0);

    if (nIdx == CB_ERR) 
    {
        goto exit;
    }

    dwServiceType = (DWORD)SendDlgItemMessageA(hwndDlg, m_nIdServiceType, CB_GETITEMDATA, nIdx, 0);
    MYDBGASSERT(dwServiceType < m_nServiceInfo);
    
    //
    // Get the current country code
    //

    nIdx = (UINT) SendDlgItemMessageA(hwndDlg, m_nIdCountry, CB_GETCURSEL, 0, 0);
    
    if (nIdx == CB_ERR) 
    {
        goto exit;
    }

    dwCountryID = (DWORD)SendDlgItemMessageA(hwndDlg, m_nIdCountry, CB_GETITEMDATA, nIdx, 0);
    
    //
    // Get the current region ID
    //
    
    nIdx = (UINT) SendDlgItemMessageA(hwndDlg, m_nIdRegion, CB_GETCURSEL, 0, 0);

    if (nIdx != CB_ERR) 
    {
        dwRegionIdx = (DWORD)SendDlgItemMessageA(hwndDlg, m_nIdRegion, CB_GETITEMDATA, nIdx, 0);
    } 
    
    for (nIdx=0; nIdx < m_nServiceInfo; nIdx++) 
    {
        if (m_psiServiceInfo[nIdx].nServiceString == dwServiceType) 
        {
            if ((dwRegionIdx == UINT_MAX) || 
                (m_pnRegionIdx[m_nServiceInfo*dwRegionIdx+nIdx] != UINT_MAX)) 
            {
                LoadNumbersCBStruct sParam = {this,
                                              m_Map.GetPBByIdx(m_psiServiceInfo[nIdx].dwPB),
                                              hwndDlg,
                                              nIdNumberA,
                                              nIdNumberB,
                                              nIdMore,
                                              m_psiServiceInfo[nIdx].pFilterA,
                                              m_psiServiceInfo[nIdx].pFilterB,
                                              pszAnsiPhoneNumber,
                                              pszAnsiPhoneBookFile};

                PhoneBookEnumNumbers(sParam.dwPB,
                                     _LoadNumbersCB,
                                     dwCountryID,
                                     (dwRegionIdx == UINT_MAX) ? UINT_MAX : m_pnRegionIdx[m_nServiceInfo*dwRegionIdx+nIdx],
                                     m_psiServiceInfo[nIdx].pFilter,
                                     (DWORD_PTR) &sParam);
            }
            else 
            {
                //
                // Multiple PBKs (especially if one has no regions) can create a 
                // situation in which we have a valid region selection in the combo
                // but the m_pnRegionIdx[m_nServiceInfo*dwRegionIdx+nIdx] is 
                // UINT_MAX. What we do in this situation is enumerate the 
                // numbers such that only those without regions are added to the 
                // list by enumerating phone numbers with region 0.
                //

                if ((dwRegionIdx != UINT_MAX) && 
                    (m_pnRegionIdx[m_nServiceInfo*dwRegionIdx+nIdx] == UINT_MAX))
                {
                    LoadNumbersCBStruct sParam = {this,
                                                  m_Map.GetPBByIdx(m_psiServiceInfo[nIdx].dwPB),
                                                  hwndDlg,
                                                  nIdNumberA,
                                                  nIdNumberB,
                                                  nIdMore,
                                                  m_psiServiceInfo[nIdx].pFilterA,
                                                  m_psiServiceInfo[nIdx].pFilterB,
                                                  pszAnsiPhoneNumber,
                                                  pszAnsiPhoneBookFile};

                    PhoneBookEnumNumbersWithRegionsZero(sParam.dwPB,
                                                         _LoadNumbersCB,
                                                         dwCountryID,
                                                         m_psiServiceInfo[nIdx].pFilter,
                                                         (DWORD_PTR) &sParam);
                }
            }
        }
    }

exit:

#ifdef UNICODE
    CmFree(pszAnsiPhoneNumber);
    CmFree(pszAnsiPhoneBookFile);
#endif

    return;
}

BOOL CPhoneBookInfo::HasMoreNumbers()
{
    //
    // Filters are stored by service type, so examine each one.
    //

    for (UINT nIdx = 0; nIdx < m_nServiceInfo; nIdx++) 
    {       
        if (PhoneBookHasPhoneType(m_Map.GetPBByIdx(m_psiServiceInfo[nIdx].dwPB), m_psiServiceInfo[nIdx].pFilterB))
        {
            return TRUE;
        }
    }

    return FALSE;
}

BOOL CPhoneBookInfo::LoadFile(LPCTSTR pszFile, PPBFS pFilterA, PPBFS pFilterB) 
{
    CMTRACE(TEXT("CPhoneBookInfo::LoadFile"));

    LPSTR pszAnsiFile = NULL;
    BOOL bRes = TRUE;

#ifdef UNICODE
    pszAnsiFile = WzToSzWithAlloc(pszFile);
    if (!pszAnsiFile)
    {
        return FALSE;
    }
#else
    pszAnsiFile = (LPSTR)pszFile;
#endif

    SCBS sSvc = {this,pFilterA,pFilterB,0,pszAnsiFile};
    PhoneBookParseInfoStruct iInfo;

    sSvc.dwPB = m_Map.Open(pszAnsiFile, m_nServiceInfo);
    
    if (sSvc.dwPB == CPBMAP_ERROR) 
    {
        bRes = FALSE;
        goto exit;
    }

    ZeroMemory(&iInfo, sizeof(iInfo));
    iInfo.dwSize = sizeof(iInfo);
    iInfo.pfnSvc = _ServiceCB; 
    iInfo.dwSvcParam = (DWORD_PTR) &sSvc;

    CMTRACE(TEXT("CPhoneBookInfo::LoadFile - ParseInfo"));

    bRes = PhoneBookParseInfo(pszAnsiFile, &iInfo);

    PhoneBookFreeFilter(iInfo.pFilterA);
    PhoneBookFreeFilter(iInfo.pFilterB);

exit:

#ifdef UNICODE
        CmFree(pszAnsiFile);
#endif

    return (bRes);
}


BOOL CPhoneBookInfo::ServiceCB(LPCTSTR pszSvc,
                               PPBFS pFilter,
                               PPBFS pFilterA,
                               PPBFS pFilterB,
                               DWORD dwPB,
                               LPCTSTR pszFile) 
{
    ServiceInfo *psiInfo;
    UINT nIdx;

    CMTRACE(TEXT("CPhoneBookInfo::ServiceCB"));

    //
    // Extended m_psiServiceInfo and set up the new element
    //

    ExtendArray((void **) &m_psiServiceInfo,sizeof(*m_psiServiceInfo),&m_nServiceInfo);
    psiInfo = &m_psiServiceInfo[m_nServiceInfo-1];
    psiInfo->dwPB = dwPB;
    psiInfo->pFilter = pFilter;
    psiInfo->pFilterA = PhoneBookCopyFilter(pFilterA);
    psiInfo->pFilterB = PhoneBookCopyFilter(pFilterB);
    psiInfo->pszFile = CmStrCpyAlloc(pszFile);
    
    for (nIdx=0;nIdx<m_nServiceString;nIdx++) 
    {
        if (lstrcmpU(pszSvc,m_ppszServiceString[nIdx]) == 0) 
        {
            psiInfo->nServiceString = nIdx;
            break;
        }
    }
    
    if (nIdx == m_nServiceString) 
    {
        ExtendArray((void **) &m_ppszServiceString,sizeof(*m_ppszServiceString),&m_nServiceString);
        m_ppszServiceString[m_nServiceString-1] = CmStrCpyAlloc(pszSvc);
        psiInfo->nServiceString = m_nServiceString - 1;
    }
    return (TRUE);
}

static BOOL WINAPI _ReferenceCB(LPCSTR pszFile,
                                LPCSTR pszURL,
                                PPBFS pFilterA,
                                PPBFS pFilterB,
                                DWORD_PTR dwParam) 
{
    CPhoneBookInfo *pParam = (CPhoneBookInfo *) dwParam;

#ifdef UNICODE
    LPWSTR pszwFile = NULL;
    pszwFile = SzToWzWithAlloc(pszFile);
    BOOL bReturn = FALSE;

    if (NULL != pszwFile)
    {
        bReturn = pParam->LoadFile(pszwFile, pFilterA, pFilterB);
        CmFree(pszwFile);       
    }
    else
    {
        CMTRACE(TEXT("_ReferenceCB -- CmMalloc returned a NULL pointer."));
    }

    return bReturn;

#else
    return (pParam->LoadFile(pszFile, pFilterA, pFilterB));
#endif
}


static BOOL CALLBACK _ServiceCB(LPCSTR pszSvc, PPBFS pFilter, DWORD_PTR dwParam) 
{
    CPhoneBookInfo::SCBS *pParam = (CPhoneBookInfo::SCBS *) dwParam;

#ifdef UNICODE
    BOOL bReturn = FALSE;
    LPWSTR pszwSvc = SzToWzWithAlloc(pszSvc);
    LPWSTR pszwFile = SzToWzWithAlloc(pParam->pszFile);

    if ((NULL != pszwFile) && (NULL != pszwSvc))
    {
        bReturn = (pParam->pInfo->ServiceCB)(pszwSvc,
                                             pFilter,
                                             pParam->pFilterA,
                                             pParam->pFilterB,
                                             pParam->dwPB,
                                             pszwFile);
    }

    CmFree(pszwSvc);    
    CmFree(pszwFile);    

    return bReturn;

#else
    return (pParam->pInfo->ServiceCB(pszSvc,
                                     pFilter,
                                     pParam->pFilterA,
                                     pParam->pFilterB,
                                     pParam->dwPB,
                                     pParam->pszFile));
#endif

}


typedef struct tagPBDlgArgs 
{
    PBArgs *pPBArgs;
    CPhoneBookInfo cPB;
    BMPDATA BmpData;
} PBDlgArgs;


static BOOL PBDlgFillData(HWND hwndDlg, PBArgs *pPBArgs, CPhoneBookInfo *pPB, BOOL fValidateDun) 
{
    UINT nTmpIdx;
    UINT nId;
    DWORD dwLen;

    GetDlgItemTextU(hwndDlg,IDC_PHONEBOOK_SERVICETYPE_COMBO,pPBArgs->szServiceType,sizeof(pPBArgs->szServiceType)/sizeof(TCHAR)-1);
    
    nTmpIdx = (UINT) SendDlgItemMessageU(hwndDlg,IDC_PHONEBOOK_COUNTRY_COMBO,CB_GETCURSEL,0,0);
    if (nTmpIdx != CB_ERR) 
    {
        pPBArgs->dwCountryId = (DWORD)SendDlgItemMessageU(hwndDlg,IDC_PHONEBOOK_COUNTRY_COMBO,CB_GETITEMDATA,nTmpIdx,0);
    } 
    else 
    {
        pPBArgs->dwCountryId = PhoneBookGetCurrentCountryId();
    }
    
    GetDlgItemTextU(hwndDlg,IDC_PHONEBOOK_REGION_COMBO,pPBArgs->szRegionName,sizeof(pPBArgs->szRegionName)/sizeof(TCHAR)-1);
    nId = IDC_PHONEBOOK_PHONE_LIST;
    
    nTmpIdx = (UINT) SendDlgItemMessageU(hwndDlg,nId,LB_GETCURSEL,0,0);
    if (nTmpIdx == LB_ERR) 
    {
        if (GetDlgItem(hwndDlg,IDC_PHONEBOOKEX_PHONE_LIST)) 
        {
            nId = IDC_PHONEBOOKEX_PHONE_LIST;
            nTmpIdx = (UINT) SendDlgItemMessageU(hwndDlg,nId,LB_GETCURSEL,0,0);

            UINT nTmpCount = (UINT) SendDlgItemMessageU(hwndDlg,nId,LB_GETCOUNT,0,0);

        }
    }
    
    if (nTmpIdx != LB_ERR) 
    {
        DWORD dwIdx = (DWORD)SendDlgItemMessageU(hwndDlg,nId,LB_GETITEMDATA,nTmpIdx,0);
        
        if (dwIdx != LB_ERR)
        {
            dwLen = sizeof(pPBArgs->szNonCanonical) / sizeof(TCHAR);
            pPB->GetNonCanonical(dwIdx,pPBArgs->szNonCanonical,&dwLen);

            dwLen = sizeof(pPBArgs->szCanonical) / sizeof(TCHAR);
            pPB->GetCanonical(dwIdx,pPBArgs->szCanonical,&dwLen);

            dwLen = sizeof(pPBArgs->szDesc) / sizeof(TCHAR);
            pPB->GetDesc(dwIdx,pPBArgs->szDesc,&dwLen);
            lstrcpynU(pPBArgs->szPhoneBookFile,pPB->GetFile(dwIdx),sizeof(pPBArgs->szPhoneBookFile)/sizeof(TCHAR));
            dwLen = sizeof(pPBArgs->szDUNFile) / sizeof(TCHAR);
            pPB->GetDUN(dwIdx,pPBArgs->szDUNFile,&dwLen);
            
            if (fValidateDun)
            {
                //
                // Make sure we can support any DUN settings associated with the number
                //
                
                if (FALSE == ValidateDialupDunSettings(pPBArgs->szPhoneBookFile, pPBArgs->szDUNFile, pPBArgs->pszCMSFile))
                {           
                    return FALSE;
                }       
            }
        }
#ifdef DEBUG
        if (LB_ERR == dwIdx)
        {
            CMTRACE(TEXT("PBDlgProc() LB_GETITEMDATA failed"));
        }
#endif
    }

    return TRUE;
}


INT_PTR CALLBACK PBDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) 
{
    PBDlgArgs *pArgs = (PBDlgArgs *) GetWindowLongU(hwndDlg,DWLP_USER);
    static DWORD adwHelp[] = {IDC_PHONEBOOK_SERVICETYPE_COMBO,IDH_PHONEBOOK_SERVICETYP,
                              IDC_PHONEBOOK_COUNTRY_COMBO,IDH_PHONEBOOK_COUNTRY,
                              IDC_PHONEBOOK_REGION_COMBO,IDH_PHONEBOOK_STATEREG,
                              IDC_PHONEBOOK_REGION_STATIC,IDH_PHONEBOOK_STATEREG,
                              IDC_PHONEBOOK_PHONE_LIST,IDH_PHONEBOOK_ACCESSNUMS,
                              IDC_PHONEBOOK_HELP_BUTTON, IDH_CMHELP,
                              //IDC_PHONEBOOK_MORE_BUTTON,IDH_PHONEBOOK_MORE,
                              IDC_PHONEBOOKEX_MESSAGE_DISPLAY,IDH_PHONEBOOK_SVCMSG,
                              IDC_PHONEBOOKEX_MORE_STATIC,IDH_PHONEBOOK_MORENUMS,
                              IDC_PHONEBOOKEX_PHONE_LIST,IDH_PHONEBOOK_MORENUMS,
                              0,0};
    switch (uMsg) 
    {
        case WM_INITDIALOG:

            CMTRACE(TEXT("PBDlgProc - WM_INITDIALOG"));
            
            UpdateFont(hwndDlg);

            pArgs = (PBDlgArgs *) lParam;
            SetWindowLongU(hwndDlg,DWLP_USER,(LONG_PTR) pArgs);
            SetDlgItemTextU(hwndDlg,IDC_PHONEBOOKEX_MESSAGE_DISPLAY,pArgs->pPBArgs->pszMessage);
            pArgs->cPB.LoadServiceTypes(hwndDlg,IDC_PHONEBOOK_SERVICETYPE_COMBO,pArgs->pPBArgs->szServiceType);
            pArgs->cPB.LoadCountries(hwndDlg,IDC_PHONEBOOK_COUNTRY_COMBO,pArgs->pPBArgs->dwCountryId);
            pArgs->cPB.LoadRegions(hwndDlg,IDC_PHONEBOOK_REGION_COMBO,pArgs->pPBArgs->szRegionName);
            pArgs->cPB.LoadNumbers(hwndDlg,
                                   IDC_PHONEBOOK_PHONE_LIST,
                                   IDC_PHONEBOOKEX_PHONE_LIST,
                                   IDC_PHONEBOOK_MORE_BUTTON,
                                   pArgs->pPBArgs->szCanonical,
                                   pArgs->pPBArgs->szPhoneBookFile);

            if ((SendDlgItemMessageU(hwndDlg,IDC_PHONEBOOK_PHONE_LIST,LB_GETCURSEL,0,0) == LB_ERR) &&
                (!GetDlgItem(hwndDlg,IDC_PHONEBOOKEX_PHONE_LIST) ||
                 (SendDlgItemMessageU(hwndDlg,IDC_PHONEBOOKEX_PHONE_LIST,LB_GETCURSEL,0,0) == LB_ERR))) 
            {
                EnableWindow(GetDlgItem(hwndDlg,IDOK),FALSE);
            }
            
            SendDlgItemMessageU(hwndDlg,IDC_PHONEBOOK_BITMAP,STM_SETIMAGE,IMAGE_BITMAP,(LPARAM) &pArgs->BmpData);

            if (IsLogonAsSystem())
            {
                EnableWindow(GetDlgItem(hwndDlg, IDC_PHONEBOOK_HELP_BUTTON), FALSE);
            }

            return (FALSE);

        case WM_COMMAND:
            switch (LOWORD(wParam)) 
            {
                case IDOK:
                    if (PBDlgFillData(hwndDlg, pArgs->pPBArgs, &pArgs->cPB, TRUE))
                    {
                        EndDialog(hwndDlg,1);
                    }
                    return (TRUE);

                case IDC_PHONEBOOK_HELP_BUTTON:
                    CmWinHelp(hwndDlg, hwndDlg, pArgs->pPBArgs->pszHelpFile,HELP_FORCEFILE,ICM_TRB);
                    return (TRUE);

                case IDCANCEL:
                    EndDialog(hwndDlg,0);
                    return (TRUE);

                case IDC_PHONEBOOK_MORE_BUTTON:
                    MYDBGASSERT(FALSE); // Now obsolete
                    PBDlgFillData(hwndDlg, pArgs->pPBArgs, &pArgs->cPB, FALSE);
                    EndDialog(hwndDlg,2);
                    return (TRUE);

                default:
                    if ((HIWORD(wParam) == CBN_SELCHANGE) || (HIWORD(wParam) == LBN_SELCHANGE)) 
                    {
                        switch (LOWORD(wParam)) 
                        {                              
                            case IDC_PHONEBOOK_SERVICETYPE_COMBO:

                                PBDlgFillData(hwndDlg, pArgs->pPBArgs, &pArgs->cPB, FALSE);
                                pArgs->cPB.LoadCountries(hwndDlg,IDC_PHONEBOOK_COUNTRY_COMBO,pArgs->pPBArgs->dwCountryId);

                                // fall through
                            case IDC_PHONEBOOK_COUNTRY_COMBO:

                                pArgs->cPB.LoadRegions(hwndDlg,IDC_PHONEBOOK_REGION_COMBO,pArgs->pPBArgs->szRegionName);
                                // fall through
                            case IDC_PHONEBOOK_REGION_COMBO:

                                pArgs->cPB.LoadNumbers(hwndDlg,
                                                       IDC_PHONEBOOK_PHONE_LIST,
                                                       IDC_PHONEBOOKEX_PHONE_LIST,
                                                       IDC_PHONEBOOK_MORE_BUTTON,
                                                       pArgs->pPBArgs->szCanonical,
                                                       pArgs->pPBArgs->szPhoneBookFile);

                                if ((SendDlgItemMessageU(hwndDlg,IDC_PHONEBOOK_PHONE_LIST,LB_GETCURSEL,0,0) == LB_ERR) &&
                                    (!GetDlgItem(hwndDlg,IDC_PHONEBOOKEX_PHONE_LIST) ||
                                     (SendDlgItemMessageU(hwndDlg,IDC_PHONEBOOKEX_PHONE_LIST,LB_GETCURSEL,0,0) == LB_ERR))) 
                                {
                                    EnableWindow(GetDlgItem(hwndDlg,IDOK),FALSE);
                                } 
                                else 
                                {
                                    EnableWindow(GetDlgItem(hwndDlg,IDOK),TRUE);
                                }

                                return (TRUE);

                            case IDC_PHONEBOOK_PHONE_LIST:
                                if (SendDlgItemMessageU(hwndDlg,IDC_PHONEBOOK_PHONE_LIST,LB_GETCURSEL,0,0) != LB_ERR) 
                                {
                                    EnableWindow(GetDlgItem(hwndDlg,IDOK),TRUE);
                                    SendDlgItemMessageU(hwndDlg,IDC_PHONEBOOKEX_PHONE_LIST,LB_SETCURSEL,(WPARAM) -1,0);
                                }
                                return (TRUE);

                            case IDC_PHONEBOOKEX_PHONE_LIST:
                                if (SendDlgItemMessageU(hwndDlg,IDC_PHONEBOOKEX_PHONE_LIST,LB_GETCURSEL,0,0) != LB_ERR) 
                                {
                                    EnableWindow(GetDlgItem(hwndDlg,IDOK),TRUE);
                                    SendDlgItemMessageU(hwndDlg,IDC_PHONEBOOK_PHONE_LIST,LB_SETCURSEL,(WPARAM) -1,0);
                                }
                                return (TRUE);

                            default:
                                break;
                        }
                    }
                    if (HIWORD(wParam) == LBN_DBLCLK) 
                    {
                        switch (LOWORD(wParam)) 
                        {
                            case IDC_PHONEBOOK_PHONE_LIST:
                            case IDC_PHONEBOOKEX_PHONE_LIST:
                                if (SendDlgItemMessageU(hwndDlg,LOWORD(wParam),LB_GETCURSEL,0,0) != LB_ERR) 
                                {
                                    SendMessageU(hwndDlg, WM_COMMAND, IDOK, 0);
                                }
                                break;

                            default:
                                break;
                        }
                    }
                    break;
            }
            break;

        case WM_HELP:
        {
            LPHELPINFO lpHelpInfo = (LPHELPINFO) lParam;

            CmWinHelp((HWND) (lpHelpInfo->hItemHandle), 
                    (HWND) (lpHelpInfo->hItemHandle),
                    pArgs->pPBArgs->pszHelpFile,
                    HELP_WM_HELP, 
                    (ULONG_PTR) ((LPTSTR) adwHelp));

            return (TRUE);
        }

        case WM_CONTEXTMENU:
            {

                POINT   pt = {LOWORD(lParam), HIWORD(lParam)};
                HWND    hWndItem;
                
                ScreenToClient(hwndDlg, &pt);
                hWndItem = ChildWindowFromPoint(hwndDlg, pt);
                if (hWndItem != NULL && 
                    HaveContextHelp(hwndDlg, hWndItem))
                {
                    CmWinHelp((HWND) wParam, hWndItem,pArgs->pPBArgs->pszHelpFile,HELP_CONTEXTMENU,(ULONG_PTR) (LPSTR) adwHelp);
                    return (TRUE);
                }
                //
                // 170599: Assertion when right click phone book dialog title bar
                // Return FALSE, DefaultWindowProc will handle this message then.
                //
                return (FALSE);
            }

        case WM_PALETTEISCHANGING:
            CMTRACE2(TEXT("PBDlgProc() got WM_PALETTEISCHANGING message, wParam=0x%x, hwndDlg=0x%x."), wParam, hwndDlg);
            break;

        case WM_PALETTECHANGED: 
        {                       
            if ((wParam != (WPARAM) hwndDlg) && pArgs->BmpData.hDIBitmap) 
            {
                PaletteChanged(&pArgs->BmpData, hwndDlg, IDC_PHONEBOOK_BITMAP);
            }
            else
            {
                CMTRACE2(TEXT("PBDlgProc().WM_PALETTECHANGED not changing palette, wParam=0x%x, hwndDlg=0x%x."), 
                    wParam, hwndDlg);
            }
            break;
        }

        case WM_QUERYNEWPALETTE:

            QueryNewPalette(&pArgs->BmpData, hwndDlg, IDC_PHONEBOOK_BITMAP);        
            break;

        default:
            break;
    }
    return (FALSE);
}


BOOL DisplayPhoneBook(HWND hwndDlg, PBArgs *pPBArgs, BOOL fHasValidTopLevelPBK, BOOL fHasValidReferencedPBKs) 
{
    PBDlgArgs sDlgArgs;
    BOOL bRes = FALSE;
    HWND hwndParent = NULL;
    CNamedMutex PbMutex;

    memset(&sDlgArgs,0,sizeof(sDlgArgs));
    sDlgArgs.pPBArgs = pPBArgs;

    //
    // Show wait cursor and attempt to grab PB access mutex
    //

    HCURSOR hPrev = SetCursor(LoadCursorU(NULL,IDC_WAIT));
    
    if (PbMutex.Lock(c_pszCMPhoneBookMutex, TRUE, MAX_PB_WAIT))
    {       
        sDlgArgs.cPB.Load(pPBArgs->pszCMSFile, fHasValidTopLevelPBK, fHasValidReferencedPBKs);
        PbMutex.Unlock();
    }
    else
    {
        SetCursor(hPrev);
        CMTRACE(TEXT("DisplayPhoneBook() - Unable to grab PB access mutex."));
        return bRes;   
    }

    //
    //  We have a phonebook to display, setup graphics
    //
    
    if (pPBArgs->pszBitmap && *pPBArgs->pszBitmap) 
    {
        sDlgArgs.BmpData.hDIBitmap = CmLoadBitmap(g_hInst, pPBArgs->pszBitmap);
    }
    
    if (!sDlgArgs.BmpData.hDIBitmap) 
    {
        sDlgArgs.BmpData.hDIBitmap = CmLoadBitmap(g_hInst, MAKEINTRESOURCE(IDB_PB));
    }
    
    if (sDlgArgs.BmpData.hDIBitmap) 
    {
        //
        // Create a new Device Dependent bitmap 
        //
       
        sDlgArgs.BmpData.phMasterPalette = pPBArgs->phMasterPalette;
        sDlgArgs.BmpData.bForceBackground = TRUE; // paint as a background app

        CreateBitmapData(sDlgArgs.BmpData.hDIBitmap, &sDlgArgs.BmpData, hwndDlg, TRUE);
    }

    //
    // Determine the template to be used, if the aggregate PB contains any 
    // surcharge numbers then use the EX template for displaying more numbers.
    //

    LPCTSTR pszDlgBox = NULL;
    
    if (sDlgArgs.cPB.HasMoreNumbers())
    {
        pszDlgBox = MAKEINTRESOURCE(IDD_PHONEBOOKEX);
    }
    else
    {
        pszDlgBox = MAKEINTRESOURCE(IDD_PHONEBOOK); 
    }

    MYDBGASSERT(pszDlgBox);

    //
    // Restore cursor and display the PB dialog
    //

    SetCursor(hPrev);

    hwndParent = hwndDlg;

#if 0
/*
    //
    // Previously, the user drove the template decision by electing to see 
    // More numbers via the More button. The return code from the proc would
    // dictate if we should simply call it a again with a different template.
    // Hence this loop and switch.
    //
      
        
    while (1) 
    {
        switch (DialogBoxParam(g_hInst, pszDlgBox, hwndParent, PBDlgProc,  (LPARAM) &sDlgArgs)) 
        {
            case 1:
                bRes = TRUE;
                break;

            case 2:
                pszDlgBox = MAKEINTRESOURCE(IDD_PHONEBOOKEX);
                continue;

            case 0:
            default:
                break;
        }
        //
        // Release bitmap resources for dlg
        //

        ReleaseBitmapData(&sDlgArgs.BmpData);
            
        return (bRes);
    }
*/
#else
        bRes = (BOOL) DialogBoxParamU(g_hInst, pszDlgBox, hwndParent, PBDlgProc,  (LPARAM) &sDlgArgs);

        ReleaseBitmapData(&sDlgArgs.BmpData);
            
        return (bRes);
#endif
}