windows-server-2003/net/config/shell/netsetup/wfinish.cpp

#include "pch.h"
#pragma hdrstop
#include <shlobj.h>
#include "ncatlui.h"
#include "ncnetcon.h"
#include "ncreg.h"
#include "ncui.h"
#include "resource.h"
#include "shortcut.h"
#include "wizard.h"
#include "ncstl.h"
#include "foldinc.h"

static const WCHAR c_szNetConUserPath[] = NETCON_HKEYCURRENTUSERPATH;
static const WCHAR c_szFinishShortCut[] = NETCON_DESKTOPSHORTCUT;
static const WCHAR c_szNewRasConn[]     = L"NewRasCon";
static const WCHAR c_szAdvancedPath[]   = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced";
static const WCHAR c_szCascadeNetworkConnections[] = L"CascadeNetworkConnections";
static const WCHAR c_szYES[]            = L"YES";
static const WCHAR c_szShellMenu[]      = L"ShellMenu";

struct HFONTS
{
    HFONT hFontBold;
    HFONT hFontBoldLarge;
    HFONT hMarlettFont;
};

//
// Function:    HrFinishPageSaveConnection
//
// Purpose:     Take the name from the dialog and call the provider to
//              create the new connection
//
// Parameters:  hwndDlg [IN] - Handle to the Finish dialog
//              pWizard [IN] - Ptr to a wizard instance
//              ppConn [OUT] - Ptr to the newly created connection
//
// Returns:     HRESULT
//
HRESULT HrFinishPageSaveConnection(HWND hwndDlg, CWizard * pWizard,
                                   INetConnection ** ppConn,
                                   BOOL * pfRetry)
{
    TraceFileFunc(ttidGuiModeSetup);
    
    HRESULT          hr;
    HWND             hwndEdit = GetDlgItem(hwndDlg, EDT_FINISH_NAME);
    INetConnection * pConn    = NULL;

    Assert(pfRetry);
    *pfRetry = TRUE;

    CWizProvider * pWizProvider = pWizard->GetCurrentProvider();
    Assert(NULL != pWizProvider);
    Assert(NULL != pWizProvider->PWizardUi());

    if (IsPostInstall(pWizard))
    {
        // Set the connections name from the edit control data
        //
        Assert(0 < GetWindowTextLength(hwndEdit));
        Assert(NETCON_MAX_NAME_LEN >= GetWindowTextLength(hwndEdit));
        WCHAR szName[NETCON_MAX_NAME_LEN + 10];

        *ppConn = NULL;

        GetWindowText(hwndEdit, szName, NETCON_MAX_NAME_LEN);
        szName[NETCON_MAX_NAME_LEN] = 0;

        hr = (pWizProvider->PWizardUi())->SetConnectionName(szName);
    }
    else
    {
        hr = S_OK;
    }

    BOOL fFirewallErrorDlg = FALSE;

    if (SUCCEEDED(hr))
    {
        // Create the connection if it's not already set
        //
        hr = (pWizProvider->PWizardUi())->GetNewConnection(&pConn);
        TraceHr(ttidWizard, FAL, hr, FALSE, "FinishPageSaveConnection - Failed to GetNewConnection");
        if (SUCCEEDED(hr))
        {
            // Stash the new connection away
            //
            *ppConn = pConn;
        }
        else
        {
            // Don't let user retry as RAS will AV (#333893)
            *pfRetry = FALSE;
        }

        DWORD dwWizFlags;
        NETCON_MEDIATYPE MediaType;
        hr = (pWizProvider->PWizardUi())->GetNewConnectionInfo(&dwWizFlags, &MediaType);
        if (SUCCEEDED(hr))
        {
            if (dwWizFlags & NCWF_FIREWALLED)
            {
                CComPtr<IHNetCfgMgr> pHNetCfgMgr;
                CComPtr<IHNetConnection> pHNConn;
                CComPtr<IHNetFirewalledConnection> pFWConn;
                hr = CoCreateInstance(
                        CLSID_HNetCfgMgr,
                        NULL,
                        CLSCTX_ALL,
                        IID_IHNetCfgMgr,
                        reinterpret_cast<void**>(&pHNetCfgMgr)
                        );

                if (SUCCEEDED(hr))
                {
                    hr = pHNetCfgMgr->GetIHNetConnectionForINetConnection(pConn, &pHNConn);
                    if (SUCCEEDED(hr))
                    {
                        hr = pHNConn->Firewall(&pFWConn);
                    }
                }

                fFirewallErrorDlg = TRUE;
            }
        }
    }

    if (FAILED(hr) && IsPostInstall(pWizard))
    {
        if (fFirewallErrorDlg)
        {
            LPWSTR szFirewallError;
            LPWSTR pszError;
            if (FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                           NULL, hr, MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
                           (PWSTR)&pszError, 0, NULL))
            {
                if (DwFormatStringWithLocalAlloc(SzLoadIds(IDS_E_FIREWALL_FAILED), &szFirewallError, pszError))
                {
                    if (MessageBox(GetParent(hwndDlg), szFirewallError, SzLoadIds(IDS_SETUP_CAPTION), MB_OK | MB_ICONEXCLAMATION))
                    {
                        hr = S_OK;
                    }
                    LocalFree(szFirewallError);
                }
                LocalFree(pszError);
            }
        }

        if (FAILED(hr))
        {
            INT idsErr = IDS_E_CREATECONNECTION;

            if (HRESULT_FROM_WIN32(ERROR_DUP_NAME) == hr)
                idsErr = IDS_E_DUP_NAME;
            else
                if (HRESULT_FROM_WIN32(ERROR_INVALID_NAME) == hr)
                    idsErr = IDS_E_INVALID_NAME;

            // Tell the user what went wrong
            //
            NcMsgBox(GetParent(hwndDlg), IDS_SETUP_CAPTION, idsErr, MB_OK);
        }

        return hr;
    }

    return hr;
}

