windows-xp/Source/XPSP1/NT/windows/feime/chs/ntime/ddis.c

/*++

Copyright (c) 1995-1999 Microsoft Corporation, All Rights Reserved

Module Name:

    DDIS.C
    
++*/

#include <windows.h>
#include <windowsx.h>
#include <winerror.h>
#ifdef CROSSREF
#include <winuser.h>    
#endif
#include <immdev.h>
#include <string.h>
#include <regstr.h>
#include <ctype.h>
#include <shlobj.h>

#include "imedefs.h"
#include "resource.h"

LPTSTR _rtcschr(LPTSTR string, TCHAR c);

LONG    lLock = 0;  // this variable is for Lock and Unlock.

//we must init hprivate->mb_name
//*******************************************************************
//    InitMbName(hIMC);
//*******************************************************************
void InitMbName(HIMC hIMC)
{
LPINPUTCONTEXT    lpIMC;

    if (!hIMC) {
        return ;
    }
    
    lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
    if(!lpIMC){
        return;
    }

    StartEngine(lpIMC->hPrivate);

    ImmUnlockIMC(hIMC);
    return;

}


// Get the current user's EMB file path, and IME's MB path
// fill global variable sImeG.szIMESystemPath and sImeG.szIMEUserPath

void GetCurrentUserEMBPath(  )
{

    PSECURITY_ATTRIBUTES psa = NULL;
    TCHAR   szModuleName[MAX_PATH], *lpszStart, *lpszDot;
    int     i;

    // Get the path for MB and EMB

    GetSystemDirectory(sImeG.szIMESystemPath, MAX_PATH);

    GetModuleFileName(hInst, szModuleName, sizeof(szModuleName)/sizeof(TCHAR) );
   
    lpszStart = szModuleName + lstrlen(szModuleName) - 1;

    while ( (lpszStart != szModuleName) && ( *lpszStart != TEXT('\\') ) ) {
          
          if ( *lpszStart == TEXT('.') ) {
             lpszDot = lpszStart;
             *lpszDot = TEXT('\0');
          }

          lpszStart --;
    }

    if ( *lpszStart == TEXT('\\') ) {
         lpszStart ++;
    }

    if ( lpszStart != szModuleName ) {
       for (i=0; i<lstrlen(lpszStart); i++) 
           szModuleName[i] = lpszStart[i];

       szModuleName[i] = TEXT('\0');
    }

//    psa = CreateSecurityAttributes();

    SHGetSpecialFolderPath(NULL,sImeG.szIMEUserPath,CSIDL_APPDATA, FALSE);

    if ( sImeG.szIMEUserPath[lstrlen(sImeG.szIMEUserPath)-1] == TEXT('\\') )
         sImeG.szIMEUserPath[lstrlen(sImeG.szIMEUserPath) - 1] = TEXT('\0');

    // Because CreateDirectory( ) cannot create directory like \AA\BB, 
    // if AA and BB both do not exist. It can create only one layer of 
    // directory each time. so we must call twice CreateDirectory( ) for 
    // \AA\BB

    lstrcat(sImeG.szIMEUserPath, TEXT("\\Microsoft") );

    if ( GetFileAttributes(sImeG.szIMEUserPath) != FILE_ATTRIBUTE_DIRECTORY) 
       CreateDirectory(sImeG.szIMEUserPath, psa);

    lstrcat(sImeG.szIMEUserPath, TEXT("\\IME") );

    if ( GetFileAttributes(sImeG.szIMEUserPath) != FILE_ATTRIBUTE_DIRECTORY)
       CreateDirectory(sImeG.szIMEUserPath, psa);

    lstrcat(sImeG.szIMEUserPath, TEXT("\\") );
    lstrcat(sImeG.szIMEUserPath, szModuleName);
    
    //
    // Create the directory, so that CreateFile( ) can work fine later. 
    // ortherwise, if the directory does not exist, and you try to create 
    // a file under that dir,  CreateFile will return error.
    //

    if ( GetFileAttributes(sImeG.szIMEUserPath) != FILE_ATTRIBUTE_DIRECTORY)
        CreateDirectory(sImeG.szIMEUserPath, psa);
//    FreeSecurityAttributes(psa);

    return;
}



/**********************************************************************/
/* ImeInquire()                                                       */
/* Return Value:                                                      */
/*      TRUE - successful, FALSE - failure                            */
/**********************************************************************/
BOOL WINAPI ImeInquire(         // initialized data structure of IME
    LPIMEINFO lpImeInfo,        // IME specific data report to IMM
    LPTSTR    lpszWndCls,       // the class name of UI
    DWORD     dwSystemInfoFlags)
{
    if (!lpImeInfo) {
        return (FALSE);
    }
    
    lpImeInfo->dwPrivateDataSize = sizeof(PRIVCONTEXT);
    lpImeInfo->fdwProperty = IME_PROP_KBD_CHAR_FIRST|
#ifdef UNICODE
        IME_PROP_UNICODE|
#endif
        IME_PROP_CANDLIST_START_FROM_1|
        IME_PROP_IGNORE_UPKEYS;

    lpImeInfo->fdwConversionCaps = IME_CMODE_NATIVE|IME_CMODE_FULLSHAPE|
        IME_CMODE_CHARCODE|IME_CMODE_SOFTKBD|IME_CMODE_NOCONVERSION|
        IME_CMODE_EUDC;
    lpImeInfo->fdwSentenceCaps = 0;
    // IME will have different distance base multiple of 900 escapement
    lpImeInfo->fdwUICaps = UI_CAP_ROT90|UI_CAP_SOFTKBD;
    // composition string is the reading string for simple IME
    lpImeInfo->fdwSCSCaps = SCS_CAP_COMPSTR|SCS_CAP_MAKEREAD;
    // IME want to decide conversion mode on ImeSelect
    lpImeInfo->fdwSelectCaps = (DWORD) 0;

    lstrcpy(lpszWndCls, (LPTSTR)szUIClassName);

    if ( lpImeL )
    {
       if ( dwSystemInfoFlags & IME_SYSINFO_WINLOGON )
       {
            //  the client app is running in logon mode.
            lpImeL->fWinLogon = TRUE;
       }
       else
            lpImeL->fWinLogon = FALSE;

    }

    return (TRUE);
}

