From 08e0dc14d08678cb8cb8d8eafddeec73f08ae272 Mon Sep 17 00:00:00 2001 From: yangjiaxuan <171295266@qq.com> Date: Mon, 29 Jan 2024 14:41:37 +0800 Subject: [PATCH] =?UTF-8?q?twain--=E5=AF=BC=E5=87=BA=E8=AE=BE=E7=BD=AE?= =?UTF-8?q?=E5=8D=8F=E8=AE=AE=E5=92=8C=E8=8E=B7=E5=8F=96=E5=8D=8F=E8=AE=AE?= =?UTF-8?q?=E7=9A=84=E6=8E=A5=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- build2/qt/HGTwainUser/HGTwainUser.def | 2 + modules/twain_user/HGTwain.cpp | 22 + modules/twain_user/HGTwain.h | 37 ++ modules/twain_user/HGTwainImpl.cpp | 587 +++++++++++++++++--------- modules/twain_user/HGTwainImpl.hpp | 12 +- 5 files changed, 452 insertions(+), 208 deletions(-) diff --git a/build2/qt/HGTwainUser/HGTwainUser.def b/build2/qt/HGTwainUser/HGTwainUser.def index 4b469939..263226ae 100644 --- a/build2/qt/HGTwainUser/HGTwainUser.def +++ b/build2/qt/HGTwainUser/HGTwainUser.def @@ -27,3 +27,5 @@ HGTwain_EnableDSUIOnly HGTwain_EnableDS HGTwain_EnableDSWithSingleScan HGTwain_DisableDS +HGTwain_SetCapbility +HGTwain_GetCapbility diff --git a/modules/twain_user/HGTwain.cpp b/modules/twain_user/HGTwain.cpp index 853a8ea2..3123996d 100644 --- a/modules/twain_user/HGTwain.cpp +++ b/modules/twain_user/HGTwain.cpp @@ -324,3 +324,25 @@ HGResult HGAPI HGTwain_DisableDS(HGTwainDS ds) HGTwainDSImpl* twainDSImpl = (HGTwainDSImpl*)ds; return twainDSImpl->Disable(); } + +HGEXPORT HGResult HGAPI HGTwain_SetCapbility(HGTwainDS ds, HGUShort cap, const HGCapValue *value, HGBool reset) +{ + if (NULL == ds) + { + return HGBASE_ERR_INVALIDARG; + } + + HGTwainDSImpl* twainDSImpl = (HGTwainDSImpl*)ds; + return twainDSImpl->SetCapbility(cap, value, reset); +} + +HGEXPORT HGResult HGAPI HGTwain_GetCapbility(HGTwainDS ds, HGUShort cap, HGCapValue *value) +{ + if (NULL == ds) + { + return HGBASE_ERR_INVALIDARG; + } + + HGTwainDSImpl* twainDSImpl = (HGTwainDSImpl*)ds; + return twainDSImpl->GetCapbility(cap, value); +} diff --git a/modules/twain_user/HGTwain.h b/modules/twain_user/HGTwain.h index 18e1bb35..ac4c2cab 100644 --- a/modules/twain_user/HGTwain.h +++ b/modules/twain_user/HGTwain.h @@ -33,8 +33,41 @@ typedef struct HGInt totalCount; // 历史张数 }HGTwainDeviceCustomInfo; +typedef struct +{ + HGUInt type; + union + { + HGChar valueChar; + HGByte valueByte; + HGShort valueShort; + HGUShort valueUShort; + HGInt valueInt; + HGUInt valueUInt; + HGBool valueBool; + HGFloat valueFloat; + HGChar valueStr32[32]; + HGChar valueStr64[64]; + HGChar valueStr128[128]; + HGChar valueStr255[255]; + }; +}HGCapValue; + #pragma pack(pop) +#define HGCAPVALUE_TYPE_CHAR 1 +#define HGCAPVALUE_TYPE_BYTE 2 +#define HGCAPVALUE_TYPE_SHORT 3 +#define HGCAPVALUE_TYPE_USHORT 4 +#define HGCAPVALUE_TYPE_INT 5 +#define HGCAPVALUE_TYPE_UINT 6 +#define HGCAPVALUE_TYPE_BOOL 7 +#define HGCAPVALUE_TYPE_FLOAT 8 +#define HGCAPVALUE_TYPE_STR32 9 +#define HGCAPVALUE_TYPE_STR64 10 +#define HGCAPVALUE_TYPE_STR128 11 +#define HGCAPVALUE_TYPE_STR255 12 + #define HGTWAIN_EVENT_TYPE_WORKING 1L #define HGTWAIN_EVENT_TYPE_SCANFINISHED 2L #define HGTWAIN_EVENT_TYPE_CLOSEDSREQ 3L @@ -98,4 +131,8 @@ HGEXPORT HGResult HGAPI HGTwain_EnableDSWithSingleScan(HGTwainDS ds, HWND parent HGEXPORT HGResult HGAPI HGTwain_DisableDS(HGTwainDS ds); +HGEXPORT HGResult HGAPI HGTwain_SetCapbility(HGTwainDS ds, HGUShort cap, const HGCapValue *value, HGBool reset); + +HGEXPORT HGResult HGAPI HGTwain_GetCapbility(HGTwainDS ds, HGUShort cap, HGCapValue *value); + #endif /* __HGTWAIN_H__ */ diff --git a/modules/twain_user/HGTwainImpl.cpp b/modules/twain_user/HGTwainImpl.cpp index bde634ec..5adb51b6 100644 --- a/modules/twain_user/HGTwainImpl.cpp +++ b/modules/twain_user/HGTwainImpl.cpp @@ -432,7 +432,13 @@ HGResult HGTwainDSImpl::GetDeviceName(HGChar* name, HGUInt maxLen) return HGBASE_ERR_INVALIDARG; } - return GetCapStr255(0x8854, name, maxLen); + HGCapValue value; + value.type = HGCAPVALUE_TYPE_STR255; + HGResult ret = GetCapbility(0x8854, &value); + if (HGBASE_ERR_OK == ret) + strcpy(name, value.valueStr255); + + return ret; } HGResult HGTwainDSImpl::GetDeviceCustomInfo(HGTwainDeviceCustomInfo *info) @@ -444,22 +450,42 @@ HGResult HGTwainDSImpl::GetDeviceCustomInfo(HGTwainDeviceCustomInfo *info) memset(info, 0, sizeof(HGTwainDeviceCustomInfo)); - GetCapInt(0x8852, &info->vid); - GetCapInt(0x8853, &info->pid); - GetCapStr255(0x8856, info->sn, sizeof(info->sn)); - GetCapStr255(0x8855, info->type, sizeof(info->type)); - GetCapStr255(0x8857, info->fwVer, sizeof(info->fwVer)); - GetCapStr255(0x8858, info->ip, sizeof(info->ip)); - GetCapStr255(0x8859, info->mac, sizeof(info->mac)); - GetCapStr255(0x884A, info->driverVer, sizeof(info->driverVer)); - GetCapStr255(0x884B, info->vendor, sizeof(info->vendor)); - GetCapStr255(0x884C, info->copyright, sizeof(info->copyright)); - GetCapStr255(0x884D, info->comUrl, sizeof(info->comUrl)); - GetCapStr255(0x884E, info->comTel, sizeof(info->comTel)); - GetCapStr255(0x884F, info->comAddr, sizeof(info->comAddr)); - GetCapStr255(0x8850, info->comGps, sizeof(info->comGps)); - GetCapInt(0x9902, &info->rollerCount); - GetCapInt(0x8849, &info->totalCount); + HGCapValue value; + + GetCapbility(0x8852, &value); + info->vid = value.valueInt; + GetCapbility(0x8853, &value); + info->pid = value.valueInt; + + GetCapbility(0x8856, &value); + strcpy(info->sn, value.valueStr255); + GetCapbility(0x8855, &value); + strcpy(info->type, value.valueStr255); + GetCapbility(0x8857, &value); + strcpy(info->fwVer, value.valueStr255); + GetCapbility(0x8858, &value); + strcpy(info->ip, value.valueStr255); + GetCapbility(0x8859, &value); + strcpy(info->mac, value.valueStr255); + GetCapbility(0x884A, &value); + strcpy(info->driverVer, value.valueStr255); + GetCapbility(0x884B, &value); + strcpy(info->vendor, value.valueStr255); + GetCapbility(0x884C, &value); + strcpy(info->copyright, value.valueStr255); + GetCapbility(0x884D, &value); + strcpy(info->comUrl, value.valueStr255); + GetCapbility(0x884E, &value); + strcpy(info->comTel, value.valueStr255); + GetCapbility(0x884F, &value); + strcpy(info->comAddr, value.valueStr255); + GetCapbility(0x8850, &value); + strcpy(info->comGps, value.valueStr255); + + GetCapbility(0x9902, &value); + info->rollerCount = value.valueInt; + GetCapbility(0x8849, &value); + info->totalCount = value.valueInt; return HGBASE_ERR_OK; } @@ -530,11 +556,70 @@ HGResult HGTwainDSImpl::Logout() HGResult HGTwainDSImpl::ClearRollerCount() { - return ResetCapInt(0x9902, TWTY_INT32); + HGCapValue value; + value.type = HGCAPVALUE_TYPE_INT; + value.valueInt = 0; + + return SetCapbility(0x9902, &value, true); } #pragma pack(push) #pragma pack(1) +struct CapInt8Type +{ + TW_UINT16 ItemType; + TW_INT8 Value; +}; +struct CapInt16Type +{ + TW_UINT16 ItemType; + TW_INT16 Value; +}; +struct CapInt32Type +{ + TW_UINT16 ItemType; + TW_INT32 Value; +}; +struct CapUInt8Type +{ + TW_UINT16 ItemType; + TW_UINT8 Value; +}; +struct CapUInt16Type +{ + TW_UINT16 ItemType; + TW_UINT16 Value; +}; +struct CapUInt32Type +{ + TW_UINT16 ItemType; + TW_UINT32 Value; +}; +struct CapBoolType +{ + TW_UINT16 ItemType; + TW_BOOL Value; +}; +struct CapFix32Type +{ + TW_UINT16 ItemType; + TW_FIX32 Value; +}; +struct CapStr32Type +{ + TW_UINT16 ItemType; + TW_STR32 Value; +}; +struct CapStr64Type +{ + TW_UINT16 ItemType; + TW_STR64 Value; +}; +struct CapStr128Type +{ + TW_UINT16 ItemType; + TW_STR128 Value; +}; struct CapStr255Type { TW_UINT16 ItemType; @@ -571,7 +656,9 @@ HGResult HGTwainDSImpl::GetDriverLog(const HGChar *fileName) HGResult HGTwainDSImpl::ClearDriverLog() { - return ResetCapStr255(0x9903); + HGCapValue value; + value.type = HGCAPVALUE_TYPE_STR255; + return SetCapbility(0x9903, &value, true); } HGResult HGTwainDSImpl::GetDeviceLog(const HGChar *fileName) @@ -603,7 +690,10 @@ HGResult HGTwainDSImpl::GetDeviceLog(const HGChar *fileName) HGResult HGTwainDSImpl::ClearDeviceLog() { - return ResetCapStr255(0x9904); + + HGCapValue value; + value.type = HGCAPVALUE_TYPE_STR255; + return SetCapbility(0x9904, &value, true); } HGResult HGTwainDSImpl::EnableUIOnly(HWND parent, HGDSEventFunc eventFunc, HGPointer eventParam) @@ -660,8 +750,10 @@ HGResult HGTwainDSImpl::Enable(HGBool showUI, HWND parent, HGDSEventFunc eventFu HGResult HGTwainDSImpl::EnableWithSingleScan(HWND parent, HGDSEventFunc eventFunc, HGPointer eventParam, HGDSImageFunc imageFunc, HGPointer imageParam) { - HGInt oldXferCount = -1; - HGResult ret = GetCapInt(CAP_XFERCOUNT, &oldXferCount); + HGCapValue value; + HGResult ret = GetCapbility(CAP_XFERCOUNT, &value); + HGInt oldXferCount = value.valueInt; + if (HGBASE_ERR_OK != ret) { TW_STATUS status; @@ -672,7 +764,10 @@ HGResult HGTwainDSImpl::EnableWithSingleScan(HWND parent, HGDSEventFunc eventFun return ret; } - ret = SetCapInt(CAP_XFERCOUNT, TWTY_INT16, 1); + HGCapValue value2; + value2.type = HGCAPVALUE_TYPE_SHORT; + value2.valueInt = 1; + ret = SetCapbility(CAP_XFERCOUNT, &value2, false); if (HGBASE_ERR_OK != ret) { TW_STATUS status; @@ -688,7 +783,10 @@ HGResult HGTwainDSImpl::EnableWithSingleScan(HWND parent, HGDSEventFunc eventFun twUI.hParent = (TW_HANDLE)parent; if (TWRC_SUCCESS != m_dsmImpl->m_pDSMProc(&m_dsmImpl->m_AppId, &m_iden, DG_CONTROL, DAT_USERINTERFACE, MSG_ENABLEDS, (TW_MEMREF)&twUI)) { - SetCapInt(CAP_XFERCOUNT, TWTY_INT16, oldXferCount); + HGCapValue value3; + value3.type = HGCAPVALUE_TYPE_SHORT; + value3.valueInt = oldXferCount; + SetCapbility(CAP_XFERCOUNT, &value3, false); TW_STATUS status; m_dsmImpl->m_pDSMProc(&m_dsmImpl->m_AppId, &m_iden, DG_CONTROL, DAT_STATUS, MSG_GET, (TW_MEMREF)&status); @@ -718,7 +816,10 @@ HGResult HGTwainDSImpl::Disable() if (m_singleScan) { - SetCapInt(CAP_XFERCOUNT, TWTY_INT16, m_oldXferCount); + HGCapValue value; + value.type = HGCAPVALUE_TYPE_SHORT; + value.valueInt = m_oldXferCount; + SetCapbility(CAP_XFERCOUNT, &value, false); } m_singleScan = FALSE; @@ -732,75 +833,77 @@ HGResult HGTwainDSImpl::Disable() return HGBASE_ERR_OK; } -#pragma pack(push) -#pragma pack(1) -struct CapInt8Type -{ - TW_UINT16 ItemType; - TW_INT8 Value; -}; -struct CapInt16Type -{ - TW_UINT16 ItemType; - TW_INT16 Value; -}; -struct CapInt32Type -{ - TW_UINT16 ItemType; - TW_INT32 Value; -}; -#pragma pack(pop) - -HGResult HGTwainDSImpl::SetCapInt(HGUInt cap, TW_UINT16 itemType, HGInt value) -{ - TW_CAPABILITY twCap; - twCap.Cap = (TW_UINT16)cap; - twCap.ConType = TWON_ONEVALUE; - DWORD size = sizeof(CapInt32Type); - if (itemType == TWTY_INT8) - size = sizeof(CapInt8Type); - else if (itemType == TWTY_INT16) - size = sizeof(CapInt16Type); - twCap.hContainer = GlobalAlloc(GHND, size); - if (NULL == twCap.hContainer) - { - return HGBASE_ERR_FAIL; - } - - void* pVal = GlobalLock(twCap.hContainer); - assert(NULL != pVal); - if (itemType == TWTY_INT8) - { - ((CapInt8Type*)pVal)->ItemType = TWTY_INT8; - ((CapInt8Type*)pVal)->Value = (TW_INT8)value; - } - else if (itemType == TWTY_INT16) - { - ((CapInt16Type*)pVal)->ItemType = TWTY_INT16; - ((CapInt16Type*)pVal)->Value = (TW_INT16)value; - } - else - { - ((CapInt32Type*)pVal)->ItemType = TWTY_INT32; - ((CapInt32Type*)pVal)->Value = (TW_INT32)value; - } - GlobalUnlock(twCap.hContainer); - - USHORT ret = m_dsmImpl->m_pDSMProc(&m_dsmImpl->m_AppId, &m_iden, DG_CONTROL, DAT_CAPABILITY, MSG_SET, &twCap); - GlobalFree(twCap.hContainer); - return (TWRC_SUCCESS == ret) ? HGBASE_ERR_OK : HGTWAIN_ERR_FAIL; -} - -HGResult HGTwainDSImpl::ResetCapInt(HGUInt cap, TW_UINT16 itemType) +HGResult HGTwainDSImpl::SetCapbility(HGUShort cap, const HGCapValue* value, HGBool reset) { TW_CAPABILITY twCap; twCap.Cap = (TW_UINT16)cap; twCap.ConType = TWON_ONEVALUE; - DWORD size = sizeof(CapInt32Type); - if (itemType == TWTY_INT8) + twCap.hContainer = NULL; + + HGInt size = 0; + TW_UINT16 itemType = 0; + + if (HGCAPVALUE_TYPE_CHAR == value->type) + { size = sizeof(CapInt8Type); - else if (itemType == TWTY_INT16) + itemType = TWTY_INT8; + } + else if (HGCAPVALUE_TYPE_BYTE == value->type) + { + size = sizeof(CapUInt8Type); + itemType = TWTY_UINT8; + } + else if (HGCAPVALUE_TYPE_SHORT == value->type) + { size = sizeof(CapInt16Type); + itemType = TWTY_INT16; + } + else if (HGCAPVALUE_TYPE_USHORT == value->type) + { + size = sizeof(CapUInt16Type); + itemType = TWTY_UINT16; + } + else if (HGCAPVALUE_TYPE_INT == value->type) + { + size = sizeof(CapInt32Type); + itemType = TWTY_INT32; + } + else if (HGCAPVALUE_TYPE_UINT == value->type) + { + size = sizeof(CapUInt32Type); + itemType = TWTY_UINT32; + } + else if (HGCAPVALUE_TYPE_BOOL == value->type) + { + size = sizeof(CapBoolType); + itemType = TWTY_BOOL; + } + else if (HGCAPVALUE_TYPE_FLOAT == value->type) + { + size = sizeof(CapFix32Type); + itemType = TWTY_FIX32; + } + else if (HGCAPVALUE_TYPE_STR32 == value->type) + { + size = sizeof(CapStr32Type); + itemType = TWTY_STR32; + } + else if (HGCAPVALUE_TYPE_STR64 == value->type) + { + size = sizeof(CapStr64Type); + itemType = TWTY_STR64; + } + else if (HGCAPVALUE_TYPE_STR128 == value->type) + { + size = sizeof(CapStr128Type); + itemType = TWTY_STR128; + } + else if (HGCAPVALUE_TYPE_STR255 == value->type) + { + size = sizeof(CapStr255Type); + itemType = TWTY_STR255; + } + twCap.hContainer = GlobalAlloc(GHND, size); if (NULL == twCap.hContainer) { @@ -809,125 +912,94 @@ HGResult HGTwainDSImpl::ResetCapInt(HGUInt cap, TW_UINT16 itemType) void* pVal = GlobalLock(twCap.hContainer); assert(NULL != pVal); - if (itemType == TWTY_INT8) + + if (HGCAPVALUE_TYPE_CHAR == value->type) { - ((CapInt8Type*)pVal)->ItemType = TWTY_INT8; - ((CapInt8Type*)pVal)->Value = 0; + ((CapInt8Type*)pVal)->ItemType = itemType; + ((CapInt8Type*)pVal)->Value = value->valueChar; } - else if (itemType == TWTY_INT16) + else if (HGCAPVALUE_TYPE_BYTE == value->type) { - ((CapInt16Type*)pVal)->ItemType = TWTY_INT16; - ((CapInt16Type*)pVal)->Value = 0; + ((CapUInt8Type*)pVal)->ItemType = itemType; + ((CapUInt8Type*)pVal)->Value = value->valueByte; } - else + else if (HGCAPVALUE_TYPE_SHORT == value->type) { - ((CapInt32Type*)pVal)->ItemType = TWTY_INT32; - ((CapInt32Type*)pVal)->Value = 0; + ((CapInt16Type*)pVal)->ItemType = itemType; + ((CapInt16Type*)pVal)->Value = value->valueShort; + } + else if (HGCAPVALUE_TYPE_USHORT == value->type) + { + ((CapUInt16Type*)pVal)->ItemType = itemType; + ((CapUInt16Type*)pVal)->Value = value->valueUShort; + } + else if (HGCAPVALUE_TYPE_INT == value->type) + { + ((CapInt32Type*)pVal)->ItemType = itemType; + ((CapInt32Type*)pVal)->Value = value->valueInt; + } + else if (HGCAPVALUE_TYPE_UINT == value->type) + { + ((CapUInt32Type*)pVal)->ItemType = itemType; + ((CapUInt32Type*)pVal)->Value = value->valueUInt; + } + else if (HGCAPVALUE_TYPE_BOOL == value->type) + { + ((CapBoolType*)pVal)->ItemType = itemType; + ((CapBoolType*)pVal)->Value = value->valueBool; + } + else if (HGCAPVALUE_TYPE_FLOAT == value->type) + { + ((CapFix32Type*)pVal)->ItemType = itemType; + ((CapFix32Type*)pVal)->Value = FloatToFIX32(value->valueFloat); + } + else if (HGCAPVALUE_TYPE_STR32 == value->type) + { + assert(NULL != pVal); + ((CapStr32Type*)pVal)->ItemType = itemType; + if (reset) + memset(((CapStr32Type*)pVal)->Value, 0, sizeof(((CapStr32Type*)pVal)->Value)); + else + strcpy(((CapStr32Type*)pVal)->Value, value->valueStr32); + } + else if (HGCAPVALUE_TYPE_STR64 == value->type) + { + assert(NULL != pVal); + ((CapStr64Type*)pVal)->ItemType = itemType; + if (reset) + memset(((CapStr64Type*)pVal)->Value, 0, sizeof(((CapStr64Type*)pVal)->Value)); + else + strcpy(((CapStr64Type*)pVal)->Value, value->valueStr64); + } + else if (HGCAPVALUE_TYPE_STR128 == value->type) + { + assert(NULL != pVal); + ((CapStr128Type*)pVal)->ItemType = itemType; + if (reset) + memset(((CapStr128Type*)pVal)->Value, 0, sizeof(((CapStr128Type*)pVal)->Value)); + else + strcpy(((CapStr128Type*)pVal)->Value, value->valueStr128); + } + else if (HGCAPVALUE_TYPE_STR255 == value->type) + { + assert(NULL != pVal); + ((CapStr255Type*)pVal)->ItemType = itemType; + if (reset) + memset(((CapStr255Type*)pVal)->Value, 0, sizeof(((CapStr255Type*)pVal)->Value)); + else + strcpy(((CapStr255Type*)pVal)->Value, value->valueStr255); } - GlobalUnlock(twCap.hContainer); - USHORT ret = m_dsmImpl->m_pDSMProc(&m_dsmImpl->m_AppId, &m_iden, DG_CONTROL, DAT_CAPABILITY, MSG_RESET, &twCap); + GlobalUnlock(twCap.hContainer); + + USHORT ret = m_dsmImpl->m_pDSMProc(&m_dsmImpl->m_AppId, &m_iden, DG_CONTROL, DAT_CAPABILITY, reset ? MSG_RESET : MSG_SET, &twCap); GlobalFree(twCap.hContainer); return (TWRC_SUCCESS == ret) ? HGBASE_ERR_OK : HGTWAIN_ERR_FAIL; } -HGResult HGTwainDSImpl::GetCapInt(HGUInt cap, HGInt* value) +HGResult HGTwainDSImpl::GetCapbility(HGUShort cap, HGCapValue* value) { - if (NULL == value) - { - return HGBASE_ERR_INVALIDARG; - } - - TW_CAPABILITY twCap; - twCap.Cap = (TW_UINT16)cap; - twCap.ConType = TWON_ONEVALUE; - twCap.hContainer = NULL; - if (TWRC_SUCCESS != m_dsmImpl->m_pDSMProc(&m_dsmImpl->m_AppId, &m_iden, DG_CONTROL, DAT_CAPABILITY, MSG_GETCURRENT, &twCap)) - { - return HGTWAIN_ERR_FAIL; - } - - HGResult ret = HGBASE_ERR_FAIL; - assert(NULL != twCap.hContainer); - void* pVal = GlobalLock(twCap.hContainer); - if (NULL != pVal) - { - TW_UINT16 ItemType = *(TW_UINT16*)pVal; - if (ItemType == TWTY_INT8) - { - *value = ((CapInt8Type*)pVal)->Value; - ret = HGBASE_ERR_OK; - } - else if (ItemType == TWTY_INT16) - { - *value = ((CapInt16Type*)pVal)->Value; - ret = HGBASE_ERR_OK; - } - else if (ItemType == TWTY_INT32) - { - *value = ((CapInt32Type*)pVal)->Value; - ret = HGBASE_ERR_OK; - } - - GlobalUnlock(twCap.hContainer); - } - - GlobalFree(twCap.hContainer); - return ret; -} - -HGResult HGTwainDSImpl::SetCapStr255(HGUInt cap, const HGChar *value) -{ - if (NULL == value || strlen(value) >= sizeof(TW_STR255)) - { - return HGBASE_ERR_INVALIDARG; - } - - TW_CAPABILITY twCap; - twCap.Cap = (TW_UINT16)cap; - twCap.ConType = TWON_ONEVALUE; - twCap.hContainer = GlobalAlloc(GHND, sizeof(CapStr255Type)); - if (NULL == twCap.hContainer) - { - return HGBASE_ERR_FAIL; - } - - CapStr255Type* pVal = (CapStr255Type*)GlobalLock(twCap.hContainer); - assert(NULL != pVal); - pVal->ItemType = TWTY_STR255; - strcpy(pVal->Value, value); - GlobalUnlock(twCap.hContainer); - - USHORT ret = m_dsmImpl->m_pDSMProc(&m_dsmImpl->m_AppId, &m_iden, DG_CONTROL, DAT_CAPABILITY, MSG_SET, &twCap); - GlobalFree(twCap.hContainer); - return (TWRC_SUCCESS == ret) ? HGBASE_ERR_OK : HGTWAIN_ERR_FAIL; -} - -HGResult HGTwainDSImpl::ResetCapStr255(HGUInt cap) -{ - TW_CAPABILITY twCap; - twCap.Cap = (TW_UINT16)cap; - twCap.ConType = TWON_ONEVALUE; - twCap.hContainer = GlobalAlloc(GHND, sizeof(CapStr255Type)); - if (NULL == twCap.hContainer) - { - return HGBASE_ERR_FAIL; - } - - CapStr255Type* pVal = (CapStr255Type*)GlobalLock(twCap.hContainer); - assert(NULL != pVal); - pVal->ItemType = TWTY_STR255; - memset(pVal->Value, 0, sizeof(pVal->Value)); - GlobalUnlock(twCap.hContainer); - - USHORT ret = m_dsmImpl->m_pDSMProc(&m_dsmImpl->m_AppId, &m_iden, DG_CONTROL, DAT_CAPABILITY, MSG_RESET, &twCap); - GlobalFree(twCap.hContainer); - return (TWRC_SUCCESS == ret) ? HGBASE_ERR_OK : HGTWAIN_ERR_FAIL; -} - -HGResult HGTwainDSImpl::GetCapStr255(HGUInt cap, HGChar *value, HGUInt maxLen) -{ - if (NULL == value || 0 == maxLen) + if (NULL == value) { return HGBASE_ERR_INVALIDARG; } @@ -943,20 +1015,115 @@ HGResult HGTwainDSImpl::GetCapStr255(HGUInt cap, HGChar *value, HGUInt maxLen) HGResult ret = HGBASE_ERR_FAIL; assert(NULL != twCap.hContainer); - CapStr255Type* pVal = (CapStr255Type*)GlobalLock(twCap.hContainer); - if (NULL != pVal && pVal->ItemType == TWTY_STR255) + void* pVal = GlobalLock(twCap.hContainer); + if (NULL != pVal) { - if (maxLen > strlen(pVal->Value)) + TW_UINT16 ItemType = *(TW_UINT16*)pVal; + + if (ItemType == TWTY_INT8) { - strcpy(value, pVal->Value); + value->type = HGCAPVALUE_TYPE_CHAR; + value->valueChar = ((CapInt8Type*)pVal)->Value; ret = HGBASE_ERR_OK; } - else + else if (ItemType == TWTY_UINT8) { - ret = HGBASE_ERR_INVALIDARG; + value->type = HGCAPVALUE_TYPE_BYTE; + value->valueByte = ((CapUInt8Type*)pVal)->Value; + ret = HGBASE_ERR_OK; } + else if (ItemType == TWTY_INT16) + { + value->type = HGCAPVALUE_TYPE_SHORT; + value->valueShort = ((CapInt16Type*)pVal)->Value; + ret = HGBASE_ERR_OK; + } + else if (ItemType == TWTY_UINT16) + { + value->type = HGCAPVALUE_TYPE_USHORT; + value->valueUShort = ((CapUInt16Type*)pVal)->Value; + ret = HGBASE_ERR_OK; + } + else if (ItemType == TWTY_INT32) + { + value->type = HGCAPVALUE_TYPE_INT; + value->valueInt = ((CapInt32Type*)pVal)->Value; + ret = HGBASE_ERR_OK; + } + else if (ItemType == TWTY_UINT32) + { + value->type = HGCAPVALUE_TYPE_UINT; + value->valueUInt = ((CapUInt32Type*)pVal)->Value; + ret = HGBASE_ERR_OK; + } + else if (ItemType == TWTY_BOOL) + { + value->type = HGCAPVALUE_TYPE_BOOL; + value->valueBool = ((CapBoolType*)pVal)->Value; + ret = HGBASE_ERR_OK; + } + else if (ItemType == TWTY_FIX32) + { + value->type = HGCAPVALUE_TYPE_FLOAT; + value->valueFloat = FIX32ToFloat(((CapFix32Type*)pVal)->Value); + + ret = HGBASE_ERR_OK; + } + else if (ItemType == TWTY_STR32) + { + if (32 > strlen(((CapStr32Type*)pVal)->Value)) + { + value->type = HGCAPVALUE_TYPE_STR32; + strcpy(value->valueStr32, ((CapStr32Type*)pVal)->Value); + ret = HGBASE_ERR_OK; + } + else + { + ret = HGBASE_ERR_INVALIDARG; + } + } + else if (ItemType == TWTY_STR64) + { + if (64 > strlen(((CapStr64Type*)pVal)->Value)) + { + value->type = HGCAPVALUE_TYPE_STR64; + strcpy(value->valueStr64, ((CapStr64Type*)pVal)->Value); + ret = HGBASE_ERR_OK; + } + else + { + ret = HGBASE_ERR_INVALIDARG; + } + } + else if (ItemType == TWTY_STR128) + { + if (128 > strlen(((CapStr128Type*)pVal)->Value)) + { + value->type = HGCAPVALUE_TYPE_STR128; + strcpy(value->valueStr128, ((CapStr128Type*)pVal)->Value); + ret = HGBASE_ERR_OK; + } + else + { + ret = HGBASE_ERR_INVALIDARG; + } + } + else if (ItemType == TWTY_STR255) + { + if (255 > strlen(((CapStr255Type*)pVal)->Value)) + { + value->type = HGCAPVALUE_TYPE_STR255; + strcpy(value->valueStr255, ((CapStr255Type*)pVal)->Value); + ret = HGBASE_ERR_OK; + } + else + { + ret = HGBASE_ERR_INVALIDARG; + } + } + + GlobalUnlock(twCap.hContainer); } - GlobalUnlock(twCap.hContainer); GlobalFree(twCap.hContainer); return ret; @@ -1045,6 +1212,22 @@ HGResult HGTwainDSImpl::Reset() return HGBASE_ERR_OK; } +TW_FIX32 HGTwainDSImpl::FloatToFIX32(float i_float) +{ + TW_FIX32 Fix32_value; + TW_INT32 value = (TW_INT32)(i_float * 65536.0 + 0.5); + Fix32_value.Whole = LOWORD(value >> 16); + Fix32_value.Frac = LOWORD(value & 0x0000ffffL); + return Fix32_value; +} + +float HGTwainDSImpl::FIX32ToFloat(TW_FIX32 FIX32Value) +{ + TW_INT16 whole = FIX32Value.Whole; + TW_UINT16 frac = FIX32Value.Frac; + return (float)(whole << 16 | frac) / 65536.0; +} + void HGAPI HGTwainDSImpl::ThreadFunc(HGThread thread, HGPointer param) { (void)thread; diff --git a/modules/twain_user/HGTwainImpl.hpp b/modules/twain_user/HGTwainImpl.hpp index 1a1a5c2b..d1ac6d6f 100644 --- a/modules/twain_user/HGTwainImpl.hpp +++ b/modules/twain_user/HGTwainImpl.hpp @@ -72,17 +72,17 @@ public: HGDSImageFunc imageFunc, HGPointer imageParam); HGResult Disable(); + HGResult SetCapbility(HGUShort cap, const HGCapValue* value, HGBool reset); + HGResult GetCapbility(HGUShort cap, HGCapValue* value); + private: - HGResult SetCapInt(HGUInt cap, TW_UINT16 itemType, HGInt value); - HGResult ResetCapInt(HGUInt cap, TW_UINT16 itemType); - HGResult GetCapInt(HGUInt cap, HGInt* value); - HGResult SetCapStr255(HGUInt cap, const HGChar *value); - HGResult ResetCapStr255(HGUInt cap); - HGResult GetCapStr255(HGUInt cap, HGChar *value, HGUInt maxLen); HGResult ImageNativeXfer(HGUInt type, HGUInt origin, HGImage* image); HGResult EndXfer(HGUInt* count); HGResult Reset(); + TW_FIX32 FloatToFIX32(float i_float); + float FIX32ToFloat(TW_FIX32 FIX32Value); + static void HGAPI ThreadFunc(HGThread thread, HGPointer param); private: