windows-xp/Source/XPSP1/NT/printscan/wia/test/wiatest/wiatestui.cpp

// WIATestUI.cpp : implementation file
//

#include "stdafx.h"
#include "WIATest.h"
#include "WIATestUI.h"


#ifdef _DEBUG
    #define new DEBUG_NEW
    #undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CWIAPropListCtrl
/**************************************************************************\
* CWIAPropListCtrl::CWIAPropListCtrl()
*
*   Constructor for the CWIAPropListCtrl class
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
CWIAPropListCtrl::CWIAPropListCtrl()
{
}
/**************************************************************************\
* CWIAPropListCtrl::~CWIAPropListCtrl()
*
*   Destructor for the CWIAPropListCtrl class
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
CWIAPropListCtrl::~CWIAPropListCtrl()
{
}


BEGIN_MESSAGE_MAP(CWIAPropListCtrl, CListCtrl)
//{{AFX_MSG_MAP(CWIAPropListCtrl)
ON_WM_SHOWWINDOW()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CWIAPropListCtrl message handlers
/**************************************************************************\
* CWIAPropListCtrl::InitHeaders()
*
*   Constructs the headers / colums for the list control
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIAPropListCtrl::InitHeaders()
{
    LVCOLUMN lv;
    int i = 0;
    // initialize item property list control column headers

    // Property name
    lv.mask         = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
    lv.fmt          = LVCFMT_LEFT ;
    lv.cx           = 100;
    lv.pszText      = "Property";
    lv.cchTextMax   = 0;
    lv.iSubItem     = 0;
    lv.iImage       = 0;
    lv.iOrder       = 0;
    i = InsertColumn(0,&lv);

    // Property Value (current)
    lv.cx           = 125;
    lv.iOrder       = 1;
    lv.iSubItem     = 1;
    lv.pszText      = "Value";
    i = InsertColumn(1,&lv);

    // VT_???
    lv.cx           = 85;
    lv.iOrder       = 2;
    lv.iSubItem     = 2;
    lv.pszText      = "Var Type";
    i = InsertColumn(2,&lv);

    // Property access Flags
    lv.cx           = 500;
    lv.iOrder       = 3;
    lv.iSubItem     = 3;
    lv.pszText      = "Access Flags";
    i = InsertColumn(3,&lv);
}

/**************************************************************************\
* CWIAPropListCtrl::ConvertPropVarToString()
*
*   Converts the Property value to a string for display only
*
*
* Arguments:
*
*   pPropVar - Target Property Variant
*   pszVal - String value converted
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIAPropListCtrl::ConvertPropVarToString(PROPVARIANT  *pPropVar,LPSTR szVal)
{
    char szValue[MAX_PATH];

    switch (pPropVar->vt) {
    case VT_I1:
        {
            sprintf(szValue,"%d",pPropVar->cVal);
            strcpy(szVal,szValue);
        }
        break;
    case VT_UI1:
        {
            sprintf(szValue,"%d",pPropVar->bVal);
            strcpy(szVal,szValue);
        }
        break;
    case VT_I2:
        {
            sprintf(szValue,"%d",pPropVar->iVal);
            strcpy(szVal,szValue);
        }
        break;
    case VT_UI2:
        {
            sprintf(szValue,"%d",pPropVar->uiVal);
            strcpy(szVal,szValue);
        }
        break;
    case VT_UI4:
        {
            sprintf(szValue,"%d",pPropVar->ulVal);
            strcpy(szVal,szValue);
        }
        break;
    case VT_UI8:
        {
            sprintf(szValue,"%d",pPropVar->lVal);
            strcpy(szVal,szValue);
        }
        break;
    case VT_INT:
        {
            sprintf(szValue,"%d",pPropVar->intVal);
            strcpy(szVal,szValue);
        }
        break;
    case VT_I4:
        {
            sprintf(szValue,"%d",pPropVar->lVal);
            strcpy(szVal,szValue);
        }
        break;
    case VT_I8:
        {
            sprintf(szValue,"%d",pPropVar->hVal);
            strcpy(szVal,szValue);
        }
        break;
    case VT_R4:
        {
            sprintf(szValue,"%2.5f",pPropVar->fltVal);
            strcpy(szVal,szValue);
        }
        break;
    case VT_R8:
        {
            sprintf(szValue,"%2.5f",pPropVar->dblVal);
            strcpy(szVal,szValue);
        }
        break;
    case VT_BSTR:
        {
            if (WideCharToMultiByte(CP_ACP, 0,pPropVar->bstrVal, -1,
                                    szValue, MAX_PATH,NULL,NULL) > 0) {
                strcpy(szVal,szValue);

            } else
                strcpy(szVal,"");
        }
        break;
    case VT_LPSTR:
        {
            strcpy(szVal,pPropVar->pszVal);
        }
        break;
    case VT_LPWSTR:
        {
            sprintf(szValue,"%ws",pPropVar->pwszVal);
            strcpy(szVal,szValue);
        }
        break;
    case VT_UINT:
        {
            sprintf(szValue,"%d",pPropVar->uintVal);
            strcpy(szVal,szValue);
        }
        break;
    case VT_CLSID:
        {
            UCHAR *pwszUUID = NULL;
            UuidToStringA(pPropVar->puuid,&pwszUUID);
            sprintf(szValue,"%s",pwszUUID);
            strcpy(szVal,szValue);
            RpcStringFree(&pwszUUID);
        }
        break;
    default:
        {
            sprintf(szValue,"%d",pPropVar->lVal);
            strcpy(szVal,szValue);
        }
        break;
    }
}

/**************************************************************************\
* CWIAPropListCtrl::DisplayItemPropData()
*
*   Displays formatted property data from the specified item
*
*
* Arguments:
*
*   pIWiaItem - Target item
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIAPropListCtrl::DisplayItemPropData(IWiaItem *pIWiaItem,BOOL bAccessFlags)
{
    HRESULT hResult = S_OK;
    IWiaPropertyStorage *pIWiaPropStg = NULL;
    BSTR bstrFullItemName = NULL;
    BOOL bSuccess = FALSE;
    int ItemNumber = 0;

    //
    // if the IWiaItem is NULL, Clean the display and exit
    //

    if (pIWiaItem == NULL) {
        DeleteAllItems();
        return;
    }

    //
    // Delete all Items (Possible others)
    //

    DeleteAllItems();

    hResult = pIWiaItem->QueryInterface(IID_IWiaPropertyStorage,(void **)&pIWiaPropStg);
    if (hResult == S_OK) {

        //
        // Start Enumeration
        //

        IEnumSTATPROPSTG    *pIPropEnum;
        hResult = pIWiaPropStg->Enum(&pIPropEnum);
        if (hResult == S_OK) {
            STATPROPSTG StatPropStg;
            do {
                hResult = pIPropEnum->Next(1,&StatPropStg,NULL);
                if (hResult == S_OK) {
                    if (StatPropStg.lpwstrName != NULL) {

                        //
                        // read property value
                        //

                        PROPSPEC        PropSpec;
                        PROPVARIANT     PropVar;

                        PropSpec.ulKind = PRSPEC_PROPID;
                        PropSpec.propid = StatPropStg.propid;

                        hResult = pIWiaPropStg->ReadMultiple(1,&PropSpec,&PropVar);
                        if (hResult == S_OK) {
                            CHAR  szPropName[MAX_PATH];
                            CHAR  szValue[MAX_PATH];
                            CHAR  szText[MAX_PATH];

                            LV_ITEM         lvitem;

                            lvitem.mask     = LVIF_TEXT | LVIF_PARAM;
                            lvitem.iItem    = ItemNumber;
                            lvitem.iSubItem = 0;
                            lvitem.pszText  = szText;
                            lvitem.iImage   = NULL;
                            lvitem.lParam   = StatPropStg.propid;

                            //
                            // Write property name to list control
                            //

                            if (WideCharToMultiByte(CP_ACP, 0,StatPropStg.lpwstrName,-1,
                                                    szPropName, MAX_PATH,NULL,NULL) > 0) {
                                strcpy(szText,szPropName);
                                InsertItem(&lvitem);

                                //
                                // move to next column for setting the value
                                //

                                lvitem.mask     = LVIF_TEXT;
                                lvitem.iSubItem = 1;
                            } else
                                strcpy(szPropName,"");


                            //
                            // Write propery value to list control
                            //

                            ConvertPropVarToString(&PropVar,szText);
                            SetItem(&lvitem);
                            ItemNumber++;

                            //
                            // Display output to the debugger
                            //

                            CString msg;
                            msg.Format("Property: %s = %s",szPropName,szText);
                            StressStatus(msg);
                            if (bAccessFlags) {

                                //
                                // display access flags and var type
                                //

                                ULONG AccessFlags = 0;
                                ULONG VarType = 0;
                                PROPVARIANT     AttrPropVar; // not used at this time
                                hResult = pIWiaPropStg->GetPropertyAttributes(1, &PropSpec,&AccessFlags,&AttrPropVar);
                                if (hResult != S_OK) {
                                    StressStatus("* pIWiaItem->GetPropertyAttributes() Failed",hResult);
                                    hResult = S_OK; // do this to continue property traversal
                                } else {
                                    //
                                    // display access flags
                                    //
                                    lvitem.mask     = LVIF_TEXT;
                                    lvitem.iSubItem = 3;
                                    if (ConvertAccessFlagsToString(lvitem.pszText,AccessFlags))
                                        SetItem(&lvitem);
                                }
                            }

                            //
                            // display var type
                            //

                            lvitem.mask     = LVIF_TEXT;
                            lvitem.iSubItem = 2;

                            if (ConvertVarTypeToString(lvitem.pszText,PropVar.vt))
                                SetItem(&lvitem);
                        }
                    } else {
                        CString msg;
                        msg.Format("* Property with NULL name, propid = %li\n",StatPropStg.propid);
                        StressStatus(msg);
                    }
                }
                //
                // clean up property name
                //
                CoTaskMemFree(StatPropStg.lpwstrName);
            } while (hResult == S_OK);
        }
        pIPropEnum->Release();
        pIWiaPropStg->Release();
    }
    //
    // auto resize columns to fit data
    //
    for (int Col = 0; Col <4;Col++)
        SetColumnWidth(Col, LVSCW_AUTOSIZE );
}
/**************************************************************************\
* CWIAPropListCtrl::ConvertAccessFlagsToString()
*
*   Converts the accessflag into a readable string for display only
*
*
* Arguments:
*
*   pszText - target string pointer for formatted string
*   AccessFlag - Flag to convert
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
BOOL CWIAPropListCtrl::ConvertAccessFlagsToString(char* pszText,ULONG AccessFlags)
{
    if (pszText == NULL)
        return FALSE;
    CString sFlag = "";
    if ((AccessFlags & WIA_PROP_READ) == WIA_PROP_READ)
        sFlag += "WIA_PROP_READ | ";

    if ((AccessFlags & WIA_PROP_WRITE) == WIA_PROP_WRITE)
        sFlag += "WIA_PROP_WRITE | ";

    if (sFlag == "WIA_PROP_READ | WIA_PROP_WRITE | ")
        sFlag = "WIA_PROP_RW | ";

    if ((AccessFlags & WIA_PROP_NONE) == WIA_PROP_NONE)
        sFlag += "WIA_PROP_NONE | ";

    if ((AccessFlags & WIA_PROP_RANGE) == WIA_PROP_RANGE)
        sFlag += "WIA_PROP_RANGE | ";

    if ((AccessFlags & WIA_PROP_LIST) == WIA_PROP_LIST)
        sFlag += "WIA_PROP_LIST | ";

    if ((AccessFlags & WIA_PROP_FLAG) == WIA_PROP_FLAG)
        sFlag += "WIA_PROP_FLAG | ";

    // check for unknown access flags
    if (sFlag.GetLength() == 0)
        sFlag.Format("WIA_PROP_UNKNOWN = %d    ",AccessFlags);

    sFlag = sFlag.Left(sFlag.GetLength()-3);
    strcpy(pszText,sFlag.GetBuffer(256));
    return TRUE;
}
/**************************************************************************\
* CWIAPropListCtrl::ConvertVarTypeToString()
*
*   Converts Var Type to a readable string for display only
*
*
* Arguments:
*
*   pszText - Target string pointer for formatted string data
*   VarType - Var type to convert
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
BOOL CWIAPropListCtrl::ConvertVarTypeToString(char* pszText,ULONG VarType)
{
    if (pszText == NULL)
        return FALSE;
    switch (VarType) {
    case VT_EMPTY:              // nothing
        strcpy(pszText,TEXT("VT_EMPTY"));
        break;
    case VT_NULL:               // SQL style Null
        strcpy(pszText,TEXT("VT_NULL"));
        break;
    case VT_I2:                 // 2 byte signed int
        strcpy(pszText,TEXT("VT_I2"));
        break;
    case VT_I4:                 // 4 byte signed int
        strcpy(pszText,TEXT("VT_I4"));
        break;
    case VT_R4:                 // 4 byte real
        strcpy(pszText,TEXT("VT_R4"));
        break;
    case VT_R8:                 // 8 byte real
        strcpy(pszText,TEXT("VT_R8"));
        break;
    case VT_CY:                 // currency
        strcpy(pszText,TEXT("VT_CY"));
        break;
    case VT_DATE:               // date
        strcpy(pszText,TEXT("VT_DATE"));
        break;
    case VT_BSTR:               // OLE Automation string
        strcpy(pszText,TEXT("VT_BSTR"));
        break;
    case VT_DISPATCH:           // IDispatch *
        strcpy(pszText,TEXT("VT_DISPATCH"));
        break;
    case VT_ERROR:              // SCODE
        strcpy(pszText,TEXT("VT_ERROR"));
        break;
    case VT_BOOL:               // True=-1, False=0
        strcpy(pszText,TEXT("VT_BOOL"));
        break;
    case VT_VARIANT:            // VARIANT *
        strcpy(pszText,TEXT("VT_VARIANT"));
        break;
    case VT_UNKNOWN:            // IUnknown *
        strcpy(pszText,TEXT("VT_UNKNOWN"));
        break;
    case VT_DECIMAL:            // 16 byte fixed point
        strcpy(pszText,TEXT("VT_DECIMAL"));
        break;
    case VT_RECORD:             // user defined type
        strcpy(pszText,TEXT("VT_RECORD"));
        break;
    case VT_I1:                 // signed char
        strcpy(pszText,TEXT("VT_I1"));
        break;
    case VT_UI1:                // unsigned char
        strcpy(pszText,TEXT("VT_UI1"));
        break;
    case VT_UI2:                // unsigned short
        strcpy(pszText,TEXT("VT_UI2"));
        break;
    case VT_UI4:                // unsigned short
        strcpy(pszText,TEXT("VT_UI4"));
        break;
    case VT_I8:                 // signed 64-bit int
        strcpy(pszText,TEXT("VT_I8"));
        break;
    case VT_UI8:                // unsigned 64-bit int
        strcpy(pszText,TEXT("VT_UI8"));
        break;
    case VT_INT:                // signed machine int
        strcpy(pszText,TEXT("VT_INT"));
        break;
    case VT_UINT:               // unsigned machine int
        strcpy(pszText,TEXT("VT_UINT"));
        break;
    case VT_VOID:               // C style void
        strcpy(pszText,TEXT("VT_VOID"));
        break;
    case VT_HRESULT:            // Standard return type
        strcpy(pszText,TEXT("VT_HRESULT"));
        break;
    case VT_PTR:                // pointer type
        strcpy(pszText,TEXT("VT_PTR"));
        break;
    case VT_SAFEARRAY:          // (use VT_ARRAY in VARIANT)
        strcpy(pszText,TEXT("VT_SAFEARRAY"));
        break;
    case VT_CARRAY:             // C style array
        strcpy(pszText,TEXT("VT_CARRAY"));
        break;
    case VT_USERDEFINED:        // user defined type
        strcpy(pszText,TEXT("VT_USERDEFINED"));
        break;
    case VT_LPSTR:              // null terminated string
        strcpy(pszText,TEXT("VT_LPSTR"));
        break;
    case VT_LPWSTR:             // wide null terminated string
        strcpy(pszText,TEXT("VT_LPWSTR"));
        break;
    case VT_FILETIME:           // FILETIME
        strcpy(pszText,TEXT("VT_FILETIME"));
        break;
    case VT_BLOB:               // Length prefixed bytes
        strcpy(pszText,TEXT("VT_BLOB"));
        break;
    case VT_STREAM:             // Name of the stream follows
        strcpy(pszText,TEXT("VT_STREAM"));
        break;
    case VT_STORAGE:            // Name of the storage follows
        strcpy(pszText,TEXT("VT_STORAGE"));
        break;
    case VT_STREAMED_OBJECT:    // Stream contains an object
        strcpy(pszText,TEXT("VT_STREAMED_OBJECT"));
        break;
    case VT_STORED_OBJECT:      // Storage contains an object
        strcpy(pszText,TEXT("VT_STORED_OBJECT"));
        break;
    case VT_VERSIONED_STREAM:   // Stream with a GUID version
        strcpy(pszText,TEXT("VT_VERSIONED_STREAM"));
        break;
    case VT_BLOB_OBJECT:        // Blob contains an object
        strcpy(pszText,TEXT("VT_BLOB_OBJECT"));
        break;
    case VT_CF:                 // Clipboard format
        strcpy(pszText,TEXT("VT_CF"));
        break;
    case VT_CLSID:              // A Class ID
        strcpy(pszText,TEXT("VT_CLSID"));
        break;
    case VT_VECTOR:             // simple counted array
        strcpy(pszText,TEXT("VT_VECTOR"));
        break;
    case VT_ARRAY:              // SAFEARRAY*
        strcpy(pszText,TEXT("VT_ARRAY"));
        break;
    case VT_BYREF:              // void* for local use
        strcpy(pszText,TEXT("VT_BYREF"));
        break;
    case VT_BSTR_BLOB:          // Reserved for system use
        strcpy(pszText,TEXT("VT_BSTR_BLOB"));
        break;
    case VT_VECTOR|VT_I4:
        strcpy(pszText,TEXT("VT_VECTOR | VT_I4"));
        break;
    case VT_VECTOR | VT_UI1:
        strcpy(pszText,TEXT("VT_VECTOR | VT_UI1"));
        break;
    default:                    // unknown type detected!!
        strcpy(pszText,TEXT("VT_UNKNOWNTYPE"));
        break;
    }
    return TRUE;
}
/**************************************************************************\
* CWIAPropListCtrl::Resize()
*
*   Resizes the list control to specified changes in dx, and dy values
*
*
* Arguments:
*
*   dx - change in Width of parent frame
*   dy - change in Height of parent frame
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIAPropListCtrl::Resize(int dx, int dy)
{
    RECT ListBoxRect;
    GetWindowRect(&ListBoxRect);
    CWnd* pFrm = GetParent();
    if (pFrm != NULL)
        pFrm->ScreenToClient(&ListBoxRect);

    ListBoxRect.right += dx;
    ListBoxRect.bottom += dy;
    MoveWindow(&ListBoxRect);
}
/////////////////////////////////////////////////////////////////////////////
// CWIATreeCtrl
/**************************************************************************\
* CWIATreeCtrl::CWIATreeCtrl()
*
*   Constructor for CWIATreeCtrl class
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
CWIATreeCtrl::CWIATreeCtrl()
{
}
/**************************************************************************\
* CWIATreeCtrl::~CWIATreeCtrl()
*
*   Destructor for the CWIATreeCtrl class
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
CWIATreeCtrl::~CWIATreeCtrl()
{
}


BEGIN_MESSAGE_MAP(CWIATreeCtrl, CTreeCtrl)
//{{AFX_MSG_MAP(CWIATreeCtrl)
// NOTE - the ClassWizard will add and remove mapping macros here.
//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CWIATreeCtrl message handlers


void CWIATreeCtrl::InitHeaders()
{
    // initialize the tree control
    //m_ItemTree.SetImageList(((CWIATestApp*)pApp)->GetApplicationImageList(),TVSIL_NORMAL);
}
/**************************************************************************\
* CWIATreeCtrl::BuildItemTree()
*
*   Constructs a Tree display of the Active Tree list which contains, Item pointers
*
*
* Arguments:
*
*   pActiveTreeList - list of IWiaItem* pointers
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
BOOL CWIATreeCtrl::BuildItemTree(CPtrList *pActiveTreeList)
{
    DeleteAllItems();
    //
    // Start at head of the ActiveTree list
    //
    m_CurrentPosition = pActiveTreeList->GetHeadPosition();
    Construct(pActiveTreeList, TVI_ROOT,0);
    //
    // select the Root item
    //
    SelectItem(GetRootItem());
    return TRUE;
}
/**************************************************************************\
* CWIATreeCtrl::Construct()
*
*   Build the actual tree in display form
*
*
* Arguments:
*
*   pActiveTreeList - list of IWiaItem* pointers
*   hParent - handle of Parent tree item
*   ParentID - Parent's ID...which level does the item belong to???
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
BOOL CWIATreeCtrl::Construct(CPtrList *pActiveTreeList, HTREEITEM hParent, int ParentID)
{
    IWiaItem* pIWiaItem = NULL;
    WIAITEMTREENODE* pWiaItemTreeNode = NULL;
    IWiaPropertyStorage *pIWiaPropStg;
    HRESULT hResult = S_OK;
    HTREEITEM hTree = NULL;
    IEnumWiaItem* pEnumItem = NULL;
    TV_INSERTSTRUCT tv;

    tv.hParent              = hParent;
    tv.hInsertAfter         = TVI_LAST;
    tv.item.mask            = TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT | TVIF_PARAM;
    tv.item.hItem           = NULL;
    tv.item.state           = TVIS_EXPANDED;
    tv.item.stateMask       = TVIS_STATEIMAGEMASK;
    tv.item.cchTextMax      = 6;
    tv.item.cChildren       = 0;
    tv.item.lParam          = 0;

    //
    // save current position in list
    //

    tv.item.lParam  = (LPARAM)m_CurrentPosition;

    pWiaItemTreeNode = (WIAITEMTREENODE*)pActiveTreeList->GetNext(m_CurrentPosition);
    pIWiaItem = pWiaItemTreeNode->pIWiaItem;
    ParentID = pWiaItemTreeNode->ParentID;

    if (pIWiaItem == NULL)
        return FALSE;

    CHAR szTemp[ MAX_PATH ];
    BSTR bstrFullItemName = NULL;

    //
    // get item's name and add it to the tree
    //

    hResult = pIWiaItem->QueryInterface(IID_IWiaPropertyStorage,(void **)&pIWiaPropStg);
    if (hResult == S_OK) {
        hResult = ReadPropStr(WIA_IPA_FULL_ITEM_NAME, pIWiaPropStg, &bstrFullItemName);
        if (hResult != S_OK) {
            StressStatus("* ReadPropStr(WIA_IPA_FULL_ITEM_NAME) Failed",hResult);
            bstrFullItemName = ::SysAllocString(L"Uninitialized");
        }
        pIWiaPropStg->Release();
    } else {
        StressStatus("* QueryInterface(IDD_IWiaPropertyStorage) Failed",hResult);
        return FALSE;
    }

    WideCharToMultiByte(CP_ACP,0,bstrFullItemName,-1,szTemp,MAX_PATH,NULL,NULL);
    tv.item.pszText = szTemp;

    hTree = InsertItem(&tv);

    HTREEITEM ParentLevel[50];
    ParentLevel[ParentID] = hTree;
    while (m_CurrentPosition) {
        //
        // save current position in list
        //

        tv.item.lParam  = (LPARAM)m_CurrentPosition;

        pWiaItemTreeNode = (WIAITEMTREENODE*)pActiveTreeList->GetNext(m_CurrentPosition);
        pIWiaItem = pWiaItemTreeNode->pIWiaItem;
        ParentID = pWiaItemTreeNode->ParentID;

        if (pIWiaItem == NULL)
            return FALSE;

        CHAR szTemp[ MAX_PATH ];
        BSTR bstrFullItemName = NULL;

        //
        // get item's name and add it to the tree
        //

        hResult = pIWiaItem->QueryInterface(IID_IWiaPropertyStorage,(void **)&pIWiaPropStg);
        if (hResult == S_OK) {
            hResult = ReadPropStr(WIA_IPA_FULL_ITEM_NAME, pIWiaPropStg, &bstrFullItemName);
            if (hResult != S_OK) {
                StressStatus("* ReadPropStr(WIA_IPA_FULL_ITEM_NAME) Failed",hResult);
                bstrFullItemName = ::SysAllocString(L"Uninitialized");
            }
            pIWiaPropStg->Release();
        } else {
            StressStatus("* QueryInterface(IDD_IWiaPropertyStorage) Failed",hResult);
            return FALSE;
        }

        WideCharToMultiByte(CP_ACP,0,bstrFullItemName,-1,szTemp,MAX_PATH,NULL,NULL);
        tv.item.pszText = szTemp;

        tv.hParent = ParentLevel[ParentID];

        hTree = InsertItem(&tv);

        // find out if the item is a folder, if it is,
        // ask for child items...
        long lType = 0;
        pIWiaItem->GetItemType(&lType);
        if (lType & WiaItemTypeFolder) {
            if (pIWiaItem->EnumChildItems(&pEnumItem) == S_OK) {
                ParentLevel[ParentID+1] = hTree;
            }
        }
    }
    return FALSE;
}
/**************************************************************************\
* CWIATreeCtrl::DestroyItemTree()
*
*   Destroys the display, and Active Tree list
*
*
* Arguments:
*
*   pActiveTreeList - list of IWiaItem* pointers
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATreeCtrl::DestroyItemTree(CPtrList* pActiveTreeList)
{
    if (pActiveTreeList->GetCount() == 0)
        return;

    SelectItem(GetRootItem());
    POSITION Position = pActiveTreeList->GetHeadPosition();
    IWiaItem* pIWiaItem = NULL;
    while (Position) {
        WIAITEMTREENODE* pWiaItemTreeNode = (WIAITEMTREENODE*)pActiveTreeList->GetNext(Position);
        pIWiaItem = pWiaItemTreeNode->pIWiaItem;
        pIWiaItem->Release();
    }
    pActiveTreeList->RemoveAll();
    DeleteAllItems( );
}
/**************************************************************************\
* CWIATreeCtrl::GetSelectedIWiaItem()
*
*   returns the selected IWiaItem* pointer in the tree
*
*
* Arguments:
*
*   pActiveTreeList - list of IWiaItem* pointers
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
IWiaItem* CWIATreeCtrl::GetSelectedIWiaItem(CPtrList* pActiveTreeList)
{
    HTREEITEM hTreeItem = GetSelectedItem();
    if (hTreeItem != NULL) {
        //
        // we have a valid hTreeItem
        //
        POSITION Position = (POSITION)GetItemData(hTreeItem);
        if (Position) {
            //
            // we have a POSITION
            //
            IWiaItem* pIWiaItem = NULL;
            if (Position) {
                WIAITEMTREENODE* pWiaItemTreeNode = (WIAITEMTREENODE*)pActiveTreeList->GetAt(Position);
                if (pWiaItemTreeNode != NULL) {
                    pIWiaItem = pWiaItemTreeNode->pIWiaItem;
                    if (pIWiaItem != NULL) {
                        //
                        // a valid item is found
                        //
                        return pIWiaItem;
                    }
                } else
                    return NULL;
            } else
                return NULL;
        }
    } else
        MessageBox("Please select an Item","WIATest Status",MB_OK);
    return NULL;
}
/**************************************************************************\
* CWIATreeCtrl::GetRootIWiaItem()
*
*   Returns the ROOT item from the pActiveTreeList
*
*
* Arguments:
*
*   pActiveTreeList - list of IWiaItem* pointers
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
IWiaItem* CWIATreeCtrl::GetRootIWiaItem(CPtrList* pActiveTreeList)
{
    HTREEITEM hTreeItem = GetRootItem();
    if (hTreeItem != NULL) {
        //
        // we have a valid hTreeItem
        //
        POSITION Position = (POSITION)GetItemData(hTreeItem);
        if (Position) {
            //
            // we have a POSITION
            //
            IWiaItem* pIWiaItem = NULL;
            if (Position) {
                WIAITEMTREENODE* pWiaItemTreeNode = (WIAITEMTREENODE*)pActiveTreeList->GetAt(Position);
                if (pWiaItemTreeNode != NULL) {
                    pIWiaItem = pWiaItemTreeNode->pIWiaItem;
                    if (pIWiaItem != NULL) {
                        //
                        // a valid item is found
                        //
                        return pIWiaItem;
                    }
                } else
                    return NULL;
            } else
                return NULL;
        }
    }
    return NULL;
}

/////////////////////////////////////////////////////////////////////////////
// CWIADeviceComboBox
/**************************************************************************\
* CWIADeviceComboBox::CWIADeviceComboBox
*
*   Constructor for the CWIADeviceComboBox class
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
CWIADeviceComboBox::CWIADeviceComboBox()
{
}
/**************************************************************************\
* CWIADeviceComboBox::~CWIADeviceComboBox()
*
*   Destructor for the CWIAPropListCtrl class
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
CWIADeviceComboBox::~CWIADeviceComboBox()
{
}
/**************************************************************************\
* CWIADeviceComboBox::AddDevice()
*
*   Add a Device ID to the Device ComboBox
*
*
* Arguments:
*
*   DeviceIndex -  position to place the Device ID in the combo box
*   DeviceName - Name of the Device
*   ServerName - Name of the server, (local or other) of the device
*   bstrDeviceID - Device ID
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIADeviceComboBox::AddDeviceID(int DeviceIndex, BSTR DeviceName, BSTR ServerName,BSTR bstrDeviceID)
{
    //
    // report no WIA devices found if -1 is passed as the DeviceIndex param
    //
    if (DeviceIndex == -1)
        InsertString(0,"< No WIA Devices Found >");
    else {
        //
        // add WIA device name, and ID to combobox
        //
        InsertString(DeviceIndex,(CString)DeviceName + "  ( " + (CString)ServerName + " )");
        SetItemDataPtr(DeviceIndex,(LPVOID)bstrDeviceID);
    }
}

BEGIN_MESSAGE_MAP(CWIADeviceComboBox, CComboBox)
//{{AFX_MSG_MAP(CWIADeviceComboBox)
// NOTE - the ClassWizard will add and remove mapping macros here.
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CWIADeviceComboBox message handlers
/**************************************************************************\
* CWIADeviceComboBox::GetCurrentDeviceID()
*
*   Returns the currently selected device ID from the combo box
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*    BSTR - DeviceID
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
BSTR CWIADeviceComboBox::GetCurrentDeviceID()
{
    int ComboIndex = GetCurSel();
    return(BSTR)GetItemDataPtr(ComboIndex);
}
/**************************************************************************\
* CWIADeviceComboBox::GetCurrentDeviceName()
*
*   Returns the currently selected device's Name
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*    CString - device name in CString format
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
CString CWIADeviceComboBox::GetCurrentDeviceName()
{
    int ComboIndex = GetCurSel();
    return GetDeviceName(ComboIndex);
}
/**************************************************************************\
* CWIADeviceComboBox::GetDeviceName()
*
*   Returns the target device's Name
*
*
* Arguments:
*
*   Comboindex - Position in the combo box of the target device
*
* Return Value:
*
*    CString - device name in CString format
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
CString CWIADeviceComboBox::GetDeviceName(int ComboIndex)
{
    CString DeviceName;
    GetLBText(ComboIndex,DeviceName);
    return DeviceName;
}
/**************************************************************************\
* CWIADeviceComboBox::SetCurrentSelFromID()
*
*   Sets the combo selection based on the target ID
*   note: this is used for command line only
*
*
* Arguments:
*
*   CmdLine - Command Line containing Device ID
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIADeviceComboBox::SetCurrentSelFromID(CString CmdLine)
{
    //
    // find the specified Device ID
    //
    int DeviceCount = GetCount();
    int ComboIndex = 0;
    BSTR bstrDeviceID;
    CString DeviceID;
    if (DeviceCount > 0) {
        for (int i = 0;i<DeviceCount;i++) {

            bstrDeviceID = (BSTR)GetItemDataPtr(i);
            DeviceID = bstrDeviceID;
            if (DeviceID == CmdLine)
                ComboIndex = i;
        }
        //
        // ComboIndex will be zero if none of
        // the DeviceIDs match
        // Zero is the first Device in the combo box
        //
        SetCurSel(ComboIndex);
    }
}

/////////////////////////////////////////////////////////////////////////////
// CWIAClipboardFormatComboBox
/**************************************************************************\
* CWIAClipboardFormatComboBox::CWIAClipboardFormatComboBox()
*
*   Constructor for the CWIAClipboardFormatComboBox class
*
* Arguments:
*
*   none
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
CWIAClipboardFormatComboBox::CWIAClipboardFormatComboBox()
{
}
/**************************************************************************\
* CWIAClipboardFormatComboBox::~CWIAClipboardFormatComboBox()
*
*   Destructor for the CWIAClipboardFormatComboBox class
*
* Arguments:
*
*   none
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
CWIAClipboardFormatComboBox::~CWIAClipboardFormatComboBox()
{
}

BEGIN_MESSAGE_MAP(CWIAClipboardFormatComboBox, CComboBox)
//{{AFX_MSG_MAP(CWIAClipboardFormatComboBox)
// NOTE - the ClassWizard will add and remove mapping macros here.
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CWIAClipboardFormatComboBox message handlers
/**************************************************************************\
* CWIAClipboardFormatComboBox::InitClipboardFormats()
*
*   Enumerates the supported clipboard formats, and populates the combo
*   box with these values. (filtering is based on the Tymed param)
*
* Arguments:
*
*   pWIAFormatInfo -
*   Tymed - Filter TYMED_ value
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIAClipboardFormatComboBox::InitClipboardFormats(CPtrList* pSupportedFormatList,LONG Tymed)
{

    //
    // save current format
    //
    GUID CurrentClipboardFormat;

    if (pSupportedFormatList != NULL)
        CurrentClipboardFormat = GetCurrentClipboardFormat();

    int i = 0;

    //
    // nuke all entries
    //

    ResetContent( );
    if (pSupportedFormatList == NULL) {

        //
        // Add WiaImgFmt_BMP some default value
        //

        InsertString(0,TEXT("WiaImgFmt_BMP(default)"));
        SetItemDataPtr(0,(void*)&WiaImgFmt_BMP);
    } else {
        POSITION Position = pSupportedFormatList->GetHeadPosition();
        while (Position) {
            WIA_FORMAT_INFO* pfe = (WIA_FORMAT_INFO*)pSupportedFormatList->GetNext(Position);
            if (Tymed == pfe->lTymed) {
                InsertString(i,ConvertClipboardFormatToCString(pfe->guidFormatID));
                SetItemDataPtr(i,(void*)GetGUIDPtr(pfe->guidFormatID));
                i++;
            }
        }
    }
    SetClipboardFormat(CurrentClipboardFormat);
}
/**************************************************************************\
* CWIAClipboardFormatComboBox::GetCurrentClipboardFormat()
*
*   Returns the currently selected clipboard format from the combo box
*
* Arguments:
*
*   none
*
* Return Value:
*
*    USHORT - Currently selected clipboard format
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
GUID CWIAClipboardFormatComboBox::GetCurrentClipboardFormat()
{
    int ComboIndex = GetCurSel();
    return *((GUID*)GetItemDataPtr(ComboIndex));
}
/**************************************************************************\
* CWIAClipboardFormatComboBox::ConvertClipboardFormatToCString()
*
*   Converts a Clipboard format to a CString value for display only
*
* Arguments:
*
*   ClipboardFormat - Clipboardformat to convert
*
* Return Value:
*
*    CString - converted Clipboardformat in CString format
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
CString CWIAClipboardFormatComboBox::ConvertClipboardFormatToCString(GUID ClipboardFormat)
{
    if(ClipboardFormat == WiaImgFmt_UNDEFINED)
        return "WiaImgFmt_UNDEFINED";
    else if(ClipboardFormat == WiaImgFmt_MEMORYBMP)
        return "WiaImgFmt_MEMORYBMP";
    else if(ClipboardFormat == WiaImgFmt_BMP)
        return "WiaImgFmt_BMP";
    else if(ClipboardFormat == WiaImgFmt_EMF)
        return "WiaImgFmt_EMF";
    else if(ClipboardFormat == WiaImgFmt_WMF)
        return "WiaImgFmt_WMF";
    else if(ClipboardFormat == WiaImgFmt_JPEG)
        return "WiaImgFmt_JPEG";
    else if(ClipboardFormat == WiaImgFmt_PNG)
        return "WiaImgFmt_PNG";
    else if(ClipboardFormat == WiaImgFmt_GIF)
        return "WiaImgFmt_GIF";
    else if(ClipboardFormat == WiaImgFmt_TIFF)
        return "WiaImgFmt_TIFF";
    else if(ClipboardFormat == WiaImgFmt_EXIF)
        return "WiaImgFmt_EXIF";
    else if(ClipboardFormat == WiaImgFmt_PHOTOCD)
        return "WiaImgFmt_PHOTOCD";
    else if(ClipboardFormat == WiaImgFmt_FLASHPIX)
        return "WiaImgFmt_FLASHPIX";
    else
        return "** UNKNOWN **";

}
/**************************************************************************\
* CWIAClipboardFormatComboBox::GetGUIDPtr()
*
*   Converts a GUID format to a pointer to the constant
*
* Arguments:
*
*   guidIn - GUID to convert
*
* Return Value:
*
*    GUID* - pointer to a GUID constant
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
const GUID* CWIAClipboardFormatComboBox::GetGUIDPtr(GUID guidIn)
{
    if(guidIn == WiaImgFmt_UNDEFINED)
        return &WiaImgFmt_UNDEFINED;
    else if(guidIn == WiaImgFmt_MEMORYBMP)
        return &WiaImgFmt_MEMORYBMP;
    else if(guidIn == WiaImgFmt_BMP)
        return &WiaImgFmt_BMP;
    else if(guidIn == WiaImgFmt_EMF)
        return &WiaImgFmt_EMF;
    else if(guidIn == WiaImgFmt_WMF)
        return &WiaImgFmt_WMF;
    else if(guidIn == WiaImgFmt_JPEG)
        return &WiaImgFmt_JPEG;
    else if(guidIn == WiaImgFmt_PNG)
        return &WiaImgFmt_PNG;
    else if(guidIn == WiaImgFmt_GIF)
        return &WiaImgFmt_GIF;
    else if(guidIn == WiaImgFmt_TIFF)
        return &WiaImgFmt_TIFF;
    else if(guidIn == WiaImgFmt_EXIF)
        return &WiaImgFmt_EXIF;
    else if(guidIn == WiaImgFmt_PHOTOCD)
        return &WiaImgFmt_PHOTOCD;
    else if(guidIn == WiaImgFmt_FLASHPIX)
        return &WiaImgFmt_FLASHPIX;
    return (GUID*)&GUID_NULL;
}
/**************************************************************************\
* CWIAClipboardFormatComboBox::SetClipboardFormat()
*
*   Attempts to set the current clipboard format value in the combo box,
*   if it can't be found the first item is set to default (index 0)
*
* Arguments:
*
*   CF_VALUE - Clipboard format to set
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIAClipboardFormatComboBox::SetClipboardFormat(GUID CF_VALUE)
{
    int NumItems = GetCount();
    int Index = 0;
    BOOL bFound = FALSE;
    if (NumItems >0) {
        while (Index < NumItems) {
            if (CF_VALUE == *(GUID*)GetItemDataPtr(Index)) {
                SetCurSel(Index);
                bFound = TRUE;
            }
            Index++;
        }
        if (!bFound)
            SetCurSel(0);
    } else
        StressStatus("* No WIA Supported Formats in format listbox");
}

/////////////////////////////////////////////////////////////////////////////
// CWIATymedComboBox
/**************************************************************************\
* CWIATymedComboBox::CWIATymedComboBox()
*
*   Constructor for the CWIATymedComboBox class
*
* Arguments:
*
*   none
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
CWIATymedComboBox::CWIATymedComboBox()
{
}
/**************************************************************************\
* CWIATymedComboBox::~CWIATymedComboBox()
*
*   Destructor for the CWIATymedComboBox class
*
* Arguments:
*
*   none
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
CWIATymedComboBox::~CWIATymedComboBox()
{
}

BEGIN_MESSAGE_MAP(CWIATymedComboBox, CComboBox)
//{{AFX_MSG_MAP(CWIATymedComboBox)
// NOTE - the ClassWizard will add and remove mapping macros here.
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CWIATymedComboBox message handlers

/**************************************************************************\
* CWIATymedComboBox::GetCurrentTymed()
*
*   Returns the currently selected TYMED value in the combo box
*
* Arguments:
*
*   none
*
* Return Value:
*
*    DWORD - selected TYMED value
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
DWORD CWIATymedComboBox::GetCurrentTymed()
{
    int ComboIndex = GetCurSel();
    return(DWORD)GetItemData(ComboIndex);
}
/**************************************************************************\
* CWIATymedComboBox::InitTymedComboBox()
*
*   Initialize the TymedComboBox with supported values
*
* Arguments:
*
*   none
*
* Return Value:
*
*    none
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATymedComboBox::InitTymedComboBox()
{
    //
    // initialize the combo box with possible
    // tymed combinations
    //
    InsertString(0,"TYMED_FILE");
    SetItemData(0,TYMED_FILE);

    InsertString(1,"TYMED_CALLBACK");
    SetItemData(1,TYMED_CALLBACK);

    //
    // Set Default selection to first entry
    //
    SetCurSel(0);
}