/**********************************************************************/
/* SetImeDlgProc()                                                    */
/* Return Value:                                                      */
/*      TRUE - successful, FALSE - failure                            */
/**********************************************************************/
BOOL FAR PASCAL SetImeDlgProc(
    HWND  hDlg,
    UINT  uMessage,
    DWORD wParam,
    LONG  lParam)
{
    RECT           rc;
    LONG           DlgWidth, DlgHeight;
    HIMC           hIMC;
#ifdef CROSSREF
    HWND          hLayoutListBox;
    static HIMC   hOldIMC;
#endif //CROSSREF
 

    switch (uMessage) {
    case WM_INITDIALOG:
        hCrtDlg = hDlg;    
        // reset position
        GetWindowRect(hDlg, &rc);
        DlgWidth =  rc.right - rc.left;
        DlgHeight =  rc.bottom - rc.top;
        
        SetWindowPos(hDlg, HWND_TOP,
            (int)(sImeG.rcWorkArea.right - DlgWidth)/2,
            (int)(sImeG.rcWorkArea.bottom - DlgHeight)/2,
            (int) 0, (int) 0, SWP_NOSIZE);

        // Init CheckFrame State
        SetImeCharac(hDlg, (int) 0, SIC_READY, 0);

        CheckDlgButton (hDlg, IDC_LX, 
                MBIndex.IMEChara[0].IC_LX);
        CheckDlgButton (hDlg, IDC_CZ,
                MBIndex.IMEChara[0].IC_CZ);
        CheckDlgButton (hDlg, IDC_TS,
                MBIndex.IMEChara[0].IC_TS);
        CheckDlgButton (hDlg, IDC_CTS,
                MBIndex.IMEChara[0].IC_CTC);
        CheckDlgButton (hDlg, IDC_TC,
                MBIndex.IMEChara[0].IC_Trace);

        //CHP    
#ifdef FUSSYMODE
        CheckDlgButton (hDlg, IDC_FCSR,
                MBIndex.IMEChara[0].IC_FCSR);
        CheckDlgButton (hDlg, IDC_FCTS,
                MBIndex.IMEChara[0].IC_FCTS);

        EnableWindow(GetDlgItem(hDlg, IDC_CZ), FALSE);

#endif //FUSSYMODE

#if defined(COMBO_IME)        
         if (MBIndex.IMEChara[0].IC_GB)
            SendMessage(GetDlgItem(hDlg, IDC_GB),
                    BM_SETCHECK,
                    TRUE,
                    0L);
        else
            SendMessage(GetDlgItem(hDlg, IDC_GBK),
                    BM_SETCHECK,
                    TRUE,
                    0L);
#endif //COMBO_IME

        if(MBIndex.IMEChara[0].IC_TS) {
            EnableWindow(GetDlgItem(hDlg, IDC_CTS), TRUE);
        } else {
            EnableWindow(GetDlgItem(hDlg, IDC_CTS), FALSE);
        }


#ifdef CROSSREF
        hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST);

        hIMC = ImmGetContext(hLayoutListBox);
        if(hIMC){
            ImmSetOpenStatus(hIMC, FALSE);
        }
        ImmReleaseContext(hLayoutListBox, hIMC);
        // put all reverse conversion hKL into this list
        ReverseConversionList(hLayoutListBox);
#endif //CROSSREF

        return (TRUE);          // don't want to set focus to special control
    case WM_COMMAND:
        switch (LOWORD(wParam)) {
        case IDOK:
            SetImeCharac(hDlg, (int) 0, SIC_SAVE1, 0);
#ifdef CROSSREF
            hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST);
            hIMC = ImmGetContext(hLayoutListBox);
            if(hIMC) {
                   ImmSetOpenStatus(hIMC, TRUE);
            }
            ImmReleaseContext(hLayoutListBox, hIMC);
#endif //CROSSREF
            EndDialog(hDlg, FALSE);
            break;
        case IDCANCEL:
#ifdef CROSSREF
            hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST);
            hIMC = ImmGetContext(hLayoutListBox);
            if(hIMC) {
                   ImmSetOpenStatus(hIMC, TRUE);
            }
            ImmReleaseContext(hLayoutListBox, hIMC);
#endif //CROSSREF
            EndDialog(hDlg, FALSE);
            break;
        case IDC_LX:
        case IDC_CZ:
        case IDC_TS:
        case IDC_CTS:
        case IDC_TC:

                //CHP
#ifdef FUSSYMODE
                case IDC_FCSR:
                case IDC_FCTS:
#endif //FUSSYMODE

            // Set Current InputMode Param(temp)
            SetImeCharac(hDlg, (wParam - IDC_LX), SIC_MODIFY, (int) 0);
            break;
#if defined(COMBO_IME)
        case IDC_GB:
        case IDC_GBK:
            // Set Current InputMode Param(temp)
            SetImeCharac(hDlg, 7, SIC_MODIFY, (int) 0);
            break;
#endif //COMBO_IME
        default:
            return (FALSE);
        }
        return (TRUE);
    case WM_PAINT:
        {
            RECT rc;

            GetClientRect(hDlg, &rc);
            DrawConvexRect(GetDC(hDlg),
                rc.left + 6,
                rc.top + 8,
                rc.right - 6 - 1,
                rc.bottom - 40 - 1);

            DrawConvexRectP(GetDC(hDlg),
                rc.left + 6,
                rc.top + 8,
                rc.right - 6,
                rc.bottom - 40);
        }
        
        return (FALSE);
    case WM_CLOSE:
#ifdef CROSSREF
        hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST);
        hIMC = ImmGetContext(hLayoutListBox);
        if(hIMC) {
            ImmSetOpenStatus(hIMC, TRUE);
        }
        ImmReleaseContext(hLayoutListBox, hIMC);
#endif //CROSSREF
        EndDialog(hDlg, FALSE);
        return (TRUE);
    default:
        return (FALSE);
    }

    return (TRUE);
}

