//*********************************************************************
//*                  Microsoft Windows                               **
//*            Copyright(c) Microsoft Corp., 1994                    **
//*********************************************************************

//
//  ISPPAGE.CPP - Functions for 
//

//  HISTORY:
//  
//  05/13/98  donaldm  Created.
//
//*********************************************************************

#include "pre.h"
#include "shlobj.h"
#include "webvwids.h"

TCHAR   szHTMLFile[MAX_PATH]; //Name of html file
BOOL    bOKToPersist = TRUE;
DWORD   g_dwPageType = 0;
BOOL    g_bWebGateCheck = TRUE;
BOOL    g_bConnectionErr = FALSE;

//PROTOTYPES
BOOL SaveISPFile( HWND hwndParent, TCHAR* szSrcFileName, DWORD dwFileType);

#if defined (DBG)
BOOL HtmlSaveAs( HWND hwndParent, TCHAR* szFileName, TCHAR* szTargetFileName);
void AskSaveISPHTML(HWND hWnd, LPTSTR lpszHTMLFile)
{
    HKEY hKey = NULL;
    DWORD dwTemp = 0;
    DWORD dwType = 0;
    DWORD dwSize = sizeof(dwTemp);

    RegOpenKey(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\ISignup\\Debug"), &hKey);
    if (hKey)
    {
        RegQueryValueEx(hKey,TEXT("SaveIspHtmLocally"),0,&dwType,(LPBYTE)&dwTemp, &dwSize);
    
        if (dwTemp)
        {        
            if (IDYES == MessageBox(hWnd, TEXT("Would you like to save this ISP HTML file?"), TEXT("ICW -- DEBUG"), MB_YESNO | MB_ICONQUESTION | MB_APPLMODAL))
                HtmlSaveAs(hWnd, lpszHTMLFile, NULL);
        }
    }
}
#endif      // dbg

void  InitPageControls
(
    HWND hDlg, 
    DWORD dwPageType,
    DWORD dwPageFlag
)
{
    TCHAR    szTemp[MAX_MESSAGE_LEN];
    switch (dwPageType)    
    {
        // TOS, has the Accept, Don't Accept UI
        case PAGETYPE_ISP_TOS:
        {    
            // Show the TOS controls
            ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSINSTRT),     SW_SHOW);
            ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSHTML),       SW_SHOW);
            ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSSAVE),       SW_SHOW);
            ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSACCEPT),     SW_SHOW);
            ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSDECLINE),    SW_SHOW);
            ShowWindow(GetDlgItem(hDlg, IDC_TOS_TOSSAVE),           SW_SHOW);
            //hide "normal weboc"
            ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_HTML),          SW_HIDE);
            //hide the save check box controls
            ShowWindow(GetDlgItem(hDlg, IDC_SAVE_DESKTOP_TEXT),     SW_HIDE);
            ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_CUSTHTML),      SW_HIDE);
            // Reset the TOS page
            Button_SetCheck(GetDlgItem(hDlg, IDC_ISPDATA_TOSACCEPT), BST_UNCHECKED);
            Button_SetCheck(GetDlgItem(hDlg, IDC_ISPDATA_TOSDECLINE),BST_UNCHECKED);

            // Set tab focus
            SetWindowLong(GetDlgItem(hDlg, IDC_ISPDATA_TOSACCEPT), GWL_STYLE, GetWindowLong(GetDlgItem(hDlg, IDC_ISPDATA_TOSACCEPT),GWL_STYLE)|WS_TABSTOP);            
            EnableWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSDECLINE),  TRUE);
            EnableWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSACCEPT),   TRUE);
            EnableWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSSAVE),     TRUE);
            PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK);
            break;
        }    
        
        // Finish, Custom Finish, and Normal are the same from a UI perspective (Also default)            
        case PAGETYPE_ISP_CUSTOMFINISH:
        case PAGETYPE_ISP_FINISH:
        case PAGETYPE_ISP_NORMAL:
        default:
        {
            BOOL bIsQuickFinish = FALSE;
            // Need to see if this is a Quick Finish page
            gpWizardState->pHTMLWalker->get_IsQuickFinish(&bIsQuickFinish);
        
            // Hide the TOS controls
            ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSINSTRT),     SW_HIDE);
            ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSHTML),       SW_HIDE);
            ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSACCEPT),     SW_HIDE);
            ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSDECLINE),    SW_HIDE);
            ShowWindow(GetDlgItem(hDlg, IDC_TOS_TOSSAVE),           SW_HIDE);
    
            if (dwPageFlag & PAGEFLAG_SAVE_CHKBOX)
            {
                // Show check box controls 
                ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_CUSTHTML),  SW_SHOW);
                ShowWindow(GetDlgItem(hDlg, IDC_SAVE_DESKTOP_TEXT), SW_SHOW);
                ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSSAVE),   SW_SHOW);
                // Hide the normal controls
                ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_HTML),      SW_HIDE);
                //Reenable the UI
                EnableWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSSAVE), TRUE);
            }
            else
            {
                //show "normal" web oc
                ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_HTML),      SW_SHOW);
                // Hide the Checkbox controls
                ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSSAVE),   SW_HIDE);
                ShowWindow(GetDlgItem(hDlg, IDC_SAVE_DESKTOP_TEXT), SW_HIDE);
                ShowWindow(GetDlgItem(hDlg, IDC_ISPDATA_CUSTHTML),  SW_HIDE);
            }
            
            //set the wizard buttons
            // If we are on a Custom Finish, or Quick finish page then
            // use Active the Finish button
            PropSheet_SetWizButtons(GetParent(hDlg), 
                                   ((bIsQuickFinish || (PAGETYPE_ISP_CUSTOMFINISH == dwPageType)) ? PSWIZB_FINISH : PSWIZB_NEXT) | PSWIZB_BACK);
            break;
        }
    }

    // Change the title for the finish page
    if (gpWizardState->cmnStateData.dwFlags & ICW_CFGFLAG_AUTOCONFIG)
    {
        LoadString(ghInstanceResDll, IDS_STEP3_TITLE, szTemp, MAX_MESSAGE_LEN);
    }
    else
    {
        if((PAGETYPE_ISP_CUSTOMFINISH == dwPageType ) || (PAGETYPE_ISP_FINISH == dwPageType))
            LoadString(ghInstanceResDll, IDS_STEP3_TITLE, szTemp, MAX_MESSAGE_LEN);
        else
            LoadString(ghInstanceResDll, IDS_STEP2_TITLE, szTemp, MAX_MESSAGE_LEN);
    }
    PropSheet_SetHeaderTitle(GetParent(hDlg), EXE_NUM_WIZARD_PAGES + ORD_PAGE_ISPDATA, szTemp);
}    


