how can i create dll from cpp class for using in c#

[masoud taheri]

can some one tell how can convert this class to c# class
or convert it to dll for using in c# app

// 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();
}
 
 

[ATTACH]IRIBIO_API_TEST SOURCE.zip[/ATTACH]

[weaknessforcats]

I think you will have considerable trouble converting MFC to C#.

May I suggest you start writing from scratch using the .NET Framework where all this MFC stuff has already been converted for you.