can some one tell how can convert this class to c# class
or convert it to dll for using in c# app
[ATTACH]IRIBIO_API_TEST SOURCE.zip[/ATTACH]
or convert it to dll for using in c# app
Code:
// FTDI_loadDlg.cpp : ±¸اِ ئؤہد
//
#include "dos.h"
#include "stdafx.h"
#include "IRIBIO_API_TEST.h"
#include "IRIBIO_API_TESTDlg.h"
#include "return_code.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////////////////////////////
//DECLARATION
//////////////////////////////////////////////////////////////////////////////////////////////
//define
#define TRANSFER_DATA_SIZE 4
#define ID_LENGTH_SIZE 20
#define CHECKSUM_DATA_SIZE 27
#define TOTAL_PROTOCOL_SIZE 32
#define TOTAL_PERSON_SIZE 150
#define ID_STR_LENGTH_SIZE 21
#define MAX_TEMPLATE_SIZE 5000
#define MAX_SIZE 10000
//string length need one byte more than ID_LENGTH_SIZE to record '\0'
#define USB_NOT_FOUND false
#define USB_FOUND true
typedef unsigned char ReturnCode;
//data structure
typedef struct RxBufferReturnData //default protocol
{
unsigned char RxTemplateData[MAX_SIZE];
int RxTemplateLength;
unsigned char RxDataIDTotal[TOTAL_PERSON_SIZE*ID_LENGTH_SIZE];
unsigned char RxDataID[ID_LENGTH_SIZE];
unsigned char RxDataIDTotalLength;
ReturnCode RxCode;
}ReturnData;
//global variable
ReturnData RxData={0x00};
char g_ID[256];
char g_FilePath[256];
char null_ID[256];
unsigned char FileName[256];
char ReadBuffer[MAX_SIZE] = {0};
bool g_USBStatus = USB_NOT_FOUND;
bool UsbFoundMessageOutOnce = false;
bool g_USBStatusMessageOutOnce = false;
bool g_hEvent = false;
bool g_GetTemplate = false;
bool g_Deletion = false;
HANDLE hEvent = NULL;
HANDLE hThread = NULL;
DWORD g_WaitForSingleObjectStatus;
bool g_WaitForSingleObjectStart = false;
bool g_Cancelation = false;
bool g_ContinueCommnad = false;
bool g_DoubleRegister = false;
bool g_RegProc = false;
bool g_CertProc = false;
//CRITICAL_SECTION cs;
//function declaration
void GetID(char *g_ID);//get ID from CEdit
void ResultMessageTextOut(ReturnCode DlgRCode);//return code switch
void MyAfxMessageBox( char* str );//for logging
void PutStaticMessage(int DefinedMSG);//text handle by using AfxGetApp()
void PutList();//get ID data from DLL
int SaveTemplate(ReturnData RxData);
int ReadTemplate(char *g_ID);
void MemoryDumpData(ReturnData *Src, ReturnData *Dst);
UINT EventHandlerFunc(LPVOID lpParam);
//CALLBACK
//declaration function pointer
typedef void(*FUNCP)(ReturnData *);
typedef void(*UsbFUNCP)(bool);
//typedef void(__stdcall *FUNCP)(ReturnData *);
//typedef void(__stdcall *UsbFUNCP)(bool);
//call back function declaration
void RxBufferReturnDataCallBack(ReturnData *);
void RxBufferReturnDataCallBackEx(ReturnData *);
void DllUsbCheckCallBack(bool g_USBStatus);
//thread
unsigned __stdcall WaitThread(void *vpCallback);
//import method form DLL
extern "C" __declspec(dllimport) void _stdcall IrisInit();
extern "C" __declspec(dllimport) void _stdcall IrisRegister(FUNCP pCallBack = NULL, char *RxTxID = NULL);
extern "C" __declspec(dllimport) void _stdcall IrisRegisterEx(FUNCP pCallback = NULL, char *RxTxID = NULL);
extern "C" __declspec(dllimport) void _stdcall IrisMsgBoxOk();
extern "C" __declspec(dllimport) void _stdcall IrisCertify(FUNCP pCallBack = NULL, char *RxTxID = NULL);
extern "C" __declspec(dllimport) void _stdcall IrisIDDelete(FUNCP pCallBack = NULL, char *RxTxID = NULL);
extern "C" __declspec(dllimport) void _stdcall IrisCancel(FUNCP pCallBack = NULL);
extern "C" __declspec(dllimport) void _stdcall IrisIDSave(FUNCP pCallBack = NULL);
extern "C" __declspec(dllimport) void _stdcall IrisGetIDList(FUNCP pCallBack = NULL);
extern "C" __declspec(dllimport) void _stdcall IrisGetTemplate(FUNCP pCallBack = NULL, char *RxTxID = NULL);
extern "C" __declspec(dllimport) void _stdcall IrisPutTemplate(FUNCP pCallBack = NULL, char *RxTxID = NULL, ReturnData *TxData = NULL);
//extern "C" __declspec(dllimport) void _stdcall IrisLampOn();
extern "C" __declspec(dllimport) void _stdcall IrisUSBCheck(UsbFUNCP pUsbCallBack = NULL);
extern "C" __declspec(dllimport) void _stdcall IrisModuleOpen();
extern "C" __declspec(dllimport) void _stdcall IrisModuleClose();
//log file
#define LOGFILE_PATH "Debug.txt"
char debugMsg[100];
static bool g_MyMsg = true;
void LogFileOut(char *LogFile, unsigned char *data);
#define API_DEBUG
#define ID_VERIFY
/////////////////////////////////////////////////////////////////////////////////////////////////
class CAboutDlg : public CDialog
{
public:
CAboutDlg();
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ءِ؟ّہش´د´ظ.
// ±¸اِہش´د´ظ.
protected:
DECLARE_MESSAGE_MAP()
};
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
END_MESSAGE_MAP()
// CFTDI_loadDlg ´ëب* »َہع
CFTDI_loadDlg::CFTDI_loadDlg(CWnd* pParent /*=NULL*/)
: CDialog(CFTDI_loadDlg::IDD, pParent)
{
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
void CFTDI_loadDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
DDX_Control(pDX, ID_STATUS_LST, m_StatusInfo);
DDX_Control(pDX, IDC_ID_EDT, m_ID);
}
BEGIN_MESSAGE_MAP(CFTDI_loadDlg, CDialog)
ON_WM_SYSCOMMAND()
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
//}}AFX_MSG_MAP
ON_BN_CLICKED(IDC_REGISTRATION_BTN, &CFTDI_loadDlg::OnBnClickedRegistrationBtn)
ON_BN_CLICKED(IDC_CERTIFICATION_BTN, &CFTDI_loadDlg::OnBnClickedCertificationBtn)
ON_BN_CLICKED(IDC_SAVE_BTN, &CFTDI_loadDlg::OnBnClickedSaveBtn)
ON_BN_CLICKED(IDC_CANCEL_BTN, &CFTDI_loadDlg::OnBnClickedCancelBtn)
ON_BN_CLICKED(IDC_DELETE_BTN, &CFTDI_loadDlg::OnBnClickedDeleteBtn)
//ON_BN_CLICKED(IDC_LAMP_BTN, &CFTDI_loadDlg::OnBnClickedLampBtn)
ON_BN_CLICKED(IDC_LIST_BTN, &CFTDI_loadDlg::OnBnClickedListBtn)
ON_BN_CLICKED(IDC_CLOSE_BTN, &CFTDI_loadDlg::OnBnClickedCloseBtn)
ON_LBN_SELCHANGE(ID_STATUS_LST, &CFTDI_loadDlg::OnLbnSelchangeStatusLst)
ON_BN_CLICKED(IDC_GET_IRIS_BTN, &CFTDI_loadDlg::OnBnClickedGetIrisBtn)
ON_BN_CLICKED(IDC_PUT_IRIS_BTN, &CFTDI_loadDlg::OnBnClickedPutIrisBtn)
ON_BN_CLICKED(IDC_REG_PROCESS_BTN, &CFTDI_loadDlg::OnBnClickedRegProcessBtn)
ON_BN_CLICKED(IDC_CERT_PROCESS_BTN, &CFTDI_loadDlg::OnBnClickedIDProcessBtn)
ON_BN_CLICKED(IDC_PORT_OPEN_BTN, &CFTDI_loadDlg::OnBnClickedPortOpenBtn)
ON_BN_CLICKED(IDC_PORT_CLOSE_BTN, &CFTDI_loadDlg::OnBnClickedPortCloseBtn)
END_MESSAGE_MAP()
// CFTDI_loadDlg ¸ق½أءِ أ³¸®±â
BOOL CFTDI_loadDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// ½أ½؛إغ ¸ق´؛؟، "ء¤؛¸..." ¸ق´؛ ا׸ٌہ» أك°،اص´د´ظ.
// ہج ´ëب* »َہعہا ¾ئہجؤـہ» ¼³ء¤اص´د´ظ. ہہ؟ë اء·خ±×·¥ہا ءض أ¢ہج ´ëب* »َہع°، ¾ئ´ز °و؟ى؟،´آ
// اء·¹ہس؟ِإ©°، ہج ہغ¾÷ہ» ہعµ؟ہ¸·خ ¼ِاàاص´د´ظ.
SetIcon(m_hIcon, TRUE); // إ« ¾ئہجؤـہ» ¼³ء¤اص´د´ظ.
SetIcon(m_hIcon, FALSE); // ہغہ؛ ¾ئہجؤـہ» ¼³ء¤اص´د´ظ.
//init module
//IrisInit();
PutStaticMessage(MESSAGE_WELCOME);
IrisUSBCheck(&DllUsbCheckCallBack);
hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
hThread = AfxBeginThread(EventHandlerFunc, NULL);
//InitializeCriticalSection(&cs);
return TRUE; // ئ÷ؤ؟½؛¸¦ ؤءئ®·ر؟، ¼³ء¤ادءِ ¾تہ¸¸é TRUE¸¦ ¹فب¯اص´د´ظ.
}
void CFTDI_loadDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
CDialog::OnSysCommand(nID, lParam);
}
// ´ëب* »َہع؟، أض¼زب* ´ـأك¸¦ أك°،از °و؟ى ¾ئہجؤـہ» ±×¸®·ء¸é
// ¾ئ·، ؤعµه°، ات؟ناص´د´ظ. ¹®¼*/؛ن ¸ًµ¨ہ» »ç؟ëاد´آ MFC ہہ؟ë اء·خ±×·¥ہا °و؟ى؟،´آ
// اء·¹ہس؟ِإ©؟،¼* ہج ہغ¾÷ہ» ہعµ؟ہ¸·خ ¼ِاàاص´د´ظ.
void CFTDI_loadDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // ±×¸®±â¸¦ ہ§ار µً¹ظہج½؛ ؤءإط½؛ئ®
SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
// إ¬¶َہج¾ًئ® »ç°¢اü؟،¼* ¾ئہجؤـہ» °،؟îµ¥؟، ¸آأن´د´ظ.
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// ¾ئہجؤـہ» ±×¸³´د´ظ.
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}
// »ç؟ëہع°، أض¼زب*µب أ¢ہ» ²ô´آ µ؟¾ب؟، ؤ؟¼*°، ا¥½أµاµµ·د ½أ½؛إغ؟،¼*
// ہج اش¼ِ¸¦ ب£أâاص´د´ظ.
HCURSOR CFTDI_loadDlg::OnQueryDragIcon()
{
return static_cast<HCURSOR>(m_hIcon);
}
//////////////////////////////////////////////////////////////////////////////////////////////
//TEXT OUT MESSAGE TO CSTATIC
//////////////////////////////////////////////////////////////////////////////////////////////
void PutStaticMessage(int DefinedMSG)
{
CString StrCode;
CString StrCodeWithID;
StrCode = (CString)DialogMessageList[DefinedMSG];
CStatic *pCStatic;
CListBox *pCListBox;
CWinApp *pWinApp = AfxGetApp();
CWnd *pCWnd = pWinApp->GetMainWnd();
pCStatic = (CStatic *)pCWnd->GetDlgItem(IDC_MESSAGE_STATIC);
pCListBox = (CListBox *)pCWnd->GetDlgItem(ID_STATUS_LST);
if(DefinedMSG == MESSAGE_IS_NOT_REGISTERED || DefinedMSG == MESSAGE_IS_REGISTERED
|| DefinedMSG == MESSAGE_IS_NOT_CERTIFICATED || DefinedMSG == MESSAGE_IS_CERTIFICATED)
{
char Temp[256];
char Temp2[256];
int TempLength;
int TempLength2;
unsigned char ReturnID[ID_STR_LENGTH_SIZE];
memset(ReturnID,'\0',ID_STR_LENGTH_SIZE);
memcpy(ReturnID,RxData.RxDataID,sizeof(RxData.RxDataID));
//ReturnID[strlen((const char *)RxData.RxDataID)+1] = '\0';
//to make ReturnID STRING type, adding NULL to end of string
TempLength = 9 + strlen((const char *)ReturnID)+strlen(DialogMessageList[DefinedMSG]);
TempLength2 = strlen(DialogMessageList[DefinedMSG]);
//////memory reset
memset(Temp,NULL,TempLength);
memset(Temp2,NULL,TempLength2);
//
memcpy(Temp2,&DialogMessageList[DefinedMSG],TempLength2);
Temp2[strlen(DialogMessageList[DefinedMSG])] = '\0';
sprintf(Temp,"'%s' is %s",(const char *)ReturnID,Temp2);
StrCodeWithID = (LPCSTR)(LPSTR)Temp;
pCStatic->SetWindowText(StrCodeWithID);
}
else
{
pCStatic->SetWindowText(StrCode);
if(DefinedMSG == MESSAGE_DATABASE_EMPTY)
{
pCListBox->ResetContent();
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
//TEXT OUT ID LIST TO CLISTBOX
//////////////////////////////////////////////////////////////////////////////////////////////
void PutList()
{
USES_CONVERSION;
LPWSTR Target;
CListBox *pCListBox;
unsigned char IDstr[ID_STR_LENGTH_SIZE];
CWinApp *p_WinApp = AfxGetApp();
CWnd *pCWnd = p_WinApp->GetMainWnd();
pCListBox = (CListBox *)pCWnd->GetDlgItem(ID_STATUS_LST);
pCListBox->ResetContent();
for(int i=0;i<RxData.RxDataIDTotalLength;i++)
{
memset(IDstr, 0x00, ID_STR_LENGTH_SIZE);
memcpy(IDstr, &RxData.RxDataIDTotal[(i * ID_LENGTH_SIZE)], ID_LENGTH_SIZE);
Target = A2W ((char *)IDstr);
pCListBox->AddString(Target);
}
PutStaticMessage(MESSAGE_LIST_DONE);
}
//////////////////////////////////////////////////////////////////////////////////////////////
//DATA INSERT TO "GLOBAL DATA STRUCTURE" FROM DLL
//////////////////////////////////////////////////////////////////////////////////////////////
void DllUsbCheckCallBack(bool USBStatus)
{
switch(USBStatus)
{
case USB_NOT_FOUND:
MyAfxMessageBox("USB NOT FOUND");
g_USBStatus = USB_NOT_FOUND;
PutStaticMessage(MESSAGE_USB_NOT_FOUND);
UsbFoundMessageOutOnce = false;
g_USBStatusMessageOutOnce = true;
break;
case USB_FOUND:
g_USBStatus = USB_FOUND;
if(g_USBStatusMessageOutOnce)
{
if(!UsbFoundMessageOutOnce)
{
PutStaticMessage(MSEEAGE_USB_FOUND);
UsbFoundMessageOutOnce = true;
}
}
break;
}
}
void RxBufferReturnDataCallBack(ReturnData *RData)
{
if(g_USBStatus == USB_NOT_FOUND)return;
//copy data from DLL to local temp RD
ReturnData RD;
memcpy(&RD,RData,sizeof(RD));
//copy RD to global RxData
//id data
memcpy(&RxData.RxDataIDTotal,&RD.RxDataIDTotal,sizeof(RD.RxDataIDTotal));
//id name
memcpy(&RxData.RxDataID,&RD.RxDataID,ID_LENGTH_SIZE);
//id length
RxData.RxDataIDTotalLength = RD.RxDataIDTotalLength;
//return code
RxData.RxCode = RD.RxCode;
//template length
RxData.RxTemplateLength = RD.RxTemplateLength;
//template data
memcpy(&RxData.RxTemplateData,&RD.RxTemplateData,RD.RxTemplateLength);
if(RxData.RxCode == 0x1a)
{
g_USBStatus = USB_FOUND;
}
else if(RxData.RxCode != 0x00)
{
ResultMessageTextOut(RxData.RxCode);
switch(RxData.RxCode)
{
case ID_LIST_GET:
PutList();
break;
case GET_TEMPLATE_RETRIEVAL_COMPLETE:
SaveTemplate(RxData);
break;
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
//ALL BUTTON EVENT
//////////////////////////////////////////////////////////////////////////////////////////////
void CFTDI_loadDlg::OnBnClickedRegistrationBtn()
{
if(g_USBStatus == USB_FOUND)
{
GetID(g_ID);
if(strlen(g_ID) == 0)
{
PutStaticMessage(MESSAGE_ID_NOT_INSERTED);
}
else if(strlen(g_ID) > 0)
{
if(strlen(g_ID) >20)
{
PutStaticMessage(MESSAGE_ID_LENGTH_EXCEEDED);
}
else
{
PutStaticMessage(MESSAGE_IS_REGISTERING);
IrisRegister(&RxBufferReturnDataCallBack,g_ID);
}
}
}
else
{
MyAfxMessageBox("USB cable is unplugged. Command will not be executed");
}
}
void CFTDI_loadDlg::OnBnClickedCertificationBtn()
{
if(g_USBStatus == USB_FOUND)
{
GetID(g_ID);
IrisCertify(&RxBufferReturnDataCallBack,g_ID);
}
else
{
MyAfxMessageBox("USB cable is unplugged. Command will not be executed");
}
}
void CFTDI_loadDlg::OnBnClickedSaveBtn()
{
if(g_USBStatus == USB_FOUND)
{
IrisIDSave(&RxBufferReturnDataCallBack);
}
else
{
MyAfxMessageBox("USB cable is unplugged. Command will not be executed");
}
}
void CFTDI_loadDlg::OnBnClickedCancelBtn()
{
g_Cancelation = true;
if(g_USBStatus == USB_FOUND)
{
IrisCancel(&RxBufferReturnDataCallBack);
}
else
{
MyAfxMessageBox("USB cable is unplugged. Command will not be executed");
}
}
void CFTDI_loadDlg::OnBnClickedListBtn()
{
if(g_USBStatus == USB_FOUND)
{
IrisGetIDList(&RxBufferReturnDataCallBack);
}
else
{
MyAfxMessageBox("USB cable is unplugged. Command will not be executed");
}
}
void CFTDI_loadDlg::OnBnClickedDeleteBtn()
{
int rMsg = 0;
/*CString Msg;
CString Msg2*/;
USES_CONVERSION;
LPWSTR Msg;
LPWSTR Msg2;
memset(&g_ID,0x00,sizeof(g_ID));
char MsgTemp[256];
char MsgTemp2[256];
GetID(g_ID);
sprintf(MsgTemp,"Would like to delete '%s'?",g_ID);
sprintf(MsgTemp2,"Without ID, Would like to delete all ID?");
//Msg = (LPCSTR)(LPSTR)MsgTemp;
//Msg2 = (LPCSTR)(LPSTR)MsgTemp2;
Msg = A2W ((char *)MsgTemp);
Msg2 = A2W ((char *)MsgTemp2);
if(g_USBStatus == USB_FOUND)
{
if(strlen(g_ID) > 0)
{
rMsg = MessageBox(Msg, NULL, MB_ICONWARNING | MB_YESNO);
if (rMsg == IDYES)
{
IrisIDDelete(&RxBufferReturnDataCallBack,g_ID);
}
else if(rMsg == IDNO)
{
IrisCancel(&RxBufferReturnDataCallBack);
MyAfxMessageBox("ID deletion canceled.");
}
}
else
{
rMsg = MessageBox(Msg2, NULL, MB_ICONWARNING | MB_YESNO);
if (rMsg == IDYES)
{
memset(g_ID,'\0',sizeof(g_ID));
IrisIDDelete(&RxBufferReturnDataCallBack,g_ID);
}
else if(rMsg == IDNO)
{
IrisCancel(&RxBufferReturnDataCallBack);
MyAfxMessageBox("All ID deletion canceled");
}
}
//IrisGetIDList(&RxBufferReturnDataCallBack);
}
else
{
MyAfxMessageBox("USB cable is unplugged. Command will not be executed");
}
}
void CFTDI_loadDlg::OnBnClickedGetIrisBtn()
{
if(g_USBStatus == USB_FOUND)
{
GetID(g_ID);
if(strlen(g_ID) > 0)
{
IrisGetTemplate(&RxBufferReturnDataCallBack,g_ID);
}
else
{
MyAfxMessageBox("Please select ID list.");
}
}
else
{
MyAfxMessageBox("USB cable is unplugged. Command will not be executed");
}
}
void CFTDI_loadDlg::OnBnClickedPutIrisBtn()
{
if(g_USBStatus == USB_FOUND)
{
int rMsg = 0;
//////////////////
//file open dialog
//declare variable
char *sep = "\\";
char *token;
char temp[256];
char *str = new char[256];
RtlZeroMemory(str, 256);
OPENFILENAME ofn;
memset(&ofn,0,sizeof(OPENFILENAME));
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = this->m_hWnd;
ofn.lpstrFile = (LPWSTR)str;
ofn.nMaxFile = 256;
ofn.lpstrTitle = L"Select Iris template file (*.bin) to identify your iris.";
ofn.lpstrFilter = L"Iris Template File (*.bin)\0*.bin\0";
GetOpenFileName(&ofn);
//CString temp1;
RtlZeroMemory(g_FilePath,256);
RtlZeroMemory(g_ID,256);
WideCharToMultiByte(CP_ACP, 0, ofn.lpstrFile, -1, g_FilePath, 128, NULL, NULL);
token = strtok(g_FilePath,sep);
while(token)
{
RtlCopyMemory(temp,token,sizeof(g_ID));
token = strtok(NULL,sep);
if(token == NULL)
{
break;
}
}
for(int i=4;i<strlen(temp);i++)
{
if(temp[i] == '.')
{
break;
}
g_ID[i-4] = temp[i];
}
int ErrorCode;
ErrorCode = ReadTemplate(g_ID);
if(ErrorCode == 0)
{
PutStaticMessage(MESSAGE_TEMPLATE_ID_NOT_FOUND);
}
else
{
IrisPutTemplate(&RxBufferReturnDataCallBack,g_ID,&RxData);
}
}
else
{
MyAfxMessageBox("USB cable is unplugged. Command will not be executed");
}
}
void CFTDI_loadDlg::OnBnClickedLampBtn()
{
}
void CFTDI_loadDlg::OnBnClickedCloseBtn()
{
OnCancel();
}
//////////////////////////////////////////////////////////////////////////////////////////////
//CLISTBOX EVENT WHEN CLICK ID
//////////////////////////////////////////////////////////////////////////////////////////////
void CFTDI_loadDlg::OnLbnSelchangeStatusLst()
{
int sel = 0;
CString StrBuffer;
CListBox *pCListBox;
CEdit *pCEdit;
pCListBox = (CListBox *)GetDlgItem(ID_STATUS_LST);
pCEdit = (CEdit *)GetDlgItem(IDC_ID_EDT);
int nIndex = pCListBox->GetCurSel();
int nCount = pCListBox->GetCount();
if ((nIndex != LB_ERR) && (nCount > 0))
{
sel = pCListBox->GetCurSel();
pCListBox->GetText(sel, StrBuffer);
pCEdit->SetWindowText(StrBuffer);
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
//GET ID FROM CEDIT
//////////////////////////////////////////////////////////////////////////////////////////////
void GetID(char *g_ID)
{
CString StrID;
CString Msg;
char MsgTemp[256];
CEdit *pCEdt;
CWinApp *p_WinApp = AfxGetApp();
CWnd *pCWnd = p_WinApp->GetMainWnd();
pCEdt = (CEdit *)pCWnd->GetDlgItem(IDC_ID_EDT);
pCEdt->GetWindowText(StrID);
sprintf(g_ID, "%s", CT2A(StrID));
}
//////////////////////////////////////////////////////////////////////////////////////////////
//MAPPING "RETURN CODE" TO "RESULT MASSAGE"
//////////////////////////////////////////////////////////////////////////////////////////////
void ResultMessageTextOut(ReturnCode DlgRCode)
{
switch(DlgRCode)
{
case REGISTRATION_FAIL : //registration failure
PutStaticMessage(MESSAGE_IS_NOT_REGISTERED);
//AfxMessageBox(DialogMessageList[MESSAGE_IS_NOT_REGISTERED]);
break;
case IDENTIFICATION_FAIL : //certification failure
PutStaticMessage(MESSAGE_IS_NOT_CERTIFICATED);
//AfxMessageBox(DialogMessageList[MESSAGE_IS_NOT_CERTIFICATED]);
break;
case DELETION_FAIL : //deletion failure "id not found"
PutStaticMessage(MESSAGE_DELETE_FAIL);
//AfxMessageBox(DialogMessageList[MESSAGE_DELETE_FAIL]);
break;
case ID_LIST_GET : //receive ID length
PutStaticMessage(MESSAGE_LIST);
//AfxMessageBox(DialogMessageList[MESSAGE_LIST]);
break;
//working
case COMMON_VERSION_DISPLAY : //version
PutStaticMessage(MESSAGE_LIST);
//AfxMessageBox(DialogMessageList[MESSAGE_LIST]);
break;
case COMMON_CANCELATION : //cancel
PutStaticMessage(MESSAGE_CANCEL);
//AfxMessageBox(DialogMessageList[MESSAGE_CANCEL]);
break;
case REGISTERARION_NO_IRIS_FRAME : //no frame captured
PutStaticMessage(MESSAGE_REGI_NO_FRAME_CAPTURED);
//AfxMessageBox(DialogMessageList[MESSAGE_NO_FRAME_CAPTURED]);
break;
case IDENTIFICATION_NO_IRIS_FRAME : //no frame captured
PutStaticMessage(MESSAGE_CERT_NOT_ENOUGH_FRAME);
//AfxMessageBox(DialogMessageList[MESSAGE_CERT_NOT_ENOUGH_FRAME]);
break;
case IDENTIFICATION_NONE_IN_DB : //data base empty
PutStaticMessage(MESSAGE_DATABASE_EMPTY);
//AfxMessageBox(DialogMessageList[MESSAGE_DATABASE_EMPTY]);
break;
case IDENTIFICATION_NO_ID_IN_DB : //data base empty
PutStaticMessage(MESSAGE_DATABASE_EMPTY);
//AfxMessageBox(DialogMessageList[MESSAGE_DATABASE_EMPTY]);
break;
case REGISTRATION_MODULE_DB_OVER_FLOW : //data base full
PutStaticMessage(MESSAGE_DATABASE_FULL);
//AfxMessageBox(DialogMessageList[MESSAGE_DATABASE_FULL]);
break;
case REGISTRATION_BAD_OR_INSUFFICENT_IRIS_FRAME : //not enough frame for registration
PutStaticMessage(MESSAGE_REGI_NOT_ENOUGH_FRAME);
//AfxMessageBox(DialogMessageList[MESSAGE_REGI_NOT_ENOUGH_FRAME]);
break;
case SAVE_FAIL : //save failure
PutStaticMessage(MESSAGE_IS_NOT_SAVED);
///AfxMessageBox(DialogMessageList[MESSAGE_IS_NOT_SAVED]);
break;
case COMMON_SYSTEM_INIT : //system initialization
PutStaticMessage(MESSAGE_COMMON_SYSTEM_INIT);
//AfxMessageBox(DialogMessageList[MESSAGE_COMMON_SYSTEM_INIT]);
break;
case COMMON_TIMEOVER : //time over
PutStaticMessage(MESSAGE_TIME_OVER);
//AfxMessageBox(DialogMessageList[MESSAGE_TIME_OVER]);
break;
case COMMON_CHECKSUM_ERROR : //checksum ERROR
PutStaticMessage(MESSAGE_COMMON_CHECKSUM_ERROR);
//AfxMessageBox(DialogMessageList[MESSAGE_COMMON_CHECKSUM_ERROR]);
break;
case GET_TEMPLATE_RETRIEVAL_START : //transmission start
PutStaticMessage(MESSAGE_PUT_TEMPLATE_FILE_TRANSFER_READY_TO_START);
//AfxMessageBox(DialogMessageList[MESSAGE_PUT_TEMPLATE_FILE_TRANSFER_READY_TO_START]);
break;
case GET_TEMPLATE_RETRIEVAL_COMPLETE : //transmission complete
PutStaticMessage(MESSAGE_REGIST_CODE_DOWNLOAD);
//AfxMessageBox(DialogMessageList[MESSAGE_REGIST_CODE_DOWNLOAD]);
break;
case PUT_TEMPLATE_FILE_FORMAT_ERROR : //checksum ERROR
PutStaticMessage(MESSAGE_COMMON_CHECKSUM_ERROR);
//AfxMessageBox(DialogMessageList[MESSAGE_COMMON_CHECKSUM_ERROR]);
break;
case PUT_TEMPLATE_DB_OVER_FLOW : //db over flow (download)
PutStaticMessage(MESSAGE_DATABASE_FULL);
//AfxMessageBox(DialogMessageList[MESSAGE_DATABASE_FULL]);
break;
case PUT_TEMPLATE_FILE_TRANSFER_READY_TO_START : //ready to start
PutStaticMessage(MESSAGE_PUT_TEMPLATE_FILE_TRANSFER_READY_TO_START);
//AfxMessageBox(DialogMessageList[MESSAGE_PUT_TEMPLATE_FILE_TRANSFER_READY_TO_START]);
break;
case REGISTRATION_VIDEO_MODE :
PutStaticMessage(MESSAGE_PUT_TEMPLATE_FILE_TRANSFER_READY_TO_START);
//AfxMessageBox(DialogMessageList[MESSAGE_DATABASE_FULL]);
break;
case REGISTRATION_SUCCESS : //registration success
PutStaticMessage(MESSAGE_IS_REGISTERED);
//AfxMessageBox(DialogMessageList[MESSAGE_IS_REGISTERED]);
break;
case IDENTIFICATION_SUCCESS : //identification success
PutStaticMessage(MESSAGE_IS_CERTIFICATED);
//AfxMessageBox(DialogMessageList[MESSAGE_IS_CERTIFICATED]);
break;
//working
case DELETION_SUCCESS : //delete all or one
PutStaticMessage(MESSAGE_IS_DELETED);
//AfxMessageBox(DialogMessageList[MESSAGE_IS_DELETED]);
break;
case SAVE_SUCCESS : //save success
PutStaticMessage(MESSAGE_IS_SAVED);
//AfxMessageBox(DialogMessageList[MESSAGE_IS_SAVED]);
break;
}
}
int ReadTemplate(char *g_ID)
{
if(g_USBStatus == USB_NOT_FOUND)return 0;
HANDLE h_Template;
DWORD dwBytesRead = 0;
memset(&FileName[0],0x00,256);
sprintf((char *)FileName,"REG_%s.bin",g_ID);
USES_CONVERSION;
LPWSTR FName;
FName = A2W((LPCSTR)FileName);
h_Template = CreateFile(FName, // file to open
GENERIC_READ, // open for reading
FILE_SHARE_READ, // share for reading
NULL, // default security
OPEN_EXISTING, // existing file only
FILE_ATTRIBUTE_NORMAL, // normal file
NULL); // no attribute template
if (h_Template == INVALID_HANDLE_VALUE)
{
return 0;
}
if( FALSE == ReadFile(h_Template, ReadBuffer, MAX_SIZE, &dwBytesRead, NULL) )
{
CloseHandle(h_Template);
return 0;
}
if (dwBytesRead > 0 || dwBytesRead <= MAX_SIZE)
{
ReadBuffer[dwBytesRead]='\0';
//printf("Data read from %s",g_ID);
}
else if (dwBytesRead == 0)
{
//printf("No data read from file %s\n");
return 0;
}
else
{
//printf("\n ** Unexpected value for dwBytesRead ** \n");
return 0;
}
unsigned char DllInfo[21];
memset(DllInfo,0x00,21);
memcpy(DllInfo, &ReadBuffer[0], 20);
memcpy(&RxData.RxTemplateData,&ReadBuffer[40],dwBytesRead-40);
RxData.RxTemplateLength = dwBytesRead;
CloseHandle(h_Template);
return 1;
}
int SaveTemplate(ReturnData RxData)
{
//write file
HANDLE h_Template;
unsigned char HeaderTemplate[MAX_TEMPLATE_SIZE];
unsigned char DllInfo[21] = "QIRIBIOM60622-WINWIN";
DWORD dwBytesToWrite = (DWORD)(RxData.RxTemplateLength+40); //fixed header size : 40
////
//DWORD dwBytesToWrite = (DWORD)RxData.RxTemplateLength;
DWORD dwBytesWritten = 0;
BOOL bErrorFlag = FALSE;
unsigned char FileName[256];
memset(&FileName[0],0x00,256);
sprintf((char *)FileName,"REG_%s.bin",RxData.RxDataID);
////
memset(&HeaderTemplate[0],0x00,MAX_TEMPLATE_SIZE);
memcpy(HeaderTemplate, DllInfo, 20);
memcpy(&HeaderTemplate[20], RxData.RxDataID, 20);
memcpy(&HeaderTemplate[40], RxData.RxTemplateData, RxData.RxTemplateLength);
USES_CONVERSION;
LPWSTR FName;
FName = A2W((LPCSTR)FileName);
h_Template = CreateFile(FName, // name of the write
GENERIC_WRITE, // open for writing
0, // do not share
NULL, // default security
CREATE_NEW, // create new file only
FILE_ATTRIBUTE_NORMAL, // normal file
NULL); // no attribute template
if (h_Template == INVALID_HANDLE_VALUE)
{
return 0;
}
bErrorFlag = WriteFile(
h_Template, // open file handle
//&RxData.RxTemplateData, // start of data to write
&HeaderTemplate[0],
dwBytesToWrite, // number of bytes to write
&dwBytesWritten, // number of bytes that were written
NULL); // no overlapped structure
if (FALSE == bErrorFlag)
{
//printf("Terminal failure: Unable to write to file.\n");
}
else
{
if (dwBytesWritten != dwBytesToWrite)
{
//printf("Error: dwBytesWritten != dwBytesToWrite\n");
}
else
{
//printf("Wrote file successfully.\n");
}
}
CloseHandle(h_Template);
return 1;
}
void MemoryDumpData(ReturnData *Src, ReturnData *Dst)
{
Src->RxTemplateLength = Dst->RxTemplateLength;
////memory reset
memset(&Src->RxTemplateData,0x00,Src->RxTemplateLength);
////copy TX buffer
memcpy(&Src->RxTemplateData,&Dst->RxTemplateData,Dst->RxTemplateLength);
}
//////////////////////////////////////////////////////////////////////////////////////////////
//MAKE LOG FILE TO DEBUG
//////////////////////////////////////////////////////////////////////////////////////////////
static void WriteLog(const char* msg) {
USES_CONVERSION;
HANDLE h = CreateFile(A2W(LOGFILE_PATH), GENERIC_WRITE, FILE_SHARE_READ, 0, OPEN_ALWAYS, 0, 0);
if (INVALID_HANDLE_VALUE != h) {
if (INVALID_SET_FILE_POINTER != SetFilePointer(h, 0, 0, FILE_END)) {
DWORD cb = strlen(msg) * sizeof *msg;
WriteFile(h, msg, cb, &cb, 0);
}
CloseHandle(h);
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
//MAKE LOG FILE TO DEBUG
//////////////////////////////////////////////////////////////////////////////////////////////
void MyAfxMessageBox( char* str )
{
//if ( g_MyMsg )
// AfxMessageBox( CString(str));
#ifndef API_DEBUG
WriteLog(str);
WriteLog((const char *)"\n");
#endif
}
//////////////////////////////////////////////////////////////////////////////////////////////////
//
//CHAIN-COMMAND FUNCTION, CHAIN-COMMAND RECIEVE CALLBACK FUNCTION, THREAD FUNCTION TO HANDLE EVENT
//
//////////////////////////////////////////////////////////////////////////////////////////////////
void CFTDI_loadDlg::OnBnClickedRegProcessBtn()
{
Sleep(300);
if(g_USBStatus == USB_FOUND)
{
GetID(g_ID);
int rMsg = 0;
if(strlen(g_ID) == 0)
{
PutStaticMessage(MESSAGE_ID_NOT_INSERTED);
}
else if(strlen(g_ID) > 0)
{
if(strlen(g_ID) >20)
{
PutStaticMessage(MESSAGE_ID_LENGTH_EXCEEDED);
}
else
{
PutStaticMessage(MESSAGE_IS_REGISTERING);
//get button handle
////////////////////////////////////////////////////////////
////2010.03.19 BUTTON DISABLE
////////////////////////////////////////////////////////////
CButton *pCButton;
CWinApp *pWinApp = AfxGetApp();
CWnd *pCWnd = pWinApp->GetMainWnd();
pCButton = (CButton *)pCWnd->GetDlgItem(IDC_REG_PROCESS_BTN);
pCButton->EnableWindow(FALSE);
////
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
////2010.03.19 DELETE ALL ID FROM MODULE
////////////////////////////////////////////////////////////
memset(null_ID,'\0',sizeof(null_ID));
if(g_USBStatus == USB_FOUND)IrisIDDelete(&RxBufferReturnDataCallBackEx,null_ID);
//else return;
g_WaitForSingleObjectStart = true;
g_WaitForSingleObjectStatus = WaitForSingleObject(hEvent,5000);
////
////////////////////////////////////////////////////////////
LPWSTR Msg = L"Please look at the mirror for registration. (keep 10 Cm distance) ";
rMsg = MessageBox(Msg, NULL, MB_ICONWARNING | MB_OK);
if (rMsg == IDOK)
{
MyAfxMessageBox("Reg start");
if(g_USBStatus == USB_FOUND)IrisRegister(&RxBufferReturnDataCallBackEx,g_ID);
else return;
g_WaitForSingleObjectStart = true;
WaitForSingleObject(hEvent,15000);
//first registration success
if(RxData.RxCode != REGISTRATION_SUCCESS)
{
////////////////////////////////////////////////////////////
////2010.03.19 IF-NOT REGISTERED, DELETE ID FROM MODULE
////////////////////////////////////////////////////////////
PutStaticMessage(MESSAGE_IS_NOT_REGISTERED);
pCButton->EnableWindow(TRUE);
if(g_USBStatus == USB_FOUND)IrisIDDelete(&RxBufferReturnDataCallBackEx,g_ID);
g_WaitForSingleObjectStart = true;
g_WaitForSingleObjectStatus = WaitForSingleObject(hEvent,5000);
return;
////
////////////////////////////////////////////////////////////
}
LPWSTR Msg = L"Please register once more.";
rMsg = MessageBox(Msg, NULL, MB_ICONWARNING | MB_OK);
if (rMsg == IDOK)
{
if(g_USBStatus == USB_FOUND)IrisRegister(&RxBufferReturnDataCallBackEx,g_ID);
//else return;
g_WaitForSingleObjectStart = true;
WaitForSingleObject(hEvent,15000);
//second registration
if(RxData.RxCode != REGISTRATION_SUCCESS)
{
////////////////////////////////////////////////////////////
////2010.03.19 IF-NOT REGISTERED, DELETE ID FROM MODULE
////////////////////////////////////////////////////////////
PutStaticMessage(MESSAGE_IS_NOT_REGISTERED);
pCButton->EnableWindow(TRUE);
if(g_USBStatus == USB_FOUND)IrisIDDelete(&RxBufferReturnDataCallBackEx,g_ID);
g_WaitForSingleObjectStart = true;
g_WaitForSingleObjectStatus = WaitForSingleObject(hEvent,5000);
return;
////
////////////////////////////////////////////////////////////
}
LPWSTR Msg = L"Successfully registered. Please look at the mirror for identification.";
rMsg = MessageBox(Msg, NULL, MB_ICONWARNING | MB_OK);
if (rMsg == IDOK)
{
//Sleep(2000);
if(g_USBStatus == USB_FOUND)IrisCertify(&RxBufferReturnDataCallBackEx,g_ID);
//else return;
g_WaitForSingleObjectStart = true;
WaitForSingleObject(hEvent,15000);
//certification success
if(RxData.RxCode != IDENTIFICATION_SUCCESS)
{
////////////////////////////////////////////////////////////
////2010.03.19 IF-NOT IDENTIFIED, DELETE ID FROM MODULE
////////////////////////////////////////////////////////////
PutStaticMessage(MESSAGE_IS_NOT_REGISTERED);
pCButton->EnableWindow(TRUE);
if(g_USBStatus == USB_FOUND)IrisIDDelete(&RxBufferReturnDataCallBackEx,g_ID);
g_WaitForSingleObjectStart = true;
g_WaitForSingleObjectStatus = WaitForSingleObject(hEvent,5000);
return;
////
////////////////////////////////////////////////////////////
}
//Sleep(2000);//sync. not required
IrisGetTemplate(&RxBufferReturnDataCallBackEx,g_ID);
g_WaitForSingleObjectStart = true;
WaitForSingleObject(hEvent,15000);
//get template success
if(RxData.RxCode != GET_TEMPLATE_RETRIEVAL_COMPLETE)
{
ResultMessageTextOut(MESSAGE_IS_NOT_CERTIFICATED);
pCButton->EnableWindow(TRUE);
return;
}
if(g_USBStatus == USB_FOUND)IrisIDDelete(&RxBufferReturnDataCallBackEx,g_ID);
//else return;
g_WaitForSingleObjectStart = true;
g_WaitForSingleObjectStatus = WaitForSingleObject(hEvent,5000);
//deletion success
if(RxData.RxCode == DELETION_SUCCESS)
{
LPWSTR Msg = L"Registration process was completed";
PutStaticMessage(MESSAGE_IS_REGISTERED);
rMsg = MessageBox(Msg, NULL, MB_ICONWARNING | MB_OK);
////////////////////////////////////////////////////////////
////2010.03.19 BUTTON ENABLE
////////////////////////////////////////////////////////////
pCButton->EnableWindow(TRUE);
////
////////////////////////////////////////////////////////////
}
else
{
if(RxData.RxCode != DELETION_SUCCESS)
{
//memcpy(&RxData.RxDataID[0],&g_ID[0],ID_LENGTH_SIZE);
ResultMessageTextOut(MESSAGE_IS_NOT_REGISTERED);
////////////////////////////////////////////////////////////
////2010.03.19 BUTTON ENABLE
////////////////////////////////////////////////////////////
pCButton->EnableWindow(TRUE);
////
////////////////////////////////////////////////////////////
return;
}
}
}
}
}
}
}
}
else
{
MyAfxMessageBox("USB cable is unplugged. Command will not be executed");
}
}
void CFTDI_loadDlg::OnBnClickedIDProcessBtn()
{
if(g_USBStatus == USB_FOUND)
{
int rMsg = 0;
//////////////////
//file open dialog
//declare variable
char *sep = "\\";
char *token;
char temp[256];
char *str = new char[256];
RtlZeroMemory(str, 256);
OPENFILENAME ofn;
memset(&ofn,0,sizeof(OPENFILENAME));
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = this->m_hWnd;
ofn.lpstrFile = (LPWSTR)str;
ofn.nMaxFile = 256;
ofn.lpstrTitle = L"Select Iris template file (*.bin) to identify your iris.";
ofn.lpstrFilter = L"Iris Template File (*.bin)\0*.bin\0";
GetOpenFileName(&ofn);
//CString temp1;
RtlZeroMemory(g_FilePath,256);
RtlZeroMemory(g_ID,256);
WideCharToMultiByte(CP_ACP, 0, ofn.lpstrFile, -1, g_FilePath, 128, NULL, NULL);
token = strtok(g_FilePath,sep);
while(token)
{
RtlCopyMemory(temp,token,sizeof(g_ID));
token = strtok(NULL,sep);
if(token == NULL)
{
break;
}
}
for(int i=4;i<strlen(temp);i++)
{
if(temp[i] == '.')
{
break;
}
g_ID[i-4] = temp[i];
}
g_ContinueCommnad = true;
//get button handle
////////////////////////////////////////////////////////////
////2010.03.19 BUTTON DISABLE
////////////////////////////////////////////////////////////
CButton *pCButton;
CWinApp *pWinApp = AfxGetApp();
CWnd *pCWnd = pWinApp->GetMainWnd();
pCButton = (CButton *)pCWnd->GetDlgItem(IDC_CERT_PROCESS_BTN);
////
////////////////////////////////////////////////////////////
//ADD MESSAGE TO RETURN_CODE.H & RETURN_CODE.CPP
PutStaticMessage(MESSAGE_IS_CERTFYING);
if(g_USBStatus == USB_FOUND)IrisIDDelete(&RxBufferReturnDataCallBackEx,g_ID);
//else return;
g_WaitForSingleObjectStart = true;
g_WaitForSingleObjectStatus = WaitForSingleObject(hEvent,15000);
int ErrorCode;
ErrorCode = ReadTemplate(g_ID);
if(ErrorCode == 0)
{
PutStaticMessage(MESSAGE_TEMPLATE_ID_NOT_FOUND);
return;
}
//lock button
pCButton->EnableWindow(FALSE);
if(g_USBStatus == USB_FOUND)IrisPutTemplate(&RxBufferReturnDataCallBackEx,g_ID,&RxData);
//else return;
g_WaitForSingleObjectStart = true;
g_WaitForSingleObjectStatus = WaitForSingleObject(hEvent,15000);
if(RxData.RxCode != PUT_TEMPLATE_FILE_TRANSFER_READY_TO_START)
{
PutStaticMessage(MESSAGE_COMMON_CHECKSUM_ERROR);
//return;
}
LPWSTR Msg = L"Please look at the mirror for identification. (keep 10 Cm distance)";
rMsg = MessageBox(Msg, NULL, MB_ICONWARNING | MB_OK);
if (rMsg == IDOK)
{
if(g_USBStatus == USB_FOUND)IrisCertify(&RxBufferReturnDataCallBackEx,g_ID);
//else return;
g_WaitForSingleObjectStart = true;
g_WaitForSingleObjectStatus = WaitForSingleObject(hEvent,15000);
/////////////////////////////////////////////////////////////////////////////
////2010.03.19 IF-NOT CERTIFIED DELETE ID THEN PUT MESSAGE "NOT CERTIFICATED"
// IF CERTIFIED DELETE ID THEN PUT MESSAGE "CERTIFICATED"
/////////////////////////////////////////////////////////////////////////////
if(RxData.RxCode != IDENTIFICATION_SUCCESS)
{
g_ContinueCommnad = false;
}
//Sleep(2000);
if(g_USBStatus == USB_FOUND)IrisIDDelete(&RxBufferReturnDataCallBackEx,g_ID);
//else return;
g_WaitForSingleObjectStart = true;
g_WaitForSingleObjectStatus = WaitForSingleObject(hEvent,15000);
if(RxData.RxCode == DELETION_SUCCESS && g_ContinueCommnad == true)
{
LPWSTR Msg = L"Identification process was completed.";
rMsg = MessageBox(Msg, NULL, MB_ICONWARNING | MB_OK);
PutStaticMessage(MESSAGE_IS_CERTIFICATED);
}
else
{
////////////////////////////////////////////////////////////////////////////////////////
//if not certified
////////////////////////////////////////////////////////////////////////////////////////
memcpy(&RxData.RxDataID[0],&g_ID[0],ID_LENGTH_SIZE);
PutStaticMessage(MESSAGE_IS_NOT_CERTIFICATED);
}
}
////////////////////////////////////////////////////////////
////2010.03.19 BUTTON ENABLE
////////////////////////////////////////////////////////////
pCButton->EnableWindow(TRUE);
////
////////////////////////////////////////////////////////////
}
else
{
MyAfxMessageBox("USB cable is unplugged. Command will not be executed");
}
}
void RxBufferReturnDataCallBackEx(ReturnData *RData) //for chain command
{
//copy data from DLL to local temp RD
MyAfxMessageBox("--CALLBACK : DLL call");
if(g_USBStatus == USB_NOT_FOUND)return;
ReturnData RD;
memcpy(&RD,RData,sizeof(RD));
//copy RD to global RxData
//id data
memcpy(&RxData.RxDataIDTotal,&RD.RxDataIDTotal,sizeof(RD.RxDataIDTotal));
//id name
memcpy(&RxData.RxDataID,&RD.RxDataID,ID_LENGTH_SIZE);
//id length
RxData.RxDataIDTotalLength = RD.RxDataIDTotalLength;
//return code
RxData.RxCode = RD.RxCode;
//template length
RxData.RxTemplateLength = RD.RxTemplateLength;
//template data
memcpy(&RxData.RxTemplateData,&RD.RxTemplateData,RD.RxTemplateLength);
if(RxData.RxCode == 0x1a)
{
g_USBStatus = USB_FOUND;
}
else if(RxData.RxCode != 0x00)
{
//set event for waiting for single object
if(RxData.RxCode == REGISTRATION_SUCCESS || RxData.RxCode == REGISTRATION_FAIL ||RxData.RxCode == REGISTERARION_NO_IRIS_FRAME
||RxData.RxCode == REGISTRATION_BAD_OR_INSUFFICENT_IRIS_FRAME ||RxData.RxCode == REGISTRATION_MODULE_DB_OVER_FLOW
||RxData.RxCode == REGISTRATION_VIDEO_MODE ||RxData.RxCode == DELETION_SUCCESS ||RxData.RxCode == DELETION_FAIL
||RxData.RxCode == IDENTIFICATION_SUCCESS ||RxData.RxCode == IDENTIFICATION_FAIL ||RxData.RxCode == IDENTIFICATION_NO_IRIS_FRAME
||RxData.RxCode == IDENTIFICATION_NO_ID_IN_DB ||RxData.RxCode == IDENTIFICATION_NONE_IN_DB ||RxData.RxCode == PUT_TEMPLATE_FILE_TRANSFER_READY_TO_START
||RxData.RxCode == PUT_TEMPLATE_DB_OVER_FLOW ||RxData.RxCode == PUT_TEMPLATE_FILE_FORMAT_ERROR ||RxData.RxCode == PUT_TEMPLATE_FILE_ALREADY_EXIST)
{
MyAfxMessageBox("--CALLBACK : branch");
SetEvent(hEvent);
g_hEvent = true;
}
if(RxData.RxCode == GET_TEMPLATE_RETRIEVAL_COMPLETE)
{
SetEvent(hEvent);
g_hEvent = true;
SaveTemplate(RxData);
}
if(g_hEvent == true)
{
g_hEvent = false;
ResetEvent(hEvent);
}
}
}
UINT EventHandlerFunc(LPVOID lpParam)
{
while(1)
{
Sleep(200);
if((g_USBStatus == USB_NOT_FOUND && g_WaitForSingleObjectStart == true) || g_Cancelation == true)
{
g_WaitForSingleObjectStart = false;
g_Cancelation = false;
SetEvent(hEvent);
g_hEvent = true;
MyAfxMessageBox("SetEvent call");
if(g_hEvent == true)
{
g_hEvent = false;
ResetEvent(hEvent);
}
}
}
return 0;
}
void CFTDI_loadDlg::OnBnClickedPortOpenBtn()
{
IrisModuleOpen();
}
void CFTDI_loadDlg::OnBnClickedPortCloseBtn()
{
IrisModuleClose();
}
Comment