/**********************************************************************/
/* SetImeCharac()                                                    */
/* Return Value: voide                                                */
/* Entry:                                                             */
/*     code=0, init                                                   */
/*     code=1, Save temp                                              */
/*     code=2, Save resault                                           */
/**********************************************************************/
void SetImeCharac (
    HWND  hDlg,
    int   ParamNum,
    int   Mode,
    DWORD ObjImeIndex)
{
    HIMC            hIMC;
    LPINPUTCONTEXT  lpIMC;
    LPPRIVCONTEXT   lpImcP;
#if defined(COMBO_IME)
    static DWORD    TempParam[8];
#else
    static DWORD    TempParam[7];
#endif //COMBO_IME
    HKEY            hKeyCurrVersion;
    HKEY            hKey;
    DWORD           retCode;
#ifdef UNICODE
    TCHAR           ValueName[][9] = { 
        {0x8BCD, 0x8BED, 0x8054, 0x60F3, 0x0000},
        {0x8BCD, 0x8BED, 0x8F93, 0x5165, 0x0000},
        {0x9010, 0x6E10, 0x63D0, 0x793A, 0x0000},
        {0x5916, 0x7801, 0x63D0, 0x793A, 0x0000},
        {0x5149, 0x6807, 0x8DDF, 0x968F, 0x0000},
#else
   TCHAR ValueName[][9] = { 
        TEXT("��������"),
        TEXT("��������"),
        TEXT("������ʾ"),
        TEXT("������ʾ"),
          TEXT("��������"),
#endif
        TEXT("FC input"),
        TEXT("FC aid"),

#if defined(COMBO_IME)
           TEXT("GB/GBK")
#endif //COMBO_IME
        };
    UINT i;

    switch (Mode)
    {
    case SIC_READY:

        InitImeCharac(ObjImeIndex);
        //CHP
#ifdef FUSSYMODE
        if (MBIndex.IMEChara[ObjImeIndex].IC_FCSR)
        {
              if (MBIndex.IMEChara[ObjImeIndex].IC_FCTS)
                    EnableWindow(GetDlgItem(hDlg, IDD_LAYOUT_LIST), FALSE);
        }
        else
              EnableWindow(GetDlgItem(hDlg, IDC_FCTS), FALSE);
#endif //FUSSYMODE


        TempParam[0] = MBIndex.IMEChara[ObjImeIndex].IC_LX;
        TempParam[1] = MBIndex.IMEChara[ObjImeIndex].IC_CZ;
        TempParam[2] = MBIndex.IMEChara[ObjImeIndex].IC_TS;
        TempParam[3] = MBIndex.IMEChara[ObjImeIndex].IC_CTC;
        TempParam[4] = MBIndex.IMEChara[ObjImeIndex].IC_Trace;

                //CHP
        TempParam[5] = MBIndex.IMEChara[ObjImeIndex].IC_FCSR;
        TempParam[6] = MBIndex.IMEChara[ObjImeIndex].IC_FCTS;
     
#if defined(COMBO_IME)
        TempParam[7] = MBIndex.IMEChara[ObjImeIndex].IC_GB;
#endif //COMBO_IME

        break;
    case SIC_MODIFY:
        TempParam[ParamNum] = (TempParam[ParamNum] ^ 0x00000001) & 0x00000001;
        if(TempParam[2]) {
            EnableWindow(GetDlgItem(hDlg, IDC_CTS), TRUE);
        } else {
            EnableWindow(GetDlgItem(hDlg, IDC_CTS), FALSE);
            TempParam[3] = 0;
            CheckDlgButton (hDlg, IDC_CTS, FALSE);
        }

        //CHP
#ifdef FUSSYMODE
        if (TempParam[5]) 
        {
            EnableWindow(GetDlgItem(hDlg, IDC_FCTS), TRUE);
            if  (TempParam[6])
                EnableWindow(GetDlgItem(hDlg, IDD_LAYOUT_LIST), FALSE);
            else
                EnableWindow(GetDlgItem(hDlg, IDD_LAYOUT_LIST), TRUE);
        }
        else
        {
            EnableWindow(GetDlgItem(hDlg, IDC_FCTS), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDD_LAYOUT_LIST), TRUE);
        }
#endif //FUSSYMODE

        break;
    case SIC_SAVE1:
        MBIndex.IMEChara[ObjImeIndex].IC_LX = TempParam[0];
        MBIndex.IMEChara[ObjImeIndex].IC_CZ = TempParam[1];
        MBIndex.IMEChara[ObjImeIndex].IC_TS = TempParam[2];
        MBIndex.IMEChara[ObjImeIndex].IC_CTC = TempParam[3];
        MBIndex.IMEChara[ObjImeIndex].IC_Trace = TempParam[4];

                // CHP
#ifdef FUSSYMODE
        MBIndex.IMEChara[ObjImeIndex].IC_FCSR = TempParam[5];
        MBIndex.IMEChara[ObjImeIndex].IC_FCTS = TempParam[6];
#endif //FUSSYMODE

#if defined(COMBO_IME)
        MBIndex.IMEChara[ObjImeIndex].IC_GB = TempParam[7];
#endif //COMBO_IME

        retCode = OpenReg_PathSetup(&hKeyCurrVersion);
        if (retCode) {
            RegCreateKey(HKEY_CURRENT_USER, REGSTR_PATH_SETUP, &hKeyCurrVersion);
        }

        if ( hKeyCurrVersion )
            retCode = RegCreateKeyEx(hKeyCurrVersion, MBIndex.MBDesc[ObjImeIndex].szName, 0,
                        NULL, REG_OPTION_NON_VOLATILE,    KEY_ALL_ACCESS    , NULL, &hKey, NULL);
        else
            return;


        if ( hKey == NULL )
        {
            RegCloseKey(hKeyCurrVersion);
            return;
        }

#if defined(COMBO_IME)
        for(i=0; i<8; i++) {
#else
        for(i=0; i<7; i++) {
#endif //COMBO_IME
             DWORD Value;

            switch (i)
            {
                case 0:
                    Value = MBIndex.IMEChara[ObjImeIndex].IC_LX;
                    break;
                case 1:
                    Value = MBIndex.IMEChara[ObjImeIndex].IC_CZ;
                    break;
                case 2:
                    Value = MBIndex.IMEChara[ObjImeIndex].IC_TS;
                    break;
                case 3:
                    Value = MBIndex.IMEChara[ObjImeIndex].IC_CTC;
                    break;
                case 4:
                    Value = MBIndex.IMEChara[ObjImeIndex].IC_Trace;
                    break;

                                //CHP
#ifdef FUSSYMODE
                case 5:
                    Value = MBIndex.IMEChara[ObjImeIndex].IC_FCSR;
                    break;
                case 6:
                    Value = MBIndex.IMEChara[ObjImeIndex].IC_FCTS;
                    break;
#endif //FUSSYMODE
#if defined(COMBO_IME)
                case 7:
                    Value = MBIndex.IMEChara[ObjImeIndex].IC_GB;
                    break;
#endif //COMBO_IME
            }
            
            if ( hKey != NULL )
            {
                RegSetValueEx (hKey, ValueName[i],
                                      (DWORD) 0,
                                      REG_DWORD,
                                      (LPBYTE)&Value,
                                      sizeof(DWORD));
            }
        }

        RegCloseKey(hKey);
        RegCloseKey(hKeyCurrVersion);

#ifdef CROSSREF
    {
        HWND hLayoutListBox;
        int  iCurSel;
        HKL  hKL;
       
        DWORD retCode;

        hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST);
        iCurSel = (int)SendMessage(hLayoutListBox, LB_GETCURSEL, 0, 0);
        hKL = (HKL)SendMessage(hLayoutListBox, LB_GETITEMDATA,
               iCurSel, 0);

        //CHP
#ifdef FUSSYMODE
        if (MBIndex.IMEChara[ObjImeIndex].IC_FCSR &&
            MBIndex.IMEChara[ObjImeIndex].IC_FCTS)
            hKL = GetKeyboardLayout(0);
#endif //FUSSYMODE

        if (MBIndex.hRevKL != hKL) {
            WORD nRevMaxKey;
            HKEY hKeyAppUser, hKeyIMEUser;
            LPPRIVCONTEXT  lpImcP;

            MBIndex.hRevKL = hKL;


            //set reverse layout to registry
            retCode = OpenReg_PathSetup(&hKeyAppUser);
            if (retCode) {
                RegCreateKey(HKEY_CURRENT_USER, REGSTR_PATH_SETUP, &hKeyCurrVersion);
            }

            retCode = RegCreateKeyEx(hKeyAppUser, MBIndex.MBDesc[0].szName, 0,
                NULL, REG_OPTION_NON_VOLATILE,    KEY_ALL_ACCESS    , NULL, &hKeyIMEUser, NULL);

            if (retCode) {
                DWORD   dwDisposition;
        
                retCode = RegCreateKeyEx (hKeyCurrVersion,
                                 MBIndex.MBDesc[0].szName,
                              0,
                              0,
                              REG_OPTION_NON_VOLATILE,
                              KEY_ALL_ACCESS,
                              NULL,
                              &hKey,
                              &dwDisposition);
            }

            RegSetValueEx(hKeyIMEUser, szRegRevKL, 0, REG_DWORD, (LPBYTE)&hKL,sizeof(hKL));

            // get the new size
            nRevMaxKey = (WORD)ImmEscape(hKL, (HIMC)NULL, IME_ESC_MAX_KEY,
                NULL);

            if (lpImeL->nMaxKey != nRevMaxKey) {
                if(lpImeL->nMaxKey < nRevMaxKey)
                    lpImeL->nMaxKey = nRevMaxKey;

                // set the width & height for composition window
                 lpImeL->rcCompText.right = lpImeL->rcCompText.left +
                    sImeG.xChiCharWi * ((lpImeL->nMaxKey+2)/2);
                lpImeL->xCompWi = lpImeL->rcCompText.right + lpImeL->cxCompBorder * (2 + 4);

                //generate message to broadcast change comp win size
                hIMC = (HIMC)ImmGetContext(hDlg);
                if (!hIMC) {
                    return;
                }
                lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
                if (!lpIMC) {
                    return;
                }
                lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
                if (!lpImcP) {
                    goto ChgConfigUnlockIMC;
                }
                lpImcP->fdwImeMsg |= MSG_IMN_COMPOSITIONPOS;
                GenerateMessage(hIMC, lpIMC, lpImcP);
                ImmUnlockIMCC(lpIMC->hPrivate);
ChgConfigUnlockIMC:
                ImmUnlockIMC(hIMC);
            } //end of change nMaxKey

            RegSetValueEx(hKeyIMEUser, szRegRevMaxKey, 0, REG_DWORD, (LPBYTE)&lpImeL->nMaxKey,sizeof(DWORD));

            RegCloseKey(hKeyAppUser);
            RegCloseKey(hKeyIMEUser);

        } //end of change RegRevKL
    }
#endif    //CROSSREF

        break;
    }

    return;
}
#if defined(CROSSREF)
/**********************************************************************/
/* ReverseConversionList()                                            */
/**********************************************************************/
void PASCAL ReverseConversionList(HWND   hLayoutListBox)
{
    int      nLayouts, i, nIMEs;
    TCHAR    szImeName[16];
    HKL FAR *lpKLMem;

    LoadString(hInst, IDS_NONE, szImeName, sizeof(szImeName)/sizeof(TCHAR));

    SendMessage(hLayoutListBox, LB_INSERTSTRING,
        0, (LPARAM)szImeName);

    SendMessage(hLayoutListBox, LB_SELECTSTRING,
        0, (LPARAM)szImeName);

    SendMessage(hLayoutListBox, LB_SETITEMDATA,
        0, (LPARAM)(HKL)NULL);

    nLayouts = GetKeyboardLayoutList(0, NULL);

    lpKLMem = GlobalAlloc(GPTR, sizeof(HKL) * nLayouts);
    if (!lpKLMem) {
        return;
    }

    GetKeyboardLayoutList(nLayouts, lpKLMem);

    for (i = 0, nIMEs = 0; i < nLayouts; i++) {
        HKL hKL;

        hKL = *(lpKLMem + i);

        if (LOWORD(hKL) != NATIVE_LANGUAGE) {
            // not support other language
            continue;
        }

        // NULL hIMC ???????
        if (!ImmGetConversionList(hKL, (HIMC)NULL, NULL,
            NULL, 0, GCL_REVERSECONVERSION)) {
            // this IME not support reverse conversion
            continue;
        }

        if (!ImmEscape(hKL, (HIMC)NULL, IME_ESC_IME_NAME,
            szImeName)) {
            // this IME does not report the IME name
            continue;
        }

        if( lstrcmp(szImeName, MBIndex.MBDesc[0].szName) == 0)
            continue;

        nIMEs++;

        SendMessage(hLayoutListBox, LB_INSERTSTRING,
            nIMEs, (LPARAM)szImeName);

        if (hKL == MBIndex.hRevKL) {
            SendMessage(hLayoutListBox, LB_SELECTSTRING, nIMEs,
                (LPARAM)szImeName);
        }

        SendMessage(hLayoutListBox, LB_SETITEMDATA,
            nIMEs, (LPARAM)hKL);
    }

    GlobalFree((HGLOBAL)lpKLMem);

    return;
}
#endif //CROSSREF

