windows-server-2003/base/ntsetup/ocmanage/common/ocsetup.c

#include "precomp.h"
#pragma hdrstop
#include <stdio.h>


typedef struct _SETUP_PAGE {
    POC_MANAGER OcManager;
    SETUP_PAGE_CONTROLS ControlsInfo;
    HSPFILEQ FileQueue;
    PVOID QueueContext;
    UINT StepCount;

    BOOL ForceExternalProgressIndicator;

    PUINT ComponentTickCounts;
    PUINT ComponentMaxTickCounts;
    LONG CurrentTopLevelComponentIndex;

    BOOL AllowCancel;

    HWND hdlg;

    BOOL UserClickedCancel;

    DWORD RefCount;

// Boolean to track NeedMedia requests. NeedMedia notification is sent always by Setupapi the first time it 
// tries to access a new media. We need to figure out if the media is actually inaccessible by checking if setupapi
// called us a second time on the same media. The Boolean is checked and set in NeedMedia and cleared on an
// SPFILENOTIFY_ENDCOPY or SPFILENOTIFY_STARTSUBQUEUE.

    BOOL SecondNeedMedia;

} SETUP_PAGE, *PSETUP_PAGE;

#define WMX_SETUP           (WM_APP+4537)
#define WMX_TICK            (WM_APP+4538)

#define OCSETUPSTATE_INIT       0
#define OCSETUPSTATE_QUEUE      1
#define OCSETUPSTATE_GETSTEP    2
#define OCSETUPSTATE_DOIT       3
#define OCSETUPSTATE_COPYDONE   4
#define OCSETUPSTATE_DONE       100
#define OCSETUPSTATE_COPYABORT  101


typedef struct _GEN_THREAD_PARAMS {
    HWND hdlg;
    PSETUP_PAGE SetupPage;
    BOOL Async;
} GEN_THREAD_PARAMS, *PGEN_THREAD_PARAMS;

TCHAR g_LastFileCopied[MAX_PATH];

#ifdef UNICODE
HANDLE hSfp = NULL;
#endif

HANDLE WorkerThreadHandle = NULL;

INT_PTR
SetupPageDialogProc(
                   IN HWND   hdlg,
                   IN UINT   msg,
                   IN WPARAM wParam,
                   IN LPARAM lParam
                   );

BOOL
pOcSetupInitialize(
                  IN OUT PSETUP_PAGE SetupPage,
                  IN     HWND        hdlg
                  );

VOID
pOcSetupStartWorkerThread(
                         IN OUT PSETUP_PAGE            SetupPage,
                         IN     HWND                   hdlg,
                         IN     LPTHREAD_START_ROUTINE ThreadRoutine
                         );

DWORD
pOcSetupQueue(
             IN PGEN_THREAD_PARAMS Params
             );

UINT
pOcSetupQueueWorker(
                   IN PSETUP_PAGE SetupPage,
                   IN LONG        StringId,
                   IN LONG        TopLevelStringId
                   );

DWORD
pOcSetupGetStepCount(
                    IN PGEN_THREAD_PARAMS Params
                    );

UINT
pOcSetupGetStepCountWorker(
                          IN PSETUP_PAGE SetupPage,
                          IN LONG        StringId,
                          IN LONG        TopLevelStringId
                          );

DWORD
pOcSetupDoIt(
            IN PGEN_THREAD_PARAMS Params
            );

VOID
pOcPreOrPostCommitProcessing(
                            IN OUT PSETUP_PAGE SetupPage,
                            IN     BOOL        PreCommit
                            );

VOID
pOcTopLevelPreOrPostCommitProcessing(
                                    IN PSETUP_PAGE SetupPage,
                                    IN BOOL        PreCommit
                                    );

VOID
pOcSetupDoItWorker(
                  IN PSETUP_PAGE SetupPage,
                  IN LONG        StringId,
                  IN LONG        TopLevelStringId,
                  IN BOOL        PreCommit
                  );

BOOL
pOcMarkUnprocessedStringCB(
                          IN PVOID               StringTable,
                          IN LONG                StringId,
                          IN PCTSTR              String,
                          IN POPTIONAL_COMPONENT Oc,
                          IN UINT                OcSize,
                          IN LPARAM              Unused
                          );

VOID
_pOcExternalProgressIndicator(
                             IN PSETUP_PAGE SetupPage,
                             IN BOOL        ExternalIndicator,
                             IN HWND        hdlg
                             );


extern POC_MANAGER gLastOcManager;
WNDPROC OldProgressProc;

BOOL
NewProgessProc(
    IN HWND   hdlg,
    IN UINT   msg,
    IN WPARAM wParam,
    IN LPARAM lParam
    )
{
    switch (msg)
    {
        case PBM_DELTAPOS:
        case PBM_SETRANGE:
        case PBM_SETRANGE32:
        case PBM_STEPIT:
        case PBM_SETPOS:
        case PBM_SETSTEP:
            // If we have a callback, use it.
            if ((gLastOcManager) &&
                (gLastOcManager->Callbacks.BillboardProgressCallback))
            {
                gLastOcManager->Callbacks.BillboardProgressCallback(msg, wParam, lParam);
            }
            break;
    }
    return (BOOL)CallWindowProc(OldProgressProc,hdlg,msg,wParam,lParam);
}

HPROPSHEETPAGE
OcCreateSetupPage(
                 IN PVOID                OcManagerContext,
                 IN PSETUP_PAGE_CONTROLS ControlsInfo
                 )

/*++

Routine Description:

    This routine creates the wizard page used for progress and installation
    completion.

Arguments:

    OcManagerContext - supplies OC Manager context returned by OcInitialize.

    ControlsInfo - supplies information about the dialog template and
        control information.

Return Value:

    Handle to property sheet page, or NULL if error (such as out of memory).

--*/

{
    PROPSHEETPAGE Page;
    HPROPSHEETPAGE PageHandle;
    PSETUP_PAGE SetupPage;
    TCHAR buffer[256];
    POC_MANAGER OcManager = (POC_MANAGER)OcManagerContext;

    SetupPage = pSetupMalloc(sizeof(SETUP_PAGE));
    if (!SetupPage) {
        return (NULL);
    }
    ZeroMemory(SetupPage,sizeof(SETUP_PAGE));

    SetupPage->OcManager = OcManagerContext;
    SetupPage->ControlsInfo = *ControlsInfo;
    SetupPage->CurrentTopLevelComponentIndex = -1;
    SetupPage->ForceExternalProgressIndicator = ControlsInfo->ForceExternalProgressIndicator;
    SetupPage->AllowCancel = ControlsInfo->AllowCancel;
    SetupPage->SecondNeedMedia = FALSE;
    InterlockedIncrement( &SetupPage->RefCount );

    SetupPage->ComponentTickCounts = pSetupMalloc(SetupPage->OcManager->TopLevelOcCount * sizeof(UINT));
    if (!SetupPage->ComponentTickCounts) {
        pSetupFree(SetupPage);
        return (NULL);
    }

    SetupPage->ComponentMaxTickCounts = pSetupMalloc(SetupPage->OcManager->TopLevelOcCount * sizeof(UINT));
    if (!SetupPage->ComponentMaxTickCounts) {
        pSetupFree(SetupPage->ComponentTickCounts);
        pSetupFree(SetupPage);
        return (NULL);
    }

    Page.dwSize = sizeof(PROPSHEETPAGE);
    Page.dwFlags = PSP_DEFAULT;
    Page.hInstance = ControlsInfo->TemplateModule;
    Page.pszTemplate = ControlsInfo->TemplateResource;
    Page.pfnDlgProc = SetupPageDialogProc;
    Page.lParam = (LPARAM)SetupPage;
    Page.pszHeaderTitle = NULL;
    Page.pszHeaderSubTitle = NULL;

    if (SetupPage->OcManager->SetupPageTitle[0]) {
        Page.dwFlags |= PSP_USETITLE;
        Page.pszTitle = SetupPage->OcManager->SetupPageTitle;
    }

    if (ControlsInfo->HeaderText) {
        if (LoadString(Page.hInstance,
                       ControlsInfo->HeaderText,
                       buffer,
                       sizeof(buffer) / sizeof(TCHAR)))
        {
            Page.dwFlags |= PSP_USEHEADERTITLE;
            Page.pszHeaderTitle = _tcsdup(buffer);
        }
    }

    if (ControlsInfo->SubheaderText) {
        if (LoadString(Page.hInstance,
                       ControlsInfo->SubheaderText,
                       buffer,
                       sizeof(buffer) / sizeof(TCHAR)))
        {
            Page.dwFlags |= PSP_USEHEADERSUBTITLE;
            Page.pszHeaderSubTitle = _tcsdup(buffer);
        }
    }

    PageHandle = CreatePropertySheetPage(&Page);
    if (!PageHandle) {
        pSetupFree(SetupPage->ComponentTickCounts);
        pSetupFree(SetupPage->ComponentMaxTickCounts);
        pSetupFree(SetupPage);
        if (Page.pszHeaderTitle) {
            free((LPTSTR)Page.pszHeaderTitle);
        }
        if (Page.pszHeaderSubTitle) {
            free((LPTSTR)Page.pszHeaderSubTitle);
        }
    } else {
        OcManager->OcSetupPage = (PVOID) SetupPage;

    }



    return (PageHandle);
}

