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

/*++

Copyright (c) 1996 Microsoft Corporation

Module Name:

    ocpage.c

Abstract:

    Routines to run an optional component selection wizard page
    and friends (details, have disk, etc).

Author:

    Ted Miller (tedm) 17-Sep-1996

Revision History:

--*/

#include "precomp.h"
#pragma hdrstop

//
// Maximum number of levels in the OC hierarchy.
// 10 is really generous.
//
#define MAX_OC_LEVELS   10

//
// Max number of depenedent components displayed
// in the remove components Msgbox
//
#define MAX_DISPLAY_IDS 10
//
// Window messages.
//
#define WMX_SELSTATECHANGE  (WM_APP+0)

//
// Internal flag to force routines to turn components on or off
//
#define OCQ_FORCE               0x40000000
#define OCQ_SKIPDISKCALC        0x20000000
#define OCQ_COLLECT_NEEDS       0x10000000
#define OCO_COLLECT_NODEPENDENT OCQ_DEPENDENT_SELECTION

//
// Structure used to track parentage within the optional component page.
//
typedef struct _OCPAGE {
    //
    // OC Manager structure.
    //
    POC_MANAGER OcManager;

    //
    // Parent string id.
    //
    LONG ParentStringId;

    //
    // Information about the dialog controls on main wizard page
    // and on "details" pages.
    //
    OC_PAGE_CONTROLS WizardPageControlsInfo;
    OC_PAGE_CONTROLS DetailsPageControlsInfo;

    //
    // Pointer to actual set of controls in use.
    //
    POC_PAGE_CONTROLS ControlsInfo;

    //
    // Disk space list to use when interacting with OC DLLs.
    //
    HDSKSPC DiskSpaceList;

    //
    // Flag indicating whether we've set initial states.
    //
    BOOL AlreadySetInitialStates;

    //
    // Format string for 'space needed' text, fetched from the
    // dialog at init time (something like "%u.%u MB").
    //
    TCHAR SpaceNeededTextFormat[64];

    //
    // Format string for 'x or y components selected' text, fetched from the
    // dialog at init time (something like "%u of %u components selected").
    //
    TCHAR InstalledCountTextFormat[100];

    //
    // String ids that we collect during selection changes to ask
    // the user if it is Ok to change these as well
    //
    PLONG StringIds;
    UINT  StringIdsCount;

    //
    // Values we sock away in case the user cancels at an OC details page,
    // so we can easily restore things.
    //
    HDSKSPC OldDiskSpaceList;
    PVOID OldComponentStrTab;

} OCPAGE, *POCPAGE;


//
// Structure used when enumerating the component string table to populate
// the list box.
//
typedef struct _POPULATE_ENUM_PARAMS {
    //
    // Master context structure.
    //
    POCPAGE OcPage;

    //
    // List box being populated.
    //
    HWND ListBox;

    //
    // String ID of desired parent. This is how we deal with only
    // those subcomponents we actually care about.
    //
    LONG DesiredParent;

} POPULATE_ENUM_PARAMS, *PPOPULATE_ENUM_PARAMS;

WNDPROC OldListBoxProc;

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

BOOL
pAskUserOkToChange(
                  IN HWND    hDlg,
                  IN LONG    OcStringId,
                  IN POCPAGE OcPage,
                  IN BOOL   TurningOn
                  );

VOID
pOcDrawLineInListBox(
                    IN POCPAGE         OcPage,
                    IN DRAWITEMSTRUCT *Params
                    );

VOID
pOcListBoxHighlightChanged(
                          IN     HWND    hdlg,
                          IN OUT POCPAGE OcPage,
                          IN     HWND    ListBox
                          );

VOID
pOcSetInstalledCountText(
                        IN HWND                hdlg,
                        IN POCPAGE             OcPage,
                        IN POPTIONAL_COMPONENT OptionalComponent,   OPTIONAL
                        IN LONG                OcStringId
                        );

VOID
pOcListBoxChangeSelectionState(
                              IN     HWND    hdlg,
                              IN OUT POCPAGE OcPage,
                              IN     HWND    ListBox
                              );

VOID
pOcInvalidateRectInListBox(
                          IN HWND    ListBox,
                          IN LPCTSTR OptionalComponent    OPTIONAL
                          );

BOOL
pChangeSubcomponentState(
                        IN  POCPAGE OcPage,
                        IN  HWND    ListBox,
                        IN  LONG    SubcomponentStringId,
                        IN  UINT    Pass,
                        IN  UINT    NewState,
                        IN  UINT    Flags
                        );

VOID
pOcUpdateParentSelectionStates(
                              IN POC_MANAGER OcManager,
                              IN HWND        ListBox,             OPTIONAL
                              IN LONG        SubcomponentStringId
                              );

VOID
pOcUpdateSpaceNeededText(
                        IN POCPAGE OcPage,
                        IN HWND    hdlg
                        );

BOOL
pOcIsDiskSpaceOk(
                IN POCPAGE OcPage,
                IN HWND    hdlg
                );

LRESULT
pOcListBoxSubClassWndProc(
                         IN HWND   hwnd,
                         IN UINT   msg,
                         IN WPARAM wParam,
                         IN LPARAM lParam
                         );

BOOL
pOcPagePopulateListBox(
                      IN POCPAGE OcPage,
                      IN HWND    ListBox,
                      IN LONG    DesiredParent
                      );

BOOL
pOcPopulateListBoxStringTableCB(
                               IN PVOID                 StringTable,
                               IN LONG                  StringId,
                               IN LPCTSTR               String,
                               IN POPTIONAL_COMPONENT   OptionalComponent,
                               IN UINT                  OptionalComponentSize,
                               IN PPOPULATE_ENUM_PARAMS Params
                               );

LONG
pOcGetTopLevelComponent(
                       IN POC_MANAGER OcManager,
                       IN LONG        StringId
                       );

VOID
pOcGetMbAndMbTenths(
                   IN  LONGLONG Number,
                   OUT PUINT    MbCount,
                   OUT PUINT    MbTenthsCount
                   );

VOID
pOcSetStates(
            IN OUT POCPAGE OcPage
            );

BOOL
pOcSetStatesStringWorker(
                        IN LONG         StringId,
                        IN UINT         OverRideState,
                        IN POCPAGE      OcPage
                        );

BOOL
pOcSetStatesStringCB(
                    IN PVOID               StringTable,
                    IN LONG                StringId,
                    IN LPCTSTR             String,
                    IN POPTIONAL_COMPONENT Oc,
                    IN UINT                OcSize,
                    IN LPARAM              lParam
                    );

BOOL
pOcSetStatesStringCB2(
                     IN PVOID               StringTable,
                     IN LONG                StringId,
                     IN LPCTSTR             String,
                     IN POPTIONAL_COMPONENT Oc,
                     IN UINT                OcSize,
                     IN LPARAM              lParam
                     );

BOOL
pOcSetNeededComponentState(
                          IN LONG         StringId,
                          IN UINT         OverRideState,
                          IN POCPAGE      OcPage
                          );

UINT
GetComponentState(
                 IN POCPAGE OcPage,
                 IN LONG    StringId
                 );

#ifdef _OC_DBG
VOID
pOcPrintStates(
              IN POCPAGE OcPage
              );
#endif

HPROPSHEETPAGE
OcCreateOcPage(
              IN PVOID             OcManagerContext,
              IN POC_PAGE_CONTROLS WizardPageControlsInfo,
              IN POC_PAGE_CONTROLS DetailsPageControlsInfo
              )

/*++

Routine Description:

    This routine creates the optional component selection page using
    a particular dialog template.

Arguments:

    OcManagerContext - supplies Optional Component Manager context,
        as returned by OcInitialize().

    WizardPageControlsInfo - supplies information about the controls in the
        template for the top-level/wizard page.

    DetailsPageControlsInfo - supplies information about the controls in the
        template for the top-level/wizard page.

Return Value:

    Handle to newly created property sheet page, or NULL if failure
    (assume out of memory in this case).

--*/

{
    PROPSHEETPAGE Page;
    HPROPSHEETPAGE hPage;
    POCPAGE OcPage;
    TCHAR buffer[256];

    //
    // Allocate and initialize the OCPAGE structure.
    //
    OcPage = pSetupMalloc(sizeof(OCPAGE));
    if (!OcPage) {
        goto c0;
    }
    ZeroMemory(OcPage,sizeof(OCPAGE));

    OcPage->OcManager = OcManagerContext;
    OcPage->WizardPageControlsInfo = *WizardPageControlsInfo;
    OcPage->DetailsPageControlsInfo = *DetailsPageControlsInfo;
    OcPage->ControlsInfo = &OcPage->WizardPageControlsInfo;
    OcPage->ParentStringId = -1;

    //
    // Create the disk space list object.
    //
    OcPage->DiskSpaceList = SetupCreateDiskSpaceList(0,0,SPDSL_DISALLOW_NEGATIVE_ADJUST);
    if (!OcPage->DiskSpaceList) {
        goto c1;
    }

    //
    // Initialize the property sheet page parameters.
    //
    Page.dwSize = sizeof(PROPSHEETPAGE);
    Page.dwFlags = PSP_DEFAULT;
    Page.hInstance = WizardPageControlsInfo->TemplateModule;
    Page.pszTemplate = WizardPageControlsInfo->TemplateResource;
    Page.pfnDlgProc = pOcPageDlgProc;
    Page.lParam = (LPARAM)OcPage;
    Page.pszHeaderTitle = NULL;
    Page.pszHeaderSubTitle = NULL;

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

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

    //
    // Create the property sheet page itself.
    //
    hPage = CreatePropertySheetPage(&Page);
    if (!hPage) {
        goto c2;
    }

    return (hPage);

    c2:
    if (Page.pszHeaderTitle) {
        free((LPTSTR)Page.pszHeaderTitle);
    }
    if (Page.pszHeaderSubTitle) {
        free((LPTSTR)Page.pszHeaderSubTitle);
    }
    SetupDestroyDiskSpaceList(OcPage->DiskSpaceList);
    c1:
    pSetupFree(OcPage);
    c0:
    return (NULL);
}


INT_PTR
CALLBACK
pOcPageDlgProc(
              IN HWND   hdlg,
              IN UINT   msg,
              IN WPARAM wParam,
              IN LPARAM lParam
              )

/*++

Routine Description:

    Dialog procedure for the OC selection page.

Arguments:

    Standard dialog procedure arguments.

Return Value:

    Standard dialog procedure return value.

--*/