#ifdef EUDC
//**********************************************************************
//BOOL EUDCDicName( HWND hWnd)
//**********************************************************************
BOOL EUDCDicName( HWND hWnd)
{
    HANDLE       hUsrDicFile;
    BOOL         fRet;
    TCHAR        szFileName[MAX_PATH];
    TCHAR        szMapFileName[MAX_PATH];
    TCHAR        EUDCMB_PathAndName[MAX_PATH];
    TCHAR        *tepstr;
    HKEY         hKeyCurrVersion,hKey;
    PSECURITY_ATTRIBUTES psa;

    LoadString(hInst, IDS_IMEMBFILENAME, szFileName, MAX_PATH);
    tepstr = _rtcschr(szFileName,TEXT('.'));

    if ( tepstr != NULL )
        lstrcpy(tepstr,TEXT(".EMB"));

    lstrcpy(EUDCMB_PathAndName, sImeG.szIMEUserPath);
    lstrcat(EUDCMB_PathAndName, TEXT("\\") );
    lstrcat(EUDCMB_PathAndName, szFileName); 

    psa = CreateSecurityAttributes();

    hUsrDicFile = CreateFile(EUDCMB_PathAndName, 
                             GENERIC_WRITE,
                             FILE_SHARE_READ|FILE_SHARE_WRITE,
                             psa, 
                             OPEN_ALWAYS,
                             FILE_ATTRIBUTE_NORMAL, 
                             (HANDLE)NULL);

    if (hUsrDicFile == INVALID_HANDLE_VALUE) {
        FreeSecurityAttributes(psa);
        return (FALSE);
    }

    CloseHandle(hUsrDicFile);
    FreeSecurityAttributes(psa);

    lstrcpy(MBIndex.EUDCData.szEudcDictName, EUDCMB_PathAndName);

    // if we have already got a map file, we just use it. 
    if (MBIndex.EUDCData.szEudcMapFileName[0]) {
        return (TRUE);
    }
 
    // Otherwise, generate the Map File Name, which is Basic Filename plus EUDC
   
    lstrcpy(szMapFileName, szFileName); 
    tepstr = _rtcschr(szMapFileName,TEXT('.'));
    lstrcpy(tepstr, TEXT("EUDC"));

    lstrcpy(MBIndex.EUDCData.szEudcMapFileName, szMapFileName);

    fRet = OpenReg_PathSetup(&hKeyCurrVersion);

    if (fRet)  return FALSE;

    fRet = OpenReg_User (hKeyCurrVersion,
                         MBIndex.MBDesc[0].szName,
                         &hKey);
    if (fRet) {
        DWORD   dwDisposition;
        
        fRet = RegCreateKeyEx (hKeyCurrVersion,
                                 MBIndex.MBDesc[0].szName,
                              0,
                              0,
                              REG_OPTION_NON_VOLATILE,
                              KEY_ALL_ACCESS,
                              NULL,
                              &hKey,
                              &dwDisposition);

        if (fRet != ERROR_SUCCESS) return FALSE;
    }

    fRet = RegSetValueEx (hKey, 
                          szRegEudcDictName,
                          (DWORD) 0,
                          REG_SZ,
                          (const unsigned char *)MBIndex.EUDCData.szEudcDictName,
                          lstrlen(MBIndex.EUDCData.szEudcDictName)*sizeof(TCHAR));

    if (fRet != ERROR_SUCCESS ) return FALSE;

    fRet = RegSetValueEx (hKey, 
                          szRegEudcMapFileName,
                          (DWORD) 0,
                          REG_SZ,
                          (const unsigned char *)MBIndex.EUDCData.szEudcMapFileName,
                          lstrlen(MBIndex.EUDCData.szEudcMapFileName)*sizeof(TCHAR));

    if (fRet) return FALSE;

    return (TRUE);
}
#endif    //EUDC

/**********************************************************************/
/* ImeConfigure()                                                     */
/* Return Value:                                                      */
/*      TRUE - successful, FALSE - failure                            */
/**********************************************************************/
BOOL WINAPI ImeConfigure(      // configurate the IME setting
    HKL     hKL,               // hKL of this IME
    HWND    hAppWnd,           // the owner window
    DWORD   dwMode,               // mode of dialog
    LPVOID  lpData)            
{
    switch (dwMode) {
    case IME_CONFIG_GENERAL:
        DialogBox(hInst, TEXT("SETIME"), hAppWnd, (DLGPROC) SetImeDlgProc);
        break;

#ifdef EUDC
    case IME_CONFIG_SELECTDICTIONARY:
        return(EUDCDicName(hAppWnd));
        break;
#endif //EUDC
    default:
        return (FALSE);
        break;
    }
    return (TRUE);
}

/**********************************************************************/
/* ForwordConversion()                                                */
/**********************************************************************/
UINT PASCAL ForwordConversion(
    HIMC            hIMC,
    LPCTSTR         lpszSrc,
    LPCANDIDATELIST lpCandList,
    UINT            uBufLen)

{
    unsigned int   i;
    LPTSTR wCode;
    LPINPUTCONTEXT      lpIMC;
    UINT        uMaxCand;
    DWORD       dwSize;

    wCode = ConverList.szSelectBuffer;

    ConverList.szSelectBuffer[0] =TEXT('\0');
    ConverList.szInBuffer[0]     =TEXT('\0');
    ConverList.Candi_Cnt         =0;
    ConverList.Candi_Pos[0]      =TEXT('\0');


    if (!hIMC) {
        return (0);
    }
    
    lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);

    if (!lpIMC) {
        return (0);
    }

    if (!Conversion (lpIMC->hPrivate,lpszSrc,0)) {
    return (0);
    }
    ConverList.szSelectBuffer [lstrlen(ConverList.szSelectBuffer)-1]
        =TEXT('\0');
    dwSize =
        // header length
        sizeof(CANDIDATELIST) +
        // candidate string pointers
        sizeof(DWORD) * ConverList.Candi_Cnt+
        // string plus NULL terminator
        sizeof(TCHAR) * lstrlen (wCode);


    if (!uBufLen) {
        return (dwSize);
    }

    uMaxCand = uBufLen - sizeof(CANDIDATELIST);

    uMaxCand /= sizeof(DWORD) + lstrlen (wCode);
    if (!uMaxCand) {
        // can not even put one string
        return (0);
    }

    lpCandList->dwSize = dwSize;
    lpCandList->dwStyle = IME_CAND_READ;    // candidate having same reading
    lpCandList->dwCount = 0;
    lpCandList->dwSelection = 0;
    lpCandList->dwPageSize = CANDPERPAGE;
    lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) *
        (uMaxCand - 1);

     lstrcpy((LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[0]),
              (LPTSTR)wCode);   

     lpCandList->dwCount =(DWORD)ConverList.Candi_Cnt;

        for (i=1;i<lpCandList->dwCount;i++) {
          lpCandList->dwOffset[i] = lpCandList->dwOffset[0]
          +(DWORD)ConverList.Candi_Pos[i+1];

          *(LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[i]-1) = TEXT('\0');

        }


    return (dwSize);
}