HRESULT InitForPageType
(
    HWND    hDlg
)
{
    DWORD   dwPageType = 0;
    DWORD   dwPageFlag = 0;
    BOOL    bRetVal    = FALSE;
    HRESULT hRes       = E_FAIL;
    BSTR    bstrPageID = NULL;
    BSTR    bstrHTMLFile = NULL;
    
    //make sure these are disabled here incase getpagetype fails
    EnableWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSDECLINE), FALSE);
    EnableWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSACCEPT),  FALSE);
    EnableWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSSAVE),    FALSE);

    // Get webgate to dump the HTML into a file            
    gpWizardState->pWebGate->DumpBufferToFile(&bstrHTMLFile, &bRetVal);

    // Use the Walker to get the page type
    gpWizardState->pHTMLWalker->AttachToMSHTML(bstrHTMLFile);
    gpWizardState->pHTMLWalker->Walk();
    
    // Setup the controls based on the page type
    if (FAILED(hRes = gpWizardState->pHTMLWalker->get_PageType(&dwPageType)))
    {
        gpWizardState->pRefDial->DoHangup();
        g_bMalformedPage = TRUE; //used by server error to get correct msg
    }
    else
    {    
        if (dwPageType == PAGETYPE_ISP_TOS)
        {
            if(gpWizardState->cmnStateData.bOEMCustom)
            {
                gpWizardState->pICWWebView->SetHTMLBackgroundBitmap(NULL, NULL);
            }
            gpWizardState->pICWWebView->ConnectToWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSHTML), PAGETYPE_ISP_TOS);
        }
        else        
        {
            RECT    rcHTML;
            HWND    hWndHTML;
            
            gpWizardState->pHTMLWalker->get_PageFlag(&dwPageFlag);
    
            if (dwPageFlag & PAGEFLAG_SAVE_CHKBOX) 
            {
                hWndHTML = GetDlgItem(hDlg, IDC_ISPDATA_CUSTHTML);
                // See if we need to display the app background bitmap in the HTML
                // window
                if(gpWizardState->cmnStateData.bOEMCustom)
                {
                    GetWindowRect(hWndHTML, &rcHTML);
                    MapWindowPoints(NULL, gpWizardState->cmnStateData.hWndApp, (LPPOINT)&rcHTML, 2);
                    gpWizardState->pICWWebView->SetHTMLBackgroundBitmap(gpWizardState->cmnStateData.hbmBkgrnd, &rcHTML);
                }
                gpWizardState->pICWWebView->ConnectToWindow(hWndHTML, PAGETYPE_ISP_NORMAL);
            }
            else
            {
                hWndHTML = GetDlgItem(hDlg, IDC_ISPDATA_HTML);
                // See if we need to display the app background bitmap in the HTML
                // window
                if(gpWizardState->cmnStateData.bOEMCustom)
                {
                    GetWindowRect(hWndHTML, &rcHTML);
                    MapWindowPoints(NULL, gpWizardState->cmnStateData.hWndApp, (LPPOINT)&rcHTML, 2);
                    gpWizardState->pICWWebView->SetHTMLBackgroundBitmap(gpWizardState->cmnStateData.hbmBkgrnd, &rcHTML);
                }
                gpWizardState->pICWWebView->ConnectToWindow(hWndHTML, PAGETYPE_ISP_NORMAL);
            }
        }

        // Custom finish means that the ISP wants us to show some special text
        // and then finish the wizard
        if (dwPageType == PAGETYPE_ISP_CUSTOMFINISH)
        {
            BOOL bRetVal;
            
            // Show the page. no need to cache it    
            bOKToPersist = FALSE;
            lstrcpy(szHTMLFile, W2A(bstrHTMLFile));
            gpWizardState->pICWWebView->DisplayHTML(szHTMLFile);
            
            // Kill the idle timer and connection, since there are no more pages
            ASSERT(gpWizardState->pRefDial);
            
            KillIdleTimer();
            gpWizardState->pRefDial->DoHangup();
            gpWizardState->pRefDial->RemoveConnectoid(&bRetVal);
            gpWizardState->bDialExact = FALSE;
                
        }
        else
        {
            // In order to persist data entered by the user, we have to 
            // effectivly "cache" the pages, so that when the user goes back
            // we make MSHTML think that we are loading a page that it has seen
            // before, and it will then reload the persisted history.
            
            // This will be done by using the PAGEID value in the HTML to form a
            // temp file name, so that we can re-load the page date from that file
            // each time we see the same page ID value.
            
            // Get the Page ID.
            gpWizardState->pHTMLWalker->get_PageID(&bstrPageID);
            if (bOKToPersist && SUCCEEDED( gpWizardState->lpSelectedISPInfo->CopyFiletoISPPageCache(bstrPageID, W2A(bstrHTMLFile))))
            {
                // We have a "cache" file, so we can use it and persist data
                // Get the cache file name now, since we will need it later
                gpWizardState->lpSelectedISPInfo->GetCacheFileNameFromPageID(bstrPageID, szHTMLFile, sizeof(szHTMLFile));
            }        
            else
            {
                bOKToPersist = FALSE;
                lstrcpy(szHTMLFile, W2A(bstrHTMLFile));
            }
            
            // Display the page we just "cached"
            gpWizardState->pICWWebView->DisplayHTML(szHTMLFile);
            
            if (bOKToPersist)
            {
                // Restore any persisted data on this page.
                gpWizardState->lpSelectedISPInfo->LoadHistory(bstrPageID);
            }
            
            // Cleanup
            SysFreeString(bstrPageID);
        }
        