{
    BOOL b;
    POCPAGE OcPage;
    NMHDR *NotifyParams;
    HWND ListBox;
    HIMAGELIST ImageList;
    static BOOL UserClickedCancelOnThisPage = FALSE;
    MSG msgTemp;
    HCURSOR OldCursor;

    //
    // Get pointer to OcPage 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.
    //
    if (OcPage = (POCPAGE)GetWindowLongPtr(hdlg,DWLP_USER)) {
        ListBox = GetDlgItem(hdlg,OcPage->ControlsInfo->ListBox);
    } else {
        ListBox = NULL;
    }
    b = FALSE;

    switch (msg) {

        case WM_INITDIALOG:

            //
            // Get the pointer to the OC Manager context structure and stick it
            // in a window long.
            //
            OcPage = (POCPAGE)((PROPSHEETPAGE *)lParam)->lParam;
            ListBox = GetDlgItem(hdlg,OcPage->ControlsInfo->ListBox);
            SetWindowLongPtr(hdlg,DWLP_USER,(LPARAM)OcPage);

            //
            // Subclass the listview.
            //
            OldListBoxProc = (WNDPROC)SetWindowLongPtr(ListBox,GWLP_WNDPROC,(LONG_PTR)pOcListBoxSubClassWndProc);

            //
            // Populate the listbox.
            //
            pOcPagePopulateListBox(OcPage,ListBox,OcPage->ParentStringId);

            //
            // Fetch the space needed text.
            //
            GetDlgItemText(
                          hdlg,
                          OcPage->ControlsInfo->SpaceNeededText,
                          OcPage->SpaceNeededTextFormat,
                          sizeof(OcPage->SpaceNeededTextFormat)/sizeof(TCHAR)
                          );

            GetDlgItemText(
                          hdlg,
                          OcPage->ControlsInfo->InstalledCountText,
                          OcPage->InstalledCountTextFormat,
                          sizeof(OcPage->InstalledCountTextFormat)/sizeof(TCHAR)
                          );

            pOcUpdateSpaceNeededText(OcPage,hdlg);

            //
            // If this has a parent component, then assume it's a details page
            // and set the window title to the description of the parent.
            // If it has no parent, then assume it's the top-level guy and
            // set the instructions text, which is too long for the rc file.
            //
            if (OcPage->ParentStringId == -1) {

                TCHAR Instr[1024];

                FormatMessage(
                             FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_IGNORE_INSERTS,
                             MyModuleHandle,
                             MSG_OC_PAGE_INSTRUCTIONS,
                             0,
                             Instr,
                             sizeof(Instr)/sizeof(TCHAR),
                             NULL
                             );

                SetDlgItemText(hdlg,OcPage->ControlsInfo->InstructionsText,Instr);

            } else {

                OPTIONAL_COMPONENT Oc;

                pSetupStringTableGetExtraData(
                                       OcPage->OcManager->ComponentStringTable,
                                       OcPage->ParentStringId,
                                       &Oc,
                                       sizeof(OPTIONAL_COMPONENT)
                                       );

                SetWindowText(hdlg,Oc.Description);

                //
                // Set component list header
                //
                {
                    TCHAR FormatString[150];
                    TCHAR Title[1000];

                    LoadString(
                              MyModuleHandle,
                              IDS_SUBCOMP_OF,
                              FormatString,
                              sizeof(FormatString)/sizeof(TCHAR)
                              );

                    wsprintf(Title,FormatString,Oc.Description);
                    SetDlgItemText(hdlg,OcPage->ControlsInfo->ComponentHeaderText,Title);
                }
            }

            b = TRUE;
            break;

        case WM_DESTROY:

            if (OcPage && OcPage->ControlsInfo == &OcPage->WizardPageControlsInfo) {

                if (UserClickedCancelOnThisPage) {

                    pOcFreeOcSetupPage(OcPage->OcManager->OcSetupPage);
                    OcPage->OcManager->OcSetupPage = NULL;
                }

                SetupDestroyDiskSpaceList(OcPage->DiskSpaceList);
                OcPage->DiskSpaceList = NULL;

                if (OcPage->StringIds) {
                    pSetupFree(OcPage->StringIds);
                    OcPage->StringIds = NULL;
                }

                pSetupFree(OcPage);
                SetWindowLongPtr(hdlg,DWLP_USER,(LPARAM)NULL);
                break;
            }

            break;

        case WM_MEASUREITEM:
            //
            // Height is height of text/small icon, plus space for a border.
            //
            {
                HDC hdc;
                SIZE size;
                int cy;

                hdc = GetDC(hdlg);
                if (hdc) {
                   SelectObject(hdc,(HFONT)SendMessage(GetParent(hdlg),WM_GETFONT,0,0));
                   GetTextExtentPoint32(hdc,TEXT("W"),1,&size);
                   ReleaseDC(hdlg,hdc);
                } else {
                   size.cy = 0;
                }

                cy = GetSystemMetrics(SM_CYSMICON);

                ((MEASUREITEMSTRUCT *)lParam)->itemHeight = max(size.cy,cy)
                                                            + (2*GetSystemMetrics(SM_CYBORDER));
            }
            b = TRUE;
            break;

        case WM_DRAWITEM:

            pOcDrawLineInListBox(OcPage,(DRAWITEMSTRUCT *)lParam);
            b = TRUE;
            break;

        case WM_COMMAND:

            switch (LOWORD(wParam)) {

                case IDOK:

                    if (HIWORD(wParam) == BN_CLICKED) {
                        //
                        // Only possible from details dialog.
                        //
                        EndDialog(hdlg,TRUE);
                        b = TRUE;
                    }
                    break;

                case IDCANCEL:

                    if (HIWORD(wParam) == BN_CLICKED) {
                        //
                        // Only possible from details dialog.
                        //
                        EndDialog(hdlg,FALSE);
                        b = TRUE;
                    }
                    break;

                default:

                    if ((LOWORD(wParam) == OcPage->ControlsInfo->DetailsButton) && (HIWORD(wParam) == BN_CLICKED)) {
                        //
                        // Details button. Fake out WM_INITDIALOG so lParam is right.
                        //
                        OCPAGE NewOcPage;
                        PROPSHEETPAGE Page;
                        int i;

                        SetCursor(LoadCursor(NULL,IDC_WAIT));

                        i = (int)SendMessage(ListBox,LB_GETCURSEL,0,0);

                        NewOcPage = *OcPage;
                        NewOcPage.ControlsInfo = &NewOcPage.DetailsPageControlsInfo;
                        NewOcPage.ParentStringId = (LONG)SendMessage(ListBox,LB_GETITEMDATA,i,0);

                        //
                        // Preserve the disk space list and component string table
                        // in case the user cancels the details page. Then we can
                        // easily restore things.
                        //
                        OcPage->OldDiskSpaceList = SetupDuplicateDiskSpaceList(
                                                                              NewOcPage.DiskSpaceList,
                                                                              0,0,0
                                                                              );

                        OcPage->OldComponentStrTab = pSetupStringTableDuplicate(
                                                                         OcPage->OcManager->ComponentStringTable
                                                                         );


                        Page.lParam = (LPARAM)&NewOcPage;

                        i = (int)DialogBoxParam(
                                               NewOcPage.DetailsPageControlsInfo.TemplateModule,
                                               NewOcPage.DetailsPageControlsInfo.TemplateResource,
                                               hdlg,
                                               pOcPageDlgProc,
                                               (LPARAM)&Page
                                               );

                        if (i == TRUE) {

                            SetupDestroyDiskSpaceList(OcPage->OldDiskSpaceList);
                            OcPage->DiskSpaceList = NewOcPage.DiskSpaceList;

                            pSetupStringTableDestroy(OcPage->OldComponentStrTab);
                            OcPage->OldComponentStrTab = NULL;

                            //
                            // Force repaint of the listbox, which redraws the checkboxes.
                            //
                            pOcInvalidateRectInListBox(ListBox,NULL);

                            //
                            // Update count of installed subcomponents.
                            //
                            pOcSetInstalledCountText(
                                                    hdlg,
                                                    OcPage,
                                                    NULL,
                                                    (LONG)SendMessage(ListBox,LB_GETITEMDATA,SendMessage(ListBox,LB_GETCURSEL,0,0),0)
                                                    );

                        } else {

                            pSetupStringTableDestroy(OcPage->OcManager->ComponentStringTable);
                            OcPage->OcManager->ComponentStringTable = OcPage->OldComponentStrTab;

                            SetupDestroyDiskSpaceList(NewOcPage.DiskSpaceList);
                            NewOcPage.DiskSpaceList = NULL;
                            OcPage->DiskSpaceList = OcPage->OldDiskSpaceList;
                        }
                        OcPage->OldDiskSpaceList = NULL;
                        OcPage->OldComponentStrTab = NULL;

                        //
                        // It won't hurt anything to do this even in the cancel/failure case,
                        // and this will update the space available.
                        //
                        pOcUpdateSpaceNeededText(OcPage,hdlg);

                        SetCursor(LoadCursor(NULL,IDC_ARROW));

                        b = TRUE;
                    }

                    if (LOWORD(wParam) == OcPage->ControlsInfo->ListBox) {

                        switch (HIWORD(wParam)) {

                            case LBN_DBLCLK:
                                //
                                // Double-click is the same as hitting the details button.
                                // First make sure the details button is enabled.
                                //
                                if (IsWindowEnabled(GetDlgItem(hdlg,OcPage->ControlsInfo->DetailsButton))) {

                                    SetCursor(LoadCursor(NULL,IDC_WAIT));

                                    PostMessage(
                                               hdlg,
                                               WM_COMMAND,
                                               MAKEWPARAM(OcPage->ControlsInfo->DetailsButton,BN_CLICKED),
                                               (LPARAM)GetDlgItem(hdlg,OcPage->ControlsInfo->DetailsButton)
                                               );

                                    SetCursor(LoadCursor(NULL,IDC_ARROW));
                                }
                                b = TRUE;
                                break;

                            case LBN_SELCHANGE:

                                SetCursor(LoadCursor(NULL,IDC_WAIT));
                                pOcListBoxHighlightChanged(hdlg,OcPage,ListBox);
                                SetCursor(LoadCursor(NULL,IDC_ARROW));
                                b = TRUE;
                                break;
                        }
                    }
            }
            break;

        case WM_NOTIFY:

            NotifyParams = (NMHDR *)lParam;

            switch (NotifyParams->code) {

                case PSN_QUERYCANCEL:
                    if (OcPage->OcManager->SetupData.OperationFlags & SETUPOP_STANDALONE) {

                        b = FALSE;
                        OcPage->OcManager->InternalFlags |= OCMFLAG_USERCANCELED;
                        UserClickedCancelOnThisPage = TRUE;

                        SetWindowLongPtr(
                                        hdlg,
                                        DWLP_MSGRESULT,
                                        b
                                        );
                    }

                    b = TRUE;
                    break;

                case PSN_SETACTIVE:

                    //
                    // Set states based on mode bits, if necessary.
                    //

                    OldCursor = SetCursor(LoadCursor (NULL, IDC_WAIT));

                    if (!OcPage->AlreadySetInitialStates) {
                        if ( OcPage->DiskSpaceList  ) {
                            SetupDestroyDiskSpaceList(OcPage->DiskSpaceList);
                            OcPage->DiskSpaceList=NULL;
                        }
                        OcPage->DiskSpaceList = SetupCreateDiskSpaceList(0,0,SPDSL_DISALLOW_NEGATIVE_ADJUST);
                        sapiAssert(OcPage->DiskSpaceList);

                        pOcSetStates(OcPage);
                        OcPage->AlreadySetInitialStates = TRUE;
                    }
#ifdef _OC_DBG
                    pOcPrintStates(OcPage);
#endif
                    pOcUpdateSpaceNeededText(OcPage,hdlg);

                    //
                    // we want to empty the message cue to make sure that
                    // people will see this page, and not accidentally click
                    // next because they were antsy
                    //
                    while (PeekMessage(&msgTemp,NULL,WM_MOUSEFIRST,WM_MOUSELAST,PM_REMOVE));
                    while (PeekMessage(&msgTemp,NULL,WM_KEYFIRST,WM_KEYLAST,PM_REMOVE));
                    SetCursor(OldCursor);

                    if (OcPage->OcManager->SetupData.OperationFlags & SETUPOP_STANDALONE) {
                        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);
                    }

                    // turn off 'back' button if this is the first page

                    PropSheet_SetWizButtons(GetParent(hdlg),
                                            (OcPage->OcManager->InternalFlags & OCMFLAG_NOPREOCPAGES) ? PSWIZB_NEXT : PSWIZB_BACK | PSWIZB_NEXT);

                    //
                    // See whether any component wants to skip this page
                    // or if we are running in unattended mode.
                    // If so, disallow activation and move to next page;
                    // if not then fall through to allow activation of the page.
                    //
                    if (((OcPage->OcManager->SetupData.OperationFlags & SETUPOP_BATCH)
                         || pOcDoesAnyoneWantToSkipPage(OcPage->OcManager,OcPageComponentHierarchy))
                        && pOcIsDiskSpaceOk(OcPage,hdlg)) {

                        //
                        // Skiping this page...
                        // Set Initial State to false because when we
                        // back up from the next page we will go to the
                        // Previos page.
                        //
                        OcPage->AlreadySetInitialStates = FALSE;
                        SetWindowLongPtr(hdlg,DWLP_MSGRESULT,-1);
                    } else {
                        SetWindowLongPtr(hdlg,DWLP_MSGRESULT,0);
                    }
                    b = TRUE;
                    break;

                case PSN_WIZNEXT:
                    //
                    // Check disk space. If not OK, stop here.
                    // Otherwise allow advancing.
                    //
                    SetWindowLongPtr(hdlg,DWLP_MSGRESULT,pOcIsDiskSpaceOk(OcPage,hdlg) ? 0 : -1);
                    b = TRUE;
                    break;

                case PSN_KILLACTIVE:
                    //
                    // Restore the wizard's cancel button if we removed it earlier
                    //
                    if (OcPage->OcManager->SetupData.OperationFlags & SETUPOP_STANDALONE) {
                        ShowWindow(GetDlgItem(GetParent(hdlg),IDCANCEL),SW_SHOW);
                        EnableWindow(GetDlgItem(GetParent(hdlg),IDCANCEL),TRUE);
                    }
                    // pass through

                case PSN_WIZBACK:
                case PSN_WIZFINISH:
                    //
                    // Allow activation/motion.
                    //
                    SetWindowLongPtr(hdlg,DWLP_MSGRESULT,0);
                    b = TRUE;
                    break;
            }
            break;

        case WMX_SELSTATECHANGE:
            //
            // User changed the selection state of an item.
            //
            SetCursor(LoadCursor(NULL,IDC_WAIT));
            pOcListBoxChangeSelectionState(hdlg,OcPage,ListBox);

            pOcSetInstalledCountText(
                                    hdlg,
                                    OcPage,
                                    NULL,
                                    (LONG)SendMessage(ListBox,LB_GETITEMDATA,SendMessage(ListBox,LB_GETCURSEL,0,0),0)
                                    );

            SetCursor(LoadCursor(NULL,IDC_ARROW));
            b = TRUE;

            break;
    }

    return (b);
}