#if defined(CROSSREF)
//*******************************************************************
// The parameters are inherited from SelectOneCand
//    CrossReverseConv()
//*******************************************************************

int CrossReverseConv(
    LPINPUTCONTEXT      lpIMC,
    LPCOMPOSITIONSTRING lpCompStr,
    LPPRIVCONTEXT       lpImcP,
    LPCANDIDATELIST     lpCandList)
{
    LPGUIDELINE lpGuideLine;
    UINT uSize=0;

    if (!MBIndex.hRevKL) {
        return 0;
    }


    lpGuideLine = ImmLockIMCC(lpIMC->hGuideLine);

    if (!lpGuideLine) {
        return 0;
    }

    if (lpCompStr->dwResultStrLen != 2/sizeof(TCHAR)) {
        // we only can reverse convert one DBCS character for now
        lpGuideLine->dwLevel = GL_LEVEL_NOGUIDELINE;
        lpGuideLine->dwIndex = GL_ID_UNKNOWN;
    } else {
        TCHAR szStrBuf[4];

         LPCANDIDATELIST     lpRevCandList;

        if(lpImcP->hRevCandList == (HIMCC)NULL){
            //we alloc memory in lpImcP->hRevCandList, for reverse convert
            //result codes; When finish reconvert, should read out this info.
REALLOC:
            lpImcP->hRevCandList = (HIMCC)GlobalAlloc(GHND, sizeof(CANDIDATELIST)+1*sizeof(DWORD)+MAXCODE*sizeof(TCHAR)+1);
            if (lpImcP->hRevCandList == (HIMCC)NULL) {
                return 0 ;
            }
               lpRevCandList = (LPCANDIDATELIST)GlobalLock((HGLOBAL)lpImcP->hRevCandList);
            if (lpRevCandList == NULL) {
                return 0 ;
            }
           }else{
               lpRevCandList = (LPCANDIDATELIST)GlobalLock((HGLOBAL)lpImcP->hRevCandList);
               if (lpRevCandList == NULL) {
                goto REALLOC;
               }
        }

        *(LPUNAWORD)szStrBuf = *(LPUNAWORD)((LPBYTE)lpCompStr + lpCompStr->dwResultStrOffset);
        szStrBuf[2/sizeof(TCHAR)] = TEXT('\0');

        memset(lpRevCandList, 0, sizeof(CANDIDATELIST)+1*sizeof(DWORD)+MAXCODE*sizeof(TCHAR)+1);
        lpRevCandList->dwSize = sizeof(CANDIDATELIST)+1*sizeof(DWORD)+MAXCODE*sizeof(TCHAR)+1;

        uSize = ImmGetConversionList(MBIndex.hRevKL, (HIMC)NULL, szStrBuf,
            (LPCANDIDATELIST)lpRevCandList, 
            lpRevCandList->dwSize, GCL_REVERSECONVERSION);

        GlobalUnlock((HGLOBAL)lpImcP->hRevCandList);
        

        if (uSize) {
            if (lpImcP->fdwImeMsg & MSG_ALREADY_START) {
                lpImcP->fdwImeMsg &= ~(MSG_END_COMPOSITION|
                    MSG_START_COMPOSITION);
            } else {
                lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg|
                    MSG_START_COMPOSITION) & ~(MSG_END_COMPOSITION);
            }
        } else {
            GlobalFree((HGLOBAL)lpImcP->hRevCandList);
            lpImcP->hRevCandList = (HIMCC)NULL; 
        }
    }

    ImmUnlockIMCC(lpIMC->hGuideLine);
    //CHP 
    //We need to know the result.
    return uSize;
}
#endif //CROSSREF



/**********************************************************************/
/* ReverseConversion()                                                */
/**********************************************************************/
UINT PASCAL ReverseConversion(

    HIMCC            hPrivate,
    LPCTSTR         lpszSrc,
    LPCANDIDATELIST lpCandList,
    UINT            uBufLen)
{
    LPTSTR        wCode;
    UINT        uMaxCand;
    DWORD       dwSize;


    wCode = ConverList.szInBuffer;

    ConverList.szSelectBuffer[0] =TEXT('\0');
    ConverList.szInBuffer[0]     =TEXT('\0');
    ConverList.Candi_Cnt         =0;
    ConverList.Candi_Pos[0]      =TEXT('\0');

    dwSize =                
        // header length
        sizeof(CANDIDATELIST) +
        // candidate string pointers
        sizeof(DWORD) +
        // string plus NULL terminator
        MAXCODE*sizeof(TCHAR);


    if (!uBufLen) {
        return (dwSize);
    }

    if(lpszSrc ==NULL){
        return (0);
    }

    if (!Conversion (hPrivate,lpszSrc,1)) {
        return (0);
    }
    uMaxCand = uBufLen - sizeof(CANDIDATELIST);

    uMaxCand /= sizeof(DWORD) + lstrlen (wCode);
    if (!uMaxCand) {
        // can not even put one string
        return (0);
    }

    lpCandList->dwSize = dwSize;
    lpCandList->dwStyle = IME_CAND_READ;    // candidate having same reading
    lpCandList->dwCount = 1;
    lpCandList->dwSelection = 0;
    lpCandList->dwPageSize = CANDPERPAGE;
    lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) *
        (uMaxCand - 1);

    lstrcpy((LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[0]),
              (LPTSTR)wCode);   

    return (dwSize);

}

/**********************************************************************/
/* ImeConversionList()                                                */
/**********************************************************************/
DWORD WINAPI ImeConversionList(
    HIMC            hIMC,
    LPCTSTR         lpszSrc,
    LPCANDIDATELIST lpCandList,
    DWORD           dwBufLen,
    UINT            uFlag)
{


    if (!dwBufLen) {            
    } else if (!lpszSrc) {
        return (0);
    } else if (!*lpszSrc) {
        return (0);
    } else if (!lpCandList) {
        return (0);
    } else if (dwBufLen <= sizeof(CANDIDATELIST)) {
        // buffer size can not even put the header information
        return (0);
    } else {
    }


    switch (uFlag) {

    case GCL_CONVERSION:
        return ForwordConversion(hIMC,lpszSrc, lpCandList, dwBufLen);
        break;

    case GCL_REVERSECONVERSION:
        if (!dwBufLen) {
            return ReverseConversion(NULL,0, lpCandList, dwBufLen);
        } else { 
 
           DWORD fRet=0;
           HIMCC hPrivate;

           hPrivate = (HIMCC)ImmCreateIMCC(sizeof(PRIVCONTEXT));
           if(hPrivate == (HIMCC)NULL){
               return 0;
           }
           StartEngine(hPrivate);
        
           fRet = ReverseConversion(hPrivate,lpszSrc, lpCandList, dwBufLen);

           EndEngine(hPrivate);
           ImmDestroyIMCC(hPrivate);
           return fRet;
        }
        break;

    default:
        return (0);
        break;
    }
}

/**********************************************************************/
/* ImeDestroy()                                                       */
/* Return Value:                                                      */
/*      TRUE - successful, FALSE - failure                            */
/**********************************************************************/
BOOL WINAPI ImeDestroy(         // this dll is unloaded
    UINT uReserved)
{
    if (uReserved) {
        return (FALSE);
    }

    return (TRUE);
}

/**********************************************************************/
/* ImeEscape()                                                        */
/* Return Value:                                                      */
/*      TRUE - successful, FALSE - failure                            */
/**********************************************************************/
#define IME_INPUTKEYTOSEQUENCE  0x22