#if defined(DBG)
        AskSaveISPHTML(hDlg, szHTMLFile);
#endif

        InitPageControls(hDlg, dwPageType, dwPageFlag);
        g_dwPageType = dwPageType;
    }                                                
    // Detach the walker
    gpWizardState->pHTMLWalker->Detach();

    HideProgressAnimation();
    
    SysFreeString(bstrHTMLFile);
    
    return hRes;
}


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

  NAME:    ISPPageInitProc

  SYNOPSIS:  Called when page is displayed

  ENTRY:    hDlg - dialog window
        fFirstInit - TRUE if this is the first time the dialog
        is initialized, FALSE if this InitProc has been called
        before (e.g. went past this page and backed up)

********************************************************************/
BOOL CALLBACK ISPPageInitProc
(
    HWND hDlg,
    BOOL fFirstInit,
    UINT *puNextPage
)
{
    if (fFirstInit)
    {
        // Setup an Event Handler for RefDial and Webgate
        CINSHandlerEvent *pINSHandlerEvent;
        pINSHandlerEvent = new CINSHandlerEvent(hDlg);
        if (NULL != pINSHandlerEvent)
        {
            HRESULT hr;
            gpWizardState->pINSHandlerEvents = pINSHandlerEvent;
            gpWizardState->pINSHandlerEvents->AddRef();
    
            hr = ConnectToConnectionPoint((IUnknown *)gpWizardState->pINSHandlerEvents, 
                                            DIID__INSHandlerEvents,
                                            TRUE,
                                            (IUnknown *)gpWizardState->pINSHandler, 
                                            &gpWizardState->pINSHandlerEvents->m_dwCookie, 
                                            NULL);     
        }    
        PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK);
    }
    else
    {      

        if (FAILED(InitForPageType(hDlg)))    
        {
            //The page type isn't recognized which means there's a problem
            //with the data. goto the serverr page
            gpWizardState->pRefDial->DoHangup();
            *puNextPage = ORD_PAGE_SERVERR;
        }
        
        // if we've travelled through external apprentice pages,
        // it's easy for our current page pointer to get munged,
        // so reset it here for sanity's sake.
        gpWizardState->uCurrentPage = ORD_PAGE_ISPDATA;
    }
    return TRUE;
}