VOID
pOcFreeOcSetupPage(
    IN PVOID pSetupPage
    )
/*++

Routine Description:

    This routine frees the setup page when it's not needed anymore.
    The routine uses a ref-count, and the page is only freed when the
    refcount drops to zero.

Arguments:

    SetupPage - pointer to structure to be freed


Return Value:

    None.

--*/
{
    PSETUP_PAGE SetupPage = (PSETUP_PAGE)pSetupPage;

    sapiAssert( SetupPage != NULL );

//    TRACE(( TEXT("pOcFreeOcSetupPage: Refcount = %d\n"), SetupPage->RefCount ));

    if (!InterlockedDecrement( &SetupPage->RefCount )) {

//        TRACE(( TEXT("pOcFreeOcSetupPage: Refcount = 0, freeing SetupPage\n") ));

        if (SetupPage->QueueContext) {
            SetupTermDefaultQueueCallback(SetupPage->QueueContext);
        }
        if (SetupPage->FileQueue) {
            SetupCloseFileQueue(SetupPage->FileQueue);
        }

        pSetupFree(SetupPage->ComponentTickCounts);
        pSetupFree(SetupPage->ComponentMaxTickCounts);
        pSetupFree(SetupPage);
    }



    return;
}


BOOL
pOcDisableCancel(
    IN HWND hdlg
    )
/*++

Routine Description:

    This routine disables cancelling of ocm setup.

Arguments:

    hdlg - window handle to the ocm dialog


Return Value:

    TRUE if we succeed, else FALSE

--*/
{
    HMENU hMenu;

    //
    // hide the cancel button
    //
    EnableWindow(GetDlgItem(GetParent(hdlg),IDCANCEL),FALSE);
    ShowWindow(GetDlgItem(GetParent(hdlg),IDCANCEL),SW_HIDE);

    if(hMenu = GetSystemMenu(GetParent(hdlg),FALSE)) {
        EnableMenuItem(hMenu,SC_CLOSE,MF_BYCOMMAND|MF_GRAYED);
    }

    return TRUE;


}


VOID
PumpMessageQueue(
    VOID
    )
{
    MSG msg;

    while(PeekMessage(&msg,NULL,0,0,PM_REMOVE)) {
        DispatchMessage(&msg);
    }

}


INT_PTR
SetupPageDialogProc(
                   IN HWND   hdlg,
                   IN UINT   msg,
                   IN WPARAM wParam,
                   IN LPARAM lParam
                   )
{
    BOOL b;
    NMHDR *NotifyParams;
    PSETUP_PAGE SetupPage;
    DWORD Timeout;
    DWORD WaitProcStatus;
    BOOL KeepWaiting = TRUE;

    //
    // Get pointer to SetupPage data structure. If we haven't processed
    // WM_INITDIALOG yet, then this will be NULL, but it's still pretty
    // convenient to do this here once instead of all over the place below.
    //
    SetupPage = (PSETUP_PAGE)GetWindowLongPtr(hdlg,DWLP_USER);
    b = FALSE;

    switch (msg) {

        case WM_INITDIALOG:
            //
            // Get the pointer to the Setup Page context structure and stick it
            // in a window long.
            //
            SetWindowLongPtr(hdlg,DWLP_USER,((PROPSHEETPAGE *)lParam)->lParam);
            b = TRUE;
            //
            // eat any extra press button messages
            // this is necessary because netsetup is broken
            // it is posting an extra PSM_PRESSBUTTON message
            // to the wizard.
            //
            {
                MSG msg;
                HWND hwnd=GetParent(hdlg);
                while (PeekMessage(&msg,hwnd,PSM_PRESSBUTTON,PSM_PRESSBUTTON,PM_REMOVE)){}
            }

            break;

        case WM_SYSCOMMAND:
            if (!SetupPage->AllowCancel && wParam == SC_CLOSE) {
                return TRUE;
            }

            b = FALSE;
            break;
        case WM_DESTROY:

            PumpMessageQueue();

            if (WorkerThreadHandle) {

                BOOL Done = FALSE;

                do{

                    switch (MsgWaitForMultipleObjects( 1, &WorkerThreadHandle, FALSE, 60*1000*20, QS_ALLINPUT)){
                    
                    case WAIT_OBJECT_0+1:
                        //
                        // Messages in the queue.
                        //
                        PumpMessageQueue();
                        break;
                    
                    case WAIT_TIMEOUT:
                    case WAIT_OBJECT_0:
                    default:
                        Done = TRUE;
                        break;
                    }

                }while( !Done );

                CloseHandle( WorkerThreadHandle );
            }

            if (SetupPage) {

                pOcFreeOcSetupPage( SetupPage );

            }

            SetWindowLongPtr(hdlg,DWLP_USER,(LPARAM)NULL);

            break;

        case WM_NOTIFY:

            NotifyParams = (NMHDR *)lParam;
            switch (NotifyParams->code) {

                case PSN_SETACTIVE:
#ifdef UNICODE
                    if (SetupPage->OcManager->Callbacks.SetupPerfData)
                        SetupPage->OcManager->Callbacks.SetupPerfData(TEXT(__FILE__),__LINE__,L"BEGIN_SECTION",L"OCSetup");
#endif
                    // activate the cancel button accordingly

                    if (SetupPage->AllowCancel) {
                        ShowWindow(GetDlgItem(GetParent(hdlg),IDCANCEL),SW_SHOW);
                        EnableWindow(GetDlgItem(GetParent(hdlg),IDCANCEL),TRUE);
                    } else {
                        ShowWindow(GetDlgItem(GetParent(hdlg),IDCANCEL),SW_HIDE);
                        EnableWindow(GetDlgItem(GetParent(hdlg),IDCANCEL),FALSE);
                    }

                    if (SetupPage->OcManager->Callbacks.ShowHideWizardPage)
                    {
                        // If we have a callback, hide the wizard.
                        SetupPage->OcManager->Callbacks.ShowHideWizardPage(FALSE);
                    }
                    OldProgressProc = (WNDPROC)SetWindowLongPtr(GetDlgItem(hdlg,SetupPage->ControlsInfo.ProgressBar),
                                                                GWLP_WNDPROC,
                                                                (LONG_PTR)NewProgessProc);

                    //
                    // Post a message that causes us to start the installation process.
                    //
                    PostMessage(hdlg,WMX_SETUP,OCSETUPSTATE_INIT,0);

                    //
                    // Accept activation.
                    //
                    SetWindowLongPtr(hdlg,DWLP_MSGRESULT,0);
                    b = TRUE;
                    break;

                case PSN_KILLACTIVE:
                    //
                    // Restore the wizard's cancel button if we removed it earlier
                    //
                    if (!SetupPage->AllowCancel) {
                        ShowWindow(GetDlgItem(GetParent(hdlg),IDCANCEL),SW_SHOW);
                        EnableWindow(GetDlgItem(GetParent(hdlg),IDCANCEL),TRUE);
                    }

                    //
                    // Accept deactivation.
                    //
                    SetWindowLongPtr(hdlg,DWLP_MSGRESULT,0);
                    b = TRUE;
                    break;

                case PSN_QUERYCANCEL:

                    if (!SetupPage->AllowCancel) {
                        SetWindowLongPtr(hdlg,DWLP_MSGRESULT,TRUE);
                        return(TRUE);
                    }
                    if ( (SetupPage->OcManager->InternalFlags & OCMFLAG_FILEABORT )
                         || (OcHelperConfirmCancel(hdlg) )){
                        b = TRUE;

                        SetupPage->OcManager->InternalFlags |= OCMFLAG_USERCANCELED;
                        SetupPage->UserClickedCancel = TRUE;

                    }

                    SetWindowLongPtr(hdlg,DWLP_MSGRESULT,!b);
                    b = TRUE;
                    break;
            }
            break;

        case WMX_SETUP:

            switch (wParam) {

                case OCSETUPSTATE_INIT:
                    //
                    // Initialize.
                    //
                    if (SetupPage->ForceExternalProgressIndicator) {
                        _pOcExternalProgressIndicator(SetupPage,TRUE,hdlg);
                    }

                    PropSheet_SetWizButtons(GetParent(hdlg),0);

                    //
                    // If this a remove all, disable the cancel button early
                    //
                    if ((SetupPage->OcManager->SetupMode & SETUPMODE_PRIVATE_MASK) == SETUPMODE_REMOVEALL) {
                        if (!SetupPage->AllowCancel) {
                            EnableWindow(GetDlgItem(GetParent(hdlg),IDCANCEL),FALSE);
                            ShowWindow(GetDlgItem(GetParent(hdlg),IDCANCEL),SW_HIDE);
                        }
                    }

                    if (pOcSetupInitialize(SetupPage,hdlg)) {
                        PostMessage(hdlg,WMX_SETUP,OCSETUPSTATE_QUEUE,0);
                    } else {
                        PostMessage(hdlg,WMX_SETUP,OCSETUPSTATE_COPYABORT,0);
                    }
                    break;

                case OCSETUPSTATE_QUEUE:
                    //
                    // Queue files for installation.
                    //
                    pOcSetupStartWorkerThread(SetupPage,hdlg,pOcSetupQueue);
                    break;

                case OCSETUPSTATE_GETSTEP:
                    //
                    // Figure out step counts.
                    //
                    pOcSetupStartWorkerThread(SetupPage,hdlg,pOcSetupGetStepCount);
                    break;

                case OCSETUPSTATE_DOIT:

                    //
                    // Quick init of the gas guage here, because the file queue could be
                    // empty, in which case we never get WMX_TICK with wParam=0.
                    //
                    SendDlgItemMessage(
                                      hdlg,
                                      SetupPage->ControlsInfo.ProgressBar,
                                      PBM_SETRANGE,
                                      0,
                                      MAKELPARAM(0,SetupPage->StepCount)
                                      );
                    SendDlgItemMessage(
                                      hdlg,
                                      SetupPage->ControlsInfo.ProgressBar,
                                      PBM_SETPOS,
                                      0,
                                      0
                                      );

                    SetCursor(LoadCursor(NULL,IDC_ARROW));

                    //
                    // Commit the file queue and let the OCs install themselves.
                    //
                    pOcSetupStartWorkerThread(SetupPage,hdlg,pOcSetupDoIt);
                    break;


                    //
                    // Unrecoverable error in copyfile phase, abort the setup
                    //
                case OCSETUPSTATE_COPYABORT:

                    SetupPage->OcManager->InternalFlags |= OCMFLAG_FILEABORT;

                    if (SetupPage->AllowCancel
                        && SetupPage->OcManager->SetupData.OperationFlags & SETUPOP_STANDALONE) {
                        PropSheet_PressButton(GetParent(hdlg),PSBTN_CANCEL);
                    } else {
                        PropSheet_PressButton(GetParent(hdlg),PSBTN_NEXT);
                    }

                    break;


                case OCSETUPSTATE_COPYDONE:
                    //
                    // Get rid of the wizard's cancel button
                    //

                    //
                    // AndrewR -- we've already committed the file queue
                    // at this point, so we should not allow the user to cancel
                    // (since:
                    //  a) in an uninstall scenario the file state and
                    // configuration state will be out of sync
                    //  b) we don't call all of the OC components to let them know
                    // about the cancel event, and we don't want only some of the
                    // components to get a complete installation callback
                    //
                    //if(!SetupPage->AllowCancel) {
                    SetupPage->AllowCancel = FALSE;
                    pOcDisableCancel(hdlg);

                    // }
                    break;

                case OCSETUPSTATE_DONE:
                    //
                    // Done. Advance to next page in wizard.
                    //
                    PropSheet_SetWizButtons(GetParent(hdlg),PSWIZB_NEXT);
                    PropSheet_PressButton(GetParent(hdlg),PSBTN_NEXT);
#ifdef UNICODE
                    if (SetupPage->OcManager->Callbacks.SetupPerfData)
                        SetupPage->OcManager->Callbacks.SetupPerfData(TEXT(__FILE__),__LINE__,L"END_SECTION",L"OCSetup");
#endif

                    // un-subclass the progress bar. just in case
                    SetWindowLongPtr(GetDlgItem(hdlg,SetupPage->ControlsInfo.ProgressBar),
                                     GWLP_WNDPROC,
                                     (LONG_PTR)OldProgressProc);
                    //
                    // Clear user canceled flag,
                    //
                    SetupPage->OcManager->InternalFlags &= ~ OCMFLAG_USERCANCELED;
                    break;
            }

            b = TRUE;
            break;

        case WMX_TICK:

            switch (wParam) {

                case 0:
                    //
                    // The setup API queue commit routine is telling us how many 
                    // files are to be copied. We do nothing in this case, as we
                    // set the progress guage manually so that we also count
                    // delete operations in our progress guage.
                    //
                    break;

                case 1:
                    //
                    // File copied.
                    //
                    SendDlgItemMessage(hdlg,SetupPage->ControlsInfo.ProgressBar,PBM_DELTAPOS,1,0);
                    break;

                case 10:

                    //
                    // We got our private message telling us how many files are
                    // to be processed.  see comments above in the 0 case.
                    //
                    SendDlgItemMessage(
                                          hdlg,
                                          SetupPage->ControlsInfo.ProgressBar,
                                          PBM_SETRANGE,
                                          0,
                                          MAKELPARAM(0,lParam)
                                          );
                    break;

                case 500:
                    //
                    // Incoming tick request from component dll. Don't allow a broken component dll
                    // to tick the gauge more than it said it wanted to.
                    //
                    if ((SetupPage->CurrentTopLevelComponentIndex != -1)
                        && (SetupPage->ComponentTickCounts[SetupPage->CurrentTopLevelComponentIndex]
                            < SetupPage->ComponentMaxTickCounts[SetupPage->CurrentTopLevelComponentIndex])) {

                        SetupPage->ComponentTickCounts[SetupPage->CurrentTopLevelComponentIndex]++;

                        SendDlgItemMessage(hdlg,SetupPage->ControlsInfo.ProgressBar,PBM_DELTAPOS,1,0);
                    }
                    break;
            }

            b = TRUE;
            break;
    }

    return (b);
}