BOOL ConnListDuplicateNameCheck(IN const CIntelliName *pIntelliName, IN LPCTSTR szName, NETCON_MEDIATYPE *pncm, NETCON_SUBMEDIATYPE *pncms)
{
    HRESULT hr = S_OK;
    BOOL fDupFound = FALSE;

    Assert(pncm);
    Assert(pncms);

    ConnListEntry cleDup;
    hr = g_ccl.HrFindConnectionByName(szName, cleDup);
    if (S_OK == hr)
    {
        fDupFound = TRUE;
        *pncm = cleDup.ccfe.GetNetConMediaType();

        NETCON_MEDIATYPE ncmPseudo;
        hr = pIntelliName->HrGetPseudoMediaTypes(cleDup.ccfe.GetGuidID(), &ncmPseudo, pncms);
        if (FAILED(hr))
        {
            AssertSz(FALSE, "Could not obtain Pseudo Media type");
            fDupFound = FALSE;

            if (*pncm == NCM_LAN)
            {
                Assert(ncmPseudo == NCM_LAN);
            }
        }
    }
    else
    {
        fDupFound = FALSE;
    }
    return fDupFound;
}

// ISSUE: guidAdapter can be GUID_NULL
VOID GenerateUniqueConnectionName(REFGUID guidAdapter, tstring * pstr, CWizProvider * pWizProvider)
{
    TraceFileFunc(ttidGuiModeSetup);
    HRESULT hr = S_OK;

    Assert(pstr);
    Assert(pWizProvider);

    CIntelliName IntelliName(_Module.GetResourceInstance(), ConnListDuplicateNameCheck);

    NETCON_MEDIATYPE ncm;
    DWORD dwFlags;
    hr = (pWizProvider->PWizardUi())->GetNewConnectionInfo(&dwFlags, &ncm);

    Assert(SUCCEEDED(hr));
    if (FAILED(hr))
    {
        return;
    }

    tstring szConnNameHint;

    PWSTR pszSuggested;
    hr = (pWizProvider->PWizardUi())->GetSuggestedConnectionName(&pszSuggested);
    if (SUCCEEDED(hr))
    {
        szConnNameHint = pszSuggested;
        CoTaskMemFree(pszSuggested);
    }

    DWORD dwNCCF = 0;
    if (dwFlags & NCWF_INCOMINGCONNECTION)
    {
        dwNCCF |= NCCF_INCOMING_ONLY;
    }

    DWORD dwTries = 0;
    do
    {
        LPWSTR szName;
        if (szConnNameHint.empty())
        {
            hr = IntelliName.GenerateName(guidAdapter, ncm, dwNCCF, NULL, &szName);
        }
        else
        {
            hr = IntelliName.GenerateName(guidAdapter, ncm, dwNCCF, szConnNameHint.c_str(), &szName);
        }

        if (SUCCEEDED(hr))
        {
            hr = (pWizProvider->PWizardUi())->SetConnectionName(szName);
            *pstr = szName;
            CoTaskMemFree(szName);
        }

        AssertSz(dwTries < 64, "Something is wrong. GenerateName should have by now generated a unique name!");
        dwTries++;
    }
    while ( (dwTries < 64) && (HRESULT_FROM_WIN32(ERROR_DUP_NAME) == hr) );
    // This can only happens if somebody else created a duplicated name at this EXACT instance. So try again a few times.
   
}

