include "twaincpp.h"
#include <QtGlobal>
#include <QDateTime>
#include <QString>
#pragma execution_character_set("utf-8")；
CTwain::CTwain(HWND hWnd)
{
m_hMessageWnd = nullptr;//消息窗口句柄
m_hTwainDLL = nullptr;//是否已载入库
m_pDSMProc = nullptr;//数据源管理器
m_bSourceSelected = false;//是否已选择数据源
m_bDSOpen = false;//是否已打开数据源
m_bDSMOpen = false;//是否已打开数据源管理器
m_bSourceEnabled = false;//数据源是否设为可用
m_bModalUI = true;
m_nImageCount = TWCPP_ANYCOUNT;
if(hWnd)
{
qDebug()<<"在构造函数中安装Twain";
InitTwain(hWnd);
}
}
CTwain::~CTwain()
{
ReleaseTwain();
}
/*
Initializes TWAIN interface . Is already called from the constructor.
It should be called again if ReleaseTwain is called.
hWnd is the window which has to subclassed in order to recieve
Twain messaged. Normally - this would be your main application window.
初始化TWAIN接口。已经从构造函数调用。
如果调用ReleaseTwain，则应再次调用它。
hWnd是必须进行子类化以便接收的窗口Twain消息。
通常 - 这将是您的主要应用程序窗口。
*/
bool CTwain::InitTwain(HWND hWnd)
{
qDebug()<<"****************开始安装Twain****************";
char libName[512];
if(IsValidDriver())
{
return true;
}
memset(&m_AppId,0,sizeof(m_AppId));
if(!IsWindow(hWnd))//确定给定的窗口句柄是否标识一个已存在的窗口
{
return false;
}
m_hMessageWnd = hWnd;//要传递消息的窗口
strcpy_s(libName,"TWAIN_32.DLL");
m_hTwainDLL = LoadLibraryA(libName);//载入库
if(m_hTwainDLL != nullptr)
{
qDebug()<<"已载入有效扫描驱动";
//获取数据源管理器入
if(!(m_pDSMProc = (DSMENTRYPROC)GetProcAddress(m_hTwainDLL,(LPCSTR)MAKEINTRESOURCE(1))))
{
qDebug()<<"获取数据源管理器入口失败";
FreeLibrary(m_hTwainDLL);
m_hTwainDLL = nullptr;
}
else
{
qDebug()<<"获取数据源管理器入口成功";
}
}
if(IsValidDriver())//成功载入驱动且获取了数据源管理器
{
GetIdentity();//设置应用程序信息
//打开数据源管理器
m_bDSMOpen = CallTwainProc(&m_AppId,nullptr,DG_CONTROL,DAT_PARENT,MSG_OPENDSM,(TW_MEMREF)&m_hMessageWnd);
if(m_bDSMOpen)
{
qDebug()<<"初始化Twain接口：打开数据源管理器成功";
get_source_list();
qDebug()<<"****************结束安装Twain****************";
return true;
}
else
{
qDebug()<<"初始化Twain接口：打开数据源管理器失败";
qDebug()<<"****************结束安装Twain****************";
return false;
}
}
else
{
qDebug()<<"****************结束安装Twain****************";
return false;
}
}
/*
Releases the twain interface . Need not be called unless you
want to specifically shut it down.
释放twain接口。除非你想要特别关闭它。
*/
void CTwain::ReleaseTwain()
{
qDebug()<<"****************开始析构Twain****************";
if(IsValidDriver())//如果已加载有效的驱动程序且存在数据源管理器入口
{
CloseDSM();
FreeLibrary(m_hTwainDLL);
m_hTwainDLL = nullptr;
m_pDSMProc = nullptr;
sourcelist.clear();
}
qDebug()<<"****************结束析构Twain****************";
}
/*
Returns true if a valid driver has been loaded
如果已加载有效的驱动程序且存在数据源管理器入口，则返回true
*/
bool CTwain::IsValidDriver() const
{
return (m_hTwainDLL && m_pDSMProc);
}
/*
Entry point into Twain. For a complete description of this
routine please refer to the Twain specification 1.8
进入Twain的入口点。有关此的完整描述
例程请参考Twain规范1.8
*/
bool CTwain::CallTwainProc(pTW_IDENTITY pOrigin,pTW_IDENTITY pDest,
TW_UINT32 DG,TW_UINT16 DAT,TW_UINT16 MSG,
TW_MEMREF pData)
{
// qDebug()<<"****************开始数据源管理器相关操作****************";
if(IsValidDriver())//如果已加载有效的驱动程序且存在数据源管理器入口
{
USHORT ret_val;
//数据源管理器相关操作
ret_val = (*m_pDSMProc)(pOrigin,pDest,DG,DAT,MSG,pData);
// qDebug()<<"数据源管理器相关操作结果"<<ret_val;
m_returnCode = ret_val;
/////////////////////吐血开始//////////////////
// if(ret_val != TWRC_SUCCESS)
// {
// qDebug()<<"数据源管理器相关操作失败";
// //初始化数据源管理器
// (*m_pDSMProc)(pOrigin,pDest,DG_CONTROL,DAT_STATUS,MSG_GET,&m_Status);
// }
// else
// {
// qDebug()<<"数据源管理器相关操作成功";
// }
////////////////////吐血结束/////////////////
// qDebug()<<"****************结束数据源管理器相关操作****************A";
return (ret_val == TWRC_SUCCESS);
}
else
{
m_returnCode = TWRC_FAILURE;
// qDebug()<<"****************未加载有效的驱动程序或不存在数据源管理器入口****************";
// qDebug()<<"****************结束数据源管理器相关操作****************B";
return false;
}
}
/*
This function should ideally be overridden in the derived class . If only a
few fields need to be updated , call CTawin::GetIdentity first in your
derived class
理想情况下，应在派生类中重写此函数。 如果只有一个
几个字段需要更新，首先在你的电话中调用CTawin :: GetIdentity
派生类
设置应用程序信息
*/
void CTwain::GetIdentity()
{
// Expects all the fields in m_AppId to be set except for the id field.
//期望m_AppId中的所有字段都要设置，除了id字段。
m_AppId.Id = 0; // Initialize to 0 Source Manager
// will assign real value)
m_AppId.Version.MajorNum = 1; //Your app's version number
m_AppId.Version.MinorNum = 0;
m_AppId.Version.Language = TWLG_USA;
m_AppId.Version.Country = TWCY_USA;
strcpy_s (m_AppId.Version.Info, "1.0");
m_AppId.ProtocolMajor = TWON_PROTOCOLMAJOR;
m_AppId.ProtocolMinor = TWON_PROTOCOLMINOR;
m_AppId.SupportedGroups = DG_IMAGE | DG_CONTROL;
strcpy_s (m_AppId.Manufacturer, "MICSS");
strcpy_s (m_AppId.ProductFamily, "Generic");
strcpy_s (m_AppId.ProductName, "jiandao Twain");
}
/*
Called to display a dialog box to select the Twain source to use.
This can be overridden if a list of all sources is available
to the application. These sources can be enumerated by Twain.
it is not yet supportted by CTwain.
调用以显示一个对话框以选择要使用的Twain源。
如果所有源列表都可用，则可以覆盖此项
到申请。这些来源可以由Twain列举。
它还没有得到CTwain的支持。
//选择数据源
MSG_USERSELECT的效果是弹出一个框让用户选择数据源
*/
bool CTwain::SelectSource()
{
qDebug()<<"****************开始选择数据源****************";
memset(&m_Source,0,sizeof(m_Source));
if(!SourceSelected())//扫描时候未选择数据源，则设置数据源为默认的数据源
{
SelectDefaultSource();
}
if(CallTwainProc(&m_AppId,nullptr,DG_CONTROL,DAT_IDENTITY,MSG_USERSELECT,&m_Source))//MSG_OPENDS
{
m_bSourceSelected = true;
qDebug()<<"成功应用所选的数据源";
}
else
{
m_bSourceSelected = false;
qDebug()<<"应用所选的数据源失败";
}
qDebug()<<"****************结束选择数据源****************";
return m_bSourceSelected;
}
//选择默认的数据源
bool CTwain::SelectDefaultSource()
{
qDebug()<<"未选择数据源，使用默认的数据源";
m_bSourceSelected = CallTwainProc(&m_AppId,nullptr,DG_CONTROL,DAT_IDENTITY,MSG_GETDEFAULT,&m_Source);
if(m_bSourceSelected)
{
qDebug()<<"使用默认的数据源成功";
}
else
{
qDebug()<<"使用默认的数据源失败";
}
return m_bSourceSelected;
}
//关闭数据源 先禁用再关闭
void CTwain::CloseDS()
{
qDebug()<<"****************开始关闭数据源****************";
if(DSOpen())//数据源是打开的
{
DisableSource();
qDebug()<<"关闭数据源";
CallTwainProc(&m_AppId,nullptr,DG_CONTROL,DAT_IDENTITY,MSG_CLOSEDS,(TW_MEMREF)&m_Source);
m_bDSOpen = false;
}
qDebug()<<"****************结束关闭数据源****************";
}
//关闭数据源管理器
void CTwain::CloseDSM()
{
qDebug()<<"****************开始关闭数据源管理器****************";
if(DSMOpen())//如果数据源管理器是打开的
{
CloseDS();//关闭数据源
qDebug()<<"执行关闭数据源管理器";
CallTwainProc(&m_AppId,nullptr,DG_CONTROL,DAT_PARENT,MSG_CLOSEDSM,(TW_MEMREF)&m_hMessageWnd);
m_bDSMOpen = false;
}
qDebug()<<"****************结束关闭数据源管理器****************";
}
/*如果：
1、数据源是打开的
2、数据源管理器是打开的
3、数据源管理器入口存在
返回true
*/
bool CTwain::DSMOpen() const
{
return IsValidDriver() && m_bDSMOpen;
}
/*如果：
1、数据源是打开的
2、数据源管理器是打开的
3、数据源管理器入口存在
4、已载入扫描驱动
返回true
*/
bool CTwain::DSOpen() const
{
return IsValidDriver() && DSMOpen() && m_bDSOpen;
}
//打开作为输入参数提供的数据源
bool CTwain::OpenSource(TW_IDENTITY *pSource)
{
if(pSource)
{
m_Source = *pSource;
}
if(DSMOpen())//如果此时数据源管理器是打开的
{
qDebug()<<"xxxxxxxxxxx";
if(!SourceSelected())//此时未选中数据源
{
SelectDefaultSource();
}
//打开数据源
m_bDSOpen = CallTwainProc(&m_AppId,nullptr,DG_CONTROL,DAT_IDENTITY,MSG_OPENDS,(TW_MEMREF)&m_Source);
}
return DSOpen();
}
/*
Should be called from the main message loop of the application. Can always be called,
it will not process the message unless a scan is in progress.
应该从应用程序的主消息循环调用。可以随时调用，
除非正在进行扫描，否则它不会处理消息。
消息事件
*/
bool CTwain::ProcessMessage(MSG msg)
{
if (msg.message == 528) // don't really know why...
{
return false;
}
if (m_hMessageWnd == nullptr)
{
return false;
}
if(SourceEnabled() && m_pDSMProc)//如果数据源可用
{
TW_EVENT twEvent;
twEvent.pEvent = (TW_MEMREF)&msg;
twEvent.TWMessage = MSG_NULL;
TW_UINT16 twRC = TWRC_NOTDSEVENT;
//从扫描仪中获取事件
twRC = CallTwainProc(&m_AppId,&m_Source,DG_CONTROL,DAT_EVENT,MSG_PROCESSEVENT,(TW_MEMREF)&twEvent);
if(twRC != TWRC_NOTDSEVENT)
{
switch(twEvent.TWMessage)
{
case MSG_XFERREADY:
TransferImage();//传输图像或取消传输
break;
case MSG_CLOSEDSREQ://关闭数据源
CloseDS();
break;
case MSG_CLOSEDSOK:
break;
case MSG_DEVICEEVENT:
break;
default: ;
//qDebug()<<"都不是";
}
}
else
{
qDebug()<<"无法获取事件";
}
return false;
}
else
{
// qDebug()<<"数据源不可用";
}
return false;
}
/*
Queries the capability of the Twain Data Source
查询twain数据源的功能
*/
bool CTwain::GetCapability(TW_CAPABILITY& twCap,TW_UINT16 cap,TW_UINT16 conType)
{
if(DSOpen())
{
twCap.Cap = cap;
twCap.ConType = conType;
twCap.hContainer = nullptr;
if(CallTwainProc(&m_AppId,&m_Source,DG_CONTROL,DAT_CAPABILITY,MSG_GET,(TW_MEMREF)&twCap))
{
return true;
}
}
return false;
}
/*
Queries the capability of the Twain Data Source
同上 重载函数
*/
bool CTwain::GetCapability(TW_UINT16 cap,TW_UINT32& value)
{
TW_CAPABILITY twCap;
if(GetCapability(twCap,cap))
{
pTW_ONEVALUE pVal;
pVal = (pTW_ONEVALUE )GlobalLock(twCap.hContainer);
if(pVal)
{
value = pVal->Item;
GlobalUnlock(pVal);
GlobalFree(twCap.hContainer);
return true;
}
}
return false;
}
/*
Sets the capability of the Twain Data Source
设置twain数据源的功能
*/
bool CTwain::SetCapability(TW_UINT16 cap,TW_UINT16 value,bool sign)
{
if(DSOpen())
{
TW_CAPABILITY twCap;
pTW_ONEVALUE pVal;
bool ret_value = false;
twCap.Cap = cap;
twCap.ConType = TWON_ONEVALUE;
twCap.hContainer = GlobalAlloc(GHND,sizeof(TW_ONEVALUE));
if(twCap.hContainer)
{
pVal = (pTW_ONEVALUE)GlobalLock(twCap.hContainer);
pVal->ItemType = sign ? TWTY_INT16 : TWTY_UINT16;
pVal->Item = (TW_UINT32)value;
GlobalUnlock(twCap.hContainer);
ret_value = SetCapability(twCap);
GlobalFree(twCap.hContainer);
}
return ret_value;
}
return false;
}
bool CTwain::SetResolution(TW_UINT16 cap,TW_UINT32 value)
{
if(DSOpen())
{
TW_CAPABILITY twCap;
pTW_ONEVALUE pVal;
BOOL ret_value = FALSE;
twCap.Cap = cap;
twCap.ConType = TWON_ONEVALUE;
twCap.hContainer = GlobalAlloc(GHND,sizeof(TW_ONEVALUE));
if(twCap.hContainer)
{
pVal = (pTW_ONEVALUE)GlobalLock(twCap.hContainer);
pVal->ItemType = TWTY_FIX32;
pVal->Item = (TW_UINT32)value;
GlobalUnlock(twCap.hContainer);
ret_value = SetCapability(twCap);
GlobalFree(twCap.hContainer);
}
return ret_value;
}
return FALSE;
}
/*
Sets the capability of the Twain Data Source
同上 重载函数
*/
bool CTwain::SetCapability(TW_CAPABILITY& cap)
{
if(DSOpen())
{
return CallTwainProc(&m_AppId,&m_Source,DG_CONTROL,DAT_CAPABILITY,MSG_SET,(TW_MEMREF)&cap);
}
return false;
}
/*
Sets the number of images which can be accpeted by the application at one time
设置应用程序一次可接收的图像数
*/
bool CTwain::SetImageCount(TW_INT16 nCount)
{
if(SetCapability(CAP_XFERCOUNT,(TW_UINT16)nCount,true))
{
m_nImageCount = nCount;
return true;
}
else
{
if(GetRC() == TWRC_CHECKSTATUS)
{
TW_UINT32 count;
if(GetCapability(CAP_XFERCOUNT,count))
{
nCount = (TW_INT16)count;
if(SetCapability(CAP_XFERCOUNT,nCount))
{
m_nImageCount = nCount;
return true;
}
}
}
}
return false;
}
/*
Called to enable the Twain Acquire Dialog. This too can be
overridden but is a helluva job .
调用以启用TWAIN获取对话框。这也可以
被重写，但这是一个地狱般的工作。
使数据源可用
*/
bool CTwain::EnableSource(bool showUI)
{
qDebug()<<"****************开始使数据源可用****************";
if(DSOpen() && !SourceEnabled())//数据源打开了且数据源不可用
{
twUI.ShowUI = false/*showUIfalse*/;//是否打开默认的UI 111111111111111111111111111111111这里不设为false会报错 看看
twUI.hParent = (TW_HANDLE)m_hMessageWnd;//消息窗口作为默认ui的主窗口
//启用数据源
if(CallTwainProc(&m_AppId,&m_Source,DG_CONTROL,DAT_USERINTERFACE,MSG_ENABLEDS,(TW_MEMREF)&twUI))
{
m_bSourceEnabled = true;
m_bModalUI = twUI.ModalUI;
qDebug()<<"启用数据源成功 EnableSource";
}
else
{
m_bSourceEnabled = false;
m_bModalUI = true;
qDebug()<<"启用数据源失败 EnableSource";
}
return m_bSourceEnabled;
}
return false;
}
/*
Called to acquire images from the source. parameter numImages i the
numberof images that you an handle concurrently
调用以从源获取图像。参数numImages i
同时处理的图像数
*/
bool CTwain::Acquire(int numImages,TW_UINT16 duplex,TW_UINT16 size,TW_UINT16 pixel,TW_UINT16 resolution)
{
qDebug()<<"****************开始启动扫描****************";
if(DSOpen() || OpenSource())//数据源是打开可用的
{
BOOL ret_value = SetCapability(CAP_DUPLEXENABLED,duplex,TRUE);
ret_value = SetCapability(ICAP_SUPPORTEDSIZES,size,TRUE);
ret_value = SetCapability(ICAP_PIXELTYPE,pixel,TRUE);
ret_value = SetResolution(ICAP_XRESOLUTION,resolution);
ret_value = SetResolution(ICAP_YRESOLUTION,resolution);
// lqh - 设置传输模式为文件
ret_value = SetCapability(ICAP_XFERMECH,TWSX_FILE,TRUE);
//设置扫描的最大张数
if(SetImageCount(numImages))
{
if(EnableSource())
{
return true;
}
else
{
qDebug()<<"启用扫描源失败";
return false;
}
}
}
return false;
}
//禁用数据源
bool CTwain::DisableSource()
{
qDebug()<<"****************开始禁用数据源****************";
if(SourceEnabled())//数据源目前的状态是:可用
{
//禁用数据源
if(CallTwainProc(&m_AppId,&m_Source,DG_CONTROL,DAT_USERINTERFACE,MSG_DISABLEDS,&twUI))
{
m_bSourceEnabled = false;
qDebug()<<"禁用数据源成功";
return true;
}
else
{
qDebug()<<"禁用数据源失败";
return false;
}
}
else
{
qDebug()<<"数据源目前的状态是不可用，不用再次禁用";
}
return false;
}
/*
Gets Imageinfo for an image which is about to be transferred.
获取即将传输的图像的ImageInfo
*/
bool CTwain::GetImageInfo(TW_IMAGEINFO& info)
{
qDebug()<<"****************开始获取图片信息****************";
if(SourceEnabled())//如果数据源是可用的
{
bool b = CallTwainProc(&m_AppId,&m_Source,DG_IMAGE,DAT_IMAGEINFO,MSG_GET,(TW_MEMREF)&info);
if(b == true)
{
qDebug()<<"成功获取即将传输的图片信息";
}
else
{
qDebug()<<"获取即将传输的图片信息失败";
}
return b;
}
return false;
}
/*
Trasnfers the image or cancels the transfer depending on the state of the
TWAIN system
根据图像的状态传输图像或取消传输
*/
void CTwain::TransferImage()
{
qDebug()<<"****************根据图像的状态传输图像或取消传输****************";
TW_IMAGEINFO info;//图片信息
bool bContinue = true;
while(bContinue)
{
if(GetImageInfo(info))//获取图片信息
{
/* lqh start */
TW_SETUPFILEXFER filexfer;
memset(&filexfer, 0, sizeof(filexfer));
QString file = "C:\\SCANFILES\\scan_" + QDateTime::currentDateTime().toString("yyyyMMddHHmmsszzz") +".bmp";
qDebug() << "scan file = " << file ;
filexfer.Format = TWFF_BMP/*TWFF_BMP*/;
strcpy(filexfer.FileName,file.toLatin1().data());
CallTwainProc(&m_AppId,&m_Source,DG_CONTROL, DAT_SETUPFILEXFER, MSG_SET, (TW_MEMREF)&(filexfer));
/* lqh end */
int permission;
permission = ShouldTransfer(info);
qDebug()<<"执行到这";
switch(permission)
{
case TWCPP_CANCELTHIS:
qDebug()<<"执行到这01";
bContinue = EndTransfer();//结束当前的传输
break;
case TWCPP_CANCELALL:
qDebug()<<"执行到这02";
CancelTransfer();//中止所有传输
bContinue = false;
break;
case TWCPP_DOTRANSFER:
qDebug()<<"执行到这03";
bContinue = GetImage(info);//获取图片
break;
}
}
}
}
/*
Ends the current transfer.
Returns true if the more images are pending
结束当前传输。
如果有更多图像挂起，则返回true
*/
bool CTwain::EndTransfer()
{
qDebug()<<"****************执行结束当前传输****************";
TW_PENDINGXFERS twPend;
if(CallTwainProc(&m_AppId,&m_Source,DG_CONTROL,DAT_PENDINGXFERS,MSG_ENDXFER,(TW_MEMREF)&twPend))
{
if (twPend.Count==0)
{
DisableSource();
}
return twPend.Count != 0;
}
return false;
}
/*
Aborts all transfers
中止所有传输
*/
void CTwain::CancelTransfer()
{
qDebug()<<"****************执行终止所有传输****************";
TW_PENDINGXFERS twPend;
CallTwainProc(&m_AppId,&m_Source,DG_CONTROL,DAT_PENDINGXFERS,MSG_RESET,(TW_MEMREF)&twPend);
}
/*
Calls TWAIN to actually get the image
调用twain以实际获取图像
*/
bool CTwain::GetImage(TW_IMAGEINFO& info)
{
qDebug()<<"****************获得图片****************";
HANDLE hBitmap;
// CallTwainProc(&m_AppId,&m_Source,DG_IMAGE,DAT_IMAGENATIVEXFER,MSG_GET,&hBitmap);
//这里失败了
CallTwainProc(&m_AppId,&m_Source,DG_IMAGE, DAT_IMAGEFILEXFER, MSG_GET, NULL);
qDebug()<<"m_returnCode "<<m_returnCode;
switch(m_returnCode)
{
case TWRC_XFERDONE:
qDebug()<<"01";
CopyImage(hBitmap,info);//本类的虚函数 子类实现获取图片后的操作
break;
case TWRC_CANCEL:
qDebug()<<"02";
break;
case TWRC_FAILURE:
break;
CancelTransfer();//终止传输
return false;
}
GlobalFree(hBitmap);//释放图片内存
return EndTransfer();
}
//获取数据源列表
void CTwain::get_source_list()
{
if(!sourcelist.isEmpty())
{
sourcelist.clear();
}
if (CallTwainProc(&m_AppId,nullptr,DG_CONTROL,DAT_IDENTITY,MSG_GETFIRST,&m_Source))
{
TW_IDENTITY temp_Source = m_Source;
sourcelist.append(temp_Source);//添加到链表
// qDebug()<<"可用扫描仪："<<temp_Source.ProductName;
while(CallTwainProc(&m_AppId,nullptr,DG_CONTROL,DAT_IDENTITY,MSG_GETNEXT,&m_Source))
{
TW_IDENTITY temp_Source = m_Source;
sourcelist.append(temp_Source);//添加到链表
// qDebug()<<"可用扫描仪："<<temp_Source.ProductName;
}
m_Source = sourcelist.value(0);//第一个可用的扫描源
m_bSourceSelected = TRUE;
}
else
{
qDebug()<<"没有可用的扫描仪";
m_bSourceSelected = FALSE;
}
}