VOID
pOcTickSetupGauge(
                 IN POC_MANAGER OcManager
                 )

/*++

Routine Description:

    The tick gauge OC helper/callback routine calls this routine.

Arguments:

    OcManager - supplies OC Manager context.

Return Value:

    None.

--*/

{
    //
    // The ProgressTextWindow is non-NULL if we are in
    // the installation-completion phase.
    //
    if (OcManager->ProgressTextWindow) {
        SendMessage(GetParent(OcManager->ProgressTextWindow),WMX_TICK,500,0);
    }
}


BOOL
pOcSetupInitialize(
                  IN OUT PSETUP_PAGE SetupPage,
                  IN     HWND        hdlg
                  )
{
    TCHAR Text[128];

    LoadString(MyModuleHandle,IDS_INITIALIZING,Text,sizeof(Text)/sizeof(TCHAR));
    SetDlgItemText(hdlg,SetupPage->ControlsInfo.ProgressText,Text);

    // If, update the text on the billboard for the progress bar.
    if (SetupPage->OcManager->Callbacks.BillBoardSetProgressText)
    {
        SetupPage->OcManager->Callbacks.BillBoardSetProgressText(Text);
    }

    //
    // Create a setup file queue.
    //
    SetupPage->FileQueue = SetupOpenFileQueue();
    if (SetupPage->FileQueue == INVALID_HANDLE_VALUE) {

        _LogError(SetupPage->OcManager,OcErrLevFatal,MSG_OC_OOM);

        SetupPage->FileQueue = NULL;
        return (FALSE);
    }

    SetupPage->QueueContext = SetupInitDefaultQueueCallbackEx(hdlg,hdlg,WMX_TICK,0,0);
    if (!SetupPage->QueueContext) {

        _LogError(SetupPage->OcManager,OcErrLevFatal,MSG_OC_OOM);

        SetupCloseFileQueue(SetupPage->FileQueue);
        SetupPage->FileQueue = NULL;
        return (FALSE);
    }

    return (TRUE);
}


VOID
pOcSetupStartWorkerThread(
                         IN OUT PSETUP_PAGE            SetupPage,
                         IN     HWND                   hdlg,
                         IN     LPTHREAD_START_ROUTINE ThreadRoutine
                         )
{
    PGEN_THREAD_PARAMS pParams;
    GEN_THREAD_PARAMS Params;
    HANDLE h;
    DWORD id;

    if (WorkerThreadHandle) {
        CloseHandle( WorkerThreadHandle );
        WorkerThreadHandle = NULL;
    }

    if (pParams = pSetupMalloc(sizeof(GEN_THREAD_PARAMS))) {

        pParams->SetupPage = SetupPage;
        pParams->SetupPage->hdlg = hdlg;
        pParams->hdlg = hdlg;
        pParams->Async = TRUE;

        h = CreateThread(NULL,0,ThreadRoutine,pParams,0,&id);
        if (!h) {
            pSetupFree(pParams);
        } else {
            WorkerThreadHandle = h;
        }

    } else {
        h = NULL;
    }

    if (!h) {

        //
        // Just try it synchronously.
        //
        Params.SetupPage = SetupPage;
        Params.hdlg = hdlg;
        Params.Async = FALSE;
        ThreadRoutine(&Params);
    }
}

