able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/printscan/wia/test/wiatest/wiatestview.cpp

2397 lines
63 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// 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");
}
Reference in a new issue Copy permalink