LRESULT
pOcListBoxSubClassWndProc(
                         IN HWND   hwnd,
                         IN UINT   msg,
                         IN WPARAM wParam,
                         IN LPARAM lParam
                         )

/*++

Routine Description:

    Subclass window procecure for listbox controls to handle the following:

    - Highlighting/selection of an item when the user clicks its state icon

    - Spacebar needs to be interpreted as a click on the state icon.

Arguments:

    Standard window procedure arguments.

Return Value:

    Standard window procedure return value.

--*/

{
    int index;
    LRESULT l;

    if (OldListBoxProc == NULL) {
        OutputDebugString(TEXT("Warning: old list box proc is NULL\n"));
        sapiAssert(FALSE && "Warning: old list box proc is NULL\n");
    }

    switch (msg) {

        case WM_LBUTTONDOWN:
            //
            // We want to let the standard list box window proc
            // set selection regardless of what else we do.
            //
            l = CallWindowProc(OldListBoxProc,hwnd,msg,wParam,lParam);

            //
            // If we're over a state icon, then toggle selection state.
            //
            if (LOWORD(lParam) < GetSystemMetrics(SM_CXSMICON)) {
                if (SendMessage(hwnd, LB_ITEMFROMPOINT, 0, lParam) < SendMessage(hwnd, LB_GETCOUNT, 0, 0)) {
                    PostMessage(GetParent(hwnd),WMX_SELSTATECHANGE,0,0);
                }
            }
            break;

        case WM_LBUTTONDBLCLK:
            //
            // Ignore double-clicks over the state icon.
            //
            if (LOWORD(lParam) < GetSystemMetrics(SM_CXSMICON)) {
                l = 0;
            } else {
                l = CallWindowProc(OldListBoxProc,hwnd,msg,wParam,lParam);
            }
            break;

        case WM_KEYDOWN:
            //
            // Catch space bar and treat as a click on the state icon.
            //
            if (wParam == VK_SPACE) {
                PostMessage(GetParent(hwnd),WMX_SELSTATECHANGE,0,0);
                l = 0;
            } else {
                l = CallWindowProc(OldListBoxProc,hwnd,msg,wParam,lParam);
            }
            break;

        default:
            //
            // Let the standard listview window proc handle it.
            //
            l = CallWindowProc(OldListBoxProc,hwnd,msg,wParam,lParam);
            break;
    }

    return (l);
}


VOID
pOcDrawLineInListBox(
                    IN POCPAGE         OcPage,
                    IN DRAWITEMSTRUCT *Params
                    )

/*++

Routine Description:

    Paint a line in the owner-draw listbox, including a state icon,
    mini-icon, and text.

Arguments:

    OcPage - supplies OC page context.

    Params - supplies the draw-item structure.

Return Value:

    None.

--*/

{
    TCHAR Text[MAXOCDESC];
    TCHAR Text2[128];
    SIZE Size;
    int OldMode;
    DWORD OldBackColor,OldTextColor;
    OPTIONAL_COMPONENT Oc;
    UINT IconId;
    int x;
    UINT Length;
    UINT Mb,Tenths;
    TCHAR Dll[MAX_PATH];
    LPCTSTR pDll,Resource;
    LPTSTR p;

    if ((int)Params->itemID < 0) {
        return;
    }

    pSetupStringTableGetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           (LONG)Params->itemData,
                           &Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    Length = (UINT)SendMessage(Params->hwndItem,LB_GETTEXT,Params->itemID,(LPARAM)Text),
             GetTextExtentPoint32(Params->hDC,Text,Length,&Size);

    if (Params->itemAction != ODA_FOCUS) {

        OldMode = GetBkMode(Params->hDC);

        OldBackColor = SetBkColor(
                                 Params->hDC,
                                 GetSysColor((Params->itemState & ODS_SELECTED) ? COLOR_HIGHLIGHT : COLOR_WINDOW)
                                 );

        OldTextColor = SetTextColor(
                                   Params->hDC,
                                   GetSysColor((Params->itemState & ODS_SELECTED) ? COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT)
                                   );

        //
        // Fill in the background (before mini-icon is drawn!)
        //
        ExtTextOut(Params->hDC,0,0,ETO_OPAQUE,&Params->rcItem,NULL,0,NULL);

        //
        // Draw check box mini-icon.
        //
        switch (Oc.SelectionState) {

            case SELSTATE_NO:
                IconId = 13;
                break;

            case SELSTATE_YES:
                IconId = 12;
                break;

            case SELSTATE_PARTIAL:
                IconId = 25;
                break;

            default:
                IconId = 0;
                break;
        }

        x = SetupDiDrawMiniIcon(
                               Params->hDC,
                               Params->rcItem,
                               IconId,
                               (Params->itemState & ODS_SELECTED) ? MAKELONG(DMI_BKCOLOR, COLOR_HIGHLIGHT) : 0
                               );

        Params->rcItem.left += x;

        //
        // Draw mini-icon for this OC and move string accordingly
        //
        if ((INT)Oc.IconIndex < 0) {
            //
            // Component-supplied miniicon. We query the component dll for the bitmap,
            // which gets added to the mini icon list in setupapi, and thus we can
            // use SetupDiDrawMiniIcon(). Save the index for future use -- we only
            // go through this code path once per subcomponent.
            //
            if (Oc.IconIndex == (UINT)(-2)) {

                pOcFormSuitePath(OcPage->OcManager->SuiteName,Oc.IconDll,Dll);
                pDll = Dll;
                Resource = MAKEINTRESOURCE(_tcstoul(Oc.IconResource,&p,10));
                //
                // If the char that stopped the conversion in _tcstoul is
                // not the terminating nul then the value is not a valid
                // base-10 number; assume it's a name in string form.
                //
                if (*p) {
                    Resource = Oc.IconResource;
                }
            } else {
                pDll = NULL;
                Resource = NULL;
            }

            Oc.IconIndex = pOcCreateComponentSpecificMiniIcon(
                                                             OcPage->OcManager,
                                                             pOcGetTopLevelComponent(OcPage->OcManager,(LONG)Params->itemData),
                                                             pSetupStringTableStringFromId(
                                                                                    OcPage->OcManager->ComponentStringTable,
                                                                                    (LONG)Params->itemData
                                                                                    ),
                                                             x-2,
                                                             GetSystemMetrics(SM_CYSMICON),
                                                             pDll,
                                                             Resource
                                                             );

            pSetupStringTableSetExtraData(
                                   OcPage->OcManager->ComponentStringTable,
                                   (LONG)Params->itemData,
                                   &Oc,
                                   sizeof(OPTIONAL_COMPONENT)
                                   );
        }

        x = SetupDiDrawMiniIcon(
                               Params->hDC,
                               Params->rcItem,
                               Oc.IconIndex,
                               (Params->itemState & ODS_SELECTED) ? MAKELONG(DMI_BKCOLOR, COLOR_HIGHLIGHT) : 0
                               );

        //
        // Draw the text transparently on top of the background
        //
        SetBkMode(Params->hDC,TRANSPARENT);

        ExtTextOut(
                  Params->hDC,
                  x + Params->rcItem.left,
                  Params->rcItem.top + ((Params->rcItem.bottom - Params->rcItem.top) - Size.cy) / 2,
                  0,
                  NULL,
                  Text,
                  Length,
                  NULL
                  );

        pOcGetMbAndMbTenths(Oc.SizeApproximation,&Mb,&Tenths);
        LoadString(MyModuleHandle,IDS_MB_AND_TENTHS,Text2,sizeof(Text2)/sizeof(TCHAR));
        wsprintf(Text,Text2,Mb,locale.DecimalSeparator,Tenths);
        GetTextExtentPoint32(Params->hDC,Text,lstrlen(Text),&Size);
        Params->rcItem.left = Params->rcItem.right - Size.cx - 8;

        ExtTextOut(
                  Params->hDC,
                  Params->rcItem.left,
                  Params->rcItem.top + ((Params->rcItem.bottom - Params->rcItem.top) - Size.cy) / 2,
                  0,
                  NULL,
                  Text,
                  lstrlen(Text),
                  NULL
                  );

        //
        // Restore hdc colors.
        //
        SetBkColor(Params->hDC,OldBackColor);
        SetTextColor(Params->hDC,OldTextColor);
        SetBkMode(Params->hDC,OldMode);
    }

    if ((Params->itemAction == ODA_FOCUS) || (Params->itemState & ODS_FOCUS)) {
        DrawFocusRect(Params->hDC,&Params->rcItem);
    }
}