VOID FinishGenerateUniqueNameInUI(HWND hwndDlg, CWizard * pWizard)
{
    TraceFileFunc(ttidGuiModeSetup);
    
    tstring str;
    HWND    hwndEdit     = GetDlgItem(hwndDlg, EDT_FINISH_NAME);
    WCHAR   szName[NETCON_MAX_NAME_LEN + 10] = {0};
    CWizProvider * pWizProvider = pWizard->GetCurrentProvider();
    Assert(NULL != pWizProvider);
    Assert(NULL != pWizProvider->PWizardUi());

    // Populate the Edit control if it's empty
    DWORD Flags = 0;
    NETCON_MEDIATYPE   MediaType;

    HRESULT hr = (pWizProvider->PWizardUi())->GetNewConnectionInfo(&Flags, &MediaType);
    if (SUCCEEDED(hr) & (Flags & NCWF_RENAME_DISABLE))
    {
        LPWSTR szSuggestedName;
        hr = (pWizProvider->PWizardUi())->GetSuggestedConnectionName(&szSuggestedName);
        if (SUCCEEDED(hr))
        {
            str = szSuggestedName;
            CoTaskMemFree(szSuggestedName);
        }
        else
        {
            GenerateUniqueConnectionName(GUID_NULL, &str, pWizProvider);
        }
    }
    else
    {
        GenerateUniqueConnectionName(GUID_NULL, &str, pWizProvider);
    }

    // reset provider changed flag
    pWizard->ClearProviderChanged();

    SetWindowText(hwndEdit, str.c_str());
}

BOOL FCheckAllUsers(NETCON_PROPERTIES* pConnProps)
{
    TraceFileFunc(ttidGuiModeSetup);
    
    Assert(NULL != pConnProps);

    if ((NCM_LAN != pConnProps->MediaType) &&
        (NCCF_ALL_USERS & pConnProps->dwCharacter))
    {
        return TRUE;
    }

    return FALSE;
}

//
// Function:    OnFinishPageNext
//
// Purpose:     Handle the pressing of the Next button
//
// Parameters:  hwndDlg [IN] - Handle to the finish dialog
//
// Returns:     BOOL, TRUE
//
BOOL OnFinishPageNext(HWND hwndDlg)
{
    TraceFileFunc(ttidGuiModeSetup);
    
    HCURSOR          hOldCursor = NULL;
    INetConnection * pConn = NULL;

    // Retrieve the CWizard instance from the dialog
    CWizard * pWizard =
        reinterpret_cast<CWizard *>(::GetWindowLongPtr(hwndDlg, DWLP_USER));
    Assert(NULL != pWizard);
    HWND        hwndEdit = GetDlgItem(hwndDlg, EDT_FINISH_NAME);
    HRESULT     hr;
    WCHAR       szConnName[NETCON_MAX_NAME_LEN + 1];

    int cchText = GetWindowText(hwndEdit, reinterpret_cast<PWSTR>(&szConnName),
                                NETCON_MAX_NAME_LEN);

    if (IsPostInstall(pWizard))
    {
        if (!FIsValidConnectionName(szConnName))
        {
            SendMessage(hwndEdit, EM_SETSEL, 0, -1);
            SetFocus(hwndEdit);
            MessageBox(GetParent(hwndDlg), SzLoadIds(IDS_E_INVALID_NAME),
                       SzLoadIds(IDS_SETUP_CAPTION), MB_OK | MB_ICONSTOP);
            ::SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, -1);
            return TRUE;
        }
    }

    hOldCursor = BeginWaitCursor();

    BOOL fRetry;
    hr = HrFinishPageSaveConnection(hwndDlg, pWizard, &pConn, &fRetry);
    if (IsPostInstall(pWizard) && FAILED(hr))
    {
        EndWaitCursor(hOldCursor);

        if (fRetry)
        {
            // Don't leave the page
            ::SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, -1);
        }
        else
        {
            // Jump to the Exit page
            PostMessage(GetParent(hwndDlg), PSM_SETCURSEL, 0,
                        (LPARAM)pWizard->GetPageHandle(IDD_Exit));
    
        }   

        EndWaitCursor(hOldCursor);
        return TRUE;
    }

    // If it's post install cache the connection
    if (IsPostInstall(pWizard))
    {
        DWORD   dwDisposition;
        HKEY    hkey = NULL;

        hr = HrRegCreateKeyEx(HKEY_CURRENT_USER, c_szNetConUserPath,
                              REG_OPTION_NON_VOLATILE, KEY_READ_WRITE, NULL,
                              &hkey, &dwDisposition);
        if (SUCCEEDED(hr))
        {
            DWORD dw;

            // Have we ever created a connection with this wizard before
            //
            hr = HrRegQueryDword (hkey, c_szNewRasConn, &dw);
            if (FAILED(hr))
            {
                HKEY hkeyAdvanced = NULL;

                // First time, retain the fact we created a RAS connection
                //
                (VOID)HrRegSetDword (hkey, c_szNewRasConn, 1);

                // Update the Start Menu to cascade the folder auto-magically
                //
                hr = HrRegOpenKeyEx(HKEY_CURRENT_USER, c_szAdvancedPath,
                                    KEY_WRITE, &hkeyAdvanced);
                if (SUCCEEDED(hr))
                {
                    (VOID)HrRegSetSz(hkeyAdvanced,
                                     c_szCascadeNetworkConnections,
                                     c_szYES);
                    RegCloseKey(hkeyAdvanced);

                    ULONG_PTR lres = 0;
                    LRESULT lr = SendMessageTimeout(HWND_BROADCAST, WM_SETTINGCHANGE, NULL,
                                reinterpret_cast<LPARAM>(c_szShellMenu), SMTO_ABORTIFHUNG | SMTO_NOTIMEOUTIFNOTHUNG,
                                30 * 1000, &lres);

                    if (lr == 0)
                    {
                        if (GetLastError() == 0)
                        {
                            TraceError("SendMessageTimeout timed out sending WM_SETTINGCHANGE broadcast message", E_FAIL);
                        }
                        else
                        {
                            TraceError("SendMessageTimeout failed", HRESULT_FROM_WIN32(GetLastError()));
                        }
                    }
                }
                hr = S_OK;
            }
        }

        // If the Shortcut check box is visible we might need to create a shortcut
        //
        if (IsWindowVisible(GetDlgItem(hwndDlg, CHK_CREATE_SHORTCUT)))
        {
            // Retain the shortcut "check" state for future invocations
            //
            BOOL fCreateShortcut = (BST_CHECKED ==
                        IsDlgButtonChecked(hwndDlg, CHK_CREATE_SHORTCUT));

            if (hkey)
            {
                (VOID)HrRegSetDword (hkey, c_szFinishShortCut,
                        (fCreateShortcut) ? 1 : 0);
            }

            // If the shortcut box is checked, try to create a shortcut
            //
            if (fCreateShortcut && (NULL != pConn))
            {
                NETCON_PROPERTIES* pConnProps = NULL;

                hr = pConn->GetProperties(&pConnProps);
                if (SUCCEEDED(hr))
                {
                    BOOL fAllUsers = FCheckAllUsers(pConnProps);

                    (VOID)HrCreateStartMenuShortCut(GetParent(hwndDlg),
                                                    fAllUsers,
                                                    pConnProps->pszwName,
                                                    pConn);
                    FreeNetconProperties(pConnProps);
                }
            }
        }

        RegCloseKey(hkey);

        // Save the Connection so we can hand it back to the connections folder
        pWizard->CacheConnection(pConn);
        pConn = NULL;
    }

    // Release the object since we don't need it any more
    ReleaseObj(pConn);

    // Whack the text so we requery it the next time around
    SetWindowText(hwndEdit, c_szEmpty);

    // On PostInstall there is no need to request the "Next" adapter as
    // the wizard is a one time through entity
    if (IsPostInstall(pWizard))
    {
        if (pWizard->FProcessLanPages())
        {
            (VOID)HrCommitINetCfgChanges(GetParent(hwndDlg), pWizard);
        }

        // Jump to the Exit page
        PostMessage(GetParent(hwndDlg), PSM_SETCURSEL, 0,
                    (LPARAM)pWizard->GetPageHandle(IDD_Exit));

        EndWaitCursor(hOldCursor);
        return TRUE;
    }
    else
    {
        // Do one of the following (as appropriate):
        //      Process the next adapter if it exists
        //      Jump to the join page (!IsPostInstall)
        //      Jump to the exit page
        //
        EndWaitCursor(hOldCursor);
        return OnProcessNextAdapterPageNext(hwndDlg, FALSE);
    }
}