// Returns FALSE if we should stay on this page, TRUE if we should change pages
// the param bError indicates we should proceed to the server Error Page.
BOOL ProcessNextBackPage
(
    HWND    hDlg,
    BOOL    fForward,
    BOOL    *pfError
)
{           
    BOOL    bRet = FALSE;
    TCHAR   szURL[2*INTERNET_MAX_URL_LENGTH + 1] = TEXT("\0");
    
    *pfError = FALSE;
    
    gpWizardState->pHTMLWalker->get_URL(szURL, fForward);
         
    // See if a URL is Specified        
    if (lstrcmp(szURL, TEXT("")) == 0)
    {
        //Stop the animation
        HideProgressAnimation();
    
        //Reenable the UI
        PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_NEXT | PSWIZB_BACK);
        
        // If forward, we want to force our way to the server error page,
        // since we cannot go forward to a blank URL
        if (fForward)
        {
            KillIdleTimer();
            gpWizardState->pRefDial->DoHangup();
            *pfError = TRUE;
        }
        else
        {
            // We are backing out of ISP page land, so lets hangup.
            if(gpWizardState->pRefDial)
            {
                BOOL bRetVal;
                KillIdleTimer();
                gpWizardState->pRefDial->DoHangup();
                gpWizardState->pRefDial->RemoveConnectoid(&bRetVal);
                gpWizardState->bDialExact = FALSE;
            }                
        }
        // We will need to navigate away from the ISP page
        bRet = TRUE;
    }
    else
    {
        
        BOOL    bRetWebGate;
        BOOL    bConnected = FALSE;
        g_bWebGateCheck = TRUE;
        g_bConnectionErr = FALSE;
        
        // Do not go to the next page. Also valid for the cancel case
        bRet = FALSE;
    
        // Kill the idle Timer
        KillIdleTimer();
        
        // Tell webgate to go fetch the page
        gpWizardState->pWebGate->put_Path(A2W(szURL));
        gpWizardState->pWebGate->FetchPage(0,0,&bRetWebGate);
    
        //This flag is only to be used by ICWDEBUG.EXE
        if (gpWizardState->cmnStateData.dwFlags & ICW_CFGFLAG_MODEMOVERRIDE)
            bConnected = TRUE;
        else
            gpWizardState->pRefDial->get_RasGetConnectStatus(&bConnected);
        
        if (bConnected)
        {
            WaitForEvent(gpWizardState->hEventWebGateDone);
        }
        else
        {
            g_bConnectionErr = TRUE;
        }
        // See if the user canceled.  If so we want to force the wizard to bail.
        // this can be hacked by forcing the return value to be FALSE and
        // setting the gfQuitWizard flag to TRUE. Gendlg will check this flag
        // when the OK proc returns, and process appropriatly
        if (!gfUserCancelled)
        {
            if (g_bConnectionErr)
            {
                // Make it go to server error page
                bRet = TRUE;
                *pfError = TRUE;
            }
            else
            {

                // Restart the Idle Timer
                StartIdleTimer();
            
                // detach the walker, since Init for page type needs it
                gpWizardState->pHTMLWalker->Detach();
            
                // Setup for this page
                if (FAILED(InitForPageType(hDlg)))    
                {
                    //The page type isn't recognized which means there's a problem
                    //with the data. goto the serverr page
                    *pfError = TRUE;
                     bRet    = TRUE;
                }
            }

        }
        else
        {
            // Force the wizard to quit, since the user canceled
            gfQuitWizard = TRUE;
        }                    
    }
    
    return bRet;
}    
/*******************************************************************

  NAME:    ISPPageOKProc

  SYNOPSIS:  Called when Next or Back btns pressed from  page

  ENTRY:    hDlg - dialog window
        fForward - TRUE if 'Next' was pressed, FALSE if 'Back'
        puNextPage - if 'Next' was pressed,
          proc can fill this in with next page to go to.  This
          parameter is ingored if 'Back' was pressed.
        pfKeepHistory - page will not be kept in history if
          proc fills this in with FALSE.

  EXIT:    returns TRUE to allow page to be turned, FALSE
        to keep the same page.

********************************************************************/
BOOL CALLBACK ISPPageOKProc
(
    HWND hDlg,
    BOOL fForward,
    UINT *puNextPage,
    BOOL *pfKeepHistory
)
{
    ASSERT(puNextPage);

    DWORD           dwPageType;
    TCHAR           szURL[2*INTERNET_MAX_URL_LENGTH + 1] = TEXT("\0");
    BOOL            bRetVal = TRUE;
    BSTR            bstrPageID = NULL;
    IWebBrowser2    *lpWebBrowser;

    // We don't want to keep any of the ISP pages in the history list
    *pfKeepHistory = FALSE;
    
    // If we are going forward, and if the user has been autodisconnected, then
    // we want to automatically navigate to the server error page.
    if (fForward && gpWizardState->bAutoDisconnected)
    {
        gpWizardState->bAutoDisconnected = FALSE;
        *puNextPage = ORD_PAGE_SERVERR;
        return TRUE;
    }
    
    // Attach the walker to the curent page to get the page type
    gpWizardState->pICWWebView->get_BrowserObject(&lpWebBrowser);
    gpWizardState->pHTMLWalker->AttachToDocument(lpWebBrowser);
    gpWizardState->pHTMLWalker->Walk();
    gpWizardState->pHTMLWalker->get_PageType(&dwPageType);
    
    // Custom finish means we just exit, so we just need to return TRUE
    if (PAGETYPE_ISP_CUSTOMFINISH == dwPageType)
    {
        gpWizardState->pHTMLWalker->Detach();
        return TRUE;
    }
    
    // Check the TOS settings. If the users decline, don't allow them to proceed
    if (IsWindowVisible(GetDlgItem(hDlg, IDC_ISPDATA_TOSDECLINE)) )
    {
        if (fForward)
        {
            if (Button_GetCheck(GetDlgItem(hDlg, IDC_ISPDATA_TOSDECLINE)))
            {
                if (MsgBox(hDlg,IDS_ERR_TOS_DECLINE,MB_ICONSTOP,MB_OKCANCEL) != IDOK)
                {
                    gfQuitWizard = TRUE;
                }
                Button_SetCheck(GetDlgItem(hDlg, IDC_ISPDATA_TOSACCEPT), 0);
                Button_SetCheck(GetDlgItem(hDlg, IDC_ISPDATA_TOSDECLINE), 0);
                // Set tab focus
                SetWindowLong(GetDlgItem(hDlg, IDC_ISPDATA_TOSACCEPT), GWL_STYLE, GetWindowLong(GetDlgItem(hDlg, IDC_ISPDATA_TOSACCEPT),GWL_STYLE)|WS_TABSTOP);            
                SetFocus(GetDlgItem(hDlg, IDC_ISPDATA_TOSHTML));
                PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK);
                return FALSE;
            }
        }
        EnableWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSDECLINE), FALSE);
        EnableWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSACCEPT), FALSE);
        EnableWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSSAVE), FALSE);
    }    


    //Show the progress animation 
    ShowProgressAnimation();
    
    //Disable the UI
    PropSheet_SetWizButtons(GetParent(hDlg), 0);

    if (bOKToPersist)
    {
        // Persist any data on this page.
        gpWizardState->pHTMLWalker->get_PageID(&bstrPageID);
        gpWizardState->lpSelectedISPInfo->SaveHistory(bstrPageID);
        SysFreeString(bstrPageID);
    }
    
    // User going back?
    if (fForward)
    {
        // Depending on the page type, we do different things
        switch (dwPageType)    
        {
            // The finish page types, mean that what we fetch next is an INS file
            case PAGETYPE_ISP_FINISH:
            {
                BSTR    bstrINSFile;
                BSTR    bstrStartURL;
                BOOL    bRet;
                BOOL    bIsQuickFinish = FALSE;
                long    lBrandingFlags;
            
                gpWizardState->pHTMLWalker->get_URL(szURL, TRUE);
            
                // Kill the idle timer
                KillIdleTimer();
            
                gpWizardState->pHTMLWalker->get_IsQuickFinish(&bIsQuickFinish);
                
                if(!bIsQuickFinish)
                {
                    BOOL bConnected = FALSE;
                    g_bWebGateCheck = TRUE;
                    g_bConnectionErr = FALSE;

                    // Tell webgate to go fetch the page
                    gpWizardState->pWebGate->put_Path(A2W(szURL));
                    gpWizardState->pWebGate->FetchPage(1,0,&bRet);
        
                    //This flag is only to be used by ICWDEBUG.EXE
                    if (gpWizardState->cmnStateData.dwFlags & ICW_CFGFLAG_MODEMOVERRIDE)
                        bConnected = TRUE;
                    else
                        // Check for connection status before proceed
                        gpWizardState->pRefDial->get_RasGetConnectStatus(&bConnected);
                    
                    if (bConnected)
                    {
                        WaitForEvent(gpWizardState->hEventWebGateDone);
                    }
                    else
                    {
                        bConnected = TRUE;
                    }

                    if (g_bConnectionErr)
                    {
                        gpWizardState->pRefDial->DoHangup();
                        *puNextPage = ORD_PAGE_SERVERR;
                        break;
                    }
            
                    // Can't allow the user to cancel now
                    PropSheet_CancelToClose(GetParent(hDlg));       
                    PropSheet_SetWizButtons(GetParent(hDlg),0);
                    UpdateWindow(GetParent(hDlg));
                
                     //Stop the animation
                     HideProgressAnimation();

                    // See if the user canceled while downloading the INS file
                    if (!gfUserCancelled)
                    {   
                        // OK process the INS file.
                        gpWizardState->pWebGate->get_DownloadFname(&bstrINSFile);
                
                        // Get the Branding flags
                        gpWizardState->pRefDial->get_BrandingFlags(&lBrandingFlags);
                
                        // Tell the INSHandler about the branding flags
                        gpWizardState->pINSHandler->put_BrandingFlags(lBrandingFlags);

                        // Process the inf file.
                        gpWizardState->pINSHandler->ProcessINS(bstrINSFile, &bRet);

                        //hang on to whether or not this failed.
                        gpWizardState->cmnStateData.ispInfo.bFailedIns = !bRet;

                        // Get the Start URL from INS file.
                        gpWizardState->pINSHandler->get_DefaultURL(&bstrStartURL);
                        lstrcpy(gpWizardState->cmnStateData.ispInfo.szStartURL, 
                                 W2A(bstrStartURL));
                    
                        // Time to retun to the main wizard
                        *puNextPage = g_uExternUINext;
                
                        // Detach the walker before we go
                        gpWizardState->pHTMLWalker->Detach();
                
                        //Copy over the isp name and support number for the last page.
                        lstrcpy(gpWizardState->cmnStateData.ispInfo.szISPName, 
                                 gpWizardState->lpSelectedISPInfo->get_szISPName());
                    
                        BSTR bstrSupportPhoneNum;
                        gpWizardState->pRefDial->get_ISPSupportNumber(&bstrSupportPhoneNum);
                    
                        lstrcpy(gpWizardState->cmnStateData.ispInfo.szSupportNumber, 
                                 W2A(bstrSupportPhoneNum));
                             
                    }
                    else
                    {
                        // The user canceled while we were donwloading the INS, so lets bail
                        gpWizardState->pHTMLWalker->Detach();
                        gfQuitWizard = TRUE;
                        bRetVal = FALSE;
                    } 
                }
                else
                    HideProgressAnimation();

                // Let the wizard Continue/Finish
                break;
            }
           
            // These page types mean that we need to form a new URL, and get the next page
            case PAGETYPE_ISP_TOS:
            case PAGETYPE_ISP_NORMAL:
            {
                BOOL    bError;
                
                bRetVal = ProcessNextBackPage(hDlg, TRUE, &bError);
                
                if (bError)
                {
                    // Go to the server error page
                    gpWizardState->pRefDial->DoHangup();
                    *puNextPage = ORD_PAGE_SERVERR;
                }
                break;
            }
            default:
            {
                //Stop the animation
                HideProgressAnimation();

                gpWizardState->pRefDial->DoHangup();
                // Goto the server error page, since we surely did not recognize this page type
                *puNextPage = ORD_PAGE_SERVERR;
                break;        
            }
        }            
    }
    else
    {
        // Going Backwards.
        BOOL    bError;
                
        bRetVal = ProcessNextBackPage(hDlg, FALSE, &bError);
                
        if (bError)
        {
            // Go to the server error page
            *puNextPage = ORD_PAGE_SERVERR;
        }
    }
    
    return bRetVal;
}

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

  NAME:    ISPCmdProc