VOID
pOcListBoxHighlightChanged(
                          IN     HWND    hdlg,
                          IN OUT POCPAGE OcPage,
                          IN     HWND    ListBox
                          )

/*++

Routine Description:

    This routine handles a change in the highlight in the listbox
    control in the oc page. It enables or disables the details button
    based on whether the newly selected component has children
    subcomponents, and changes the tip text.

Arguments:

    hdlg - supplies window handle of OC page

    OcPage - supplies OC page context structure

    ListBox - supplies window handle of list view control in hdlg

Return Value:

    None.

--*/

{
    int i;
    OPTIONAL_COMPONENT Oc;

    //
    // Fetch the optional component data for the highlighted/slected item.
    //
    i = (int)SendMessage(ListBox,LB_GETCURSEL,0,0);
    if (i < 0) {
        return;
    }

    pSetupStringTableGetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           (LONG)SendMessage(ListBox,LB_GETITEMDATA,i,0),
                           &Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    //
    // Enable/disable the details button.
    // The selected item's lParam is the string id for the selected item.
    //
    EnableWindow(
                GetDlgItem(hdlg,OcPage->ControlsInfo->DetailsButton),
                Oc.FirstChildStringId != -1
                );

    //
    // Change the tip text.
    //
    SetDlgItemText(hdlg,OcPage->ControlsInfo->TipText,Oc.Tip);

    //
    // Set up the count of installed subcomponents.
    //
    pOcSetInstalledCountText(hdlg,OcPage,&Oc,0);
}


VOID
pOcSetInstalledCountText(
                        IN HWND                hdlg,
                        IN POCPAGE             OcPage,
                        IN POPTIONAL_COMPONENT OptionalComponent,   OPTIONAL
                        IN LONG                OcStringId
                        )
{
    TCHAR Text[256];
    UINT TotalCount;
    UINT SelectedCount;
    HWND TextWindow;
    DWORD Args[2];
    OPTIONAL_COMPONENT Oc;
    BOOL b;

    if (OptionalComponent) {
        Oc = *OptionalComponent;
    } else {
        pSetupStringTableGetExtraData(
                               OcPage->OcManager->ComponentStringTable,
                               OcStringId,
                               &Oc,
                               sizeof(OPTIONAL_COMPONENT)
                               );
    }

    TextWindow = GetDlgItem(hdlg,OcPage->ControlsInfo->InstalledCountText);

    //
    // Set up the count ("1 of 3 items selected").
    // If this is not a parent component, then hide that text item.
    //
    if (Oc.FirstChildStringId == -1) {
        ShowWindow(TextWindow,SW_HIDE);
    } else {
        ShowWindow(TextWindow,SW_SHOW);

        //
        // Examine all child components to see how many of them are in
        // a selected state (selected or partially selected). We only count
        // direct children, not children of children, etc.
        //
        TotalCount = 0;
        SelectedCount = 0;
        b = TRUE;

        pSetupStringTableGetExtraData(
                               OcPage->OcManager->ComponentStringTable,
                               Oc.FirstChildStringId,
                               &Oc,
                               sizeof(OPTIONAL_COMPONENT)
                               );

        do {
            TotalCount++;
            if (Oc.SelectionState != SELSTATE_NO) {
                SelectedCount++;
            }

            if (Oc.NextSiblingStringId == -1) {
                b = FALSE;
            } else {
                pSetupStringTableGetExtraData(
                                       OcPage->OcManager->ComponentStringTable,
                                       Oc.NextSiblingStringId,
                                       &Oc,
                                       sizeof(OPTIONAL_COMPONENT)
                                       );
            }
        } while (b);

        Args[0] = SelectedCount;
        Args[1] = TotalCount;

        //
        // Use FormatMessage since order of numbers could change from
        // language to language; wsprintf isn't good enough.
        //
        FormatMessage(
                     FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                     OcPage->InstalledCountTextFormat,
                     0,
                     0,
                     Text,
                     sizeof(Text)/sizeof(TCHAR),
                     (va_list *)Args
                     );

        SetWindowText(TextWindow,Text);
    }
}


VOID
pOcListBoxChangeSelectionState(
                              IN     HWND    hdlg,
                              IN OUT POCPAGE OcPage,
                              IN     HWND    ListBox
                              )

/*++

Routine Description:

    This routine handles a change in selection state for an item.
    Selection state refers to whether the user has placed or cleared
    a checkbox next to an item in the listbox.

    It is assumed that the currently highlighted item is the one
    we want to operate on.

    Selecting/deselecting a component involves calling through the
    installation DLL interface to inform the component's installation DLL
    that a change in selection state has taken place, updating disk space
    requirements, etc.

Arguments:

    hdlg - supplies window handle of OC page

    OcPage - supplies OC page context structure

    ListBox - supplies window handle of listbox control in hdlg

Return Value:

    None.

--*/

{
    OPTIONAL_COMPONENT Oc;
    BOOL TurningOn;
    DWORD b;
//  UINT  state;
    int i;
    LONG StringId;

    //
    // Fetch the optional component data for the highlighted/slected item.
    //
    i = (int)SendMessage(ListBox,LB_GETCURSEL,0,0);
    if (i < 0) {
        return;
    }

    StringId = (LONG)SendMessage(ListBox,LB_GETITEMDATA,i,0);

    //
    // Figure out whether the item is being turned on or off.
    // If the state is deselected then we're turning it on.
    // Otherwise it's partially or fully selected and we're turning it off.
    //
    pSetupStringTableGetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           StringId,
                           &Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    TurningOn = (Oc.SelectionState == SELSTATE_NO);
    //
    // Tell the user about needs and validate that he wants to continue.
    // turn on or off the needed components.
    //

    OcPage->StringIds = NULL;
    OcPage->StringIdsCount = 0;

    //
    // Do it.
    //
    if (TurningOn) {
        b = pChangeSubcomponentState(OcPage,
                                     ListBox,
                                     StringId,
                                     1,
                                     SELSTATE_YES,
                                     OCQ_ACTUAL_SELECTION|OCQ_COLLECT_NEEDS);

        if (b) {
            if (b = pAskUserOkToChange(hdlg, StringId, OcPage, TurningOn)) {
                pChangeSubcomponentState(OcPage,
                                         ListBox,
                                         StringId,
                                         2,
                                         SELSTATE_YES,
                                         OCQ_ACTUAL_SELECTION);
            }
        }
    } else {
        b = pChangeSubcomponentState(OcPage,
                                     ListBox,
                                     StringId,
                                     1,
                                     SELSTATE_NO,
                                     OCQ_ACTUAL_SELECTION|OCQ_COLLECT_NEEDS);

        if (b) {
            if (b = pAskUserOkToChange(hdlg, StringId, OcPage, TurningOn)) {
                pChangeSubcomponentState(OcPage,
                                         ListBox,
                                         StringId,
                                         2,
                                         SELSTATE_NO,
                                         OCQ_ACTUAL_SELECTION);
            }
        }
    }

    if (b) {
        //
        // Refresh space needed text.
        //
        pOcUpdateSpaceNeededText(OcPage,hdlg);
    }
}

BOOL
pAskUserOkToChange(
                  IN HWND    hDlg,
                  IN LONG    SubcomponentStringId,
                  IN POCPAGE OcPage,
                  IN BOOL AddComponents
                  )

/*++

Routine Description:

    This routine asks the user if it ok to turn off all needed subcomponents

Arguments:

    hDlg                 - parent dialog handle for the messagebox
    SubcomponentStringId - string id of the component that is being changed
    OcPage        - supplies OC page context info.
    AddComponents - TRUE if we're adding components, FALSE if they are being
                    removed

Return Value:

    Boolean value indicating whether the routine was successful.

--*/

