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

// WIATestView.cpp : implementation of the CWIATestView class
//

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

#include "WIATestDoc.h"
#include "WIATestView.h"
#include "Mainfrm.h"
#include "PropEdit.h"
#include "datacallback.h"
#include "devicecmddlg.h"
#include "iteminfodlg.h"

#include "mmsystem.h"

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

/////////////////////////////////////////////////////////////////////////////
// CWIATestView

IMPLEMENT_DYNCREATE(CWIATestView, CFormView)

BEGIN_MESSAGE_MAP(CWIATestView, CFormView)
//{{AFX_MSG_MAP(CWIATestView)
    ON_NOTIFY(TVN_SELCHANGED, IDC_DEVICE_ITEM_TREE, OnSelchangedDeviceItemTree)
    ON_CBN_SELCHANGE(IDC_DEVICELIST_COMBO, OnSelchangeDevicelistCombo)
    ON_NOTIFY(NM_DBLCLK, IDC_LIST_ITEMPROP, OnDblclkListItemprop)
    ON_COMMAND(ID_GETIMAGEDLG, OnGetimagedlg)
    ON_COMMAND(ID_IDTGETBANDED, OnIdtgetbanded)
    ON_COMMAND(ID_WIADATA, OnWiadata)
    ON_COMMAND(ID_ADDDEVICE, OnAdddevice)
    ON_COMMAND(ID_REFRESH, OnRefresh)
    ON_COMMAND(ID_VIEW_TRANSFER_TOOLBAR, OnViewTransferToolbar)
    ON_COMMAND(ID_EXECUTECOMMAND, OnExecutecommand)
    ON_COMMAND(ID_DUMPDRVITEM_INFO, OnDumpdrvitemInfo)
    ON_COMMAND(ID_DUMPAPPITEM_INFO, OnDumpappitemInfo)
    ON_WM_PAINT()
    ON_BN_CLICKED(IDC_PAINTMODE_CHECKBOX, OnPaintmodeCheckbox)
    ON_COMMAND(ID_RESETSTI, OnResetsti)
    ON_COMMAND(ID_FULLPREVIEW, OnFullpreview)
    ON_BN_CLICKED(IDC_THUMBNAILMODE, OnThumbnailmode)
    ON_COMMAND(ID_DELETEITEM, OnDeleteitem)
    ON_CBN_SELCHANGE(IDC_TYMED_COMBOBOX, OnSelchangeTymedCombobox)
    ON_CBN_SELCHANGE(IDC_CLIPBOARDFORMAT_COMBOBOX, OnSelchangeClipboardFormatCombobox)
    ON_UPDATE_COMMAND_UI(ID_VIEW_TRANSFER_TOOLBAR, OnUpdateViewTransferToolbar)
    ON_BN_CLICKED(IDC_PLAYAUDIO_BUTTON, OnPlayaudioButton)
    ON_COMMAND(ID_GETROOTITEMTEST, OnGetrootitemtest)
    ON_COMMAND(ID_REENUMITEMS, OnReenumitems)
    ON_COMMAND(ID_SAVEPROPSTREAM, OnSavepropstream)
    ON_COMMAND(ID_LOADPROPSTREAM, OnLoadpropstream)
    ON_COMMAND(ID_GET_SET_PROPSTREAM_TEST, OnGetSetPropstreamTest)
    ON_COMMAND(ID_ANALYZE, OnAnalyzeItem)
    ON_COMMAND(ID_CREATE_CHILD_ITEM, OnCreateChildItem)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CWIATestView construction/destruction

CWIATestView::CWIATestView()
: CFormView(CWIATestView::IDD)
{
    //{{AFX_DATA_INIT(CWIATestView)
    m_FileName = _T("");
    m_GUIDDisplay = _T("");
    //}}AFX_DATA_INIT
    m_pIWiaDevMgr = NULL;
    m_pDIB = NULL;
    m_pPreviewWindow = NULL;
    m_pFullPreviewWindow = NULL;
    m_PaintMode = PAINT_TOFIT;
    m_bThumbnailMode = FALSE;
    m_pThumbNail = NULL;
    m_hBitmap = NULL;
}