********************************************************************/
BOOL CALLBACK ISPCmdProc
(
    HWND    hDlg,
    WPARAM  wParam,
    LPARAM  lParam
)
{
    switch (GET_WM_COMMAND_CMD(wParam, lParam)) 
    {
        case BN_CLICKED:
        {
            switch (GET_WM_COMMAND_ID(wParam, lParam)) 
            { 
                case IDC_ISPDATA_TOSACCEPT: 
                case IDC_ISPDATA_TOSDECLINE:
                {
                    PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_NEXT | PSWIZB_BACK);
                    break;
                }
                case IDC_ISPDATA_TOSSAVE:
                {
                    if  (SaveISPFile(hDlg, szHTMLFile, g_dwPageType))
                    {        
                        SetFocus(GetDlgItem(hDlg, IDC_ISPDATA_TOSHTML));
                        EnableWindow(GetDlgItem(hDlg, IDC_ISPDATA_TOSSAVE), FALSE);
                    }
                    break;
                }
                default:
                    break;
            }
            break;
        }
        case BN_DBLCLK:
        {
            switch (GET_WM_COMMAND_ID(wParam, lParam)) 
            { 
                case IDC_ISPDATA_TOSACCEPT: 
                case IDC_ISPDATA_TOSDECLINE:
                {
                    // somebody double-clicked a radio button
                    // auto-advance to the next page
                    PropSheet_PressButton(GetParent(hDlg), PSBTN_NEXT);
                    break;
                }
                default:
                    break;
            }
            break;
        }
        case BN_SETFOCUS:
        {
            if ((GET_WM_COMMAND_ID(wParam, lParam) == IDC_ISPDATA_TOSACCEPT) )
            {
                CheckDlgButton(hDlg, IDC_ISPDATA_TOSACCEPT, BST_CHECKED);

                // Uncheck the decline checkbox make sure no two radio button
                // selected at the same time.
                CheckDlgButton(hDlg, IDC_ISPDATA_TOSDECLINE, BST_UNCHECKED);
                PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_NEXT | PSWIZB_BACK);
            }
            break;
        }
        default:
            break;
    }
    return 1;
}



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

  NAME:     DisplayConfirmationDialog

  SYNOPSIS: Display a confirmation dialog for the file being written

  ENTRY:    hwndParent - dialog window
            dwFileType - current isp page type
            szFileName - source file name

  EXIT:     returns TRUE when save successfully; FALSE otherwise.