LRESULT WINAPI ImeEscape(       // escape function of IMEs
    HIMC   hIMC,
    UINT   uSubFunc,
    LPVOID lpData)
{
    LRESULT lRet;

    switch (uSubFunc) {
    case IME_ESC_QUERY_SUPPORT:
        if (lpData == NULL)
            return FALSE;

        switch (*(LPUINT)lpData) {
        case IME_ESC_QUERY_SUPPORT:
#ifdef     EUDC
        case IME_ESC_GET_EUDC_DICTIONARY:
        case IME_ESC_SET_EUDC_DICTIONARY:
#endif    //EUDC
        case IME_ESC_SEQUENCE_TO_INTERNAL:
        case IME_ESC_MAX_KEY:
        case IME_ESC_IME_NAME:
        case IME_ESC_GETHELPFILENAME:
                               return (TRUE);
        default:
                               return (FALSE);
        }
        break;
    case IME_ESC_SEQUENCE_TO_INTERNAL:
                  if (!lpData || (*(LPBYTE)lpData) == '\0') {
                     return (FALSE);
                  }

                  lRet = *(LPWORD)lpData;
                  return (lRet);

#ifdef     EUDC
    case IME_ESC_GET_EUDC_DICTIONARY:
                  if (!lpData) {
                     return (FALSE);
                  }

                  if (MBIndex.EUDCData.szEudcDictName[0] == TEXT('\0')) {        
                     *(LPTSTR)lpData = TEXT('\0');
                     return(TRUE);
                  } else {
                     lstrcpy((LPTSTR)lpData,MBIndex.EUDCData.szEudcDictName);
                     return TRUE;
                  }    
 
    case IME_ESC_SET_EUDC_DICTIONARY:
                  return TRUE;
#endif    //EUDC
    case IME_ESC_MAX_KEY:
#ifdef EUDC
         {
            TCHAR          szFullFileName[MAX_PATH], szFileName[MAX_PATH];
            unsigned int   cb;

            cb = MAX_PATH;

            if  (lpImeL->nMaxKey > EUDC_MAX_READING) {
                GetModuleFileName(NULL,szFullFileName ,cb);
                GetFileTitle(szFullFileName, szFileName, (WORD)cb);
            
#ifdef UNICODE
                // Compare first 8 chars only
                if (_wcsnicmp(szFileName,TEXT("EUDCEDIT.EXE"),8)) 
#else
                if (_strnicmp(szFileName,"EUDCEDIT.EXE",8)) 
#endif 
                   return (lpImeL->nMaxKey);
                else 
                   return EUDC_MAX_READING;
            } else {
                return (lpImeL->nMaxKey);
            }            
        }
#else
        return (lpImeL->nMaxKey);
#endif //EUDC

    case IME_ESC_IME_NAME:
   
            if ( lpData == NULL ) 
               return FALSE;

            lstrcpy(lpData,MBIndex.MBDesc[0].szName);
            return (TRUE);

    case IME_ESC_GETHELPFILENAME :
         {
           TCHAR szIMEGUDHlpName[MAX_PATH];
           int iLen;

           if (lpData == NULL )
              return FALSE;
   
           szIMEGUDHlpName[0] = 0;
           GetWindowsDirectory((LPTSTR)szIMEGUDHlpName, MAX_PATH);
           lstrcat((LPTSTR)szIMEGUDHlpName, TEXT("\\HELP\\"));
           lstrcat((LPTSTR)szIMEGUDHlpName, (LPTSTR)szImeMBFileName);
           iLen = lstrlen(szIMEGUDHlpName);
           szIMEGUDHlpName[iLen-3] = 0;
           lstrcat((LPTSTR)szIMEGUDHlpName, TEXT(".CHM"));

           lstrcpy(lpData, szIMEGUDHlpName);

           return TRUE;

         }      

    default:
        return (FALSE);
    }

    return (lRet);
}

/**********************************************************************/
/* InitCompStr()                                                      */
/**********************************************************************/
void PASCAL InitCompStr(                // init setting for composing string
    LPCOMPOSITIONSTRING lpCompStr)
{
    if (!lpCompStr) {
        return;
    }

    lpCompStr->dwCompReadAttrLen = 0;
    lpCompStr->dwCompReadClauseLen = 0;
    lpCompStr->dwCompReadStrLen = 0;

    lpCompStr->dwCompAttrLen = 0;
    lpCompStr->dwCompClauseLen = 0;
    lpCompStr->dwCompStrLen = 0;

    lpCompStr->dwCursorPos = 0;
    lpCompStr->dwDeltaStart = 0;

    lpCompStr->dwResultReadClauseLen = 0;
    lpCompStr->dwResultReadStrLen = 0;

    lpCompStr->dwResultClauseLen = 0;
    lpCompStr->dwResultStrLen = 0;

    return;
}

/**********************************************************************/
/* ClearCompStr()                                                     */
/* Return Value:                                                      */
/*      TRUE - successful, FALSE - failure                            */
/**********************************************************************/
BOOL PASCAL ClearCompStr(
    LPINPUTCONTEXT lpIMC)
{
    HIMCC               hMem;
    LPCOMPOSITIONSTRING lpCompStr;
    DWORD               dwSize;

    if(!lpIMC) {
        return (FALSE);
    }

    dwSize =
        // header length
        sizeof(COMPOSITIONSTRING) +
        // composition reading attribute plus NULL terminator
        lpImeL->nMaxKey * sizeof(BYTE) + sizeof(BYTE) +
        // composition reading clause
        sizeof(DWORD) + sizeof(DWORD) +
        // composition reading string plus NULL terminator
        lpImeL->nMaxKey * sizeof(WORD) + sizeof(WORD) +
        // result reading clause
        sizeof(DWORD) + sizeof(DWORD) +
        // result reading string plus NULL terminateor
        lpImeL->nMaxKey * sizeof(WORD) + sizeof(WORD) +
        // result clause
        sizeof(DWORD) + sizeof(DWORD) +
        // result string plus NULL terminateor
        MAXSTRLEN * sizeof(WORD) + sizeof(WORD);

    if (!lpIMC->hCompStr) {
        // it maybe free by other IME, init it
        lpIMC->hCompStr = ImmCreateIMCC(dwSize);
    } else if (hMem = ImmReSizeIMCC(lpIMC->hCompStr, dwSize)) {
        lpIMC->hCompStr = hMem;
    } else {
        ImmDestroyIMCC(lpIMC->hCompStr);
        lpIMC->hCompStr = ImmCreateIMCC(dwSize);
        return (FALSE);
    }

    if (!lpIMC->hCompStr) {
        return (FALSE);
    }

    lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
    if (!lpCompStr) {
        ImmDestroyIMCC(lpIMC->hCompStr);
        lpIMC->hCompStr = ImmCreateIMCC(dwSize);
        return (FALSE);
    }

    lpCompStr->dwSize = dwSize;

     // 1. composition (reading) string - simple IME
     // 2. result reading string
     // 3. result string

    lpCompStr->dwCompReadAttrLen = 0;
    lpCompStr->dwCompReadAttrOffset = sizeof(COMPOSITIONSTRING);
    lpCompStr->dwCompReadClauseLen = 0;
    lpCompStr->dwCompReadClauseOffset = lpCompStr->dwCompReadAttrOffset +
        lpImeL->nMaxKey * sizeof(TCHAR) + sizeof(TCHAR);
    lpCompStr->dwCompReadStrLen = 0;
    lpCompStr->dwCompReadStrOffset = lpCompStr->dwCompReadClauseOffset +
        sizeof(DWORD) + sizeof(DWORD);

    // composition string is the same with composition reading string 
    // for simple IMEs
    lpCompStr->dwCompAttrLen = 0;
    lpCompStr->dwCompAttrOffset = lpCompStr->dwCompReadAttrOffset;
    lpCompStr->dwCompClauseLen = 0;
    lpCompStr->dwCompClauseOffset = lpCompStr->dwCompReadClauseOffset;
    lpCompStr->dwCompStrLen = 0;
    lpCompStr->dwCompStrOffset = lpCompStr->dwCompReadStrOffset;

    lpCompStr->dwCursorPos = 0;
    lpCompStr->dwDeltaStart = 0;

    lpCompStr->dwResultReadClauseLen = 0;
    lpCompStr->dwResultReadClauseOffset = lpCompStr->dwCompStrOffset +
        lpImeL->nMaxKey * sizeof(WORD) + sizeof(WORD);
    lpCompStr->dwResultReadStrLen = 0;
    lpCompStr->dwResultReadStrOffset = lpCompStr->dwResultReadClauseOffset +
        sizeof(DWORD) + sizeof(DWORD);

    lpCompStr->dwResultClauseLen = 0;
    lpCompStr->dwResultClauseOffset = lpCompStr->dwResultReadStrOffset +
        lpImeL->nMaxKey * sizeof(WORD) + sizeof(WORD);
    lpCompStr->dwResultStrOffset = 0;
    lpCompStr->dwResultStrOffset = lpCompStr->dwResultClauseOffset +
        sizeof(DWORD) + sizeof(DWORD);

    GlobalUnlock((HGLOBAL)lpIMC->hCompStr);
    return (TRUE);
}

