From 6872573516d0303136025696600bed61b37eb3b4 Mon Sep 17 00:00:00 2001 From: "m4gn3to@gmail.com" Date: Mon, 9 Jun 2025 14:25:05 +0200 Subject: [PATCH] =?UTF-8?q?a=C3=B1ado=20los=20ficheros=20de=20clases=20pri?= =?UTF-8?q?ncipales?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- class/SMARTComm70.cpp | 1386 +++++++++++++++++++++++++ class/SMARTComm70.h | 331 ++++++ class/SmartCommon.dll.h | 2177 +++++++++++++++++++++++++++++++++++++++ class/SmartErrCodes.h | 270 +++++ 4 files changed, 4164 insertions(+) create mode 100644 class/SMARTComm70.cpp create mode 100644 class/SMARTComm70.h create mode 100644 class/SmartCommon.dll.h create mode 100644 class/SmartErrCodes.h diff --git a/class/SMARTComm70.cpp b/class/SMARTComm70.cpp new file mode 100644 index 0000000..61af857 --- /dev/null +++ b/class/SMARTComm70.cpp @@ -0,0 +1,1386 @@ +#include "stdafx.h" +#include "SMARTComm70.h" +#include "SmartErrcodes.h" + + + + +CSMARTCommon::CSMARTCommon(void) +{ + m_hDll = NULL; + m_hSmart = NULL; + m_nLastRes = SM_SUCCESS; +} + +CSMARTCommon::~CSMARTCommon(void) +{ + Free(); +} + + + +#define GETDLLFUNC(_hdll,_fn) (_fn) GetProcAddress( (_hdll), (#_fn) ) + +BOOL CSMARTCommon::Load(LPTSTR dllFile) +{ + m_hDll = LoadLibrary( dllFile ); + if( m_hDll == NULL ) + { + return FALSE; + } + + + m_pfn_GetDeviceList = GETDLLFUNC( m_hDll, Smart70_GetDeviceList ); + m_pfn_ExGetDeviceList = GETDLLFUNC( m_hDll, Smart70_ExGetDeviceList ); + m_pfn_GetDeviceInfo = GETDLLFUNC( m_hDll, Smart70_GetDeviceInfo ); + m_pfn_OpenDevice = GETDLLFUNC( m_hDll, Smart70_OpenDevice ); + m_pfn_ExOpenDevice = GETDLLFUNC( m_hDll, Smart70_ExOpenDevice ); + m_pfn_CloseDevice = GETDLLFUNC( m_hDll, Smart70_CloseDevice ); + m_pfn_GetRibbonInfo = GETDLLFUNC( m_hDll, Smart70_GetRibbonInfo ); + m_pfn_GetConnectedDevices = GETDLLFUNC( m_hDll, Smart70_GetConnectedDevices ); + m_pfn_GetConnectedModules = GETDLLFUNC( m_hDll, Smart70_GetConnectedModules ); + m_pfn_ICHContact = GETDLLFUNC( m_hDll, Smart70_ICHContact ); + m_pfn_ICHDiscontact = GETDLLFUNC( m_hDll, Smart70_ICHDiscontact ); + m_pfn_OpenDocument = GETDLLFUNC( m_hDll, Smart70_OpenDocument ); + m_pfn_CloseDocument = GETDLLFUNC( m_hDll, Smart70_CloseDocument ); + m_pfn_ClearDocument = GETDLLFUNC( m_hDll, Smart70_ClearDocument ); + m_pfn_GetFieldCount = GETDLLFUNC( m_hDll, Smart70_GetFieldCount ); + m_pfn_GetFieldName = GETDLLFUNC( m_hDll, Smart70_GetFieldName ); + m_pfn_GetFieldValue = GETDLLFUNC( m_hDll, Smart70_GetFieldValue ); + m_pfn_SetFieldValue = GETDLLFUNC( m_hDll, Smart70_SetFieldValue ); + m_pfn_GetPrinterSettings = GETDLLFUNC( m_hDll, Smart70_GetPrinterSettings ); + m_pfn_SetPrinterSettings = GETDLLFUNC( m_hDll, Smart70_SetPrinterSettings ); + m_pfn_DrawImage = GETDLLFUNC( m_hDll, Smart70_DrawImage ); + m_pfn_DrawImage2 = GETDLLFUNC( m_hDll, Smart70_ExDrawImage ); + m_pfn_DrawText = GETDLLFUNC( m_hDll, Smart70_DrawText ); + m_pfn_DrawText2 = GETDLLFUNC( m_hDll, Smart70_DrawText2 ); + m_pfn_DrawRect = GETDLLFUNC( m_hDll, Smart70_DrawRect ); + m_pfn_DrawBarcode = GETDLLFUNC( m_hDll, Smart70_DrawBarcode ); + m_pfn_GetBarcodeTypeCount = GETDLLFUNC( m_hDll, Smart70_GetBarcodeTypeCount ); + m_pfn_GetBarcodeTypeName = GETDLLFUNC( m_hDll, Smart70_GetBarcodeTypeName ); + m_pfn_SetICG = GETDLLFUNC( m_hDll, Smart70_SetICG ); + m_pfn_GetICG = GETDLLFUNC( m_hDll, Smart70_GetICG ); + m_pfn_GetPreviewBitmap = GETDLLFUNC( m_hDll, Smart70_GetPreviewBitmap ); + m_pfn_GetUnitInfo = GETDLLFUNC( m_hDll, Smart70_GetUnitInfo ); + m_pfn_GetFieldLinkedUnitInfo = GETDLLFUNC( m_hDll, Smart70_GetFieldLinkedUnitInfo ); + m_pfn_SetUnitInfo = GETDLLFUNC( m_hDll, Smart70_SetUnitInfo ); + m_pfn_GetUnitInfo2 = GETDLLFUNC( m_hDll, Smart70_GetUnitInfo2 ); + m_pfn_GetFieldLinkedUnitInfo2 = GETDLLFUNC( m_hDll, Smart70_GetFieldLinkedUnitInfo2 ); + m_pfn_SetUnitInfo2 = GETDLLFUNC( m_hDll, Smart70_SetUnitInfo2 ); + m_pfn_GetUnitInfo2Direct = GETDLLFUNC( m_hDll, Smart70_GetUnitInfo2Direct ); + m_pfn_RFPowerOn = GETDLLFUNC( m_hDll, Smart70_RFPowerOn ); + m_pfn_RFPowerOff = GETDLLFUNC( m_hDll, Smart70_RFPowerOff ); + m_pfn_RFTransmit = GETDLLFUNC( m_hDll, Smart70_RFTransmit ); + m_pfn_RFPowerOn2 = GETDLLFUNC( m_hDll, Smart70_RFPowerOn2 ); + m_pfn_RFPowerOff2 = GETDLLFUNC( m_hDll, Smart70_RFPowerOff2 ); + m_pfn_RFTransmit2 = GETDLLFUNC( m_hDll, Smart70_RFTransmit2 ); + m_pfn_ICPowerOn = GETDLLFUNC( m_hDll, Smart70_ICPowerOn ); + m_pfn_ICPowerOff = GETDLLFUNC( m_hDll, Smart70_ICPowerOff ); + m_pfn_ICTransmit = GETDLLFUNC( m_hDll, Smart70_ICTransmit ); + m_pfn_ICPowerOn2 = GETDLLFUNC( m_hDll, Smart70_ICPowerOn2 ); + m_pfn_ICPowerOff2 = GETDLLFUNC( m_hDll, Smart70_ICPowerOff2 ); + m_pfn_ICTransmit2 = GETDLLFUNC( m_hDll, Smart70_ICTransmit2 ); + m_pfn_DCLOpenDevice = GETDLLFUNC( m_hDll, Smart70DCL_OpenDevice ); + m_pfn_DCLExOpenDevice = GETDLLFUNC( m_hDll, Smart70DCL_ExOpenDevice ); + m_pfn_DCLCloseDevice = GETDLLFUNC( m_hDll, Smart70DCL_CloseDevice ); + m_pfn_DCLPrint = GETDLLFUNC( m_hDll, Smart70DCL_Print ); + m_pfn_ExSetConfig = GETDLLFUNC( m_hDll, Smart70_ExSetConfig ); + m_pfn_ExGetConfig = GETDLLFUNC( m_hDll, Smart70_ExGetConfig ); + m_pfn_RequestPreemption = GETDLLFUNC( m_hDll, Smart70_RequestPreemption ); + m_pfn_ReleasePreemption = GETDLLFUNC( m_hDll, Smart70_ReleasePreemption ); + m_pfn_GetModuleState = GETDLLFUNC( m_hDll, Smart70_GetModuleState ); + m_pfn_UpdateModuleState = GETDLLFUNC( m_hDll, Smart70_UpdateModuleState ); + m_pfn_GetStatus = GETDLLFUNC( m_hDll, Smart70_GetStatus ); + m_pfn_IsModuleReady = GETDLLFUNC( m_hDll, Smart70_IsModuleReady ); + m_pfn_IsReadyInsertJob = GETDLLFUNC( m_hDll, Smart70_IsReadyInsertJob ); + m_pfn_ToggleManualMode = GETDLLFUNC( m_hDll, Smart70_ToggleManualMode ); + m_pfn_UpdateCurrPrintJob = GETDLLFUNC( m_hDll, Smart70_UpdateCurrPrintJob ); + m_pfn_GetCurrPrintJob = GETDLLFUNC( m_hDll, Smart70_GetCurrPrintJob ); + m_pfn_DeleteCurrPrintJob = GETDLLFUNC( m_hDll, Smart70_DeleteCurrPrintJob ); + m_pfn_CardIn = GETDLLFUNC( m_hDll, Smart70_CardIn ); + m_pfn_CardOut = GETDLLFUNC( m_hDll, Smart70_CardOut ); + m_pfn_CardMove = GETDLLFUNC( m_hDll, Smart70_CardMove ); + m_pfn_CardMove2 = GETDLLFUNC( m_hDll, Smart70_CardMove2 ); + m_pfn_CardListMove = GETDLLFUNC( m_hDll, Smart70_CardListMove ); + m_pfn_CardMoveQuick = GETDLLFUNC( m_hDll, Smart70_CardMoveQuick ); + m_pfn_CardPass = GETDLLFUNC( m_hDll, Smart70_CardPass ); + m_pfn_CardFlipPass = GETDLLFUNC( m_hDll, Smart70_CardFlipPass ); + m_pfn_CardFlip = GETDLLFUNC( m_hDll, Smart70_CardFlip ); + m_pfn_CardFlip2 = GETDLLFUNC( m_hDll, Smart70_CardFlip2 ); + m_pfn_CardFlipStay = GETDLLFUNC( m_hDll, Smart70_CardFlipStay ); + m_pfn_Flip = GETDLLFUNC( m_hDll, Smart70_Flip ); + m_pfn_CardMoveSensor = GETDLLFUNC( m_hDll, Smart70_CardMoveSensor ); + m_pfn_CardMovePosition = GETDLLFUNC( m_hDll, Smart70_CardMovePosition ); + m_pfn_CardEject = GETDLLFUNC( m_hDll, Smart70_CardEject ); + m_pfn_CardEjectBin = GETDLLFUNC( m_hDll, Smart70_CardEjectBin ); + m_pfn_CardEject2 = GETDLLFUNC( m_hDll, Smart70_CardEject2 ); + m_pfn_SetEncConfig = GETDLLFUNC( m_hDll, Smart70_SetEncConfig ); + m_pfn_GetEncConfig2 = GETDLLFUNC( m_hDll, Smart70_GetEncConfig2 ); + m_pfn_SetEncConfig2 = GETDLLFUNC( m_hDll, Smart70_SetEncConfig2 ); + m_pfn_SetEncBuffer = GETDLLFUNC( m_hDll, Smart70_SetEncBuffer ); + m_pfn_WriteEncoder = GETDLLFUNC( m_hDll, Smart70_WriteEncoder ); + m_pfn_ReadEncoder = GETDLLFUNC( m_hDll, Smart70_ReadEncoder ); + m_pfn_FetchEncoder = GETDLLFUNC( m_hDll, Smart70_FetchEncoder ); + m_pfn_GetEncBuffer = GETDLLFUNC( m_hDll, Smart70_GetEncBuffer ); + m_pfn_RunEncoder = GETDLLFUNC( m_hDll, Smart70_RunEncoder ); + m_pfn_GetPrinterSettings = GETDLLFUNC( m_hDll, Smart70_GetPrinterSettings ); + m_pfn_SetPrinterSettings = GETDLLFUNC( m_hDll, Smart70_SetPrinterSettings ); + m_pfn_PrintDocument = GETDLLFUNC( m_hDll, Smart70_PrintDocument ); + m_pfn_SetJobCallback = GETDLLFUNC( m_hDll, Smart70_SetJobCallback ); + m_pfn_PrintStart = GETDLLFUNC( m_hDll, Smart70_PrintStart ); + m_pfn_GetJobInfo = GETDLLFUNC( m_hDll, Smart70_GetJobInfo ); + m_pfn_GetJobInfoEx = GETDLLFUNC( m_hDll, Smart70_GetJobInfoEx ); + + m_pfn_NewJobDescriptor = GETDLLFUNC( m_hDll, Smart70_NewJobDescriptor ); + m_pfn_FreeJobDescriptor = GETDLLFUNC( m_hDll, Smart70_FreeJobDescriptor ); + m_pfn_AddJobItem = GETDLLFUNC( m_hDll, Smart70_AddJobItem ); + m_pfn_AddJobItemMove = GETDLLFUNC( m_hDll, Smart70_AddJobItemMove ); + m_pfn_AddJobItemFlip = GETDLLFUNC( m_hDll, Smart70_AddJobItemFlip ); + m_pfn_AddJobItemMagnetic = GETDLLFUNC( m_hDll, Smart70_AddJobItemMagnetic ); + m_pfn_AddJobItemContact = GETDLLFUNC( m_hDll, Smart70_AddJobItemContact ); + m_pfn_AddJobItemContactless = GETDLLFUNC( m_hDll, Smart70_AddJobItemContactless ); + m_pfn_AddJobItemScanImage = GETDLLFUNC( m_hDll, Smart70_AddJobItemScanImage ); + m_pfn_AddJobItemScanBarcode = GETDLLFUNC( m_hDll, Smart70_AddJobItemScanBarcode ); + m_pfn_AddJobItemPrint = GETDLLFUNC( m_hDll, Smart70_AddJobItemPrint ); + m_pfn_AddJobItemLaminate = GETDLLFUNC( m_hDll, Smart70_AddJobItemLaminate ); + m_pfn_AddJobItemUser = GETDLLFUNC( m_hDll, Smart70_AddJobItemUser ); + m_pfn_InsertJob = GETDLLFUNC( m_hDll, Smart70_InsertJob ); + m_pfn_ExGetDevParam2 = GETDLLFUNC( m_hDll, Smart70_ExGetDevParam2 ); + m_pfn_ExSetDevParam2 = GETDLLFUNC( m_hDll, Smart70_ExSetDevParam2 ); + m_pfn_MagWrite = GETDLLFUNC( m_hDll, Smart70_MagWrite ); + m_pfn_MagRead = GETDLLFUNC( m_hDll, Smart70_MagRead ); + + m_pfn_LaserConnect = GETDLLFUNC( m_hDll, Smart70_LaserConnect ); + m_pfn_LaserDisconnect = GETDLLFUNC( m_hDll, Smart70_LaserDisconnect ); + m_pfn_LaserCheckPort = GETDLLFUNC( m_hDll, Smart70_LaserCheckPort ); + m_pfn_LDrawLine = GETDLLFUNC( m_hDll, Smart70_LDrawLine ); + m_pfn_LDrawRect = GETDLLFUNC( m_hDll, Smart70_LDrawRect ); + m_pfn_LDrawOval = GETDLLFUNC( m_hDll, Smart70_LDrawOval ); + m_pfn_LDrawRRect = GETDLLFUNC( m_hDll, Smart70_LDrawRRect ); + m_pfn_LDrawText = GETDLLFUNC( m_hDll, Smart70_LDrawText ); + m_pfn_LDrawBarcode = GETDLLFUNC( m_hDll, Smart70_LDrawBarcode ); + m_pfn_LDrawImage = GETDLLFUNC( m_hDll, Smart70_LDrawImage ); + m_pfn_LDrawBitmap = GETDLLFUNC( m_hDll, Smart70_LDrawBitmap ); + + + if( !m_pfn_GetDeviceList || + !m_pfn_GetDeviceList || + !m_pfn_ExGetDeviceList || + !m_pfn_GetDeviceInfo || + !m_pfn_OpenDevice || + !m_pfn_ExOpenDevice || + !m_pfn_CloseDevice || + !m_pfn_GetRibbonInfo || + !m_pfn_GetConnectedDevices || + !m_pfn_GetConnectedModules || + !m_pfn_ICHContact || + !m_pfn_ICHDiscontact || + !m_pfn_OpenDocument || + !m_pfn_CloseDocument || + !m_pfn_ClearDocument || + !m_pfn_GetFieldCount || + !m_pfn_GetFieldName || + !m_pfn_GetFieldValue || + !m_pfn_SetFieldValue || + !m_pfn_GetPrinterSettings || + !m_pfn_SetPrinterSettings || + !m_pfn_DrawImage || + !m_pfn_DrawImage2 || + !m_pfn_DrawText || + !m_pfn_DrawText2 || + !m_pfn_DrawRect || + !m_pfn_DrawBarcode || + !m_pfn_GetBarcodeTypeCount || + !m_pfn_GetBarcodeTypeName || + !m_pfn_SetICG || + !m_pfn_GetICG || + !m_pfn_GetPreviewBitmap || + !m_pfn_GetUnitInfo || + !m_pfn_GetFieldLinkedUnitInfo || + !m_pfn_SetUnitInfo || + !m_pfn_GetUnitInfo2 || + !m_pfn_GetFieldLinkedUnitInfo2 || + !m_pfn_SetUnitInfo2 || + !m_pfn_GetUnitInfo2Direct || + !m_pfn_RFPowerOn || + !m_pfn_RFPowerOff || + !m_pfn_RFTransmit || + !m_pfn_RFPowerOn2 || + !m_pfn_RFPowerOff2 || + !m_pfn_RFTransmit2 || + !m_pfn_ICPowerOn || + !m_pfn_ICPowerOff || + !m_pfn_ICTransmit || + !m_pfn_ICPowerOn2 || + !m_pfn_ICPowerOff2 || + !m_pfn_ICTransmit2 || + !m_pfn_DCLOpenDevice || + !m_pfn_DCLExOpenDevice || + !m_pfn_DCLCloseDevice || + !m_pfn_DCLPrint || + !m_pfn_ExSetConfig || + !m_pfn_ExGetConfig || + !m_pfn_RequestPreemption || + !m_pfn_ReleasePreemption || + !m_pfn_GetModuleState || + !m_pfn_UpdateModuleState || + !m_pfn_GetStatus || + !m_pfn_IsModuleReady || + !m_pfn_IsReadyInsertJob || + !m_pfn_ToggleManualMode || + !m_pfn_UpdateCurrPrintJob || + !m_pfn_GetCurrPrintJob || + !m_pfn_DeleteCurrPrintJob || + !m_pfn_CardIn || + !m_pfn_CardOut || + !m_pfn_CardMove || + !m_pfn_CardMove2 || + !m_pfn_CardListMove || + !m_pfn_CardMoveQuick || + !m_pfn_CardPass || + !m_pfn_CardFlipPass || + !m_pfn_CardFlip || + !m_pfn_CardFlip2 || + !m_pfn_CardFlipStay || + !m_pfn_Flip || + !m_pfn_CardMoveSensor || + !m_pfn_CardMovePosition || + !m_pfn_CardEject || + !m_pfn_CardEjectBin || + !m_pfn_CardEject2 || + !m_pfn_SetEncConfig || + !m_pfn_GetEncConfig2 || + !m_pfn_SetEncConfig2 || + !m_pfn_SetEncBuffer || + !m_pfn_WriteEncoder || + !m_pfn_ReadEncoder || + !m_pfn_FetchEncoder || + !m_pfn_GetEncBuffer || + !m_pfn_RunEncoder || + !m_pfn_GetPrinterSettings || + !m_pfn_SetPrinterSettings || + !m_pfn_PrintDocument || + !m_pfn_SetJobCallback || + !m_pfn_PrintStart || + !m_pfn_GetJobInfo || + !m_pfn_GetJobInfoEx || + + !m_pfn_NewJobDescriptor || + !m_pfn_FreeJobDescriptor || + !m_pfn_AddJobItem || + !m_pfn_AddJobItemMove || + !m_pfn_AddJobItemFlip || + !m_pfn_AddJobItemMagnetic || + !m_pfn_AddJobItemContact || + !m_pfn_AddJobItemContactless || + !m_pfn_AddJobItemScanImage || + !m_pfn_AddJobItemScanBarcode || + !m_pfn_AddJobItemPrint || + !m_pfn_AddJobItemLaminate || + !m_pfn_AddJobItemUser || + !m_pfn_InsertJob || + !m_pfn_ExGetDevParam2 || + !m_pfn_ExSetDevParam2 || + !m_pfn_MagWrite || + !m_pfn_MagRead || + + !m_pfn_LaserConnect || + !m_pfn_LaserDisconnect || + !m_pfn_LaserCheckPort || + !m_pfn_LDrawLine || + !m_pfn_LDrawRect || + !m_pfn_LDrawOval || + !m_pfn_LDrawRRect || + !m_pfn_LDrawText || + !m_pfn_LDrawBarcode || + !m_pfn_LDrawImage || + !m_pfn_LDrawBitmap + ) + { + Free(); + return FALSE; + } + + return TRUE; +} + +void CSMARTCommon::Free() +{ + if( m_hDll == NULL ) + return; + + if( m_hSmart != NULL ) + DCLCloseDevice(); + + FreeLibrary( m_hDll ); + m_hDll = NULL; +} + +BOOL CSMARTCommon::IsLoaded() +{ + return ( m_hDll != NULL ); +} + +BOOL CSMARTCommon::IsOpened() +{ + return ( m_hDll != NULL && m_hSmart != NULL ); +} + + + + +int CSMARTCommon::GetDeviceList(SMART70_PRINTER_LIST* pDevInfo) +{ + if( m_pfn_GetDeviceList == NULL ) + return SM_FAIL; + + return (m_nLastRes = m_pfn_GetDeviceList(pDevInfo)); +} + +int CSMARTCommon::ExGetDeviceList(SMART70_PRINTER_LIST* pDevInfo, int opt) +{ + if( m_pfn_ExGetDeviceList == NULL ) + return SM_FAIL; + + return (m_nLastRes = m_pfn_ExGetDeviceList(pDevInfo, opt)); +} + +int CSMARTCommon::GetDeviceInfo(SMART70_PRINTER_INFO* pDevInfo, WCHAR* szdev, int ndevtype) +{ + if( m_pfn_GetDeviceInfo == NULL ) + return SM_FAIL; + + return (m_nLastRes = m_pfn_GetDeviceInfo(pDevInfo, szdev, ndevtype)); +} + +int CSMARTCommon::OpenDevice(WCHAR* szdev, int ndevtype) +{ + if( m_hSmart != NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_OpenDevice(&m_hSmart, szdev, ndevtype)); +} + +int CSMARTCommon::ExOpenDevice(WCHAR* szdev, int ndevtype) +{ + if( m_hSmart != NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ExOpenDevice(&m_hSmart, szdev, ndevtype)); +} + +int CSMARTCommon::CloseDevice() +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + int ret = m_pfn_CloseDevice(m_hSmart); + + m_hSmart = NULL; + return (m_nLastRes = ret); +} + +int CSMARTCommon::GetRibbonInfo(BYTE mod, int* pnType, int* pnRemain, int* pnMax) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetRibbonInfo(m_hSmart, mod, pnType, pnRemain, pnMax)); +} + +int CSMARTCommon::GetConnectedDevices(SMART70_DEVCONNLIST* pConnList) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetConnectedDevices(m_hSmart, pConnList)); +} + +int CSMARTCommon::GetConnectedModules(SMART70_DEVCONNLIST* pConnList) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetConnectedModules(m_hSmart, pConnList)); +} + +int CSMARTCommon::ICHContact(BYTE mod) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ICHContact(m_hSmart, mod)); +} + +int CSMARTCommon::ICHDiscontact(BYTE mod) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ICHDiscontact(m_hSmart, mod)); +} + +int CSMARTCommon::OpenDocument(LPCTSTR szCSDName) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_OpenDocument(m_hSmart, szCSDName)); +} + +int CSMARTCommon::CloseDocument() +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CloseDocument(m_hSmart)); +} + +int CSMARTCommon::ClearDocument(int page) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ClearDocument(m_hSmart, page)); +} + +int CSMARTCommon::GetFieldCount(int* pnCount) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetFieldCount(m_hSmart, pnCount)); +} + +int CSMARTCommon::GetFieldName(int idx, LPTSTR szName, DWORD dwBufLen) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetFieldName(m_hSmart, idx, szName, dwBufLen)); +} + +int CSMARTCommon::GetFieldValue(LPCTSTR szName, LPTSTR szValue) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetFieldValue(m_hSmart, szName, szValue)); +} + +int CSMARTCommon::SetFieldValue(LPCTSTR szName, LPCTSTR szValue) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_SetFieldValue(m_hSmart, szName, szValue)); +} + +int CSMARTCommon::DrawImage(BYTE page, BYTE panel, int x, int y, int cx, int cy, WCHAR* szImgPath, RECT* prcArea) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_DrawImage(m_hSmart, page, panel, x, y, cx, cy, szImgPath, prcArea)); +} + +int CSMARTCommon::DrawBitmap(BYTE page, BYTE panel, int x, int y, int cx, int cy, HBITMAP hbmp, RECT* prcArea) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_DrawBitmap(m_hSmart, page, panel, x, y, cx, cy, hbmp, prcArea)); +} + +int CSMARTCommon::DrawText(BYTE page, BYTE panel, int x, int y, WCHAR* szFontName, int nFontSize, BYTE nFontStyle, WCHAR* szText, RECT* prcArea) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_DrawText(m_hSmart, page, panel, x, y, szFontName, nFontSize, nFontStyle, szText, prcArea)); +} + +int CSMARTCommon::DrawText2(BYTE page, BYTE panel, DT2INFO* pdt2info, WCHAR* szText) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_DrawText2(m_hSmart, page, panel, pdt2info, szText)); +} + +int CSMARTCommon::DrawRect(BYTE page, BYTE panel, int x, int y, int cx, int cy, COLORREF col, RECT* prcArea) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_DrawRect(m_hSmart, page, panel, x, y, cx, cy, col, prcArea)); +} + +int CSMARTCommon::DrawBarcode(BYTE page, BYTE panel, int x, int y, int cx, int cy, COLORREF col, RECT* prcArea, LPCTSTR szName, int nSize, LPCTSTR szData, LPCTSTR szPost) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_DrawBarcode(m_hSmart, page, panel, x, y, cx, cy, col, prcArea, szName, nSize, szData, szPost)); +} + +int CSMARTCommon::GetBarcodeTypeCount(int* pnCount) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetBarcodeTypeCount(m_hSmart, pnCount)); +} + +int CSMARTCommon::GetBarcodeTypeName(int idx, LPTSTR szName, int nBufLen) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetBarcodeTypeName(m_hSmart, idx, szName, nBufLen)); +} + +int CSMARTCommon::GetPreviewBitmap(BYTE page, BITMAPINFO** const ppbi) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetPreviewBitmap(m_hSmart, page, ppbi)); +} + +int CSMARTCommon::GetUnitInfo(S70UNITINFO* pUnit, int dir) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetUnitInfo(m_hSmart, pUnit, dir)); +} + +int CSMARTCommon::GetFieldLinkedUnitInfo(WCHAR* szField, S70UNITINFO* pUnit, int dir) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetFieldLinkedUnitInfo(m_hSmart, szField, pUnit, dir)); +} + +int CSMARTCommon::SetUnitInfo(S70UNITINFO* pUnit) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_SetUnitInfo(m_hSmart, pUnit)); +} + +int CSMARTCommon::GetUnitInfo2(UNITINFO2* pUnit, int dir) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetUnitInfo2(m_hSmart, pUnit, dir)); +} + +int CSMARTCommon::GetFieldLinkedUnitInfo2(WCHAR* szField, UNITINFO2* pUnit, int dir) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetFieldLinkedUnitInfo2(m_hSmart, szField, pUnit, dir)); +} + +int CSMARTCommon::SetUnitInfo2(UNITINFO2* pUnit) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_SetUnitInfo2(m_hSmart, pUnit)); +} + +int CSMARTCommon::GetUnitInfo2Direct(UNITINFO2* pUnit) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetUnitInfo2Direct(m_hSmart, pUnit)); +} + +int CSMARTCommon::GetICG(int page, int *pnICG ) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetICG( m_hSmart, page, pnICG )); +} + +int CSMARTCommon::SetICG(int page, int nICG ) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_SetICG( m_hSmart, page, nICG )); +} + + + + + +int CSMARTCommon::RFPowerOn(int nDev, int* pnCardType, DWORD* pdwOutLen, BYTE* pOutBuf) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_RFPowerOn(m_hSmart, nDev, pnCardType, pdwOutLen, pOutBuf)); +} + +int CSMARTCommon::RFPowerOff(int nDev) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_RFPowerOff(m_hSmart, nDev)); +} + +int CSMARTCommon::RFTransmit(int nDev, DWORD dwInLen, BYTE* pInBuf, DWORD* pdwOutLen, BYTE* pOutBuf) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_RFTransmit(m_hSmart, nDev, dwInLen, pInBuf, pdwOutLen, pOutBuf)); +} + +int CSMARTCommon::RFPowerOn2(BYTE mod, DWORD* pdwOutLen, BYTE* pOutBuf) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_RFPowerOn2(m_hSmart, mod, pdwOutLen, pOutBuf)); +} + +int CSMARTCommon::RFPowerOff2(BYTE mod) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_RFPowerOff2(m_hSmart, mod)); +} + +int CSMARTCommon::RFTransmit2(BYTE mod, DWORD dwInLen, BYTE* pInBuf, DWORD* pdwOutLen, BYTE* pOutBuf) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_RFTransmit2(m_hSmart, mod, dwInLen, pInBuf, pdwOutLen, pOutBuf)); +} + +int CSMARTCommon::ICPowerOn(int nDev, DWORD* pdwOutLen, BYTE* pOutBuf) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ICPowerOn(m_hSmart, nDev, pdwOutLen, pOutBuf)); +} + +int CSMARTCommon::ICPowerOff(int nDev) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ICPowerOff(m_hSmart, nDev)); +} + +int CSMARTCommon::ICTransmit(int nDev, DWORD dwInLen, BYTE* pInBuf, DWORD* pdwOutLen, BYTE* pOutBuf) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ICTransmit(m_hSmart, nDev, dwInLen, pInBuf, pdwOutLen, pOutBuf)); +} + +int CSMARTCommon::ICPowerOn2(BYTE mod, DWORD* pdwOutLen, BYTE* pOutBuf) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ICPowerOn2(m_hSmart, mod, pdwOutLen, pOutBuf)); +} + +int CSMARTCommon::ICPowerOff2(BYTE mod) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ICPowerOff2(m_hSmart, mod)); +} + +int CSMARTCommon::ICTransmit2(BYTE mod, DWORD dwInLen, BYTE* pInBuf, DWORD* pdwOutLen, BYTE* pOutBuf) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ICTransmit2(m_hSmart, mod, dwInLen, pInBuf, pdwOutLen, pOutBuf)); +} + + + + + + + +int CSMARTCommon::DCLOpenDevice(WCHAR* szdev, int ndevtype, int nOrientation) +{ + return (m_nLastRes = m_pfn_DCLOpenDevice( &m_hSmart, szdev, ndevtype, nOrientation )); +} + +int CSMARTCommon::DCLOpenDevice3(WCHAR* szDev, int port, BOOL bSSL, int nOrientation) +{ + return (m_nLastRes = m_pfn_DCLOpenDevice3( &m_hSmart, szDev, port, bSSL, nOrientation )); +} + +int CSMARTCommon::DCLExOpenDevice(WCHAR* szdev, int ndevtype, int nOrientation) +{ + return (m_nLastRes = m_pfn_DCLExOpenDevice( &m_hSmart, szdev, ndevtype, nOrientation )); +} + +int CSMARTCommon::DCLCloseDevice() +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + int nres = m_pfn_DCLCloseDevice( m_hSmart ); + m_hSmart = NULL; + return (m_nLastRes = nres); +} + +int CSMARTCommon::DCLPrint(int nPrintSide) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_DCLPrint( m_hSmart, nPrintSide )); +} + +int CSMARTCommon::ReadUserMemory(WCHAR* szPW, int addr, BYTE* btdata) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + if( m_pfn_ReadUserMemory == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ReadUserMemory( m_hSmart, szPW, addr, btdata )); +} + +int CSMARTCommon::WriteUserMemory(WCHAR* szPW, int addr, BYTE* btdata) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + if( m_pfn_WriteUserMemory == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_WriteUserMemory( m_hSmart, szPW, addr, btdata )); +} +#ifdef _WIN64 +int CSMARTCommon::ExSetConfig(int nID, __int64 nValue) +#else//_WIN64 +int CSMARTCommon::ExSetConfig(int nID, int nValue) +#endif//_WIN64 +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ExSetConfig( m_hSmart, nID, nValue )); +} + +#ifdef _WIN64 +int CSMARTCommon::ExGetConfig(int nID, __int64* pnValue) +#else//_WIN64 +int CSMARTCommon::ExGetConfig(int nID, int* pnValue) +#endif//_WIN64 +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ExGetConfig( m_hSmart, nID, pnValue )); +} + + + + + + +int CSMARTCommon::GetStatus(BYTE mod, __int64* pstatus) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetStatus( m_hSmart, mod, pstatus)); +} + +int CSMARTCommon::RequestPreemption(WORD * pwPrmt) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_RequestPreemption( m_hSmart, pwPrmt )); +} + +int CSMARTCommon::ReleasePreemption(WORD wPrmt) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ReleasePreemption( m_hSmart, wPrmt )); +} + +int CSMARTCommon::GetModuleState(BYTE mod, BYTE * pstate) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetModuleState( m_hSmart, mod, pstate )); +} + +int CSMARTCommon::UpdateModuleState(BYTE mod) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_UpdateModuleState( m_hSmart, mod )); +} + +int CSMARTCommon::IsModuleReady(BYTE mod, int *pnReady) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_IsModuleReady( m_hSmart, mod, pnReady )); +} + +int CSMARTCommon::IsReadyInsertJob(int *pnReady) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_IsReadyInsertJob( m_hSmart, pnReady )); +} + +int CSMARTCommon::ToggleManualMode() +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ToggleManualMode( m_hSmart )); +} + +int CSMARTCommon::UpdateCurrPrintJob(BYTE mod) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_UpdateCurrPrintJob( m_hSmart, mod )); +} + +int CSMARTCommon::GetCurrPrintJob(BYTE mod, WORD* pjobid) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetCurrPrintJob( m_hSmart, mod, pjobid )); +} + +int CSMARTCommon::DeleteCurrPrintJob(BYTE mod) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_DeleteCurrPrintJob( m_hSmart, mod )); +} + +int CSMARTCommon::CardIn(BYTE module, int dir, int opt) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardIn( m_hSmart, module, dir, opt )); +} + +int CSMARTCommon::CardOut(BYTE module, int dir, int opt) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardOut( m_hSmart, module, dir, opt )); +} + +int CSMARTCommon::CardMove(BYTE fromModule, BYTE toModule, int opt) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardMove( m_hSmart, fromModule, toModule, opt )); +} + +int CSMARTCommon::CardMove2(BYTE fromModule, BYTE fromOpt, BYTE toModule, BYTE toOpt, int cmdopt) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardMove2( m_hSmart, fromModule, fromOpt, toModule, toOpt, cmdopt )); +} + +int CSMARTCommon::CardListMove(CARDMOVELIST * plist) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardListMove( m_hSmart, plist )); +} + +int CSMARTCommon::CardMoveQuick(BYTE mod, BYTE opt, int cmdopt) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardMoveQuick( m_hSmart, mod, opt, cmdopt )); +} + +int CSMARTCommon::CardPass(BYTE mod, BYTE opt, int cmdopt) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardPass( m_hSmart, mod, opt, cmdopt )); +} + +int CSMARTCommon::CardFlipPass(BYTE mod, BYTE opt, int cmdopt) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardFlipPass( m_hSmart, mod, opt, cmdopt )); +} + +int CSMARTCommon::CardFlip(BYTE modfrom, BYTE modflip, BYTE modto) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardFlip( m_hSmart, modfrom, modflip, modto )); +} + +int CSMARTCommon::CardFlip2(BYTE modfrom, BYTE modflip, BYTE modto) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardFlip2( m_hSmart, modfrom, modflip, modto )); +} + +int CSMARTCommon::CardFlipStay(BYTE modfrom, BYTE modflip) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardFlipStay( m_hSmart, modfrom, modflip )); +} + +int CSMARTCommon::Flip(BYTE mod, int opt, int value) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_Flip( m_hSmart, mod, opt, value )); +} + +int CSMARTCommon::CardMoveSensor(BYTE module, int opt1, int value, int opt2) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardMoveSensor( m_hSmart, module, opt1, value, opt2 )); +} + +int CSMARTCommon::CardMovePosition(BYTE module, int pos) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardMovePosition( m_hSmart, module, pos )); +} + +int CSMARTCommon::CardEject(BYTE module) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardEject( m_hSmart, module )); +} + +int CSMARTCommon::CardEjectBin(BYTE mod, BYTE modbin) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardEjectBin( m_hSmart, mod, modbin )); +} + +int CSMARTCommon::CardEject2(BYTE mod, int opt, BYTE modout, int optout) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_CardEject2( m_hSmart, mod, opt, modout, optout )); +} + +int CSMARTCommon::SetEncConfig(BYTE module, int config, int value) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_SetEncConfig( m_hSmart, module, config, value )); +} + +int CSMARTCommon::GetEncConfig2(BYTE module, int config, void* pbuf, int* pnbuflen) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetEncConfig2( m_hSmart, module, config, pbuf, pnbuflen)); +} + +int CSMARTCommon::SetEncConfig2(BYTE module, int config, void* pbuf, int nbuflen) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_SetEncConfig2( m_hSmart, module, config, pbuf, nbuflen)); +} +int CSMARTCommon::SetEncBuffer(BYTE module, BYTE track, int nbuflen, WCHAR* szbuf) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_SetEncBuffer( m_hSmart, module, track, nbuflen, szbuf )); +} + +int CSMARTCommon::WriteEncoder(BYTE module, BYTE track, BYTE opt) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_WriteEncoder( m_hSmart, module, track, opt )); +} + +int CSMARTCommon::ReadEncoder(BYTE module, BYTE track, BYTE opt) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ReadEncoder( m_hSmart, module, track, opt )); +} + +int CSMARTCommon::FetchEncoder(BYTE module, BYTE track) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_FetchEncoder( m_hSmart, module, track )); +} + +int CSMARTCommon::GetEncBuffer(BYTE module, BYTE track, int * pnbufsize, WCHAR* szbuf) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetEncBuffer( m_hSmart, module, track, pnbufsize, szbuf )); +} + +int CSMARTCommon::RunEncoder(BYTE module, BYTE track, int run, void* pbuf, int* pbuflen) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_RunEncoder( m_hSmart, module, track, run, pbuf, pbuflen )); +} + +int CSMARTCommon::GetPrinterSettings(BYTE module, SMART70_DEVMODE* pdm) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetPrinterSettings( m_hSmart, module, pdm )); +} + +int CSMARTCommon::SetPrinterSettings(BYTE module, SMART70_DEVMODE* pdm) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_SetPrinterSettings( m_hSmart, module, pdm )); +} + +int CSMARTCommon::PrintDocument(int opt, int * reserved) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_PrintDocument( m_hSmart, opt, reserved )); +} + +int CSMARTCommon::SetJobCallback(S70CBPROC m_pfnCB) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_SetJobCallback( m_hSmart, m_pfnCB )); +} + +int CSMARTCommon::PrintStart(BYTE mod, int opt, int cmdopt) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_PrintStart( m_hSmart, mod, opt, cmdopt )); +} + +int CSMARTCommon::GetJobInfo(JOBINFO* pjobinf) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetJobInfo( m_hSmart, pjobinf )); +} + +int CSMARTCommon::GetJobInfoEx(JOBINFO_EX * pjobinf) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_GetJobInfoEx( m_hSmart, pjobinf )); +} + + + + +int CSMARTCommon::NewJobDescriptor(HJOBD * phjd, SM70CB_ERROR m_pfncbErr) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_NewJobDescriptor( m_hSmart, phjd, m_pfncbErr )); +} + +int CSMARTCommon::FreeJobDescriptor(HJOBD hjd) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_FreeJobDescriptor( m_hSmart, hjd )); +} + +int CSMARTCommon::AddJobItem(HJOBD hjd, int ji_type, void * ji_param) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_AddJobItem( m_hSmart, hjd, ji_type, ji_param )); +} + +int CSMARTCommon::AddJobItemMove(HJOBD hjd, BYTE from_mid, BYTE from_opt, BYTE to_mid, BYTE to_opt) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_AddJobItemMove( m_hSmart, hjd, from_mid, from_opt, to_mid, to_opt )); +} + +int CSMARTCommon::AddJobItemFlip(HJOBD hjd, BYTE from_mid, BYTE flip_mid, BYTE to_mid, BYTE opt) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_AddJobItemFlip( m_hSmart, hjd, from_mid, flip_mid, to_mid, opt )); +} + +int CSMARTCommon::AddJobItemMagnetic(HJOBD hjd, BYTE mid, int coer, SM70CB_MAGNETIC m_pfncb) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_AddJobItemMagnetic( m_hSmart, hjd, mid, coer, m_pfncb )); +} + +int CSMARTCommon::AddJobItemContact(HJOBD hjd, BYTE mid, SM70CB_CONTACT m_pfncb) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_AddJobItemContact( m_hSmart, hjd, mid, m_pfncb )); +} + +int CSMARTCommon::AddJobItemContactless(HJOBD hjd, BYTE mid, SM70CB_CONTACTLESS m_pfncb) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_AddJobItemContactless( m_hSmart, hjd, mid, m_pfncb )); +} + +int CSMARTCommon::AddJobItemScanImage(HJOBD hjd, BYTE mid, int dpi, int mode, int side, int opt, SM70CB_SCANIMAGE m_pfncb) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_AddJobItemScanImage( m_hSmart, hjd, mid, dpi, mode, side, opt, m_pfncb )); +} + +int CSMARTCommon::AddJobItemScanBarcode(HJOBD hjd, BYTE mid, int dpi, int mode, int side, int opt, SM70CB_SCANBARCODE m_pfncb) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_AddJobItemScanBarcode( m_hSmart, hjd, mid, dpi, mode, side, opt, m_pfncb )); +} + +int CSMARTCommon::AddJobItemPrint(HJOBD hjd, BYTE mid, int page, SM70CB_PRINT m_pfncb) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_AddJobItemPrint( m_hSmart, hjd, mid, page, m_pfncb )); +} + +int CSMARTCommon::AddJobItemLaminate(HJOBD hjd, BYTE mid, int page, SM70CB_LAMINATE m_pfncb) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_AddJobItemLaminate( m_hSmart, hjd, mid, page, m_pfncb )); +} + +int CSMARTCommon::AddJobItemUser(HJOBD hjd, BYTE mid, int opt, SM70CB_USER m_pfncb) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_AddJobItemUser( m_hSmart, hjd, mid, opt, m_pfncb )); +} + +int CSMARTCommon::InsertJob(HJOBD hjd, int * pjobid) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_InsertJob( m_hSmart, hjd, pjobid )); +} + +int CSMARTCommon::ExGetDevParam2(BYTE mod, WCHAR* pw, int slot, int* pvalue, int nParams) +{ + if( m_hSmart == NULL) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ExGetDevParam2(m_hSmart, mod, pw, slot, pvalue, nParams)); +} + +int CSMARTCommon::ExSetDevParam2(BYTE mod, WCHAR* pw, int slot, int* pvalue, int nParams) +{ + if( m_hSmart == NULL) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_ExSetDevParam2(m_hSmart, mod, pw, slot, pvalue, nParams)); +} + +int CSMARTCommon::MagWrite(BYTE mod, BOOL bT1, WCHAR* szT1, BOOL bT2, WCHAR* szT2, BOOL bT3, WCHAR* szT3, BOOL bJIS, WCHAR* szJIS) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_MagWrite( m_hSmart, mod, bT1, szT1, bT2, szT2, bT3, szT3, bJIS, szJIS )); +} + +int CSMARTCommon::MagRead(BYTE mod, BOOL bT1, WCHAR* szT1, int nT1, BOOL bT2, WCHAR* szT2, int nT2, BOOL bT3, WCHAR* szT3, int nT3, BOOL bJIS, WCHAR* szJIS, int nJIS) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + + return (m_nLastRes = m_pfn_MagRead( m_hSmart, mod, bT1, szT1, nT1, bT2, szT2, nT2, bT3, szT3, nT3, bJIS, szJIS, nJIS )); +} + + + +int CSMARTCommon::LaserConnect() +{ + return (m_nLastRes = m_pfn_LaserConnect()); +} + +int CSMARTCommon::LaserDisconnect() +{ + return (m_nLastRes = m_pfn_LaserDisconnect()); +} + +int CSMARTCommon::LaserCheckPort() +{ + return (m_nLastRes = m_pfn_LaserCheckPort()); +} + +int CSMARTCommon::LDrawLine (LLINE *pline, S70Laser *plaser, RECT* prc) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + return (m_nLastRes = m_pfn_LDrawLine( m_hSmart, pline, plaser, prc )); +} + +int CSMARTCommon::LDrawRect (LRECT *prect, S70Laser *plaser, RECT* prc) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + return (m_nLastRes = m_pfn_LDrawRect( m_hSmart, prect, plaser, prc )); +} + +int CSMARTCommon::LDrawOval (LOVAL *poval, S70Laser *plaser, RECT* prc) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + return (m_nLastRes = m_pfn_LDrawOval( m_hSmart, poval, plaser, prc )); +} + +int CSMARTCommon::LDrawRRect (LRRECT *prrc, S70Laser *plaser, RECT* prc) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + return (m_nLastRes = m_pfn_LDrawRRect( m_hSmart, prrc, plaser, prc )); +} + +int CSMARTCommon::LDrawText (LTEXT *ptext, S70Laser *plaser, RECT* prc) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + return (m_nLastRes = m_pfn_LDrawText( m_hSmart, ptext, plaser, prc )); +} + +int CSMARTCommon::LDrawBarcode (LBAR *pbar, S70Laser *plaser, RECT* prc) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + return (m_nLastRes = m_pfn_LDrawBarcode( m_hSmart, pbar, plaser, prc )); +} + +int CSMARTCommon::LDrawImage (LIMG *pimg, S70Laser *plaser, RECT* prc) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + return (m_nLastRes = m_pfn_LDrawImage( m_hSmart, pimg, plaser, prc )); +} + +int CSMARTCommon::LDrawBitmap (LBMP *pbmp, S70Laser *plaser, RECT* prc) +{ + if( m_hSmart == NULL ) + return (m_nLastRes = -1); + return (m_nLastRes = m_pfn_LDrawBitmap( m_hSmart, pbmp, plaser, prc )); +} + + + + + + + diff --git a/class/SMARTComm70.h b/class/SMARTComm70.h new file mode 100644 index 0000000..7d4cd7d --- /dev/null +++ b/class/SMARTComm70.h @@ -0,0 +1,331 @@ +#pragma once + +#include "SmartCommon.dll.h" +#include "SmartErrcodes.h" + + +class CSMARTCommon +{ +public: + CSMARTCommon(void); +public: + ~CSMARTCommon(void); + +public: + BOOL Load(LPTSTR dllFile); + void Free(); + BOOL IsLoaded(); + BOOL IsOpened(); + int GetLastResult() { return m_nLastRes; } + +public: + int GetDeviceList(SMART70_PRINTER_LIST* pDevList); + int ExGetDeviceList(SMART70_PRINTER_LIST* pDevList, int opt); + int GetDeviceInfo(SMART70_PRINTER_INFO* pDevInfo, WCHAR* szdev, int ndevtype); + int OpenDevice(WCHAR* szdev, int ndevtype); + int ExOpenDevice(WCHAR* szdev, int ndevtype); + int CloseDevice(); + + int GetStatus(BYTE mod, __int64* pstatus); + int GetRibbonInfo(BYTE mod, int* pnType, int* pnRemain, int* pnMax); + int GetConnectedDevices(SMART70_DEVCONNLIST* pConnList); + int GetConnectedModules(SMART70_DEVCONNLIST* pConnList); + int ICHContact(BYTE mod); + int ICHDiscontact(BYTE mod); + + int OpenDocument(LPCTSTR szCSDName); + int CloseDocument(); + int ClearDocument(int page); + int GetFieldCount(int* pnCount); + int GetFieldName(int idx, LPTSTR szName, DWORD dwBufLen); + int GetFieldValue(LPCTSTR szName, LPTSTR szValue); + int SetFieldValue(LPCTSTR szName, LPCTSTR szValue); + int DrawImage(BYTE page, BYTE panel, int x, int y, int cx, int cy, WCHAR* szImgPath, RECT* prcArea); + int ExDrawImage(BYTE page, BYTE panel, int x, int y, int cx, int cy, int nScaleMethod, BYTE nAlign, WCHAR* szImgPath, RECT* prcArea); + int DrawBitmap(BYTE page, BYTE panel, int x, int y, int cx, int cy, HBITMAP hbmp, RECT* prcArea); + int DrawText(BYTE page, BYTE panel, int x, int y, WCHAR* szFontName, int nFontSize, BYTE nFontStyle, WCHAR* szText, RECT* prcArea); + int DrawText2(BYTE page, BYTE panel, DT2INFO* pdt2info, WCHAR* szText); + int DrawRect(BYTE page, BYTE panel, int x, int y, int cx, int cy, COLORREF col, RECT* prcArea); + int DrawBarcode(BYTE page, BYTE panel, int x, int y, int cx, int cy, COLORREF col, RECT* prcArea, LPCTSTR szName, int nSize, LPCTSTR szData, LPCTSTR szPost); + int GetBarcodeTypeCount(int* pnCount); + int GetBarcodeTypeName(int idx, LPTSTR szName, int nBufLen); + int GetPreviewBitmap(BYTE page, BITMAPINFO** const ppbi); + int GetDocumentBitmap(BYTE page, BYTE panel, HBITMAP* phbmp); + int GetUnitInfo(S70UNITINFO* pUnit, int dir); + int GetFieldLinkedUnitInfo(WCHAR* szField, S70UNITINFO* pUnit, int dir); + int SetUnitInfo(S70UNITINFO* pUnit); + int GetUnitInfo2(UNITINFO2* pUnit, int dir); + int GetFieldLinkedUnitInfo2(WCHAR* szField, UNITINFO2* pUnit, int dir); + int SetUnitInfo2(UNITINFO2* pUnit); + int GetUnitInfo2Direct(UNITINFO2* pUnit); + int Print(); + int SetICG(int page, int nICG); + int GetICG(int page, int* pnICG); + + int RFPowerOn(int nDev, int* pnCardType, DWORD* pdwOutLen, BYTE* pOutBuf); + int RFPowerOff(int nDev); + int RFTransmit(int nDev, DWORD dwInLen, BYTE* pInBuf, DWORD* pdwOutLen, BYTE* pOutBuf); + int RFPowerOn2(BYTE mod, DWORD* pdwOutLen, BYTE* pOutBuf); + int RFPowerOff2(BYTE mod); + int RFTransmit2(BYTE mod, DWORD dwInLen, BYTE* pInBuf, DWORD* pdwOutLen, BYTE* pOutBuf); + int ICPowerOn(int nDev, DWORD* pdwOutLen, BYTE* pOutBuf); + int ICPowerOff(int nDev); + int ICTransmit(int nDev, DWORD dwInLen, BYTE* pInBuf, DWORD* pdwOutLen, BYTE* pOutBuf); + int ICPowerOn2(BYTE mod, DWORD* pdwOutLen, BYTE* pOutBuf); + int ICPowerOff2(BYTE mod); + int ICTransmit2(BYTE mod, DWORD dwInLen, BYTE* pInBuf, DWORD* pdwOutLen, BYTE* pOutBuf); + + int DCLOpenDevice(WCHAR* szdev, int ndevtype, int nOrientation); + int DCLOpenDevice3(WCHAR* szDev, int port, BOOL bSSL, int nOrientation); + int DCLExOpenDevice(WCHAR* szdev, int ndevtype, int nOrientation); + int DCLCloseDevice(); + int DCLPrint(int nPrintSide); + + + int ReadUserMemory(WCHAR* szPW, int addr, BYTE* btdata); + int WriteUserMemory(WCHAR* szPW, int addr, BYTE* btdata); + + +#ifdef _WIN64 + int ExSetConfig(int nID, __int64 nValue); + int ExGetConfig(int nID, __int64* pnValue); +#else//_WIN64 + int ExSetConfig(int nID, int nValue); + int ExGetConfig(int nID, int* pnValue); +#endif//_WIN64 + + + int RequestPreemption(WORD * pwPrmt); + int ReleasePreemption(WORD wPrmt); + int GetModuleState(BYTE mod, BYTE * pstate); + int UpdateModuleState(BYTE mod); + int IsModuleReady(BYTE mod, int* pnReadY); + int IsReadyInsertJob(int* pnReadY); + int ToggleManualMode(); + int UpdateCurrPrintJob(BYTE mod); + int GetCurrPrintJob(BYTE mod, WORD* pjobid); + int DeleteCurrPrintJob(BYTE mod); + int CardIn(BYTE module, int dir, int opt); + int CardOut(BYTE module, int dir, int opt); + int CardMove(BYTE fromModule, BYTE toModule, int opt); + int CardMove2(BYTE fromModule, BYTE fromOpt, BYTE toModule, BYTE toOpt, int cmdopt); + int CardListMove(CARDMOVELIST * plist); + int CardMoveQuick(BYTE mod, BYTE opt, int cmdopt); + int CardPass(BYTE mod, BYTE opt, int cmdopt); + int CardFlipPass(BYTE mod, BYTE opt, int cmdopt); + int CardFlip(BYTE modfrom, BYTE modflip, BYTE modto); + int CardFlip2(BYTE modfrom, BYTE modflip, BYTE modto); + int CardFlipStay(BYTE modfrom, BYTE modflip); + int Flip(BYTE mod, int opt, int value); + int CardMoveSensor(BYTE module, int opt1, int value, int opt2); + int CardMovePosition(BYTE module, int pos); + int CardEject(BYTE module); + int CardEjectBin(BYTE mod, BYTE modbin); + int CardEject2(BYTE mod, int opt, BYTE modout, int optout); + int SetEncConfig(BYTE module, int config, int value); + int SetEncConfig2(BYTE module, int config, void* pbuf, int buflen); + int GetEncConfig2(BYTE module, int config, void* pbuf, int* pbuflen); + int SetEncBuffer(BYTE module, BYTE track, int nbuflen, WCHAR* szbuf); + int WriteEncoder(BYTE module, BYTE track, BYTE opt); + int ReadEncoder(BYTE module, BYTE track, BYTE opt); + int FetchEncoder(BYTE module, BYTE track); + int GetEncBuffer(BYTE module, BYTE track, int * pnbufsize, WCHAR* szbuf); + int RunEncoder(BYTE module, BYTE track, int run, void* pbuf, int* pbuflen); + int GetPrinterSettings(BYTE module, SMART70_DEVMODE* pdm); + int SetPrinterSettings(BYTE module, SMART70_DEVMODE* pdm); + int PrintDocument(int opt, int * reserved); + int SetJobCallback(S70CBPROC pfnCB); + int PrintStart(BYTE mod, int opt, int cmdopt); + int GetJobInfo(JOBINFO* pjobinf); + int GetJobInfoEx(JOBINFO_EX* pjobinf); + + + + int NewJobDescriptor(HJOBD * phjd, SM70CB_ERROR pfncbErr); + int FreeJobDescriptor(HJOBD hjd); + int AddJobItem(HJOBD hjd, int ji_type, void * ji_param); + int AddJobItemMove(HJOBD hjd, BYTE from_mid, BYTE from_opt, BYTE to_mid, BYTE to_opt); + int AddJobItemFlip(HJOBD hjd, BYTE from_mid, BYTE flip_mid, BYTE to_mid, BYTE opt); + int AddJobItemMagnetic(HJOBD hjd, BYTE mid, int coer, SM70CB_MAGNETIC pfncb); + int AddJobItemContact(HJOBD hjd, BYTE mid, SM70CB_CONTACT pfncb); + int AddJobItemContactless(HJOBD hjd, BYTE mid, SM70CB_CONTACTLESS pfncb); + int AddJobItemScanImage(HJOBD hjd, BYTE mid, int dpi, int mode, int side, int opt, SM70CB_SCANIMAGE pfncb); + int AddJobItemScanBarcode(HJOBD hjd, BYTE mid, int dpi, int mode, int side, int opt, SM70CB_SCANBARCODE pfncb); + int AddJobItemPrint(HJOBD hjd, BYTE mid, int page, SM70CB_PRINT pfncb); + int AddJobItemLaminate(HJOBD hjd, BYTE mid, int page, SM70CB_LAMINATE pfncb); + int AddJobItemUser(HJOBD hjd, BYTE mid, int opt, SM70CB_USER pfncb); + int InsertJob(HJOBD hjd, int * pjobid); + int ExGetDevParam2(BYTE, WCHAR*, int, int*, int); + int ExSetDevParam2(BYTE, WCHAR*, int, int*, int); + + int MagWrite(BYTE mod, BOOL bT1, WCHAR* szT1, BOOL bT2, WCHAR* szT2, BOOL bT3, WCHAR* szT3, BOOL bJIS, WCHAR* szJIS); + int MagRead(BYTE mod, BOOL bT1, WCHAR* szT1, int nT1, BOOL bT2, WCHAR* szT2, int nT2, BOOL bT3, WCHAR* szT3, int nT3, BOOL bJIS, WCHAR* szJIS, int nJIS); + + // laser device manager + int LaserConnect(); + int LaserDisconnect(); + int LaserCheckPort(); + + int LDrawLine (LLINE *pline, S70Laser *plaser, RECT* prc); + int LDrawRect (LRECT *prect, S70Laser *plaser, RECT* prc); + int LDrawOval (LOVAL *poval, S70Laser *plaser, RECT* prc); + int LDrawRRect (LRRECT *prrc, S70Laser *plaser, RECT* prc); + int LDrawText (LTEXT *ptext, S70Laser *plaser, RECT* prc); + int LDrawBarcode (LBAR *pbar, S70Laser *plaser, RECT* prc); + int LDrawImage (LIMG *pimg, S70Laser *plaser, RECT* prc); + int LDrawBitmap (LBMP *pbmp, S70Laser *plaser, RECT* prc); + + +private: + HMODULE m_hDll; + HSMART70 m_hSmart; + int m_nLastRes; // return value of last command... + + + +private: + + Smart70_GetDeviceList m_pfn_GetDeviceList; + Smart70_ExGetDeviceList m_pfn_ExGetDeviceList; + Smart70_GetDeviceInfo m_pfn_GetDeviceInfo; + Smart70_OpenDevice m_pfn_OpenDevice; + Smart70_ExOpenDevice m_pfn_ExOpenDevice; + Smart70_CloseDevice m_pfn_CloseDevice; + Smart70DCL_OpenDevice m_pfn_DCLOpenDevice; + Smart70DCL_OpenDevice3 m_pfn_DCLOpenDevice3; + Smart70DCL_ExOpenDevice m_pfn_DCLExOpenDevice; + Smart70DCL_CloseDevice m_pfn_DCLCloseDevice; + Smart70DCL_Print m_pfn_DCLPrint; + Smart70_GetRibbonInfo m_pfn_GetRibbonInfo; + Smart70_GetConnectedDevices m_pfn_GetConnectedDevices; + Smart70_GetConnectedModules m_pfn_GetConnectedModules; + + Smart70_ICHContact m_pfn_ICHContact; + Smart70_ICHDiscontact m_pfn_ICHDiscontact; + + Smart70_OpenDocument m_pfn_OpenDocument; + Smart70_CloseDocument m_pfn_CloseDocument; + Smart70_ClearDocument m_pfn_ClearDocument; + Smart70_GetPrinterSettings m_pfn_GetPrinterSettings; + Smart70_SetPrinterSettings m_pfn_SetPrinterSettings; + Smart70_ReadUserMemory m_pfn_ReadUserMemory; + Smart70_WriteUserMemory m_pfn_WriteUserMemory; + Smart70_GetFieldCount m_pfn_GetFieldCount; + Smart70_GetFieldName m_pfn_GetFieldName; + Smart70_GetFieldValue m_pfn_GetFieldValue; + Smart70_SetFieldValue m_pfn_SetFieldValue; + Smart70_DrawImage m_pfn_DrawImage; + Smart70_ExDrawImage m_pfn_DrawImage2; + Smart70_DrawBitmap m_pfn_DrawBitmap; + Smart70_DrawText m_pfn_DrawText; + Smart70_DrawText2 m_pfn_DrawText2; + Smart70_DrawRect m_pfn_DrawRect; + Smart70_DrawBarcode m_pfn_DrawBarcode; + Smart70_GetBarcodeTypeCount m_pfn_GetBarcodeTypeCount; + Smart70_GetBarcodeTypeName m_pfn_GetBarcodeTypeName; + Smart70_SetICG m_pfn_SetICG; + Smart70_GetICG m_pfn_GetICG; + + Smart70_GetPreviewBitmap m_pfn_GetPreviewBitmap; + Smart70_GetUnitInfo m_pfn_GetUnitInfo; + Smart70_GetFieldLinkedUnitInfo m_pfn_GetFieldLinkedUnitInfo; + Smart70_SetUnitInfo m_pfn_SetUnitInfo; + Smart70_GetUnitInfo2 m_pfn_GetUnitInfo2; + Smart70_GetFieldLinkedUnitInfo2 m_pfn_GetFieldLinkedUnitInfo2; + Smart70_SetUnitInfo2 m_pfn_SetUnitInfo2; + Smart70_GetUnitInfo2Direct m_pfn_GetUnitInfo2Direct; + + Smart70_GetCountParam m_pfn_GetCountParam; + Smart70_GetCountParamEx m_pfn_GetCountParamEx; + Smart70_GetDisplayInfo m_pfn_GetDisplayInfo; + Smart70_GetSystemInfo m_pfn_GetSystemInfo; + + Smart70_RFPowerOn m_pfn_RFPowerOn; + Smart70_RFPowerOff m_pfn_RFPowerOff; + Smart70_RFTransmit m_pfn_RFTransmit; + Smart70_RFPowerOn2 m_pfn_RFPowerOn2; + Smart70_RFPowerOff2 m_pfn_RFPowerOff2; + Smart70_RFTransmit2 m_pfn_RFTransmit2; + Smart70_ICPowerOn m_pfn_ICPowerOn; + Smart70_ICPowerOff m_pfn_ICPowerOff; + Smart70_ICTransmit m_pfn_ICTransmit; + Smart70_ICPowerOn2 m_pfn_ICPowerOn2; + Smart70_ICPowerOff2 m_pfn_ICPowerOff2; + Smart70_ICTransmit2 m_pfn_ICTransmit2; + + Smart70_ExSetConfig m_pfn_ExSetConfig; + Smart70_ExGetConfig m_pfn_ExGetConfig; + + Smart70_RequestPreemption m_pfn_RequestPreemption; + Smart70_ReleasePreemption m_pfn_ReleasePreemption; + Smart70_GetModuleState m_pfn_GetModuleState; + Smart70_UpdateModuleState m_pfn_UpdateModuleState; + Smart70_GetStatus m_pfn_GetStatus; + Smart70_IsModuleReady m_pfn_IsModuleReady; + Smart70_IsReadyInsertJob m_pfn_IsReadyInsertJob; + Smart70_ToggleManualMode m_pfn_ToggleManualMode; + Smart70_UpdateCurrPrintJob m_pfn_UpdateCurrPrintJob; + Smart70_GetCurrPrintJob m_pfn_GetCurrPrintJob; + Smart70_DeleteCurrPrintJob m_pfn_DeleteCurrPrintJob; + Smart70_CardIn m_pfn_CardIn; + Smart70_CardOut m_pfn_CardOut; + Smart70_CardMove m_pfn_CardMove; + Smart70_CardMove2 m_pfn_CardMove2; + Smart70_CardListMove m_pfn_CardListMove; + Smart70_CardMoveQuick m_pfn_CardMoveQuick; + Smart70_CardPass m_pfn_CardPass; + Smart70_CardFlipPass m_pfn_CardFlipPass; + Smart70_CardFlip m_pfn_CardFlip; + Smart70_CardFlip2 m_pfn_CardFlip2; + Smart70_CardFlipStay m_pfn_CardFlipStay; + Smart70_Flip m_pfn_Flip; + Smart70_CardMoveSensor m_pfn_CardMoveSensor; + Smart70_CardMovePosition m_pfn_CardMovePosition; + Smart70_CardEject m_pfn_CardEject; + Smart70_CardEjectBin m_pfn_CardEjectBin; + Smart70_CardEject2 m_pfn_CardEject2; + Smart70_SetEncConfig m_pfn_SetEncConfig; + Smart70_GetEncConfig2 m_pfn_GetEncConfig2; + Smart70_SetEncConfig2 m_pfn_SetEncConfig2; + Smart70_SetEncBuffer m_pfn_SetEncBuffer; + Smart70_WriteEncoder m_pfn_WriteEncoder; + Smart70_ReadEncoder m_pfn_ReadEncoder; + Smart70_FetchEncoder m_pfn_FetchEncoder; + Smart70_GetEncBuffer m_pfn_GetEncBuffer; + Smart70_RunEncoder m_pfn_RunEncoder; + Smart70_PrintDocument m_pfn_PrintDocument; + Smart70_SetJobCallback m_pfn_SetJobCallback; + Smart70_PrintStart m_pfn_PrintStart; + Smart70_GetJobInfo m_pfn_GetJobInfo; + Smart70_GetJobInfoEx m_pfn_GetJobInfoEx; + Smart70_NewJobDescriptor m_pfn_NewJobDescriptor; + Smart70_FreeJobDescriptor m_pfn_FreeJobDescriptor; + Smart70_AddJobItem m_pfn_AddJobItem; + Smart70_AddJobItemMove m_pfn_AddJobItemMove; + Smart70_AddJobItemFlip m_pfn_AddJobItemFlip; + Smart70_AddJobItemMagnetic m_pfn_AddJobItemMagnetic; + Smart70_AddJobItemContact m_pfn_AddJobItemContact; + Smart70_AddJobItemContactless m_pfn_AddJobItemContactless; + Smart70_AddJobItemScanImage m_pfn_AddJobItemScanImage; + Smart70_AddJobItemScanBarcode m_pfn_AddJobItemScanBarcode; + Smart70_AddJobItemPrint m_pfn_AddJobItemPrint; + Smart70_AddJobItemLaminate m_pfn_AddJobItemLaminate; + Smart70_AddJobItemUser m_pfn_AddJobItemUser; + Smart70_InsertJob m_pfn_InsertJob; + Smart70_ExGetDevParam2 m_pfn_ExGetDevParam2; + Smart70_ExSetDevParam2 m_pfn_ExSetDevParam2; + Smart70_MagWrite m_pfn_MagWrite; + Smart70_MagRead m_pfn_MagRead; + Smart70_LaserConnect m_pfn_LaserConnect; + Smart70_LaserDisconnect m_pfn_LaserDisconnect; + Smart70_LaserCheckPort m_pfn_LaserCheckPort; + Smart70_LDrawLine m_pfn_LDrawLine; + Smart70_LDrawRect m_pfn_LDrawRect; + Smart70_LDrawOval m_pfn_LDrawOval; + Smart70_LDrawRRect m_pfn_LDrawRRect; + Smart70_LDrawText m_pfn_LDrawText; + Smart70_LDrawBarcode m_pfn_LDrawBarcode; + Smart70_LDrawImage m_pfn_LDrawImage; + Smart70_LDrawBitmap m_pfn_LDrawBitmap; + +}; diff --git a/class/SmartCommon.dll.h b/class/SmartCommon.dll.h new file mode 100644 index 0000000..22b5f64 --- /dev/null +++ b/class/SmartCommon.dll.h @@ -0,0 +1,2177 @@ +#pragma once + +/* + * Device List Option + */ +#define SMART70_DEVICELIST_USB 0x01 +#define SMART70_DEVICELIST_NET 0x02 +#define SMART70_DEVICELIST_ALL (SMART70_DEVICELIST_USB | SMART70_DEVICELIST_NET) + + +/* + * Device Name + */ +#define SMART70_OPENDEVICE_BYID 0 +#define SMART70_OPENDEVICE_BYDESC 1 + + +/* + * Page / Panel + */ +#define PAGE_P1FRONT 0 +#define PAGE_P1BACK 1 +#define PAGE_P2FRONT 2 +#define PAGE_P2BACK 3 +#define PAGE_MAX 4 +#define PANEL_COLOR 1 +#define PANEL_BLACK 2 +#define PANEL_OVERLAY 4 +#define PANEL_UV 8 + + +/* + * Contactless-PCSC : Auth Side + */ +#define PCSC_MIFARE_AUTH1A 0x60 // authentication with Mifare key A +#define PCSC_MIFARE_AUTH1B 0x61 // authentication with Mifare key B + +/* + * Contactless-DUALi : Mifare Side + */ +#define DUALI_MIFARE_SIDEA 0x00 // Mifare key A on DUALi +#define DUALI_MIFARE_SIDEB 0x04 // Mifare key B on DUALi + + +/* + * Device + */ +#define INTERNALDEV 1 // internal device (IC, RF) +#define EXTERNALDEV 2 // external device (SIM, RF) + + + +/* + * Simple State Code Definition. + */ + +// Action Result +#define SS_ACT_SUCCESS 0x00 +#define SS_ACT_FAIL 0x01 +#define SS_ACT_RESULT 0x01 // mask + +// Action State +#define SS_ACT_IDLE 0x00 +#define SS_ACT_RUN 0x02 +#define SS_ACT_STATE 0x02 // mask + +// Card State +#define SS_CARD_ABSENT 0x00 +#define SS_CARD_EXIST 0x04 +#define SS_CARD_STATE 0x04 // mask + +#define SS_INIT 0x08 + +// Command State +#define SS_CMD_IDLE 0x00 +#define SS_CMD_RUN 0x10 +#define SS_CMD_STATE 0x10 // mask + +// Command Result +#define SS_CMD_SUCCESS 0x00 +#define SS_CMD_FAIL 0x20 +#define SS_CMD_RESULT 0x20 // mask + + + +/* + * SMART Printer Status Code Definition. + */ + +// SMART-70 PRINTER STATUS + +#define S7PS_M_SBSRUNNING 0x0000000000000001 // SBS(Step by Step) 명령 수행 중 +#define S7PS_M_CARDMOVE 0x0000000000000002 // 인쇄위치 이동 중 +#define S7PS_M_CARDIN 0x0000000000000004 // 카드 흡입 중 +#define S7PS_M_CARDOUT 0x0000000000000008 // 카드 배출 중 +#define S7PS_M_THEAD 0x0000000000000010 // 써멀 헤드 업/다운 중 +#define S7PS_M_SEEKRIBBON 0x0000000000000020 // 리본 찾는 중 +#define S7PS_M_MOVERIBBON 0x0000000000000040 // 리본 이동 중 +#define S7PS_M_PRINT 0x0000000000000080 // 인쇄 중 +#define S7PS_M_MAGRW 0x0000000000000100 // 마그네틱 읽기/쓰기 중 +#define S7PS_M_RECVPRINTDATA 0x0000000000000200 // 인쇄 버퍼 받는 중 +#define S7PS_M_INIT 0x0000000000000400 // 장치 초기화 중 +#define S7PS_S_READY 0x0000000000000800 // 대기상태 +#define S7PS_S_INSTALLINTENCODER 0x0000000000008000 // 내부 인코더 장착 +#define S7PS_S_INSTALLEXTHOPPER 0x0000000000010000 // 외부 호퍼 장착 +#define S7PS_S_INSTALLEXTSTACKER 0x0000000000020000 // 외부 스태커 장착 +#define S7PS_S_INSTALLEXTENCODER 0x0000000000040000 // 외부 인코더 장착 +#define S7PS_S_INSTALLEXTLAMINATOR 0x0000000000080000 // 외부 라미네이터 장착 +#define S7PS_S_INSTALLEXTFLIPPER 0x0000000000100000 // 외부 플리퍼 장착 +#define S7PS_S_INSTALLEXTETC 0x0000000000200000 // 외부 기타장치 장착 +#define S7PS_S_CASEOPEN 0x0000000000400000 // 케이스 열림 상태 +#define S7PS_S_SOFTLOCKED 0x0000000000800000 // 소프트 락 상태 +#define S7PS_S_KEYLOCKED 0x0000000001000000 // 키 락 상태 +#define S7PS_S_DETECTCARD 0x0000000002000000 // 내부 센서에 카드 감지 (In/Center/Out Sensor) +#define S7PS_S_DETECTFRONTDEVICE 0x0000000004000000 // 전방 장치(Front Device) 연결되어있음 +#define S7PS_S_DETECTREARDEVICE 0x0000000008000000 // 후방 장치(Rear Device) 연결되어있음 +#define S7PS_S_CLEANWARNING 0x0000000010000000 // 프린터 클리닝 경고 +#define S7PS_S_HAVEPRINTDATA 0x0000000020000000 // 인쇄 데이터 버퍼 보유 중 +#define S7PS_S_SBSMODE 0x0000000040000000 // SBS(Step by Step) 모드 상태 +#define S7PS_S_TESTMODE 0x0000000080000000 // 테스트모드 상태 + +#define S7PS_M_MASK (S7PS_M_SBSRUNNING|S7PS_M_CARDMOVE|S7PS_M_CARDIN|S7PS_M_CARDOUT|S7PS_M_THEAD|S7PS_M_SEEKRIBBON|S7PS_M_MOVERIBBON|S7PS_M_PRINT|S7PS_M_MAGRW|S7PS_M_INIT) +#define S7PS_S_MASK (S7PS_S_INSTALLINTENCODER|S7PS_S_INSTALLEXTHOPPER|S7PS_S_INSTALLEXTSTACKER|S7PS_S_INSTALLEXTENCODER|S7PS_S_INSTALLEXTLAMINATOR|S7PS_S_INSTALLEXTFLIPPER|S7PS_S_INSTALLEXTETC|S7PS_S_CASEOPEN|S7PS_S_SOFTLOCKED|S7PS_S_KEYLOCKED|S7PS_S_DETECTCARD|S7PS_S_DETECTFRONTDEVICE|S7PS_S_DETECTREARDEVICE|S7PS_S_CLEANWARNING|S7PS_S_HAVEPRINTDATA|S7PS_S_SBSMODE|S7PS_S_TESTMODE) + + +#define S7PS_E_CARDIN 0x0000000100000000 // 카드-인 에러 +#define S7PS_E_CARDMOVE 0x0000000200000000 // 카드 이동 에러 +#define S7PS_E_CARDOUT 0x0000000400000000 // 카드 배출 에러 +#define S7PS_E_THEADLIFT 0x0000000800000000 // 써멀 헤드 업/다운 에러 // S7PS_E_THEAD +#define S7PS_E_PRINT 0x0000004000000000 // 인쇄 중 에러 +#define S7PS_E_MAGRW 0x0000008000000000 // (내부) 마그네틱 트랙 읽기/쓰기 에러 +#define S7PS_E_MAGREADT1 0x0000010000000000 // (내부) 마그네틱 트랙 1 읽기 에러 +#define S7PS_E_MAGREADT2 0x0000020000000000 // (내부) 마그네틱 트랙 2 읽기 에러 +#define S7PS_E_MAGREADT3 0x0000040000000000 // (내부) 마그네틱 트랙 3 읽기 에러 +#define S7PS_E_CONNECTEXTHOPPER 0x0000080000000000 // 외부 호퍼 연결 에러 +#define S7PS_E_CONNECTEXTSTACKER 0x0000100000000000 // 외부 스태커 연결 에러 +#define S7PS_E_CONNECTEXTENCODER 0x0000200000000000 // 외부 인코더 연결 에러 +#define S7PS_E_CONNECTEXTLAMINATOR 0x0000400000000000 // 외부 라미네이터 연결 에러 +#define S7PS_E_CONNECTEXTFLIPPER 0x0000800000000000 // 외부 플리퍼 연결 에러 +#define S7PS_E_CONNECTEXTETC 0x0001000000000000 // 외부 기타장치 연결 에러 +#define S7PS_E_EXTPRESETMATCH 0x0002000000000000 // 외부 프리셋 장치 연결 에러 +#define S7PS_E_SCHEDULER 0x0020000000000000 // 스케쥴러 수행 에러 +#define S7PS_E_RIBBONEMPTY 0x0040000000000000 // 리본 잔량 0 +#define S7PS_E_RIBBONSEEK 0x0080000000000000 // 리본 서치 에러 +#define S7PS_E_RIBBONMOVE 0x0100000000000000 // 리본 이동 에러 +#define S7PS_F_THEADABSENT 0x0200000000000000 // 인쇄 헤드 미장착 +#define S7PS_F_THEADOVERHEAT 0x0400000000000000 // 인쇄 헤드 과열 +#define S7PS_F_RIBBONABSENT 0x0800000000000000 // 리본 없음 +#define S7PS_F_PRINTDATA 0x1000000000000000 // 인쇄 데이터 오류 +#define S7PS_F_INCORRECTPASSWORRD 0x2000000000000000 // 패스워드 틀림 +#define S7PS_F_CONFIG 0x4000000000000000 // 설정 실패 + +#define S7PS_E_MASK (S7PS_E_CARDIN|S7PS_E_CARDMOVE|S7PS_E_CARDOUT|S7PS_E_THEADLIFT|S7PS_E_PRINT|S7PS_E_MAGRW|S7PS_E_MAGREADT1|S7PS_E_MAGREADT2|S7PS_E_MAGREADT3|S7PS_E_CONNECTEXTHOPPER|S7PS_E_CONNECTEXTSTACKER|S7PS_E_CONNECTEXTENCODER|S7PS_E_CONNECTEXTLAMINATOR|S7PS_E_CONNECTEXTFLIPPER|S7PS_E_CONNECTEXTETC|S7PS_E_EXTPRESETMATCH|S7PS_E_RIBBONSEEK|S7PS_E_RIBBONMOVE) +#define S7PS_F_MASK (S7PS_F_THEADABSENT|S7PS_F_THEADOVERHEAT|S7PS_F_RIBBONABSENT|S7PS_F_PRINTDATA|S7PS_F_INCORRECTPASSWORRD|S7PS_F_CONFIG) + + + + +// SMART-70 INPUT-HOPPER (HOPPER) STATUS + +#define S7IS_M_CARDOUT 0x0000000000000002 // 카드 배출 중 +#define S7IS_S_READY 0x0000000000010000 // 대기상태 +#define S7IS_M_PROCESSING 0x0000000000020000 // 명령 수행 중 +#define S7IS_S_CATRIDGENEAREMPTY 0x0000000002000000 // 카드리지 거의 비어있음 (카드 얼마 없음) +#define S7IS_S_CATRIDGEEMPTY 0x0000000004000000 // 카드리지 비어있음 (카드 없음) +#define S7IS_S_CATRIDGELOCK 0x0000000008000000 // 카드리지 락 센서 감지 +#define S7IS_S_CATRIDGECONTACT 0x0000000010000000 // 카드리지 컨택 센서 감지 +#define S7IS_S_CARDOUT 0x0000000020000000 // 카드 아웃 센서 감지 +#define S7IS_S_REARHOOK 0x0000000040000000 // 후방 훅(Hook) 감지 +#define S7IS_S_FRONTHOOK 0x0000000080000000 // 전방 훅(Hook) 감지 + +#define S7IS_M_MASK (S7IS_M_CARDOUT|S7IS_M_PROCESSING) +#define S7IS_S_MASK (S7IS_S_READY|S7IS_S_CATRIDGENEAREMPTY|S7IS_S_CATRIDGEEMPTY|S7IS_S_CATRIDGELOCK|S7IS_S_CATRIDGECONTACT|S7IS_S_CARDOUT|S7IS_S_REARHOOK|S7IS_S_FRONTHOOK) + + +#define S7IS_E_CARDOUT 0x0000000200000000 // 카드 배출 에러 +#define S7IS_F_INIT 0x0001000000000000 // 초기화 에러 + +#define S7IS_E_MASK (S7IS_E_CARDOUT) +#define S7IS_F_MASK (S7IS_F_INIT) + + + + +// SMART-70 MULTI-HOPPER STATUS + +#define S7MS_M_INIT 0x0000000000000001 // 초기화 중 +#define S7MS_M_CARDOUT 0x0000000000000002 // 카드 배출 중 +#define S7MS_S_READY 0x0000000000000004 // 대기상태 +#define S7MS_M_PROCESSING 0x0000000000000008 // 명령 수행 중 +#define S7MS_S_HOPPER1CONNECT 0x0000000000000010 // 1번 호퍼 연결 감지 +#define S7MS_S_HOPPER2CONNECT 0x0000000000000020 // 2번 호퍼 연결 감지 +#define S7MS_S_HOPPER3CONNECT 0x0000000000000040 // 3번 호퍼 연결 감지 +#define S7MS_S_HOPPER4CONNECT 0x0000000000000080 // 4번 호퍼 연결 감지 +#define S7MS_S_HOPPER5CONNECT 0x0000000000000100 // 5번 호퍼 연결 감지 +#define S7MS_S_HOPPER6CONNECT 0x0000000000000200 // 6번 호퍼 연결 감지 +#define S7MS_M_HOPPER1RUN 0x0000000000000400 // 1번 호퍼 동작 중 +#define S7MS_M_HOPPER2RUN 0x0000000000000800 // 2번 호퍼 동작 중 +#define S7MS_M_HOPPER3RUN 0x0000000000001000 // 3번 호퍼 동작 중 +#define S7MS_M_HOPPER4RUN 0x0000000000002000 // 4번 호퍼 동작 중 +#define S7MS_M_HOPPER5RUN 0x0000000000004000 // 5번 호퍼 동작 중 +#define S7MS_M_HOPPER6RUN 0x0000000000008000 // 6번 호퍼 동작 중 +#define S7MS_S_LEFTLSENSOR 0x0000000000040000 // 왼편 리밋 센서 +#define S7MS_S_RIGHTLSENSOR 0x0000000000080000 // 오른편 리밋 센서 +#define S7MS_S_SPSENSORA 0x0000000000100000 // 쉬프터 포지션 센서 A +#define S7MS_S_SPSENSORB 0x0000000000200000 // 쉬프터 포지션 센서 B +#define S7MS_S_SPSENSORC 0x0000000000400000 // 쉬프터 포지션 센서 C +#define S7MS_S_SPSENSORD 0x0000000000800000 // 쉬프터 포지션 센서 D +#define S7MS_S_CISENSORA0 0x0000000001000000 // 카드 인 센서 A0 +#define S7MS_S_CISENSORA1 0x0000000002000000 // 카드 인 센서 A1 +#define S7MS_S_CISENSORB0 0x0000000004000000 // 카드 인 센서 B0 +#define S7MS_S_CISENSORB1 0x0000000008000000 // 카드 인 센서 B1 +#define S7MS_S_CISENSORC0 0x0000000010000000 // 카드 인 센서 C0 +#define S7MS_S_CISENSORC1 0x0000000020000000 // 카드 인 센서 C1 +#define S7MS_S_CISENSORD0 0x0000000040000000 // 카드 인 센서 D0 +#define S7MS_S_CISENSORD1 0x0000000080000000 // 카드 인 센서 D1 + +#define S7MS_M_MASK (S7MS_M_INIT|S7MS_M_CARDOUT|S7MS_M_PROCESSING|S7MS_M_HOPPER1RUN|S7MS_M_HOPPER2RUN|S7MS_M_HOPPER3RUN|S7MS_M_HOPPER4RUN|S7MS_M_HOPPER5RUN|S7MS_M_HOPPER6RUN) +#define S7MS_S_MASK (S7MS_S_READY|S7MS_S_HOPPER1CONNECT|S7MS_S_HOPPER2CONNECT|S7MS_S_HOPPER3CONNECT|S7MS_S_HOPPER4CONNECT|S7MS_S_HOPPER5CONNECT|S7MS_S_HOPPER6CONNECT|S7MS_S_LEFTLSENSOR|S7MS_S_RIGHTLSENSOR|S7MS_S_SPSENSORA|S7MS_S_SPSENSORB|S7MS_S_SPSENSORC|S7MS_S_SPSENSORD|S7MS_S_CISENSORA0|S7MS_S_CISENSORA1|S7MS_S_CISENSORB0|S7MS_S_CISENSORB1|S7MS_S_CISENSORC0|S7MS_S_CISENSORC1|S7MS_S_CISENSORD0|S7MS_S_CISENSORD1) + + +#define S7MS_F_INIT 0x0000000100000000 // 초기화 실패 +#define S7MS_E_CARDOUT 0x0000000200000000 // 카드 배출 에러 +#define S7MS_E_RUN 0x0000000800000000 // 명령 수행 에러 +#define S7MS_E_HOPPER1CONTROL 0x0000001000000000 // 호퍼 1 컨트롤 에러 +#define S7MS_E_HOPPER2CONTROL 0x0000002000000000 // 호퍼 2 컨트롤 에러 +#define S7MS_E_HOPPER3CONTROL 0x0000004000000000 // 호퍼 3 컨트롤 에러 +#define S7MS_E_HOPPER4CONTROL 0x0000008000000000 // 호퍼 4 컨트롤 에러 +#define S7MS_E_HOPPER5CONTROL 0x0000010000000000 // 호퍼 5 컨트롤 에러 +#define S7MS_E_HOPPER6CONTROL 0x0000020000000000 // 호퍼 6 컨트롤 에러 +#define S7MS_E_HOPPER1EMPTY 0x0000040000000000 // 호퍼 1 카드 없음 +#define S7MS_E_HOPPER2EMPTY 0x0000080000000000 // 호퍼 2 카드 없음 +#define S7MS_E_HOPPER3EMPTY 0x0000100000000000 // 호퍼 3 카드 없음 +#define S7MS_E_HOPPER4EMPTY 0x0000200000000000 // 호퍼 4 카드 없음 +#define S7MS_E_HOPPER5EMPTY 0x0000400000000000 // 호퍼 5 카드 없음 +#define S7MS_E_HOPPER6EMPTY 0x0000800000000000 // 호퍼 6 카드 없음 +#define S7MS_E_HOPPER1 0x0001000000000000 // 호퍼 1 에러 +#define S7MS_E_HOPPER2 0x0002000000000000 // 호퍼 2 에러 +#define S7MS_E_HOPPER3 0x0004000000000000 // 호퍼 3 에러 +#define S7MS_E_HOPPER4 0x0008000000000000 // 호퍼 4 에러 +#define S7MS_E_HOPPER5 0x0010000000000000 // 호퍼 5 에러 +#define S7MS_E_HOPPER6 0x0020000000000000 // 호퍼 6 에러 + +#define S7MS_E_MASK (S7MS_E_CARDOUT|S7MS_E_RUN|S7MS_E_HOPPER1CONTROL|S7MS_E_HOPPER2CONTROL|S7MS_E_HOPPER3CONTROL|S7MS_E_HOPPER4CONTROL|S7MS_E_HOPPER5CONTROL|S7MS_E_HOPPER6CONTROL|/*S7MS_E_HOPPER1EMPTY|S7MS_E_HOPPER2EMPTY|S7MS_E_HOPPER3EMPTY|S7MS_E_HOPPER4EMPTY|S7MS_E_HOPPER5EMPTY|S7MS_E_HOPPER6EMPTY|*/S7MS_E_HOPPER1|S7MS_E_HOPPER2|S7MS_E_HOPPER3|S7MS_E_HOPPER4|S7MS_E_HOPPER5|S7MS_E_HOPPER6) +#define S7MS_F_MASK (S7MS_F_INIT) + + + + +// SMART-70 OUTPUT-HOPPER (STACKER) STATUS + +#define S7OS_M_CARDIN 0x0000000000000001 // 카드-인 중 +#define S7OS_M_LIFTUP 0x0000000000000004 // 리프트-업 동작중 +#define S7OS_M_LIFTDOWN 0x0000000000000008 // 리프트-다운 동작중 +#define S7OS_S_READY 0x0000000000010000 // 대기상태 +#define S7OS_M_PROCESSING 0x0000000000020000 // 명령 수행 중 +#define S7OS_S_CARDSTANDBY 0x0000000002000000 // 카드 대기센서 감지 +#define S7OS_S_CATRIDGEHAVESPACE 0x0000000004000000 // 카드리지 공간 여유 있음 +#define S7OS_S_CATRIDGELOCK 0x0000000008000000 // 카드리지 락 센서 감지 +#define S7OS_S_CATRIDGECONTACT 0x0000000010000000 // 카드리지 컨택 센서 감지 안됨 +#define S7OS_S_CARDINENABLER 0x0000000020000000 // 카드 인 가능 센서 감지 +#define S7OS_S_LIFTUP 0x0000000040000000 // 리프트 업 상태 +#define S7OS_S_DETECTCARDIN 0x0000000080000000 // 카드인 센서에 카드 감지 + +#define S7OS_M_MASK (S7OS_M_CARDIN|S7OS_M_LIFTUP|S7OS_M_LIFTDOWN|S7OS_M_PROCESSING) +#define S7OS_S_MASK (S7OS_S_READY|S7OS_M_PROCESSING|S7OS_S_CARDSTANDBY|S7OS_S_CATRIDGEHAVESPACE|S7OS_S_CATRIDGELOCK|S7OS_S_CATRIDGECONTACT|S7OS_S_CARDINENABLER|S7OS_S_LIFTUP|S7OS_S_DETECTCARDIN) + + +#define S7OS_E_CARDIN 0x0000000100000000 // 카드-인 에러 +#define S7OS_E_LIFTUP 0x0000000400000000 // 리프트-업 에러 +#define S7OS_E_LIFTDOWN 0x0000000800000000 // 리프트-다운 에러 +#define S7OS_F_INIT 0x0001000000000000 // 초기화 에러 + +#define S7OS_E_MASK (S7OS_E_CARDIN|S7OS_E_LIFTUP|S7OS_E_LIFTDOWN) +#define S7OS_F_MASK (S7OS_F_INIT) + + + + +// SMART-70 FLIPPER STATUS + +#define S7FS_M_CARDIN 0x0000000000000001 // 카드-인 중 +#define S7FS_M_CARDOUT 0x0000000000000002 // 카드 배출 중 +#define S7FS_M_FLIPPING 0x0000000000000004 // 플리핑 중 +#define S7FS_M_CARDMOVE 0x0000000000000008 // 카드 이동 중 +#define S7FS_S_SMARTREADERDOWN 0x0000000000000010 // IC 리더 다운 상태. (Board Ver.2 에서 사용) +#define S7FS_S_SMARTREADERUP 0x0000000000000020 // IC 리더 업 상태. (Board Ver.2 에서 사용) +#define S7FS_S_EXTBOARDABSENT 0x0000000000000100 // 확장보드 연결 안되어있음. (Board Ver.2 에서 사용) +#define S7FS_S_DETECTCARDSCANIN 0x0000000000000200 // 스캔모듈 카드 인(하단) 센서 카드감지. (Board Ver.2 에서 사용) +#define S7FS_S_DETECTCARDSCANOUT 0x0000000000000400 // 스캔모듈 카드 아웃(상단) 센서 카드감지. (Board Ver.2 에서 사용) +#define S7FS_S_SMARTREADERCAMSENSOR 0x0000000000000800 // IC 리더 캠 센서. (Board Ver.2 에서 사용) +#define S7FS_S_NOTINSTALLSCANMOD 0x0000000000001000 // 스캔모듈 연결 안되어있음. (Board Ver.2 에서 사용) +#define S7FS_S_READY 0x0000000000010000 // 대기상태 +#define S7FS_M_PROCESSING 0x0000000000020000 // 명령 수행 중 +#define S7FS_S_V2BOARD 0x0000000000200000 // 보드 Ver. 2 +#define S7FS_S_FLIPPERBOTTOM 0x0000000000400000 // 플리퍼 하향 상태 +#define S7FS_S_FLIPPERTOP 0x0000000000800000 // 플리퍼 상향 상태 +#define S7FS_S_CATRIDGELOCK 0x0000000001000000 // 카트리지 락 센서 +#define S7FS_S_CASEOPENSENSOR 0x0000000002000000 // 케이스 열림 감지 센서. (Board Ver.2 에서 사용) +#define S7FS_S_CATRIDGEFULLSENSOR 0x0000000004000000 // 카트리지 꽉 참 센서 +#define S7FS_S_PCSVERTICALSENSOR 0x0000000008000000 // 수직 플리퍼 위치 제어 센서 +#define S7FS_S_PCSHORIZONTALSENSOR 0x0000000010000000 // 수평 플리퍼 위치 제어 센서 +#define S7FS_S_DETECTCARDRIGHT 0x0000000020000000 // 우측 센서 카드감지 +#define S7FS_S_DETECTCARDCENTER 0x0000000040000000 // 중앙 센서 카드감지 +#define S7FS_S_DETECTCARDLEFT 0x0000000080000000 // 좌측 센서 카드감지 + +#define S7FS_M_MASK (S7FS_M_CARDIN|S7FS_M_CARDOUT|S7FS_M_FLIPPING|S7FS_M_PROCESSING) +#define S7FS_S_MASK (S7FS_S_READY|S7FS_S_CATRIDGELOCK|S7FS_S_CASEOPEN|S7FS_S_CATRIDGEFULL|S7FS_S_PCSVERTICAL|S7FS_S_PCSHORIZONTAL|S7FS_S_DETECTCARDRIGHT|S7FS_S_DETECTCARDCENTER|S7FS_S_DETECTCARDLEFT) +#define S7FS_WA_V2BOARDONLY (S7FS_S_SMARTREADERDOWN|S7FS_S_SMARTREADERUP|S7FS_S_EXTBOARDABSENT|S7FS_S_DETECTCARDSCANIN|S7FS_S_DETECTCARDSCANOUT|S7FS_S_SMARTREADERCAMSENSOR|S7FS_S_NOTINSTALLSCANMOD|S7FS_S_CASEOPENSENSOR) + + +#define S7FS_E_CARDIN 0x0000000100000000 // 카드-인 에러 +#define S7FS_E_CARDOUT 0x0000000200000000 // 카드 배출 에러 +#define S7FS_E_FLIP 0x0000000400000000 // 플립 에러 +#define S7FS_E_CARDMOVE 0x0000000800000000 // 카드 이동 에러 +#define S7FS_E_SMARTREADERDOWN 0x0000001000000000 // IC 리더 다운 에러 (Board Ver.2 에서 사용) +#define S7FS_E_SMARTREADERUP 0x0000002000000000 // IC 리더 업 에러 (Board Ver.2 에서 사용) +#define S7FS_F_INIT 0x0001000000000000 // 초기화 에러 + +#define S7FS_E_MASK (S7FS_E_CARDIN|S7FS_E_CARDOUT|S7FS_E_FLIP) +#define S7FS_F_MASK (S7FS_F_INIT) +#define S7FS_WF_V2BOARDONLY (S7FS_E_SMARTREADERDOWN|S7FS_E_SMARTREADERUP) + +#define S7FS_WS_V2BOARDONLY (S7FS_WA_V2BOARDONLY|S7FS_WS_V2BOARDONLY) + + + +// SMART-70 LAMINATOR STATUS + +#define S7LS_M_CARDIN 0x0000000000000001 // 카드-인 중 +#define S7LS_M_CARDMOVE 0x0000000000000002 // 카드 이동 중 +#define S7LS_M_CARDOUT 0x0000000000000004 // 카드 배출 중 +#define S7LS_M_THEADUP 0x0000000000000008 // 헤드 업 중 +#define S7LS_M_THEADDOWN 0x0000000000000010 // 헤드 다운 중 +#define S7LS_M_THEADHEAT 0x0000000000000020 // 헤드 가열 중 +#define S7LS_M_LAMINATING 0x0000000000000040 // 라미네이팅 중 +#define S7LS_S_INSTALLEXTHOPPER 0x0000000000000080 // 외부 호퍼 장착 +#define S7LS_S_INSTALLEXTSTACKER 0x0000000000000100 // 외부 스태커 장착 +#define S7LS_S_INSTALLEXTFLIPPER 0x0000000000000200 // 외부 플리퍼 장착 +#define S7LS_S_READY 0x0000000000010000 // 대기상태 +#define S7LS_M_PROCESSING 0x0000000000020000 // 명령 수행 중 +#define S7LS_M_PROCESSUSBCMD 0x0000000000040000 // USB 명령 수행 중 +#define S7LS_S_CASEOPEN 0x0000000000100000 // 케이스 열림 감지 +#define S7LS_S_CATRIDGELOCK 0x0000000000200000 // 카트리지 락 센서 감지 +#define S7LS_S_CARDOUT 0x0000000000400000 // 아웃 센서 카드감지 +#define S7LS_S_CARDCENTERB 0x0000000000800000 // 센터 B 센서 카드 감지 +#define S7LS_S_CARDCENTERA 0x0000000001000000 // 센터 A 센서 카드 감지 +#define S7LS_S_CARDIN 0x0000000002000000 // 인 센서 카드 감지 +#define S7LS_S_THEAD 0x0000000004000000 // 헤드 업/다운 센서 +#define S7LS_S_CASEOPENSENSOR 0x0000000008000000 // 케이스 열림 감지 센서 +#define S7LS_S_FILMMARKCHECKB 0x0000000010000000 // 필름 마크 체크 B 센서 +#define S7LS_S_FILMMARKCHECKA 0x0000000020000000 // 필름 마크 체크 A 센서 +#define S7LS_S_ENCODERB 0x0000000040000000 // 인코더 B 센서 +#define S7LS_S_ENCODERA 0x0000000080000000 // 인코더 A 센서 + +#define S7LS_M_MASK (S7LS_M_CARDIN|S7LS_M_CARDMOVE|S7LS_M_CARDOUT|S7LS_M_THEADUP|S7LS_M_THEADDOWN|S7LS_M_THEADHEAT|S7LS_M_LAMINATING|S7LS_M_PROCESSING) +#define S7LS_S_MASK (S7LS_S_READY|S7LS_S_CASEOPEN|S7LS_S_CATRIDGELOCK|S7LS_S_CARDOUT|S7LS_S_CARDCENTERB|S7LS_S_CARDCENTERA|S7LS_S_CARDIN|S7LS_S_THEAD|/*S7LS_S_CASEOPENSENSOR|*/S7LS_S_FILMMARKCHECKB|S7LS_S_FILMMARKCHECKA|S7LS_S_ENCODERB|S7LS_S_ENCODERA) + + +#define S7LS_E_CARDIN 0x0000000100000000 // 카드-인 에러 +#define S7LS_E_CARDMOVE 0x0000000200000000 // 카드 이동 에러 +#define S7LS_E_CARDOUT 0x0000000400000000 // 카드 배출 에러 +#define S7LS_E_THEADUP 0x0000000800000000 // 헤드 업 에러 +#define S7LS_E_THEADDOWN 0x0000001000000000 // 헤드 다운 에러 +#define S7LS_E_LAMINATING 0x0000002000000000 // 라미네이팅 중 에러 +#define S7LS_E_INSTALLEXTHOPPER 0x0000008000000000 // 외부 플리퍼 연결 에러 +#define S7LS_E_INSTALLEXTSTACKER 0x0000010000000000 // 외부 스태커 연결 에러 +#define S7LS_E_INSTALLEXTFLIPPER 0x0000020000000000 // 외부 플리퍼 연결 에러 +#define S7LS_F_INIT 0x0001000000000000 // 초기화 실패 +#define S7LS_E_PROCESSING 0x0002000000000000 // 명령 수행 에러 +#define S7LS_E_PROCESSUSBCMD 0x0004000000000000 // USB 명령 수행 에러 +#define S7LS_F_FILMEMPTY 0x0010000000000000 // 필름 잔량 없음 +#define S7LS_F_FILMSEEK 0x0020000000000000 // 필름 찾기 에러 +#define S7LS_F_THEAD 0x0040000000000000 // 헤드 안전 에러 (과열 등) +#define S7LS_F_FILMABSENT 0x0080000000000000 // 필름 미장착 + +#define S7LS_E_MASK (S7LS_E_CARDIN|S7LS_E_CARDMOVE|S7LS_E_CARDOUT|S7LS_E_THEADUP|S7LS_E_THEADDOWN|S7LS_E_PROCESSING|S7LS_E_LAMINATING) +#define S7LS_F_MASK (S7LS_F_INIT|S7LS_F_FILMEMPTY|S7LS_F_FILMSEEK|S7LS_F_THEAD|S7LS_F_FILMABSENT) + + + + + +// SMART-70X/LE LASER STATUS + +#define S7XS_M_CARDIN 0x0000000000000001 // 카드 삽입중 +#define S7XS_M_CARDOUT 0x0000000000000002 // 카드 배출중 +#define S7XS_M_FLIPPING 0x0000000000000004 // 플리퍼 회전중 +#define S7XS_M_CARDMOVE 0x0000000000000008 // 카드 이동 +#define S7XS_M_ICHLIFT 0x0000000000000010 // IC 헤드 업/다운중 +#define S7XS_M_MAGRW 0x0000000000000020 // Magnetic 동작중 +#define S7XS_S_NOICCAM 0x0000000000000800 // IC Reader CAM Sensor 없음 +#define S7XS_S_LE 0x0000000000008000 // SMART-70LE +#define S7XS_S_READY 0x0000000000010000 // 대기 상태 +#define S7XS_M_PROCESSING 0x0000000000020000 // 명령 수행중 +#define S7XS_S_AUTOCARDIN 0x0000000000040000 // 자동 카드 삽입 설정 상태 +#define S7XS_S_RECOVERING 0x0000000000080000 // boot, case(door) close 후 복구중 +#define S7XS_S_FLPBOTTOM 0x0000000000100000 // 플리퍼 하향 상태 +#define S7XS_S_FLPTOP 0x0000000000200000 // 플리퍼 상향 상태 +#define S7XS_S_CASEOPEN 0x0000000001000000 // 케이스 열림 +#define S7XS_S_DETECTOPTOUT 0x0000000004000000 // 옵션 아웃 센서에서 카드 검출 +#define S7XS_S_DETECTFLPREAR 0x0000000008000000 // 플리퍼 후방 센서에서 카드 검출 +#define S7XS_S_DETECTOPTIN 0x0000000010000000 // 옵션 인 센서에서 카드 검출 +#define S7XS_S_DETECTCARDOUT 0x0000000020000000 // 카드 아웃 센서에서 카드 검출 +#define S7XS_S_DETECTFLPCENTER 0x0000000040000000 // 플리퍼 중앙 센서에서 카드 검출 +#define S7XS_S_DETECTCARDIN 0x0000000080000000 // 카드 인 센서에서 카드 검출 + +// +// [ LASER-X DEVICE ] +// +------------------------+ +// | | 1 : Card-In Sensor +// | Laser | 2 : Flipper-Center Sensor +// | | 3 : Flipper-Rear Sensor +// 1 [===2===] 3--4------5--6 4 : Option-In Sensor 옵션 장치들이 설치되는 공간의 시작 부분 +// | | 5 : Option-Out Sensor 옵션 장치들이 설치되는 공간의 끝 부분 +// | Flipper Options | 6 : Card-Out Sensor +// +------------------------+ + +#define S7XS_M_MASK (S7XS_M_CARDIN|S7XS_M_CARDOUT|S7XS_M_FLIPPING|S7XS_M_CARDMOVE|S7XS_M_ICHLIFT|S7XS_M_MAGRW|S7XS_M_PROCESSING) +#define S7XS_S_MASK (S7XS_S_READY|S7XS_S_AUTOCARDIN|S7XS_S_FLPBOTTOM|S7XS_S_FLPTOP|S7XS_S_FLP_SideNotSure|S7XS_S_CASEOPEN|S7XS_S_FLIPPCS_MissedLittle|S7XS_S_DETECTOPTOUT|S7XS_S_DETECTFLPREAR|S7XS_S_DETECTOPTIN|S7XS_S_DETECTCARDOUT|S7XS_S_DETECTFLPCENTER|S7XS_S_DETECTCARDIN) + + + +#define S7XS_E_CARDIN 0x0000000100000000 // 카드-인 에러 +#define S7XS_E_CARDOUT 0x0000000200000000 // 카드 배출 에러 +#define S7XS_E_CARDFLIP 0x0000000400000000 // 카드 플립 에러 +#define S7XS_E_CARDMOVE 0x0000000800000000 // 카드 이동 에러 +#define S7XS_E_ICHLIFT 0x0000001000000000 // IC 헤드 업/다운 에러 +#define S7XS_E_MAGRW 0x0000002000000000 // 마그네틱 RW 에러 +#define S7XS_F_INIT 0x0001000000000000 // 초기화 에러 + +#define S7XS_E_MASK (S7XS_E_CARDIN|S7XS_E_CARDOUT|S7XS_E_CARDFLIP|S7XS_E_CARDMOVE|S7XS_E_ICHLIFT|S7XS_E_MAGRW) +#define S7XS_F_MASK (S7XS_F_INIT) + + + + + + + +/* + * Configuration Item Definition. + */ + +#define SM70EX_CFG_BLOKING 0x0006 +#define SM70EX_CFG_PRINTMETHOD 0x000B +#define SM70EX_CFG_PRINTFILENAME 0x000C // .prn file name set/get +#define SM70EX_CFG_REVERSEOVERLAY 0x000E // overlay reverse +#define SM70EX_CFG_REVERSEUV 0x000F // uv reverse +#define SM70EX_CFG_IMAGEFLIP 0x0014 // no flip, h-flip, v-flip, rotate-180(h-flip & v-flip) for printing image. // 2018.05.10 +#define SM70EX_CFG_LECARDINCARDSIDE 0x0015 // SMART-70LE : card side when card in +#define SM70EX_CFG_LECARDOUTCARDSIDE 0x0016 // SMART-70LE : card side when card out +#define SM70EX_CFG_ADJUSTCONTACTPOS 0x0018 // adjust contact smart card position. +#define SM70EX_CFG_ADJUSTCONTACTLESSPOS 0x0019 // adjust contactless smart card position. + + +/* + * Configuration Value Definition. + */ + +// General Configuration +#define SM70EX_CFG_USE 0x01 +#define SM70EX_CFG_NOTUSE 0x00 + +// SM70EX_CFG_PRINTMETHOD +#define SM70EX_CFG_PRINTONLY 0x00 +#define SM70EX_CFG_PRINTNFILE 0x01 // only enabled at DCL mode printing. +#define SM70EX_CFG_FILEONLY 0x02 + +// SM70EX_CFG_IMAGEFLIP +#define SM70EX_CFG_NOFLIP 0x00 // no flip +#define SM70EX_CFG_VFLIP 0x01 // vertical flip +#define SM70EX_CFG_HFLIP 0x02 // horizontal flip +#define SM70EX_CFG_ROTATE180 (SM70EX_CFG_VFLIP|SM70EX_CFG_HFLIP) // rotate 180 (hflip + vflip) + + + + + +// @Smart70_CardMovePosition +#define SM70_CARDPOS_MAG 1 // magnetic (write) position +#define SM70_CARDPOS_CONTACT 2 // contact smartcard position +#define SM70_CARDPOS_CONTACTLESS 3 // contactless smartcard position +#define SM70_CARDPOS_BASE 4 // flipper position in flipper module. +#define SM70_CARDPOS_LASER 5 // laser marking position +#define SM70_CARDPOS_MAGREAD 6 // magnetic read position. (in 70X, read position is different from write) + + + +// @Smart70_Flip +#define SMART70_FLIP_360 0 // complete (360) flip. +#define SMART70_FLIP_TOTOP 1 // flip to top sided. +#define SMART70_FLIP_TOBOTTOM 2 // flip to bottom sided. +#define SMART70_FLIP_180 3 // 180 flip. no matter sided. +#define SMART70_FLIP_ANGLE 4 // any angle flip. + + + +#define SMART70_PRINTER_MAX 32 + +typedef struct { + WCHAR name[128]; // printer name + WCHAR id[64]; // printer ID + WCHAR dev[64]; // device connection + WCHAR desc[256]; // description + int pid; // USB product ID +} SMART70_PRINTER_ITEM; + +typedef struct { + int n; + SMART70_PRINTER_ITEM item[SMART70_PRINTER_MAX]; +} SMART70_PRINTER_LIST; + +typedef struct { + WCHAR port[64]; // usb port + WCHAR link[256]; // symbolic link of usb port + int is_bridge; // Network module bridge +} SMART70_PRINTER_PORT_USB; + +typedef struct { + WCHAR ver[64]; // version of network protocol + WCHAR ip[64]; // ip address + int port; // tcp port + int is_ssl; // ssl protocol +} SMART70_PRINTER_PORT_NET; + +typedef struct { + WCHAR name[128]; // printer name + WCHAR id[64]; // printer ID + WCHAR dev[64]; // device connection + int dev_type; // 1=USB, 2=NET + int pid; // USB product ID + + SMART70_PRINTER_PORT_USB usb; + SMART70_PRINTER_PORT_NET net; +} SMART70_PRINTER_STANDARD; + +typedef struct { + int is_dual; // dual printer + WCHAR ic1[64]; // internal contact encoder + WCHAR ic2[64]; // external contact SIM encoder + WCHAR rf1[64]; // internal contactless encoder + WCHAR rf2[64]; // external contactless encoder +} SMART70_PRINTER_OPTIONS; + +typedef struct { + SMART70_PRINTER_STANDARD std; + SMART70_PRINTER_OPTIONS opt; +} SMART70_PRINTER_INFO; + + + + +#define SMART70_MAX_DEVICE 32 + +#define SMART70_DEV_INHOPPER 0x10 +#define SMART70_DEV_MULINHOPPER 0x20 +#define SMART70_DEV_ENCODER 0x30 +#define SMART70_DEV_PRINTER 0x40 +#define SMART70_DEV_LAMINATOR 0x50 +#define SMART70_DEV_FLIPPER 0x60 +#define SMART70_DEV_OUTHOPPER 0x70 +#define SMART70_DEV_MULOUTHOPPER 0x80 +#define SMART70_DEV_LASER 0x60 +#define SMART70_DEV_INTENCODER 0x90 // internal encoder. +#define SMART70_DEV_OTHER 0xD0 // other devices +#define SMART70_DEV_ALL 0xF0 +#define SMART70_DEV_IDX 0x0F +#define SMART70_DEV_MASK SMART70_DEV_ALL +#define SMART70_MOD_LASER (SMART70_DEV_LASER|2) + +typedef struct { + BYTE id; + BYTE status; +} SMART70_DEVICE_STATUS; + +typedef struct { + int n; + SMART70_DEVICE_STATUS dev[SMART70_MAX_DEVICE]; +} SMART70_DEVCONNLIST; + + + +typedef void* HSMART70; + + + + + +#define SMART70_DEFAULT_LENGTH 1012 +#define SMART70_DEFAULT_HEIGHT 636 + +/* + * Supply + */ +#define SMART70_SUPPLY_AUTO 0x00 +#define SMART70_SUPPLY_HOPPER 0x01 + +/* + * Tray + */ +#define SMART70_TRAY_CR80 0x00 + +/* + * Ribbon Type + */ +#define SMART70_RIBBON_YMCKO 0 +#define SMART70_RIBBON_YMCKOK 1 +#define SMART70_RIBBON_hYMCKO 2 +#define SMART70_RIBBON_KO 3 +#define SMART70_RIBBON_K 4 +#define SMART70_RIBBON_BO 5 +#define SMART70_RIBBON_B 6 +#define SMART70_RIBBON_YMC 7 +#define SMART70_RIBBON_YMCKFO 8 +#define SMART70_RIBBON_REWRITABLE 9 +#define SMART70_RIBBON_hYMCKOKO 11 +#define SMART70_RIBBON_YMCKOKR 12 + +/* + * Ribbon - Resin + */ +#define SMART70_RESIN_BLACKTEXT 0x00 // Extract Black Text to RESIN Panel +#define SMART70_RESIN_BLACKDOT 0x01 // Extract Black Dot(Pixel) to RESIN Panel +#define SMART70_RESIN_NOTUSE 0x02 // No Extraction. +#define SMART70_RESIN_DYNAMIC 0x03 // use DC's ExtEscape(). + +/* + * Ribbon Split + */ +#define SMART70_RIBBONSPLIT_NORMAL 0x00 +#define SMART70_RIBBONSPLIT_FORBACK 0x01 + +/* + * Flip Option + */ +#define SMART70_FLIP_NORMAL 0 +#define SMART70_FLIP_VERTICAL 1 +#define SMART70_FLIP_HORIZONTAL 2 +#define SMART70_FLIP_ALL 3 + + + + + + + + + + +/* + * Color + */ +#define SMART70_COLOR_COLOR 0 +#define SMART70_COLOR_BLACKNWHITE 1 + +/* + * Dithering + */ +#define SMART70_DITHER_THRESHOLD 0 +#define SMART70_DITHER_RANDOM 1 +#define SMART70_DITHER_DIFFUSION 2 +#define SMART70_DITHER_HALFTONE 3 +#define SMART70_DITHER_HALFTONE2 4 + +/* + * Print + */ +#define SMART70_PRINT_NOTUSE 0 +#define SMART70_PRINT_USE 1 + +/* + * Print Side + */ +#define SMART70_PRINTSIDE_FRONT 0 +#define SMART70_PRINTSIDE_BACK 1 +#define SMART70_PRINTSIDE_BOTH 2 + +/* + * Print Side - Media + */ +#define SMART70_MEDIA_STANDARD 0 +#define SMART70_MEDIA_SMART 1 // Exclude IC Chip Area +#define SMART70_MEDIA_SMARTRIGHT 2 // Exclude Left of IC Chip Area +#define SMART70_MEDIA_MSISO 3 // Exclude MS ISO Track Area +#define SMART70_MEDIA_MSJIS 4 // Exclude MS JIS Track Area +#define SMART70_MEDIA_SMARTMSJIS 5 // Exclude MS JIS Track and IC Chip Area +#define SMART70_MEDIA_NOOVERLAY 6 // No Overlay +#define SMART70_MEDIA_USERDEFINED 7 // Use User Defined Bitmap +#define SMART70_MEDIA_DYNAMIC 8 // use DC's ExtEscape(). +#define SMART70_MEDIA_BITMAP L"cardprinter_mask_" // $SYSTEM32\cardprinter_mask_#.bmp + + +/* + * Eject + */ +#define SMART_EJECT_EJECT_CARD 0 +#define SMART_EJECT_HOLD_CARD 1 + + + +/* + * SMART-70 + */ + +#define SMART70_PRINT_NOTUSE 0 +#define SMART70_PRINT_USE 1 + +#define SMART70_PRINTSIDE_FRONT 0 +#define SMART70_PRINTSIDE_BACK 1 +#define SMART70_PRINTSIDE_BOTH 2 + +#define SMART70_QUALITY_STANDARD 0 +#define SMART70_QUALITY_PARTIAL 1 + +#define SMART70_SPEED_NORMAL 1 +#define SMART70_SPEED_HIGH 2 + +#define SMART70_LAMIN_NOTUSE 0 +#define SMART70_LAMIN_USE 1 + +#define SMART70_LAMIN_TOP 0 +#define SMART70_LAMIN_BOTTOM 1 +#define SMART70_LAMIN_BOTH 2 + +#define SMART70_LAMIN_OVERLAY_NOTUSE 0 +#define SMART70_LAMIN_OVERLAY_USE 1 + +#define SMART70_MODULE_INTERNAL 0 +#define SMART70_MODULE_EXTERNAL 1 +#define SMART70_MODULE_BOTH 2 + +#define SMART70_MAG_COER_AUTO 0 +#define SMART70_MAG_COER_LO 1 +#define SMART70_MAG_COER_HI 2 + +#define SMART70_MAG_OPTION_FORWARD 0 +#define SMART70_MAG_OPTION_BACKWARD 1 +#define SMART70_MAG_OPTION_BITMODE 2 + +#define SMART70_MAG_FLIP_NOTUSE 0 +#define SMART70_MAG_FLIP_USE 1 + +#define SMART70_MAG_NOTUSE 0 +#define SMART70_MAG_USE 1 + +//#define SMART70_MAG_INTERNAL 0 // ==> SMART70_MODULE_INTERNAL +//#define SMART70_MAG_EXTERNAL 1 +//#define SMART70_MAG_BOTH 2 + +#define SMART70_MAG_ENCODING_ISO 0 +#define SMART70_MAG_ENCODING_BALLYS 1 + + + + + +typedef struct _OEM_DMEXTRAHEADER { + DWORD dwSize; + DWORD dwSignature; + DWORD dwVersion; +} OEM_DMEXTRAHEADER, *POEM_DMEXTRAHEADER; + +typedef struct tagOEMDEV +{ + OEM_DMEXTRAHEADER dmOEMExtra; + + //Color Correction + DWORD dwASMain; + DWORD dwASYellow; + DWORD dwASMagenta; + DWORD dwASCyan; + DWORD dwASBlack; + DWORD dwASOverlay; + + //Resin Black(K) Processing + DWORD dwASBPText; + DWORD dwASBPDot; + DWORD dwASBPThreshold; + DWORD dwASBPDitherDegree; + DWORD dwASBPResin; + + //RewritableControl + DWORD dwASErase; + + //Wait Control + DWORD dwASWaitInRFUse; + DWORD dwASWaitInRFSide; + DWORD dwASWaitInRFPos; + DWORD dwASWaitInRFTime; + DWORD dwASWaitExRFUse; + DWORD dwASWaitExRFSide; + DWORD dwASWaitExRFPos; + DWORD dwASWaitExRFTime; + DWORD dwASWaitExICUse; + DWORD dwASWaitExICSide; + DWORD dwASWaitExICPos; + DWORD dwASWaitExICTime; + + // INPUT / OUTPUT + DWORD dwIOSupply; + DWORD dwIOTray; + DWORD dwIOOutput; + + // PRINTING 1 + DWORD dwPrtUse; + DWORD dwPrtSide; + DWORD dwPrtColorFront; + DWORD dwPrtColorBack; + DWORD dwPrtMediaFront; + DWORD dwPrtMediaBack; + WCHAR strPrtMediaUserFront[1024]; + WCHAR strPrtMediaUserBack[1024]; + DWORD dwPrtRibbon; + DWORD dwPrtQuality; + DWORD dwPrtSpeed; + DWORD dwPrtHeatControl; + DWORD dwPrtFlipFront; + DWORD dwPrtFlipBack; + DWORD dwPrtDither; + DWORD dwPrtRibbonSplit; + + // PRINTING 2 + DWORD dwPrtUse2; + DWORD dwPrtSide2; + DWORD dwPrtColorFront2; + DWORD dwPrtColorBack2; + DWORD dwPrtMediaFront2; + DWORD dwPrtMediaBack2; + WCHAR strPrtMediaUserFront2[1024]; + WCHAR strPrtMediaUserBack2[1024]; + DWORD dwPrtRibbon2; + DWORD dwPrtQuality2; + DWORD dwPrtSpeed2; + DWORD dwPrtHeatControl2; + DWORD dwPrtFlipFront2; + DWORD dwPrtFlipBack2; + DWORD dwPrtDither2; + DWORD dwPrtRibbonSplit2; + + // LAMINATING 1 + DWORD dwLamUse; + DWORD dwLamSide; + DWORD dwLamOverlay; + + // LAMINATING 2 + DWORD dwLamUse2; + DWORD dwLamSide2; + DWORD dwLamReserved2; + + // ENCODING + DWORD dwEncUse; + DWORD dwEncModule; + DWORD dwEncInCoer; + DWORD dwEncInOption; + DWORD dwEncInMagFlip; + DWORD dwEncInEncoding; + WCHAR strEncInTrack1[1024]; + WCHAR strEncInTrack2[1024]; + WCHAR strEncInTrack3[1024]; + WCHAR strEncInJISTrack[1024]; + DWORD dwEncExCoer; + DWORD dwEncExOption; + DWORD dwEncExMagFlip; + DWORD dwEncExEncoding; + WCHAR strEncExTrack1[1024]; + WCHAR strEncExTrack2[1024]; + WCHAR strEncExTrack3[1024]; + WCHAR strEncExJISTrack[1024]; + DWORD dwASCorrectColor; + DWORD dwASCorrectMono; + DWORD dwASCorrectOverlay; + DWORD dwEncInMagRepeat; + DWORD dwEncExMagRepeat; + DWORD dwOptSeparate; + DWORD dwASFastAlignment; + DWORD dwPrtAntiAliasing; + BYTE reserved[32]; +} OEMDEV, *POEMDEV; + +typedef struct { + DEVMODEW devmode; +#if defined(_MFC_VER) && (_MFC_VER <= 0x0600) + DWORD dummy1; + DWORD dummy2; +#endif + BYTE reserved[564]; + OEMDEV oemdev; +} SMART70_DEVMODE; + +#define SMART_DEVMODE SMART70_DEVMODE + + + + +#define SMART70_COUNTPARAM_VER_LATEST 0 + +typedef struct +{ + int ver; // current version is 0. + + // [ver == 0] ------------- + int img; // image issue count + int mag; // magnetic issue count + int contact; // contact smart card issue count + int sim; // SIM card issue count + int contactless_ext; // contactless smart card (external) issue count + int contactless_int; // contactless smart card (internal) issue count + int cleanskip; // cleaning skip count + int cleaning; // cleaning count +} COUNTPARAM; + + + +#define SMART70_SYSINFO_VER_0 0 +#define SMART70_SYSINFO_VER_LASTEST SMART70_SYSINFO_VER_0 + +#define SMART70_MAX_VER_LEN 32 +#define SMART70_MAX_SERIAL_LEN 24 + +typedef struct +{ + int ver; // structure version (= SMART70_SYSINFO_VER_0) + + // [ver == 0] ------------- + struct { + WCHAR ver[SMART70_MAX_VER_LEN]; // printer f/w ver. + WCHAR serial[SMART70_MAX_SERIAL_LEN]; // printer serial number + WCHAR hserial[SMART70_MAX_SERIAL_LEN]; // thermal header serial number + BYTE reserved[32]; + } printer; + struct { + BOOL installed; // flag for laminator installation + WCHAR ver[SMART70_MAX_VER_LEN]; // laminator f/w ver. + WCHAR serial[SMART70_MAX_SERIAL_LEN]; // laminator serial number + BYTE reserved[32]; + } laminator; +} SMART_SYSINFO; + + + + + + +typedef enum +{ + obj_rect, + obj_roundrect, + obj_oval, + obj_line, + obj_image, + obj_text, + obj_bar, +} S70ObjType; + + + + +#ifdef MAKE_LONIBBLE +# undef MAKE_LONIBBLE +#endif// +#ifdef MAKE_HINIBBLE +# undef MAKE_HINIBBLE +#endif// +#ifdef GET_LONIBBLE +# undef GET_LONIBBLE +#endif// +#ifdef GET_HINIBBLE +# undef GET_HINIBBLE +#endif// +#ifdef MAKE_ALIGN +# undef MAKE_ALIGN +#endif// +#ifdef GET_HALIGN +# undef GET_HALIGN +#endif// +#ifdef GET_VALIGN +# undef GET_VALIGN +#endif// +#ifdef SET_HALIGN +# undef SET_HALIGN +#endif// +#ifdef SET_VALIGN +# undef SET_VALIGN +#endif// + +#define SMART70_OBJ_ALIGN_LEFT 0x00 +#define SMART70_OBJ_ALIGN_CENTER 0x01 +#define SMART70_OBJ_ALIGN_RIGHT 0x02 +#define SMART70_OBJ_ALIGN_JUSTIFY 0x03 // text object only... +#define SMART70_OBJ_ALIGN_HNOALIGN 0x04 +#define SMART70_OBJ_ALIGN_TOP 0x00 +#define SMART70_OBJ_ALIGN_MIDDLE 0x10 +#define SMART70_OBJ_ALIGN_BOTTOM 0x20 +#define SMART70_OBJ_ALIGN_VNOALIGN 0x30 +#define SMART70_OBJ_ALIGN_HORZMASK 0x0F +#define SMART70_OBJ_ALIGN_VERTMASK 0xF0 +#define MAKE_LONIBBLE(nb) ( (nb) & 0x0F ) +#define MAKE_HINIBBLE(nb) ( ((nb) & 0x0F) << 4 ) +#define GET_LONIBBLE(bt) ( (bt) & 0x0F ) +#define GET_HINIBBLE(bt) ( ((bt) & 0xF0 ) >> 4 ) +#define MAKE_ALIGN(h,v) ( (h) | (v) ) +#define SMART70_OBJ_ALIGN_NOALIGN (SMART70_OBJ_ALIGN_VNOALIGN|SMART70_OBJ_ALIGN_HNOALIGN) +#define GET_HALIGN(a) ((a)&SMART70_OBJ_ALIGN_HORZMASK) //GET_HINIBBLE(a) +#define GET_VALIGN(a) ((a)&SMART70_OBJ_ALIGN_VERTMASK) //GET_LONIBBLE(a) +#define SET_HALIGN(a,h) MAKE_ALIGN(h,GET_VALIGN(a)) +#define SET_VALIGN(a,v) MAKE_ALIGN(GET_HALIGN(a),v) + + +#define SMART70_IMGSCALE_FITHORZ 0x00 // scale to fit to width of frame +#define SMART70_IMGSCALE_FITVERT 0x01 // scale to fit to height of frame +#define SMART70_IMGSCALE_FITFRAME 0x02 // scale to fit to frame. +#define SMART70_IMGSCALE_USER 0x03 // scale factor is user setted. +#define SMART70_IMGSCALE_BEST SMART70_IMGSCALE_FITHORZ +#define SMART70_IMGSCALE_BASEAMP 10000 // default amplyfiying value + +#define SMART70_IMGEFFECT_CONTRASTMIN -100 +#define SMART70_IMGEFFECT_CONTRASTMAX 100 //412 +#define SMART70_IMGEFFECT_BRIGHTMIN -256 +#define SMART70_IMGEFFECT_BRIGHTMAX 255 + +#define SMART70_IMGEFFECT_CONTRASTMIN -100 +#define SMART70_IMGEFFECT_CONTRASTMAX 100 //412 +#define SMART70_IMGEFFECT_BRIGHTMIN -256 +#define SMART70_IMGEFFECT_BRIGHTMAX 255 + +#define SMART70_FONT_NORMAL 0x00 +#define SMART70_FONT_BOLD 0x01 +#define SMART70_FONT_ITALIC 0x02 +#define SMART70_FONT_UNDERLINE 0x04 + +#define SMART70_TEXT_NOFIT 0 // use font size +#define SMART70_TEXT_FITHEIGHT 1 // font is sized to frame's height +#define SMART70_TEXT_FITWIDTH 2 // font is sized to frame's width +#define SMART70_TEXT_FITBOTH 3 // font is sized to frame's width and height +#define SMART70_TEXT_AUTOSIZE 4 +#define SMART70_TEXT_SIZEMASK 0x000F + + +// border style +#define BS_NONE 5 +#define BS_SOLID 0 +#define BS_DASH 1 +#define BS_DOT 2 +#define BS_DASHDOT 3 +#define BS_DASHDOTDOT 4 + + +#define SMART70_OTB_NONE 0x0000 +#define SMART70_OTB_FromEnum(e) (1 << (e)) +#define SMART70_OTB_RECT SMART70_OTB_FromEnum(obj_rect) +#define SMART70_OTB_ROUNDRECT SMART70_OTB_FromEnum(obj_roundrect) +#define SMART70_OTB_OVAL SMART70_OTB_FromEnum(obj_oval) +#define SMART70_OTB_LINE SMART70_OTB_FromEnum(obj_line) +#define SMART70_OTB_IMAGE SMART70_OTB_FromEnum(obj_image) +#define SMART70_OTB_TEXT SMART70_OTB_FromEnum(obj_text) +#define SMART70_OTB_BAR SMART70_OTB_FromEnum(obj_bar) + +#define SMART70_UNITTYPE_TEXT SMART70_OTB_TEXT +#define SMART70_UNITTYPE_IMAGE SMART70_OTB_IMAGE +#define SMART70_UNITTYPE_BARCODE SMART70_OTB_BAR + +#define SMART70_UNITINFO_FIRST 0 +#define SMART70_UNITINFO_NEXT 1 + + +#define SMART70_MAX_FIELDNAMELEN 32 +#define SMART70_MAX_FIELDVALUELEN 1024 + +#define SMART70_FIELD_PREFIX L'~' + +#define SMART70_MAX_BARCODENAME 64 + + +typedef struct _tagFontInfo +{ + int size; + BYTE style; + COLORREF color; + WCHAR name[LF_FACESIZE]; +} S70FontInfo; + +typedef struct _tagFontInfo2 +{ + int size; // font size + int size2; // font width size (for slim or large sized text...) + BYTE style; + COLORREF color; + WCHAR name[LF_FACESIZE]; +} FontInfo2; + +typedef struct _tagBorder +{ + USHORT type; // using PenStyle. PS_SOLID, ... + USHORT width; // mm type.... + COLORREF color; +} S70Border; + +typedef struct _tagBackGround +{ + BOOL fill; + COLORREF color; + BYTE transparency; // % unit. (0:Opaque, 100:transparent) +} S70BackGround; + +typedef struct _tagLaser +{ + int power; + int speed; + int frequency; + int angle; + int reserved[16]; +} S70Laser; + + +typedef struct +{ + short leftMargin; // spaceLeft + short topMargin; // spaceTop + short rightMargin; // spaceRight + short bottomMargin; // spaceBottom + BYTE align; + S70FontInfo font; + + WCHAR field[SMART70_MAX_FIELDNAMELEN+1]; +} S70UNITTEXT; + +typedef struct +{ + int widthZoom; + int heightZoom; + short contrast; + short brightness; + BOOL grayscale; + USHORT align; + POINT offset; + BYTE scaleMethod; + int round; + + WCHAR field[SMART70_MAX_FIELDNAMELEN+1]; +} S70UNITIMAGE; + +typedef struct +{ + int type; + int size; + int option; + SIZE size2D; + COLORREF barColor; + + WCHAR field[SMART70_MAX_FIELDNAMELEN+1]; +} S70UNITBAR; + + +typedef struct +{ + int index; + int type; + BYTE page; + BYTE panel; + int left; + int top; + int width; + int height; + int rotate; + S70Border border; + S70BackGround back; + + union + { + S70UNITTEXT txt; + S70UNITIMAGE img; + S70UNITBAR bar; + }; +} S70UNITINFO; + + + + +#define SMART70_UNITINFO2_VER_1 1 +#define SMART70_UNITINFO2_VER_2 2 +#define SMART70_UNITINFO2_VER SMART70_UNITINFO2_VER_2 + +typedef struct +{ + short leftMargin; // spaceLeft + short topMargin; // spaceTop + short rightMargin; // spaceRight + short bottomMargin; // spaceBottom + BYTE align; + S70FontInfo font; + WCHAR field[SMART70_MAX_FIELDNAMELEN+1]; + BYTE reserved[32]; // must be 0 +} UNITTEXT2; + + +#define SMART70_UIMG2OPT_OFFSET_ORIGIN 0x0000 // UNITIMAGE2::offset value is original (before-rotating) offset point. +#define SMART70_UIMG2OPT_OFFSET_DRAW 0x0001 // UNITIMAGE2::offset value is drawing point (applied-rotation). +#define SMART70_UIMG2OPT_OFFSET_MASK 0x0001 + +typedef struct +{ + int option; + int widthZoom; + int heightZoom; + short contrast; + short brightness; + BOOL grayscale; + USHORT align; + POINT offset; + BYTE scaleMethod; + int round; + BOOL autoportrait; + BOOL autoeffect; + WCHAR field[SMART70_MAX_FIELDNAMELEN+1]; + BYTE reserved[32]; +} UNITIMAGE2; + +typedef struct +{ + int type; + int size; + int option; + SIZE size2D; + COLORREF barColor; + WCHAR field[SMART70_MAX_FIELDNAMELEN+1]; + BYTE reserved[32]; +} UNITBAR2; + + +typedef struct +{ + int ver; + int index; // zero-based index from ElementList... + int type; // this is not EQUAL with CGObj's one. + // objType can have the value within SMART70_UNITTYPE_TEXT, SMART70_UNITTYPE_IMAGE and SMART70_UNITTYPE_BARCODE. + BYTE page; + BYTE panel; + int left; // offsetLeft + int top; // offsetTop + int width; + int height; + int rotate; + S70Border border; + S70BackGround back; + + union + { + UNITTEXT2 txt; + UNITIMAGE2 img; + UNITBAR2 bar; + }; + + S70Laser laser; +} UNITINFO2; + + + + + +typedef struct +{ + DWORD oiSize; // entire struct size. struct size + extended data size + DWORD oiIndex; // object index + BYTE oiPage; + BYTE oiPanel; + int oiLeft; + int oiTop; + int oiWidth; + int oiHeight; + int oiRotate; + BOOL oiPrintable; // print or not ... + int oiType; // object type + S70Border oiBorder; + S70BackGround oiBack; + + union + { + struct { + int oirrRound; + } oiRRect; + struct { + short oitLeftSpace; + short oitTopSpace; + short oitRightSpace; + short oitBottomSpace; + BYTE oitAlign; + int oitFitOn; + FontInfo2 oitFont; + int oitField; + DWORD oitTextPos; // offset position of wide-char string data.. + DWORD oitTextLen; // data length.. + ///////////////////////////////// + // [ OBJ_INFO ] + // - base structure members 0 ~ ... + // - oiText strcuture members ... ~ sizeof(OBJ_INFO) + // ------------------------------- + // + + // - text data additional data area... + ///////////////////////////////// + } oiText; + struct { + int oiiWidth; + int oiiHeight; + DWORD oiiZoomWidth; // unit is permil. SMART70_IMGSCALE_BASEAMP: use origin size of image + DWORD oiiZoomHeight; // unit is permil. SMART70_IMGSCALE_BASEAMP: use origin size of image + short oiiContrast; // -100 ~ . default value is 0. + short oiiBrightness; // -256 ~ 255. default value is 0. + BOOL oiiGrayscaled; + USHORT oiiAlign; + POINT oiiOffset; // offset position in left-upper corner of frame + BYTE oiiScale; // image scaling method... + COLORREF oiiTransColor; + int oiiTransRange; + int oiiRound; + int oiiField; + DWORD oiiImgNamePos; // offset position of wide-char string data.. + DWORD oiiImgNameLen; // data length.. + ///////////////////////////////// + // [ OBJ_INFO ] + // - base structure members 0 ~ ... + // - oiImage strcuture members ... ~ sizeof(OBJ_INFO) + // ------------------------------- + // + + // - image url(file-path) data additional data area... + ///////////////////////////////// + } oiImage; + struct { + WCHAR oibName[SMART70_MAX_BARCODENAME]; + int oibSize; + int oibOpt; + short oib2DOpt1; + short oib2DOpt2; + COLORREF oibColor; + int oibField; + DWORD oibDataPos; // barcode-data position. + DWORD oibDataLen; // barcode-data length. + DWORD oibExDataPos; // zip-postal data. it is used only "MaxiCode" type. + DWORD oibExDataLen; // zip-postal data. it is used only "MaxiCode" type. + ///////////////////////////////// + // [ OBJ_INFO ] + // - base structure members 0 ~ ... + // - oiBar strcuture members ... ~ sizeof(OBJ_INFO) + // ------------------------------- + // + + // - barcode data additional data area... + // - zip-postal data (if necessary) + ///////////////////////////////// + } oiBar; + }; +} OBJ_INFO; + + +#define OBJINFO2_VER_2 2 +#define OBJINFO2_VER OBJINFO2_VER_2 + +#define LINE_FLIP_HORZ 0x01 +#define LINE_FLIP_VERT 0x02 + +typedef struct +{ + DWORD oiVer; // OBJINFO_VER + DWORD oiSize; // base structure size. = sizeof(OBJ_INFO2) + DWORD oiWholeSize; // entire struct size. include datas. = sizeof(OBJ_INFO2) + extend data size + DWORD oiIndex; // object index + BYTE oiPage; + BYTE oiPanel; + int oiLeft; + int oiTop; + int oiWidth; + int oiHeight; + int oiRotate; + BOOL oiPrintable; // print or not ... + int oiType; // object type + S70Border oiBorder; + S70BackGround oiBack; + S70Laser oiLaser; + + union + { + struct { + int oirrRound; + } oiRRect; + struct { + short oitLeftSpace; + short oitTopSpace; + short oitRightSpace; + short oitBottomSpace; + BYTE oitAlign; + int oitOption; + FontInfo2 oitFont; + int oitField; + DWORD oitTextPos; // offset position of wide-char string data.. + DWORD oitTextLen; // data length.. + } oiText; + struct { + int oiiWidth; + int oiiHeight; + DWORD oiiZoomWidth; // unit is permil. IMGSCALE_BASEAMP: use origin size of image + DWORD oiiZoomHeight; // unit is permil. IMGSCALE_BASEAMP: use origin size of image + short oiiContrast; // -100 ~ . default value is 0. + short oiiBrightness; // -256 ~ 255. default value is 0. + BOOL oiiGrayscaled; + USHORT oiiAlign; + POINT oiiOffset; // offset position in left-upper corner of frame + BYTE oiiScale; // image scaling method... + COLORREF oiiTransColor; + int oiiTransRange; + int oiiRound; + int oiiField; + DWORD oiiImgNamePos; // offset position of wide-char string data.. + DWORD oiiImgNameLen; // data length.. + } oiImage; + struct { + WCHAR oibName[SMART70_MAX_BARCODENAME]; + int oibSize; + int oibOpt; + short oib2DOpt1; + short oib2DOpt2; + COLORREF oibColor; + int oibField; + DWORD oibDataPos; + DWORD oibDataLen; + DWORD oibExDataPos; // zip-postal data. it is used only "MaxiCode" type. + DWORD oibExDataLen; // zip-postal data. it is used only "MaxiCode" type. + } oiBar; + struct { + int oilFlip; // LINE_FLIP_HORZ | LINE_FLIP_VERT + } oiLine; + }; +} OBJ_INFO2; + + + +typedef struct +{ + int x; + int y; + int cx; + int cy; + int rotate; + int align; + int fontHeight; + int fontWidth; + int style; + COLORREF color; + int option; + WCHAR szFaceName[LF_FACESIZE]; //LF_FACESIZE = 32 +} DT2INFO; + +#define SMART70_MAX_FIELDNAMELEN 32 +#define SMART70_MAX_FIELDDATALEN 1024 + + +typedef struct +{ + DWORD fiIndex; + WCHAR fiName[SMART70_MAX_FIELDNAMELEN]; + DWORD fiDataLen; + WCHAR fiData[SMART70_MAX_FIELDDATALEN]; +} FIELD_INFO; + + + + + + + + + +typedef int (WINAPI * Smart70_GetDeviceList)(SMART70_PRINTER_LIST* pDevList); +typedef int (WINAPI * Smart70_ExGetDeviceList)(SMART70_PRINTER_LIST* pDevList, int opt); +typedef int (WINAPI * Smart70_GetDeviceInfo)(SMART70_PRINTER_INFO* pDevInfo, WCHAR* szdev, int ndevtype ); +typedef int (WINAPI * Smart70_OpenDevice)(HSMART70* pHandle, WCHAR* szdev, int ndevtype); +typedef int (WINAPI * Smart70_ExOpenDevice)(HSMART70* pHandle, WCHAR* szdev, int ndevtype); +typedef int (WINAPI * Smart70_CloseDevice)(HSMART70 hHandle); + +typedef int (WINAPI * Smart70_GetRibbonInfo)(HSMART70 hHandle, BYTE mod, int* pnType, int* pnRemain, int* pnMax); +typedef int (WINAPI * Smart70_GetConnectedDevices)(HSMART70 hSC, SMART70_DEVCONNLIST* pConnList); +typedef int (WINAPI * Smart70_GetConnectedModules)(HSMART70 hSC, SMART70_DEVCONNLIST* pConnList); +typedef int (WINAPI * Smart70_ICHContact)(HSMART70 hHandle, BYTE mod); +typedef int (WINAPI * Smart70_ICHDiscontact)(HSMART70 hHandle, BYTE mod); +typedef int (WINAPI * Smart70_OpenDocument)(HSMART70 hHandle, const WCHAR* szCSDName); +typedef int (WINAPI * Smart70_CloseDocument)(HSMART70 hHandle); +typedef int (WINAPI * Smart70_ClearDocument)(HSMART70 hHandle, int page); +typedef int (WINAPI * Smart70_GetFieldCount)(HSMART70 hHandle, int* pnCount); +typedef int (WINAPI * Smart70_GetFieldName)(HSMART70 hHandle, int idx, WCHAR* szName, DWORD dwBufLen); +typedef int (WINAPI * Smart70_GetFieldValue)(HSMART70 hHandle, const WCHAR* szName, WCHAR* szValue); +typedef int (WINAPI * Smart70_SetFieldValue)(HSMART70 hHandle, const WCHAR* szName, const WCHAR* szValue); +typedef int (WINAPI * Smart70_DrawImage)(HSMART70 hHandle, BYTE page, BYTE panel, int x, int y, int cx, int cy, WCHAR* szImgPath, RECT* prcArea); +typedef int (WINAPI * Smart70_ExDrawImage)(HSMART70 hHandle, BYTE page, BYTE panel, int x, int y, int cx, int cy, int nScaleMethod, BYTE nAlign, WCHAR* szImgPath, RECT* prcArea); +typedef int (WINAPI * Smart70_DrawBitmap)(HSMART70 hSC, BYTE page, BYTE panel, int x, int y, int cx, int cy, HBITMAP hbmp, RECT* prcArea); +typedef int (WINAPI * Smart70_ExDrawBitmap)(HSMART70 hSC, BYTE page, BYTE panel, int x, int y, int cx, int cy, int nScaleMethod, BYTE nAlign, HBITMAP hbmp, RECT* prcArea); +typedef int (WINAPI * Smart70_DrawText)(HSMART70 hHandle, BYTE page, BYTE panel, int x, int y, WCHAR* szFontName, int nFontSize, BYTE nFontStyle, WCHAR* szText, RECT* prcArea); +typedef int (WINAPI * Smart70_DrawText2)(HSMART70 hHandle, BYTE page, BYTE panel, DT2INFO* pdt2info, WCHAR* szText); +typedef int (WINAPI * Smart70_DrawRect)(HSMART70 hHandle, BYTE page, BYTE panel, int x, int y, int cx, int cy, COLORREF col, RECT* prcArea); +typedef int (WINAPI * Smart70_DrawBarcode)(HSMART70 hHandle, BYTE page, BYTE panel, int x, int y, int cx, int cy, COLORREF col, RECT* prcArea, const WCHAR* szName, int nSize, const WCHAR* szData, const WCHAR* szPost); +typedef int (WINAPI * Smart70_GetBarcodeTypeCount)(HSMART70 hHandle, int* pnCount); +typedef int (WINAPI * Smart70_GetBarcodeTypeName)(HSMART70 hHandle, int idx, WCHAR* szName, int nBufLen); +typedef int (WINAPI * Smart70_GetPreviewBitmap)(HSMART70 hHandle, BYTE page, BITMAPINFO** const ppbi); +typedef int (WINAPI * Smart70_GetUnitInfo)(HSMART70 hHandle, S70UNITINFO* pUnit, int dir); +typedef int (WINAPI * Smart70_GetFieldLinkedUnitInfo)(HSMART70 hHandle, WCHAR* szField, S70UNITINFO* pUnit, int dir); +typedef int (WINAPI * Smart70_SetUnitInfo)(HSMART70 hHandle, S70UNITINFO* pUnit); +typedef int (WINAPI * Smart70_GetUnitInfo2)(HSMART70 hHandle, UNITINFO2* pUnit, int dir); +typedef int (WINAPI * Smart70_GetFieldLinkedUnitInfo2)(HSMART70 hHandle, WCHAR* szField, UNITINFO2* pUnit, int dir); +typedef int (WINAPI * Smart70_SetUnitInfo2)(HSMART70 hHandle, UNITINFO2* pUnit); +typedef int (WINAPI * Smart70_GetUnitInfo2Direct)(HSMART70 hHandle, UNITINFO2* pUnit); +typedef int (WINAPI * Smart70_GetICG)(HSMART70 hHandle, int page, int *pnICG); +typedef int (WINAPI * Smart70_SetICG)(HSMART70 hHandle, int page, int nICG); +typedef int (WINAPI * Smart70_GetVersion)(HSMART70 hSC, WCHAR* szBuf, int* pnBufLen); +typedef int (WINAPI * Smart70_IsBackEnable)(HSMART70 hHandle, BOOL* pbEnabled); +typedef int (WINAPI * Smart70_GetCountParam)(HSMART70 hHandle, COUNTPARAM* pParam); +typedef int (WINAPI * Smart70_GetCountParamEx)(HSMART70 hHandle, COUNTPARAM * pParams); +typedef int (WINAPI * Smart70_GetDisplayInfo)(HSMART70 hHandle, int* pnType, int* pnLang); +typedef int (WINAPI * Smart70_GetSystemInfo)(HSMART70 hHandle, SMART_SYSINFO* pSysInfo); +typedef int (WINAPI * Smart70_ReadUserMemory)(HSMART70 hHandle, WCHAR* szPW, int addr, BYTE* btdata); +typedef int (WINAPI * Smart70_WriteUserMemory)(HSMART70 hHandle, WCHAR* szPW, int addr, BYTE* btdata); +typedef int (WINAPI * Smart70_RFPowerOn)(HSMART70 hHandle, int nDev, int* pnCardType, DWORD* pdwOutLen, BYTE* pOutBuf); +typedef int (WINAPI * Smart70_RFPowerOn2)(HSMART70 hHandle, BYTE mod, DWORD* pdwOutLen, BYTE* pOutBuf); +typedef int (WINAPI * Smart70_RFPowerOff)(HSMART70 hHandle, int nDev); +typedef int (WINAPI * Smart70_RFPowerOff2)(HSMART70 hHandle, BYTE mod); +typedef int (WINAPI * Smart70_RFTransmit)(HSMART70 hHandle, int nDev, DWORD dwInLen, BYTE* pInBuf, DWORD* pdwOutLen, BYTE* pOutBuf); +typedef int (WINAPI * Smart70_RFTransmit2)(HSMART70 hHandle, BYTE mod, DWORD dwInLen, BYTE* pInBuf, DWORD* pdwOutLen, BYTE* pOutBuf); +typedef int (WINAPI * Smart70_ExRFPCSC_GetReaderName)(HSMART70 hHandle, int nWhich, WCHAR* szName); +typedef int (WINAPI * Smart70_ICPowerOn)(HSMART70 hHandle, int nDev, DWORD* pdwOutLen, BYTE* pOutBuf); +typedef int (WINAPI * Smart70_ICPowerOn2)(HSMART70 hHandle, BYTE mod, DWORD* pdwOutLen, BYTE* pOutBuf); +typedef int (WINAPI * Smart70_ICPowerOff)(HSMART70 hHandle, int nDev); +typedef int (WINAPI * Smart70_ICPowerOff2)(HSMART70 hHandle, BYTE mod); +typedef int (WINAPI * Smart70_ICTransmit)(HSMART70 hHandle, int nDev, DWORD dwInLen, BYTE* pInBuf, DWORD* pdwOutLen, BYTE* pOutBuf); +typedef int (WINAPI * Smart70_ICTransmit2)(HSMART70 hHandle, BYTE mod, DWORD dwInLen, BYTE* pInBuf, DWORD* pdwOutLen, BYTE* pOutBuf); + + +#ifdef _WIN64 +typedef int (WINAPI * Smart70_ExSetConfig)(HSMART70 hHandle, int nID, __int64 nValue); +typedef int (WINAPI * Smart70_ExGetConfig)(HSMART70 hHandle, int nID, __int64* pnValue); +#else//_WIN64 +typedef int (WINAPI * Smart70_ExSetConfig)(HSMART70 hHandle, int nID, int nValue); +typedef int (WINAPI * Smart70_ExGetConfig)(HSMART70 hHandle, int nID, int* pnValue); +#endif//_WIN64 + + + + + + + +typedef struct { + DWORD side; + DWORD orientation; + DWORD ribbon; + DWORD ribbon_type; + DWORD width; + DWORD height; +} SMART70_SURFACE_PROPERTIES; + +typedef struct { + HDC hdcColor; + HDC hdcResin; + HDC hdcFluorescent; + HDC hdcOverlay; + HBITMAP hBmpColor; + HBITMAP hBmpResin; + HBITMAP hBmpFluorescent; + HBITMAP hBmpOverlay; + BYTE * lpPRN; +} SMART70_SURFACE_BITMAPS; + + + + + + +typedef int (WINAPI * Smart70DCL_OpenDevice)(HSMART70 *phHandle, WCHAR* szdev, int ndevtype, int nOrientation); +typedef int (WINAPI * Smart70DCL_OpenDevice3)(HSMART70 *phHandle, WCHAR* szDev, int port, BOOL bSSL, int nOrientation); +typedef int (WINAPI * Smart70DCL_CloseDevice)(HSMART70 hHandle); +typedef int (WINAPI * Smart70DCL_ExOpenDevice)(HSMART70 *phHandle, WCHAR* szdev, int ndevtype, int nOrientation); +typedef int (WINAPI * Smart70DCL_Print)(HSMART70 hHandle, int nPrintSide); + +typedef int (WINAPI * Smart70_GetVersion)(HSMART70 hSC, WCHAR* szBuf, int* pnBufLen); + + + + + + +#define SMART70_MAX_MODULES 10 + +#define SMART70_COMMAND_WAITFINISH 0x00 +#define SMART70_COMMAND_ONLY 0x01 +#define SMART70_PRINT_EJECT 0x00 +#define SMART70_PRINT_HOLD 0x10 +#define SMART70_PRINT_PRNONLY 0x20 // for internal use only. you cannot use SMART70_PRINT_PRNONLY and SMART70_PRINT_HOLD both. + +#define SMART70_LEFTSIDE 0 // left : front +#define SMART70_RIGHTSIDE 1 // right : rear + + +// @Smart70_CardMove2 +#define SMART70_MHOP_AUTO 0 +#define SMART70_MHOP_HOP1 0x10 +#define SMART70_MHOP_HOP2 0x20 +#define SMART70_MHOP_HOP3 0x30 +#define SMART70_MHOP_HOP4 0x40 +#define SMART70_MHOP_HOP5 0x50 +#define SMART70_MHOP_HOP6 0x60 + +// @Smart70_CardEject2 +#define SMART70_EJECT_MHOP_LEFT 0x00000000 // eject option : multi-hopper eject to left side +#define SMART70_EJECT_MHOP_RIGHT 0x00000001 // eject option : multi-hopper eject to right side +#define SMART70_EJECT_MHOP_SIDE 0x00000001 // eject option : multi-hopper side mask +#define SMART70_EJECT_MHOP_HOP1 0x00010000 // eject option : multi-hopper hopper #1 +#define SMART70_EJECT_MHOP_HOP2 0x00020000 // eject option : multi-hopper hopper #2 +#define SMART70_EJECT_MHOP_HOP3 0x00030000 // eject option : multi-hopper hopper #3 +#define SMART70_EJECT_MHOP_HOP4 0x00040000 // eject option : multi-hopper hopper #4 +#define SMART70_EJECT_MHOP_HOPPER 0x00070000 // eject option : multi-hopper hopper mask + + +typedef struct { + BYTE from; + BYTE to; + int res; +} MOVECARD; + +typedef struct { + int n; + MOVECARD card[SMART70_MAX_MODULES]; +} CARDMOVELIST; + + +// Encoder Config +#define SMART70_ENCCFG_MAG_COER 0 // [set] set magnetic coercivity. +#define SMART70_ENCCFG_MIRU_IMAGE 10 // [get/set] miru image config (set:volatile) +#define SMART70_ENCCFG_MIRU 11 // [get] get MIRU config. +#define SMART70_ENCCFG_MIRU_GAIN 12 // [set] +#define SMART70_ENCCFG_MIRU_OFFSET 13 // [set] +#define SMART70_ENCCFG_MIRU_SPEED 14 // [set] +#define SMART70_ENCCFG_MIRU_SHADING 15 // [set] + +// Encoder Specific Command - MIRU +#define SMART70_ENC_MIRU_VERSION 10 // [get] get version of miru +#define SMART70_ENC_MIRU_IMAGESAVE 11 // [set] miru image config save +#define SMART70_ENC_MIRU_IMAGEREAD 12 // [get +bulk] read and get image +#define SMART70_ENC_MIRU_READTOPBAR 13 // [get] get top side bar-codes +#define SMART70_ENC_MIRU_READBOTBAR 14 // [get] get bottom side bar-codes +#define SMART70_ENC_MIRU_SCANAREA 15 // [set] set the scanning area. +#define SMART70_ENC_MIRU_RESET 16 // [set] reset the scanner. +#define SMART70_ENC_MIRU_DOSHADING 17 // [get] do shading and get the result. +#define SMART70_ENC_MIRU_RESTORE 18 // [get] restore defaults and get the result. + +// when SMART70_ENC_MIRU_IMAGEREAD, buffer is SMART70_MIRU_SAVEFILENAME [out]. +typedef struct { + WCHAR * sztop; + WCHAR * szbottom; +} SMART70_MIRU_SAVEFILENAME; + + + +#define MIRU_STATUS_DPI_300 300 +#define MIRU_STATUS_DPI_600 600 + +#define MIRU_STATUS_MODE_GRAY 1 +#define MIRU_STATUS_MODE_COLOR 3 + +#define MIRU_STATUS_SIDE_SINGLE 1 +#define MIRU_STATUS_SIDE_DUAL 2 + +#define MIRU_STATUS_FACE_TOP 0 +#define MIRU_STATUS_FACE_BOTTOM 1 + +#define MIRU_STATUS_DROP_NONE 0 +#define MIRU_STATUS_DROP_BLUE 1 +#define MIRU_STATUS_DROP_GREEN 2 +#define MIRU_STATUS_DROP_RED 3 +#define MIRU_STATUS_DROP_IR 4 + +#define MIRU_STATUS_GAIN_MIN 0 +#define MIRU_STATUS_GAIN_MAX 63 + +#define MIRU_STATUS_OFFSET_MIN 0 +#define MIRU_STATUS_OFFSET_MAX 511 + +#define MIRU_STATUS_SPEED_MIN 7400 +#define MIRU_STATUS_SPEED_MAX 59200 + +#define MIRU_SHADING_OFF 0 +#define MIRU_SHADING_ON 1 + +typedef struct { + int dpi; + int mode; + int side; + int face; + int drop; +} MIRU_IMAGE_CONFIG; + +typedef struct { + int dpi; + int mode; + int side; + int face; + int drop; + int width; + int height; + int gain; + int offset; + int speed; + int state; + int cline; + int sline; + int b_trigger; + int b_shading; + int b_monitoring; +} MIRU_CONFIG; + + + +// Encoder Track +#define SMART70_ENC_TRACK_MS1 0x01 +#define SMART70_ENC_TRACK_MS2 0x02 +#define SMART70_ENC_TRACK_MS3 0x04 +#define SMART70_ENC_TRACK_JIS 0x08 +#define SMART70_ENC_TRACK_BAR 0x10 + +// Encoder Option +#define SMART70_ENC_OPTION_NORMAL 0x00 +#define SMART70_ENC_OPTION_BACKWARD 0x40 +#define SMART70_ENC_OPTION_BITMODE 0x80 + +// Magnetic Coercivity +#define SMART70_ENC_MAGCOERCIVITY_LOCO 200 +#define SMART70_ENC_MAGCOERCIVITY_HICO 600 +#define SMART70_ENC_MAGCOERCIVITY_SPCO 800 + +#define SMART70_ENC_TRACK_MS1_MAX 76 +#define SMART70_ENC_TRACK_MS2_MAX 37 +#define SMART70_ENC_TRACK_MS3_MAX 104 +#define SMART70_ENC_TRACK_JIS_MAX 69 + +#define SMART70_ENC_CL_DIR 1 + + + +#define JOB_WAIT 0 +#define JOB_MOVE 1 +#define JOB_PRINT 2 +#define JOB_FLIP 3 +#define JOB_LAMINATE 4 +#define JOB_ERROR 5 +#define JOB_LASER 6 + +#pragma pack(push,1) +typedef struct +{ + int jobid; // job-id for request information, and you must fill this before request. + int work; // job's current working info. JOB_WAIT, ... + BYTE module; // module-id where the card is. + int remain; // the number of remain jobs in job pool, EXCEPT jobid. + // when the 'jobid' value is 0 'work' and 'module' does not have any information and + // 'remain' is ENTIRE jobs count. +} JOBINFO; +#pragma pack(pop) + + +#pragma pack(push,1) +typedef struct +{ + int jobid; // job-id for request information, and you must fill this before request. + int work; // job's current working info. JOB_WAIT, ... + int opt; // print option + BYTE module; // module-id where the card is. + void* hsmart; + BOOL cancel; // user requests cancel. + int remain; // the number of remain jobs in job pool, EXCEPT jobid. + // when the 'jobid' value is 0 'work' and 'module' does not have any information and + // 'remain' is ENTIRE jobs count. +} JOBINFO_EX; +#pragma pack(pop) + + + +typedef struct +{ + int jobid; + int res; + BYTE module; // 0xFF : when success, other : res is error and module is errored module-id. +} S70CBParam; + +typedef LRESULT (CALLBACK * S70CBPROC)(S70CBParam* pcbres); + + + +typedef int (WINAPI * Smart70_RequestPreemption)(HSMART70 handle, WORD * pwPrmt); +typedef int (WINAPI * Smart70_ReleasePreemption)(HSMART70 handle, WORD wPrmt); +typedef int (WINAPI * Smart70_GetModuleState)(HSMART70 handle, BYTE mod, BYTE * pstate); +typedef int (WINAPI * Smart70_UpdateModuleState)(HSMART70 handle, BYTE mod); +typedef int (WINAPI * Smart70_GetStatus)(HSMART70 handle, BYTE mod, __int64 *pstatus); +typedef int (WINAPI * Smart70_IsModuleReady)(HSMART70 handle, BYTE mod, int *pnReady); +typedef int (WINAPI * Smart70_IsReadyInsertJob)(HSMART70 handle, int *pnReady); +typedef int (WINAPI * Smart70_ToggleManualMode)(HSMART70 handle); +typedef int (WINAPI * Smart70_UpdateCurrPrintJob)(HSMART70 handle, BYTE mod); +typedef int (WINAPI * Smart70_GetCurrPrintJob)(HSMART70 handle, BYTE mod, WORD* pjobid); +typedef int (WINAPI * Smart70_DeleteCurrPrintJob)(HSMART70 handle, BYTE mod); +typedef int (WINAPI * Smart70_CardIn)(HSMART70 handle, BYTE module, int dir, int opt); +typedef int (WINAPI * Smart70_CardOut)(HSMART70 handle, BYTE module, int dir, int opt); +typedef int (WINAPI * Smart70_CardMove)(HSMART70 handle, BYTE fromModule, BYTE toModule, int opt); +typedef int (WINAPI * Smart70_CardMove2)(HSMART70 handle, BYTE fromModule, BYTE fromOpt, BYTE toModule, BYTE toOpt, int cmdopt); +typedef int (WINAPI * Smart70_CardListMove)(HSMART70 handle, CARDMOVELIST * plist); +typedef int (WINAPI * Smart70_CardMoveQuick)(HSMART70 handle, BYTE mod, BYTE opt, int cmdopt); +typedef int (WINAPI * Smart70_CardPass)(HSMART70 handle, BYTE mod, BYTE opt, int cmdopt); +typedef int (WINAPI * Smart70_CardFlipPass)(HSMART70 handle, BYTE mod, BYTE opt, int cmdopt); +typedef int (WINAPI * Smart70_CardFlip)(HSMART70 handle, BYTE modfrom, BYTE modflip, BYTE modto); +typedef int (WINAPI * Smart70_CardFlip2)(HSMART70 handle, BYTE modfrom, BYTE modflip, BYTE modto); +typedef int (WINAPI * Smart70_CardFlipStay)(HSMART70 handle, BYTE modfrom, BYTE modflip); +typedef int (WINAPI * Smart70_Flip)(HSMART70 handle, BYTE mod, int opt, int value); +typedef int (WINAPI * Smart70_CardMoveSensor)(HSMART70 handle, BYTE module, int opt1, int valule, int opt2); +typedef int (WINAPI * Smart70_CardMovePosition)(HSMART70 handle, BYTE mod, int pos); +typedef int (WINAPI * Smart70_CardEject)(HSMART70 handle, BYTE mod); +typedef int (WINAPI * Smart70_CardEjectBin)(HSMART70 handle, BYTE mod, BYTE modbin); +typedef int (WINAPI * Smart70_CardEject2)(HSMART70 handle, BYTE mod, int opt, BYTE modout, int optout); +typedef int (WINAPI * Smart70_SetEncConfig)(HSMART70 handle, BYTE module, int config, int value); +typedef int (WINAPI * Smart70_GetEncConfig2)(HSMART70 handle, BYTE module, int config, void* pvalue, int* plen); +typedef int (WINAPI * Smart70_SetEncConfig2)(HSMART70 handle, BYTE module, int config, void* pvalue, int len); +typedef int (WINAPI * Smart70_SetEncBuffer)(HSMART70 handle, BYTE module, BYTE track, int nbuflen, WCHAR* szbuf); +typedef int (WINAPI * Smart70_WriteEncoder)(HSMART70 handle, BYTE module, BYTE track, BYTE opt); +typedef int (WINAPI * Smart70_ReadEncoder)(HSMART70 handle, BYTE module, BYTE track, BYTE opt); +typedef int (WINAPI * Smart70_FetchEncoder)(HSMART70 handle, BYTE module, BYTE track); +typedef int (WINAPI * Smart70_GetEncBuffer)(HSMART70 handle, BYTE module, BYTE track, int * pnbufsize, WCHAR* szbuf); +typedef int (WINAPI * Smart70_RunEncoder)(HSMART70 handle, BYTE module, BYTE track, int run, void* pbuf, int* pbuflen); +typedef int (WINAPI * Smart70_GetPrinterSettings)(HSMART70 handle, BYTE module, SMART70_DEVMODE* pdm); +typedef int (WINAPI * Smart70_SetPrinterSettings)(HSMART70 handle, BYTE module, SMART70_DEVMODE* pdm); +typedef int (WINAPI * Smart70_PrintDocument)(HSMART70 handle, int opt, int * pjobid); +typedef int (WINAPI * Smart70_SetJobCallback)(HSMART70 handle, S70CBPROC pfnCB); + +// @Smart70_PrintStart( opt ) +#define SMART70_PRINT_IMMEDIATE 0x00 +#define SMART70_PRINT_WITHCARDIN 0x01 +#define SMART70_LAMINATE_IMMEDIATE SMART70_PRINT_IMMEDIATE +#define SMART70_LAMINATE_WITHCARDIN SMART70_PRINT_WITHCARDIN +#define SMART70_LAMINATE_SIDETOP 0x00 +#define SMART70_LAMINATE_SIDEBOTTOM 0x02 +//typedef int (WINAPI * Smart70_PrintStart)(HSMART70 handle, BYTE mod, BOOL bCardIn, int cmdopt); +typedef int (WINAPI * Smart70_PrintStart)(HSMART70 handle, BYTE mod, int opt, int cmdopt); + +typedef int (WINAPI * Smart70_GetJobInfo)(HSMART70 handle, JOBINFO* pjobinf); +typedef int (WINAPI * Smart70_GetJobInfoEx)(HSMART70 handle, JOBINFO_EX * pjobinf); + + + + + + +/* + * Job Descriptor Callback Functions + */ + +// error callback +typedef int /*LRESULT*/ (CALLBACK * SM70CB_ERROR)(HSMART70 handle, int jobid, BYTE mid, int nres); + +// magnetic encoding callback +typedef int (CALLBACK * SM70CB_MAGNETIC)(HSMART70 handle, int jobid, BYTE mid); + +// contact smart card encoding callback +typedef int (CALLBACK * SM70CB_CONTACT)(HSMART70 handle, int jobid, BYTE mid, BYTE *pATR, int nATRLen); + +// contactless smart card encoding callback +typedef int (CALLBACK * SM70CB_CONTACTLESS)(HSMART70 handle, int jobid, BYTE mid, BYTE *pATR, int nATRLen); + +// scan image callback +typedef struct { + int bpp; + int width; + int height; +} IMAGE_INFO; + +typedef struct { + BYTE * ptop; + int ntoplen; + BYTE * pbottom; + int nbottomlen; + IMAGE_INFO topinf; + IMAGE_INFO bottominf; +} SCANIMAGE_RESULT; + +typedef int (CALLBACK * SM70CB_SCANIMAGE)(HSMART70 handle, int jobid, BYTE mid, SCANIMAGE_RESULT * presult); + +// scan barcode callback +typedef struct { + WCHAR * msztop; // multi null-terminated string of barcode text in top side. + WCHAR * mszbottom; // multi null-terminated string of barcode text in bottom side. +} SCANBARCODE_RESULT; + +typedef int (CALLBACK * SM70CB_SCANBARCODE)(HSMART70 handle, int jobid, BYTE mid, SCANBARCODE_RESULT * presult); + +// print a page callback +typedef int (CALLBACK * SM70CB_PRINT)(HSMART70 handle, int jobid, BYTE mid, int page); + +// laminate a page callback +typedef int (CALLBACK * SM70CB_LAMINATE)(HSMART70 handle, int jobid, BYTE mid, int page); + +// user callback +typedef int (CALLBACK * SM70CB_USER)(HSMART70 handle, int jobid, BYTE mid, int opt); + + + + + +/* + * Job Descriptor Item + */ + +// card insert, move, eject. +#define S7JD_MOVE 1 + +typedef struct { + BYTE from_mid; // source module-id to move + BYTE from_opt; // option for from_mid + BYTE to_mid; // target module-id to move + BYTE to_opt; // optio nfor to_mid + BYTE reserved[8]; +} S7JD_PARAM_MOVE; + +#define S7JD_MOVE_OPT_MIHAUTO 0x0F // Multi-Input-Hopper Auto +#define S7JD_MOVE_OPT_MOHAUTO 0x0F // Multi-Output-Hopper Auto +#define S7JD_MOVE_OPT_EJECT 0xFF + + +// card flip +#define S7JD_FLIP 2 + +typedef struct { + BYTE from_mid; // source module-id to move for flip + BYTE flip_mid; // module-id of flipper + BYTE to_mid; // target module-id to move after flip + BYTE opt; // flip option + BYTE reserved[8]; +} S7JD_PARAM_FLIP; + + +// magnetic encoding +#define S7JD_MAGNETIC 3 + +typedef struct { + BYTE mid; // module-id of magnetic encoder + int coer; // coercivity value + BYTE reserved[8]; + SM70CB_MAGNETIC pfncb; // callback function for magnetic encoding. + // SDK move the card to magnetic position, configure coercivity and + // calls this callback function. +} S7JD_PARAM_MAGNETIC; + + +// contact smart card encoding +#define S7JD_CONTACT 4 + +typedef struct { + BYTE mid; // module-id of contact smart card encoder + BYTE reserved[8]; + SM70CB_CONTACT pfncb; // callback function for contact smart card encoding. + // SDK move the card to contact position, contact header down, power on and + // calls this callback function. + // after callback function SDK power off and detach contact header. +} S7JD_PARAM_CONTACT; + + +// contactless smart card encoding +#define S7JD_CONTACTLESS 5 + +typedef struct { + BYTE mid; // module-id of contactless smart card encoder + BYTE reserved[8]; + SM70CB_CONTACTLESS pfncb; // callback function for contactless smart card encoding. + // SDK move the card to contactless position, power on and + // calls this callback function. + // after callback function SDK power off. +} S7JD_PARAM_CONTACTLESS; + + +// scan the image +#define S7JD_SCANIMAGE 6 + +typedef struct { + BYTE mid; // module-id of scanner + int dpi; // scanning dpi + int mode; // scanning color mode + int side; // scanning side + int opt; // option for scan + BYTE reserved[8]; + SM70CB_SCANIMAGE pfncb; // callback function for scan the image. + // SDK configure scanner, scan image and calls this callback function. +} S7JD_PARAM_SCANIMAGE; + +#define SCANIMAGE_OPT_TOP 0 // acquire top side result only +#define SCANIMAGE_OPT_BOTTOM 1 // acquire bottom side result only +#define SCANIMAGE_OPT_BOTH 2 // acquire both side results + + + +// scan the barcode +#define S7JD_SCANBARCODE 7 + +typedef struct { + BYTE mid; // module-id of scanner + int dpi; // scanning dpi + int mode; // scanning color mode + int side; // scanning side + int opt; // option for scan + BYTE reserved[8]; + SM70CB_SCANBARCODE pfncb; // callback function for scan the barcode. + // SDK configure scanner, scan barcodes and calls this callback function. +} S7JD_PARAM_SCANBARCODE; + +#define SCANBARCODE_OPT_TOP 0 // acquire top side result only +#define SCANBARCODE_OPT_BOTTOM 1 // acquire bottom side result only +#define SCANBARCODE_OPT_BOTH 2 // acquire both side results + + +// print +#define S7JD_PRINT 8 + +typedef struct { + BYTE mid; // module-id of printer + int page; // printing page + BYTE reserved[8]; + SM70CB_PRINT pfncb; // callback function for print a page. + // SDK move card to print position if necessary and calls this callback function. + // In print callback function, draw, make print data and send print data to printer. + // After callback function, SDK starts printing. +} S7JD_PARAM_PRINT; + + +// laminate +#define S7JD_LAMINATE 9 + +typedef struct { + BYTE mid; // module-id of laminator + int page; // laminating page + BYTE reserved[8]; + SM70CB_LAMINATE pfncb; // callback function for laminate a page. + // SDK laminates page and calls this callback function. +} S7JD_PARAM_LAMINATE; + + +// laminate +#define S7JD_USER 10 + +typedef struct { + BYTE mid; // module-id of user-defined work + int opt; // option + BYTE reserved[8]; + SM70CB_USER pfncb; // callback function for user-defined work. +} S7JD_PARAM_USER; + + + +typedef void * HJOBD; + +typedef int (WINAPI * Smart70_NewJobDescriptor)(HSMART70 handle, HJOBD * phjd, SM70CB_ERROR pfncbErr); +typedef int (WINAPI * Smart70_FreeJobDescriptor)(HSMART70 handle, HJOBD hjd); +typedef int (WINAPI * Smart70_AddJobItem)(HSMART70 handle, HJOBD hjd, int ji_type, void * ji_param); +typedef int (WINAPI * Smart70_AddJobItemMove)(HSMART70 handle, HJOBD hjd, BYTE from_mid, BYTE from_opt, BYTE to_mid, BYTE to_opt); +typedef int (WINAPI * Smart70_AddJobItemFlip)(HSMART70 handle, HJOBD hjd, BYTE from_mid, BYTE flip_mid, BYTE to_mid, BYTE opt); +typedef int (WINAPI * Smart70_AddJobItemMagnetic)(HSMART70 handle, HJOBD hjd, BYTE mid, int coer, SM70CB_MAGNETIC pfncb); +typedef int (WINAPI * Smart70_AddJobItemContact)(HSMART70 handle, HJOBD hjd, BYTE mid, SM70CB_CONTACT pfncb); +typedef int (WINAPI * Smart70_AddJobItemContactless)(HSMART70 handle, HJOBD hjd, BYTE mid, SM70CB_CONTACTLESS pfncb); +typedef int (WINAPI * Smart70_AddJobItemScanImage)(HSMART70 handle, HJOBD hjd, BYTE mid, int dpi, int mode, int side, int opt, SM70CB_SCANIMAGE pfncb); +typedef int (WINAPI * Smart70_AddJobItemScanBarcode)(HSMART70 handle, HJOBD hjd, BYTE mid, int dpi, int mode, int side, int opt, SM70CB_SCANBARCODE pfncb); +typedef int (WINAPI * Smart70_AddJobItemPrint)(HSMART70 handle, HJOBD hjd, BYTE mid, int page, SM70CB_PRINT pfncb); +typedef int (WINAPI * Smart70_AddJobItemLaminate)(HSMART70 handle, HJOBD hjd, BYTE mid, int page, SM70CB_LAMINATE pfncb); +typedef int (WINAPI * Smart70_AddJobItemUser)(HSMART70 handle, HJOBD hjd, BYTE mid, int opt, SM70CB_USER pfncb); +typedef int (WINAPI * Smart70_InsertJob)(HSMART70 handle, HJOBD hjd, int * pjobid); +typedef int (WINAPI * Smart70_ExGetDevParam2)(HSMART70 handle, BYTE mod, WCHAR* pw, int slot, int* pvalue, int nParams); +typedef int (WINAPI * Smart70_ExSetDevParam2)(HSMART70 handle, BYTE mod, WCHAR* pw, int slot, int* pvalue, int nParams); + +typedef int (WINAPI * Smart70_MagWrite)(HSMART70 handle, BYTE mod, BOOL bT1, WCHAR* szT1, BOOL bT2, WCHAR* szT2, BOOL bT3, WCHAR* szT3, BOOL bJIS, WCHAR* szJIS); +typedef int (WINAPI * Smart70_MagRead)(HSMART70 handle, BYTE mod, BOOL bT1, WCHAR* szT1, int nT1, BOOL bT2, WCHAR* szT2, int nT2, BOOL bT3, WCHAR* szT3, int nT3, BOOL bJIS, WCHAR* szJIS, int nJIS); + +// laser device manager +typedef int (WINAPI * Smart70_LaserConnect)(); +typedef int (WINAPI * Smart70_LaserDisconnect)(); +typedef int (WINAPI * Smart70_LaserCheckPort)(); + + +// draw function for support laser + +typedef struct { + BYTE page; + BYTE panel; + int x; + int y; + int cx; + int cy; + S70Border border; + S70BackGround back; +} LLINE, LRECT, LOVAL; + +typedef struct { + BYTE page; + BYTE panel; + int x; + int y; + int cx; + int cy; + S70Border border; + S70BackGround back; + int round; +} LRRECT; + +typedef struct { + BYTE page; + BYTE panel; + int x; + int y; + int cx; + int cy; + S70Border border; + S70BackGround back; + S70FontInfo font; + int align; + WCHAR* szText; +} LTEXT; + +typedef struct { + BYTE page; + BYTE panel; + int x; + int y; + int cx; + int cy; + S70Border border; + S70BackGround back; + WCHAR* szBarName; + int nSize; + COLORREF rgbBar; + WCHAR* szData; + WCHAR* szPost; + bool showString; + int opt1; + int opt2; +} LBAR; + +typedef struct { + BYTE page; + BYTE panel; + int x; + int y; + int cx; + int cy; + S70Border border; + S70BackGround back; + WCHAR* szFile; + BYTE scale; + BYTE align; +} LIMG; + +typedef struct { + BYTE page; + BYTE panel; + int x; + int y; + int cx; + int cy; + S70Border border; + S70BackGround back; + HBITMAP hbmp; + BYTE scale; + BYTE align; +} LBMP; + +typedef int (WINAPI * Smart70_LDrawLine )(HSMART70 handle, LLINE *pline, S70Laser *plaser, RECT* prc); +typedef int (WINAPI * Smart70_LDrawRect )(HSMART70 handle, LRECT *prect, S70Laser *plaser, RECT* prc); +typedef int (WINAPI * Smart70_LDrawOval )(HSMART70 handle, LOVAL *poval, S70Laser *plaser, RECT* prc); +typedef int (WINAPI * Smart70_LDrawRRect )(HSMART70 handle, LRRECT *prrc, S70Laser *plaser, RECT* prc); +typedef int (WINAPI * Smart70_LDrawText )(HSMART70 handle, LTEXT *ptext, S70Laser *plaser, RECT* prc); +typedef int (WINAPI * Smart70_LDrawBarcode )(HSMART70 handle, LBAR *pbar, S70Laser *plaser, RECT* prc); +typedef int (WINAPI * Smart70_LDrawImage )(HSMART70 handle, LIMG *pimg, S70Laser *plaser, RECT* prc); +typedef int (WINAPI * Smart70_LDrawBitmap )(HSMART70 handle, LBMP *pbmp, S70Laser *plaser, RECT* prc); + diff --git a/class/SmartErrCodes.h b/class/SmartErrCodes.h new file mode 100644 index 0000000..e6a54b3 --- /dev/null +++ b/class/SmartErrCodes.h @@ -0,0 +1,270 @@ +#pragma once + + + + +#define SM_SUCCESS 0x00000000 +#define SM_FAIL 0xFFFFFFFF // -1 + +// error code definition +#define SM_F_FOUNDNODEV 0x80000000 // there is no device to use. +#define SM_F_INVALIDDEVIDX 0x80000001 // index of device is out of bound. +#define SM_F_INVALIDBUFPOINTER 0x80000002 // invalid buffer pointer. (may be null) +#define SM_F_NOTEXISTDEV 0x80000003 // not exist device. (not connected device) +#define SM_F_INVALIDPARAM 0x80000004 // invalid parameter value. +#define SM_F_DEVOPENFAILED 0x80000005 // device open failed. for more information, use GetLastError API. +#define SM_F_DEVIO 0x80000006 // device io operation is failed. for more information, use GetLastError API. +#define SM_F_FOUNDNODRV 0x80000007 // not found driver or cannot acquire DEVMODE from driver. +#define SM_F_INVALIDHANDLE 0x80000008 // invalid handle value. +#define SM_F_CARDISINSIDE 0x80000009 // card is already inside of device. +#define SM_F_NOCARDISINSIDE 0x8000000A // no card is inside of device. +#define SM_F_HOPPEREMPTY 0x8000000B // no cards are in hopper. +#define SM_F_NOCARDONBOTH 0x8000000C // no card both hopper and inside of printer. +#define SM_F_WAITTIMEOUT 0x8000000D // timeout occured while wait... +#define SM_F_CASEOPEN 0x8000000E // case is opened. +#define SM_F_ERRORSTATUS 0x8000000F // current status has error flag. +#define SM_F_CARDIN 0x80000010 // card-in action is failed. +#define SM_F_CARDOUT 0x80000011 // card-out action is failed. +#define SM_F_CARDOUTBACK 0x80000012 // card-back-out action is failed. +#define SM_F_MOVE2MAG 0x80000013 // card move (to magnetic) is failed. +#define SM_F_MOVE2IC 0x80000014 // card move (to IC) is failed. +#define SM_F_MOVE2RF 0x80000015 // card move (to RF) is failed. +#define SM_F_MOVE2ROT 0x80000016 // card move (to Rotator) is failed. +#define SM_F_MOVE2DEV 0x80000017 // card move (from Rotator) is failed. +#define SM_F_MAGRW 0x80000018 // magnetic read/write is failed, +#define SM_F_NOPRINTDATA 0x80000019 // printer failed to receive print data. +#define SM_F_PRINT 0x8000001A // print failed. +#define SM_F_SEEKRIBBON 0x8000001B // seek-ribbon is failed. +#define SM_F_MOVERIBBON 0x8000001C // move-ribbon is failed. +#define SM_F_EMPTYRIBBON 0x8000001D // ribbon is empty. +#define SM_F_ICHUP 0x8000001E // ic-head up failed. +#define SM_F_ICHDN 0x8000001F // ic-head down failed. +#define SM_F_ROTTOP 0x80000020 // rotate to top is failed. +#define SM_F_ROTBOTTOM 0x80000021 // rotate to bottom is failed. +#define SM_F_REQNOMAGTRACK 0x80000022 // requested no magnetic track. +#define SM_F_REQMULTIMAGTRACK 0x80000023 // requested two or more magnetic tracks in XXXGetBuffer function. +#define SM_F_FILENOTFOUND 0x80000024 // file not found. +#define SM_F_FIELDNOTFOUND 0x80000025 // field is not exist. +#define SM_F_IMAGELOAD 0x80000026 // failed to load image. +#define SM_F_CREATEDC 0x80000027 // dc creation is failed. +#define SM_F_VERIFYDRV 0x80000028 // driver verification is failed. may the driver is not ours. +#define SM_F_SPOOLING 0x80000029 // failed to make spool data. (includes StartDoc, StartPage, EndPage and EndDoc) +#define SM_F_DEVNOTOPENED 0x8000002A // request access to ic/rf module without opening the printer device. +#define SM_F_USEDBYOTHER 0x8000002B // usb is temporarily blocked by other. +#define SM_F_SOCKETCREATE 0x8000002C // socket creation failed. +#define SM_F_SOCKETCONNECT 0x8000002D // socket connection failed. +#define SM_F_SSLINIT 0x8000002E // SSL initialization failed. +#define SM_F_SSLCREATE 0x8000002F // SSL creation failed. +#define SM_F_SSLCONNECT 0x80000030 // SSL connection is failed. +#define SM_F_RESERVED 0x80000031 // host is already reserved status. +#define SM_F_INVALIDSOCKET 0x80000032 // socket fd is invalid. +#define SM_F_LESSSENDED 0x80000033 // packet is sended less than requested. +#define SM_F_LESSRECVED 0x80000034 // packet is received less than requested. +#define SM_F_SOCKETERROR 0x80000035 // socket error occured. for more information, use WSAGetLastError API. +#define SM_F_INVALIDPACKET 0x80000036 // packet is not valid. (include signature is not matched or else ...) +#define SM_F_PACKETSEQDIFFER 0x80000037 // packet sequence/id is not equaled when receive. +#define SM_F_PACKETFLAGNOREPLY 0x80000038 // reply flag is not setted on received packet. +#define SM_F_PACKETFLAGHEADER 0x80000039 // sent packet header is incorrect. +#define SM_F_PACKETFLAGARGUMENT 0x8000003A // argument is not valid on sent packet. +#define SM_F_PACKETFLAGEXE 0x8000003B // execution error flag is setted. +#define SM_F_PACKETFLAGBADCMD 0x8000003C // bad command flag is setted. +#define SM_F_PACKETFLAGINIT 0x8000003D // ... +#define SM_F_PACKETFLAGHANDLE 0x8000003E // invalid handle is given. +#define SM_F_FILEOPEN 0x8000003F // file open failed... +#define SM_F_FILEREAD 0x80000040 // read from file is failed. +#define SM_F_NOTSUPPORTYET 0x80000041 // not support yet... +#define SM_F_INSUFFICIENTBUF 0x80000042 // insufficient buffer. + +// IC error area... +#define SM_F_ICESTABLISH 0x80000043 // SCardEstablish failed. for more information, use GetLastError. +#define SM_F_ICLISTREADER 0x80000044 // SCardListReaders failed. for more information, use GetLastError. +#define SM_F_ICCONNECT 0x80000045 // SCardConnect failed. for more information, use GetLastError. +#define SM_F_ICGETSTATUS 0x80000046 // SCardStatus failed. for more information, use GetLastError. +#define SM_F_ICDISCONNECT 0x80000047 // SCardDisconenct failed. for more information, use GetLastError. +#define SM_F_ICRELEASE 0x80000048 // SCardReleaseContext failed. for more information, use GetLastError. + +// RF error area... +#define SM_F_RFINVALIDSETTING 0x80000049 // setting value is incorrect. (i.e., RF Port, ...) +#define SM_F_RFOPEN 0x8000004A // port open failed. +#define SM_F_RFCONNECT 0x8000004B // connect failed. +// 0x80000050 NOTE: LEAVE THIS. PLEASE. +#define SM_F_RFALREADYOPENED 0x80000051 // open the port that already opened. +#define SM_F_RFOPENFAIL 0x80000052 // port open failed. +#define SM_F_RFINVALIDCOMMPORT 0x80000053 // invalid COM port number. +#define SM_F_RFFAILGETCOMMSTATE 0x80000054 // error of communication setting. +#define SM_F_RFFAILSETCOMMSTATE 0x80000055 // error of communication setting. +#define SM_F_RFFAILCOMMIOTHREAD 0x80000056 // error of communication setting. +#define SM_F_RFPARAMETER 0x80000057 // incorrect function parameter. +#define SM_F_RFCOMMSTATE 0x80000150 // . +#define SM_F_RFCOMMSTATEPROCESS 0x80000151 // running non-blocking mode works. +#define SM_F_RFCOMMSTATEFINISH 0x8000015F // finished non-blocking mode works. +#define SM_F_RFCOMMSTATEERROR 0x800001D0 // . +#define SM_F_RFCOMMSTATEERRORWRITE 0x800001D1 // data transmition error. +#define SM_F_RFCOMMSTATEERRORFORMAT 0x800001D2 // invalid received data format. +#define SM_F_RFCOMMSTATEERRORLENGTH 0x800001D3 // incorrect data length of received data length. +#define SM_F_RFCOMMSTATEERRORLRC 0x800001D4 // error of received data's LRC. +#define SM_F_RFCOMMSTATEERRORTIMEOUT 0x800001D5 // receiving timeout. + +// additional error codes... +#define SM_F_INVALIDNAME 0x80000200 // invalid or not supporting barcode name is given. +#define SM_F_ICDLLLOADFAILED 0x80000201 // ic(contact smartcard) dll load failed. // DEPRECATED. +#define SM_F_RFDLLLOADFAILED 0x80000202 // rf(contactless smartcard) dll load failed. // DEPRECATED. +#define SM_F_OBJECTNOTFOUND 0x80000203 // object is not exist. +#define SM_F_SUBDLLLOADFAILED 0x80000204 // sub-dll load failed... (ie., devconlib.dll, PIR_D02B.dll, ...) +#define SM_F_CONFIGFILEFAILED 0x80000205 // configuration file load/save failed... + +#define SM_F_OVERHEATED 0x80000206 // thermal-head is overheated... +#define SM_F_NOPRINTHREAD 0x80000207 // no thermal-head + +#define SM_F_LOWERVERSION 0x80000208 // SmartCommCl is lower than SmartCommon +#define SM_F_HIGHERVERSION 0x80000209 // SmartCommCl is higher than SmartCommon +#define SM_F_OLDSERVER 0x8000020A // SmartCommonService is old. +#define SM_F_VERSIONNOTMATCH 0x8000020B // version is not matched. + +#define SM_F_CHANGEPASSWORD 0x8000020C // changing root/user password is failed. +#define SM_F_UNLOCK 0x8000020D // unlock is failed. +#define SM_F_LOCK 0x8000020E // lock is failed. +#define SM_F_FAILEDTOSET 0x8000020F // failed to printer set.... + +#define SM_F_FILESIZEZERO 0x80000220 // required file size is 0. +#define SM_F_DEPRECATED 0x80000221 // that function is deprecated. +#define SM_F_SERIALNORESPONSE 0x80000222 // not responding for serial command... + + +#define SM_F_NETAUTHFAIL 0x80000300 // Network Authentification failed. +#define SM_F_NETREBOOTERROR 0x80000301 // Network Reboot command failed. +#define SM_F_NETRELOADERROR 0x80000302 // Network Reload command failed. +#define SM_F_NETRESETERROR 0x80000303 // Network Reset command failed. +#define SM_F_NETUPGRADEERROR 0x80000304 // Network upgrade command failed. +#define SM_F_NETGETSYSCFGERROR 0x80000305 // Network Get System Config command failed. +#define SM_F_NETSETSYSCFGERROR 0x80000306 // Network Set System Config command failed. +#define SM_F_NETGETSVCCFGERROR 0x80000307 // Network Get Service Config command failed. +#define SM_F_NETSETSVCCFGERROR 0x80000308 // Network Set Service Config command failed. +#define SM_F_NETLISTUSERERROR 0x80000309 // Network List User command failed. +#define SM_F_NETADDUSERERROR 0x8000030A // Network Add User command failed. +#define SM_F_NETDELUSERERROR 0x8000030B // Network Delete User command failed. +#define SM_F_NETPASSWDUSERERROR 0x8000030C // Network Change User Password command failed. + + +// SMART-70 Extended Error Codes... +#define SM_F_PREEMPTION 0x80000350 // Preemption Failed. Other Program Already have the Preemption. +#define SM_F_CARDMOVE 0x80000351 // Card Move (among the Modules) is failed. +#define SM_F_MOVEPOSITION 0x80000352 // Card Positining Move is failed. +#define SM_F_SETENCCONFIG 0x80000353 // Change Encoder Config is failed. +#define SM_F_ENCODING 0x80000354 // Encoding failed. +#define SM_F_NOTEXISTMODULE 0x80000355 // Module does not exist. +#define SM_F_MODULERESERVED 0x80000356 // Module is reserved by other job. +#define SM_F_MODULEOCUPIED 0x80000357 // Module is ocupied by other job. +#define SM_F_NOTEXISTJOB 0x80000358 // Specified Job Id does not exit. Maybe Wrong Job id or finished already. +#define SM_F_MODULEBUSY 0x80000359 // Module is busy +#define SM_F_MODULEHASERROR 0x8000035A // Module has error +#define SM_F_CANCELBYUSER 0x8000035B // Printing Job is Canceled by User. +#define SM_F_EMPTYDATA 0x8000035C // There is No Encoded Data. +#define SM_F_LAMINATE 0x8000035D // error while laminating +#define SM_W_HOLDINGPRINTDATA 0x8000035E // not an error. have print data but not printing. +#define SM_F_INVALIDMODULEID 0x8000035F // invalid module id. +#define SM_F_STACKERFULL 0x80000360 // stacker is full. +#define SM_F_MODULEWEAKRESERVED 0x80000361 // Module is weak-reserved by other job. +#define SM_F_OBJINFORBIDDENAREA 0x80000362 // laser engraving object(s) is(are) in not allowed zone. + +#define SM_F_UNKNOWNCMD 0x80000381 // given command is unknown. + +// 485 Packet Error Code +#define SM7_F_PACKETINVALID 0x80000400 // packet is invalid (not our format). +#define SM7_F_PACKETSHORT 0x80000401 // data +#define SM7_F_PACKETCRC 0x80000402 // different crc +#define SM7_F_EMPTYHOPPER 0x80000403 // hopper is empty +#define SM7_F_ERRORLASTCMD 0x80000404 // error came from last command... + + +// smartcard error codes... +#define SM_F_SCARD_F_INTERNAL_ERROR SCARD_F_INTERNAL_ERROR // 0x80100001 // An internal consistency check failed. +#define SM_F_SCARD_E_CANCELLED SCARD_E_CANCELLED // 0x80100002 // The action was cancelled by an SCardCancel request. +#define SM_F_SCARD_E_INVALID_HANDLE SCARD_E_INVALID_HANDLE // 0x80100003 // The supplied handle was invalid. +#define SM_F_SCARD_E_INVALID_PARAMETER SCARD_E_INVALID_PARAMETER // 0x80100004 // One or more of the supplied parameters could not be properly interpreted. +#define SM_F_SCARD_E_INVALID_TARGET SCARD_E_INVALID_TARGET // 0x80100005 // Registry startup information is missing or invalid. +#define SM_F_SCARD_E_NO_MEMORY SCARD_E_NO_MEMORY // 0x80100006 // Not enough memory available to complete this command. +#define SM_F_SCARD_F_WAITED_TOO_LONG SCARD_F_WAITED_TOO_LONG // 0x80100007 // An internal consistency timer has expired. +#define SM_F_SCARD_E_INSUFFICIENT_BUFFER SCARD_E_INSUFFICIENT_BUFFER // 0x80100008 // The data buffer to receive returned data is too small for the returned data. +#define SM_F_SCARD_E_UNKNOWN_READER SCARD_E_UNKNOWN_READER // 0x80100009 // The specified reader name is not recognized. +#define SM_F_SCARD_E_TIMEOUT SCARD_E_TIMEOUT // 0x8010000A // The user-specified timeout value has expired. +#define SM_F_SCARD_E_SHARING_VIOLATION SCARD_E_SHARING_VIOLATION // 0x8010000B // The smart card cannot be accessed because of other connections outstanding. +#define SM_F_SCARD_E_NO_SMARTCARD SCARD_E_NO_SMARTCARD // 0x8010000C // The operation requires a Smart Card, but no Smart Card is currently in the device. +#define SM_F_SCARD_E_UNKNOWN_CARD SCARD_E_UNKNOWN_CARD // 0x8010000D // The specified smart card name is not recognized. +#define SM_F_SCARD_E_CANT_DISPOSE SCARD_E_CANT_DISPOSE // 0x8010000E // The system could not dispose of the media in the requested manner. +#define SM_F_SCARD_E_PROTO_MISMATCH SCARD_E_PROTO_MISMATCH // 0x8010000F // The requested protocols are incompatible with the protocol currently in use with the smart card. +#define SM_F_SCARD_E_NOT_READY SCARD_E_NOT_READY // 0x80100010 // The reader or smart card is not ready to accept commands. +#define SM_F_SCARD_E_INVALID_VALUE SCARD_E_INVALID_VALUE // 0x80100011 // One or more of the supplied parameters values could not be properly interpreted. +#define SM_F_SCARD_E_SYSTEM_CANCELLED SCARD_E_SYSTEM_CANCELLED // 0x80100012 // The action was cancelled by the system, presumably to log off or shut down. +#define SM_F_SCARD_F_COMM_ERROR SCARD_F_COMM_ERROR // 0x80100013 // An internal communications error has been detected. +#define SM_F_SCARD_F_UNKNOWN_ERROR SCARD_F_UNKNOWN_ERROR // 0x80100014 // An internal error has been detected, but the source is unknown. +#define SM_F_SCARD_E_INVALID_ATR SCARD_E_INVALID_ATR // 0x80100015 // An ATR obtained from the registry is not a valid ATR string. +#define SM_F_SCARD_E_NOT_TRANSACTED SCARD_E_NOT_TRANSACTED // 0x80100016 // An attempt was made to end a non-existent transaction. +#define SM_F_SCARD_E_READER_UNAVAILABLE SCARD_E_READER_UNAVAILABLE // 0x80100017 // The specified reader is not currently available for use. +#define SM_F_SCARD_P_SHUTDOWN SCARD_P_SHUTDOWN // 0x80100018 // The operation has been aborted to allow the server application to exit. +#define SM_F_SCARD_E_PCI_TOO_SMALL SCARD_E_PCI_TOO_SMALL // 0x80100019 // The PCI Receive buffer was too small. +#define SM_F_SCARD_E_READER_UNSUPPORTED SCARD_E_READER_UNSUPPORTED // 0x8010001A // The reader driver does not meet minimal requirements for support. +#define SM_F_SCARD_E_DUPLICATE_READER SCARD_E_DUPLICATE_READER // 0x8010001B // The reader driver did not produce a unique reader name. +#define SM_F_SCARD_E_CARD_UNSUPPORTED SCARD_E_CARD_UNSUPPORTED // 0x8010001C // The smart card does not meet minimal requirements for support. +#define SM_F_SCARD_E_NO_SERVICE SCARD_E_NO_SERVICE // 0x8010001D // The Smart card resource manager is not running. +#define SM_F_SCARD_E_SERVICE_STOPPED SCARD_E_SERVICE_STOPPED // 0x8010001E // The Smart card resource manager has shut down. +#define SM_F_SCARD_E_UNEXPECTED SCARD_E_UNEXPECTED // 0x8010001F // An unexpected card error has occurred. +#define SM_F_SCARD_E_ICC_INSTALLATION SCARD_E_ICC_INSTALLATION // 0x80100020 // No Primary Provider can be found for the smart card. +#define SM_F_SCARD_E_ICC_CREATEORDER SCARD_E_ICC_CREATEORDER // 0x80100021 // The requested order of object creation is not supported. +#define SM_F_SCARD_E_UNSUPPORTED_FEATURE SCARD_E_UNSUPPORTED_FEATURE // 0x80100022 // This smart card does not support the requested feature. +#define SM_F_SCARD_E_DIR_NOT_FOUND SCARD_E_DIR_NOT_FOUND // 0x80100023 // The identified directory does not exist in the smart card. +#define SM_F_SCARD_E_FILE_NOT_FOUND SCARD_E_FILE_NOT_FOUND // 0x80100024 // The identified file does not exist in the smart card. +#define SM_F_SCARD_E_NO_DIR SCARD_E_NO_DIR // 0x80100025 // The supplied path does not represent a smart card directory. +#define SM_F_SCARD_E_NO_FILE SCARD_E_NO_FILE // 0x80100026 // The supplied path does not represent a smart card file. +#define SM_F_SCARD_E_NO_ACCESS SCARD_E_NO_ACCESS // 0x80100027 // Access is denied to this file. +#define SM_F_SCARD_E_WRITE_TOO_MANY SCARD_E_WRITE_TOO_MANY // 0x80100028 // The smartcard does not have enough memory to store the information. +#define SM_F_SCARD_E_BAD_SEEK SCARD_E_BAD_SEEK // 0x80100029 // There was an error trying to set the smart card file object pointer. +#define SM_F_SCARD_E_INVALID_CHV SCARD_E_INVALID_CHV // 0x8010002A // The supplied PIN is incorrect. +#define SM_F_SCARD_E_UNKNOWN_RES_MNG SCARD_E_UNKNOWN_RES_MNG // 0x8010002B // An unrecognized error code was returned from a layered component. +#define SM_F_SCARD_E_NO_SUCH_CERTIFICATE SCARD_E_NO_SUCH_CERTIFICATE // 0x8010002C // The requested certificate does not exist. +#define SM_F_SCARD_E_CERTIFICATE_UNAVAILABLE SCARD_E_CERTIFICATE_UNAVAILABLE // 0x8010002D // The requested certificate could not be obtained. +#define SM_F_SCARD_E_NO_READERS_AVAILABLE SCARD_E_NO_READERS_AVAILABLE // 0x8010002E // Cannot find a smart card reader. +#define SM_F_SCARD_E_COMM_DATA_LOST SCARD_E_COMM_DATA_LOST // 0x8010002F // A communications error with the smart card has been detected. Retry the operation. +#define SM_F_SCARD_E_NO_KEY_CONTAINER SCARD_E_NO_KEY_CONTAINER // 0x80100030 // The requested key container does not exist on the smart card. +#define SM_F_SCARD_E_SERVER_TOO_BUSY SCARD_E_SERVER_TOO_BUSY // 0x80100031 // The Smart card resource manager is too busy to complete this operation. + +// These are warning codes. + +#define SM_F_SCARD_W_UNSUPPORTED_CARD SCARD_W_UNSUPPORTED_CARD // 0x80100065 +#define SM_F_SCARD_W_UNRESPONSIVE_CARD SCARD_W_UNRESPONSIVE_CARD // 0x80100066 // The smart card is not responding to a reset. +#define SM_F_SCARD_W_UNPOWERED_CARD SCARD_W_UNPOWERED_CARD // 0x80100067 // Power has been removed from the smart card, so that further communication is not possible. +#define SM_F_SCARD_W_RESET_CARD SCARD_W_RESET_CARD // 0x80100068 // The smart card has been reset, so any shared state information is invalid. +#define SM_F_SCARD_W_REMOVED_CARD SCARD_W_REMOVED_CARD // 0x80100069 // The smart card has been removed, so that further communication is not possible. +#define SM_F_SCARD_W_SECURITY_VIOLATION SCARD_W_SECURITY_VIOLATION // 0x8010006A // Access was denied because of a security violation. +#define SM_F_SCARD_W_WRONG_CHV SCARD_W_WRONG_CHV // 0x8010006B // The card cannot be accessed because the wrong PIN was presented. +#define SM_F_SCARD_W_CHV_BLOCKED SCARD_W_CHV_BLOCKED // 0x8010006C // The card cannot be accessed because the maximum number of PIN entry attempts has been reached. +#define SM_F_SCARD_W_EOF SCARD_W_EOF // 0x8010006D // The end of the smart card file has been reached. +#define SM_F_SCARD_W_CANCELLED_BY_USER SCARD_W_CANCELLED_BY_USER // 0x8010006E // The action was cancelled by the user. +#define SM_F_SCARD_W_CARD_NOT_AUTHENTICATED SCARD_W_CARD_NOT_AUTHENTICATED // 0x8010006F // No PIN was presented to the smart card. + + + +// SMART-70X error codes. + +#define SL_SUCCESS SM_SUCCESS +#define SL_F_EZCADRUN 1 // Find EZCAD running +#define SL_F_NOFINDCFGFILE 2 // Can not find EZCAD.CFG +#define SL_F_FAILEDOPEN 3 // Open LMC1 board failed +#define SL_F_NODEVICE 4 // Can not find valid lmc1 device +#define SL_F_HARDVER 5 // Lmc1’s version is error. +#define SL_F_DEVCFG 6 // Can not find configuration files +#define SL_F_STOPSIGNAL 7 // Alarm signal +#define SL_F_USERSTOP 8 // User stops +#define SL_F_UNKNOW 9 // Unknown error +#define SL_F_OUTTIME 10 // Overtime +#define SL_F_NOINITIAL 11 // Un-initialized +#define SL_F_READFILE 12 // Read file error +#define SL_F_OWENWNDNULL 13 // Window handle is NULL +#define SL_F_NOFINDFONT 14 // Can not find designated font +#define SL_F_PENNO 15 // Wrong pen number +#define SL_F_NOTTEXT 16 // Object is not text +#define SL_F_SAVEFILE 17 // Save file failed +#define SL_F_NOFINDENT 18 // Can not find designated object +#define SL_F_STATUE 19 // Can not run the operation in current state +#define SL_F_LOADLIBRARY 40 // Can not load laser library +#define SL_F_IMAGEMAKE 43 // Image Make Error