********************************************************************/
BOOL DisplayConfirmationDialog(HWND hwndParent, DWORD dwFileType, TCHAR* szFileName)
{
    TCHAR   szFinal [MAX_MESSAGE_LEN] = TEXT("\0");
    TCHAR   szFmt   [MAX_MESSAGE_LEN];
    TCHAR   *args   [1];
    LPVOID  pszIntro;
    BOOL    bRet = TRUE;
    UINT    uMsgID;

    args[0] = (LPTSTR) szFileName;
    
    if (PAGETYPE_ISP_TOS == dwFileType)
    {
        uMsgID = IDS_SAVE_COPY_CONFIRM_MSG;
    }
    else 
    {
        uMsgID = IDS_SAVE_ISP_CONFIRM_MSG;
    }

    LoadString(ghInstanceResDll, uMsgID, szFmt, ARRAYSIZE(szFmt));
                
    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, 
                  szFmt, 
                  0, 
                  0, 
                  (LPTSTR)&pszIntro, 
                  0,
                  (va_list*)args);
                  
    lstrcpy(szFinal, (LPTSTR)pszIntro);
        
    LoadString(ghInstanceResDll, IDS_APPNAME, szFmt, ARRAYSIZE(szFmt));

    MessageBox(hwndParent, szFinal, szFmt, MB_OK | MB_ICONINFORMATION | MB_APPLMODAL);

    LocalFree(pszIntro);
    
    return(bRet);
}



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

  NAME:     SaveISPFile

  SYNOPSIS: Called want to save html file to desktop without dialog

  ENTRY:    hwndParent - dialog window
            szSrcFileName - source file name
            uFileType - Type of files embedded in the htm file

  EXIT:     returns TRUE when save successfully; FALSE otherwise.

