archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
3.8 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/printscan/wia/test/stillvue/stillvue.cpp

1968 lines
60 KiB
Raw Blame History

/******************************************************************************
stillvue.cpp
Simple test of WDM Still Image Class
Copyright (C) Microsoft Corporation, 1997 - 1999
All rights reserved
Notes:
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
PURPOSE.
******************************************************************************/
#define INITGUID
#include "stillvue.h"
#include <dbt.h>
#include <devguid.h>
#include <pnpmgr.h>
#include "stivar.h" // stillvue local includes
//
// defined in wsti.cpp
//
extern WCHAR szFriendlyName[];
extern WCHAR szInternalName[];
extern DWORD dwStiTotal;
extern PSTI_DEVICE_INFORMATION pStiInfoPtr;
/******************************************************************************
BOOL CommandParse(HWND hWnd,UINT wMsgID,WPARAM wParam,LPARAM lParam)
Handle user menu commands.
******************************************************************************/
BOOL CommandParse(HWND hWnd,UINT wMsgID,WPARAM wParam,LPARAM lParam)
{
HRESULT hres = STI_OK;
DWORD dwSize = 0,
dwType = 0,
dwPriority = STI_TRACE_ERROR,
EscapeFunction = 0,
dwNumberOfBytes = 0;
WCHAR szMessage[] = L"Sti Compliance Test message";
WCHAR szDevKey[LONGSTRING];
char lpInData[LONGSTRING],
lpOutData[LONGSTRING];
int nReturn = 0; // generic return value
BOOL bReturn;
//
// Set the InATest semaphore
//
nInATestSemaphore = 1;
switch(wParam)
{
// IStillImage Interfaces
case IDM_CREATE_INSTANCE:
hres = StiCreateInstance(&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_GET_DEVLIST:
hres = StiEnum(&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_CREATE_DEV:
if (bAuto)
hres = StiSelect(hWnd,AUTO,&bReturn);
else
hres = StiSelect(hWnd,MANUAL,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_GET_DEVINFO:
hres = StiGetDeviceInfo(szInternalName,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_GET_DEVVAL:
hres = StiGetDeviceValue(szInternalName,
STI_DEVICE_VALUE_TWAIN_NAME,(LPBYTE) lpInData,
&dwType,DWORD(LONGSTRING),&bReturn);
hres = StiGetDeviceValue(szInternalName,
STI_DEVICE_VALUE_ISIS_NAME,(LPBYTE) lpInData,
&dwType,DWORD(LONGSTRING),&bReturn);
hres = StiGetDeviceValue(szInternalName,
STI_DEVICE_VALUE_ICM_PROFILE,(LPBYTE) lpInData,
&dwType,DWORD(LONGSTRING),&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_SET_DEVVAL:
//
// Store a dummy registry key and value
//
wcscpy(szDevKey,L"StiTestRegKey");
strcpy(lpOutData,"This is a bland statement");
dwType = REG_SZ;
dwSize = strlen(lpOutData);
//
// set the value and then retrieve it
//
hres = StiSetDeviceValue(szInternalName,
szDevKey,(LPBYTE) lpOutData,dwType,dwSize,&bReturn);
hres = StiGetDeviceValue(szInternalName,
szDevKey,(LPBYTE) lpOutData,&dwType,DWORD(LONGSTRING),&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_REGISTER_LAUNCH:
hres = StiRegister(hWnd,hThisInstance,ON,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_UNREGISTER_LAUNCH:
hres = StiRegister(hWnd,hThisInstance,OFF,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_ENABLE_HWNOTIF:
//
// Change Hw notification to inverse
//
nHWState = 0;
hres = StiEnableHwNotification(szInternalName,&nHWState,&bReturn);
DisplayLogPassFail(bReturn);
if (nHWState == 0)
nHWState = 1;
else
nHWState = 0;
hres = StiEnableHwNotification(szInternalName,&nHWState,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_GET_HWNOTIF:
//
// Look at the current HW notification state
//
nHWState = PEEK;
hres = StiEnableHwNotification(szInternalName,&nHWState,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_REFRESH_DEVBUS:
hres = StiRefresh(szInternalName,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_WRITE_ERRORLOG:
for (;lParam >= 1;lParam--)
hres = StiWriteErrLog(dwPriority,szMessage,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_IMAGE_RELEASE:
hres = StiImageRelease(&bReturn);
DisplayLogPassFail(bReturn);
break;
// IStillImage_Device Interfaces
case IDM_GET_STATUS_A:
nReturn = STI_DEVSTATUS_ONLINE_STATE;
hres = StiGetStatus(nReturn,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_GET_STATUS_B:
nReturn = STI_DEVSTATUS_EVENTS_STATE;
hres = StiGetStatus(nReturn,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_GET_STATUS_C:
nReturn = STI_DEVSTATUS_ONLINE_STATE | STI_DEVSTATUS_EVENTS_STATE;
hres = StiGetStatus(nReturn,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_GET_CAPS:
hres = StiGetCaps(&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_DEVICERESET:
hres = StiReset(&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_DIAGNOSTIC:
hres = StiDiagnostic(&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_GET_LASTERRINFO:
hres = StiGetLastErrorInfo(&bReturn);
DisplayLogPassFail(bReturn);
DisplayOutput("");
break;
case IDM_SUBSCRIBE:
hres = StiSubscribe(&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_UNSUBSCRIBE:
nUnSubscribe = 0;
DisplayOutput("");
break;
case IDM_ESCAPE_A:
//
// Set up the Escape command parameters
//
EscapeFunction = 0;
strcpy(lpInData,"This is a bland statement");
hres = StiEscape(EscapeFunction,&lpInData[0],&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_RAWREADDATA_A:
//
// Set up the RawReadData command parameters
//
ZeroMemory(lpInData,LONGSTRING);
dwNumberOfBytes = 16;
hres = StiRawReadData(lpInData,&dwNumberOfBytes,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_RAWWRITEDATA_A:
//
// Set up the RawReadData command parameters
//
strcpy(lpOutData,"The eagle flies high");
dwNumberOfBytes = strlen(lpOutData);
hres = StiRawWriteData(lpOutData,dwNumberOfBytes,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_RAWREADCOMMAND_A:
//
// Set up the RawReadCommand command parameters
//
ZeroMemory(lpInData,LONGSTRING);
dwNumberOfBytes = 16;
hres = StiRawReadCommand(lpInData,&dwNumberOfBytes,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_RAWWRITECOMMAND_A:
//
// Set up the RawWriteCommand command parameters
//
strcpy(lpOutData,"Jack and Jill went up the hill");
dwNumberOfBytes = strlen(lpOutData);
hres = StiRawWriteCommand(lpOutData,dwNumberOfBytes,&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_DEVICE_RELEASE:
hres = StiDeviceRelease(&bReturn);
DisplayLogPassFail(bReturn);
break;
case IDM_NEXT_DEVICE:
hres = NextStiDevice();
DisplayLogPassFail(bReturn);
break;
case IDM_LAMPON:
StiLamp(ON);
break;
case IDM_LAMPOFF:
StiLamp(OFF);
break;
case IDM_SCAN:
hres = StiScan(hWnd);
break;
case IDM_SHOWDIB:
hres = DisplayScanDIB(hWnd);
break;
case IDM_COMPLIANCE:
//
// assign a test suite and start the automated test timer
//
pSuite = nComplianceSuite;
nMaxCount = 3;
nTimeScan = 10;
nTimeNext = 1;
bAuto = StartAutoTimer(hWnd);
break;
case IDM_SHIPCRIT:
//
// assign a test suite and start the automated test timer
//
pSuite = nShipcritSuite;
nMaxCount = 200;
nTimeScan = 10;
nTimeNext = 1;
bAuto = StartAutoTimer(hWnd);
break;
case IDM_PAUSE:
// toggle pausing automation (if running) on/off
if (! nPause) {
DisplayOutput("..pausing automated test..");
nPause = 1;
}
else {
DisplayOutput("Resuming automated test");
nPause = 0;
}
break;
case IDM_AUTO:
// toggle the automation on/off
if (bAuto) {
// stop the auto timer and the stress tests
KillTimer(hWnd,TIMER_ONE);
bAuto = FALSE;
EnableMenuItem(hMenu, IDM_PAUSE, MF_DISABLED);
DisplayOutput("Ending the tests");
}
else {
// start the auto timer and the stress tests
LoadString(hThisInstance,IDS_APPNAME,pszStr1,MEDSTRING);
if (! SetTimer(hWnd,TIMER_ONE,nTimeNext * nTimeMultiplier,NULL))
ErrorMsg((HWND) NULL,"Too many clocks or timers!",pszStr1,TRUE);
else {
bAuto = TRUE;
EnableMenuItem(hMenu, IDM_PAUSE, MF_ENABLED);
DisplayOutput("Starting the Sti Compliance tests");
pSuite = nComplianceSuite;
//
// initialize NT Logging
//
NTLogInit();
}
}
break;
case IDM_SETTINGS:
bReturn = fDialog(IDD_SETTINGS, hWnd, (FARPROC) Settings);
// implement the settings if user pressed OK
if (bReturn != FALSE)
{
if (nTTNext != nTimeNext) {
nTimeNext = nTTNext;
DisplayOutput("Test interval changed to %d seconds",nTimeNext);
}
if (nTTScan != nTimeScan) {
nTimeScan = nTTScan;
DisplayOutput("Scan interval changed to %d seconds",
nTimeScan * nTimeNext);
}
if (nTTMax != nMaxCount) {
nMaxCount = nTTMax;
DisplayOutput("Test loops changed to %d (0 is forever)",
nMaxCount);
}
}
break;
case IDM_HELP:
Help();
break;
default:
break;
}
//
// Clear the InATest semaphore
//
nInATestSemaphore = 0;
// always return 0
return 0;
}
/******************************************************************************
BOOL TimerParse(HWND hWnd,UINT wMsgID,WPARAM wParam,LPARAM lParam)
Each timer tick, decide whether to run the next test, repeat a prior test,
end testing, or shut everything down.
******************************************************************************/
BOOL TimerParse(HWND hWnd,UINT wMsgID,WPARAM wParam,LPARAM lParam)
{
HRESULT hres = STI_OK; // generic Sti return value
int nReturn = 0, // generic return value
*pTest; // pointer to the test suite to run
BOOL bResume = TRUE, // reset timer flag
bReturn = TRUE; // dialog box return value
static int nDeviceNumber = 1; // current device
static int nCountdown = nTimeScan; // WM_TIMER ticks until next scan
static DWORD dwOut = 0;
//
// Don't start a test if paused or running a test currently.
//
//
if ((nInTimerSemaphore)||(nInATestSemaphore)||(nPause))
return 0;
//
// Suspend the timer while running this test.
// Set Flag to reset timer
// Set the nInTimerSemaphore
// Set the current test ID
//
KillTimer(hWnd,TIMER_ONE);
bResume = TRUE;
nInTimerSemaphore = 1;
nTestID = nNextTest;
//
// point to the next test in the current suite to run
//
pTest = pSuite + nNextTest;
switch (*pTest)
{
case NONE:
nNextTest++;
break;
case HELP:
nNextTest++;
break;
case COMPLIANCE:
//
// initialize test structures
//
if (pdevRoot == NULL) {
InitPrivateList(&pdevRoot,pSuite);
pdevPtr = pdevRoot;
}
//
// if this is COMPLIANCE test, ask user to confirm test
//
bResume = ComplianceDialog(hWnd);
nNextTest++;
break;
case SHIPCRIT:
//
// initialize test structures
//
if (pdevRoot == NULL) {
InitPrivateList(&pdevRoot,pSuite);
pdevPtr = pdevRoot;
}
nNextTest++;
break;
case ERRORLOG:
nNextTest++;
break;
case TEST:
nNextTest++;
break;
case tBeginningOfTest:
DisplayOutput("Begin Testing test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"Begin Testing test, loop %d, device %d",nTestCount,nDeviceNumber);
nNextTest++;
break;
case tCreateInstance:
DisplayOutput("CreateInstance test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"CreateInstance test, loop %d, device %d",nTestCount,nDeviceNumber);
DisplayOutput("%S (%S) is being tested",
pdevPtr->szLocalName,pdevPtr->szInternalName);
tlLog(hNTLog,TL_LOG,"%S (%S) is being tested",
pdevPtr->szLocalName,pdevPtr->szInternalName);
DisplayOutput("");
PostMessage(hWnd,WM_COMMAND,IDM_CREATE_INSTANCE,0);
nNextTest++;
break;
case tGetDeviceList:
DisplayOutput("GetDeviceList test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"GetDeviceList test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_GET_DEVLIST,0);
nNextTest++;
break;
case tCreateDevice:
DisplayOutput("CreateDevice test (Device ONLINE), loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,
"CreateDevice test (Device ONLINE), loop %d, device %d",nTestCount,nDeviceNumber);
//
// Call Sti with device
//
nNameOnly = 0;
PostMessage(hWnd,WM_COMMAND,IDM_CREATE_DEV,0);
nNextTest++;
break;
case tSelectDeviceName:
DisplayOutput("SelectDeviceName test (Device OFFLINE), "\
"loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"SelectDeviceName test (Device OFFLINE),"\
"loop %d, device %d",nTestCount,nDeviceNumber);
//
// Call Sti with device name only
//
nNameOnly = 1;
PostMessage(hWnd,WM_COMMAND,IDM_CREATE_DEV,0);
nNextTest++;
break;
case tGetDeviceInfo:
DisplayOutput("GetDeviceInfo test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"GetDeviceInfo test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_GET_DEVINFO,0);
nNextTest++;
break;
case tGetDeviceValue:
DisplayOutput("GetDeviceValue test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"GetDeviceValue test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_GET_DEVVAL,0);
nNextTest++;
break;
case tSetDeviceValue:
DisplayOutput("SetDeviceValue test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"SetDeviceValue test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_SET_DEVVAL,0);
nNextTest++;
break;
case tRegisterLaunchApplication:
DisplayOutput("RegisterLaunchApplication test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"RegisterLaunchApplication test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_REGISTER_LAUNCH,0);
nNextTest++;
break;
case tUnRegisterLaunchApplication:
DisplayOutput("UnRegisterLaunchApplication test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"UnRegisterLaunchApplication test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_UNREGISTER_LAUNCH,0);
nNextTest++;
break;
case tEnableHwNotifications:
DisplayOutput("EnableHwNotifications test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"EnableHwNotifications test, "\
"loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_ENABLE_HWNOTIF,0);
nNextTest++;
break;
case tGetHwNotificationState:
DisplayOutput("GetHwNotificationState test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"GetHwNotificationState test, "\
"loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_GET_HWNOTIF,0);
nNextTest++;
break;
case tWriteToErrorLog:
DisplayOutput("WriteToErrorLog test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"WriteToErrorLog test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_WRITE_ERRORLOG,0);
nNextTest++;
break;
case tWriteToErrorLogBig:
DisplayOutput("WriteToErrorLog test, Variation 1, "\
"loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"WriteToErrorLog test, Variation 1, "\
"loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_WRITE_ERRORLOG,100);
nNextTest++;
break;
case tGetStatusA:
DisplayOutput("GetStatus (Online) test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"GetStatus test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_GET_STATUS_A,0);
nNextTest++;
break;
case tGetStatusB:
DisplayOutput("GetStatus (Event) test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"GetStatus test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_GET_STATUS_B,0);
nNextTest++;
break;
case tGetStatusC:
DisplayOutput("GetStatus (All) test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"GetStatus test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_GET_STATUS_C,0);
nNextTest++;
break;
case tGetCapabilities:
DisplayOutput("GetCapabilities test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"GetCapabilities test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_GET_CAPS,0);
nNextTest++;
break;
case tDeviceReset:
DisplayOutput("DeviceReset test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"DeviceReset test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_DEVICERESET,0);
nNextTest++;
break;
case tDiagnostic:
DisplayOutput("Diagnostic test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"Diagnostic test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_DIAGNOSTIC,0);
nNextTest++;
break;
case tGetLastInfoError:
DisplayOutput("GetLastInfoError test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"GetLastInfoError test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_GET_LASTERRINFO,0);
nNextTest++;
break;
case tSubscribe:
DisplayOutput("Subscribe test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"Subscribe test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_SUBSCRIBE,0);
nNextTest++;
break;
case tUnSubscribe:
DisplayOutput("UnSubscribe test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"UnSubscribe test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_UNSUBSCRIBE,0);
nNextTest++;
break;
case tEscapeA:
DisplayOutput("Escape (variation A) test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"Escape test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_ESCAPE_A,0);
nNextTest++;
break;
case tRawReadDataA:
DisplayOutput("RawReadData (variation A) test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"RawReadData test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_RAWREADDATA_A,0);
nNextTest++;
break;
case tRawWriteDataA:
DisplayOutput("RawWriteData (variation A) test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"RawWriteData test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_RAWWRITEDATA_A,0);
nNextTest++;
break;
case tRawReadCommandA:
DisplayOutput("RawReadCommand (variation A) test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"RawReadCommand test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_RAWREADCOMMAND_A,0);
nNextTest++;
break;
case tRawWriteCommandA:
DisplayOutput("RawWriteCommand (variation A) test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"RawWriteCommand test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_RAWWRITECOMMAND_A,0);
nNextTest++;
break;
case tAcquire:
if (! nICanScan) {
nNextTest++;
} else {
if (nCountdown == nTimeScan) {
nCountdown--;
DisplayOutput("...countdown %d to acquire...",nCountdown);
PostMessage(hWnd,WM_COMMAND,IDM_SCAN,0);
}
else {
if (nCountdown == 0) {
nNextTest++;
nCountdown = nTimeScan;
}
else {
nCountdown--;
DisplayOutput("Acquire test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"Acquire test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_SHOWDIB,0);
}
}
}
break;
case tReleaseDevice:
DisplayOutput("ReleaseDevice test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"ReleaseDevice test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_DEVICE_RELEASE,0);
nNextTest++;
break;
case tReleaseSti:
DisplayOutput("ReleaseSti test, loop %d, device %d",nTestCount,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"ReleaseSti test, loop %d, device %d",nTestCount,nDeviceNumber);
PostMessage(hWnd,WM_COMMAND,IDM_IMAGE_RELEASE,0);
nNextTest++;
break;
case tHelp:
PostMessage(hWnd,WM_COMMAND,IDM_HELP,0);
nNextTest++;
break;
case tTest:
DisplayOutput(" Line %d",dwOut++);
nNextTest++;
break;
case tEndOfTest:
//
// Reached the end of test suite
//
DisplayOutput("test loop complete");
tlLog(hNTLog,TL_LOG,"test loop complete");
if (nICanScan) {
DisplayOutput("-> %d loops (%d scans and %d errors) device %d",
nTestCount,nScanCount,pdevPtr->nError,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"-> %d loops (%d scans and %d errors) device %d",
nTestCount,nScanCount,pdevPtr->nError,nDeviceNumber);
} else {
DisplayOutput("-> %d loops (%d errors) device %d",
nTestCount,pdevPtr->nError,nDeviceNumber);
tlLog(hNTLog,TL_LOG,"-> %d loops (%d errors) device %d",
nTestCount,pdevPtr->nError,nDeviceNumber);
}
//
// Have we run requested number of tests per device?
//
if (((nTestCount >= nMaxCount) &&
((dwStiTotal == (DWORD) (nDeviceNumber)) || (dwStiTotal == 0)) &&
(nMaxCount != 0))) {
DisplayOutput("Requested number of test loops per device "\
"reached");
tlLog(hNTLog,TL_LOG,"Requested number of test loops per "\
"device reached");
//
// shut off timer and turn off automation
//
KillTimer(hWnd,TIMER_ONE);
bAuto = FALSE;
bResume = FALSE;
//
// print the test summary for the devices
//
DisplayOutput("");
tlLog(hNTLog,TL_LOG,"");
if (pdevRoot == NULL) {
DisplayOutput("No valid Still Imaging devices were found");
tlLog(hNTLog,TL_LOG,"No valid Still Imaging devices were found");
} else {
PDEVLOG pD = pdevRoot;
PERRECORD pR = NULL;
BOOL bPF = FALSE;
DisplayOutput("Testing results:");
tlLog(hNTLog,TL_LOG,"Testing results:");
do {
DisplayOutput(" %S (%S)",pD->szLocalName,pD->szInternalName);
tlLog(hNTLog,TL_LOG," %S (%S)",pD->szLocalName,
pD->szInternalName);
for (pR = pD->pRecord;pR->pNext != NULL;pR = pR->pNext) {
if (pR->bFatal && pR->nCount) {
DisplayOutput(" %s failures: %d",
StrFromTable(pR->nTest,StSuiteStrings),
pR->nCount);
tlLog(hNTLog,TL_LOG," %s failures: %d",
StrFromTable(pR->nTest,StSuiteStrings),
pR->nCount);
//
// set the FAIL flag
//
bPF = TRUE;
}
}
if (bPF == TRUE) {
DisplayOutput("FAIL: This device has FAILED the "\
"Still Imaging Compliance test!");
tlLog(hNTLog,TL_LOG,"FAIL: This device has FAILED "\
"the Still Imaging Compliance test!");
} else {
DisplayOutput("PASS: This device has PASSED the "\
"Still Imaging Compliance test!");
tlLog(hNTLog,TL_LOG,"PASS: This device has PASSED "\
"the Still Imaging Compliance test!");
}
// cycle through all devices, BREAK at end of list
if (pD->pNext) {
pD = pD->pNext;
DisplayOutput("");
tlLog(hNTLog,TL_LOG,"");
bPF = FALSE;
} else {
DisplayOutput("");
break;
}
} while (TRUE);
}
//
// free the private lists and close Sti subsystem
//
ClosePrivateList(&pdevRoot);
StiClose(&bReturn);
//
// reset test counters
//
nDeviceNumber = 1;
nNextTest = 0;
nTestCount = 1;
DisplayOutput("End of testing");
tlLog(hNTLog,TL_LOG,"End of testing");
DisplayOutput("");
} else {
//
// Point to first test (past initialization) in list.
//
nNextTest = 2;
//
// select next device in device log
// Note that this list isn't dynamic for PNP changes...
//
nDeviceNumber = NextStiDevice();
//
// increment test pass counter if we're at first device again
//
if ((++nDeviceNumber) == 1)
nTestCount++;
DisplayOutput("");
}
break;
default:
DisplayOutput("");
DisplayOutput("Unimplemented test # %d",*pTest);
DisplayOutput("");
nNextTest++;
break;
}
//
// Resume the timer if the flag is set
//
if (bResume) {
if (! SetTimer(hWnd,TIMER_ONE,nTimeNext * nTimeMultiplier,NULL)) {
LoadString(hThisInstance,IDS_APPNAME,pszStr1,MEDSTRING);
ErrorMsg((HWND) NULL,"Too many clocks or timers!",pszStr1,TRUE);
}
}
//
// Clear the nInTimerSemaphore
//
nInTimerSemaphore = 0;
// always return 0
return 0;
}
/******************************************************************************
int EndTest(HWND hWnd,int nNumTest)
After each test run cleanup.
******************************************************************************/
int EndTest(HWND hWnd,int nNumTest)
{
int nReturn = 0; // generic return value
BOOL bReturn; // generic return value
// shut off timer
KillTimer(hWnd,TIMER_ONE);
// close any open still imaging devices
StiClose(&bReturn);
// save test stats if more than non-trivial number of tests run
if (nTestCount >= 2)
{
LoadString(hThisInstance,IDS_PRIVINI,pszOut,LONGSTRING);
LoadString(hThisInstance,IDS_PRIVSECTION,pszStr4,LONGSTRING);
_itoa(nTestCount,pszStr2,10);
WritePrivateProfileString(pszStr4,"Last count",pszStr2,pszOut);
_itoa(nScanCount,pszStr2,10);
WritePrivateProfileString(pszStr4,"Last scan",pszStr2,pszOut);
_itoa(nError,pszStr2,10);
WritePrivateProfileString(pszStr4,"Last error",pszStr2,pszOut);
}
DisplayOutput("Testing complete");
DisplayOutput("This run was %d loops (%d scans and %d errors)",
nTestCount,nScanCount,nError);
// reset current line, errors
// nError = nNextLine = 0;
//
// end NT Logging
//
NTLogEnd();
return nReturn;
}
/******************************************************************************
BOOL NTLogInit()
Initialize NT logging
******************************************************************************/
BOOL NTLogInit()
{
//
// Create the log object. We are specifying that the file be refreshed,
// and that logging be output for variations. The flags also specify that
// only output at SEV2, WARN and PASS levels should be logged.
//
dwNTStyle = TLS_SEV2 | TLS_WARN | TLS_PASS | TLS_VARIATION | TLS_REFRESH |
TLS_TEST;
LoadString(hThisInstance,IDS_NTLOG,pszStr1,LONGSTRING);
hNTLog = tlCreateLog(pszStr1,dwNTStyle);
tlAddParticipant(hNTLog,NULL,0);
return (TRUE);
}
/******************************************************************************
BOOL NTLogEnd()
Terminate NT logging
******************************************************************************/
BOOL NTLogEnd()
{
tlRemoveParticipant(hNTLog);
tlDestroyLog(hNTLog);
return (TRUE);
}
/******************************************************************************
void Help()
Display help.
******************************************************************************/
void Help()
{
DisplayOutput("Stillvue command line parameters");
DisplayOutput("");
DisplayOutput("Stillvue -COMPLIANCE");
DisplayOutput(" WHQL external Sti Compliance test");
DisplayOutput("Stillvue -SHIPCRIT");
DisplayOutput(" Internal PSD Sti Compliance test");
DisplayOutput("Stillvue -ERRORLOG");
DisplayOutput(" Errorlog limits test");
// DisplayOutput("Stillvue -EXIT");
// DisplayOutput(" Application will Exit after test completes");
DisplayOutput("Stillvue -NODIALOG");
DisplayOutput(" Don't display opening dialog");
DisplayOutput("Stillvue -HELP");
DisplayOutput(" Display this help");
DisplayOutput("");
/*
DisplayOutput("Stillvue /INF test.inf");
DisplayOutput(" Read test.inf file");
DisplayOutput("Stillvue /LOG test.log");
DisplayOutput(" Write to test.log file");
DisplayOutput("Stillvue /");
DisplayOutput(" ");
*/
}
/******************************************************************************
BOOL StartAutoTimer(HWND)
Start the automated test timer
Parameters
Handle to app's window
Return
Return TRUE if successful, else FALSE
******************************************************************************/
BOOL StartAutoTimer(HWND hWnd)
{
BOOL bAutoTimer = TRUE;
// start the timer to run tests automatically
LoadString(hThisInstance,IDS_APPNAME,pszStr1,MEDSTRING);
if (! SetTimer(hWnd,TIMER_ONE,nTimeNext * nTimeMultiplier,NULL)) {
ErrorMsg((HWND) NULL,"Too many clocks or timers!",pszStr1,TRUE);
bAutoTimer = FALSE;
} else {
EnableMenuItem(hMenu, IDM_PAUSE, MF_ENABLED);
DisplayOutput("Starting the Automated tests");
}
return (bAutoTimer);
}
/******************************************************************************
BOOL ComplianceDialog(HWND)
Call the Compliance test confirmation dialog
Parameters
Handle to app's window
Return
Return TRUE if user pressed OK, else FALSE
******************************************************************************/
BOOL ComplianceDialog(HWND hWnd)
{
BOOL bReturn = FALSE;
if ((pSuite[0] == COMPLIANCE)&&(bCompDiag == TRUE)) {
bReturn = fDialog(IDD_COMPLIANCE, hWnd, (FARPROC) Compliance);
//
// implement the settings if user pressed OK
//
if (bReturn == FALSE)
{
//
// shut off timer and turn off automation
//
KillTimer(hWnd,TIMER_ONE);
bAuto = FALSE;
//
// free the private lists
//
ClosePrivateList(&pdevRoot);
DisplayOutput("Testing cancelled at user request");
tlLog(hNTLog,TL_LOG,"Testing cancelled at user request");
} else {
DisplayOutput("Testing starting at user request");
tlLog(hNTLog,TL_LOG,"Testing starting at user request");
}
}
return (bReturn);
}
/******************************************************************************
BOOL FAR PASCAL Compliance(HWND,UINT,WPARAM,LPARAM)
OK the Compliance test dialog
Parameters:
The usual dialog box parameters.
Return:
Result of the call.
******************************************************************************/
BOOL FAR PASCAL Compliance(HWND hDlg,UINT msg,WPARAM wParam,LPARAM lParam)
{
PDEVLOG pPtr = pdevRoot;
int iIndex = 0;
switch (msg) {
case WM_INITDIALOG:
//
// fill dialog with Sti Device Internal Names
//
if (pPtr == NULL) {
//
// could not find any devices
//
wsprintf(pszStr1,"%s","No Sti devices found!");
iIndex = SendDlgItemMessage(hDlg,IDC_COMPLIANCE_DEV_NAME,
LB_ADDSTRING,0,(LPARAM) (LPCTSTR) pszStr1);
} else {
for (;pPtr->szLocalName;) {
//
// convert UNICODE string to ANSI
//
wsprintf(pszStr1,"%ls",pPtr->szLocalName);
iIndex = SendDlgItemMessage(hDlg,IDC_COMPLIANCE_DEV_NAME,
LB_ADDSTRING,0,(LPARAM) (LPCTSTR) pszStr1);
if (pPtr->pNext)
pPtr = pPtr->pNext;
else
break;
}
}
return TRUE;
case WM_COMMAND:
switch (wParam) {
case IDOK:
EndDialog(hDlg, TRUE);
return TRUE;
case IDCANCEL:
EndDialog(hDlg, FALSE);
return TRUE;
}
}
return FALSE;
}
/******************************************************************************
BOOL FAR PASCAL Settings(HWND,UINT,WPARAM,LPARAM)
Miscellaneous settings dialog
Parameters:
The usual dialog box parameters.
Return:
Result of the call.
******************************************************************************/
BOOL FAR PASCAL Settings(HWND hDlg,UINT msg,WPARAM wParam,LPARAM lParam)
{
int iIndex;
int iMC[] = { 0,1,10,100,200,300,-1 };
int iTN[] = { 1,2,5,10,20,30,-1 };
int iTS[] = { 10,20,30,60,120,-1 };
switch (msg) {
case WM_INITDIALOG:
//
// fill the comboboxes
//
for (iIndex = 0;iMC[iIndex] != -1;iIndex++) {
_itoa(iMC[iIndex],pszStr1,10);
SendDlgItemMessage(hDlg,IDC_MAX_SCAN,
CB_ADDSTRING,0,(LPARAM) (LPCTSTR) pszStr1);
}
for (iIndex = 0;iTN[iIndex] != -1;iIndex++) {
_itoa(iTN[iIndex],pszStr1,10);
SendDlgItemMessage(hDlg,IDC_AUTO_SECONDS,
CB_ADDSTRING,0,(LPARAM) (LPCTSTR) pszStr1);
}
for (iIndex = 0;iTS[iIndex] != -1;iIndex++) {
_itoa(iTS[iIndex],pszStr1,10);
SendDlgItemMessage(hDlg,IDC_SCAN_SECONDS,
CB_ADDSTRING,0,(LPARAM) (LPCTSTR) pszStr1);
}
//
// set the combobox to the current setttings
//
for (iIndex = 0;iMC[iIndex] != -1;iIndex++) {
if (nMaxCount == iMC[iIndex])
break;
}
SendDlgItemMessage(hDlg,IDC_MAX_SCAN,CB_SETCURSEL,iIndex,0);
for (iIndex = 0;iTN[iIndex] != -1;iIndex++) {
if (nTimeNext == iTN[iIndex])
break;
}
SendDlgItemMessage(hDlg,IDC_AUTO_SECONDS,CB_SETCURSEL,iIndex,0);
for (iIndex = 0;iTS[iIndex] != -1;iIndex++) {
if (nTimeScan == iTS[iIndex])
break;
}
SendDlgItemMessage(hDlg,IDC_SCAN_SECONDS,CB_SETCURSEL,iIndex,0);
return TRUE;
case WM_COMMAND:
switch (wParam) {
case IDOK:
iIndex = SendDlgItemMessage(hDlg,IDC_MAX_SCAN,CB_GETCURSEL,0,0);
iIndex = SendDlgItemMessage(hDlg,IDC_MAX_SCAN,
CB_GETLBTEXT,iIndex,(LPARAM) (LPCTSTR) pszStr1);
nTTMax = atoi(pszStr1);
iIndex = SendDlgItemMessage(hDlg,IDC_AUTO_SECONDS,CB_GETCURSEL,0,0);
iIndex = SendDlgItemMessage(hDlg,IDC_AUTO_SECONDS,
CB_GETLBTEXT,iIndex,(LPARAM) (LPCTSTR) pszStr1);
nTTNext = atoi(pszStr1);
iIndex = SendDlgItemMessage(hDlg,IDC_SCAN_SECONDS,CB_GETCURSEL,0,0);
iIndex = SendDlgItemMessage(hDlg,IDC_SCAN_SECONDS,
CB_GETLBTEXT,iIndex,(LPARAM) (LPCTSTR) pszStr1);
nTTScan = atoi(pszStr1);
EndDialog(hDlg, TRUE);
return TRUE;
case IDCANCEL:
EndDialog(hDlg, FALSE);
return TRUE;
}
}
return FALSE;
}
/******************************************************************************
BOOL SizeDiff(HWND hWnd,UINT wMsgID,WPARAM wParam,LPARAM lParam)
Output redraw handler when window size changes.
******************************************************************************/
BOOL SizeDiff(HWND hWnd,UINT wMsgID,WPARAM wParam,LPARAM lParam)
{
RECT rcClient;
GetClientRect(hWnd,&rcClient);
SetWindowPos(hLogWindow,NULL,0,0,
rcClient.right+(GetSystemMetrics(SM_CXBORDER)*2),
rcClient.bottom+(GetSystemMetrics(SM_CXBORDER)*2),
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
// always return 0
return 0;
}
/******************************************************************************
BOOL HScroll(HWND hWnd,UINT wMsgID,WPARAM wParam,LPARAM lParam)
Horizontal scroll handler.
******************************************************************************/
BOOL HScroll(HWND hWnd,UINT wMsgID,WPARAM wParam,LPARAM lParam)
{
int iHscrollInc;
switch (LOWORD (wParam))
{
case SB_LINEUP :
iHscrollInc = -1 ;
break ;
case SB_LINEDOWN :
iHscrollInc = 1 ;
break ;
case SB_PAGEUP :
iHscrollInc = -8 ;
break ;
case SB_PAGEDOWN :
iHscrollInc = 8 ;
break ;
case SB_THUMBPOSITION :
iHscrollInc = HIWORD(wParam) - iHscrollPos ;
break ;
default :
iHscrollInc = 0 ;
}
iHscrollInc = max (-iHscrollPos,
min (iHscrollInc, iHscrollMax - iHscrollPos)) ;
if (iHscrollInc != 0)
{
iHscrollPos += iHscrollInc ;
ScrollWindow (hWnd, -cxChar * iHscrollInc, 0, NULL, NULL) ;
SetScrollPos (hWnd, SB_HORZ, iHscrollPos, TRUE) ;
}
// always return 0
return 0;
}
/******************************************************************************
BOOL VScroll(HWND hWnd,UINT wMsgID,WPARAM wParam,LPARAM lParam)
Vertical scroll handler.
******************************************************************************/
BOOL VScroll(HWND hWnd,UINT wMsgID,WPARAM wParam,LPARAM lParam)
{
int iVscrollInc;
switch (LOWORD (wParam))
{
case SB_TOP :
iVscrollInc = -iVscrollPos ;
break ;
case SB_BOTTOM :
iVscrollInc = iVscrollMax - iVscrollPos ;
break ;
case SB_LINEUP :
iVscrollInc = -1 ;
break ;
case SB_LINEDOWN :
iVscrollInc = 1 ;
break ;
case SB_PAGEUP :
iVscrollInc = min (-1, -cyClient / cyChar) ;
break ;
case SB_PAGEDOWN :
iVscrollInc = max (1, cyClient / cyChar) ;
break ;
case SB_THUMBTRACK :
iVscrollInc = HIWORD (wParam) - iVscrollPos ;
break ;
default :
iVscrollInc = 0 ;
}
iVscrollInc = max (-iVscrollPos,
min (iVscrollInc, iVscrollMax - iVscrollPos)) ;
if (iVscrollInc != 0)
{
iVscrollPos += iVscrollInc ;
ScrollWindow (hWnd, 0, -cyChar * iVscrollInc, NULL, NULL) ;
SetScrollPos (hWnd, SB_VERT, iVscrollPos, TRUE) ;
UpdateWindow (hWnd) ;
}
// always return 0
return 0;
}
/******************************************************************************
BOOL Creation(HWND,UINT,WPARAM,LPARAM)
Initialization and global allocation.
Return 0 to continue creation of window, -1 to quit
******************************************************************************/
BOOL Creation(HWND hWnd,UINT wMsgID,WPARAM wParam,LPARAM lParam)
{
TEXTMETRIC tm;
RECT rRect;
HDC hDC;
// seed random generator
srand((unsigned)time(NULL));
// create the 5 display and utility strings
if (! ((hLHand[0] = LocalAlloc(LPTR,LONGSTRING)) &&
(pszOut = (PSTR) LocalLock(hLHand[0]))))
return -1;
if (! ((hLHand[1] = LocalAlloc(LPTR,LONGSTRING)) &&
(pszStr2 = (PSTR) LocalLock(hLHand[1]))))
return -1;
if (! ((hLHand[2] = LocalAlloc(LPTR,LONGSTRING)) &&
(pszStr1 = (PSTR) LocalLock(hLHand[2]))))
return -1;
if (! ((hLHand[3] = LocalAlloc(LPTR,LONGSTRING)) &&
(pszStr3 = (PSTR) LocalLock(hLHand[3]))))
return -1;
if (! ((hLHand[4] = LocalAlloc(LPTR,LONGSTRING)) &&
(pszStr4 = (PSTR) LocalLock(hLHand[4]))))
return -1;
// create output display window
hDC = GetDC(hWnd);
GetTextMetrics(hDC,&tm);
cxChar = tm.tmAveCharWidth ;
cxCaps = (tm.tmPitchAndFamily & 1 ? 3 : 2) * cxChar / 2 ;
cyChar = tm.tmHeight + tm.tmExternalLeading ;
iMaxWidth = 40 * cxChar + 22 * cxCaps ;
ReleaseDC(hWnd,hDC);
GetClientRect(hWnd,&rRect);
if (NULL == (hLogWindow = CreateWindow("LISTBOX",NULL,
WS_CHILD | WS_VISIBLE | WS_HSCROLL | WS_VSCROLL |
LBS_NOINTEGRALHEIGHT | LBS_NOSEL,
0,0,rRect.right,rRect.bottom,hWnd,NULL,
(HINSTANCE)GetWindowLong(hWnd,GWL_HINSTANCE),NULL)))
return -1;
// create the DIB to display scanned image
CreateScanDIB(hWnd);
// return 0 to continue creation of window
return 0;
}
/******************************************************************************
BOOL Destruction(HWND,UINT,WPARAM,LPARAM)
Current instance termination routines.
Free error message buffer, send destroy window message.
Note that if Creation() fails, pszMessage is 0.
******************************************************************************/
BOOL Destruction(HWND hWnd,UINT wMsgID,WPARAM wParam,LPARAM lParam)
{
int x; // loop counter
LoadString(hThisInstance,IDS_PRIVINI,pszStr2,LONGSTRING);
LoadString(hThisInstance,IDS_PRIVSECTION,pszStr1,LONGSTRING);
// save window location
SaveFinalWindow(hThisInstance,hWnd,pszStr2,pszStr1);
// free the 5 display and utility strings
for (x = 0;x < 5;x++)
{
LocalUnlock(hLHand[x]);
LocalFree(hLHand[x]);
}
// delete the DIB object
DeleteScanDIB();
// free the output and main windows
DestroyWindow(hLogWindow);
DestroyWindow(hWnd);
// always return 0
return 0;
}
/******************************************************************************
BOOL OnDeviceChange(HWND,UINT,WPARAM,LPARAM)
******************************************************************************/
const CHAR cszStiBroadcastPrefix[] = TEXT("STI");
BOOL OnDeviceChange(HWND hWnd,UINT wMsgID,WPARAM wParam,LPARAM lParam)
{
struct _DEV_BROADCAST_USERDEFINED *pBroadcastHeader;
if (wParam == DBT_USERDEFINED ) {
pBroadcastHeader = (struct _DEV_BROADCAST_USERDEFINED *)lParam;
__try {
if (pBroadcastHeader &&
(pBroadcastHeader->dbud_dbh.dbch_devicetype == DBT_DEVTYP_OEM) &&
(_strnicmp(pBroadcastHeader->dbud_szName,cszStiBroadcastPrefix,lstrlen(cszStiBroadcastPrefix)) == 0)
) {
//
// Got STI device broadcast
//
DisplayOutput("Received STI device broadcast with message:%s ",
pBroadcastHeader->dbud_szName + lstrlen(cszStiBroadcastPrefix));
}
}
__except(EXCEPTION_EXECUTE_HANDLER ) {
::GetExceptionCode();
}
}
return FALSE;
}
/******************************************************************************
BOOL FirstInstance(HANDLE)
Register the window.
Return TRUE/FALSE on success/failure.
******************************************************************************/
BOOL FirstInstance(HINSTANCE hInst)
{
PWNDCLASS pClass;
PSTR pszClass;
if (! (pszClass = (PSTR) LocalAlloc(LPTR, LONGSTRING)))
return FALSE;
LoadString((HINSTANCE)hInst, IDS_CLASSNAME, pszClass, LONGSTRING);
pClass = (PWNDCLASS) LocalAlloc(LPTR, sizeof(WNDCLASS));
// set hbrBackground to 0 for no background (app draws background)
// use COLOR_BACKGROUND+1 for desktop color
pClass->style = CS_HREDRAW | CS_VREDRAW;
pClass->lpfnWndProc = WiskProc;
pClass->cbClsExtra = 0;
pClass->cbWndExtra = 0;
pClass->hInstance = (HINSTANCE)hInst;
pClass->hIcon = LoadIcon((HINSTANCE)hInst, MAKEINTRESOURCE(IDI_STI));
pClass->hCursor = LoadCursor((HINSTANCE)NULL, IDC_ARROW);
pClass->hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
pClass->lpszMenuName = NULL;
pClass->lpszClassName = (LPSTR) pszClass;
if (! (RegisterClass((LPWNDCLASS) pClass)))
return FALSE;
LocalFree((HANDLE) pClass);
LocalFree((HANDLE) pszClass);
return TRUE;
}
/******************************************************************************
HWND MakeWindow(HANDLE)
Create a window for current instance.
Return handle to window (which is 0 on failure)
******************************************************************************/
HWND MakeWindow(HINSTANCE hInst)
{
HWND hWindow;
PSTR pszA,pszB;
RECT rect;
DWORD dwError;
// if we can't get string memory, shut down app
if (pszA = (PSTR) LocalAlloc(LPTR, LONGSTRING))
{
if (! (pszB = (PSTR) LocalAlloc(LPTR, LONGSTRING)))
{
LocalFree((HANDLE) pszA);
return FALSE;
}
}
else
return FALSE;
// get the caption, classname
LoadString(hInst, IDS_PRIVINI, pszA, LONGSTRING);
LoadString(hInst, IDS_PRIVSECTION, pszB, LONGSTRING);
GetFinalWindow(hInst,&rect,pszA,pszB);
LoadString(hInst,IDS_CAPTION,pszA,LONGSTRING);
LoadString(hInst,IDS_CLASSNAME,pszB,LONGSTRING);
hWindow = CreateWindow((LPSTR) pszB,
(LPSTR) pszA,
WS_OVERLAPPEDWINDOW,
rect.left,
rect.top,
rect.right,
rect.bottom,
(HWND) NULL,
0,
hInst,
NULL);
if (hWindow == 0)
dwError = GetLastError();
// Save Instance globally
hThisInstance = hInst;
LocalFree((HANDLE) pszB);
LocalFree((HANDLE) pszA);
return hWindow;
}
/******************************************************************************
void DisplayOutput(LPSTR pString,...)
Show text on the display window
******************************************************************************/
void DisplayOutput(LPSTR pString,...)
{
char Buffer[512];
MSG msg;
int iIndex;
va_list list;
va_start(list,pString);
vsprintf(Buffer,pString,list);
if (ulCount1++ == MAX_LOOP)
{
ulCount1 = 1;
ulCount2++;
SendMessage(hLogWindow,LB_RESETCONTENT,0,0);
}
iIndex = SendMessage(hLogWindow,LB_ADDSTRING,0,(LPARAM)Buffer);
SendMessage(hLogWindow,LB_SETCURSEL,iIndex,(LPARAM)MAKELONG(FALSE,0));
while (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
UpdateWindow(hLogWindow);
}
/******************************************************************************
void LogOutput(int,LPSTR pString,...)
Show text on the display window
******************************************************************************/
void LogOutput(int nVerbose,LPSTR pString,...)
{
char Buffer[512];
MSG msg;
int iIndex;
va_list list;
va_start(list,pString);
vsprintf(Buffer,pString,list);
if (ulCount1++ == MAX_LOOP)
{
ulCount1 = 1;
ulCount2++;
SendMessage(hLogWindow,LB_RESETCONTENT,0,0);
}
iIndex = SendMessage(hLogWindow,LB_ADDSTRING,0,(LPARAM)Buffer);
SendMessage(hLogWindow,LB_SETCURSEL,iIndex,(LPARAM)MAKELONG(FALSE,0));
while (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
UpdateWindow(hLogWindow);
}
/*****************************************************************************
void StiDisplayError(HRESULT,char *,BOOL)
Display verbose error information
Parameters:
HRESULT from failed call
failed call title string
BOOL TRUE to record error, else ignore it
Return:
none
*****************************************************************************/
void FatalError(char *szMsg)
{
DisplayOutput(szMsg);
DisplayOutput("* FATAL ERROR CANNOT CONTINUE *");
return;
}
/******************************************************************************
void DisplayLogPassFail(BOOL bPass)
******************************************************************************/
void DisplayLogPassFail(BOOL bPass)
{
if (bPass)
sprintf(pszStr1," PASS");
else
sprintf(pszStr1," FAIL");
DisplayOutput(pszStr1);
DisplayOutput("");
tlLog(hNTLog,TL_LOG,pszStr1);
}
/******************************************************************************
BOOL ParseCmdLine(LPSTR lpCmdLine)
Parse the command line for valid options
Return TRUE if an automated test was selected, else FALSE
******************************************************************************/
BOOL ParseCmdLine(LPSTR lpCmdLine)
{
int nAnyTest = 0,
nInfFile = 0,
nLogFile = 0,
nWLogFile = 0,
next;
char *pArg,
*szPtr,
szTmpBuf[LONGSTRING];
if (*lpCmdLine) {
DisplayOutput("Command line: \"%s\"",lpCmdLine);
DisplayOutput("");
}
for (pArg = lpCmdLine;*pArg;)
{
next = NextToken(szTmpBuf,pArg);
pArg += next;
// remove the common command line separators (if present)
if (szTmpBuf[0] == '/' || szTmpBuf[0] == '-')
strcpy(szTmpBuf,(szTmpBuf + 1));
// upper case our parameter
for (szPtr = &szTmpBuf[0];*szPtr;szPtr++)
*szPtr = toupper(*szPtr);
// Look for other switches
switch(szTmpBuf[0])
{
case '?':
case 'H':
if (! nAnyTest) {
// request for help
if ((! strncmp("?",szTmpBuf,strlen(szTmpBuf)) ||
(! strncmp("HELP",szTmpBuf,strlen(szTmpBuf))))) {
pSuite = nHelpSuite;
nMaxCount = 1;
nAnyTest = 1;
}
}
break;
case 'C':
if (! nAnyTest) {
// external Sti compliance test
if (! strncmp("COMPLIANCE",szTmpBuf,strlen(szTmpBuf))) {
pSuite = nComplianceSuite;
nMaxCount = 3;
nTimeScan = 10;
nTimeNext = 1;
nAnyTest = 1;
// get handle to the compliance menu
hMenu = LoadMenu(hThisInstance,
MAKEINTRESOURCE(IDR_STI_COMP));
}
}
break;
case 'E':
if (! nAnyTest) {
// external Sti compliance test
if (! strncmp("ERRORLOG",szTmpBuf,strlen(szTmpBuf))) {
pSuite = nErrorlogSuite;
nMaxCount = 1;
nTimeNext = 1;
nAnyTest = 1;
}
}
// exit when test has run
if (! strncmp("EXIT",szTmpBuf,strlen(szTmpBuf)))
bExit = TRUE;
break;
case 'I':
if (! nInfFile) {
// read test instructions from an .INF file
if (! strncmp("INF",szTmpBuf,strlen(szTmpBuf))) {
// inf file stuff
nInfFile = 1;
}
}
break;
case 'L':
if (! nLogFile) {
// write screen output to .LOG file
if (! strncmp("LOG",szTmpBuf,strlen(szTmpBuf))) {
// log file stuff
nLogFile = 1;
}
}
break;
case 'N':
// don't show COMPLIANCE test dialog
if (! strncmp("NODIALOG",szTmpBuf,strlen(szTmpBuf)))
bCompDiag = FALSE;
break;
case 'S':
if (! nAnyTest) {
// internal Sti SHIPCRIT test
if (! strncmp("SHIPCRIT",szTmpBuf,strlen(szTmpBuf))) {
pSuite = nShipcritSuite;
nMaxCount = 200;
nTimeScan = 10;
nTimeNext = 1;
nAnyTest = 1;
}
}
// the application was launched by an Sti event!
if (! (strncmp(STIEVENTARG,szTmpBuf, strlen(STIEVENTARG))) ||
(! (strncmp(STIDEVARG,szTmpBuf, strlen(STIDEVARG))))) {
nEvent = 1;
MessageBox(NULL,szTmpBuf,"Stillvue",MB_OK);
}
break;
case 'T':
if (! nAnyTest) {
// external Sti compliance test
if (! strncmp("TEST",szTmpBuf,strlen(szTmpBuf))) {
pSuite = nOutputSuite;
nMaxCount = 0;
nTimeNext = 1;
nAnyTest = 1;
nTimeMultiplier = 1;
}
}
break;
case 'W':
if (! nWLogFile) {
// write NTLOG output to STIWHQL.LOG file
if (! strncmp("WHQL",szTmpBuf,strlen(szTmpBuf))) {
// log file stuff
nWLogFile = 1;
}
}
break;
default:
break;
}
}
if (nAnyTest)
return TRUE;
else
return FALSE;
}
/******************************************************************************
int PASCAL WinMain(HANDLE,HANDLE,LPSTR,short)
The app itself.
******************************************************************************/
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
MSG msg; // message passing structure
HWND hWnd; // Handle to main window
HMENU hMenuPopup; // add ports to PORT menu
// exit if registration and window creation fail
if (! FirstInstance (hInstance))
return FALSE;
// Can't create window? Bail out
if (! (hWnd = MakeWindow (hInstance)))
return FALSE;
ShowWindow(hWnd,nCmdShow);
// save instance
hThisInstance = hInstance;
// initialize NT Logging
NTLogInit();
// display name of this app
LoadString(hThisInstance,IDS_APPNAME,pszOut,LONGSTRING);
LoadString(hThisInstance,IDS_CAPTION,pszStr2,LONGSTRING);
wsprintf(pszStr1,"%s - %s",pszOut,pszStr2);
DisplayOutput(pszStr1);
// display last run statistics
{
int nCount,
nScan,
nError;
LoadString(hThisInstance,IDS_PRIVINI,pszStr3,LONGSTRING);
LoadString(hThisInstance,IDS_PRIVSECTION,pszStr4,LONGSTRING);
nCount = GetPrivateProfileInt(pszStr4,"Last count",0,pszStr3);
nScan = GetPrivateProfileInt(pszStr4,"Last scan",0,pszStr3);
nError = GetPrivateProfileInt(pszStr4,"Last error",0,pszStr3);
wsprintf(pszStr1,
"Last run was %d loops (%d scans and %d errors)",
nCount,nScan,nError);
DisplayOutput(pszStr1);
}
// get handle to the standard menu
hMenu = LoadMenu(hThisInstance, MAKEINTRESOURCE(IDR_STI_LAB));
// parse the command line
bAuto = ParseCmdLine(lpCmdLine);
// start test timer if automated test on command line
if (bAuto)
{
bAuto = StartAutoTimer(hWnd);
}
// start Sti event handler if an Sti event launched us
if (nEvent)
{
BOOL bReturn;
StiCreateInstance(&bReturn);
StiEnum(&bReturn);
StiEvent(hWnd);
// select the device that called the event
StiSelect(hWnd,EVENT,&bReturn);
}
// load the selected menu
hMenuPopup = CreateMenu();
SetMenu(hWnd, hMenu);
while (GetMessage(&msg,(HWND) NULL,0,0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return 0;
}
/******************************************************************************
long FAR PASCAL WiskProc(HWND,UINT,WPARAM,LPARAM)
The main exported procedure.
******************************************************************************/
long FAR PASCAL WiskProc(HWND hWnd,UINT wMsgID,WPARAM wParam,LPARAM lParam)
{
switch (wMsgID)
{
case WM_COMMAND:
return CommandParse(hWnd,wMsgID,wParam,lParam);
case WM_TIMER:
return TimerParse(hWnd,wMsgID,wParam,lParam);
case WM_SIZE:
return SizeDiff(hWnd,wMsgID,wParam,lParam);
case WM_HSCROLL:
return HScroll(hWnd,wMsgID,wParam,lParam);
case WM_VSCROLL:
return VScroll(hWnd,wMsgID,wParam,lParam);
case WM_CLOSE:
EndTest(hWnd,0);
return Destruction(hWnd,wMsgID,wParam,lParam);
case WM_DESTROY:
PostQuitMessage(0);
return 0L;
case WM_CREATE:
return Creation(hWnd,wMsgID,wParam,lParam);
case WM_DEVICECHANGE:
return OnDeviceChange(hWnd,wMsgID,wParam,lParam);
default:
return DefWindowProc(hWnd,wMsgID,wParam,lParam);
}
}