//
// Function:    OnFinishPageBack
//
// Purpose:     Handle the BACK notification on the finish page
//
// Parameters:  hwndDlg [IN] - Handle to the finish dialog
//
// Returns:     BOOL, TRUE
//
BOOL OnFinishPageBack(HWND hwndDlg)
{
    TraceFileFunc(ttidGuiModeSetup);
    
    UINT           nCnt = 0;
    HPROPSHEETPAGE hPage = NULL;

    // Retrieve the CWizard instance from the dialog
    CWizard * pWizard =
        reinterpret_cast<CWizard *>(::GetWindowLongPtr(hwndDlg, DWLP_USER));
    Assert(NULL != pWizard);

    if (IsWindowVisible(GetDlgItem(hwndDlg, CHK_CREATE_SHORTCUT)))
    {
        // Retain the shortcut "check" state

        DWORD dw;
        HKEY  hKey = NULL;
        BOOL fCreateShortcut = IsDlgButtonChecked(hwndDlg, CHK_CREATE_SHORTCUT);

        if (fCreateShortcut == BST_CHECKED)
        {
            dw = 1;
        }
        else
        {
            dw = 0;
        }

        HRESULT hr = HrRegOpenKeyEx(HKEY_CURRENT_USER, c_szNetConUserPath,
                                    KEY_WRITE, &hKey);

        if (SUCCEEDED(hr))
        {
            HrRegSetValueEx(hKey, c_szFinishShortCut, REG_DWORD, (BYTE *)&dw, sizeof(DWORD));
            RegCloseKey(hKey);
        }
    }

    HWND     hwndEdit        = GetDlgItem(hwndDlg, EDT_FINISH_NAME);
    SetWindowText(hwndEdit, _T(""));
    
    // Goto the guard page of the current provider

    AppendGuardPage(pWizard, pWizard->GetCurrentProvider(),
                    &hPage, &nCnt);
    Assert(nCnt);

    PropSheet_SetWizButtons(GetParent(hwndDlg), PSWIZB_NEXT | PSWIZB_BACK);

    // Goto to the guard page of the current provider
    PostMessage(GetParent(hwndDlg), PSM_SETCURSEL, 0,
                (LPARAM)(HPROPSHEETPAGE)hPage);

    ::SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, -1);
    return TRUE;
}