********************************************************************/
BOOL SaveISPFile( HWND hwndParent, TCHAR* szSrcFileName, DWORD dwFileType)
{
    
    TCHAR         szNewFileBuff [MAX_PATH + 1];
    TCHAR         szWorkingDir  [MAX_PATH + 1];     
    TCHAR         szDesktopPath [MAX_PATH + 1];     
    TCHAR         szLocalFile   [MAX_PATH + 1];   
    TCHAR         szISPName     [MAX_ISP_NAME + 1];  
    TCHAR         szFmt         [MAX_MESSAGE_LEN];
    TCHAR         szNumber      [MAX_MESSAGE_LEN];
    TCHAR         *args         [2];
    DWORD         dwFileFormatOrig;
    DWORD         dwFileFormatCopy;
    LPTSTR        pszInvalideChars             = TEXT("\\/:*?\"<>|");
    LPVOID        pszIntro                     = NULL;
    LPITEMIDLIST  lpItemDList                  = NULL;
    HRESULT       hr                           = E_FAIL; //don't assume success
    IMalloc      *pMalloc                      = NULL;
    BOOL          ret                          = FALSE;
    
    ASSERT(hwndParent);
    ASSERT(szFileName);

    // Validate page type, return false if page type is unknown
    if (PAGETYPE_ISP_TOS == dwFileType)
    {
        dwFileFormatOrig = IDS_TERMS_FILENAME;
        dwFileFormatCopy = IDS_TERMS_FILENAME_COPY;
    }
    else if ((PAGETYPE_ISP_CUSTOMFINISH == dwFileType) ||
          (PAGETYPE_ISP_FINISH == dwFileType) ||
          (PAGETYPE_ISP_NORMAL == dwFileType))
    {
        dwFileFormatOrig = IDS_ISPINFO_FILENAME;
        dwFileFormatCopy = IDS_ISPINFO_FILENAME_COPY;
    }
    else
    {
        return FALSE;
    }

    GetCurrentDirectory(ARRAYSIZE(szWorkingDir), szWorkingDir);
    
    hr = SHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP,&lpItemDList);
 
    //Get the "DESKTOP" dir 
    ASSERT(SUCCEEDED(hr));

    if (SUCCEEDED(hr))  
    {
        SHGetPathFromIDList(lpItemDList, szDesktopPath);
        
        // Free up the memory allocated for LPITEMIDLIST
        if (SUCCEEDED (SHGetMalloc (&pMalloc)))
        {
            pMalloc->Free (lpItemDList);
            pMalloc->Release ();
        }
    }


    // Replace invalid file name char in ISP name with underscore
    lstrcpy(szISPName, gpWizardState->lpSelectedISPInfo->get_szISPName());
    for( int i = 0; szISPName[i]; i++ )
    {
        if(_tcschr(pszInvalideChars, szISPName[i])) 
        {
            szISPName[i] = '_';
        }
    }

    // Load the default file name
    args[0] = (LPTSTR) szISPName;
    args[1] = NULL;
    LoadString(ghInstanceResDll, dwFileFormatOrig, szFmt, ARRAYSIZE(szFmt));
        
    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, 
                  szFmt, 
                  0, 
                  0, 
                  (LPTSTR)&pszIntro, 
                  0,
                  (va_list*)args);

    lstrcat(szDesktopPath, TEXT("\\"));
    wsprintf(szLocalFile, TEXT("\"%s\""), (LPTSTR)pszIntro);
    lstrcpy(szNewFileBuff, szDesktopPath);
    lstrcat(szNewFileBuff, (LPTSTR)pszIntro);
    LocalFree(pszIntro);

    // Check if file already exists
    if (0xFFFFFFFF != GetFileAttributes(szNewFileBuff))
    {
        // If file exists, create new filename with paranthesis
        int     nCurr = 1;
        do
        {
            wsprintf(szNumber, TEXT("%d"), nCurr++);
            args[1] = (LPTSTR) szNumber;

            LoadString(ghInstanceResDll, dwFileFormatCopy, szFmt, ARRAYSIZE(szFmt));
                
            FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, 
                          szFmt, 
                          0, 
                          0, 
                          (LPTSTR)&pszIntro, 
                          0,
                          (va_list*)args);
            lstrcpy(szNewFileBuff, szDesktopPath);
            wsprintf(szLocalFile, TEXT("\"%s\""), (LPTSTR)pszIntro);
            lstrcat(szNewFileBuff, (LPTSTR)pszIntro);
            LocalFree(pszIntro);
        } while ((0xFFFFFFFF != GetFileAttributes(szNewFileBuff)) && (nCurr <= 100));

    }

    // Copy the file to permanent location
    HANDLE hFile = CreateFile(szNewFileBuff, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile != INVALID_HANDLE_VALUE)
    {
        IICWWalker* pHTMLWalker = NULL;
        BSTR bstrText           = NULL;
        DWORD dwByte            = 0;

        if (SUCCEEDED(CoCreateInstance(CLSID_ICWWALKER,NULL,CLSCTX_INPROC_SERVER,
                                       IID_IICWWalker,(LPVOID*)&pHTMLWalker)))
        {
            pHTMLWalker->InitForMSHTML();
            pHTMLWalker->AttachToMSHTML(A2W(szSrcFileName));
            if (SUCCEEDED(pHTMLWalker->ExtractUnHiddenText(&bstrText)) && bstrText)
            {
                #ifdef UNICODE
                BYTE UNICODE_BYTE_ORDER_MARK[] = {0xFF, 0xFE};
                WriteFile(hFile, 
                          UNICODE_BYTE_ORDER_MARK,
                          sizeof(UNICODE_BYTE_ORDER_MARK),
                          &dwByte,
                          NULL);
                #endif
                ret = WriteFile(hFile, W2A(bstrText), lstrlen(W2A(bstrText))* sizeof(TCHAR), &dwByte, NULL);  
                SysFreeString(bstrText);
            }
            pHTMLWalker->TermForMSHTML();
            pHTMLWalker->Release();
        }
        CloseHandle(hFile);
    
    }

    // Display message according to the state of CopyFile
    if (!ret)
    {
        DeleteFile(szNewFileBuff);

        //let the user know there was not enough disk space
        TCHAR szTemp    [MAX_RES_LEN] = TEXT("\0"); 
        TCHAR szCaption [MAX_RES_LEN] = TEXT("\0"); 

        LoadString(ghInstanceResDll, IDS_NOT_ENOUGH_DISKSPACE, szTemp, ARRAYSIZE(szTemp));
        LoadString(ghInstanceResDll, IDS_APPNAME, szCaption, ARRAYSIZE(szCaption));
        MessageBox(hwndParent, szTemp, szCaption, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL);
    }
    else
    {
        // Display the confirmation
        DisplayConfirmationDialog(hwndParent, dwFileType, szLocalFile);
    }

    return ret;
}