{
    BOOL b = TRUE;
    UINT n;
    UINT Id;
    TCHAR buffer[2024];
    TCHAR caption[256];
    LPCTSTR pArgs;
    OPTIONAL_COMPONENT OptionalComponent;

    //
    // Only display warning if there are dependents or
    // user is removing components
    //
    if ( OcPage->StringIdsCount == 0 || AddComponents ) {
        return b;
    }

    pSetupStringTableGetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           SubcomponentStringId,
                           &OptionalComponent,
                           sizeof(OPTIONAL_COMPONENT));

    //
    // Format the first Half of the message with the component name
    //
    pArgs = OptionalComponent.Description;

    n = FormatMessage(
                     FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                     MyModuleHandle,
                     MSG_OC_PAGE_DEPENDENTS1,
                     0,
                     buffer,
                     sizeof(buffer)/sizeof(TCHAR),
                     (va_list *)&pArgs
                     );


    //
    // Add each dependent component to the message
    // Only add as many components as we have room for
    // Leave roon on the end of buffer for the last message.
    //

    for (Id = 0; Id < OcPage->StringIdsCount
        && n < (sizeof(buffer)/sizeof(TCHAR) - 200 ); Id++)  {

        //
        // Only allow so many components in the messgebox, otherwise will
        // be larger then a VGA display
        //
        if ( Id > MAX_DISPLAY_IDS ) {

            n = lstrlen(buffer);
            FormatMessage(
                         FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                         MyModuleHandle,
                         MSG_OC_PAGE_DEPENDENTS2,
                         0,
                         &buffer[n],
                         (sizeof(buffer)-n)/sizeof(TCHAR),
                         (va_list *)NULL
                         );
            break;

        }
        pSetupStringTableGetExtraData(
                               OcPage->OcManager->ComponentStringTable,
                               OcPage->StringIds[Id],
                               &OptionalComponent,
                               sizeof(OPTIONAL_COMPONENT)
                               );

        //
        // Skip this item if it is a dependent of the Parent, we can arrive
        // at this situation when dependents of the parent needs other
        // dependents. The Collection code can not detect this.
        //
        if (  OptionalComponent.ParentStringId != SubcomponentStringId ) {
            OPTIONAL_COMPONENT ParentOc;
            UINT ParentId;

            //
            // Scan the parentenal chain until we find a match or run out of parents
            // if there is a match then this dependent is the same dependent as the
            // the target component
            //
            ParentId = OptionalComponent.ParentStringId;
            while (ParentId != -1) {

                pSetupStringTableGetExtraData(
                                       OcPage->OcManager->ComponentStringTable,
                                       ParentId,
                                       &ParentOc,
                                       sizeof(OPTIONAL_COMPONENT)
                                       );

                if ( ParentOc.ParentStringId == SubcomponentStringId ) {
                    goto skip;
                }
                ParentId = ParentOc.ParentStringId;
            }


            n += lstrlen(OptionalComponent.Description);
            lstrcat(buffer, OptionalComponent.Description);
            lstrcat(buffer, _T("\n"));
            b = FALSE;
            skip:;

        }
    }

    //
    // Continue if any components got by the Parent and dependent screen
    //
    if ( ! b ) {
        //
        // Add the last half of the message
        //
        n = lstrlen(buffer);
        FormatMessage(
                     FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                     MyModuleHandle,
                     MSG_OC_PAGE_DEPENDENTS3,
                     0,
                     &buffer[n],
                     (sizeof(buffer)-n)/sizeof(TCHAR),
                     (va_list *)NULL
                     );

        //
        // Returns codes from MessageBox()
        //
        *caption = 0;
        LoadString(MyModuleHandle, IDS_SETUP, caption, sizeof(caption)/sizeof(TCHAR));
        sapiAssert(*caption);

        b = (MessageBox(hDlg,
                        buffer,
                        caption,
                        MB_APPLMODAL | MB_ICONINFORMATION | MB_YESNO) == IDYES);
    }

    if (OcPage->StringIds) {
        pSetupFree(OcPage->StringIds);
        OcPage->StringIds = NULL;
        OcPage->StringIdsCount = 0;

    }
    return b;
}

BOOL
pChangeSubcomponentState(
                        IN  POCPAGE OcPage,
                        IN  HWND    ListBox,
                        IN  LONG    SubcomponentStringId,
                        IN  UINT    Pass,
                        IN  UINT    NewState,
                        IN  UINT    Flags
                        )

/*++

Routine Description:

    This routine turns on or off a subcomponent and all needed subcomponents
    and child subcomponents.

Arguments:

    OcPage - supplies OC page context info.

    SubcomponentStringId - supplies string id for subcomponent to be turned on.

    Pass - Supplies an ordinal value that controls operation of this routine.

        Pass = 1: do not actually turn on the subcomponents, but instead
                  perform a dry-run wherein subcomponent installation DLLs
                  are asked whether they will allow the selection.

        Pass = 2: actually turn on the subcomponents and update the
                  selection state in the optional component structure.

    NewState - indicates the new state, SELSTATE_YES or SELSTATE_NO.

    Flags - supplies misc flags

Return Value:

    Boolean value indicating whether the routine was successful.

--*/

{
    UINT n;
    BOOL b;
    BOOL any;
    LONG l;
    UINT SaveState;
    UINT state;
    OPTIONAL_COMPONENT Subcomponent;
    OPTIONAL_COMPONENT OptionalComponent;

    state = NewState;

    pSetupStringTableGetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           SubcomponentStringId,
                           &OptionalComponent,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    //
    // If the subcomponent is already in the desired state, do nothing.
    //
    if ((OptionalComponent.SelectionState == NewState)
        || (OptionalComponent.InternalFlags & OCFLAG_STATECHANGE)) {
        return (TRUE);
    }

    //
    // Save the state so we can back out in case of failure,
    // then set the "state change in progress" flag.
    //
    SaveState = OptionalComponent.SelectionState;
    OptionalComponent.InternalFlags |= OCFLAG_STATECHANGE;
    pSetupStringTableSetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           SubcomponentStringId,
                           &OptionalComponent,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    // ask the component whether it will allow being turned on.

    b = OcInterfaceQueryChangeSelState(
                                      OcPage->OcManager,
                                      pOcGetTopLevelComponent(OcPage->OcManager,SubcomponentStringId),
                                      pSetupStringTableStringFromId(OcPage->OcManager->ComponentStringTable,SubcomponentStringId),
                                      (NewState != SELSTATE_NO),
                                      (Pass == 1) ? Flags : Flags  & ~(OCQ_ACTUAL_SELECTION)
                                      );

    if (!b)
        goto Backout_ExtraData;

    //
    // Next, turn on needed/needed-by components.
    // and turn off excluded/excluded-by components
    //
    if (NewState == SELSTATE_YES) {
        for (n=0; n<OptionalComponent.NeedsCount; n++) {
            b = pChangeSubcomponentState(
                                        OcPage,
                                        ListBox,
                                        OptionalComponent.NeedsStringIds[n],
                                        Pass,
                                        NewState,
                                        Flags & ~(OCQ_ACTUAL_SELECTION|OCO_COLLECT_NODEPENDENT));

            if (!b) {
                goto Backout_ExtraData;
            }
        }
    } else if (NewState == SELSTATE_NO) {
        for (n=0; n<OptionalComponent.NeededByCount; n++) {
            b = pChangeSubcomponentState(
                                        OcPage,
                                        ListBox,
                                        OptionalComponent.NeededByStringIds[n],
                                        Pass,
                                        NewState,
                                        Flags & ~(OCQ_ACTUAL_SELECTION|OCO_COLLECT_NODEPENDENT));

            if (!b) {
                goto Backout_ExtraData;
            }
        }
    }

    // handle exclusives

    if (NewState != SELSTATE_NO) {
        for (n=0; n<OptionalComponent.ExcludedByCount; n++) {
            b = pChangeSubcomponentState(
                                        OcPage,
                                        ListBox,
                                        OptionalComponent.ExcludedByStringIds[n],
                                        Pass,
                                        SELSTATE_NO,
                                        Flags & OCO_COLLECT_NODEPENDENT & ~(OCQ_ACTUAL_SELECTION));

            if (!b) {
                goto Backout_ExtraData;
            }
        }
        for (n=0; n<OptionalComponent.ExcludeCount; n++) {
            b = pChangeSubcomponentState(
                                        OcPage,
                                        ListBox,
                                        OptionalComponent.ExcludeStringIds[n],
                                        Pass,
                                        SELSTATE_NO,
                                        Flags & OCO_COLLECT_NODEPENDENT & ~(OCQ_ACTUAL_SELECTION));

            if (!b) {
                goto Backout_ExtraData;
            }
        }
    }

    //
    // Turn off Collect needs if this is the top level selection or the
    // dependent of the toplevel item
    //
    if ( Flags & OCQ_ACTUAL_SELECTION ) {
        Flags |= OCO_COLLECT_NODEPENDENT;
    }

    //
    // Now turn on/off all subcomponents.
    //
    any = (OptionalComponent.FirstChildStringId == -1) ? TRUE : FALSE;
    for (l = OptionalComponent.FirstChildStringId; l != -1; l = Subcomponent.NextSiblingStringId) {
        b = pChangeSubcomponentState(
                                    OcPage,
                                    ListBox,
                                    l,
                                    Pass,
                                    NewState,
                                    Flags  & ~OCQ_ACTUAL_SELECTION);

        if (b)
            any = TRUE;

        pSetupStringTableGetExtraData(
                               OcPage->OcManager->ComponentStringTable,
                               l,
                               &Subcomponent,
                               sizeof(OPTIONAL_COMPONENT)
                               );
    }

    // if all changes were rejected - fail

    if (!any) {
        b = FALSE;
        goto Backout_ExtraData;
    }

    // load the return value and do the work

    b = TRUE;

    switch (Pass) {

        case 1:
            //
            // Component says it's ok add this string ID to the list of Dependents
            // Only if the user is making the selection
            //
            if (    (Flags & OCQ_COLLECT_NEEDS)         // Are we checking
                    &&  !(Flags & OCO_COLLECT_NODEPENDENT ) // dependents of the Selection
                    &&  !(Flags & OCQ_ACTUAL_SELECTION )    // The current selections
               ) {

                LONG *p;
                INT count = (INT)OcPage->StringIdsCount;
                BOOL Found = FALSE;

                //
                // Search the list of dependent components
                // Skip if the current component or the parent of the current component
                // All ready is in the list
                //
                while (count--  ) {

                    if ( (OcPage->StringIds[count] == SubcomponentStringId)
                         || (OcPage->StringIds[count] == OptionalComponent.ParentStringId) ){
                        Found = TRUE;
                        break;
                    }
                }

                if ( !Found ) {
                    if (OcPage->StringIds) {
                        p = pSetupRealloc(
                                     OcPage->StringIds,
                                     (OcPage->StringIdsCount+1) * sizeof(LONG)
                                     );
                    } else {
                        OcPage->StringIdsCount = 0;
                        p = pSetupMalloc(sizeof(LONG));
                    }
                    if (p) {
                        OcPage->StringIds = (PVOID)p;
                        OcPage->StringIds[OcPage->StringIdsCount++] = SubcomponentStringId;
                    } else {
                        _LogError(OcPage->OcManager,OcErrLevFatal,MSG_OC_OOM);
                        return (FALSE);
                    }
                }
            }
            goto Backout_ExtraData;
            break;

        case 2:
            //
            // In pass 2, we update the states in the optional component structures
            // and request the component DLL put its stuff on the disk space list.
            // (The component itself is called only for leaf nodes. We do not call
            // down to the subcomponent's DLL for parent components).
            //

            // check one more time to see if the state change wasn't as expected

            if (OptionalComponent.FirstChildStringId != -1)
                state = GetComponentState(OcPage, SubcomponentStringId);

            OptionalComponent.SelectionState = state;
            OptionalComponent.InternalFlags &= ~OCFLAG_STATECHANGE;

            pSetupStringTableSetExtraData(
                                   OcPage->OcManager->ComponentStringTable,
                                   SubcomponentStringId,
                                   &OptionalComponent,
                                   sizeof(OPTIONAL_COMPONENT)
                                   );

            if (ListBox) {
                pOcInvalidateRectInListBox(ListBox,OptionalComponent.Description);
            }

            if ((OptionalComponent.FirstChildStringId == -1) && !(Flags & OCQ_SKIPDISKCALC)) {

                OcInterfaceCalcDiskSpace(
                                        OcPage->OcManager,
                                        pOcGetTopLevelComponent(OcPage->OcManager,SubcomponentStringId),
                                        pSetupStringTableStringFromId(OcPage->OcManager->ComponentStringTable,SubcomponentStringId),
                                        OcPage->DiskSpaceList,
                                        (NewState != SELSTATE_NO)
                                        );
            }

            pOcUpdateParentSelectionStates(OcPage->OcManager,ListBox,SubcomponentStringId);
            b = TRUE;
            break;
    }

    return (b);

    Backout_ExtraData:

    OptionalComponent.SelectionState = SaveState;
    OptionalComponent.InternalFlags &= ~OCFLAG_STATECHANGE;

    pSetupStringTableSetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           SubcomponentStringId,
                           &OptionalComponent,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    return (b);
}