VOID FinishUpdateButtons(HWND hwndDlg)
{
    TraceFileFunc(ttidGuiModeSetup);
    
    // Retrieve the CWizard instance from the dialog
    CWizard * pWizard =
        reinterpret_cast<CWizard *>(::GetWindowLongPtr(hwndDlg, DWLP_USER));
    Assert(NULL != pWizard);

    // Only play with the UI when the page is shown postinstall
    if (IsPostInstall(pWizard))
    {
        LPARAM lFlags = PSWIZB_BACK | PSWIZB_FINISH;
        PropSheet_SetWizButtons(GetParent(hwndDlg), lFlags);
    }
}

//
// Function:    OnFinishPageActivate
//
// Purpose:     Handle the page activation
//
// Parameters:  hwndDlg [IN] - Handle to the finish dialog
//
// Returns:     BOOL, TRUE
//
BOOL OnFinishPageActivate(HWND hwndDlg)
{
    TraceFileFunc(ttidGuiModeSetup);
    
    HRESULT  hr;
    HWND     hwndEdit        = GetDlgItem(hwndDlg, EDT_FINISH_NAME);
    HWND     hwndChkShortCut = GetDlgItem(hwndDlg, CHK_CREATE_SHORTCUT);

    CWizard* pWizard =
        reinterpret_cast<CWizard *>(::GetWindowLongPtr(hwndDlg, DWLP_USER));
    Assert(NULL != pWizard);

    TraceTag(ttidWizard, "Entering finish page...");
    ::SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, 0);

    if (IsPostInstall(pWizard))
    {
        FinishGenerateUniqueNameInUI(hwndDlg, pWizard);
        FinishUpdateButtons(hwndDlg);


        const DWORD MAXDLG_FINISH_CONTROLS = 4;
        UINT uiCtls[MAXDLG_FINISH_CONTROLS];
        uiCtls[0] = EDT_FINISH_TYPE1;
        uiCtls[1] = EDT_FINISH_TYPE2;
        uiCtls[2] = EDT_FINISH_TYPE3;
        uiCtls[3] = EDT_FINISH_TYPE4;

        UINT uiLbls[MAXDLG_FINISH_CONTROLS];
        uiLbls[0] = IDC_FINISH_CHK1;
        uiLbls[1] = IDC_FINISH_CHK2;
        uiLbls[2] = IDC_FINISH_CHK3;
        uiLbls[3] = IDC_FINISH_CHK4;

        DWORD dwCurrentControl = 0;

        CWizProvider * pProv = pWizard->GetCurrentProvider();
        if (NULL != pProv)
        {
            DWORD dwWizFlags;
            BOOL  fAllowShortCut = FALSE;
            BOOL  fCheckShortCut = FALSE;
            NETCON_MEDIATYPE MediaType;

            Assert(NULL != pProv->PWizardUi());

            hr = (pProv->PWizardUi())->GetNewConnectionInfo(&dwWizFlags, &MediaType);
            if (SUCCEEDED(hr))
            {
                fAllowShortCut = !!(dwWizFlags & NCWF_SHORTCUT_ENABLE);

                if (dwWizFlags & NCWF_DEFAULT)
                {
                    SetDlgItemText(hwndDlg, uiCtls[dwCurrentControl++], SzLoadIds(IDS_NCWF_DEFAULT));
                }
                if (dwWizFlags & NCWF_FIREWALLED)
                {
                    SetDlgItemText(hwndDlg, uiCtls[dwCurrentControl++], SzLoadIds(IDS_NCWF_FIREWALLED));
                }
                if (dwWizFlags & NCWF_ALLUSER_CONNECTION)
                {
                    SetDlgItemText(hwndDlg, uiCtls[dwCurrentControl++], SzLoadIds(IDS_NCWF_ALLUSER_CONNECTION));
                }
                if (dwWizFlags & NCWF_GLOBAL_CREDENTIALS)
                {
                    SetDlgItemText(hwndDlg, uiCtls[dwCurrentControl++], SzLoadIds(IDS_NCWF_GLOBAL_CREDENTIALS));
                }
    //          if (dwWizFlags & NCWF_SHARED)
    //          {
    //              SetDlgItemText(hwndDlg, uiCtls[dwCurrentControl++], SzLoadIds(IDS_NCWF_SHARED));
    //          }
            }

            Assert(dwCurrentControl <= MAXDLG_FINISH_CONTROLS);

            for (DWORD x = 0; x < MAXDLG_FINISH_CONTROLS; x++)
            {
                HWND hwndCtrl = GetDlgItem(hwndDlg, uiCtls[x]);
                if (hwndCtrl)
                {
                    if (x < dwCurrentControl)
                    {
                        EnableWindow(hwndCtrl, TRUE);
                        ShowWindow(hwndCtrl, SW_SHOW);
                    }
                    else
                    {
                        EnableWindow(hwndCtrl, FALSE);
                        ShowWindow(hwndCtrl, SW_HIDE);
                    }
                }
                else
                {
                    AssertSz(FALSE, "Could not load type edit control");
                }

                hwndCtrl = GetDlgItem(hwndDlg, uiLbls[x]);
                if (hwndCtrl)
                {
                    if (x < dwCurrentControl)
                    {
                        EnableWindow(hwndCtrl, TRUE);
                        ShowWindow(hwndCtrl, SW_SHOW);
                    }
                    else
                    {
                        EnableWindow(hwndCtrl, FALSE);
                        ShowWindow(hwndCtrl, SW_HIDE);
                    }
                }
                else
                {
                    AssertSz(FALSE, "Could not load bullet control");
                }
            }

            // Disable the connection name edit control if the connection type
            // does not support renaming

            ShowWindow(hwndChkShortCut, fAllowShortCut ? SW_SHOW : SW_HIDE);
            EnableWindow(hwndChkShortCut, fAllowShortCut);

            // Check the registry for the last setting of the checkbox state
            // if shortcuts are allowed
            //
            if (fAllowShortCut)
            {
                // Default Shortcut state (if allowed) is on.
                //
                fCheckShortCut = FALSE;

                DWORD dw;
                HKEY  hkey = NULL;

                hr = HrRegOpenKeyEx(HKEY_CURRENT_USER, c_szNetConUserPath,
                                    KEY_READ, &hkey);
                if (SUCCEEDED(hr))
                {
                    hr = HrRegQueryDword (hkey, c_szFinishShortCut, &dw);
                    if (SUCCEEDED(hr))
                    {
                        fCheckShortCut = (1==dw);
                    }
                    RegCloseKey(hkey);
                }
            }

            CheckDlgButton(hwndDlg, CHK_CREATE_SHORTCUT, fCheckShortCut);
        }
    }
    else
    {
        Assert(pWizard->FProcessLanPages());
        OnFinishPageNext(hwndDlg);

        // Temporarily briefly accept focus
        ::SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, 0);
    }

    return TRUE;
}