#if defined (DBG)
BOOL HtmlSaveAs( HWND hwndParent, TCHAR* szFileName, TCHAR* szTargetFileName)
{
    ASSERT(hwndParent);
    ASSERT(szFileName);
    
    OPENFILENAME  ofn;                                              
    TCHAR         szNewFileBuff [MAX_PATH + 1];
    TCHAR         szDesktopPath [MAX_PATH + 1] = TEXT("\0");     
    TCHAR         szWorkingDir  [MAX_PATH + 1] = TEXT("\0");     
    TCHAR         szFilter      [255]          = TEXT("\0");
    LPITEMIDLIST  lpItemDList                  = NULL;
    HRESULT       hr                           = E_FAIL; //don't assume success
    IMalloc      *pMalloc                      = NULL;
    BOOL          ret = TRUE;
    
    GetCurrentDirectory(ARRAYSIZE(szWorkingDir), szWorkingDir);
    
    hr = SHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP,&lpItemDList);
 
    //Get the "DESKTOP" dir 
       ASSERT(SUCCEEDED(hr));

    if (SUCCEEDED(hr))  
    {
        SHGetPathFromIDList(lpItemDList, szDesktopPath);
        
        // Free up the memory allocated for LPITEMIDLIST
        if (SUCCEEDED (SHGetMalloc (&pMalloc)))
        {
            pMalloc->Free (lpItemDList);
            pMalloc->Release ();
        }
    }

    if (szTargetFileName != NULL)
    {
        lstrcpy(szNewFileBuff, szDesktopPath);
        lstrcat(szNewFileBuff, TEXT("\\"));
        lstrcat(szNewFileBuff, szTargetFileName);
       
        // Copy temporary file to permanent location
        ret = CopyFile(szFileName, szNewFileBuff, FALSE);
    }
    else
    {
        //Setup the filter
        LoadString(ghInstanceResDll, IDS_DEFAULT_TOS_FILTER, szFilter, ARRAYSIZE(szFilter)); // "HTML Files"
        
        //Setup the default file name
        if(!LoadString(ghInstanceResDll, IDS_DEFAULT_TOS_FILENAME, szNewFileBuff, ARRAYSIZE(szNewFileBuff))) // "terms"
            lstrcpy(szNewFileBuff, TEXT("terms"));
        lstrcat(szNewFileBuff, TEXT(".htm"));

        //init the filename struct
        ofn.lStructSize       = sizeof(OPENFILENAME); 
        ofn.hwndOwner         = hwndParent; 
        ofn.lpstrFilter       = szFilter; 
        ofn.lpstrFile         = szNewFileBuff;  
        ofn.nMaxFile          = sizeof(szNewFileBuff); 
        ofn.lpstrFileTitle    = NULL; 
        ofn.lpstrInitialDir   = szDesktopPath; 
        ofn.lpstrTitle        = NULL;
        ofn.lpstrCustomFilter = (LPTSTR) NULL;
        ofn.nMaxCustFilter    = 0L;
        ofn.nFileOffset       = 0;
        ofn.nFileExtension    = 0;
        ofn.lpstrDefExt       = TEXT("*.htm");
        ofn.lCustData         = 0;
        ofn.nFilterIndex      = 1L;
        ofn.nMaxFileTitle     = 0;
        ofn.Flags             = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY |
                                OFN_EXPLORER      | OFN_LONGNAMES | OFN_OVERWRITEPROMPT;  
   
        //Call the SaveAs common dlg
        if(TRUE == GetSaveFileName(&ofn))
        {
            HANDLE hFile = CreateFile(ofn.lpstrFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
            if (hFile != INVALID_HANDLE_VALUE)
            {
                IICWWalker* pHTMLWalker = NULL;
                BSTR bstrText           = NULL;
                DWORD dwByte            = 0;

                if (SUCCEEDED(CoCreateInstance(CLSID_ICWWALKER,NULL,CLSCTX_INPROC_SERVER,
                                               IID_IICWWalker,(LPVOID*)&pHTMLWalker)))
                {
                    pHTMLWalker->InitForMSHTML();
                    pHTMLWalker->AttachToMSHTML(A2W(szFileName));
                    if (SUCCEEDED(pHTMLWalker->ExtractUnHiddenText(&bstrText)) && bstrText)
                    {
                        ret = WriteFile(hFile, W2A(bstrText), lstrlen(W2A(bstrText)), &dwByte, NULL);  
                        SysFreeString(bstrText);
                    }
                    pHTMLWalker->TermForMSHTML();
                    pHTMLWalker->Release();
                }
                CloseHandle(hFile);
            
            }
            if (!ret)
            {
                DeleteFile(ofn.lpstrFile);

                //let the user know there was not enough disk space
                TCHAR szTemp    [MAX_RES_LEN] = TEXT("\0"); 
                TCHAR szCaption [MAX_RES_LEN] = TEXT("\0"); 

                LoadString(ghInstanceResDll, IDS_NOT_ENOUGH_DISKSPACE, szTemp, ARRAYSIZE(szTemp));
                LoadString(ghInstanceResDll, IDS_APPNAME, szCaption, ARRAYSIZE(szCaption));
                MessageBox(hwndParent, szTemp, szCaption, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL);
            }
        }
    }    
    SetCurrentDirectory(szWorkingDir);
    return ret;
}
#endif