//
// a debugging routine that makes it easy to cancel at any phase of setup
//
/*
VOID CancelRoutine(
    VOID
    )
{
    static int i = 0;
    TCHAR dbg[100];

    wsprintf( dbg, TEXT("cancel routine iteration number %i \n"), i);
    OutputDebugString( dbg );

    OutputDebugString( TEXT(" waiting 5 seconds for cancel ... \n" ));
    Sleep( 1000 * 5 );
    OutputDebugString( TEXT(" done waiting for cancel ... \n" ));

    i++;
}
*/

BOOL
CheckForQueueCancel(
                   PSETUP_PAGE SetupPage
                   )
{
    BOOL bRet;

    //CancelRoutine();

    bRet = SetupPage->UserClickedCancel;

    return (bRet);
}

DWORD
pOcSetupQueue(
             IN PGEN_THREAD_PARAMS Params
             )
{
    UINT Err;
    unsigned i,child;
    OPTIONAL_COMPONENT Oc;
    TCHAR Text[128];
    DWORD RetVal;

    InterlockedIncrement( &Params->SetupPage->RefCount );

    LoadString(MyModuleHandle,IDS_BUILDINGCOPYLIST,Text,sizeof(Text)/sizeof(TCHAR));

#ifdef UNICODE
    if (Params->SetupPage->OcManager->Callbacks.SetupPerfData)
        Params->SetupPage->OcManager->Callbacks.SetupPerfData(TEXT(__FILE__),__LINE__,L"BEGIN_SECTION",Text);

    // If, update the text on the billboard for the progress bar.
    if (Params->SetupPage->OcManager->Callbacks.BillBoardSetProgressText)
    {
        Params->SetupPage->OcManager->Callbacks.BillBoardSetProgressText(Text);
    }
#endif
    SetDlgItemText(Params->hdlg,Params->SetupPage->ControlsInfo.ProgressText,Text);

    if (CheckForQueueCancel(Params->SetupPage)) {
        RetVal = NO_ERROR;
        goto exit;
    }

    //
    // Handle each component.
    //
    for (i=0; i<Params->SetupPage->OcManager->TopLevelOcCount; i++) {

        pSetupStringTableGetExtraData(
                               Params->SetupPage->OcManager->ComponentStringTable,
                               Params->SetupPage->OcManager->TopLevelOcStringIds[i],
                               &Oc,
                               sizeof(OPTIONAL_COMPONENT)
                               );

        //
        // Call the component dll once for the entire component.
        //
        Err = OcInterfaceQueueFileOps(
                                     Params->SetupPage->OcManager,
                                     Params->SetupPage->OcManager->TopLevelOcStringIds[i],
                                     NULL,
                                     Params->SetupPage->FileQueue
                                     );

        if (Err != NO_ERROR) {
            //
            // Notify user and continue.
            //
            _LogError(
                     Params->SetupPage->OcManager,
                     OcErrLevError,
                     MSG_OC_CANT_QUEUE_FILES,
                     Oc.Description,
                     Err
                     );
        }

        if (CheckForQueueCancel(Params->SetupPage)) {
            RetVal = NO_ERROR;
            goto exit;
        }

        //
        // Process each top level parent item in the tree
        //
        for (child=0; child<Params->SetupPage->OcManager->TopLevelParentOcCount; child++) {

            Err = pOcSetupQueueWorker(
                                     Params->SetupPage,
                                     Params->SetupPage->OcManager->TopLevelParentOcStringIds[child],
                                     Params->SetupPage->OcManager->TopLevelOcStringIds[i]
                                     );

            if (Err != NO_ERROR) {
                //
                // Notification is handled in the worker routine so nothing to do here.
                //
            }
        }

        if (CheckForQueueCancel(Params->SetupPage)) {
            RetVal = NO_ERROR;
            goto exit;
        }

    }

    if (CheckForQueueCancel(Params->SetupPage)) {
        RetVal = NO_ERROR;
        goto exit;
    }

    PostMessage(Params->hdlg,WMX_SETUP,OCSETUPSTATE_GETSTEP,0);

exit:

#ifdef UNICODE
    if (Params->SetupPage->OcManager->Callbacks.SetupPerfData)
        Params->SetupPage->OcManager->Callbacks.SetupPerfData(TEXT(__FILE__),__LINE__,L"END_SECTION",Text);
#endif
    pOcFreeOcSetupPage( Params->SetupPage );

    if (Params->Async) {
        pSetupFree(Params);
    }

    return (RetVal);
}