// ***************************************************************************
//
// Function:    OnFinishInitDialog
//
// Purpose:     Handle WM_INITDIALOG message
//
// Parameters:  hwndDlg [IN] - Handle to the finish dialog
//              lParam  [IN] - LPARAM value from the WM_INITDIALOG message
//
// Returns:     FALSE - Accept default control activation
//
BOOL OnFinishInitDialog(HWND hwndDlg, LPARAM lParam)
{
    TraceFileFunc(ttidGuiModeSetup);
    
    // Initialize our pointers to property sheet info.
    PROPSHEETPAGE* psp = (PROPSHEETPAGE*)lParam;
    Assert(psp->lParam);
    ::SetWindowLongPtr(hwndDlg, DWLP_USER, psp->lParam);

    CWizard * pWizard = reinterpret_cast<CWizard *>(psp->lParam);
    Assert(NULL != pWizard);

    HFONTS *phFonts = NULL;
    if (IsPostInstall(pWizard))
    {
        pWizard->SetPageData(IDD_Finish, (LPARAM)NULL);

        // Set up the Welcome font
        HFONT hBoldFontLarge = NULL;
        SetupFonts(hwndDlg, &hBoldFontLarge, TRUE);
        if (NULL != hBoldFontLarge)
        {
            phFonts = new HFONTS;
            ZeroMemory(phFonts, sizeof(HFONTS));
            phFonts->hFontBoldLarge = hBoldFontLarge;

            pWizard->SetPageData(IDD_Finish, (LPARAM)phFonts);
            HWND hwndCtl = GetDlgItem(hwndDlg, IDC_WELCOME_CAPTION);
            if (hwndCtl)
            {
                if (pWizard->FProcessLanPages())
                    SetWindowText(hwndCtl, SzLoadIds(IDS_LAN_FINISH_CAPTION));

                SetWindowFont(hwndCtl, hBoldFontLarge, TRUE);
            }
        }

        // Get the bold font for the radio buttons
        HFONT hBoldFont = NULL;
        SetupFonts(hwndDlg, &hBoldFont, FALSE);

        if (NULL != hBoldFont)
        {
            if (!phFonts)
            {
                phFonts = new HFONTS;
                ZeroMemory(phFonts, sizeof(HFONTS));
                pWizard->SetPageData(IDD_Finish, (LPARAM)hBoldFont);
            }
            
            phFonts->hFontBold = hBoldFont;

            HWND hwndCtl = GetDlgItem(hwndDlg, EDT_FINISH_NAME);
            if (hwndCtl)
            {
                SetWindowFont(hwndCtl, hBoldFont, TRUE);
            }
        }
    
       // Create the Marlett font.  In the Marlett font the "i" is a bullet.
       // Code borrowed from Add Hardware Wizard. 
       HFONT hFontCurrent;
       HFONT hFontCreated;
       LOGFONT LogFont;

       hFontCurrent = (HFONT)SendMessage(GetDlgItem(hwndDlg, IDC_FINISH_CHK1), WM_GETFONT, 0, 0);
       GetObject(hFontCurrent, sizeof(LogFont), &LogFont);
       LogFont.lfCharSet = SYMBOL_CHARSET;
       LogFont.lfPitchAndFamily = FF_DECORATIVE | DEFAULT_PITCH;
       lstrcpy(LogFont.lfFaceName, L"Marlett");
       hFontCreated = CreateFontIndirect(&LogFont);

       if (hFontCreated)
       {
           if (phFonts)
           {
               phFonts->hMarlettFont = hFontCreated;
           }
           //
           // An "i" in the marlett font is a small bullet.
           //
           SetWindowText(GetDlgItem(hwndDlg, IDC_FINISH_CHK1), L"i");
           SetWindowFont(GetDlgItem(hwndDlg, IDC_FINISH_CHK1), hFontCreated, TRUE);
           SetWindowText(GetDlgItem(hwndDlg, IDC_FINISH_CHK2), L"i");
           SetWindowFont(GetDlgItem(hwndDlg, IDC_FINISH_CHK2), hFontCreated, TRUE);
           SetWindowText(GetDlgItem(hwndDlg, IDC_FINISH_CHK3), L"i");
           SetWindowFont(GetDlgItem(hwndDlg, IDC_FINISH_CHK3), hFontCreated, TRUE);
           SetWindowText(GetDlgItem(hwndDlg, IDC_FINISH_CHK4), L"i");
           SetWindowFont(GetDlgItem(hwndDlg, IDC_FINISH_CHK4), hFontCreated, TRUE);
       }

       HKEY hKey;
       HRESULT hrT = HrRegCreateKeyEx(HKEY_CURRENT_USER, c_szNetConUserPath,
                        REG_OPTION_NON_VOLATILE, KEY_READ_WRITE, NULL,
                        &hKey, NULL);

       if (SUCCEEDED(hrT))
       {
            RegCloseKey(hKey);
       }
    }

    // Clear the shortcut flag in the registry
    HKEY hKey;
    DWORD dw = 0;
    HRESULT hr = HrRegOpenKeyEx(HKEY_CURRENT_USER, c_szNetConUserPath,
                                KEY_WRITE, &hKey);

    if (SUCCEEDED(hr))
    {
        HrRegSetValueEx(hKey, c_szFinishShortCut, REG_DWORD, (BYTE *)&dw, sizeof(DWORD));
        RegCloseKey(hKey);
    }

    return FALSE;   // Accept default control focus
}