VOID
pOcUpdateParentSelectionStates(
                              IN POC_MANAGER OcManager,
                              IN HWND        ListBox,             OPTIONAL
                              IN LONG        SubcomponentStringId
                              )

/*++

Routine Description:

    Examines parent subcomponents of a given component and determines
    the parent states. For example if only some of a parent's children
    are selected, then the parent's state is partially selected.

    Structures are updated and if necessary the relevent items in the
    list box are invalidated to force their checkboxes to be repainted.

Arguments:

    OcManager - supplies OC Manager page context.

    ListBox - supplies window handle of list box.

    SubcomponentStringId - supplies string identifier in the component
        string table, for the subcomponent whose parent(s) state(s) are
        to be checked and updated.

Return Value:

    None.

--*/

{
    UINT Count;
    UINT FullySelectedCount;
    UINT DeselectedCount;
    LONG l,m;
    OPTIONAL_COMPONENT OptionalComponent,Subcomponent;
    BOOL Changed;

    pSetupStringTableGetExtraData(
                           OcManager->ComponentStringTable,
                           SubcomponentStringId,
                           &OptionalComponent,
                           sizeof(OPTIONAL_COMPONENT)
                           );


    for (l = OptionalComponent.ParentStringId; l != -1; l = OptionalComponent.ParentStringId) {

        pSetupStringTableGetExtraData(
                               OcManager->ComponentStringTable,
                               l,
                               &OptionalComponent,
                               sizeof(OPTIONAL_COMPONENT)
                               );

        //
        // Examine all children of this parent subcomponent.
        // If all of them are fully selected, then the parent state is
        // fully selected. If all of them are deselected then the parent state
        // is deselected. Any other case means partially selected.
        //
        Count = 0;
        FullySelectedCount = 0;
        DeselectedCount = 0;

        for (m = OptionalComponent.FirstChildStringId; m != -1; m = Subcomponent.NextSiblingStringId) {

            pSetupStringTableGetExtraData(
                                   OcManager->ComponentStringTable,
                                   m,
                                   &Subcomponent,
                                   sizeof(OPTIONAL_COMPONENT)
                                   );

            //
            // Only count viewable components
            //
            if (!(Subcomponent.InternalFlags & OCFLAG_HIDE)) {
                Count++;

                if (Subcomponent.SelectionState == SELSTATE_YES) {
                    FullySelectedCount++;
                } else {
                    if (Subcomponent.SelectionState == SELSTATE_NO) {
                        DeselectedCount++;
                    }
                }
            }
        }

        if (Count && (Count == FullySelectedCount)) {
            Changed = (OptionalComponent.SelectionState != SELSTATE_YES);
            OptionalComponent.SelectionState = SELSTATE_YES;
        } else {
            if (Count == DeselectedCount) {
                Changed = (OptionalComponent.SelectionState != SELSTATE_NO);
                OptionalComponent.SelectionState = SELSTATE_NO;
            } else {
                Changed = (OptionalComponent.SelectionState != SELSTATE_PARTIAL);
                OptionalComponent.SelectionState = SELSTATE_PARTIAL;
            }
        }

        pSetupStringTableSetExtraData(
                               OcManager->ComponentStringTable,
                               l,
                               &OptionalComponent,
                               sizeof(OPTIONAL_COMPONENT)
                               );

        //
        // Force repaint of the list to get the checkbox state right
        // if the state changed and the item is in the current listbox.
        //
        if (Changed && ListBox) {
            pOcInvalidateRectInListBox(ListBox,OptionalComponent.Description);
        }
    }
}


VOID
pOcInvalidateRectInListBox(
                          IN HWND    ListBox,
                          IN LPCTSTR OptionalComponentName    OPTIONAL
                          )
{
    int i;
    RECT Rect;

    if (OptionalComponentName) {

        i = (int)SendMessage(
                            ListBox,
                            LB_FINDSTRINGEXACT,
                            (WPARAM)(-1),
                            (LPARAM)OptionalComponentName
                            );

        if (i >= 0) {
            SendMessage(ListBox,LB_GETITEMRECT,i,(LPARAM)&Rect);
            InvalidateRect(ListBox,&Rect,FALSE);
        }
    } else {
        InvalidateRect(ListBox,NULL,FALSE);
    }
}


VOID
pOcUpdateSpaceNeededText(
                        IN POCPAGE OcPage,
                        IN HWND    hdlg
                        )

/*++

Routine Description:

    Updates the space needed/space available text on the current
    oc page. Assumes that space needed and available refer to the drive
    where the system is installed.

Arguments:

    OcPage - supplies OC page context.

    hdlg - supplies handle to current oc page dialog.

Return Value:

    None.

--*/

{
    TCHAR Text[128];
    LONGLONG Value;
    DWORD ValueMB;
    DWORD ValueMBTenths;
    TCHAR Drive[MAX_PATH];
    BOOL b;
    DWORD spc,bps,freeclus,totalclus;

    // We check the return code of GetWindowsDirectory to make Prefix happy.

    if (0 == GetWindowsDirectory(Drive,MAX_PATH))
        return;


    //
    // Needed first.
    //
    Drive[2] = 0;
    b = SetupQuerySpaceRequiredOnDrive(OcPage->DiskSpaceList,Drive,&Value,0,0);
    if (!b || (Value < 0)) {
        Value = 0;
    }

    pOcGetMbAndMbTenths(Value,&ValueMB,&ValueMBTenths);
    wsprintf(Text,OcPage->SpaceNeededTextFormat,ValueMB,locale.DecimalSeparator,ValueMBTenths);
    SetDlgItemText(hdlg,OcPage->ControlsInfo->SpaceNeededText,Text);

    //
    // Available next.
    //
    Drive[2] = TEXT('\\');
    Drive[3] = 0;

    if (GetDiskFreeSpace(Drive,&spc,&bps,&freeclus,&totalclus)) {
        Value = ((LONGLONG)(spc*bps)) * freeclus;
    } else {
        Value = 0;
    }

    pOcGetMbAndMbTenths(Value,&ValueMB,&ValueMBTenths);
    wsprintf(Text,OcPage->SpaceNeededTextFormat,ValueMB,locale.DecimalSeparator,ValueMBTenths);
    SetDlgItemText(hdlg,OcPage->ControlsInfo->SpaceAvailableText,Text);
}


BOOL
pOcIsDiskSpaceOk(
                IN POCPAGE OcPage,
                IN HWND    hdlg
                )

/*++

Routine Description:

    This routine checks the space required against the space available,
    for the system drive only (that's the only one the user sees on the
    oc page so it's the only one we check here).

    If there's not enough space, a message box is generated.

Arguments:

    OcPage - supplies OC page context structure.

    hdlg - supplies handle to page in oc manager wizard.

Return Value:

    Boolean value indicating whether disk space is sufficient.

--*/

{
    BOOL b;
    TCHAR Drive[3*MAX_PATH];
    TCHAR caption[256];
    LONGLONG FreeSpace,NeededSpace;
    ULARGE_INTEGER freespace,totalspace,unused;
    DWORD spc,bps,freeclus,totclus;
    HMODULE k32;
    BOOL (WINAPI * pGetSpace)(LPCTSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER);

    if (!GetWindowsDirectory(Drive,MAX_PATH)) {
       return(FALSE);
    }

    b = FALSE;

    if (k32 = LoadLibrary(TEXT("KERNEL32"))) {

        pGetSpace = (PVOID)GetProcAddress(
                                         k32,
#ifdef UNICODE
                                         "GetDiskFreeSpaceExW"
#else
                                         "GetDiskFreeSpaceExA"
#endif
                                         );

        if (pGetSpace) {
            if (b = pGetSpace(Drive,&freespace,&totalspace,&unused)) {
                FreeSpace = (LONGLONG)freespace.QuadPart;
            }
        }

        FreeLibrary(k32);
    }

    if (!b) {
        Drive[3] = 0;
        if (GetDiskFreeSpace(Drive,&spc,&bps,&freeclus,&totclus)) {
            FreeSpace = (LONGLONG)(spc * bps * (DWORDLONG)freeclus);
        } else {
            FreeSpace = 0;
        }
    }

    Drive[2] = 0;
    b = SetupQuerySpaceRequiredOnDrive(OcPage->DiskSpaceList,Drive,&NeededSpace,0,0);
    if (!b || (NeededSpace < 0)) {
        NeededSpace = 0;
    }

    if (FreeSpace < NeededSpace) {

        spc = (DWORD)(UCHAR)Drive[0];

        FormatMessage(
                     FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                     MyModuleHandle,
                     MSG_OC_PAGE_NODISKSPACE,
                     0,
                     Drive,
                     sizeof(Drive)/sizeof(TCHAR),
                     (va_list *)&spc
                     );

        OcPage->OcManager->Callbacks.LogError(OcErrLevInfo, Drive, NULL);

        //
        // If Batch mode log the error and ignore
        //
        if ( OcPage->OcManager->SetupData.OperationFlags & SETUPOP_BATCH ) {
            b = TRUE;
        } else {
            *caption = 0;
            LoadString(MyModuleHandle, IDS_SETUP, caption, sizeof(caption)/sizeof(TCHAR));
            sapiAssert(*caption);

            MessageBox(WizardDialogHandle,
                       Drive,
                       caption,
                       MB_ICONINFORMATION | MB_OK);

            b = FALSE;
        }

    } else {
        b = TRUE;
    }

    return (b);
}


BOOL
pOcPagePopulateListBox(
                      IN POCPAGE OcPage,
                      IN HWND    ListBox,
                      IN LONG    DesiredParent
                      )

/*++

Routine Description:

    This routine add one item to a listbox control for every subcomponent
    that has a given subcomponent as its parent. (In other words it populates
    the listbox for a specific level in the hierarchy.)

    This includes handling the small icons and selection state icons.

    The 0th element is selected.

Arguments:

    OcPage - supplies OC page context structure.

    List - supplies handle to list box control to be populated.

    DesiredParent - supplies string id of subcomponent that is the parent
        of the level we care about. -1 indicates the topmost level.

Return Value:

    Boolean value indicating whether population was successful.
    If FALSE, the caller can assume OOM.

--*/

