// 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;iGetHeadPosition(); 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); }