/**************************************************************************\
* CWIATestView::~CWIATestView()
*
*   Destructor for WIA object:
*   Deletes WIA preview window
*   Deletes FULL preview window
*   unregisters for Events
*
*
* Arguments:
*
*   none
*
*
*
* Return Value:
*
*    status
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
CWIATestView::~CWIATestView()
{

    //
    // delete preview window pointer, if exists
    //

    if (m_pPreviewWindow != NULL)
        delete m_pPreviewWindow;

    //
    // delete FULL preview window pointer, if exists
    //

    if (m_pFullPreviewWindow != NULL) {
        m_pFullPreviewWindow->DestroyWindow();
        delete m_pFullPreviewWindow;
    }

    //
    // unregister from events
    //

    UnRegisterForAllEventsByInterface();
}

/**************************************************************************\
* CWIATestView::DoDataExchange()
*
*   Maps messages from controls to member variables
*
*
* Arguments:
*
*   pDX - CDataExchange object
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::DoDataExchange(CDataExchange* pDX)
{
    CFormView::DoDataExchange(pDX);
    //{{AFX_DATA_MAP(CWIATestView)
    DDX_Control(pDX, IDC_PLAYAUDIO_BUTTON, m_PlayAudioButton);
        DDX_Control(pDX, IDC_TYMED_COMBOBOX, m_TymedComboBox);
        DDX_Control(pDX, IDC_THUMBNAIL, m_ThumbnailImage);
        DDX_Control(pDX, IDC_PREVIEW, m_PreviewFrame);
        DDX_Control(pDX, IDC_LIST_ITEMPROP, m_ItemPropertyListControl);
        DDX_Control(pDX, IDC_DEVICELIST_COMBO, m_DeviceListComboBox);
        DDX_Control(pDX, IDC_DEVICE_ITEM_TREE, m_ItemTree);
        DDX_Control(pDX, IDC_CLIPBOARDFORMAT_COMBOBOX, m_ClipboardFormatComboBox);
        DDX_Text(pDX, IDC_FILENAME_EDITBOX, m_FileName);
    //}}AFX_DATA_MAP
}
/**************************************************************************\
* CWIATestView::PreCreateWindow()
*
* Sets window creation parameters.
*
*
* Arguments:
*
*   cs - CREATESTRUCT, window construction params
*
* Return Value:
*
*   status
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
BOOL CWIATestView::PreCreateWindow(CREATESTRUCT& cs)
{
    return CFormView::PreCreateWindow(cs);
}
/**************************************************************************\
* CWIATestView::OnInitialUpdate()
*
*   Initialization routine for FORM
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnInitialUpdate()
{
    CFormView::OnInitialUpdate();

    //
    // Set default file name
    //

    m_AudioFileName = "test.wav";
    m_FileName = "c:\\test";
    UpdateData(FALSE);

    //
    // hide audio play button
    //

    m_PlayAudioButton.ShowWindow(SW_HIDE);

    //
    // resize mainframe to fit resource template
    //

    GetParentFrame()->RecalcLayout();
    ResizeParentToFit(FALSE);

    //
    // set transfer type radio button
    //

    CButton* pRadioButton = (CButton*)GetDlgItem(IDC_TOMEMORY);
    if (pRadioButton != NULL)
        pRadioButton->SetCheck(1);

    //
    // initialize clipboard type combo box
    //

    m_ClipboardFormatComboBox.InitClipboardFormats(NULL,NULL);

    //
    // initialize tymed combo box
    //

    m_TymedComboBox.InitTymedComboBox();

    //
    // initialize headers for Property list control
    //

    m_ItemPropertyListControl.InitHeaders();

    //
    // initialize headers for Item tree control
    //

    m_ItemTree.InitHeaders();

    if(FAILED(m_WIA.Initialize())){
        AfxMessageBox("WIA did not initialize correctly..");
        exit(0);
    }

    HRESULT hResult = S_OK;
    hResult = EnumerateWIADevices();
    if (SUCCEEDED(hResult))
         StressStatus("Device Enumeration Successful");
    else
         StressStatus("* EnumerateWIADevices() Failed",hResult);

    if (((CWIATestApp*)AfxGetApp())->GetDeviceIDCommandLine() == "") {
        if (m_WIA.GetWIADeviceCount() > 0) {

            if (!DoDefaultUIInit()) {
                StressStatus("* WIATest UI Failed attempting to do DEFAULT UI setup");
                exit(0);
            }
        } else {
            AfxMessageBox("There are no WIA devices on this system..WIATEST will now exit");
            exit(0);
        }
    } else
        if (!DoCmdLineUIInit(((CWIATestApp*)AfxGetApp())->GetDeviceIDCommandLine()))
            StressStatus("* WIATest UI Failed attempting to do CommandLine UI setup");

    if (m_pPreviewWindow == NULL) {
        m_pPreviewWindow = new CWIAPreview;
        if (m_pPreviewWindow != NULL) {
            RECT PreviewFrameRect;
            m_PreviewFrame.GetWindowRect(&PreviewFrameRect);
            ScreenToClient(&PreviewFrameRect);
            if (!m_pPreviewWindow->Create(NULL,"WIA Preview Window",WS_CHILD|WS_BORDER|WS_VSCROLL|WS_HSCROLL|WS_VISIBLE,PreviewFrameRect,this,NULL)) {
                StressStatus("Preview Window Failed to create..",0);
            } else {

                //
                // hide the place holder frame
                //

                m_PreviewFrame.ShowWindow(SW_HIDE);

                //
                // hide both scroll bars
                //

                m_pPreviewWindow->ShowScrollBar(SB_BOTH,FALSE);

                //
                // paint NULL image (white background)
                //

                DisplayImage();
            }
        }
    }

    //
    // Register for Connect / Disconnect Events
    //

    RegisterForAllEventsByInterface();

    GetDocument()->SetTitle(m_DeviceListComboBox.GetCurrentDeviceName());
    ((CMainFrame*)GetParent())->ActivateSizing(TRUE);
}

/////////////////////////////////////////////////////////////////////////////
// CWIATestView diagnostics

#ifdef _DEBUG
void CWIATestView::AssertValid() const
{
    CFormView::AssertValid();
}

void CWIATestView::Dump(CDumpContext& dc) const
{
    CFormView::Dump(dc);
}

CWIATestDoc* CWIATestView::GetDocument() // non-debug version is inline
{
    ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CWIATestDoc)));
    return(CWIATestDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CWIATestView message handlers

/**************************************************************************\
* CWIATestView::EnumerateWIADevices()
*
*   Enumerates all WIA devices on the system
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   status
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
HRESULT CWIATestView::EnumerateWIADevices()
{
    HRESULT hResult = S_OK;
    LONG cItemRoot = 0;
    BOOL bRet = FALSE;

    int DeviceIndex = 0;
    m_DeviceListComboBox.ResetContent();

    //
    // attempt to enumerate WIA devices
    //

    m_WIA.Auto_ResetDeviceEnumerator();
    WIADEVICENODE* pDeviceNode = NULL;

    do {
        pDeviceNode = m_WIA.Auto_GetNextDevice();
        if (pDeviceNode != NULL) {
            BSTR bstrDeviceID = ::SysAllocString(pDeviceNode->bstrDeviceID);
            BSTR bstrDeviceName = ::SysAllocString(pDeviceNode->bstrDeviceName);
            BSTR bstrServerName = ::SysAllocString(pDeviceNode->bstrServerName);

            m_DeviceListComboBox.AddDeviceID(DeviceIndex, bstrDeviceName, bstrServerName, bstrDeviceID);
            StressStatus((CString)bstrDeviceName + " Found..");

            //
            // Free BSTRs allocated
            //

            ::SysFreeString(bstrDeviceName);
            ::SysFreeString(bstrServerName);

            DeviceIndex++;
        }
    } while (pDeviceNode != NULL);

    //
    // No devices found during enumeration?
    //

    if (DeviceIndex == 0) {
        m_DeviceListComboBox.AddDeviceID(-1, NULL, NULL, NULL);
        StressStatus("* No WIA Devices Found");
    }

    //
    // set the default combo box settings
    //

    m_DeviceListComboBox.SetCurSel(0);

    return  hResult;
}
/**************************************************************************\
* CWIATestView::DoDefaultUIInit()
*
*   Handles default launch initialization of parameters
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   status
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
BOOL CWIATestView::DoDefaultUIInit()
{
    int nDeviceNum = 0;
    HRESULT hResult = S_OK;
    if (SUCCEEDED(m_WIA.CreateWIADevice(m_DeviceListComboBox.GetCurrentDeviceID()))){
        if (!m_ItemTree.BuildItemTree(m_WIA.GetItemTreeList()))
        StressStatus("* BuildItemTree Failed");
       else{
       OnSelchangeTymedCombobox();
       m_ItemPropertyListControl.DisplayItemPropData(m_WIA.GetRootIWiaItem());
       }
    }else{
        if(IsWindow(m_ItemPropertyListControl.m_hWnd))
            m_ItemPropertyListControl.DeleteAllItems();
        if(IsWindow(m_ItemTree.m_hWnd))
            m_ItemTree.DeleteAllItems();
        return FALSE;
    }
    return TRUE;
}
/**************************************************************************\
* CWIATestView::DoCmdLineUIInit()
*
*   Handles command line launch initialization
*
*
* Arguments:
*
*   CmdLine - Device ID used to set the default device
*
*
* Return Value:
*
*   status
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
BOOL CWIATestView::DoCmdLineUIInit(CString CmdLine)
{
    int nDeviceNum = 0;
    HRESULT hResult = S_OK;
    m_DeviceListComboBox.SetCurrentSelFromID(CmdLine);
    if (SUCCEEDED(m_WIA.CreateWIADevice(m_DeviceListComboBox.GetCurrentDeviceID()))) {
        if (!m_ItemTree.BuildItemTree(m_WIA.GetItemTreeList()))
            StressStatus("* BuildItemTree Failed");
        else {
            OnSelchangeTymedCombobox();
            m_ItemPropertyListControl.DisplayItemPropData(m_WIA.GetRootIWiaItem());
        }
    }else{
        m_ItemPropertyListControl.DeleteAllItems();
        m_ItemTree.DeleteAllItems();
    }
    return TRUE;
}
/**************************************************************************\
* CWIATestView::OnSelchangedDeviceItemTree()
*
*   Handles the message for changing item selection in the device Item tree
*
*
* Arguments:
*
*   pNMHDR - Notification handler
*   pResult - result after notification is handled
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnSelchangedDeviceItemTree(NMHDR* pNMHDR, LRESULT* pResult)
{
    NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
    IWiaItem* pIWiaItem = NULL;
    WIAITEMTREENODE* pWiaItemTreeNode = NULL;
    if (m_ItemTree.GetCount() > 1) {
        POSITION Position = (POSITION)pNMTreeView->itemNew.lParam;
        if (Position) {
#ifdef _SMARTUI
            if (m_WIA.IsRoot(Position)) {

                //
                // enable GetImageDlg button
                //

                CMainFrame* pMainFrm = (CMainFrame*)GetParent();
                if(!pMainFrm->HideToolBarButton(IDR_TRANSFER_TOOLBAR,ID_GETIMAGEDLG,FALSE))
                    StressStatus("* GetImageDlg Button failed to be unhidden..");
            } else {

                //
                // disable GetImageDlg button
                //

                CMainFrame* pMainFrm = (CMainFrame*)GetParent();
                if(!pMainFrm->HideToolBarButton(IDR_TRANSFER_TOOLBAR,ID_GETIMAGEDLG,TRUE))
                    StressStatus("* GetImageDlg Button failed to be hidden..");
            }
#endif
            pWiaItemTreeNode = m_WIA.GetAt(Position);
            if (pWiaItemTreeNode!= NULL) {
                pIWiaItem = pWiaItemTreeNode->pIWiaItem;
                if (pIWiaItem != NULL) {

                    //
                    // display Item information
                    //

                    m_ItemPropertyListControl.DisplayItemPropData(pIWiaItem,TRUE);

                    if (m_bThumbnailMode) {

                        //
                        // display item's thumbnail only if it's a child item, and
                        // only if it's a camera child item
                        //

                        if ( (m_WIA.GetRootItemType() == StiDeviceTypeDigitalCamera) ||
                             (m_WIA.GetRootItemType() == StiDeviceTypeStreamingVideo) ) {
                            if (!m_WIA.IsRoot(Position) && !m_WIA.IsFolder(Position))
                                DisplayItemThumbnail(pIWiaItem);
                        }
                    }
                    if ((m_WIA.GetRootItemType() == StiDeviceTypeDigitalCamera) ||
                        (m_WIA.GetRootItemType() == StiDeviceTypeStreamingVideo)) {
                        if (!m_WIA.IsRoot(Position) && !m_WIA.IsFolder(Position)) {
                            if (ItemHasAudio(pIWiaItem))
                                m_PlayAudioButton.ShowWindow(SW_SHOW);
                            else
                                m_PlayAudioButton.ShowWindow(SW_HIDE);
                        }
                        else
                            m_PlayAudioButton.ShowWindow(SW_HIDE);
                    }

                    OnSelchangeTymedCombobox();
                }
            }
        }
    }
    *pResult = 0;
}
/**************************************************************************\
* CWIATestView::OnSelchangeDevicelistCombo()
*
*   Handles the message for changing current devices in the device combo box
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnSelchangeDevicelistCombo()
{
    DoDefaultUIInit();
    GetDocument()->SetTitle(m_DeviceListComboBox.GetCurrentDeviceName());
}
/**************************************************************************\
* CWIATestView::OnDblclkListItemprop()
*
* Handles the message for double-clicking on an item in the list control
*
* Arguments:
*
*   pNMHDR - Notification handler
*   pResult - result after notification is handled
*
*
* Return Value:
*
*    status
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnDblclkListItemprop(NMHDR* pNMHDR, LRESULT* pResult)
{
    CPropEdit       Edit;
    CPropEditRange  EditRange;
    CPropEditList   EditList;
    CPropEditFlags  EditFlags;

    int EditType = EDIT_NONE;
    ULONG AccessFlags = 0;
    PROPVARIANT     AttrPropVar;
    PROPSPEC PropSpec;

    HRESULT             hResult = S_OK;
    IWiaPropertyStorage *pIWiaPropStg;

    int nResponse = 0;

    //
    // find out what property is selected
    //

    HD_NOTIFY*  phdn = (HD_NOTIFY *) pNMHDR;
    LV_ITEM     lvitem;
    LONG iProp = 0;
    int item = phdn->iItem;

    //
    // is it a valid item?
    //

    if (item < 0)
        return;

    //
    // set property values to null ("")
    //

    CString strProp = "";
    CString strValue = "";

    //
    // Get selected values
    //

    strProp = m_ItemPropertyListControl.GetItemText(item,0);
    strValue = m_ItemPropertyListControl.GetItemText(item,1);
    lvitem.mask     = LVIF_PARAM;
    lvitem.iItem    = item;
    lvitem.iSubItem = 0;

    m_ItemPropertyListControl.GetItem(&lvitem);

    //
    // Assign Prop ID
    //

    iProp = (LONG)lvitem.lParam;

    //
    // setup dialogs with selected values (any one could be the selected type)
    //

    Edit.SetPropertyValue(strValue);
    Edit.SetPropertyName(strProp);

    EditRange.SetPropertyValue(strValue);
    EditRange.SetPropertyName(strProp);

    EditList.SetPropertyValue(strValue);
    EditList.SetPropertyName(strProp);

    EditFlags.SetPropertyValue(strValue);
    EditFlags.SetPropertyName(strProp);

    //
    // get access flags and var type
    //

    PropSpec.ulKind = PRSPEC_PROPID;
    PropSpec.propid = iProp;

    IWiaItem* pCurrentItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if (pCurrentItem != NULL && m_WIA.IsValidItem(pCurrentItem)) {
        hResult = pCurrentItem->QueryInterface(IID_IWiaPropertyStorage,(void **)&pIWiaPropStg);
        if (FAILED(hResult)) {
            StressStatus("* pCurrentItem->QueryInterface() Failed",hResult);
            return;
        } else {

            //
            // read property value for type only
            //

            PROPVARIANT     PropVar;
            hResult = pIWiaPropStg->ReadMultiple(1,&PropSpec,&PropVar);
            if (hResult == S_OK) {

                //
                // write TYPE to Dialogs
                //

                Edit.SetPropertyType(PropVar.vt);
                EditRange.SetPropertyType(PropVar.vt);
                EditList.SetPropertyType(PropVar.vt);
                EditFlags.SetPropertyType(PropVar.vt);
                EditFlags.SetPropID((USHORT)iProp);
            } else
                StressStatus("* pIWiaPropStg->ReadMultiple() Failed",hResult);
        }
        hResult = pIWiaPropStg->GetPropertyAttributes(1, &PropSpec,&AccessFlags,&AttrPropVar);
        if (FAILED(hResult)) {
            StressStatus("* pCurrentItem->GetPropertyAttributes() Failed",hResult);
            hResult = S_OK; // do this to continue property traversal
        } else {

            //
            // check access flags
            //

            if ((AccessFlags & WIA_PROP_NONE)) {
                EditType = EDIT_NONE;
            }

            else if ((AccessFlags & WIA_PROP_RANGE)) {
                EditType = EDIT_RANGE;
                if (AttrPropVar.caul.cElems == 4) {
                    if (EditRange.m_VT == VT_R4) {

                        EditRange.SetRangeValues(
                                                (float)AttrPropVar.caflt.pElems[WIA_RANGE_MIN],
                                                (float)AttrPropVar.caflt.pElems[WIA_RANGE_MAX],
                                                (float)AttrPropVar.caflt.pElems[WIA_RANGE_NOM],
                                                (float)AttrPropVar.caflt.pElems[WIA_RANGE_STEP]);
                    } else {

                        EditRange.SetRangeValues(
                                                (int)AttrPropVar.caul.pElems[WIA_RANGE_MIN],
                                                (int)AttrPropVar.caul.pElems[WIA_RANGE_MAX],
                                                (int)AttrPropVar.caul.pElems[WIA_RANGE_NOM],
                                                (int)AttrPropVar.caul.pElems[WIA_RANGE_STEP]);
                    }
                } else {

                    //
                    // elements does not equal 4
                    //

                    StressStatus("Range does not contain 4 elements");
                }
            }

            else if ((AccessFlags & WIA_PROP_LIST)) {
                UINT nElem = 0;
                EditType = EDIT_LIST;
                if(EditList.m_VT == VT_CLSID)
                    EditList.SetArray((BYTE*)AttrPropVar.cauuid.pElems, WIA_PROP_LIST_COUNT(&AttrPropVar));
                else
                    EditList.SetArray((BYTE*)AttrPropVar.caul.pElems, WIA_PROP_LIST_COUNT(&AttrPropVar));

            } else if ((AccessFlags & WIA_PROP_FLAG) == WIA_PROP_FLAG) {

                //
                // do flag dialog initialization here...
                //

                EditType = EDIT_FLAGS;
            }
        }

        //
        // determine which dialog to display
        //

        switch (EditType) {
        case EDIT_LIST:
            nResponse = (int) (INT_PTR)EditList.DoModal();
            break;
        case EDIT_RANGE:
            nResponse = (int) (INT_PTR)EditRange.DoModal();
            break;
        case EDIT_FLAGS:
            nResponse = (int) (INT_PTR)EditFlags.DoModal();
            break;
        default:
            nResponse = (int) (INT_PTR)Edit.DoModal();
            break;
        }
        if ((nResponse == IDOK) && (pCurrentItem != NULL)) {
            LONG lVal = 0;
            int iret = 0;

            if (EditType == EDIT_FLAGS) {
                hResult = WriteProp(EditFlags.m_VT, iProp, pIWiaPropStg, EditFlags.m_EditString.GetBuffer(20));
                if (hResult != S_OK)
                     StressStatus("* WriteProp Failed Writing FLAG values",hResult);
            } else if (EditType == EDIT_LIST) {
                hResult = WriteProp(EditList.m_VT, iProp, pIWiaPropStg, EditList.m_EditString.GetBuffer(20));
                if (hResult != S_OK)
                     StressStatus("* WriteProp Failed Writing LIST values",hResult);
            } else if (EditType == EDIT_RANGE) {
                hResult = WriteProp(EditRange.m_VT, iProp, pIWiaPropStg, EditRange.m_EditString.GetBuffer(20));
                if (hResult != S_OK)
                     StressStatus("* WriteProp Failed Writing RANGE values",hResult);
            } else {
                hResult = WriteProp(Edit.m_VT, iProp, pIWiaPropStg, Edit.m_EditString.GetBuffer(20));
                if (hResult != S_OK)
                     StressStatus("* WriteProp Failed Writing values",hResult);
            }

            //
            // release IPropStg and IWiaItem
            //

            pIWiaPropStg->Release();
            OnRefresh();
        }
    }
    *pResult = 0;
}

/**************************************************************************\
* CWIATestView::OnGetimagedlg()
*
*   Executes the GetImageDlg() call setting the intent
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnGetimagedlg()
{
    UpdateData(TRUE);
    m_WIA.SetFileName(m_FileName);
    HRESULT hResult = S_OK;
    hResult = m_WIA.DoGetImageDlg(m_hWnd, 0,0,WIA_INTENT_IMAGE_TYPE_GRAYSCALE|WIA_INTENT_MINIMIZE_SIZE,m_TymedComboBox.GetCurrentTymed(),m_ClipboardFormatComboBox.GetCurrentClipboardFormat());
    DisplayImage();
}
/**************************************************************************\
* CWIATestView::OnIdtgetbanded
*
*   Initiates a banded transfer using the currently selected item
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnIdtgetbanded()
{
    UpdateData(TRUE);
    m_WIA.SetFileName(m_FileName);
    HRESULT hResult = S_OK;
    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if (pIWiaItem != NULL){
        m_WIA.SetPreviewWindow(m_pPreviewWindow->m_hWnd);
        hResult = m_WIA.DoIWiaDataBandedTransfer(pIWiaItem,m_TymedComboBox.GetCurrentTymed(),m_ClipboardFormatComboBox.GetCurrentClipboardFormat());
        DisplayImage();
    }
}
/**************************************************************************\
* CWIATestView::
*
*   Initiates a IWiaDataTransfer, using the currently selected item
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnWiadata()
{
    UpdateData(TRUE);
    m_WIA.SetFileName(m_FileName);
    HRESULT hResult = S_OK;
    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if (pIWiaItem != NULL && m_WIA.IsValidItem(pIWiaItem)){
        hResult = m_WIA.DoIWiaDataGetDataTransfer(pIWiaItem,m_TymedComboBox.GetCurrentTymed(),m_ClipboardFormatComboBox.GetCurrentClipboardFormat());
        DisplayImage();
    }
}
/**************************************************************************\
* CWIATestView::OnAdddevice()
*
*   Creates a thread to add a device to the Device list combo box
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnAdddevice()
{
    static HANDLE   hAddDeviceThread;
    static DWORD    dwAddDeviceThreadId;
    hAddDeviceThread = CreateThread(NULL,0, &AddDeviceThread,0,0,&dwAddDeviceThreadId);
    if (!hAddDeviceThread)
        StressStatus("* CreateThread failed");
}
/**************************************************************************\
* CWIATestView::OnRefresh()
*
*   Forces a refresh of the selected items property data
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnRefresh()
{
    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if (pIWiaItem != NULL && m_WIA.IsValidItem(pIWiaItem))
        m_ItemPropertyListControl.DisplayItemPropData(pIWiaItem);
}

/**************************************************************************\
* AddDeviceThread
*
*   This is a thread that controls adding a device to the device combo box
*
*
* Arguments:
*
*   pParam - not used at this time (extra information)
*
* Return Value:
*
*    status
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
ULONG _stdcall AddDeviceThread(LPVOID pParam)
{
    HRESULT hResult = S_OK;
    CWIATestApp* pApp = (CWIATestApp*)AfxGetApp();
    CMainFrame* pFrame = (CMainFrame*)pApp->GetMainWnd();
    CWIATestView* pView = (CWIATestView*)pFrame->GetActiveView();
    IWiaItem* pIWiaItem = NULL;
    IWiaDevMgr* pIWiaDevMgr = NULL;

    //
    // initlialize OLE libs
    //

    hResult = ::OleInitialize(NULL);
    if (hResult != S_OK)
        StressStatus("* OleInitialize failed!");

    //
    // if OleInitialize is successful call CoCreateInstance for IWiaDevMgr
    //

    if (hResult == S_OK) {

        //
        // initialize IWiaDevMgr
        //

        hResult = CoCreateInstance(CLSID_WiaDevMgr, NULL, CLSCTX_LOCAL_SERVER,
                                   IID_IWiaDevMgr,(void**)&pIWiaDevMgr);
        if (hResult != S_OK)
            StressStatus("* CoCreateInstance failed - pIWiaDevMgr not created");
        else {
            StressStatus("CoCreateInstance Successful - pIWiaDevMgr created");

            hResult = pIWiaDevMgr->AddDeviceDlg(pFrame->m_hWnd,0);
            if (SUCCEEDED(hResult)){

                //
                // refresh device list
                //

                pView->RefreshDeviceList();
                pView->EnumerateWIADevices();

                //
                // set the default combo box settings
                //

                pView->m_DeviceListComboBox.SetCurSel(0);
            }
            else
                StressStatus("* No Device added ");

            pIWiaDevMgr->Release();
        }
    }
    ::OleUninitialize();
    return 0;
}
/**************************************************************************\
* CWIATestView::OnViewTransferToolbar()
*
*   Enables/Disables the Transfer toolbar
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnViewTransferToolbar()
{
    CMainFrame* pMainFrame = (CMainFrame*)GetParent();
    if (pMainFrame != NULL) {
        if (pMainFrame->IsToolBarVisible(IDR_TRANSFER_TOOLBAR)) {

            //
            // hide toolbar
            //

            pMainFrame->ShowToolBar(IDR_TRANSFER_TOOLBAR,FALSE);
        } else {

            //
            // show toolbar
            //

            pMainFrame->ShowToolBar(IDR_TRANSFER_TOOLBAR,TRUE);
        }
    }
}

/**************************************************************************\
* CWIATestView::DisplayImage
*
*   paints the current DIB to the preview area
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*    void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::DisplayImage()
{
    m_pDIB = m_WIA.GetDIB();
    m_pPreviewWindow->SetPaintMode(m_PaintMode);
    m_pPreviewWindow->SetDIB(m_pDIB);
    m_pPreviewWindow->Invalidate();

    if (m_pFullPreviewWindow != NULL) {
        if (m_pFullPreviewWindow->m_hWnd != NULL) {
            m_pFullPreviewWindow->SetPaintMode(PAINT_ACTUAL);
            m_pFullPreviewWindow->SetDIB(m_pDIB);
            m_pFullPreviewWindow->CleanBackground();
            m_pFullPreviewWindow->Invalidate();
        }
    }
}
/**************************************************************************\
* CWIATestView::OnExecutecommand()
*
*   Calls the DeviceCommand dialog, to execute device commands
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnExecutecommand()
{
    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if (pIWiaItem != NULL && m_WIA.IsValidItem(pIWiaItem)) {
        CDeviceCmdDlg DeviceCommandDlg;
        DeviceCommandDlg.Initialize(pIWiaItem);
        DeviceCommandDlg.DoModal();
        OnSelchangeDevicelistCombo();
    }
}
/**************************************************************************\
* CWIATestView::RegisterForAllEventsByInterface()
*
*   Register this application for CONNECT/DISCONNECT events
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::RegisterForAllEventsByInterface()
{
    //
    // register connected event
    //

    m_pConnectEventCB = new CEventCallback;
    m_pDisConnectEventCB = new CEventCallback;
    m_WIA.RegisterForConnectEvents(m_pConnectEventCB);
    m_WIA.RegisterForDisConnectEvents(m_pDisConnectEventCB);
}
/**************************************************************************\
* CWIATestView::UnRegisterForAllEventsByInterface()
*
*   Unregister this application from CONNECT/DISCONNECT events
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::UnRegisterForAllEventsByInterface()
{
    m_WIA.UnRegisterForConnectEvents(m_pConnectEventCB);
    m_WIA.UnRegisterForDisConnectEvents(m_pDisConnectEventCB);
}
/**************************************************************************\
* CWIATestView::UpdateUI()
*
*   Updates the UI by posting a selection change message on the Device list
*   combo box.
*   note: this is called externally, after a CONNECT/DISCONNECT event is trapped
*
*
* Arguments:
*
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::UpdateUI()
{
    OnSelchangeDevicelistCombo();
}
/**************************************************************************\
* CWIATestView::OnDumpdrvitemInfo()
*
*   Dump Driver item information for DEBUGGING ONLY
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnDumpdrvitemInfo()
{
    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if (pIWiaItem != NULL && m_WIA.IsValidItem(pIWiaItem)) {
        CItemInfoDlg ItemInfoDlg;
        ItemInfoDlg.Initialize(pIWiaItem,FALSE);
        ItemInfoDlg.DoModal();
    }
}
/**************************************************************************\
* CWIATestView::OnDumpappitemInfo()
*
*   Dump Application item information for DEBUGGING ONLY
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnDumpappitemInfo()
{
    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if (pIWiaItem != NULL && m_WIA.IsValidItem(pIWiaItem)) {
        CItemInfoDlg ItemInfoDlg;
        ItemInfoDlg.Initialize(pIWiaItem,TRUE);
        ItemInfoDlg.DoModal();
    }
}
/**************************************************************************\
* CWIATestView::OnPaint()
*
*   Handles the painting of the application window
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnPaint()
{
    CPaintDC dc(this); // device context for painting
}
/**************************************************************************\
* CWIATestView::OnPaintmodeCheckbox()
*
*   Enables/Disables 1 to 1 painting setting for the preview window
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnPaintmodeCheckbox()
{
    if (m_PaintMode == PAINT_TOFIT)
        m_PaintMode = PAINT_ACTUAL;
    else
        m_PaintMode = PAINT_TOFIT;
    DisplayImage();
}
/**************************************************************************\
* CWIATestView::OnResetsti()
*
*   Force STI to reset the current selected device.
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnResetsti()
{
    //
    // UnRegister from Connect / Disconnect Events
    //

    UnRegisterForAllEventsByInterface();

    //
    // cleanup all WIA devices
    //

    m_WIA.Shutdown();

    PSTI pSti;
    IStiDevice  *pIStiDevice;
    HRESULT     hResult = S_OK;

    hResult = StiCreateInstance(GetModuleHandle(NULL), STI_VERSION, &pSti, NULL);
    if (hResult != S_OK)
        StressStatus("* StiCreateInstance() Failed",hResult);
    else {
        hResult = pSti->CreateDevice(m_DeviceListComboBox.GetCurrentDeviceID(), STI_DEVICE_CREATE_STATUS, &pIStiDevice, NULL);
        if (hResult != S_OK)
            StressStatus("* pSti->CreateDevice() Failed",hResult);
        else {
            hResult = pIStiDevice->LockDevice(2000);
            if (hResult != S_OK)
                StressStatus("* pIStiDevice->LockDevice(2000) Failed",hResult);
            else {
                StressStatus("STI device is locked");
                pIStiDevice->DeviceReset();
                StressStatus("STI device is reset");
                pIStiDevice->UnLockDevice();
                StressStatus("STI device is unlocked");
                pIStiDevice->Release();
                pSti->Release();
            }
        }
    }

    m_WIA.Restart();

    //
    // Reform UI
    //

    DoDefaultUIInit();

    //
    // Register for Connect / Disconnect Events
    //

    RegisterForAllEventsByInterface();
}
/**************************************************************************\
* CWIATestView::OnFullpreview()
*
*   Initiate a full preview window (scrolling enabled for larger pictures)
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnFullpreview()
{
    if (m_pFullPreviewWindow == NULL) {
        m_pFullPreviewWindow = new CWIAPreview;
        if (m_pFullPreviewWindow != NULL) {
            RECT PreviewFrameRect;
            PreviewFrameRect.left = 0;
            PreviewFrameRect.top = 0;
            PreviewFrameRect.right = 400;
            PreviewFrameRect.bottom = 400;
            if (!m_pFullPreviewWindow->CreateEx(NULL,AfxRegisterWndClass(NULL),"WIA Preview Window",WS_OVERLAPPEDWINDOW|WS_VSCROLL|WS_HSCROLL|WS_VISIBLE,PreviewFrameRect,NULL,NULL,NULL)) {
                StressStatus("FULL Preview Window Failed to create..",0);
            } else {

                //
                // paint NULL image (white background)
                //

                DisplayImage();
            }
        }
    } else {
        if (m_pFullPreviewWindow->m_hWnd == NULL) {
            RECT PreviewFrameRect;
            PreviewFrameRect.left = 0;
            PreviewFrameRect.top = 0;
            PreviewFrameRect.right = 400;
            PreviewFrameRect.bottom = 400;
            if (!m_pFullPreviewWindow->CreateEx(NULL,AfxRegisterWndClass(NULL),"WIA Preview Window",WS_OVERLAPPEDWINDOW|WS_VSCROLL|WS_HSCROLL|WS_VISIBLE,PreviewFrameRect,NULL,NULL,NULL)) {
                StressStatus("FULL Preview Window Failed to create..",0);
            } else {

                //
                // paint NULL image (white background)
                //

                DisplayImage();
            }
        }
        m_pFullPreviewWindow->ShowWindow(SW_SHOW);
    }
}
/**************************************************************************\
* CWIATestView::ResizeControls()
*
*   Resize the controls along with the main frame window
*
*
* Arguments:
*
*   dx - change in width of main window
*   dy - change in height on main window
*
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::ResizeControls(int dx, int dy)
{
    m_ItemPropertyListControl.Resize(dx,dy);
}
/**************************************************************************\
* CWIATestView::OnThumbnailmode()
*
*   Enables/Disables thumbnailing for picture items on digitial cameras
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnThumbnailmode()
{
    POSITION Position = NULL;
    HTREEITEM hTreeItem = NULL;
    if (m_bThumbnailMode)
        m_bThumbnailMode = FALSE;
    else {
        IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
        if (pIWiaItem != NULL && m_WIA.IsValidItem(pIWiaItem)) {
            if ((m_WIA.GetRootItemType() == StiDeviceTypeDigitalCamera) ||
                (m_WIA.GetRootItemType() == StiDeviceTypeStreamingVideo)) {
                hTreeItem = m_ItemTree.GetSelectedItem();
                if (hTreeItem != NULL) {
                    Position = (POSITION)m_ItemTree.GetItemData(hTreeItem);
                    if (!m_WIA.IsRoot(Position) && !m_WIA.IsFolder(Position))
                        DisplayItemThumbnail(pIWiaItem);
                }
            }
        }
        m_bThumbnailMode = TRUE;
    }
}
/**************************************************************************\
* CWIATestView::DisplayItemThumbnail()
*
*   Display thumbnail for the target item
*
*
* Arguments:
*
*   pIWiaItem - Target item to thumbnail
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::DisplayItemThumbnail(IWiaItem *pIWiaItem)
{
    long ThumbNailHeight = 0;
    long ThumbNailWidth = 0;
    long ThumbNailSize = 0;

    if (m_pThumbNail != NULL) {
        LocalFree(m_pThumbNail);
        m_pThumbNail = NULL;
    }

    if (m_hBitmap != NULL) {
        DeleteObject(m_hBitmap);
        m_hBitmap = NULL;
    }

    m_pThumbNail = NULL;
    IWiaPropertyStorage *pIWiaPropStg;
    HRESULT hResult = S_OK;
    HBITMAP hBitmap = NULL;

    // get item's thumbnail height & width and create thumbnail
    hResult = pIWiaItem->QueryInterface(IID_IWiaPropertyStorage,(void **)&pIWiaPropStg);
    if (hResult == S_OK) {

        //
        // read height
        //

        hResult = ReadPropLong(WIA_IPC_THUMB_HEIGHT, pIWiaPropStg, &ThumbNailHeight);
        if (hResult != S_OK) {
            StressStatus("* ReadPropLong(WIA_IPC_THUMB_HEIGHT) Failed",hResult);
            ThumbNailHeight = 0;
        }

        //
        // read width
        //

        hResult = ReadPropLong(WIA_IPC_THUMB_WIDTH, pIWiaPropStg, &ThumbNailWidth);
        if (hResult != S_OK) {
            StressStatus("* ReadPropLong(WIA_IPC_THUMB_WIDTH) Failed",hResult);
            ThumbNailWidth = 0;
        }

        //
        // read thumbnail data
        //

        PROPVARIANT  PropVar[1];
        PROPSPEC PropSpec[1];
        memset(PropVar, 0, sizeof(PropVar));
        PropSpec[0].ulKind = PRSPEC_PROPID;
        PropSpec[0].propid = WIA_IPC_THUMBNAIL;

        hResult = pIWiaPropStg->ReadMultiple(1, PropSpec, PropVar);
        if (hResult != S_OK) {
            StressStatus("* ReadMultiple()  asking for WIA_IPC_THUMBNAIL Failed",hResult);
            m_pThumbNail = NULL;
        } else {
            ThumbNailSize   = ThumbNailWidth * ThumbNailHeight * 3;
            if (ThumbNailSize != (LONG)PropVar[0].caub.cElems) {

                //
                // force size to thumbnail's suggested size
                //

                ThumbNailSize = PropVar[0].caub.cElems;
            }
            m_pThumbNail = (PBYTE)LocalAlloc(LPTR,ThumbNailSize);
            if (m_pThumbNail != NULL) {
                memcpy(m_pThumbNail,PropVar[0].caub.pElems,ThumbNailSize);

                HDC hdc = ::GetDC(NULL);
                HDC hdcm = CreateCompatibleDC(hdc);

                BITMAPINFO bmi;
                bmi.bmiHeader.biSize            = sizeof(BITMAPINFOHEADER);
                bmi.bmiHeader.biWidth           = ThumbNailWidth;
                bmi.bmiHeader.biHeight          = ThumbNailHeight;
                bmi.bmiHeader.biPlanes          = 1;
                bmi.bmiHeader.biBitCount        = 24;
                bmi.bmiHeader.biCompression     = BI_RGB;
                bmi.bmiHeader.biSizeImage       = 0;
                bmi.bmiHeader.biXPelsPerMeter   = 0;
                bmi.bmiHeader.biYPelsPerMeter   = 0;
                bmi.bmiHeader.biClrUsed         = 0;
                bmi.bmiHeader.biClrImportant    = 0;

                PBYTE pDib = NULL;
                m_hBitmap = CreateDIBSection(hdc,&bmi,DIB_RGB_COLORS,(void **)&pDib,NULL,0);
                memcpy(pDib,m_pThumbNail,ThumbNailSize);
                m_ThumbnailImage.SetBitmap(m_hBitmap);
                m_ThumbnailImage.Invalidate();
            }
        }

        //
        // release propstg
        //

        pIWiaPropStg->Release();
    }
}
/**************************************************************************\
* CWIATestView::OnDeleteitem()
*
*   Deletes the selected item
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnDeleteitem()
{
    HRESULT hResult = S_OK;
    POSITION TestPosition = NULL;
    POSITION Position = NULL;
    HTREEITEM hTreeItem = NULL;
    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if (pIWiaItem == NULL) {
        StressStatus("* Item selected for deletion is NULL!!!");
        return;
    }
    if ((m_WIA.GetRootItemType() == StiDeviceTypeDigitalCamera) ||
        (m_WIA.GetRootItemType() == StiDeviceTypeStreamingVideo)) {

        //
        // Get selected item (to be deleted)
        //

        hTreeItem = m_ItemTree.GetSelectedItem();
        if (hTreeItem != NULL) {

            //
            // What's the selected item's position in the
            // m_ActiveTreeList??
            //

            Position = (POSITION)m_ItemTree.GetItemData(hTreeItem);
        }

        //
        // test to make sure it's not a root item
        //

        if (!m_WIA.IsRoot(Position)) {

            if (pIWiaItem != NULL) {
                hResult = pIWiaItem->DeleteItem(0);
                if (hResult == S_OK) {

                    //
                    // release selected item
                    //

                    pIWiaItem->Release();

                    //
                    // kill item from m_ActiveTreeList
                    //

                    m_WIA.RemoveAt(Position);

                    //
                    // kill item from tree control (visual delete)
                    //

                    m_ItemTree.DeleteItem(hTreeItem);
                }
            }
        } else
            AfxMessageBox("You can not delete the Root Item");
    } else {

        //
        // Get selected item (to be deleted)
        //

        hTreeItem = m_ItemTree.GetSelectedItem();
        if (hTreeItem != NULL) {

            //
            // What's the selected item's position in the
            // m_ActiveTreeList??
            //

            Position = (POSITION)m_ItemTree.GetItemData(hTreeItem);
        }

        //
        // test to make sure it's not a root item
        //

        if (!m_WIA.IsRoot(Position)) {

            if (pIWiaItem != NULL) {
                if (MessageBox("You just attempted to delete a scanner item..\nDo you really want to execute a DeleteItem()\ncall on this scanner item to see what happens?","WIATest Testing Question",MB_YESNO|MB_ICONQUESTION) == IDYES) {
                    hResult = pIWiaItem->DeleteItem(0);
                    if (hResult == S_OK) {
                        OnReenumitems();
                    } else
                        StressStatus("* pIWiaItem->DeleteItem() called on a scanner item Failed",hResult);
                }
            }
        } else
            AfxMessageBox("You can not delete the Root Item");

    }
}
/**************************************************************************\
* CWIATestView::OnSelchangeTymedCombobox()
*
*   Handles the message for a selection change in the TYMED combo box
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnSelchangeTymedCombobox()
{
    if (m_TymedComboBox.GetCurrentTymed() != TYMED_FILE) {

        //
        // disable File Edit box
        //

        CWnd* pWnd = GetDlgItem(IDC_FILENAME_EDITBOX);
        if (pWnd != NULL)
            pWnd->EnableWindow(FALSE);
    } else {

        //
        // enable  File Edit box
        //

        CWnd* pWnd = GetDlgItem(IDC_FILENAME_EDITBOX);
        if (pWnd != NULL)
            pWnd->EnableWindow(TRUE);
    }

#ifdef _SMARTUI
    if (m_TymedComboBox.GetCurrentTymed() == TYMED_CALLBACK) {

        //
        // hide IWiaData Toolbar button and
        // unhide idtGetBanded Toolbar button
        //

        CMainFrame* pMainFrm = (CMainFrame*)GetParent();
        if(!pMainFrm->HideToolBarButton(IDR_TRANSFER_TOOLBAR,ID_IDTGETBANDED,FALSE))
            StressStatus("* idtGetBanded Button failed to be unhidden..");

        if(!pMainFrm->HideToolBarButton(IDR_TRANSFER_TOOLBAR,ID_WIADATA,TRUE))
            StressStatus("* IWiaData Button failed to be hidden..");

    } else {

        //
        // hide idtGetBanded Toolbar button and
        // unhide IWiaData Toolbar button
        //

        CMainFrame* pMainFrm = (CMainFrame*)GetParent();
        if(!pMainFrm->HideToolBarButton(IDR_TRANSFER_TOOLBAR,ID_IDTGETBANDED,TRUE))
            StressStatus("* idtGetBanded Button failed to be hidden..");

        if(!pMainFrm->HideToolBarButton(IDR_TRANSFER_TOOLBAR,ID_WIADATA,FALSE))
            StressStatus("* IWiaData Button failed to be unhidden..");
    }

#endif

    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());

    if (pIWiaItem != NULL) {
        m_WIA.EnumerateSupportedFormats(pIWiaItem);
        m_ClipboardFormatComboBox.InitClipboardFormats(m_WIA.GetSupportedFormatList(),m_TymedComboBox.GetCurrentTymed());
    }
    //
    // Force update and change..
    //

    OnSelchangeClipboardFormatCombobox();
}
/**************************************************************************\
* CWIATestView::OnSelchangeClipboardFormatCombobox()
*
*   Handles the message for a selection change in the clipboard format combo box
*
*
* Arguments:
*
*   -
*   -
*   -
*
* Return Value:
*
*    status
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnSelchangeClipboardFormatCombobox()
{
    HRESULT hResult = S_OK;
    POSITION Position = NULL;
    HTREEITEM hTreeItem = NULL;
    IWiaPropertyStorage *pIWiaPropStg;
    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if (pIWiaItem == NULL) {
        StressStatus("* Item selected for setting is NULL!!!");
        return;
    }

    //
    // Get selected item
    //

    hTreeItem = m_ItemTree.GetSelectedItem();
    if (hTreeItem != NULL) {

        //
        // What's the selected item's position in the
        // m_ActiveTreeList??
        //

        Position = (POSITION)m_ItemTree.GetItemData(hTreeItem);
    }

    //
    // test to make sure it's not a root item
    //

    if (!m_WIA.IsRoot(Position)) {
        hResult = pIWiaItem->QueryInterface(IID_IWiaPropertyStorage,(void **)&pIWiaPropStg);
        if (hResult != S_OK) {
            StressStatus("* pCurrentItem->QueryInterface() Failed",hResult);
            return;
        } else {

            //
            // Write property value for TYMED
            //

            hResult = WritePropLong(WIA_IPA_TYMED,pIWiaPropStg,m_TymedComboBox.GetCurrentTymed());
            if (hResult == S_OK)
                StressStatus("tymed Successfully written");
            else
                StressStatus("* WritePropLong(WIA_IPA_TYMED) Failed",hResult);

            //
            // Write property value for SUPPORTED WIA FORMAT
            //

            hResult = WritePropGUID(WIA_IPA_FORMAT,pIWiaPropStg,m_ClipboardFormatComboBox.GetCurrentClipboardFormat());
            if (hResult == S_OK)
                StressStatus("Format Successfully written");
            else
                StressStatus("* WritePropLong(WIA_IPA_FORMAT) Failed",hResult);

            OnRefresh();
        }
    }
}
/**************************************************************************\
* CWIATestView::OnUpdateViewTransferToolbar()
*
*   Updates the Check/uncheck display on the menu for toolbar display status
*
*
* Arguments:
*
*   pCmdUI - CommandUI handler
*
* Return Value:
*
*    status
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnUpdateViewTransferToolbar(CCmdUI* pCmdUI)
{
    CMainFrame* pMainFrm = (CMainFrame*)GetParent();
    if(pMainFrm != NULL)
        pCmdUI->SetCheck(pMainFrm->IsToolBarVisible(IDR_TRANSFER_TOOLBAR));
}
/**************************************************************************\
* CWIATestView::OnPlayaudioButton()
*
*   Plays .WAV data from an item that supports audio
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnPlayaudioButton()
{
    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if(pIWiaItem != NULL){
        IWiaPropertyStorage *pIWiaPropStg;
        PROPSPEC PropSpec[1];
        PROPVARIANT       PropVar[1];
        PropSpec[0].ulKind = PRSPEC_PROPID;
        PropSpec[0].propid = WIA_IPC_AUDIO_DATA;
        memset(PropVar, 0, sizeof(PropVar));

        HRESULT hResult = S_OK;
        hResult = pIWiaItem->QueryInterface(IID_IWiaPropertyStorage,(void **)&pIWiaPropStg);
        if (hResult == S_OK) {
            hResult = pIWiaPropStg->ReadMultiple(1, PropSpec, PropVar);
            if(hResult == S_OK){
                DWORD dwAudioSize = PropVar->caub.cElems;
                BYTE* pAudioData = PropVar->caub.pElems;
                if(pAudioData != NULL){
                    CFile AudioFile;

                    //
                    // open & write audio file
                    //

                    AudioFile.Open(m_AudioFileName,CFile::modeCreate|CFile::modeWrite,NULL);
                    AudioFile.Write(pAudioData,dwAudioSize);
                    AudioFile.Close();
                    PlaySound(m_AudioFileName,NULL,SND_FILENAME);
                    DeleteFile(m_AudioFileName);
                }
            }
            else
                StressStatus("* ReadMultiple(WIA_IPC_AUDIO_DATA) Failed",hResult);
        }
    }
}
/**************************************************************************\
* CWIATestView::ItemHasAudio()
*
*   Determines if an item supports audio data, or contains data to be accessed.
*
*
* Arguments:
*
*   pIWiaData - Target item to check for audio data
*
* Return Value:
*
*    status
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
BOOL CWIATestView::ItemHasAudio(IWiaItem* pIWiaItem)
{
    long lVal = 0;
    if (pIWiaItem != NULL) {
        IWiaPropertyStorage *pIWiaPropStg;
        HRESULT hResult = S_OK;
        hResult = pIWiaItem->QueryInterface(IID_IWiaPropertyStorage,(void **)&pIWiaPropStg);
        if (hResult == S_OK) {

            //
            // read Item's Audio flag
            //

            hResult = ReadPropLong(WIA_IPC_AUDIO_AVAILABLE, pIWiaPropStg, &lVal);
            if (hResult != S_OK){
                if(hResult != S_FALSE){
                    StressStatus("* ReadPropLong(WIA_IPC_AUDIO_AVAILABLE) Failed",hResult);
                }
                pIWiaPropStg->Release();
            }

            else
                pIWiaPropStg->Release();
            if(lVal)
                return TRUE;
            else
                return FALSE;
        }
    }
return FALSE;
}
/**************************************************************************\
* CWIATestView::RefreshDeviceList()
*
*   Called externally to force a reenumeration of WIA devices on the system
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::RefreshDeviceList()
{
    m_WIA.EnumerateAllWIADevices();
}
/**************************************************************************\
* CWIATestView::OnGetrootitemtest()
*
*   Gets the selected item, and gets the root item from it.
*   Driver and application item information are dumped.
*   DEBUGGING ONLY
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnGetrootitemtest()
{
    HRESULT hr = S_OK;
    IWiaItem* pIWiaItem = NULL;
    IWiaItem* pNewRootItem = NULL;
    pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if(pIWiaItem != NULL && m_WIA.IsValidItem(pIWiaItem)){
         hr = pIWiaItem->GetRootItem(&pNewRootItem);
         if(hr == S_OK){
                CItemInfoDlg ItemInfoDlg;
                ItemInfoDlg.Initialize(pNewRootItem,TRUE);
                ItemInfoDlg.DoModal();

                CItemInfoDlg ItemInfoDlg2;
                ItemInfoDlg2.Initialize(pNewRootItem,FALSE);
                ItemInfoDlg2.DoModal();
                pNewRootItem->Release();
         }
    }
}
/**************************************************************************\
* CWIATestView::OnReenumitems()
*
*   Force a rennumeration of all child items, preserving the ROOT item
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnReenumitems()
{
    HRESULT hResult = S_OK;
    if (SUCCEEDED(m_WIA.ReEnumerateItems())){
        if (!m_ItemTree.BuildItemTree(m_WIA.GetItemTreeList()))
        StressStatus("* BuildItemTree Failed");
       else{
       OnSelchangeTymedCombobox();
       m_ItemPropertyListControl.DisplayItemPropData(m_WIA.GetRootIWiaItem());
       }
    }else{
        m_ItemPropertyListControl.DeleteAllItems();
        m_ItemTree.DeleteAllItems();
    }

}
/**************************************************************************\
* CWIATestView::OnSavepropstream()
*
*   Writes the currently selected item's property stream to a data file
*   "propstrm.wia"
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnSavepropstream()
{
    HRESULT hResult = S_OK;
    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if(pIWiaItem != NULL && m_WIA.IsValidItem(pIWiaItem)){
        hResult = m_WIA.SavePropStreamToFile("propstrm.wia", pIWiaItem);
        if (SUCCEEDED(hResult))
            StressStatus("Stream was saved successfully...");
        else
            StressStatus("* Stream Failed to be saved...",hResult);
    }
    else
        StressStatus("* Target Item is NULL");
}
/**************************************************************************\
* CWIATestView::OnLoadpropstream()
*
*   Reads a previously saved property stream file, and creates a property
*   stream.  This stream is then set to the currently selected item.
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnLoadpropstream()
{
    HRESULT hResult = S_OK;
    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if(pIWiaItem != NULL && m_WIA.IsValidItem(pIWiaItem)){
        hResult = m_WIA.ReadPropStreamFromFile("propstrm.wia", pIWiaItem);
        if (SUCCEEDED(hResult))
            StressStatus("Stream was restored successfully...");
        else
            StressStatus("* Stream Failed to be saved...",hResult);
    }
    else
        StressStatus("* Target Item is NULL");

    //
    // Refresh property display
    //

    OnRefresh();
}
/**************************************************************************\
* CWIATestView::OnGetSetPropstreamTest()
*
*   Gets a property stream from the currently selected item, and then
*   Sets the same stream back to it.
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*    2/14/1999 Original Version
*
\**************************************************************************/
void CWIATestView::OnGetSetPropstreamTest()
{
    HRESULT hResult = S_OK;
    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if(pIWiaItem != NULL && m_WIA.IsValidItem(pIWiaItem)){
        hResult = m_WIA.GetSetPropStreamTest(pIWiaItem);
        if (SUCCEEDED(hResult))
            StressStatus("GET / SET Test was successful ");
        else
            StressStatus("* GET / SET Test Failed...",hResult);
    }
    else
        StressStatus("* Target Item is NULL");

    //
    // Refresh property display
    //

    OnRefresh();
}