{
    OPTIONAL_COMPONENT OptionalComponent;
    POPULATE_ENUM_PARAMS EnumParams;
    BOOL b;

    //
    // The string table enum callback does the real work.
    //
    EnumParams.OcPage = OcPage;
    EnumParams.ListBox = ListBox;
    EnumParams.DesiredParent = DesiredParent;

    b = pSetupStringTableEnum(
                       OcPage->OcManager->ComponentStringTable,
                       &OptionalComponent,
                       sizeof(OPTIONAL_COMPONENT),
                       (PSTRTAB_ENUM_ROUTINE)pOcPopulateListBoxStringTableCB,
                       (LPARAM)&EnumParams
                       );

    SendMessage(ListBox,LB_SETCURSEL,0,0);
    PostMessage(
               GetParent(ListBox),
               WM_COMMAND,
               MAKEWPARAM(OcPage->ControlsInfo->ListBox,LBN_SELCHANGE),
               (LPARAM)ListBox
               );
    return (b);
}


BOOL
pOcPopulateListBoxStringTableCB(
                               IN PVOID                 StringTable,
                               IN LONG                  StringId,
                               IN LPCTSTR               String,
                               IN POPTIONAL_COMPONENT   OptionalComponent,
                               IN UINT                  OptionalComponentSize,
                               IN PPOPULATE_ENUM_PARAMS Params
                               )

/*++

Routine Description:

    String table enumeration callback routine, used when populating
    the listbox with items for subcomponents that are relevent at
    a given level in the OC hierarchy.

    We check to see whether the parent of the optional component is
    the parent we care about before processing. If so, we add the item
    to the listbox.

Arguments:

    Standard string table enumeration callback routine arguments.

Return Value:

    Boolean value indicating whether enumeration should continue.

--*/

{
    int i;
    BOOL b;

    //
    // If the parent is not the desired parent, nothing to do.
    //
    if ((OptionalComponent->InfStringId == -1)
        || (OptionalComponent->ParentStringId != Params->DesiredParent)
        || (OptionalComponent->InternalFlags & OCFLAG_HIDE)) {
        return (TRUE);
    }

    //
    // Initialize the item structure that tells the listview control
    // what to do.
    //
    b = FALSE;
    i = (int)SendMessage(Params->ListBox,LB_ADDSTRING,0,(LPARAM)OptionalComponent->Description);
    if (i != -1) {
        b = (SendMessage(Params->ListBox,LB_SETITEMDATA,i,StringId) != LB_ERR);
    }

    return (b);
}


LONG
pOcGetTopLevelComponent(
                       IN POC_MANAGER OcManager,
                       IN LONG        StringId
                       )

/*++

Routine Description:

    Given a string id for an optional component subcomponent,
    locate the top-level component for the subcomponent.

    The top-level component is the subcomponent whose parent is -1.

Arguments:

    OcManager - supplies OC Manager context structure.

    StringId - supplies id for subcomponent whose top-level parent is desired.
        Note that StringId may itself be a top-level subcomponent.

Return Value:

    String ID of top-level subcomponent.

--*/

{
    OPTIONAL_COMPONENT Oc;

    pSetupStringTableGetExtraData(
                           OcManager->ComponentStringTable,
                           StringId,
                           &Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    // if the result is 0, then the component is
    // a top level component without an inf file

    if (!Oc.TopLevelStringId)
        return StringId;
    else
        return Oc.TopLevelStringId;
}


VOID
pOcGetMbAndMbTenths(
                   IN  LONGLONG Number,
                   OUT PUINT    MbCount,
                   OUT PUINT    MbTenthsCount
                   )

/*++

Routine Description:

    This routine figures out how many MB and how many tenths of a MB
    are in a number. These values are properly rounded (not truncated)
    and are based on 1MB = 1024*1024.

Arguments:

    Number - supplies number to be examined.

    MbCount - receives rounded number of MB units in Number.

    MbTenthsCount - receives rounded number of tenths of MB in Number.

Return Value:

    None. MbCount and MbTenthsCount filled are in.

--*/

{
    UINT ValueMB;
    UINT ValueMBTenths;
    UINT ValueMBHundredths;

#define _1MB    (1024*1024)

    //
    // Figure out how many whole 1MB units are in the number.
    //
    ValueMB = (UINT)(Number / _1MB);

    //
    // Figure out how many whole hundredths of 1MB units are in
    // the number. Do it in such a way as to not lose any accuracy.
    // ValueMBHundredths will be 0-99 and ValueMBTenths will be 0-9.
    //
    ValueMBHundredths = (UINT)(((Number % _1MB) * 100) / _1MB);
    ValueMBTenths = ValueMBHundredths / 10;

    //
    // If the one's place in the number of hundredths is >=5,
    // then round up the tenths. That might in turn cause is to round
    // up the the next whole # of MB.
    //
    if ((ValueMBHundredths % 10) >= 5) {
        if (++ValueMBTenths == 10) {
            ValueMBTenths = 0;
            ValueMB++;
        }
    }

    //
    // Done.
    //
    *MbCount = ValueMB;
    *MbTenthsCount = ValueMBTenths;
}


UINT
OcGetUnattendComponentSpec(
                          IN POC_MANAGER OcManager,
                          IN LPCTSTR     Component
                          )
{
    LPCTSTR p;
    LPCTSTR szOn = TEXT("ON");
    LPCTSTR szOff = TEXT("OFF");
    LPCTSTR szDefault = TEXT("DEFAULT");

    extern LPCTSTR szComponents;    // defined in ocmanage.c
    INFCONTEXT InfLine;

    UINT NewState = SubcompUseOcManagerDefault;

    if (SetupFindFirstLine(OcManager->UnattendedInf,szComponents,Component,&InfLine)) {
        //
        // Get State parameter from as the first field
        //
        if (p = pSetupGetField(&InfLine,1)) {
            //
            // Found Something now Decode it
            //
            if (!lstrcmpi(p,szOn)) {
                NewState = SubcompOn;
            } else if (!lstrcmpi(p,szOff)) {
                NewState = SubcompOff;
            } else if (!lstrcmpi(p,szDefault)) {
                NewState = SubcompUseOcManagerDefault;
            } else {
                WRN((TEXT("OcGetUnattendComponentSpec: Unknown Component State(%s)\n"),p));
            }
        }
    }

    return NewState;
}

BOOL
pOcClearStateChange(
                   IN PVOID               StringTable,
                   IN LONG                StringId,
                   IN LPCTSTR             String,
                   IN POPTIONAL_COMPONENT Oc,
                   IN UINT                OcSize,
                   IN LPARAM              lParam
                   )
{
    POCPAGE OcPage = (POCPAGE) lParam;
    int i;

    UNREFERENCED_PARAMETER(StringTable);
    UNREFERENCED_PARAMETER(OcSize);

    //
    // clear the State change flag
    //
    Oc->InternalFlags &= ~OCFLAG_STATECHANGE;

    pSetupStringTableSetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           StringId,
                           Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    return TRUE;

}

VOID
pOcSetStates(
            IN OUT POCPAGE OcPage
            )

/*++

Routine Description:

    Set current states for all components.

    If all components were initially off (indicating that this is a
    first-time install) then this routine initializes the current states
    of each leaf component based on the mode bits gathered from the
    per-component infs.

    Otherwise (not a first-time install) query the dll if any
    to determine the current state.

    No confirmations are sent to component dlls as subcomponents are
    set to the selected state, but we do send the calcdiskspace
    notifications.

Arguments:

    OcPage - supplies current oc context.

Return Value:

    None.

--*/

{
    OPTIONAL_COMPONENT Oc;
    UINT i;
    UINT tli;
    UINT StringID;

    //
    // Process each top level parent item in the tree
    //
    for ( tli = 0; tli < OcPage->OcManager->TopLevelOcCount; tli++)

        for (i=0; i<OcPage->OcManager->TopLevelParentOcCount; i++) {

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

            //
            // Traverse the list in the order defined inf fil
            //
            if ( OcPage->OcManager->TopLevelOcStringIds[tli]
                 == pOcGetTopLevelComponent(OcPage->OcManager,OcPage->OcManager->TopLevelParentOcStringIds[i])) {
                //
                // Call each top level item, Each top level item then will call it's
                // suboridiates and Needs and or Needed by components
                //
                pOcSetStatesStringWorker(OcPage->OcManager->TopLevelParentOcStringIds[i], SubcompUseOcManagerDefault, OcPage );
            }
        }

    //
    // Clear the OCFLAG_STATECHANGE Flag
    //
    pSetupStringTableEnum(
                   OcPage->OcManager->ComponentStringTable,
                   &Oc,
                   sizeof(OPTIONAL_COMPONENT),
                   pOcSetStatesStringCB2,
                   (LPARAM)OcPage
                   );
}


BOOL
pOcSetStatesStringWorker(
                        IN LONG         StringId,
                        IN UINT         OverRideState,
                        IN POCPAGE      OcPage
                        )
{
    OPTIONAL_COMPONENT Oc, Subcomponent;
    LPCTSTR String;
    SubComponentState s;
    UINT NewState;
    UINT l;


    pSetupStringTableGetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           StringId,
                           &Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );


    //
    // Deal only with leaf components.
    //
    if (Oc.FirstChildStringId != -1) {

        //
        // Now turn on all subcomponents.
        //
        for (l = Oc.FirstChildStringId; l != -1; l = Oc.NextSiblingStringId) {

            pOcSetStatesStringWorker( l, OverRideState, OcPage );
            //
            // Get the next Depenend in the list
            //
            pSetupStringTableGetExtraData(
                                   OcPage->OcManager->ComponentStringTable,
                                   l,
                                   &Oc,
                                   sizeof(OPTIONAL_COMPONENT)
                                   );
        }
        pOcUpdateParentSelectionStates(OcPage->OcManager,NULL,StringId);


    } else {
        //
        // Don't process the same node twice
        //
        if (  Oc.InternalFlags & OCFLAG_STATECHANGE ) {
            return TRUE;
        }

        String =  pSetupStringTableStringFromId(OcPage->OcManager->ComponentStringTable,StringId);
        //
        // Not initial install case. Call out to component dll to find out
        // whether state needs to be set.
        //

        s = OcInterfaceQueryState(
                                 OcPage->OcManager,
                                 pOcGetTopLevelComponent(OcPage->OcManager,StringId),String, OCSELSTATETYPE_CURRENT);

        if ( (OcPage->OcManager->SetupMode & SETUPMODE_PRIVATE_MASK) == SETUPMODE_REMOVEALL )
        {
            // If Remove all Override all install states and mark the compoent to be
            // removed
            NewState    =    SELSTATE_NO;

        } else {
            //
            // If needs or Needby relationtionships are driving this path
            // OverRideState May be something other then Default
            //
            if ( OverRideState != SubcompUseOcManagerDefault ) {
                s = OverRideState;
            }
            //
            // If the component returned Default and we are in Batch Mode
            // Get the the Spec from the Unattended file
            //
            if ( s == SubcompUseOcManagerDefault
                 && OcPage->OcManager->SetupData.OperationFlags & SETUPOP_BATCH  ){
                s = OcGetUnattendComponentSpec(OcPage->OcManager, String);
            }

            if (s == SubcompUseOcManagerDefault) {
                if (Oc.InternalFlags & (OCFLAG_ANYORIGINALLYON | OCFLAG_ANYORIGINALLYOFF)) {

                    NewState = Oc.OriginalSelectionState;

                } else {

                    if ((1 << (OcPage->OcManager->SetupMode & SETUPMODE_STANDARD_MASK)) & Oc.ModeBits) {
                        //
                        // Allow Modes= lines to act an override condition if it ON
                        //
                        NewState = SELSTATE_YES;
                        s = SubcompOn;
                    } else {
                        NewState = SELSTATE_NO;
                    }
                }
            } else {
                NewState = (s == SubcompOn ? SELSTATE_YES: SELSTATE_NO);
            }
        }

        DBGOUT((
               TEXT("SubComp=%s, Original=%d, Current=%d, NewState=%s\n"),
               String,
               Oc.OriginalSelectionState,
               s,
               (NewState == SELSTATE_YES) ? TEXT("ON") : TEXT("OFF")
               ));

        //
        // Save the current state of the component
        //
        Oc.SelectionState = NewState;
        Oc.InternalFlags |= OCFLAG_STATECHANGE;

        if ( NewState == SELSTATE_YES ) {
            //
            // Make a pass over the Needs
            //
            for (l=0; l<Oc.NeedsCount; l++) {

                if (!pOcSetNeededComponentState( Oc.NeedsStringIds[l], OverRideState, OcPage ))
                    return TRUE;

                pSetupStringTableGetExtraData(
                                       OcPage->OcManager->ComponentStringTable,
                                       Oc.NeedsStringIds[l],
                                       &Subcomponent,
                                       sizeof(OPTIONAL_COMPONENT)
                                       );
            }
        }

        pSetupStringTableSetExtraData(
                               OcPage->OcManager->ComponentStringTable,
                               StringId,
                               &Oc,
                               sizeof(OPTIONAL_COMPONENT)
                               );

        if ( NewState == SELSTATE_YES ) {
            //
            // Make a pass over the Needs
            //
            for (l=0; l<Oc.NeedsCount; l++) {

                pOcSetStatesStringWorker( Oc.NeedsStringIds[l], s, OcPage );

                pSetupStringTableGetExtraData(
                                       OcPage->OcManager->ComponentStringTable,
                                       Oc.NeedsStringIds[l],
                                       &Subcomponent,
                                       sizeof(OPTIONAL_COMPONENT)
                                       );
            }
        } else {
            //
            // Make a pass over the NeedsBy - turning off components
            //
            for (l=0; l<Oc.NeededByCount; l++) {
                pOcSetStatesStringWorker( Oc.NeededByStringIds[l], s, OcPage );

                pSetupStringTableGetExtraData(
                                       OcPage->OcManager->ComponentStringTable,
                                       Oc.NeededByStringIds[l],
                                       &Subcomponent,
                                       sizeof(OPTIONAL_COMPONENT)
                                       );
            }
        }
    }

    pOcUpdateParentSelectionStates(OcPage->OcManager,NULL,StringId);

    return TRUE;
}


