Ejemplo n.º 1
0
LONG
ValidatepOptItem(
    PTVWND  pTVWnd
    )

/*++

Routine Description:




Arguments:




Return Value:




Author:

    05-Sep-1995 Tue 18:43:47 created  -by-  Daniel Chou (danielc)


Revision History:


--*/

{
    POPTITEM    pItem;
    POPTITEM    pLastItem;
    LONG        cGroup = 0;


    pItem     = pTVWnd->ComPropSheetUI.pOptItem;
    pLastItem = pTVWnd->pLastItem;

    while (pItem <= pLastItem) {

        DWORD   Flags;
        BYTE    DMPubID;
        BYTE    DlgPageIdx;
        BYTE    CurLevel;


        ++cGroup;

        CurLevel   = pItem->Level;
        DlgPageIdx = pItem->DlgPageIdx;
        DMPubID    = pItem->DMPubID;
        Flags      = pItem->Flags;

        do {

            POPTTYPE    pOptType;
            POPTPARAM   pOptParam = NULL;
            PEXTCHKBOX  pECB;
            INT         Count;
            INT         IconCount;
            INT         cNotHide;
            BYTE        Mask;
            BYTE        HideBits;
            LONG        MinSel;
            LONG        MaxSel;
            BYTE        Type;
            BOOL        pDefSelIsMem;


            CPSUIOPTITEM(DBGITEM_VALIDATE, pTVWnd, "Validate", 2, pItem);

            if (pItem->cbSize != sizeof(OPTITEM)) {

                return(ERR_CPSUI_INVALID_OPTITEM_CBSIZE);
            }

            //
            // clear the unused flags
            //

            pItem->Flags &= (OPTIF_MASK ^ OPTIF_ENTER_MASK);

            if ((Flags & OPTIF_HIDE) && (!(pItem->Flags & OPTIF_HIDE))) {

                return(ERR_CPSUI_SUBITEM_DIFF_OPTIF_HIDE);
            }

            if (Flags & OPTIF_INT_HIDE) {

                pItem->Flags |= OPTIF_INT_HIDE;
            }

            if (!(pItem->Flags & OPTIF_ITEM_HIDE)) {

                if (pOptType = pItem->pOptType) {

                    //
                    // Validate OPTTYPE
                    //

                    if (pOptType->cbSize != sizeof(OPTTYPE)) {

                        return(ERR_CPSUI_INVALID_OPTTYPE_CBSIZE);
                    }

                    IconCount = 1;

                    switch (Type = pOptType->Type) {

                    case TVOT_CHKBOX:
                    case TVOT_PUSHBUTTON:

                        Count = 1;
                        break;

                    case TVOT_2STATES:

                        IconCount = 2;

                    case TVOT_EDITBOX:
                    case TVOT_UDARROW:

                        Count = 2;

                        break;

                    case TVOT_3STATES:

                        IconCount = 3;

                        //
                        // Fall through
                        //

                    case TVOT_TRACKBAR:
                    case TVOT_SCROLLBAR:

                        Count = 3;
                        break;

                    case TVOT_LISTBOX:
                    case TVOT_COMBOBOX:

                        IconCount =
                        Count     = (INT)pOptType->Count;
                        break;

                    default:

                        return(ERR_CPSUI_INVALID_TVOT_TYPE);
                    }

                    if (pOptType->Count != (WORD)Count) {

                        return(ERR_CPSUI_INVALID_OPTTYPE_COUNT);
                    }

                    //
                    // Validate OPTPARAM
                    //

                    if (pOptParam = pOptType->pOptParam) {

                        cNotHide = Count;
                        HideBits = 0;
                        Mask     = 0x01;

                        while (Count--) {

                            if (pOptParam->cbSize != sizeof(OPTPARAM)) {

                                return(ERR_CPSUI_INVALID_OPTPARAM_CBSIZE);
                            }

                            if (pOptParam->Flags & OPTPF_HIDE) {

                                cNotHide--;
                                HideBits |= Mask;
                            }

                            Mask <<= 1;
                            pOptParam++;
                        }

                    } else {

                        return(ERR_CPSUI_NULL_POPTPARAM);
                    }

                    pOptParam = pOptType->pOptParam;

                    //
                    // for TVOT_2STATES, TVOT_3STATES, TVOT_LISTBOX and
                    // TVOT_COMBOBOX, if all selection are hided then we will
                    // hide this item
                    //

                    switch (Type) {

                    case TVOT_PUSHBUTTON:

                        switch (pOptParam->Style) {

                        case PUSHBUTTON_TYPE_HTSETUP:

                            _OI_HELPIDX(pItem)  = IDH_HT_SETUP;
                            pOptType->Flags    |= OTS_PUSH_ENABLE_ALWAYS;
                            break;

                        case PUSHBUTTON_TYPE_HTCLRADJ:

                            _OI_HELPIDX(pItem)  = IDH_HT_CLRADJ;
                            pOptType->Flags    |= OTS_PUSH_ENABLE_ALWAYS;
                            break;

                        case PUSHBUTTON_TYPE_DLGPROC:
                        case PUSHBUTTON_TYPE_CALLBACK:

                            break;

                        default:

                            return(ERR_CPSUI_INVALID_PUSHBUTTON_TYPE);
                        }

                        break;

                    case TVOT_3STATES:
                    case TVOT_2STATES:

                        _OT_FLAGS(pOptType) |= (WORD)HideBits;

                        CPSUIINT(("States Type=%d, HideBits=0x%02x",
                                    (UINT)pOptType->Type, (UINT)HideBits));

                    case TVOT_LISTBOX:
                    case TVOT_COMBOBOX:

                        if (!cNotHide) {

                            CPSUIWARN(("Type=%ld, all OPTPARAMs are OPTPF_HIDE, hide the item"));

                            pItem->Flags |= OPTIF_INT_HIDE;
                            Flags        |= OPTIF_INT_HIDE;
                        }

                        break;

                    default:

                        break;
                    }

                    //
                    // Validate pSel
                    //

                    MinSel       = 0;
                    MaxSel       = -1;
                    pDefSelIsMem = FALSE;

                    switch (Type) {

                    case TVOT_CHKBOX:
                    case TVOT_2STATES:

                        MaxSel = 1;
                        break;

                    case TVOT_UDARROW:
                    case TVOT_TRACKBAR:
                    case TVOT_SCROLLBAR:

                        MinSel = (LONG)((SHORT)pOptParam[1].IconID);
                        MaxSel = (LONG)((SHORT)pOptParam[1].lParam);

                        if (MinSel > MaxSel) {

                            pOptParam[1].IconID = MaxSel;
                            pOptParam[1].lParam = MinSel;

                            CPSUIWARN(("Type=%d, Swap select range (%d-%d)",
                                                            MinSel, MaxSel));

                            MinSel = MaxSel;
                            MaxSel = (LONG)((SHORT)pOptParam[1].lParam);
                        }

                        if (Type != TVOT_UDARROW) {

                            //
                            // This is the multiple factor
                            //

                            if (!pOptParam[2].IconID) {

                                pOptParam[2].IconID = 1;
                            }

                            if (!pOptParam[2].lParam) {

                                pOptParam[2].lParam = 1;
                            }
                        }

                        break;

                    case TVOT_3STATES:

                        MaxSel = 2;
                        break;

                    case TVOT_LISTBOX:
                    case TVOT_COMBOBOX:

                        if (pOptType->Style & OTS_LBCB_INCL_ITEM_NONE) {

                            MinSel = -1;

                            if (pItem->Sel < 0) {

                                pItem->Sel = -1;
                            }
                        }

                        MaxSel = (LONG)((LONG)pOptType->Count - 1);
                        break;

                    case TVOT_PUSHBUTTON:

                        switch (pOptParam->Style) {

                        case PUSHBUTTON_TYPE_HTSETUP:

                            if (_OI_PDEFSEL(pItem) = (LPVOID)
                                            LocalAlloc(LPTR,
                                                       sizeof(DEVHTINFO))) {

                                PDEVHTADJDATA   pDevHTAdjData;

                                pDefSelIsMem = TRUE;
                                pDevHTAdjData =
                                        (PDEVHTADJDATA)(pOptParam->pData);

                                CopyMemory(_OI_PDEFSEL(pItem),
                                           pDevHTAdjData->pAdjHTInfo,
                                           sizeof(DEVHTINFO));

                            } else {

                                CPSUIERR(("LocalAlloc(HTSETUP/DEVHTINFO) failed"));
                                return(ERR_CPSUI_ALLOCMEM_FAILED);
                            }

                            break;

                        case PUSHBUTTON_TYPE_HTCLRADJ:

                            if (_OI_PDEFSEL(pItem) = (LPVOID)
                                        LocalAlloc(LPTR,
                                                   sizeof(COLORADJUSTMENT))) {

                                pDefSelIsMem = TRUE;

                                CopyMemory(_OI_PDEFSEL(pItem),
                                           pOptParam->pData,
                                           sizeof(COLORADJUSTMENT));

                            } else {

                                CPSUIERR(("LocalAlloc(HTCLRADJ/COLORADJUSTMENT) failed"));
                                return(ERR_CPSUI_ALLOCMEM_FAILED);
                            }

                            break;
                        }

                        break;

                    case TVOT_EDITBOX:

                        if ((!pItem->pSel) || (!HIWORD(pItem->pSel))) {

                            return(ERR_CPSUI_INVALID_EDITBOX_PSEL);
                        }

                        if ((MaxSel = (LONG)pOptParam[1].IconID) <= 1) {

                            return(ERR_CPSUI_INVALID_EDITBOX_BUF_SIZE);

                        } else {

                            --MaxSel;

                            if (pTVWnd->Flags & TWF_ANSI_CALL) {

                                MinSel = lstrlenA((LPSTR)pItem->pSel);

                                if (MinSel > MaxSel) {

                                    ((LPSTR)pItem->pSel)[MaxSel] = 0;
                                }

                                MaxSel++;

                            } else {

                                MinSel = lstrlenW((LPWSTR)pItem->pSel);

                                if (MinSel > MaxSel) {

                                    ((LPWSTR)pItem->pSel)[MaxSel] = 0;
                                }

                                MaxSel = (LONG)((DWORD)(MaxSel + 1) << 1);
                            }

                            if (_OI_PDEFSEL(pItem) =
                                        (LPVOID)LocalAlloc(LPTR, MaxSel)) {

                                pDefSelIsMem = TRUE;

                                CopyMemory(_OI_PDEFSEL(pItem),
                                           pItem->pSel,
                                           MaxSel);

                            } else {

                                CPSUIERR(("LocalAlloc(EditBuf=%ld bytes) failed", MaxSel));
                                return(ERR_CPSUI_ALLOCMEM_FAILED);
                            }
                        }

                        //
                        // Fall through
                        //

                    default:

                        MinSel = 0;
                        MaxSel = -1;
                        break;
                    }

                    if ((MinSel < MaxSel) &&
                        ((pItem->Sel < MinSel) ||
                         (pItem->Sel > MaxSel))) {

                        CPSUIWARN(("Sel=%ld (%ld) Out of range (%ld - %ld)",
                                pItem->Sel, (DWORD)pItem->pSel,
                                MinSel, MaxSel));

                        pItem->Flags |= OPTIF_CHANGED;
                        pItem->Sel    = MinSel;
                    }

                    //
                    // Saved old selection
                    //

                    if (!pDefSelIsMem) {

                        _OI_PDEFSEL(pItem) = pItem->pSel;
                    }

                    _OI_DEF_OPTIF(pItem) = pItem->Flags;

                    //
                    // Validate pExtChkBox
                    //

                    if ((pECB = pItem->pExtChkBox) &&
                        (!(pItem->Flags & OPTIF_EXT_HIDE))) {

                        if (pItem->Flags & OPTIF_EXT_IS_EXTPUSH) {

                            PEXTPUSH    pEP = (PEXTPUSH)pECB;


                            if (pEP->cbSize != sizeof(EXTPUSH)) {

                                return(ERR_CPSUI_INVALID_EXTPUSH_CBSIZE);
                            }

                            if (pEP->Flags & EPF_PUSH_TYPE_DLGPROC) {

                                if (!(pEP->DlgProc)) {

                                    return(ERR_CPSUI_NULL_EXTPUSH_DLGPROC);
                                }

                                if (((pEP->Flags & EPF_USE_HDLGTEMPLATE) &&
                                     (pEP->hDlgTemplate == NULL))   ||
                                    (pEP->DlgTemplateID == 0)) {

                                    return(ERR_CPSUI_NO_EXTPUSH_DLGTEMPLATEID);
                                }


                            } else {

                                if ((!(pEP->pfnCallBack))   &&
                                    (!(pTVWnd->ComPropSheetUI.pfnCallBack))) {

                                    return(ERR_CPSUI_NULL_EXTPUSH_CALLBACK);
                                }
                            }

                        } else {

                            CPSUIDBG(DBG_VALIDATE, ("ExtChkBox: cbSize=%u [%u]",
                                    pECB->cbSize, sizeof(EXTCHKBOX)));

                            if (pECB->cbSize != sizeof(EXTCHKBOX)) {

                                return(ERR_CPSUI_INVALID_ECB_CBSIZE);
                            }

                            if (!(pECB->pTitle)) {

                                return(ERR_CPSUI_NULL_ECB_PTITLE);
                            }

                            if (!(pECB->pCheckedName)) {

                                return(ERR_CPSUI_NULL_ECB_PCHECKEDNAME);
                            }
                        }
                    }
                }

                //
                // Validate DMPubID
                //

                if ((DMPubID < DMPUB_USER)      &&
                    (DMPubID != DMPUB_NONE)     &&
                    (pItem->DMPubID != DMPubID)) {

                    return(ERR_CPSUI_INVALID_DMPUBID);
                }

                //
                // Validate DlgPageIdx
                //

                if (pItem->DlgPageIdx != DlgPageIdx) {

                    return(ERR_CPSUI_SUBITEM_DIFF_DLGPAGEIDX);
                }

                if (DlgPageIdx >= pTVWnd->cMyDlgPage) {

                    return(ERR_CPSUI_INVALID_DLGPAGEIDX);
                }

                if (pItem->Flags & OPTIF_CHANGED) {

                    CPSUIOPTITEM(0,pTVWnd, "Validate: OPTIF_CHANGED", 2, pItem);
                }
            }

        } WHILE_SKIP_CHILDREN(pItem, pLastItem, CurLevel);
    }

    return(cGroup);
}
Ejemplo n.º 2
0
LRESULT
CALLBACK 
MainWndProc
(
    HWND      hWnd,
    UINT      Msg,
    WPARAM    wParam,
    LPARAM    lParam
)
/*++

Routine Description:

    This is the main window procedure to the testing program


Arguments:

    See SDK


Return Value:

    See SDK

--*/
{
    DWORD   Result;
    LONG    Ret;

    switch (Msg)
    {
    case WM_INITMENUPOPUP:

        if (!HIWORD(lParam))
        {
            CheckMenuItem( (HMENU)UIntToPtr((UINT)wParam),
                           IDM_PERMISSION,
                           MF_BYCOMMAND | ((UpdatePermission) ? MF_CHECKED : MF_UNCHECKED)
                         );

            CheckMenuItem( (HMENU)UIntToPtr((UINT)wParam),
                           IDM_USESTDABOUT,
                           MF_BYCOMMAND | ((UseStdAbout) ? MF_CHECKED : MF_UNCHECKED)
                         );
        }
        break;

    case WM_COMMAND:

        switch (wParam)
        {
        case IDM_USESTDABOUT:

            UseStdAbout = !UseStdAbout;
            break;

        case IDM_PERMISSION:

            UpdatePermission = !UpdatePermission;
            break;

        case IDM_DOCPROP:
        case IDM_TVTEST:
        case IDM_DOCPROP_TVTEST:

            Ret = CommonPropertySheetUI( hWnd,
                                         (PFNPROPSHEETUI)CPSUIFunc,
                                         (LPARAM)LOWORD(wParam),
                                         &Result
                                       );

            CPSUIDBG( DBG_WINMAINPROC,
                      ("CommonPropertySheetUI()=%ld, Result=%ld", Ret, Result)
                    );

            break;

        default:

            break;
        }
        break;

    case WM_DESTROY:

        PostQuitMessage(0);
        break;

    default:

        return (DefWindowProc(hWnd, Msg, wParam, lParam));
    }

    return 0L;
}