/**********************************************************************/
/* ClearCand()                                                        */
/* Return Value:                                                      */
/*      TRUE - successful, FALSE - failure                            */
/**********************************************************************/
BOOL PASCAL ClearCand(
    LPINPUTCONTEXT lpIMC)
{
    HIMCC           hMem;
    LPCANDIDATEINFO lpCandInfo;
    LPCANDIDATELIST lpCandList;
    DWORD           dwSize =
        // header length
        sizeof(CANDIDATEINFO) + sizeof(CANDIDATELIST) +
        // candidate string pointers
        sizeof(DWORD) * (MAXCAND) +
        // string plus NULL terminator
        (sizeof(WORD) * MAXSTRLEN + sizeof(WORD)) * MAXCAND;

    if (!lpIMC) {
        return (FALSE);
    }

    if (!lpIMC->hCandInfo) {
        // it maybe free by other IME, init it
        lpIMC->hCandInfo = ImmCreateIMCC(dwSize);
    } else if (hMem = ImmReSizeIMCC(lpIMC->hCandInfo, dwSize)) {
        lpIMC->hCandInfo = hMem;
    } else {
        ImmDestroyIMCC(lpIMC->hCandInfo);
        lpIMC->hCandInfo = ImmCreateIMCC(dwSize);
        return (FALSE);
    }

    if (!lpIMC->hCandInfo) {
        return (FALSE);
    } 

    lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
    if (!lpCandInfo) {
        ImmDestroyIMCC(lpIMC->hCandInfo);
        lpIMC->hCandInfo = ImmCreateIMCC(dwSize);
        return (FALSE);
    }

    // ordering of strings are
    // buffer size
    lpCandInfo->dwSize = dwSize;
    lpCandInfo->dwCount = 0;
    lpCandInfo->dwOffset[0] = sizeof(CANDIDATEINFO);
    lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo +
        lpCandInfo->dwOffset[0]);
    // whole candidate info size - header
    lpCandList->dwSize = lpCandInfo->dwSize - sizeof(CANDIDATEINFO);
    lpCandList->dwStyle = IME_CAND_READ;
    lpCandList->dwCount = 0;
    lpCandList->dwSelection = 0;
    lpCandList->dwPageSize = CANDPERPAGE;
    lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) +
        sizeof(DWORD) * (MAXCAND - 1);

    ImmUnlockIMCC(lpIMC->hCandInfo);
    return (TRUE);
}

/**********************************************************************/
/* ClearGuideLine()                                                   */
/* Return Value:                                                      */
/*      TRUE - successful, FALSE - failure                            */
/**********************************************************************/
BOOL PASCAL ClearGuideLine(
    LPINPUTCONTEXT lpIMC)
{
    HIMCC       hMem;
    LPGUIDELINE lpGuideLine;
    DWORD       dwSize = sizeof(GUIDELINE) + sImeG.cbStatusErr;

    if (!lpIMC->hGuideLine) {
        // it maybe free by IME
        lpIMC->hGuideLine = ImmCreateIMCC(dwSize);
    } else if (hMem = ImmReSizeIMCC(lpIMC->hGuideLine, dwSize)) {
        lpIMC->hGuideLine = hMem;
    } else {
        ImmDestroyIMCC(lpIMC->hGuideLine);
        lpIMC->hGuideLine = ImmCreateIMCC(dwSize);
    }

    lpGuideLine = (LPGUIDELINE)ImmLockIMCC(lpIMC->hGuideLine);
    if (!lpGuideLine) {
        return (FALSE);
    }

    lpGuideLine->dwSize = dwSize;
    lpGuideLine->dwLevel = GL_LEVEL_NOGUIDELINE;
    lpGuideLine->dwIndex = GL_ID_UNKNOWN;
    lpGuideLine->dwStrLen = 0;
    lpGuideLine->dwStrOffset = sizeof(GUIDELINE);

    CopyMemory((LPBYTE)lpGuideLine + lpGuideLine->dwStrOffset,
        sImeG.szStatusErr, sImeG.cbStatusErr);

    ImmUnlockIMCC(lpIMC->hGuideLine);

    return (TRUE);
}

/**********************************************************************/
/* InitContext()                                                      */
/**********************************************************************/
void PASCAL InitContext(
    LPINPUTCONTEXT lpIMC)
{
    if (lpIMC->fdwInit & INIT_STATUSWNDPOS) {
    } else if (!lpIMC->hWnd) {
    } else {
#if 0 // MultiMonitor support
        POINT ptWnd;

        // 10.10 modify
        //ptWnd.x = sImeG.rcWorkArea.left;
        //ptWnd.y = sImeG.rcWorkArea.top;
        ptWnd.x = 0;
        ptWnd.y = 0;
        ClientToScreen(lpIMC->hWnd, &ptWnd);

        if (ptWnd.x < sImeG.rcWorkArea.left) {
            lpIMC->ptStatusWndPos.x = sImeG.rcWorkArea.left;
        } else if (ptWnd.x + sImeG.xStatusWi > sImeG.rcWorkArea.right) {
            lpIMC->ptStatusWndPos.x = sImeG.rcWorkArea.right -
                sImeG.xStatusWi;
        } else {
            lpIMC->ptStatusWndPos.x = ptWnd.x;
        }

        lpIMC->ptStatusWndPos.y = sImeG.rcWorkArea.bottom -
            sImeG.yStatusHi;

#else
        RECT rcWorkArea;

        rcWorkArea = ImeMonitorWorkAreaFromWindow(lpIMC->hWnd);

        lpIMC->ptStatusWndPos.x = rcWorkArea.left;

        lpIMC->ptStatusWndPos.y = rcWorkArea.bottom -
            sImeG.yStatusHi;
#endif
        lpIMC->fdwInit |= INIT_STATUSWNDPOS;
    }

    if (!(lpIMC->fdwInit & INIT_COMPFORM)) {
        lpIMC->cfCompForm.dwStyle = CFS_DEFAULT;
    }

    if (lpIMC->cfCompForm.dwStyle != CFS_DEFAULT) {
    } else if (!lpIMC->hWnd) {
    } else {
        POINT ptWnd;

        ptWnd = lpImeL->ptDefComp;
        ScreenToClient(lpIMC->hWnd, &ptWnd);
        lpIMC->cfCompForm.dwStyle = CFS_DEFAULT;
        lpIMC->cfCompForm.ptCurrentPos = ptWnd;
        lpIMC->fdwInit |= INIT_COMPFORM;
    }

    return;
}