BOOL
pOcSetNeededComponentState(
                          IN LONG         StringId,
                          IN UINT         OverRideState,
                          IN POCPAGE      OcPage
                          )
{
    OPTIONAL_COMPONENT Oc, Subcomponent;
    LPCTSTR String;
    SubComponentState s;
    UINT NewState;
    UINT l;
    BOOL b;

    // first find any components this one needs

    pSetupStringTableGetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           StringId,
                           &Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    for (l=0; l<Oc.NeedsCount; l++) {

        if (!pOcSetNeededComponentState( Oc.NeedsStringIds[l], OverRideState, OcPage ))
            return TRUE;

        pSetupStringTableGetExtraData(
                               OcPage->OcManager->ComponentStringTable,
                               Oc.NeedsStringIds[l],
                               &Subcomponent,
                               sizeof(OPTIONAL_COMPONENT)
                               );
    }

    // now handle this one

    pSetupStringTableGetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           StringId,
                           &Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    String =  pSetupStringTableStringFromId(OcPage->OcManager->ComponentStringTable,StringId);

    b = OcInterfaceQueryChangeSelState(
                                      OcPage->OcManager,
                                      pOcGetTopLevelComponent(OcPage->OcManager,StringId),
                                      String,
                                      TRUE,
                                      0
                                      );

    if (b) {
        NewState = SELSTATE_YES;
        s = SubcompOn;
    } else {
        NewState = SELSTATE_NO;
        s = SubcompOff;
    }

    DBGOUT(( TEXT("SubComp=%s, Original=%d, Current=%d, NewState=%s\n"),
             String,
             Oc.OriginalSelectionState,
             s,
             (NewState == SELSTATE_YES) ? TEXT("ON") : TEXT("OFF")
           ));


    //
    // Save the current state of the component
    //
    Oc.SelectionState = NewState;
    Oc.InternalFlags |= OCFLAG_STATECHANGE;

    pSetupStringTableSetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           StringId,
                           &Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    pOcUpdateParentSelectionStates(OcPage->OcManager,NULL,StringId);

    return b;
}


BOOL
pOcSetStatesStringCB2(
                     IN PVOID               StringTable,
                     IN LONG                StringId,
                     IN LPCTSTR             String,
                     IN POPTIONAL_COMPONENT Oc,
                     IN UINT                OcSize,
                     IN LPARAM              lParam
                     )
{
    POCPAGE OcPage;
    int i;

    UNREFERENCED_PARAMETER(StringTable);
    UNREFERENCED_PARAMETER(OcSize);

    OcPage = (POCPAGE)lParam;
    //
    // clear the State change flag left over from
    // the pOcSetStatesStringWorker
    //
    Oc->InternalFlags &= ~OCFLAG_STATECHANGE;
    pSetupStringTableSetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           StringId,
                           Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    //
    // Deal only with leaf components.
    //
    if (Oc->FirstChildStringId != -1) {
        return (TRUE);
    }

    i = 0;

    if (OcPage->OcManager->InternalFlags & OCMFLAG_ANYORIGINALLYON) {
        //
        // Not initial install case. Deal with disk space based on
        // original state.
        //
        if (Oc->OriginalSelectionState == SELSTATE_YES) {
            if (Oc->SelectionState == SELSTATE_NO) {
                //
                // Turning off what was previously on
                //
                i = 1;
            }
        } else {
            if (Oc->SelectionState == SELSTATE_YES) {
                //
                // Turning on what was previous off
                //
                i = 2;
            }
        }

    } else {
        //
        // Initial install case. If a component is on, do its disk space calc.
        // If a component is off, we assume it's not already there and so
        // we do nothing relating to its disk space requirements.
        //
        if (Oc->SelectionState == SELSTATE_YES) {
            i = 2;
        }
    }

    if (i) {
        OcInterfaceCalcDiskSpace(
                                OcPage->OcManager,
                                pOcGetTopLevelComponent(OcPage->OcManager,StringId),
                                String,
                                OcPage->DiskSpaceList,
                                i-1
                                );
    }

    return (TRUE);
}


BOOL
pOcDoesAnyoneWantToSkipPage(
                           IN OUT POC_MANAGER   OcManager,
                           IN     OcManagerPage WhichPage
                           )
{
    UINT u;

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

        OPTIONAL_COMPONENT Oc;

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

        if ((Oc.InternalFlags & OCFLAG_NOQUERYSKIPPAGES) == 0) {

            if (OcInterfaceQuerySkipPage(OcManager,OcManager->TopLevelOcStringIds[u],WhichPage)) {
                return (TRUE);
            }
        }
    }

    return (FALSE);
}

UINT
GetComponentState(
                 IN POCPAGE OcPage,
                 IN LONG    StringId
                 )
{
    LONG id;
    UINT rc;
    UINT state;
    SubComponentState s;
    OPTIONAL_COMPONENT Oc;

    pSetupStringTableGetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           StringId,
                           &Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    if (Oc.FirstChildStringId == -1)
        return Oc.SelectionState;

    // We have a parent; do all the children

    rc = SELSTATE_INIT;
    for (id = Oc.FirstChildStringId; id != -1; id = Oc.NextSiblingStringId) {

        state = GetComponentState(OcPage, id);

        if (state == SELSTATE_PARTIAL)
            return state;

        if (rc == SELSTATE_INIT)
            rc = state;

        if (rc != state)
            return SELSTATE_PARTIAL;

        pSetupStringTableGetExtraData(
                               OcPage->OcManager->ComponentStringTable,
                               id,
                               &Oc,
                               sizeof(OPTIONAL_COMPONENT)
                               );
    }

    return rc;
}




#ifdef _OC_DBG

VOID
pOcPrintStatesWorker(
                    IN LPCTSTR Offset,
                    IN POCPAGE OcPage,
                    IN LONG    StringId
                    )
{
    SubComponentState s;
    OPTIONAL_COMPONENT Oc;

    pSetupStringTableGetExtraData(
                           OcPage->OcManager->ComponentStringTable,
                           StringId,
                           &Oc,
                           sizeof(OPTIONAL_COMPONENT)
                           );

    DBGOUT(( TEXT("%32s\n"),
             pSetupStringTableStringFromId(OcPage->OcManager->ComponentStringTable,StringId)
           ));

    //
    // Deal only with leaf components.
    //
    if (Oc.FirstChildStringId == -1) {

        DBGOUT((
               TEXT("  Orignial(%s) Current(%s) ANYORIGINALLYON (%s) Mode (%d)\n"),
               (Oc.OriginalSelectionState  == SELSTATE_YES ? TEXT("Yes") : TEXT("No")),
               (Oc.SelectionState          == SELSTATE_YES ? TEXT("Yes") : TEXT("No")),
               (Oc.InternalFlags & OCFLAG_ANYORIGINALLYON) ? TEXT("TRUE") : TEXT("FALSE"),
               SETUPMODE_STANDARD_MASK & Oc.ModeBits
               ));

    } else {
        //
        // We have a parent; do all the children
        //
        LONG Id;

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

            pOcPrintStatesWorker(
                                Offset,
                                OcPage,
                                Id
                                );

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


VOID
pOcPrintStates(
              IN POCPAGE OcPage
              )
{
    OPTIONAL_COMPONENT Oc;
    DWORD i;

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

        pOcPrintStatesWorker(
                            TEXT(" "),
                            OcPage,
                            OcPage->OcManager->TopLevelOcStringIds[i]
                            );
    }
}

#endif