UINT
pOcSetupQueueWorker(
                   IN PSETUP_PAGE SetupPage,
                   IN LONG        StringId,
                   IN LONG        TopLevelStringId
                   )
{
    OPTIONAL_COMPONENT Oc;
    UINT Err;
    LONG Id;

    //
    // Fetch extra data for this subcomponent.
    //
    pSetupStringTableGetExtraData(
                           SetupPage->OcManager->ComponentStringTable,
                           StringId,
                           &Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    //
    // If it's a child, call the component dll.
    // If it's a parent, then spin through its children.
    //
    if (Oc.FirstChildStringId == -1) {

        if (TopLevelStringId == pOcGetTopLevelComponent(SetupPage->OcManager,StringId)) {

            Err = OcInterfaceQueueFileOps(
                                         SetupPage->OcManager,
                                         pOcGetTopLevelComponent(SetupPage->OcManager,StringId),
                                         pSetupStringTableStringFromId(SetupPage->OcManager->ComponentStringTable,StringId),
                                         SetupPage->FileQueue
                                         );

            if (Err != NO_ERROR) {
                //
                // Notify user and continue.
                //
                _LogError(
                         SetupPage->OcManager,
                         OcErrLevError,
                         MSG_OC_CANT_QUEUE_FILES,
                         Oc.Description,
                         Err
                         );
            }
        }
    } else {

        for (Id = Oc.FirstChildStringId; Id != -1; Id = Oc.NextSiblingStringId) {

            Err = pOcSetupQueueWorker(SetupPage,Id,TopLevelStringId);
            if (Err != NO_ERROR) {
                //
                // Notification is handled in the worker routine so nothing to do here.
                //
            }

            pSetupStringTableGetExtraData(
                                   SetupPage->OcManager->ComponentStringTable,
                                   Id,
                                   &Oc,
                                   sizeof(OPTIONAL_COMPONENT)
                                   );
        }
    }

    return (NO_ERROR);
}


DWORD
pOcSetupGetStepCount(
                    IN PGEN_THREAD_PARAMS Params
                    )
{
    UINT Err;
    unsigned i,child;
    OPTIONAL_COMPONENT Oc;
    UINT StepCount;
    TCHAR Text[128];
    UINT Count;

    InterlockedIncrement( &Params->SetupPage->RefCount );

    LoadString(MyModuleHandle,IDS_PREPARING,Text,sizeof(Text)/sizeof(TCHAR));
    SetDlgItemText(Params->hdlg,Params->SetupPage->ControlsInfo.ProgressText,Text);
#ifdef UNICODE
    // If, update the text on the billboard for the progress bar.
    if (Params->SetupPage->OcManager->Callbacks.BillBoardSetProgressText)
    {
        Params->SetupPage->OcManager->Callbacks.BillBoardSetProgressText(Text);
    }
    if (Params->SetupPage->OcManager->Callbacks.SetupPerfData)
        Params->SetupPage->OcManager->Callbacks.SetupPerfData(TEXT(__FILE__),__LINE__,L"BEGIN_SECTION",Text);
#endif

    Params->SetupPage->StepCount = 0;

    //
    // Handle each component.
    //
    for (i=0; i<Params->SetupPage->OcManager->TopLevelOcCount; i++) {

        //
        // Call the component dll once for the entire component.
        // Ignore any error. Later we call per-subcomponent and we'll
        // assume that any component that gives us an error has 1 step.
        //
        Err = OcInterfaceQueryStepCount(
                                       Params->SetupPage->OcManager,
                                       Params->SetupPage->OcManager->TopLevelOcStringIds[i],
                                       NULL,
                                       &Count
                                       );

        StepCount = ((Err == NO_ERROR) ? Count : 0);

        //
        // For each top level parent item in the tree find all the children
        // that belong to this component
        //
        for (child=0; child<Params->SetupPage->OcManager->TopLevelParentOcCount; child++) {

            //
            // Now call the component dll for each child subcomponent.
            //
            StepCount += pOcSetupGetStepCountWorker(
                                                   Params->SetupPage,
                                                   Params->SetupPage->OcManager->TopLevelParentOcStringIds[child],
                                                   Params->SetupPage->OcManager->TopLevelOcStringIds[i]
                                                   );
        }

        if (!StepCount) {
            //
            // Make sure each component has at least one step.
            //
            StepCount = 1;
        }

        Params->SetupPage->StepCount += StepCount;
        Params->SetupPage->ComponentTickCounts[i] = 0;
        Params->SetupPage->ComponentMaxTickCounts[i] = StepCount;
    }

    if (CheckForQueueCancel(Params->SetupPage)) {
        goto exit;
    }

    PostMessage(Params->hdlg,WMX_SETUP,OCSETUPSTATE_DOIT,0);

exit:

#ifdef UNICODE
    if (Params->SetupPage->OcManager->Callbacks.SetupPerfData)
        Params->SetupPage->OcManager->Callbacks.SetupPerfData(TEXT(__FILE__),__LINE__,L"END_SECTION",Text);
#endif
    pOcFreeOcSetupPage( Params->SetupPage );

    if (Params->Async) {
        pSetupFree(Params);
    }


    return (0);
}


UINT
pOcSetupGetStepCountWorker(
                          IN PSETUP_PAGE SetupPage,
                          IN LONG        StringId,
                          IN LONG        TopLevelStringId
                          )
{
    OPTIONAL_COMPONENT Oc;
    UINT Err;
    LONG Id;
    UINT Count;
    UINT TotalCount;

    TotalCount = 0;
    Count = 0;

    //
    // Fetch extra data for this subcomponent.
    //
    pSetupStringTableGetExtraData(
                           SetupPage->OcManager->ComponentStringTable,
                           StringId,
                           &Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    //
    // If it's a child, call the component dll.
    // If it's a parent, then spin through its children.
    //
    if (Oc.FirstChildStringId == -1) {

        //
        // Only call the leaf node if the top level component matches
        //
        if (TopLevelStringId == pOcGetTopLevelComponent(SetupPage->OcManager,StringId)) {

            Err = OcInterfaceQueryStepCount(
                                           SetupPage->OcManager,
                                           pOcGetTopLevelComponent(SetupPage->OcManager,StringId),
                                           pSetupStringTableStringFromId(SetupPage->OcManager->ComponentStringTable,StringId),
                                           &Count
                                           );

            if (Err == NO_ERROR) {
                TotalCount = Count;
            }
        }

    } else {

        for (Id = Oc.FirstChildStringId; Id != -1; Id = Oc.NextSiblingStringId) {

            TotalCount += pOcSetupGetStepCountWorker(SetupPage,Id,TopLevelStringId);

            pSetupStringTableGetExtraData(
                                   SetupPage->OcManager->ComponentStringTable,
                                   Id,
                                   &Oc,
                                   sizeof(OPTIONAL_COMPONENT)
                                   );
        }
    }

    return (TotalCount);
}

BOOL
pOcSetRenamesFlag(
                 IN POC_MANAGER OcManager
                 )
{
    HKEY hKey;
    long rslt = ERROR_SUCCESS;
#ifdef UNICODE
    rslt = RegOpenKeyEx(
                       HKEY_LOCAL_MACHINE,
                       TEXT("System\\CurrentControlSet\\Control\\Session Manager"),
                       0,
                       KEY_SET_VALUE,
                       &hKey);

    if (rslt == ERROR_SUCCESS) {
        DWORD Value = 1;
        rslt = RegSetValueEx(
                            hKey,
                            OC_ALLOWRENAME,
                            0,
                            REG_DWORD,
                            (LPBYTE)&Value,
                            sizeof(DWORD));

        RegCloseKey(hKey);

        if (rslt != ERROR_SUCCESS) {
            TRACE(( TEXT("couldn't RegSetValueEx, ec = %d\n"), rslt ));
        }

    } else {
        TRACE(( TEXT("couldn't RegOpenKeyEx, ec = %d\n"), rslt ));
    }
#endif

    return (rslt == ERROR_SUCCESS);

}

BOOL
pOcAttemptQueueAbort(
                    IN UINT Notification,
                    IN PUINT rc
                    )
{
    //
    // user has asked to abort installation.  We need to hand this request to
    // setupapi, but setupapi only handles this request from certain
    //  notifications
    //

    BOOL bHandled = FALSE;


    switch (Notification) {
        case SPFILENOTIFY_STARTQUEUE:
        case SPFILENOTIFY_STARTSUBQUEUE:
            SetLastError(ERROR_CANCELLED);
            *rc = 0;
            bHandled = TRUE;
            break;

        case SPFILENOTIFY_STARTDELETE:
        case SPFILENOTIFY_STARTBACKUP:
        case SPFILENOTIFY_STARTRENAME:
        case SPFILENOTIFY_STARTCOPY:
        case SPFILENOTIFY_NEEDMEDIA:
        case SPFILENOTIFY_COPYERROR:
        case SPFILENOTIFY_DELETEERROR:
        case SPFILENOTIFY_RENAMEERROR:
        case SPFILENOTIFY_BACKUPERROR:
            SetLastError(ERROR_CANCELLED);
            *rc = FILEOP_ABORT;
            bHandled = TRUE;
            break;
        case SPFILENOTIFY_FILEEXTRACTED:
        case SPFILENOTIFY_NEEDNEWCABINET:
        case SPFILENOTIFY_QUEUESCAN:
            SetLastError(ERROR_CANCELLED);
            *rc = ERROR_CANCELLED;
            bHandled = TRUE;
            break;
    };

    return (bHandled);

}

UINT
OcManagerQueueCallback1(
                       IN PVOID Context,
                       IN UINT  Notification,
                       IN UINT_PTR Param1,
                       IN UINT_PTR Param2
                       )
{
    PSETUP_PAGE SetupPage = Context;
    UINT i;
    BOOL b;
    TCHAR Text[MAX_PATH*2];
    PFILEPATHS pFile = (PFILEPATHS) Param1;
    PSOURCE_MEDIA sm = (PSOURCE_MEDIA)Param1;
    static BOOL UserClickedCancel;
    UINT rc = 0;
    UINT retval;

    //
    // We handle the user cancelling at the beginning of the queue callback.
    // If the user has cancelled then we don't execute any code, we just return
    // until we get a callback that allows us to cancel.
    //
    // There is a window in this code where the user might cancel after we
    // check for cancelling but before the queue callback code executes.  If we fall into
    // the WM_DESTROY block in our window proc when this occurs, we cannot send any more
    // messages to our window.  Use PostMessage below to guard against that.

    top:
    if (UserClickedCancel) {
        pOcAttemptQueueAbort(Notification,&rc);
        return (rc);
    }

    if (SetupPage->UserClickedCancel) {
        UserClickedCancel = TRUE;
    }

    if (UserClickedCancel) {
        goto top;
    }

    switch (Notification) {

        case SPFILENOTIFY_STARTSUBQUEUE:
            //
            // Tell the user what's going on.
            //
            switch (Param1) {
                case FILEOP_DELETE:
                    i = IDS_DELETING;
                    break;
                case FILEOP_RENAME:
                    i = IDS_RENAME;
                    break;
                case FILEOP_COPY:
                    i = IDS_COPYING;
                    break;
                default:
                    i = (UINT)(-1);
                    break;
            }

            if (i != (UINT)(-1)) {
                LoadString(MyModuleHandle,i,Text,sizeof(Text)/sizeof(TCHAR));
                SetDlgItemText(SetupPage->hdlg,SetupPage->ControlsInfo.ProgressText,Text);

                // If, update the text on the billboard for the progress bar.
                if (SetupPage->OcManager->Callbacks.BillBoardSetProgressText)
                {
                    SetupPage->OcManager->Callbacks.BillBoardSetProgressText(Text);
                }

            }

            //Reset SecondNeedMedia as we are about to begin copying for a particular queue

            SetupPage->SecondNeedMedia = FALSE;

            break;

        case  SPFILENOTIFY_STARTCOPY:
            lstrcpy( g_LastFileCopied, pFile->Target );
#ifdef UNICODE
            // fall through...
        case  SPFILENOTIFY_STARTDELETE:
        case  SPFILENOTIFY_STARTRENAME:
            if ((SetupPage->OcManager->SetupData.OperationFlags & SETUPOP_STANDALONE)) {
                if (!hSfp) {
                    hSfp = SfcConnectToServer( NULL );
                }
                if (hSfp) {
                    if (SfcIsFileProtected(hSfp,pFile->Target)) {
                        SfcFileException(
                                        hSfp,
                                        (PWSTR) pFile->Target,
                                        SFC_ACTION_REMOVED
                                        );
                    }
                }
            }
#endif
            break;

        case  SPFILENOTIFY_ENDCOPY:
            if (pFile->Win32Error == NO_ERROR) {
                _LogError(SetupPage->OcManager,
                          OcErrLevInfo,
                          MSG_OC_LOG_FILE_COPIED,
                          pFile->Source,
                          pFile->Target);
            } else {
                TRACE(( TEXT("OC:OcManagerQueueCallback Copy Error: %s --> %s (%d)\n"),
                        pFile->Source,
                        pFile->Target,
                        pFile->Win32Error));

                _LogError(SetupPage->OcManager,
                          OcErrLevInfo,
                          MSG_OC_LOG_FILE_COPY_FAILED,
                          pFile->Source,
                          pFile->Target,
                          pFile->Win32Error);
            }

            //Reset SecondNeedMedia as we are at the end of copying files for this media

            SetupPage->SecondNeedMedia = FALSE;

            break;

        case  SPFILENOTIFY_ENDDELETE:   // fall through
        case SPFILENOTIFY_ENDRENAME:
        case SPFILENOTIFY_ENDBACKUP:
            //
            // tick the progress gauge manually since setupapi doesn't do it 
            // for us.
            //
            SendMessage(SetupPage->hdlg,WMX_TICK,1,0);

            break;

        case  SPFILENOTIFY_DELETEERROR:    //    0x00000007
            TRACE(( TEXT("OC:OcManagerQueueCallback Delete Error: %s (%d)\n"),
                    pFile->Target,
                    pFile->Win32Error));
            break;

        case  SPFILENOTIFY_RENAMEERROR:    //    0x0000000a
            TRACE(( TEXT("OC:OcManagerQueueCallback Rename Error: %s (%d)\n"),
                    pFile->Target,
                    pFile->Win32Error));
            break;

        case  SPFILENOTIFY_COPYERROR:      //    0x0000000d
            TRACE(( TEXT("OC:OcManagerQueueCallback Copy Error: %s (%d)\n"),
                    pFile->Target,
                    pFile->Win32Error));

            break;

        case SPFILENOTIFY_NEEDMEDIA:
            TRACE(( TEXT("OC:OcManagerQueueCallback Need Media: %s - %s (%s)\n"),
                    sm->SourcePath,
                    sm->SourceFile,
                    sm->Tagfile));

            if (gLastOcManager && (gLastOcManager->InternalFlags & OCMFLAG_RUNQUIET)) {


                // Check if this is the second time we are getting a 
    
                if (TRUE == SetupPage->SecondNeedMedia) {
                    SetupPage->SecondNeedMedia = FALSE;
                    return (FILEOP_ABORT);
                }else{
                    SetupPage->SecondNeedMedia = TRUE;
                    return (FILEOP_DOIT);
                }
            }

            break;

        case SPFILENOTIFY_FILEOPDELAYED:
            TRACE(( TEXT("OC:OcManagerQueueCallback FileOpDelayed: %s\n"), pFile->Target ));
            //
            // We want to remember that there was at least one file
            // with a delayed-move, but we still want to let the
            // default callback get this notification also.
            //
            SetupPage->OcManager->InternalFlags |= OCMFLAG_ANYDELAYEDMOVES;
            SetupPage->OcManager->Callbacks.SetReboot();
            pOcSetRenamesFlag(SetupPage->OcManager);

            for (i=0; (i<SetupPage->OcManager->TopLevelOcCount); i++) {
                OcInterfaceFileBusy(
                                   SetupPage->OcManager,
                                   SetupPage->OcManager->TopLevelOcStringIds[i],
                                   (PFILEPATHS)Param1,
                                   (LPTSTR)Param2
                                   );
            }

            break;
    }

    return (SetupDefaultQueueCallback(SetupPage->QueueContext, Notification, Param1, Param2));

}


DWORD
pOcSetupDoIt(
            IN PGEN_THREAD_PARAMS Params
            )
{
    BOOL b;
    TCHAR Text[256];
    TCHAR LogText[256];
    OPTIONAL_COMPONENT Oc;
    POC_MANAGER OcManager;
    BOOL AllowCancel;
    UINT LastError = ERROR_SUCCESS;
    DWORD TotalFileCount,PartialCount;

    TRACE(( TEXT("at pOcSetupDoIt entry\n") ));

    InterlockedIncrement( &Params->SetupPage->RefCount );
    //
    // Call components to let them do pre-commit processing.
    //
    LoadString(MyModuleHandle,IDS_PREQUEUECONFIG,Text,sizeof(Text)/sizeof(TCHAR));
    SetDlgItemText(Params->hdlg,Params->SetupPage->ControlsInfo.ProgressText,Text);
#ifdef UNICODE
    // If, update the text on the billboard for the progress bar.
    if (Params->SetupPage->OcManager->Callbacks.BillBoardSetProgressText)
    {
        Params->SetupPage->OcManager->Callbacks.BillBoardSetProgressText(Text);
    }
    // Save it, because "Text" is used below and we would not end up with a matchin END_SECTION
    lstrcpy(LogText, Text);
    if (Params->SetupPage->OcManager->Callbacks.SetupPerfData)
        Params->SetupPage->OcManager->Callbacks.SetupPerfData(TEXT(__FILE__),__LINE__,L"BEGIN_SECTION",LogText);
#endif

    Params->SetupPage->OcManager->ProgressTextWindow = GetDlgItem(
                                                                 Params->hdlg,
                                                                 Params->SetupPage->ControlsInfo.ProgressText
                                                                 );

    if (CheckForQueueCancel(Params->SetupPage)) {
        goto exit;
    }

    //
    // send OC_ABOUT_TO_COMMIT_QUEUE message
    //
    pOcPreOrPostCommitProcessing(Params->SetupPage,TRUE);

    OcManager = Params->SetupPage->OcManager;
    AllowCancel = Params->SetupPage->AllowCancel;
    OcManager->ProgressTextWindow = NULL;

    if (CheckForQueueCancel(Params->SetupPage)) {
        goto exit;
    }

    //
    // Commit the file queue. We get the total number of file operations
    // so we can scale the progress indicator properly.  We do this manually
    // as setupapi only returns back the total number of copy operations, and
    // we want status on delete operations as well.
    //
    TotalFileCount = 0;
    PartialCount = 0;
    if (SetupGetFileQueueCount(Params->SetupPage->FileQueue,
		       FILEOP_COPY,
                       &PartialCount)) {
        TotalFileCount += PartialCount;
    }

    PartialCount = 0;

    if (SetupGetFileQueueCount(Params->SetupPage->FileQueue,
		       FILEOP_RENAME,
                       &PartialCount)) {
        TotalFileCount += PartialCount;
    }

    PartialCount = 0;

    if (SetupGetFileQueueCount(Params->SetupPage->FileQueue,
		       FILEOP_DELETE,
                       &PartialCount)) {
        TotalFileCount += PartialCount;
    }

    //
    // if the OC file queue is ever backup aware, add in the count
    // of files to be backed up here.
    //

    TRACE(( TEXT("OCM: %d file operations to complete\n"), TotalFileCount ));

    //
    // scale the progress gauge
    //
    PostMessage(Params->hdlg,
                WMX_TICK,
                10,Params->SetupPage->StepCount + TotalFileCount);
    

    // If, update the text on the billboard for the progress bar.
    if (Params->SetupPage->OcManager->Callbacks.BillBoardSetProgressText)
    {
        Params->SetupPage->OcManager->Callbacks.BillBoardSetProgressText(Text);
    }

    b = FALSE;

    while (! b) {
        DWORD ScanResult;

        LoadString(MyModuleHandle,IDS_FILESCAN,Text,sizeof(Text)/sizeof(TCHAR));
        SetDlgItemText(Params->hdlg,Params->SetupPage->ControlsInfo.ProgressText,Text);

        b = SetupScanFileQueue(Params->SetupPage->FileQueue,
                               SPQ_SCAN_FILE_VALIDITY | SPQ_SCAN_PRUNE_COPY_QUEUE,
                               Params->hdlg,
                               NULL,
                               NULL,
                               &ScanResult);

        //
        // if the scan result is 1, then there isn't anything to commit, the entire
        // file queue has been pruned. So we skip it.
        //
        if (ScanResult != 1) {

            if( IsWindow( Params->hdlg ) ){
                LoadString(MyModuleHandle,IDS_FILEOPS,Text,sizeof(Text)/sizeof(TCHAR));
                SetDlgItemText(Params->SetupPage->hdlg,Params->SetupPage->ControlsInfo.ProgressText,Text);
            }

            if (CheckForQueueCancel(Params->SetupPage)) {
                goto exit;
            }

            //Set the SecondNeedMedia to FALSE as we are starting a commit operation.

            Params->SetupPage->SecondNeedMedia = FALSE;

            b = SetupCommitFileQueue(
                                    Params->hdlg,
                                    Params->SetupPage->FileQueue,
                                    OcManagerQueueCallback1,
                                    Params->SetupPage
                                    );

            LastError =  GetLastError();

#ifdef UNICODE
            if (hSfp) {
                SfcClose(hSfp);
            }
#endif

        }

        if (!b) {

            TRACE(( TEXT("OC:SetupCommitFileQueue failed (LE=%d), last file copied was %s\n"),
                    LastError,
                    g_LastFileCopied ));

            pOcHelperReportExternalError(
                                        OcManager,
                                        0,               // defaults to Master Inf file
                                        0,
                                        MSG_OC_CANT_COMMIT_QUEUE,
                                        ERRFLG_OCM_MESSAGE,
                                        LastError
                                        );

            if ( LastError == ERROR_CANCELLED ||
                 LastError == ERROR_CONTROL_ID_NOT_FOUND ||
                 LastError == ERROR_OPERATION_ABORTED) {
                //
                // User canceled from a SetupAPI provided Dialog
                // when CallBack Returns FILEOP_ABORT LastError reports
                // ERROR_CONTROL_ID_NOT_FOUND if User aborts in SetupApi
                // find File Dialog you get ERROR_CANCELLED
                //

                if ( AllowCancel &&
                     (OcManager->SetupData.OperationFlags & SETUPOP_STANDALONE)) {
                    _LogError(
                             OcManager,
                             OcErrLevError|MB_ICONEXCLAMATION|MB_OK,
                             MSG_OC_USER_CANCELED,
                             LastError
                             );
                }
                //
                // this will force the cancel of setup
                //
                LastError = IDCANCEL;

            } else {

                //
                // Warn the user that it might be hazzardous to continue after copy error
                //
                LastError = _LogError(
                                     OcManager,
                                     OcErrLevError|MB_ICONEXCLAMATION|MB_OKCANCEL|MB_DEFBUTTON2,
                                     MSG_OC_CANT_COMMIT_QUEUE,
                                     LastError
                                     );

            }
            //
            // Abort the setup if the user pressed Cancel or
            // Batch mode log the error and cancel out of setup
            //
            if ( LastError == IDCANCEL
                 || OcManager->SetupData.OperationFlags & SETUPOP_BATCH) {
                PostMessage(Params->hdlg,WMX_SETUP,OCSETUPSTATE_COPYABORT,0);
                goto exit;
            } else if ( LastError == IDOK ) {
                b = TRUE;
            }

        }

    }

    //
    // put a message in the log so we know we completed all file operations
    //
    _LogError(OcManager,
              OcErrLevInfo,
              MSG_OC_LOG_QUEUE_COMPLETE
             );

    //
    // Tell the UI that we are done with the file operations
    //
    PostMessage(Params->hdlg,WMX_SETUP,OCSETUPSTATE_COPYDONE,0);
#ifdef UNICODE
    if (Params->SetupPage->OcManager->Callbacks.SetupPerfData)
        Params->SetupPage->OcManager->Callbacks.SetupPerfData(TEXT(__FILE__),__LINE__,L"END_SECTION",LogText);
#endif

    //
    // Call components to let them do post-commit processing.
    //
    LoadString(MyModuleHandle,IDS_CONFIGURING,Text,sizeof(Text)/sizeof(TCHAR));
    SetDlgItemText(Params->hdlg,Params->SetupPage->ControlsInfo.ProgressText,Text);
#ifdef UNICODE
    // If, update the text on the billboard for the progress bar.
    if (Params->SetupPage->OcManager->Callbacks.BillBoardSetProgressText)
    {
        Params->SetupPage->OcManager->Callbacks.BillBoardSetProgressText(Text);
    }
    if (Params->SetupPage->OcManager->Callbacks.SetupPerfData)
        Params->SetupPage->OcManager->Callbacks.SetupPerfData(TEXT(__FILE__),__LINE__,L"BEGIN_SECTION",Text);
#endif
    Params->SetupPage->OcManager->ProgressTextWindow = GetDlgItem(
                                                                 Params->hdlg,
                                                                 Params->SetupPage->ControlsInfo.ProgressText
                                                                 );

    if (CheckForQueueCancel(Params->SetupPage)) {
        goto exit;
    }

    pOcPreOrPostCommitProcessing(Params->SetupPage,FALSE);

    if (CheckForQueueCancel(Params->SetupPage)) {
        goto exit;
    }

    Params->SetupPage->OcManager->ProgressTextWindow = NULL;

    PostMessage(Params->hdlg,WMX_SETUP,OCSETUPSTATE_DONE,0);

#ifdef UNICODE
    if (Params->SetupPage->OcManager->Callbacks.SetupPerfData)
        Params->SetupPage->OcManager->Callbacks.SetupPerfData(TEXT(__FILE__),__LINE__,L"END_SECTION",Text);
#endif
exit:

    TRACE(( TEXT("at pOcSetupDoIt exit\n") ));

    pOcFreeOcSetupPage( Params->SetupPage );

    if (Params->Async) {
        pSetupFree(Params);
    }

    return (0);
}


VOID
pOcPreOrPostCommitProcessing(
                            IN OUT PSETUP_PAGE SetupPage,
                            IN     BOOL        PreCommit
                            )

/*++

Routine Description:

    Handle processing and notification to the component dlls before or after
    the file queue is committed. This involves calling interface dlls once
    for each top-level component, and then once for each subcomponent.

    The ordering for the top-level components is the order that the
    components were listed in the master oc inf.

    The ordering for leaf components is generally random within each
    top-level hierarchy, but 'detours' are taken when components are
    needed by other components. This ensures that components are
    called in the correct order to faciliate uninstall-type actions.

Arguments:

    SetupPage - supplies context data structure.
    PreCommit - TRUE indicates OC_ABOUT_TO_COMMIT_QUEUE is to be called,
                otherwise OC_COMPLETE_INSTALLATION is to be called.

Return Value:

    None. Errors are logged.

--*/

{
    OPTIONAL_COMPONENT Oc,AuxOc;
    unsigned i,child;

    //
    // Call each component at the "top-level" (ie, no subcomponent).
    //
    pOcTopLevelPreOrPostCommitProcessing(SetupPage,PreCommit);

    if (CheckForQueueCancel(SetupPage)) {
        return;
    }

    if (!PreCommit) {
        //
        // Make sure the components are marked as unprocessed.
        //

        MYASSERT(SetupPage->OcManager->ComponentStringTable);
        //
        // if this doesn't exist then something is hosed.
        //
        if (!SetupPage->OcManager->ComponentStringTable) {
            return;
        }
        pSetupStringTableEnum(
                       SetupPage->OcManager->ComponentStringTable,
                       &Oc,
                       sizeof(OPTIONAL_COMPONENT),
                       pOcMarkUnprocessedStringCB,
                       0
                       );
    }

    //
    // Call component dlls for each child subcomponent.
    //
    for (i=0; i<SetupPage->OcManager->TopLevelOcCount; i++) {


        pSetupStringTableGetExtraData(
                               SetupPage->OcManager->ComponentStringTable,
                               SetupPage->OcManager->TopLevelOcStringIds[i],
                               &Oc,
                               sizeof(OPTIONAL_COMPONENT)
                               );

        for (child=0; child<SetupPage->OcManager->TopLevelParentOcCount; child++) {

            pOcSetupDoItWorker(
                              SetupPage,
                              SetupPage->OcManager->TopLevelParentOcStringIds[child],
                              SetupPage->OcManager->TopLevelOcStringIds[i],
                              PreCommit
                              );
        }
    }
}


VOID
pOcTopLevelPreOrPostCommitProcessing(
                                    IN PSETUP_PAGE SetupPage,
                                    IN BOOL        PreCommit
                                    )

/*++

Routine Description:

    Call the OC_COMPLETE_INSTALLATION or OC_ABOUT_TO_COMMIT_QUEUE
    interface routine once for each top-level component.

Arguments:

    SetupPage - supplies context structure.

    PreCommit - if 0, then call OC_COMPLETE_INSTALLATION. Otherwise
        call OC_ABOUT_TO_COMMIT_QUEUE.

Return Value:

    None. Errors are logged.

--*/
{
    unsigned i;
    OPTIONAL_COMPONENT Oc;
    UINT Err;

    for (i=0; i<SetupPage->OcManager->TopLevelOcCount; i++) {

        pSetupStringTableGetExtraData(
                               SetupPage->OcManager->ComponentStringTable,
                               SetupPage->OcManager->TopLevelOcStringIds[i],
                               &Oc,
                               sizeof(OPTIONAL_COMPONENT)
                               );

        SetupPage->CurrentTopLevelComponentIndex = i;

        Err = OcInterfaceCompleteInstallation(
                                             SetupPage->OcManager,
                                             SetupPage->OcManager->TopLevelOcStringIds[i],
                                             NULL,
                                             PreCommit
                                             );

        if (Err != NO_ERROR) {
            _LogError(
                     SetupPage->OcManager,
                     OcErrLevError,
                     MSG_OC_COMP_INST_FAIL,
                     Oc.Description,
                     Err
                     );

            pOcHelperReportExternalError(
                                        SetupPage->OcManager,
                                        SetupPage->OcManager->TopLevelOcStringIds[i],
                                        0,
                                        MSG_OC_COMP_INST_FAIL,
                                        ERRFLG_OCM_MESSAGE,
                                        Oc.Description,
                                        Err
                                        );
        }
    }
}


VOID
pOcSetupDoItWorker(
                  IN PSETUP_PAGE SetupPage,
                  IN LONG        StringId,
                  IN LONG        TopLevelStringId,
                  IN BOOL        PreCommit
                  )
/*++

Routine Description:

    Call the OC_COMPLETE_INSTALLATION or OC_ABOUT_TO_COMMIT_QUEUE
    interface routine for each child of a given top-level component.

Arguments:

    SetupPage - supplies context structure.

    StringId - ID for the child component to be called

    TopLevelStringId - ID for the child's parent

    PreCommit - if 0, then call OC_COMPLETE_INSTALLATION. Otherwise
        call OC_ABOUT_TO_COMMIT_QUEUE.

Return Value:

    None. Errors are logged.

--*/
{
    OPTIONAL_COMPONENT Oc;
    UINT Err;
    LONG Id;
    unsigned i;
    LONG TopLevelIndex;
    UINT SelectionState;
    UINT InstalledState;

    //
    // Figure out the index of the top-level component associated with this
    // subcomponent.
    //
    Id = pOcGetTopLevelComponent(SetupPage->OcManager,StringId);
    TopLevelIndex = -1;
    for (i=0; i<SetupPage->OcManager->TopLevelOcCount; i++) {
        if (SetupPage->OcManager->TopLevelOcStringIds[i] == Id) {
            TopLevelIndex = i;
            break;
        }
    }

    //
    // Fetch extra data for this subcomponent.
    //
    pSetupStringTableGetExtraData(
                           SetupPage->OcManager->ComponentStringTable,
                           StringId,
                           &Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    if (Oc.FirstChildStringId == -1) {
        //
        // Leaf subcomponent.
        //
        // In the precommit case, check the subcomponents this subcomponent
        // is needed by; if there are any, process them first.
        //
        // In the postcommit case, check the subcomponents this subcomponent
        // needs; if there are any, process them first.
        //
        if (PreCommit) {
            for (i=0; i<Oc.NeededByCount; i++) {
                pOcSetupDoItWorker(
                                  SetupPage,
                                  Oc.NeededByStringIds[i],
                                  pOcGetTopLevelComponent(SetupPage->OcManager,Oc.NeededByStringIds[i]),
                                  TRUE
                                  );
            }
        } else {
            for (i=0; i<Oc.NeedsCount; i++) {
                if (Oc.NeedsStringIds[i] != StringId) {
                    pOcSetupDoItWorker(
                                      SetupPage,
                                      Oc.NeedsStringIds[i],
                                      pOcGetTopLevelComponent(SetupPage->OcManager,Oc.NeedsStringIds[i]),
                                      FALSE
                                      );
                }
            }
        }

        //
        // Fetch extra data for this subcomponent again as it might have
        // changed in the recursive call we just made.
        //
        pSetupStringTableGetExtraData(
                               SetupPage->OcManager->ComponentStringTable,
                               StringId,
                               &Oc,
                               sizeof(OPTIONAL_COMPONENT)
                               );

        //
        // If not processed already, process now.
        //
        if (!(Oc.InternalFlags & OCFLAG_PROCESSED)) {

            Oc.InternalFlags |= OCFLAG_PROCESSED;
            pSetupStringTableSetExtraData(
                                   SetupPage->OcManager->ComponentStringTable,
                                   StringId,
                                   &Oc,
                                   sizeof(OPTIONAL_COMPONENT)
                                   );

            SetupPage->CurrentTopLevelComponentIndex = TopLevelIndex;

            //
            // Set current install state to not installed, pending successful
            // outcome of the installation routine.
            //
            if (!PreCommit) {
                SelectionState = Oc.SelectionState;
                Oc.SelectionState = SELSTATE_NO;
                pOcSetOneInstallState(SetupPage->OcManager,StringId);
            }

            Err = OcInterfaceCompleteInstallation(
                                                 SetupPage->OcManager,
                                                 pOcGetTopLevelComponent(SetupPage->OcManager,StringId),
                                                 pSetupStringTableStringFromId(SetupPage->OcManager->ComponentStringTable,StringId),
                                                 PreCommit
                                                 );

            // Ignore error and ask the component
            // for the actual installation state.

            if (!PreCommit) {

                Oc.SelectionState = (Err) ? Oc.OriginalSelectionState : SelectionState;

                InstalledState = OcInterfaceQueryState(
                                                      SetupPage->OcManager,
                                                      pOcGetTopLevelComponent(SetupPage->OcManager,StringId),
                                                      pSetupStringTableStringFromId(SetupPage->OcManager->ComponentStringTable,StringId),
                                                      OCSELSTATETYPE_FINAL
                                                      );

                switch (InstalledState) {
                    case SubcompOn:
                        SelectionState = SELSTATE_YES;
                        break;
                    case SubcompOff:
                        SelectionState = SELSTATE_NO;
                        break;
                    default:
                        SelectionState = Oc.SelectionState;
                        break;
                }

                Oc.SelectionState = SelectionState;
                pSetupStringTableSetExtraData(
                                       SetupPage->OcManager->ComponentStringTable,
                                       StringId,
                                       &Oc,
                                       sizeof(OPTIONAL_COMPONENT)
                                       );

                pOcSetOneInstallState(SetupPage->OcManager,StringId);
            }

        }
    } else {
        //
        // Parent component. Spin through the children.
        //
        for (Id = Oc.FirstChildStringId; Id != -1; Id = Oc.NextSiblingStringId) {

            pOcSetupDoItWorker(SetupPage,Id,TopLevelStringId,PreCommit);

            pSetupStringTableGetExtraData(
                                   SetupPage->OcManager->ComponentStringTable,
                                   Id,
                                   &Oc,
                                   sizeof(OPTIONAL_COMPONENT)
                                   );
        }
    }
}


BOOL
pOcMarkUnprocessedStringCB(
                          IN PVOID               StringTable,
                          IN LONG                StringId,
                          IN PCTSTR              String,
                          IN POPTIONAL_COMPONENT Oc,
                          IN UINT                OcSize,
                          IN LPARAM              Unused
                          )

/*++

Routine Description:

    String table callback routine. Clears the OCFLAG_PROCESSED flag in
    the OPTIONAL_COMPONENT structure that is passed to it.

Arguments:

    String string table callback arguments.

Return Value:

    Always returns TRUE to continue enumeration.

--*/

{
    Oc->InternalFlags &= ~OCFLAG_PROCESSED;
    pSetupStringTableSetExtraData(StringTable,StringId,Oc,OcSize);
    return (TRUE);
}


VOID
_pOcExternalProgressIndicator(
                             IN PSETUP_PAGE SetupPage,
                             IN BOOL        ExternalIndicator,
                             IN HWND        hdlg
                             )
{
    POC_MANAGER OcManager;
    HWND Animation;

    OcManager = SetupPage->OcManager;

    EnableWindow(
                GetDlgItem(hdlg,SetupPage->ControlsInfo.ProgressBar),
                !ExternalIndicator
                );

    if (SetupPage->ForceExternalProgressIndicator) {
        ShowWindow(
                  GetDlgItem(hdlg,SetupPage->ControlsInfo.ProgressBar),
                  ExternalIndicator ? SW_HIDE : SW_SHOW
                  );

        ShowWindow(
                  GetDlgItem(hdlg,SetupPage->ControlsInfo.ProgressLabel),
                  ExternalIndicator ? SW_HIDE : SW_SHOW
                  );
    }

    Animation = GetDlgItem(hdlg,SetupPage->ControlsInfo.AnimationControl);

    sapiAssert( Animation != NULL );

    if (!ExternalIndicator) {
        Animate_Stop(Animation);
        Animate_Close(Animation);
    }

    EnableWindow(Animation,ExternalIndicator);
    ShowWindow(Animation,ExternalIndicator ? SW_SHOW : SW_HIDE);

    if (ExternalIndicator) {
        Animate_Open(Animation,MAKEINTRESOURCE(SetupPage->ControlsInfo.AnimationResource));
        Animate_Play(Animation,0,-1,-1);
    }
}


VOID
pOcExternalProgressIndicator(
                            IN PHELPER_CONTEXT OcManagerContext,
                            IN BOOL            ExternalIndicator
                            )
{
    POC_MANAGER OcManager;
    HWND hdlg;
    PSETUP_PAGE SetupPage;

    OcManager = OcManagerContext->OcManager;

    if (OcManager->ProgressTextWindow
        && (hdlg = GetParent(OcManager->ProgressTextWindow))
        && (SetupPage = (PSETUP_PAGE)GetWindowLongPtr(hdlg,DWLP_USER))
        && !SetupPage->ForceExternalProgressIndicator) {

        _pOcExternalProgressIndicator(SetupPage,ExternalIndicator,hdlg);
    }
}