420 lines
11 KiB
C++
420 lines
11 KiB
C++
#include "unimcro.h"
|
|
#include "mcromgr.h"
|
|
#include "resource.h"
|
|
|
|
//#define BUTTON_SUPPORT // (enable/disable button support)
|
|
|
|
#ifdef DEBUG
|
|
#define _DEBUG_POLL
|
|
#endif
|
|
|
|
#define MAX_BUTTONS 1
|
|
#define MAX_BUTTON_NAME 255
|
|
|
|
HINSTANCE g_hInst;
|
|
CGSDList g_GSDList;
|
|
|
|
BOOL APIENTRY DllEntryPoint(HMODULE hModule, DWORD dwreason, LPVOID lpReserved)
|
|
{
|
|
g_hInst = (HINSTANCE)hModule;
|
|
switch(dwreason) {
|
|
case DLL_PROCESS_ATTACH:
|
|
case DLL_THREAD_ATTACH:
|
|
case DLL_THREAD_DETACH:
|
|
case DLL_PROCESS_DETACH:
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
WIAMICRO_API HRESULT MicroEntry(LONG lCommand, PVAL pValue)
|
|
{
|
|
HRESULT hr = E_NOTIMPL;
|
|
PGSD pGSD = NULL;
|
|
|
|
if(NULL == pValue->pScanInfo) {
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
switch(lCommand) {
|
|
case CMD_SETGSDNAME:
|
|
Trace(TEXT("Command: CMD_SETGSDNAME"));
|
|
hr = E_FAIL;
|
|
|
|
Trace(TEXT("GSD name: %s"),pValue->szVal);
|
|
Trace(TEXT("GSD Device Handle ID: %d"),pValue->handle);
|
|
|
|
GSD NewGSD;
|
|
|
|
//
|
|
// create new MicroDriver Object
|
|
//
|
|
|
|
NewGSD.pMicroDriver = new CMicroDriver(pValue->handle ,pValue->pScanInfo);
|
|
|
|
if (NULL != NewGSD.pMicroDriver) {
|
|
|
|
//
|
|
// Initialize MicroDriver object with I/O Block Info
|
|
//
|
|
|
|
hr = ParseGSD(pValue->szVal,NewGSD.pMicroDriver->pIOBlock);
|
|
if (SUCCEEDED(hr)) {
|
|
|
|
// NewGSD.pMicroDriver->...?
|
|
|
|
//
|
|
// insert GSD into list
|
|
//
|
|
|
|
g_GSDList.Insert(&NewGSD);
|
|
|
|
} else {
|
|
Trace(TEXT("Parsing of GSD File: %s failed..."),pValue->szVal);
|
|
}
|
|
|
|
//
|
|
// delete unneeded pointers
|
|
//
|
|
|
|
delete NewGSD.pMicroDriver;
|
|
NewGSD.pMicroDriver = NULL;
|
|
|
|
} else {
|
|
Trace(TEXT("Failed to Allocate memory for CMicroDriver pointer!!!"));
|
|
}
|
|
break;
|
|
case CMD_INITIALIZE:
|
|
Trace(TEXT("Command: CMD_INITIALIZE"));
|
|
Trace(TEXT("Raw Data Channel Handle = %d"),pValue->pScanInfo->DeviceIOHandles[0]);
|
|
Trace(TEXT("Settings Data Channel Handle = %d"),pValue->pScanInfo->DeviceIOHandles[1]);
|
|
Trace(TEXT("Status Data Channel Handle = %d"),pValue->pScanInfo->DeviceIOHandles[2]);
|
|
Trace(TEXT("Pollng Data Channel Handle = %d"),pValue->pScanInfo->DeviceIOHandles[3]);
|
|
Trace(TEXT("Interrupt Data Channel Handle = %d"),pValue->pScanInfo->DeviceIOHandles[4]);
|
|
|
|
pGSD = g_GSDList.GetGSDPtr(pValue->pScanInfo->DeviceIOHandles[0]);
|
|
if(NULL != pGSD) {
|
|
hr = pGSD->pMicroDriver->InitScannerDefaults(pValue->pScanInfo);
|
|
} else {
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
break;
|
|
case CMD_UNINITIALIZE:
|
|
Trace(TEXT("Command: CMD_UNINITIALIZE"));
|
|
|
|
g_GSDList.RemoveGSD(pValue->pScanInfo->DeviceIOHandles[0]);
|
|
|
|
//
|
|
// close/unload libraries
|
|
//
|
|
|
|
hr = S_OK;
|
|
break;
|
|
case CMD_RESETSCANNER:
|
|
Trace(TEXT("Command: CMD_RESETSCANNER"));
|
|
|
|
//
|
|
// reset scanner
|
|
//
|
|
|
|
pGSD = g_GSDList.GetGSDPtr(pValue->pScanInfo->DeviceIOHandles[0]);
|
|
if(NULL != pGSD) {
|
|
hr = pGSD->pMicroDriver->InitScannerDefaults(pValue->pScanInfo);
|
|
} else {
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
hr = S_OK;
|
|
break;
|
|
case CMD_STI_DIAGNOSTIC:
|
|
Trace(TEXT("Command: CMD_STI_DIAGNOSTIC"));
|
|
hr = S_OK;
|
|
break;
|
|
case CMD_STI_DEVICERESET:
|
|
Trace(TEXT("Command: CMD_STI_DEVICERESET"));
|
|
hr = S_OK;
|
|
break;
|
|
case CMD_STI_GETSTATUS:
|
|
#ifdef _DEBUG_POLL
|
|
Trace(TEXT("Command: CMD_STI_GETSTATUS"));
|
|
#endif
|
|
|
|
//
|
|
// set status flag to ON-LINE
|
|
//
|
|
|
|
pValue->lVal = MCRO_STATUS_OK;
|
|
pValue->pGuid = (GUID*) &GUID_NULL;
|
|
|
|
//
|
|
// button polling
|
|
//
|
|
|
|
#ifdef BUTTON_SUPPORT
|
|
pGSD = g_GSDList.GetGSDPtr(pValue->pScanInfo->DeviceIOHandles[0]);
|
|
if(NULL != pGSD) {
|
|
hr = pGSD->pMicroDriver->CheckButtonStatus(pValue);
|
|
} else {
|
|
hr = E_FAIL;
|
|
}
|
|
#endif
|
|
hr = S_OK;
|
|
break;
|
|
case CMD_SETXRESOLUTION:
|
|
Trace(TEXT("Command: CMD_SETXRESOLUTION"));
|
|
pValue->pScanInfo->Xresolution = pValue->lVal;
|
|
hr = S_OK;
|
|
break;
|
|
case CMD_SETYRESOLUTION:
|
|
Trace(TEXT("Command: CMD_SETYRESOLUTION"));
|
|
pValue->pScanInfo->Yresolution = pValue->lVal;
|
|
hr = S_OK;
|
|
break;
|
|
case CMD_SETCONTRAST:
|
|
Trace(TEXT("Command: CMD_SETCONTRAST"));
|
|
pValue->pScanInfo->Contrast = pValue->lVal;
|
|
hr = S_OK;
|
|
break;
|
|
case CMD_SETINTENSITY:
|
|
Trace(TEXT("Command: CMD_SETINTENSITY"));
|
|
pValue->pScanInfo->Intensity = pValue->lVal;
|
|
hr = S_OK;
|
|
break;
|
|
case CMD_SETDATATYPE:
|
|
Trace(TEXT("Command: CMD_SETDATATYPE"));
|
|
pValue->pScanInfo->DataType = pValue->lVal;
|
|
hr = S_OK;
|
|
break;
|
|
case CMD_SETMIRROR:
|
|
Trace(TEXT("Command: CMD_SETMIRROR"));
|
|
pValue->pScanInfo->Mirror = pValue->lVal;
|
|
hr = S_OK;
|
|
break;
|
|
case CMD_SETNEGATIVE:
|
|
Trace(TEXT("Command: CMD_SETNEGATIVE"));
|
|
pValue->pScanInfo->Negative = pValue->lVal;
|
|
hr = S_OK;
|
|
break;
|
|
case CMD_GETADFAVAILABLE:
|
|
Trace(TEXT("Command: CMD_GETADFAVAILABLE"));
|
|
break;
|
|
case CMD_GETADFSTATUS:
|
|
Trace(TEXT("Command: CMD_GETADFSTATUS"));
|
|
break;
|
|
case CMD_GETADFREADY:
|
|
Trace(TEXT("Command: CMD_GETADFREADY"));
|
|
break;
|
|
case CMD_GETADFHASPAPER:
|
|
Trace(TEXT("Command: CMD_GETADFHASPAPER"));
|
|
break;
|
|
case CMD_GET_INTERRUPT_EVENT:
|
|
Trace(TEXT("Command: CMD_GET_INTERRUPT_EVENT"));
|
|
break;
|
|
case CMD_GETCAPABILITIES:
|
|
Trace(TEXT("Command: CMD_GETCAPABILITIES"));
|
|
|
|
#ifdef BUTTON_SUPPORT
|
|
|
|
Trace(TEXT("*** THIS SHOULD NOT BE CALLED AT THIS TIME!!! ***"));
|
|
|
|
//
|
|
// old globals pasted from above
|
|
//
|
|
// GUID g_Buttons[MAX_BUTTONS] ={{0xa6c5a715, 0x8c6e, 0x11d2,{ 0x97, 0x7a, 0x0, 0x0, 0xf8, 0x7a, 0x92, 0x6f}}};
|
|
// BOOL g_bButtonNamesCreated = FALSE;
|
|
// WCHAR* g_ButtonNames[MAX_BUTTONS];
|
|
|
|
|
|
//
|
|
// return Number of buttons supported, and
|
|
// array pointer to Button GUID array
|
|
//
|
|
|
|
pValue->lVal = GetButtonCount(pValue->pScanInfo);
|
|
pValue->pGuid = g_Buttons;
|
|
pValue->ppButtonNames = g_ButtonNames;
|
|
|
|
hr = S_OK;
|
|
#endif
|
|
|
|
break;
|
|
default:
|
|
Trace(TEXT("Command: UNKNOWN (%d)"),lCommand);
|
|
break;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
WIAMICRO_API HRESULT GetScanInfo(PSCANINFO pScanInfo)
|
|
{
|
|
Trace(TEXT("Export: GetScanInfo(pScanInfo = %p)"),pScanInfo);
|
|
|
|
//
|
|
// clean Scan info structure
|
|
//
|
|
|
|
ZeroMemory(pScanInfo,sizeof(SCANINFO));
|
|
CopyMemory(pScanInfo,pScanInfo,sizeof(SCANINFO));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
WIAMICRO_API HRESULT Scan(PSCANINFO pScanInfo, LONG lPhase, PBYTE pBuffer, LONG lLength, LONG *plReceived)
|
|
{
|
|
|
|
PGSD pGSD = NULL;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(NULL == pScanInfo) {
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
switch (lPhase) {
|
|
case SCAN_FIRST:
|
|
|
|
pGSD = g_GSDList.GetGSDPtr(pScanInfo->DeviceIOHandles[0]);
|
|
if(NULL != pGSD) {
|
|
hr = pGSD->pMicroDriver->SetScannerSettings(pScanInfo);
|
|
} else {
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
Trace(TEXT("SCAN_FIRST, Requesting %d ------"),lLength);
|
|
|
|
case SCAN_NEXT: // SCAN_FIRST will fall through to SCAN_NEXT (because it is expecting data)
|
|
|
|
if(lPhase == SCAN_NEXT)
|
|
Trace(TEXT("SCAN_NEXT, Requesting %d ------"),lLength);
|
|
break;
|
|
case SCAN_FINISHED:
|
|
default:
|
|
Trace(TEXT("SCAN_FINISHED"));
|
|
break;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
WIAMICRO_API HRESULT SetPixelWindow(PSCANINFO pScanInfo, LONG x, LONG y, LONG xExtent, LONG yExtent)
|
|
{
|
|
Trace(TEXT("Export: SetPixelWindow(pScanInfo = %p, x = %d, y = %d, xExtent = %d, yExtent = %d)"),
|
|
pScanInfo,
|
|
x,
|
|
y,
|
|
xExtent,
|
|
yExtent);
|
|
|
|
if(pScanInfo != NULL) {
|
|
pScanInfo = pScanInfo;
|
|
} else {
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
pScanInfo->Window.xPos = x;
|
|
pScanInfo->Window.yPos = y;
|
|
pScanInfo->Window.xExtent = xExtent;
|
|
pScanInfo->Window.yExtent = yExtent;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT ParseGSD(LPSTR szGSDName, void *pIOBlock)
|
|
{
|
|
Trace(TEXT("unimcro helper: ParseGSD(szGSDName = %s, pIOBlock = %p)"),szGSDName, pIOBlock);
|
|
return E_FAIL;
|
|
}
|
|
|
|
VOID Trace(LPCTSTR format,...)
|
|
{
|
|
|
|
#ifdef DEBUG
|
|
|
|
TCHAR Buffer[1024];
|
|
va_list arglist;
|
|
va_start(arglist, format);
|
|
wvsprintf(Buffer, format, arglist);
|
|
va_end(arglist);
|
|
OutputDebugString(Buffer);
|
|
OutputDebugString(TEXT("\n"));
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
HRESULT GetOLESTRResourceString(LONG lResourceID,LPOLESTR *ppsz,BOOL bLocal)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
TCHAR szStringValue[255];
|
|
if(bLocal) {
|
|
|
|
//
|
|
// We are looking for a resource in our own private resource file
|
|
//
|
|
|
|
HINSTANCE hInst = NULL;
|
|
INT NumTCHARs = LoadString(g_hInst,lResourceID,szStringValue,sizeof(szStringValue));
|
|
DWORD dwError = GetLastError();
|
|
|
|
#ifdef UNICODE
|
|
Trace(TEXT("NumTCHARs = %d dwError = %d Resource ID = %d (UNICODE)szString = %ws"),
|
|
NumTCHARs,
|
|
dwError,
|
|
lResourceID,
|
|
szStringValue);
|
|
#else
|
|
Trace(TEXT("NumTCHARs = %d dwError = %d Resource ID = %d (ANSI)szString = %s"),
|
|
NumTCHARs,
|
|
dwError,
|
|
lResourceID,
|
|
szStringValue);
|
|
#endif
|
|
|
|
//
|
|
// NOTE: caller must free this allocated BSTR
|
|
//
|
|
|
|
#ifdef UNICODE
|
|
*ppsz = NULL;
|
|
*ppsz = (LPOLESTR)CoTaskMemAlloc(sizeof(szStringValue));
|
|
if(*ppsz != NULL) {
|
|
wcscpy(*ppsz,szStringValue);
|
|
} else {
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
#else
|
|
WCHAR wszStringValue[255];
|
|
|
|
//
|
|
// convert szStringValue from char* to unsigned short* (ANSI only)
|
|
//
|
|
|
|
MultiByteToWideChar(CP_ACP,
|
|
MB_PRECOMPOSED,
|
|
szStringValue,
|
|
lstrlenA(szStringValue)+1,
|
|
wszStringValue,
|
|
sizeof(wszStringValue));
|
|
|
|
*ppsz = NULL;
|
|
*ppsz = (LPOLESTR)CoTaskMemAlloc(sizeof(wszStringValue));
|
|
if(*ppsz != NULL) {
|
|
wcscpy(*ppsz,wszStringValue);
|
|
} else {
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
#endif
|
|
|
|
} else {
|
|
|
|
//
|
|
// We are looking for a resource in the wiaservc's resource file
|
|
//
|
|
|
|
hr = E_NOTIMPL;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
|