//
// Function:    dlgprocFinish
//
// Purpose:     Dialog Procedure for the Finish wizard page
//
// Parameters:  standard dlgproc parameters
//
// Returns:     INT_PTR
//
INT_PTR CALLBACK dlgprocFinish( HWND hwndDlg, UINT uMsg,
                             WPARAM wParam, LPARAM lParam )
{
    TraceFileFunc(ttidGuiModeSetup);
    
    BOOL frt = FALSE;

    switch (uMsg)
    {
    case WM_INITDIALOG:
        frt = OnFinishInitDialog(hwndDlg, lParam);
        break;

    case WM_COMMAND:
        if ((EN_CHANGE == HIWORD(wParam)) &&
            (GetDlgItem(hwndDlg, EDT_FINISH_NAME) == (HWND)lParam))
        {
            FinishUpdateButtons(hwndDlg);
        }
        break;

    case WM_NOTIFY:
        {
            LPNMHDR pnmh = (LPNMHDR)lParam;

            switch (pnmh->code)
            {
            // propsheet notification
            case PSN_HELP:
                break;

            case PSN_SETACTIVE:
                frt = OnFinishPageActivate(hwndDlg);
                break;

            case PSN_APPLY:
                break;

            case PSN_KILLACTIVE:
                break;

            case PSN_RESET:
                break;

            case PSN_WIZBACK:
                frt = OnFinishPageBack(hwndDlg);
                break;

            case PSN_WIZFINISH:
                {
                    // This page isn't displayed during setup.
                    // Finish Processing in setup is done in wupgrade.cpp
                    CWizard * pWizard =
                        reinterpret_cast<CWizard *>(::GetWindowLongPtr(hwndDlg,
                                                                       DWLP_USER));
                    Assert(NULL != pWizard);
                    if (IsPostInstall(pWizard))
                    {
                        frt = OnFinishPageNext(hwndDlg);
                    }
                }
                break;

            case PSN_WIZNEXT:
                frt = OnFinishPageNext(hwndDlg);
                break;

            default:
                break;
            }
        }
        break;

    default:
        break;
    }

    return( frt );
}
//
// Function:    FinishPageCleanup
//
// Purpose:     As a callback function to allow any page allocated memory
//              to be cleaned up, after the page will no longer be accessed.
//
// Parameters:  pWizard [IN] - The wizard against which the page called
//                             register page
//              lParam  [IN] - The lParam supplied in the RegisterPage call
//
// Returns:     nothing
//
VOID FinishPageCleanup(CWizard *pWizard, LPARAM lParam)
{
    TraceFileFunc(ttidGuiModeSetup);
    
    if (IsPostInstall(pWizard))
    {
        HFONTS *phFonts = (HFONTS *)pWizard->GetPageData(IDD_Finish);
        if (NULL != phFonts)
        {
            if (phFonts->hFontBold)
            {
                DeleteObject(phFonts->hFontBold);
            }
            if (phFonts->hFontBoldLarge)
            {
                DeleteObject(phFonts->hFontBoldLarge);
            }
            if (phFonts->hMarlettFont)
            {
                DeleteObject(phFonts->hMarlettFont);
            }
            delete phFonts;
        }
    }
}