/**************************************************************************\
* CWIATestView::OnAnalyzeItem()
*
*   Runs the AnalyzeItem method of the currently selected item.
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*   01/13/2000 Original Version
*
\**************************************************************************/
void CWIATestView::OnAnalyzeItem()
{
    HRESULT hResult = S_OK;
    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if(pIWiaItem != NULL && m_WIA.IsValidItem(pIWiaItem)){
        hResult = m_WIA.AnalyzeItem(pIWiaItem);
        if (SUCCEEDED(hResult)) {
            StressStatus("AnalyzeItem run successfully...");

            OnReenumitems();
        }
        else
            StressStatus("* AnalyzeItem failed...",hResult);
    }
    else
        StressStatus("* Target Item is NULL");
}

/**************************************************************************\
* CWIATestView::OnCreateChildItem()
*
*   Runs the AnalyzeItem method of the currently selected item.
*
*
* Arguments:
*
*   none
*
* Return Value:
*
*   void
*
* History:
*
*   01/13/2000 Original Version
*
\**************************************************************************/
void CWIATestView::OnCreateChildItem()
{
    HRESULT hResult = S_OK;
    IWiaItem* pIWiaItem = m_ItemTree.GetSelectedIWiaItem(m_WIA.GetItemTreeList());
    if(pIWiaItem != NULL && m_WIA.IsValidItem(pIWiaItem)){
        hResult = m_WIA.CreateChildItem(pIWiaItem);
        if (SUCCEEDED(hResult)) {
            StressStatus("Successfully created a new child item...");

            OnReenumitems();
        }
        else
            StressStatus("* CreateChildItem failed...",hResult);
    }
    else
        StressStatus("* Target Item is NULL");
}