/**********************************************************************/
/* Select()                                                           */
/* Return Value:                                                      */
/*      TRUE - successful, FALSE - failure                            */
/**********************************************************************/
BOOL PASCAL Select(
    HIMC           hIMC,
    LPINPUTCONTEXT lpIMC,
    BOOL           fSelect)
{
    LPPRIVCONTEXT  lpImcP;

    if (fSelect) {

        if (!ClearCompStr(lpIMC))
            return FALSE;

        if (!ClearCand(lpIMC))
            return FALSE;

        ClearGuideLine(lpIMC);
    }

    if (lpIMC->cfCandForm[0].dwIndex != 0)
        lpIMC->cfCandForm[0].dwStyle = CFS_DEFAULT;

    // We add this hack for switching from other IMEs, this IME has a bug.
    // Before this bug fixed in this IME, it depends on this hack.
    if (lpIMC->cfCandForm[0].dwStyle == CFS_DEFAULT) {
        lpIMC->cfCandForm[0].dwIndex = (DWORD)-1;
    }

    if (!lpIMC->hPrivate)
        return FALSE;

    lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
    if (!lpImcP)
        return FALSE;

    if (fSelect) {

        static BOOL  bFirstTimeCallHere = TRUE;
        //
        // Init. ime character
        //
        InitImeCharac(0);

        InterlockedIncrement( &lLock );

        if ( bFirstTimeCallHere == TRUE )  {

            GetCurrentUserEMBPath( );
            bFirstTimeCallHere = FALSE;
        }

        InterlockedDecrement( &lLock );

        //
        // init fields of hPrivate
        //
        lpImcP->iImeState = CST_INIT;
        lpImcP->fdwImeMsg = (DWORD) 0;
        lpImcP->dwCompChar = (DWORD) 0;
        lpImcP->fdwGcsFlag = (DWORD) 0;
        lpImcP->uSYHFlg = 0x00000000;
        lpImcP->uDYHFlg = 0x00000000;
        lpImcP->uDSMHCount = 0x00000000;
        lpImcP->uDSMHFlg = 0x00000000;
        lpImcP->iActMBIndex = 0;
        lstrcpy(lpImcP->MB_Name, HMapTab[0].MB_Name);

        lpImcP->PrivateArea.Comp_Status.dwSTLX = 0;
        lpImcP->PrivateArea.Comp_Status.dwSTMULCODE = 0;
        lpImcP->PrivateArea.Comp_Status.dwInvalid = 0;
        lpImcP->PrivateArea.Comp_Status.OnLineCreWord = 0;

        //
        // Set IME properties
        //
        lpImcP->PrivateArea.Comp_Status.dwPPTLX = MBIndex.IMEChara[lpImcP->iActMBIndex].IC_LX;
        lpImcP->PrivateArea.Comp_Status.dwPPCZ = MBIndex.IMEChara[lpImcP->iActMBIndex].IC_CZ;
        lpImcP->PrivateArea.Comp_Status.dwPPTS = MBIndex.IMEChara[lpImcP->iActMBIndex].IC_TS;
        lpImcP->PrivateArea.Comp_Status.dwPPCTS = MBIndex.IMEChara[lpImcP->iActMBIndex].IC_CTC;
        lpImcP->PrivateArea.Comp_Status.dwTraceCusr = MBIndex.IMEChara[lpImcP->iActMBIndex].IC_Trace;
                
        CWCodeStr[0] = 0;
        CWDBCSStr[0] = 0;
        
        lpIMC->fOpen = TRUE;

        if (!(lpIMC->fdwInit & INIT_CONVERSION)) {
            lpIMC->fdwConversion = (lpIMC->fdwConversion & IME_CMODE_SOFTKBD) |
                IME_CMODE_NATIVE;
            lpIMC->fdwInit |= INIT_CONVERSION;
        }

        if (!(lpIMC->fdwInit & INIT_LOGFONT)) {
            HDC hDC;
            HGDIOBJ hSysFont;

            //hSysFont = GetStockObject(SYSTEM_FONT);
            hDC = GetDC(NULL);
            hSysFont = GetCurrentObject(hDC, OBJ_FONT);
            GetObject(hSysFont, sizeof(LOGFONT), &lpIMC->lfFont.A);
            ReleaseDC(NULL, hDC);

            lpIMC->fdwInit |= INIT_LOGFONT;
        }

        InitContext(lpIMC);

        //
        // Set Caps status
        //
        {
            DWORD fdwConversion;
        
            if (GetKeyState(VK_CAPITAL) & 0x01) {

                //
                // Change to alphanumeric mode.
                //
               fdwConversion = lpIMC->fdwConversion &
                        ~(IME_CMODE_NATIVE | IME_CMODE_CHARCODE | IME_CMODE_EUDC);
            } else {

                //
                // Change to native mode
                //
                fdwConversion = (lpIMC->fdwConversion | IME_CMODE_NATIVE) &
                        ~(IME_CMODE_CHARCODE | IME_CMODE_EUDC );
            }

            ImmSetConversionStatus(hIMC, fdwConversion, lpIMC->fdwSentence);
        }

    } else {

        if (lpImeL->hSKMenu) {
            DestroyMenu(lpImeL->hSKMenu);
            lpImeL->hSKMenu = NULL;
        }

        if (lpImeL->hPropMenu) {
            DestroyMenu(lpImeL->hPropMenu);
            lpImeL->hPropMenu = NULL;
        }

        if (lpImeL->hObjImeMenu) {
            DestroyMenu(lpImeL->hObjImeMenu);
            lpImeL->hObjImeMenu = NULL;
        }

        if (hCrtDlg) {
            SendMessage(hCrtDlg, WM_CLOSE, (WPARAM)NULL, (LPARAM)NULL);
            hCrtDlg = NULL;
        }
    }

    //
    // Start or end MB engine
    //
    if (fSelect) {
        StartEngine(lpIMC->hPrivate);
        SaTC_Trace = MBIndex.IMEChara[0].IC_Trace;
    } else {
        EndEngine(lpIMC->hPrivate);
    }

    ImmUnlockIMCC(lpIMC->hPrivate);

    return (TRUE);
}

/**********************************************************************/
/* ImeSelect()                                                        */
/* Return Value:                                                      */
/*      TRUE - successful, FALSE - failure                            */
/**********************************************************************/
BOOL WINAPI ImeSelect(
    HIMC hIMC,
    BOOL fSelect)
{
    LPINPUTCONTEXT lpIMC;
    BOOL           fRet;


    if (!hIMC) {
        return (FALSE);
    }

    lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
    if (!lpIMC) {
        return (FALSE);
    }

    fRet = Select(hIMC, lpIMC, fSelect);

    ImmUnlockIMC(hIMC);

    return (fRet);
}

/**********************************************************************/
/* ImeSetActiveContext()                                              */
/* Return Value:                                                      */
/*      TRUE - successful, FALSE - failure                            */
/**********************************************************************/
BOOL WINAPI ImeSetActiveContext(
    HIMC        hIMC,
    BOOL        fOn)
{
    if (!fOn) {
    } else if (!hIMC) {
    } else {
        LPINPUTCONTEXT lpIMC;
        LPPRIVCONTEXT  lpImcP;

        lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
        if (!lpIMC) {
            goto SetActEnd;
        }

        lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
        if (!lpImcP) {
            goto SetActUnlockIMC;
        }

        InitContext(lpIMC);

        ImmUnlockIMCC(lpIMC->hPrivate);
SetActUnlockIMC:
        ImmUnlockIMC(hIMC);

SetActEnd:
        return (TRUE);
    }

    return (TRUE);
}

/**********************************************************************/
//OpenReg_PathSetup(HKEY *phKey);
/**********************************************************************/
LONG OpenReg_PathSetup(HKEY *phKey)
{
    return RegOpenKeyEx (HKEY_CURRENT_USER,
                         REGSTR_PATH_SETUP,
                         0,
                         KEY_ENUMERATE_SUB_KEYS |
                         KEY_EXECUTE |
                         KEY_QUERY_VALUE,
                         phKey);
}

/**********************************************************************/
//LONG OpenReg_User(HKEY hKey,        // handle of open key 
//                LPCTSTR  lpszSubKey,    // address of name of subkey to open 
//                PHKEY  phkResult);     // address of handle of open key 
/**********************************************************************/
LONG OpenReg_User(HKEY hKey,            // handle of open key 
                  LPCTSTR  lpszSubKey,    // address of name of subkey to open 
                  PHKEY  phkResult)     // address of handle of open key 
{
    return RegOpenKeyEx (hKey,
                         lpszSubKey,
                         0,
                         KEY_ENUMERATE_SUB_KEYS |
                         KEY_EXECUTE |
                         KEY_QUERY_VALUE|KEY_SET_VALUE,       
                         phkResult);
}

VOID InfoMessage(HANDLE hWnd,WORD wMsgID)
{
   TCHAR   szStr[256];

   LoadString(hInst,wMsgID,szStr, sizeof(szStr)/sizeof(TCHAR));
   MessageBox(hWnd,szStr,szWarnTitle,MB_ICONINFORMATION|MB_OK);
}

VOID FatalMessage(HANDLE hWnd,WORD wMsgID)
{
    TCHAR   szStr[256];

    LoadString(hInst,wMsgID,szStr, sizeof(szStr)/sizeof(TCHAR));
    MessageBox(hWnd,szStr,szErrorTitle,MB_ICONSTOP|MB_OK);
}