//
// Function:    CreateFinishPage
//
// Purpose:     To determine if the Finish page needs to be shown, and to
//              to create the page if requested.  Note the Finish page is
//              responsible for initial installs also.
//
// Parameters:  pWizard     [IN] - Ptr to a Wizard instance
//              pData       [IN] - Context data to describe the world in
//                                 which the Wizard will be run
//              fCountOnly  [IN] - If True, only the maximum number of
//                                 pages this routine will create need
//                                 be determined.
//              pnPages     [IN] - Increment by the number of pages
//                                 to create/created
//
// Returns:     HRESULT, S_OK on success
//
HRESULT HrCreateFinishPage(CWizard *pWizard, PINTERNAL_SETUP_DATA pData,
                    BOOL fCountOnly, UINT *pnPages)
{
    TraceFileFunc(ttidGuiModeSetup);

    HRESULT hr = S_OK;
    UINT nId = 0;

    (*pnPages)++;

    // If not only counting, create and register the page
    if (!fCountOnly)
    {
        HPROPSHEETPAGE hpsp;
        PROPSHEETPAGE psp;

        TraceTag(ttidWizard, "Creating Finish Page");
        psp.dwSize = sizeof( PROPSHEETPAGE );
        if (!IsPostInstall(pWizard))
        {
            nId = IDD_FinishSetup;

            psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
            psp.pszHeaderTitle = SzLoadIds(IDS_T_Finish);
            psp.pszHeaderSubTitle = SzLoadIds(IDS_ST_Finish);
        }
        else
        {
            nId = IDD_Finish;

            psp.dwFlags = PSP_DEFAULT | PSP_HIDEHEADER;
        }
        Assert (nId);

        psp.pszTemplate = MAKEINTRESOURCE( nId );
        psp.hInstance = _Module.GetResourceInstance();
        psp.hIcon = NULL;
        psp.pfnDlgProc = dlgprocFinish;
        psp.lParam = reinterpret_cast<LPARAM>(pWizard);

        hpsp = CreatePropertySheetPage( &psp );
        if (hpsp)
        {
            pWizard->RegisterPage(nId, hpsp,
                                  FinishPageCleanup, NULL);
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }
    }

    TraceHr(ttidWizard, FAL, hr, FALSE, "HrCreateFinishPage");
    return hr;
}

//
// Function:    AppendFinishPage
//
// Purpose:     Add the Finish page, if it was created, to the set of pages
//              that will be displayed.
//
// Parameters:  pWizard     [IN] - Ptr to Wizard Instance
//              pahpsp  [IN,OUT] - Array of pages to add our page to
//              pcPages [IN,OUT] - Count of pages in pahpsp
//
// Returns:     Nothing
//
VOID AppendFinishPage(CWizard *pWizard, HPROPSHEETPAGE* pahpsp, UINT *pcPages)
{
    TraceFileFunc(ttidGuiModeSetup);

    UINT idd;

    if (!IsPostInstall(pWizard))
        idd = IDD_FinishSetup;
    else
        idd = IDD_Finish;

    HPROPSHEETPAGE hPage = pWizard->GetPageHandle(idd);
    Assert(hPage);
    pahpsp[*pcPages] = hPage;
    (*pcPages)++;
}