windows-xp/Source/XPSP1/NT/windows/feime/ddk/cht/eudc/imeeudc.c

/*++

Copyright (c) 1990-1998 Microsoft Corporation, All Rights Reserved

Module Name:

    IMEEUDC.c
    
++*/

#include <windows.h>
#include <commdlg.h>
#include <imm.h>
#include "imeeudc.h"

//
//   J. J. Lee  9-29-1994
//
//         UI of this program
//  +--------------------------------------------------+
//  +--------------------------------------------------+
//  |                                                  |
//  |                          +------------+          |
//  |                          |    FA40    |          |
//  |                          +------------+          |
//  |                                                  |
//  |                          +------------+  +-----+ |
//  | (IMEName iStartIME + 0)  |   GOLD     |  |  ^  | |
//  |                          +------------+  |  |  | |
//  |                                          |     | |
//  |                          +------------+  |scrol| |
//  | (IMEName iStartIME + 1)  |   WOOD     |  | bar | |
//  |                          +------------+  |     | |
//  |                                          |     | |
//  |                          +------------+  |  |  | |
//  | (IMEName iStartIME + 2)  |   WATER    |  |  V  | |
//  |                          +------------+  +-----+ |
//  |                                                  |
//  |   +----------+                +-----------+      |
//  |   | Register |                |   Abort   |      |
//  |   +----------+                +-----------+      |
//  |                                                  |
//  +--------------------------------------------------+
//
// The scroll bar only appear when there are more than 3 IMEs
//

// This is a sample code for EUDC regsiter a new created word into IMEs



typedef struct _tagREGWORDSTRUCT {
    HKL   hKL;
    BOOL  bUpdate;
    TCHAR szIMEName[16];
    UINT  uIMENameLen;
    TCHAR szReading[14];
    DWORD dwReadingLen;
} REGWORDSTRUCT;

typedef REGWORDSTRUCT FAR *LPREGWORDSTRUCT;


typedef struct _tagIMELINKREGWORD {
    HIMC          hOldIMC;
    HIMC          hRegWordIMC;
    BOOL          fCompMsg;
    UINT          nEudcIMEs;
    UINT          nCurrIME;
    TCHAR         szEudcCodeString[4];
    REGWORDSTRUCT sRegWordStruct[1];
} IMELINKREGWORD;

typedef IMELINKREGWORD FAR *LPIMELINKREGWORD;


typedef struct _tagIMERADICALRECT {
    UINT nStartIME;
    UINT nPerPageIMEs;
    SIZE lTextSize;
    SIZE lCurrReadingExtent;
    HWND hRegWordButton;
    HWND hScrollWnd;
    RECT rcRadical[1];
} IMERADICALRECT;

typedef IMERADICALRECT FAR *LPIMERADICALRECT;


static const TCHAR     szAppName[] = TEXT("EUDC");
static const TCHAR     szMenuName[] = TEXT("ImeEudcMenu");
static const TCHAR     szRegWordCls[] = TEXT("Radical");
static const TCHAR     szImeLinkDlg[] = TEXT("ImeLinkDlg");


typedef struct _tagCOUNTRYSETTING {
    UINT    uCodePage;
    LPCTSTR szCodePage;
} COUNTRYSETTING;

static const COUNTRYSETTING sCountry[] = {
    {
        BIG5_CP, TEXT("BIG5")
    }
    , {
        ALT_BIG5_CP, TEXT("BIG5")
    }
#if defined(UNICODE)
    , {
        UNICODE_CP, TEXT("UNICODE")
    }
#endif
    , {
        GB2312_CP, TEXT("GB2312")
    }
};


static HINSTANCE       hAppInst;


/************************************************************/
/*  SwitchToThisIME                                         */
/************************************************************/
void SwitchToThisIME(
    HWND hWnd,
    UINT uIndex)
{
    LPIMELINKREGWORD lpImeLinkRegWord;
    LPREGWORDSTRUCT  lpRegWordStructTmp;
    LPIMERADICALRECT lpImeLinkRadical;
    DWORD            fdwConversionMode, fdwSentenceMode;

    lpImeLinkRegWord = (LPIMELINKREGWORD)GetWindowLongPtr(hWnd,
        GWL_IMELINKREGWORD);

    if (lpImeLinkRegWord->nCurrIME == uIndex) {
        return;
    }

    if (uIndex >= lpImeLinkRegWord->nEudcIMEs) {
        MessageBeep((UINT)-1);
        return;
    }

    lpImeLinkRadical = (LPIMERADICALRECT)GetWindowLongPtr(hWnd,
        GWL_RADICALRECT);

    if (uIndex < lpImeLinkRadical->nStartIME) {
        lpImeLinkRadical->nStartIME = uIndex;
    } else if ((uIndex - lpImeLinkRadical->nStartIME) >=
        lpImeLinkRadical->nPerPageIMEs) {
        lpImeLinkRadical->nStartIME = uIndex -
            (lpImeLinkRadical->nPerPageIMEs - 1);
                                                 } else {
    }

    // avoid clear composition string
    SendMessage(hWnd, WM_EUDC_COMPMSG, 0, FALSE);

    lpRegWordStructTmp = &lpImeLinkRegWord->sRegWordStruct[uIndex];

    // switch to this IME
    ActivateKeyboardLayout(lpRegWordStructTmp->hKL, 0);

    ImmGetConversionStatus(lpImeLinkRegWord->hRegWordIMC,
        &fdwConversionMode, &fdwSentenceMode);

    fdwConversionMode = (fdwConversionMode | IME_CMODE_EUDC |
        IME_CMODE_NATIVE) | (fdwConversionMode & IME_CMODE_SOFTKBD);
 
    ImmSetConversionStatus(lpImeLinkRegWord->hRegWordIMC,
        fdwConversionMode, fdwSentenceMode);

    SendMessage(hWnd, WM_EUDC_COMPMSG, 0, TRUE);

    lpImeLinkRegWord->nCurrIME = uIndex;

    if(lpImeLinkRadical->hScrollWnd){
        SCROLLINFO scInfo;

        scInfo.cbSize = sizeof(SCROLLINFO);
        scInfo.fMask = SIF_POS;
        scInfo.nPos = lpImeLinkRegWord->nCurrIME;

        SetScrollInfo(lpImeLinkRadical->hScrollWnd, 
            SB_CTL, &scInfo, FALSE);
    }
    InvalidateRect(hWnd, NULL, TRUE);

    *(LPTSTR)&lpRegWordStructTmp->szReading[
        lpRegWordStructTmp->dwReadingLen] = '\0';

    ImmSetCompositionString(lpImeLinkRegWord->hRegWordIMC, SCS_SETSTR,
        NULL, 0, lpRegWordStructTmp->szReading,
        lpRegWordStructTmp->dwReadingLen * sizeof(TCHAR));

    SetFocus(hWnd);

    return;
}

/************************************************************/
/*  RegWordCreate                                           */
/************************************************************/
LPIMELINKREGWORD RegWordCreate(
    HWND hWnd)
{
    HWND             hEudcEditWnd;
    UINT             nLayouts;
    HKL FAR         *lphKL;
    UINT             i, nIMEs;
    DWORD            dwSize;
    LPIMELINKREGWORD lpImeLinkRegWord;
    LPREGWORDSTRUCT  lpRegWordStructTmp;
    TCHAR            szStrBuf[16];
    HDC              hDC;
    SIZE             lTextSize;
    RECT             rcRect;
    LPIMERADICALRECT lpImeLinkRadical;
    TCHAR            szTitle[32];
    TCHAR            szMessage[256];

    hEudcEditWnd = GetWindow(GetParent(hWnd), GW_OWNER);

    nLayouts = GetKeyboardLayoutList(0, NULL);

    lphKL = GlobalAlloc(GPTR, sizeof(HKL) * nLayouts);

    if (!lphKL) {
        return (NULL);
    }

    lpImeLinkRegWord = NULL;

    // get all keyboard layouts, it will include all IMEs
    GetKeyboardLayoutList(nLayouts, lphKL);

    for (i = 0, nIMEs = 0; i < nLayouts; i++) {
        BOOL  fRet;
        HKL   hKL;
        TCHAR szImeEudcDic[80];

        hKL = *(lphKL + i);

        fRet = ImmIsIME(hKL);

        if (!fRet) {            // this is not an IME
            continue;
        }

        szImeEudcDic[0] = '\0';

        fRet = (BOOL) ImmEscape(hKL, (HIMC)NULL, IME_ESC_GET_EUDC_DICTIONARY,
            szImeEudcDic);

        if (!fRet) {
            continue;
        } else if (szImeEudcDic[0]) {
        } else {
            continue;
        }

        *(lphKL + nIMEs) = hKL;     // write back to the same buffer

        nIMEs++;
    }

    if (!nIMEs) {
        LoadString(hAppInst, IDS_NOIME_TITLE, szTitle, sizeof(szTitle) / sizeof(TCHAR));
        LoadString(hAppInst, IDS_NOIME_MSG, szMessage, sizeof(szMessage) / sizeof(TCHAR));

        MessageBox(hEudcEditWnd, szMessage, szTitle, MB_OK);
        goto RegWordCreateFreeHKL;
    }

    // now there are nIMEs can support IME EUDC dictionary
    dwSize = sizeof(IMELINKREGWORD) - sizeof(REGWORDSTRUCT) +
        sizeof(REGWORDSTRUCT) * nIMEs;

    lpImeLinkRegWord = (LPIMELINKREGWORD)GlobalAlloc(GPTR, dwSize);

    if (!lpImeLinkRegWord) {
        LoadString(hAppInst, IDS_NOMEM_TITLE, szTitle, sizeof(szTitle) / sizeof(TCHAR));
        LoadString(hAppInst, IDS_NOMEM_MSG, szMessage, sizeof(szMessage) / sizeof(TCHAR));

        MessageBox(hEudcEditWnd, szMessage, szTitle, MB_OK);
        goto RegWordCreateFreeHKL;
    }

    lpImeLinkRegWord->nEudcIMEs = nIMEs;

    lpRegWordStructTmp = &lpImeLinkRegWord->sRegWordStruct[0];

    for (i = 0; i < nIMEs; i++) {
        LRESULT lRet;
#ifndef UNICODE
        UINT    j, uInternal;
#endif
        UINT    uReadingSize;

        lpRegWordStructTmp->hKL = *(lphKL + i);

        lRet = ImmEscape(lpRegWordStructTmp->hKL, (HIMC)NULL,
            IME_ESC_MAX_KEY, NULL);

        if (!lRet) {
            // error message - can not support this IME!
            lpImeLinkRegWord->nEudcIMEs--;
            continue;
        }

        uReadingSize = sizeof(TCHAR);

#ifndef UNICODE
        for (j = 0; j < 256; j++) {
            uInternal = ImmEscape(lpRegWordStructTmp->hKL, (HIMC)NULL,
                IME_ESC_SEQUENCE_TO_INTERNAL, &j);
            if (uInternal > 255) {
                uReadingSize = sizeof(WCHAR);
                break;
            }
        }
#endif

        if (lRet * uReadingSize > sizeof(lpRegWordStructTmp->szReading) - sizeof(TCHAR)) {
            // error case, we can not support this IME
            // we should count this into data structure
            // error message - the reading of this IME is too long!
            lpImeLinkRegWord->nEudcIMEs--;
            continue;
        }

        lRet = ImmEscape(lpRegWordStructTmp->hKL, (HIMC)NULL,
            IME_ESC_IME_NAME, lpRegWordStructTmp->szIMEName);

        if (!lRet) {
            // error message - can not support this IME!
            lpImeLinkRegWord->nEudcIMEs--;
            continue;
        }

        // avoid length problem
        lpRegWordStructTmp->szIMEName[
            sizeof(lpRegWordStructTmp->szIMEName) / sizeof(TCHAR) - 1] = '\0';

        lpRegWordStructTmp->uIMENameLen =
            lstrlen(lpRegWordStructTmp->szIMEName);

        lpRegWordStructTmp++;
    }

    if (!lpImeLinkRegWord->nEudcIMEs) {
        LoadString(hAppInst, IDS_NOIME_TITLE, szTitle, sizeof(szTitle) / sizeof(TCHAR));
        LoadString(hAppInst, IDS_NOIME_MSG, szMessage, sizeof(szMessage) / sizeof(TCHAR));

        MessageBox(hEudcEditWnd, szMessage, szTitle, MB_OK);
        goto RegWordCreateFreeRegWord;
    }

    LoadString(hAppInst, IDS_CHINESE_CHAR, szStrBuf, sizeof(szStrBuf) / sizeof(TCHAR));

    hDC = GetDC(NULL);
    GetTextExtentPoint(hDC, szStrBuf, lstrlen(szStrBuf), &lTextSize);
    ReleaseDC(NULL, hDC);

    // decide the rectangle of IME radical
    GetWindowRect(hWnd, &rcRect);

    // we can show how many IME per page
    nIMEs = (rcRect.bottom - rcRect.top) / (2 * lTextSize.cy);

    if (lpImeLinkRegWord->nEudcIMEs <= nIMEs) {
        // all IMEs can fit in one page
        nIMEs = lpImeLinkRegWord->nEudcIMEs;
    }

    dwSize = sizeof(IMERADICALRECT) - sizeof(RECT) + sizeof(RECT) *
        RECT_NUMBER * nIMEs;

    lpImeLinkRadical = (LPIMERADICALRECT)GlobalAlloc(GPTR, dwSize);

    if (!lpImeLinkRadical) {
        // we can not handle any IME
        lpImeLinkRegWord->nEudcIMEs = 0;

        LoadString(hAppInst, IDS_NOMEM_TITLE, szTitle, sizeof(szTitle) / sizeof(TCHAR));
        LoadString(hAppInst, IDS_NOMEM_MSG, szMessage, sizeof(szMessage) / sizeof(TCHAR));

        MessageBox(hEudcEditWnd, szMessage, szTitle, MB_OK);
        goto RegWordCreateFreeRegWord;
    }

    lpImeLinkRadical->nStartIME = 0;
    lpImeLinkRadical->nPerPageIMEs = nIMEs;
    lpImeLinkRadical->lTextSize = lTextSize;

    if (lpImeLinkRegWord->nEudcIMEs > nIMEs) {
        // IMEs more than one page, add scroll bar
        SCROLLINFO scInfo;

        // IMEs more than one page, add scroll bar
        lpImeLinkRadical->hScrollWnd = CreateWindowEx(0,
            TEXT("scrollbar"), NULL,
            WS_CHILD|WS_VISIBLE|SBS_VERT,
            rcRect.right - rcRect.left - lTextSize.cx, 0,
            lTextSize.cx, rcRect.bottom - rcRect.top,
            hWnd, 0, hAppInst, NULL);

        scInfo.cbSize = sizeof(SCROLLINFO);
        scInfo.fMask = SIF_ALL;
        scInfo.nMin = 0;
        scInfo.nMax = lpImeLinkRegWord->nEudcIMEs - 1 + (nIMEs - 1);
        scInfo.nPage = nIMEs;
        scInfo.nPos = 0;
        scInfo.nTrackPos = 0;

        SetScrollInfo(lpImeLinkRadical->hScrollWnd, SB_CTL, &scInfo, FALSE);
    }

    // decide the UI dimension
    for (i = 0; i < nIMEs; i++) {
        UINT j, k;

        // rectangle for IME name
        j = i * RECT_NUMBER + RECT_IMENAME;

        lpImeLinkRadical->rcRadical[j].left = lTextSize.cx;

        // add UI margin - UI_MARGIN
        lpImeLinkRadical->rcRadical[j].top = lTextSize.cy * (i * 4 + 1) / 2 -
            UI_MARGIN;

        lpImeLinkRadical->rcRadical[j].right =
            lpImeLinkRadical->rcRadical[j].left + lTextSize.cx * 4;

        // add UI margin - UI_MARGIN * 2
        lpImeLinkRadical->rcRadical[j].bottom =
            lpImeLinkRadical->rcRadical[j].top + lTextSize.cy +
            UI_MARGIN * 2;

        // rectangle for radical
        k = i * RECT_NUMBER + RECT_RADICAL;

        lpImeLinkRadical->rcRadical[k].left =
            lpImeLinkRadical->rcRadical[j].right + lTextSize.cx;

        // add UI margin - UI_MARGIN
        lpImeLinkRadical->rcRadical[k].top =
            lpImeLinkRadical->rcRadical[j].top;

        lpImeLinkRadical->rcRadical[k].right =
            lpImeLinkRadical->rcRadical[k].left + lTextSize.cx *
            (sizeof(lpRegWordStructTmp->szReading) / sizeof(TCHAR) / 2 - 1);

        // add UI margin - UI_MARGIN * 2
        lpImeLinkRadical->rcRadical[k].bottom =
            lpImeLinkRadical->rcRadical[k].top + lTextSize.cy +
            UI_MARGIN * 2;
    }

    SetWindowLongPtr(hWnd, GWL_RADICALRECT, (LONG_PTR)lpImeLinkRadical);

RegWordCreateFreeRegWord:
    if (!lpImeLinkRegWord->nEudcIMEs) {
        GlobalFree((HGLOBAL)lpImeLinkRegWord);
        lpImeLinkRegWord = NULL;
    }

RegWordCreateFreeHKL:
    GlobalFree((HGLOBAL)lphKL);

    return (lpImeLinkRegWord);
}

/************************************************************/
/*  WmImeComposition                                        */
/************************************************************/
void WmImeComposition(
    HWND   hWnd,
    LPARAM lParam)
{
    LPIMELINKREGWORD lpImeLinkRegWord;
    LPREGWORDSTRUCT  lpRegWordStructTmp;
    LONG             lRet;
    BOOL             bUpdate;
    TCHAR            szReading[sizeof(lpRegWordStructTmp->szReading)];

    lpImeLinkRegWord = (LPIMELINKREGWORD)GetWindowLongPtr(hWnd,
        GWL_IMELINKREGWORD);

    lpRegWordStructTmp = &lpImeLinkRegWord->sRegWordStruct[
        lpImeLinkRegWord->nCurrIME];

    lRet = ImmGetCompositionString(lpImeLinkRegWord->hRegWordIMC,
        GCS_COMPREADSTR, szReading, sizeof(szReading));

    if (lRet < 0) {
        lpRegWordStructTmp->bUpdate = UPDATE_ERROR;
        return;
    }

    if (lRet > (sizeof(szReading) - sizeof(TCHAR))) {
        lRet = sizeof(szReading) - sizeof(TCHAR);
    }

    szReading[lRet / sizeof(TCHAR)] = '\0';

    if (lpRegWordStructTmp->dwReadingLen != (DWORD)lRet / sizeof(TCHAR)) {
        bUpdate = TRUE;
    } else if (lstrcmp(lpRegWordStructTmp->szReading, szReading)) {
        bUpdate = TRUE;
    } else {
        bUpdate = FALSE;
    }

    if (bUpdate) {
        LPIMERADICALRECT lpImeLinkRadical;
        UINT             i;
        UINT             j, k;

        lpImeLinkRadical = (LPIMERADICALRECT)GetWindowLongPtr(hWnd,
            GWL_RADICALRECT);

        lstrcpy(lpRegWordStructTmp->szReading, szReading);

        if (lParam & GCS_RESULTSTR) {
            lpRegWordStructTmp->bUpdate = UPDATE_FINISH;
        } else {
            lpRegWordStructTmp->bUpdate = UPDATE_START;
        }

        lpRegWordStructTmp->dwReadingLen = (DWORD)lRet / sizeof(TCHAR);

        if (!IsWindowEnabled(lpImeLinkRadical->hRegWordButton)) {
            EnableWindow(lpImeLinkRadical->hRegWordButton, TRUE);
        }

        i = lpImeLinkRegWord->nCurrIME - lpImeLinkRadical->nStartIME;

        j = i * RECT_NUMBER + RECT_IMENAME;

        InvalidateRect(hWnd, &lpImeLinkRadical->rcRadical[j], FALSE);

        k = i * RECT_NUMBER + RECT_RADICAL;

        InvalidateRect(hWnd, &lpImeLinkRadical->rcRadical[k], FALSE);
    } else if (lParam & GCS_RESULTSTR) {
        LPIMERADICALRECT lpImeLinkRadical;
        UINT             i;
        UINT             j, k;

        lpImeLinkRadical = (LPIMERADICALRECT)GetWindowLongPtr(hWnd,
            GWL_RADICALRECT);

        if (lpRegWordStructTmp->bUpdate) {
            lpRegWordStructTmp->bUpdate = UPDATE_FINISH;
        }

        i = lpImeLinkRegWord->nCurrIME - lpImeLinkRadical->nStartIME;

        j = i * RECT_NUMBER + RECT_IMENAME;

        InvalidateRect(hWnd, &lpImeLinkRadical->rcRadical[j], FALSE);

        k = i * RECT_NUMBER + RECT_RADICAL;

        InvalidateRect(hWnd, &lpImeLinkRadical->rcRadical[k], FALSE);
    } else {
    }

    return;
}

/************************************************************/
/*  lstrcmpn                                                */
/************************************************************/
int lstrcmpn(
    LPCTSTR lpctszStr1,
    LPCTSTR lpctszStr2,
    int     cCount)
{
    int i;

    for (i = 0; i < cCount; i++) {
        int iCmp = *lpctszStr1++ - *lpctszStr2++;
        if (iCmp) { return iCmp; }
    }

    return 0;
}

/************************************************************/
/*  EnumReading                                             */
/************************************************************/
int CALLBACK EnumReading(
    LPCTSTR         lpszReading,
    DWORD           dwStyle,
    LPCTSTR         lpszString,
    LPREGWORDSTRUCT lpRegWordStructTmp)
{
    int     iLen;
    DWORD   dwZeroSeq;
    LRESULT lRet;
    TCHAR   tszZeroSeq[8];

    iLen = lstrlen(lpszReading);

    if (iLen * sizeof(TCHAR) > sizeof(lpRegWordStructTmp->szReading) -
        sizeof(WORD)) {
        return (0);
    }

    lpRegWordStructTmp->dwReadingLen = (DWORD)iLen;

    lstrcpy(lpRegWordStructTmp->szReading, lpszReading);

    dwZeroSeq = 0;
    lRet = ImmEscape(lpRegWordStructTmp->hKL, (HIMC)NULL,
        IME_ESC_SEQUENCE_TO_INTERNAL, &dwZeroSeq);

    if (!lRet) { return (1); }

    iLen = 0;

    if (LOWORD(lRet)) {
#ifdef UNICODE
        tszZeroSeq[iLen++] = LOWORD(lRet);
#else
        if (LOWORD(lRet) > 0xFF) {
            tszZeroSeq[iLen++] = HIBYTE(LOWORD(lRet));
            tszZeroSeq[iLen++] = LOBYTE(LOWORD(lRet));
        } else {
            tszZeroSeq[iLen++] = LOBYTE(LOWORD(lRet));
        }
#endif
    }

    if (HIWORD(lRet) == 0xFFFF) {
        // This is caused by sign extent in Win9x in the return value of
        // ImmEscape, it causes an invalid internal code.
    } else if (HIWORD(lRet)) {
#ifdef UNICODE
        tszZeroSeq[iLen++] = HIWORD(lRet);
#else
        if (HIWORD(lRet) > 0xFF) {
            tszZeroSeq[iLen++] = HIBYTE(HIWORD(lRet));
            tszZeroSeq[iLen++] = LOBYTE(HIWORD(lRet));
        } else {
            tszZeroSeq[iLen++] = LOBYTE(HIWORD(lRet));
        }
#endif
    } else {
    }

    for (; lpRegWordStructTmp->dwReadingLen > 0;
        lpRegWordStructTmp->dwReadingLen -= iLen) {
        if (lstrcmpn(&lpRegWordStructTmp->szReading[
            lpRegWordStructTmp->dwReadingLen - iLen], tszZeroSeq, iLen) != 0) {
            break;
        }
    }

    lpRegWordStructTmp->szReading[lpRegWordStructTmp->dwReadingLen] = '\0';

    return (1);
}

/************************************************************/
/*  EudcCode                                                */
/************************************************************/
void EudcCode(
    HWND hWnd,
    UINT uCode)
{
    LPIMELINKREGWORD lpImeLinkRegWord;
    LPREGWORDSTRUCT  lpRegWordStructTmp;
    UINT             i;

    lpImeLinkRegWord = (LPIMELINKREGWORD)GetWindowLongPtr(hWnd,
        GWL_IMELINKREGWORD);

#ifdef UNICODE
    lpImeLinkRegWord->szEudcCodeString[0] = (WCHAR)uCode;
#else
    lpImeLinkRegWord->szEudcCodeString[0] = HIBYTE(uCode);
    lpImeLinkRegWord->szEudcCodeString[1] = LOBYTE(uCode);
#endif
    lpImeLinkRegWord->szEudcCodeString[2] =
        lpImeLinkRegWord->szEudcCodeString[3] = '\0';

    lpRegWordStructTmp = &lpImeLinkRegWord->sRegWordStruct[0];

    for (i = 0; i < lpImeLinkRegWord->nEudcIMEs; i++) {
        lpRegWordStructTmp->bUpdate = UPDATE_NONE;
        lpRegWordStructTmp->szReading[0] = '\0';
        lpRegWordStructTmp->dwReadingLen = 0;

        ImmEnumRegisterWord(lpRegWordStructTmp->hKL, EnumReading,
            NULL, IME_REGWORD_STYLE_EUDC,
            lpImeLinkRegWord->szEudcCodeString,
            lpRegWordStructTmp);

        lpRegWordStructTmp->dwReadingLen = lstrlen(lpRegWordStructTmp->szReading);

        lpRegWordStructTmp++;
    }

    lpRegWordStructTmp = &lpImeLinkRegWord->sRegWordStruct[
        lpImeLinkRegWord->nCurrIME];

    ImmSetCompositionString(lpImeLinkRegWord->hRegWordIMC, SCS_SETSTR,
        NULL, 0, lpRegWordStructTmp->szReading,
        lpRegWordStructTmp->dwReadingLen * sizeof(TCHAR));

    InvalidateRect(hWnd, NULL, FALSE);

    return;
}

/************************************************************/
/*  ChangeToOtherIME                                        */
/************************************************************/
void ChangeToOtherIME(
    HWND   hWnd,
    LPARAM lMousePos)
{
    POINT            ptMouse;
    LPIMERADICALRECT lpImeLinkRadical;
    UINT             i;
    BOOL             bFound;

    ptMouse.x = LOWORD(lMousePos);
    ptMouse.y = HIWORD(lMousePos);

    lpImeLinkRadical = (LPIMERADICALRECT)GetWindowLongPtr(hWnd,
        GWL_RADICALRECT);

    bFound = FALSE;

    for (i = 0; i < lpImeLinkRadical->nPerPageIMEs; i++) {
        UINT j;

        j = i * RECT_NUMBER + RECT_RADICAL;

        if (PtInRect(&lpImeLinkRadical->rcRadical[j], ptMouse)) {
            bFound = TRUE;
            break;
        }
    }

    if (!bFound) {
        return;
    }

    SwitchToThisIME(hWnd, lpImeLinkRadical->nStartIME + i);

    return;
}

/************************************************************/
/*  ScrollIME                                               */
/************************************************************/
void ScrollIME(
    HWND   hWnd,
    WPARAM wParam)
{
    LPIMELINKREGWORD lpImeLinkRegWord;
    LPIMERADICALRECT lpImeLinkRadical;
    int              iLines;
    UINT             uIndex;

    lpImeLinkRegWord = (LPIMELINKREGWORD)GetWindowLongPtr(hWnd,
        GWL_IMELINKREGWORD);

    lpImeLinkRadical = (LPIMERADICALRECT)GetWindowLongPtr(hWnd,
        GWL_RADICALRECT);

    switch (LOWORD(wParam)) {
    case SB_PAGEDOWN:
        // scroll (page size - 1)
        iLines = lpImeLinkRadical->nPerPageIMEs - 1;
        break;
    case SB_LINEDOWN:
        iLines = 1;
        break;
    case SB_PAGEUP:
        // scroll (page size - 1)
        iLines = 1 - lpImeLinkRadical->nPerPageIMEs;
        break;
    case SB_LINEUP:
        iLines = -1;
        break;
    case SB_TOP:
        // swicth to the first one
        SwitchToThisIME(hWnd, 0);
        return;
    case SB_BOTTOM:
        // swicth to the last one
        SwitchToThisIME(hWnd, lpImeLinkRegWord->nEudcIMEs - 1);
        return;
    case SB_THUMBPOSITION:
        SwitchToThisIME(hWnd, HIWORD(wParam));
        return;
    default:
        return;
    }

    uIndex = lpImeLinkRegWord->nCurrIME;

    if (iLines > 0) {
        uIndex += (UINT)iLines;

        if (uIndex >= lpImeLinkRegWord->nEudcIMEs) {
            // should not exceed the total IMEs
            uIndex = lpImeLinkRegWord->nEudcIMEs - 1;
        }
    } else {
        UINT uLines;

        uLines = -iLines;

        if (uLines > uIndex) {
            uIndex = 0;
        } else {
            uIndex -= uLines;
        }
    }

    SwitchToThisIME(hWnd, uIndex);

    return;
}

/************************************************************/
/*  ScrollIMEByKey                                          */
/************************************************************/
void ScrollIMEByKey(
    HWND   hWnd,
    WPARAM wParam)
{
    switch (wParam) {
    case VK_NEXT:
        ScrollIME(hWnd, SB_PAGEDOWN);
        break;
    case VK_DOWN:   // can not work because dialog do not pass this key to us
        ScrollIME(hWnd, SB_LINEDOWN);
        break;
    case VK_PRIOR:
        ScrollIME(hWnd, SB_PAGEUP);
        break;
    case VK_UP:     // can not work because dialog do not pass this key to us
        ScrollIME(hWnd, SB_LINEUP);
        break;
    default:
        return;
    }

    return;
}

/************************************************************/
/*  RegWordGetFocus                                         */
/************************************************************/
void RegWordGetFocus(
    HWND hWnd)
{
    LPIMELINKREGWORD lpImeLinkRegWord;
    LPIMERADICALRECT lpImeLinkRadical;
    UINT             i;

    lpImeLinkRegWord = (LPIMELINKREGWORD)GetWindowLongPtr(hWnd,
        GWL_IMELINKREGWORD);

    lpImeLinkRadical = (LPIMERADICALRECT)GetWindowLongPtr(hWnd,
        GWL_RADICALRECT);

    CreateCaret(hWnd, NULL, 2, lpImeLinkRadical->lTextSize.cy +
        CARET_MARGIN * 2);

    if (lpImeLinkRegWord->nCurrIME < lpImeLinkRadical->nStartIME) {
        lpImeLinkRegWord->nCurrIME = lpImeLinkRadical->nStartIME;
    } else if ((lpImeLinkRegWord->nCurrIME - lpImeLinkRadical->nStartIME) >=
        lpImeLinkRadical->nPerPageIMEs) {
        lpImeLinkRegWord->nCurrIME = lpImeLinkRadical->nStartIME +
            lpImeLinkRadical->nPerPageIMEs - 1;
    } else {
    }

    i = lpImeLinkRegWord->nCurrIME - lpImeLinkRadical->nStartIME;

    i = (i * RECT_NUMBER) + RECT_RADICAL;

    SetCaretPos(lpImeLinkRadical->rcRadical[i].left +
        lpImeLinkRadical->lCurrReadingExtent.cx + 2,
        lpImeLinkRadical->rcRadical[i].top + UI_MARGIN - CARET_MARGIN);

    ShowCaret(hWnd);

    return;
}

/************************************************************/
/*  RegWordPaint                                            */
/************************************************************/
void RegWordPaint(
    HWND hWnd)
{
    LPIMERADICALRECT lpImeLinkRadical;
    LPIMELINKREGWORD lpImeLinkRegWord;
    LPREGWORDSTRUCT  lpRegWordStructTmp;
    HDC              hDC;
    PAINTSTRUCT      ps;
    UINT             i;
    UINT             nShowIMEs;

    lpImeLinkRadical = (LPIMERADICALRECT)GetWindowLongPtr(hWnd,
        GWL_RADICALRECT);

    lpImeLinkRegWord = (LPIMELINKREGWORD)GetWindowLongPtr(hWnd,
        GWL_IMELINKREGWORD);

    lpRegWordStructTmp = &lpImeLinkRegWord->sRegWordStruct[
        lpImeLinkRadical->nStartIME];

    HideCaret(hWnd);

    hDC = BeginPaint(hWnd, &ps);

    // we only can show up to the final one
    nShowIMEs = lpImeLinkRegWord->nEudcIMEs - lpImeLinkRadical->nStartIME;

    if (nShowIMEs > lpImeLinkRadical->nPerPageIMEs) {
        // we only can show one page a time
        nShowIMEs = lpImeLinkRadical->nPerPageIMEs;
    }

    for (i = 0; i < nShowIMEs; i++) {
        RECT rcSunken;
        UINT j, k;

        k = i * RECT_NUMBER + RECT_RADICAL;

        rcSunken = lpImeLinkRadical->rcRadical[k];

        rcSunken.left -= 2;
        rcSunken.top -= 2;
        rcSunken.right += 2;
        rcSunken.bottom += 2;

        DrawEdge(hDC, &rcSunken, BDR_SUNKENOUTER, BF_RECT);

        SetBkColor(hDC, GetSysColor(COLOR_BTNFACE));

        if (lpRegWordStructTmp->bUpdate == UPDATE_ERROR) {
            // red text for error
            SetTextColor(hDC, RGB(0xFF, 0x00, 0x00));
        } else if (lpRegWordStructTmp->bUpdate == UPDATE_START) {
            // yellow text for not finished
            SetTextColor(hDC, RGB(0xFF, 0xFF, 0x00));
        } else if (lpRegWordStructTmp->bUpdate == UPDATE_REGISTERED) {
            // green text for registered
            SetTextColor(hDC, RGB(0x00, 0x80, 0x00));
        } else {
            SetTextColor(hDC, GetSysColor(COLOR_WINDOWTEXT));
        }

        j = i * RECT_NUMBER + RECT_IMENAME;

        ExtTextOut(hDC, lpImeLinkRadical->rcRadical[j].left,
            lpImeLinkRadical->rcRadical[j].top,
            ETO_OPAQUE|ETO_CLIPPED, &lpImeLinkRadical->rcRadical[j],
            lpRegWordStructTmp->szIMEName,
            lpRegWordStructTmp->uIMENameLen, NULL);

        if ((lpImeLinkRegWord->nCurrIME - lpImeLinkRadical->nStartIME) == i) {
            SetBkColor(hDC, GetSysColor(COLOR_WINDOW));
            SetTextColor(hDC, GetSysColor(COLOR_WINDOWTEXT));

            GetTextExtentPoint(hDC, lpRegWordStructTmp->szReading,
                lpRegWordStructTmp->dwReadingLen,
                &lpImeLinkRadical->lCurrReadingExtent);

            SetCaretPos(lpImeLinkRadical->rcRadical[k].left +
                lpImeLinkRadical->lCurrReadingExtent.cx + 2,
                lpImeLinkRadical->rcRadical[k].top + UI_MARGIN - CARET_MARGIN);
        } else {
            SetTextColor(hDC, GetSysColor(COLOR_WINDOWTEXT));
        }

        ExtTextOut(hDC, lpImeLinkRadical->rcRadical[k].left,
            lpImeLinkRadical->rcRadical[k].top + UI_MARGIN,
            ETO_OPAQUE, &lpImeLinkRadical->rcRadical[k],
            lpRegWordStructTmp->szReading,
            lpRegWordStructTmp->dwReadingLen, NULL);

        lpRegWordStructTmp++;
    }

    EndPaint(hWnd, &ps);

    ShowCaret(hWnd);

    return;
}

/************************************************************/
/*  RegWordWndProc                                          */
/************************************************************/
LRESULT CALLBACK RegWordWndProc(
    HWND   hWnd,
    UINT   uMsg,
    WPARAM wParam,
    LPARAM lParam)
{
    switch (uMsg) {
    case WM_CREATE:
        {
            LPIMELINKREGWORD lpImeLinkRegWord;
            UINT             uIndex;

            // initialize to 0
            SetWindowLongPtr(hWnd, GWL_IMELINKREGWORD, 0L);
            SetWindowLongPtr(hWnd, GWL_RADICALRECT, 0L);

            lpImeLinkRegWord = RegWordCreate(hWnd);

            if (!lpImeLinkRegWord) {
                return (-1);
            }

            lpImeLinkRegWord->fCompMsg = TRUE;
            lpImeLinkRegWord->nCurrIME = 0xFFFFFFFF;

            lpImeLinkRegWord->hRegWordIMC = ImmCreateContext();

            if (!lpImeLinkRegWord->hRegWordIMC) {
                return (-1);
            }

            lpImeLinkRegWord->hOldIMC = ImmAssociateContext(hWnd,
                lpImeLinkRegWord->hRegWordIMC);

            SetWindowLongPtr(hWnd, GWL_IMELINKREGWORD, (LONG_PTR)lpImeLinkRegWord);

            uIndex = 0;
            SwitchToThisIME(hWnd, 0);

            // the switch will fail, if the window is disable, try again
            PostMessage(hWnd, WM_EUDC_SWITCHIME, 0, uIndex);
        }
        break;
    case WM_EUDC_COMPMSG:
        {
            LPIMELINKREGWORD lpImeLinkRegWord;

            lpImeLinkRegWord = (LPIMELINKREGWORD)GetWindowLongPtr(hWnd,
                GWL_IMELINKREGWORD);

            lpImeLinkRegWord->fCompMsg = (BOOL)lParam;
        }
        break;
    case WM_EUDC_SWITCHIME:
        {
            LPIMELINKREGWORD lpImeLinkRegWord;

            lpImeLinkRegWord = (LPIMELINKREGWORD)GetWindowLongPtr(hWnd,
                GWL_IMELINKREGWORD);

            lpImeLinkRegWord->nCurrIME = 0xFFFFFFFF;

            SwitchToThisIME(hWnd, (UINT)lParam);
        }
        break;
    case WM_IME_STARTCOMPOSITION:
    case WM_IME_ENDCOMPOSITION:
        break;
    case WM_IME_COMPOSITION:
        {
            LPIMELINKREGWORD lpImeLinkRegWord;

            lpImeLinkRegWord = (LPIMELINKREGWORD)GetWindowLongPtr(hWnd,
                GWL_IMELINKREGWORD);

            if (lpImeLinkRegWord->fCompMsg) {
                WmImeComposition(hWnd, lParam);
            }
        }
        break;
    case WM_IME_NOTIFY:
        switch (wParam) {
        case IMN_OPENSTATUSWINDOW:
        case IMN_CLOSESTATUSWINDOW:
        case IMN_OPENCANDIDATE:
        case IMN_CHANGECANDIDATE:
        case IMN_CLOSECANDIDATE:
            break;
        default:
            return DefWindowProc(hWnd, uMsg, wParam, lParam);
        }
        break;
    case WM_IME_SETCONTEXT:
        return DefWindowProc(hWnd, uMsg, wParam, lParam & ~(ISC_SHOWUIALL));
    case WM_EUDC_REGISTER_BUTTON:
        {
            LPIMERADICALRECT lpImeRadicalRect;

            lpImeRadicalRect = (LPIMERADICALRECT)GetWindowLongPtr(hWnd,
                GWL_RADICALRECT);

            lpImeRadicalRect->hRegWordButton = (HWND)lParam;
        }
        break;
    case WM_EUDC_CODE:
        EudcCode(hWnd, (UINT)lParam);
        break;
    case WM_LBUTTONDOWN:
        ChangeToOtherIME(hWnd, lParam);
        break;
    case WM_VSCROLL:
        ScrollIME(hWnd, wParam);
        break;
    case WM_KEYDOWN:
        ScrollIMEByKey(hWnd, wParam);
        break;
    case WM_SETFOCUS:
        RegWordGetFocus(hWnd);
        break;
    case WM_KILLFOCUS:
        DestroyCaret();
        break;
    case WM_PAINT:
        RegWordPaint(hWnd);
        break;
    case WM_DESTROY:
        {
            LPIMERADICALRECT lpImeRadicalRect;
            LPIMELINKREGWORD lpImeLinkRegWord;

            lpImeRadicalRect = (LPIMERADICALRECT)GetWindowLongPtr(hWnd,
                GWL_RADICALRECT);

            if (lpImeRadicalRect) {
                GlobalFree((HGLOBAL)lpImeRadicalRect);
            }

            lpImeLinkRegWord = (LPIMELINKREGWORD)GetWindowLongPtr(hWnd,
                GWL_IMELINKREGWORD);

            if (!lpImeLinkRegWord) {
                break;
            }

            ImmAssociateContext(hWnd, lpImeLinkRegWord->hOldIMC);

            ImmDestroyContext(lpImeLinkRegWord->hRegWordIMC);

            GlobalFree((HGLOBAL)lpImeLinkRegWord);
        }
        break;
    default:
        return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }

    return (0L);
}

/************************************************************/
/*  RegisterThisEudc                                        */
/************************************************************/
int RegisterThisEudc(
    HWND hWnd)
{
    LPIMELINKREGWORD lpImeLinkRegWord;
    LPREGWORDSTRUCT  lpRegWordStructTmp;
    UINT             i;
    int              iRet;

    lpImeLinkRegWord = (LPIMELINKREGWORD)GetWindowLongPtr(hWnd,
        GWL_IMELINKREGWORD);

    lpRegWordStructTmp = &lpImeLinkRegWord->sRegWordStruct[0];

    iRet = -1;

    for (i = 0; i < lpImeLinkRegWord->nEudcIMEs; i++, lpRegWordStructTmp++) {
        if (lpRegWordStructTmp->bUpdate == UPDATE_NONE) {
        } else if (lpRegWordStructTmp->bUpdate != UPDATE_FINISH) {
            TCHAR szStrBuf[128];
            int   iYesNo;

            if (iRet != -1) {
                continue;
            }

            LoadString(hAppInst, IDS_QUERY_NOTFINISH, szStrBuf,
                sizeof(szStrBuf) / sizeof(TCHAR));

            iYesNo = MessageBox(hWnd, szStrBuf,
                lpRegWordStructTmp->szIMEName,
                MB_APPLMODAL|MB_YESNO|MB_DEFBUTTON1);

            if (iYesNo == IDYES) {
                iRet = i;
            }
        } else {
            BOOL  fRet;
            TCHAR szStrBuf[128];
            int   iYesNo;

            fRet = ImmRegisterWord(lpRegWordStructTmp->hKL,
                lpRegWordStructTmp->szReading, IME_REGWORD_STYLE_EUDC,
                lpImeLinkRegWord->szEudcCodeString);

            if (fRet) {
                lpRegWordStructTmp->bUpdate = UPDATE_REGISTERED;
                continue;
            } else {
                lpRegWordStructTmp->bUpdate = UPDATE_ERROR;
            }

            if (iRet != -1) {
                continue;
            }

            LoadString(hAppInst, IDS_QUERY_REGISTER, szStrBuf,
                sizeof(szStrBuf) / sizeof(TCHAR));

            iYesNo = MessageBox(hWnd, szStrBuf,
                lpRegWordStructTmp->szIMEName,
                MB_APPLMODAL|MB_YESNO|MB_DEFBUTTON1);

            if (iYesNo == IDYES) {
                iRet = i;
            }
        }
    }

    InvalidateRect(hWnd, NULL, FALSE);

    return (iRet);
}

/************************************************************/
/*  CodePageInfo()                                          */
/************************************************************/
int CodePageInfo(
    UINT uCodePage)
{
    int i;

    for (i = 0; i < sizeof(sCountry) / sizeof(COUNTRYSETTING); i++) {
        if (sCountry[i].uCodePage == uCodePage) {
            return(i);
        }
    }

    return (-1);
}

/************************************************************/
/*  ImeLinkDlgProc                                          */
/************************************************************/
INT_PTR CALLBACK ImeLinkDlgProc(
    HWND   hDlg,
    UINT   uMsg,
    WPARAM wParam,
    LPARAM lParam)
{
    switch (uMsg) {
    case WM_INITDIALOG:
        {
            HWND  hRadicalWnd, hRegWordButton;
            int   cbString;
#ifdef UNICODE    // this code could not run under non NATIVE platforms
            UINT  uCodePage, uNativeCode;
            int   i;
#endif
            TCHAR szTitle[128];

            cbString = GetWindowText(hDlg, szTitle, sizeof(szTitle) /
                sizeof(TCHAR));

#ifdef UNICODE
            uCodePage = GetACP();

            i = CodePageInfo(uCodePage);

            if (uCodePage == UNICODE_CP || i == -1) {
                wsprintf(&szTitle[cbString], TEXT("%4X"), (UINT)lParam);
            } else {
                uNativeCode = 0;

                WideCharToMultiByte(uCodePage, WC_COMPOSITECHECK,
                    (LPCWSTR)&lParam, 1,
                    (LPSTR)&uNativeCode, sizeof(uNativeCode),
                    NULL, NULL);

                // convert to multi byte string
                uNativeCode = LOBYTE(uNativeCode) << 8 | HIBYTE(uNativeCode);

                wsprintf(&szTitle[cbString], TEXT("%4X (%s - %4X)"),
                    (UINT)lParam, sCountry[i].szCodePage, (UINT)uNativeCode);
            }
#else
            wsprintf(&szTitle[cbString], TEXT("%4X"), (UINT)lParam);
#endif

            SetWindowText(hDlg, szTitle);

            hRadicalWnd = GetDlgItem(hDlg, IDD_RADICAL);

            SendMessage(hRadicalWnd, WM_EUDC_CODE, 0, lParam);

            hRegWordButton = GetDlgItem(hDlg, IDOK);

            EnableWindow(hRegWordButton, FALSE);

            SendMessage(hRadicalWnd, WM_EUDC_REGISTER_BUTTON, 0,
                (LPARAM)hRegWordButton);
        }
        return (TRUE);      // do not want to set focus to special control
    case WM_COMMAND:
        switch (wParam) {
        case IDOK:
            {
                HWND  hRadicalWnd;

                hRadicalWnd = GetDlgItem(hDlg, IDD_RADICAL);

                if (RegisterThisEudc(hRadicalWnd) == -1) {
                    EndDialog(hDlg, TRUE);
                } else {
                    SetFocus(hRadicalWnd);
                }
            }

            break;
        case IDCANCEL:
            EndDialog(hDlg, FALSE);
            break;
        default:
            return (FALSE);
        }
        return (TRUE);
    case WM_IME_NOTIFY:
        // we need to hook these messages from frame window also
        // otherwise sometime the OPENSTATUS will send to the frame
        // window and the child - hRadicalWnd will not get these messages
        switch (wParam) {
        case IMN_OPENSTATUSWINDOW:
        case IMN_CLOSESTATUSWINDOW:
            return (TRUE);
        default:
            return (FALSE);
        }
    default:
        return (FALSE);
    }

    return (TRUE);
}

/************************************************************/
/*  ImeLink                                                 */
/************************************************************/
void ImeLink(
    HWND hWnd,
    UINT uCode)
{
    static BOOL bFirstTime = TRUE;

    UINT       nLayouts;
    HKL FAR   *lphKL;
    TCHAR      szTitle[32];
    TCHAR      szMessage[256];
    UINT       i, nIMEs;
    WNDCLASSEX wcClass;
    HKL        hOldKL;

    nLayouts = GetKeyboardLayoutList(0, NULL);

    lphKL = GlobalAlloc(GPTR, sizeof(HKL) * nLayouts);

    if (!lphKL) {
        LoadString(hAppInst, IDS_NOMEM_TITLE, szTitle, sizeof(szTitle) / sizeof(TCHAR));
        LoadString(hAppInst, IDS_NOMEM_MSG, szMessage, sizeof(szMessage) / sizeof(TCHAR));

        MessageBox(hWnd, szMessage, szTitle, MB_OK);
        return;
    }

    // MSVC may have problem for recusive modal dialog box,
    // I mean create a modal dialog box within a modal dialog box.

    // so we need to move the code from RegWordCreate() to here to
    // prevent creating a modal dialog form a modal dialog.
    // The ImmConfigureIME API call is possible to create a modal dialog.

    // get all keyboard layouts, it will include all IMEs
    GetKeyboardLayoutList(nLayouts, lphKL);

    for (i = 0, nIMEs = 0; i < nLayouts; i++) {
        BOOL  fRet;
        HKL   hKL;
        TCHAR szImeEudcDic[80];

        hKL = *(lphKL + i);

        fRet = ImmIsIME(hKL);

        if (!fRet) {            // this is not an IME
            continue;
        }

        szImeEudcDic[0] = '\0';

        fRet = (BOOL) ImmEscape(hKL, (HIMC)NULL, IME_ESC_GET_EUDC_DICTIONARY,
            szImeEudcDic);

        if (!fRet) {
            continue;
        }

        if (szImeEudcDic[0]) {
            fRet = TRUE;
        } else if (!bFirstTime) {
        } else {
            fRet = ImmConfigureIME(hKL, hWnd, IME_CONFIG_SELECTDICTIONARY, NULL);
        }

        if (!fRet) {
            // this IME do not have an IME EUDC dictionary
            continue;
        }

        if (szImeEudcDic[0] == '\0') {
            // check whether we really get a dictionary
            fRet = (BOOL) ImmEscape(hKL, (HIMC)NULL, IME_ESC_GET_EUDC_DICTIONARY,
                szImeEudcDic);

            if (!fRet) {
                continue;
            } else if (szImeEudcDic[0] == '\0') {
                continue;
            } else {
            }
        } else {
        }

        nIMEs++;
    }

    GlobalFree((HGLOBAL)lphKL);

    if (bFirstTime) {
        bFirstTime = FALSE;
    }

    if (!nIMEs) {
        LoadString(hAppInst, IDS_NOIME_TITLE, szTitle, sizeof(szTitle) / sizeof(TCHAR));
        LoadString(hAppInst, IDS_NOIME_MSG, szMessage, sizeof(szMessage) / sizeof(TCHAR));

        MessageBox(hWnd, szMessage, szTitle, MB_OK);
        return;
    }

    if (!GetClassInfoEx(hAppInst, szRegWordCls, &wcClass)) {
        wcClass.cbSize = sizeof(WNDCLASSEX);
        wcClass.style = CS_HREDRAW|CS_VREDRAW;
        wcClass.lpfnWndProc = RegWordWndProc;
        wcClass.cbClsExtra = 0;
        wcClass.cbWndExtra = GWL_SIZE;
        wcClass.hInstance = hAppInst;
        wcClass.hIcon = NULL;
        wcClass.hCursor = LoadCursor(NULL, IDC_ARROW);
        wcClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
        wcClass.lpszMenuName = NULL;
        wcClass.lpszClassName = szRegWordCls;
        wcClass.hIconSm = NULL;
        RegisterClassEx(&wcClass);
    }

    hOldKL = GetKeyboardLayout(0);

    DialogBoxParam(hAppInst, szImeLinkDlg, hWnd, ImeLinkDlgProc,
        (LPARAM)uCode);

    ActivateKeyboardLayout(hOldKL, 0);

    return;
}

/************************************************************/
/*  MatchImeName()                                          */
/************************************************************/
HKL MatchImeName(
    LPCTSTR szStr)
{
    TCHAR     szImeName[16];
    int       nLayout;
    HKL       hKL;
    HGLOBAL   hMem;
    HKL FAR * lpMem;
    int       i;

    nLayout = GetKeyboardLayoutList(0, NULL);

    // alloc temp buffer
    hMem = GlobalAlloc(GHND, sizeof(HKL) * nLayout);

    if (!hMem) {
        return (NULL);
    }

    lpMem = (HKL FAR *)GlobalLock(hMem);

    if (!lpMem) {
        GlobalFree(hMem);
        return (NULL);
    }

    // get all keyboard layouts, it includes all IMEs
    GetKeyboardLayoutList(nLayout, lpMem);

    for (i = 0; i < nLayout; i++) {
        BOOL fRet;

        hKL = *(lpMem + i);

        fRet = (BOOL) ImmEscape(hKL, (HIMC)NULL, IME_ESC_IME_NAME, szImeName);

        if (!fRet) {                // this hKL can not ask name
            continue;
        }

        if (lstrcmp(szStr, szImeName) == 0) {
            goto MatchOvr;
        }
    }

    hKL = NULL;

MatchOvr:
    GlobalUnlock(hMem);
    GlobalFree(hMem);

    return (hKL);
}

/************************************************************/
/*  RegisterTable()                                         */
/************************************************************/
HKL RegisterTable(
    HWND          hWnd,
    LPUSRDICIMHDR lpIsvUsrDic,
    DWORD         dwFileSize,
    UINT          uCodePage)
{
    HKL    hKL;
    HDC    hDC;
    SIZE   lTextSize;
    RECT   rcProcess;
    DWORD  i;
    LPBYTE lpCurr, lpEnd;
    BOOL   fRet;
    TCHAR  szStr[16];
    TCHAR  szProcessFmt[32];
    TCHAR  szResult[2][32];
    TCHAR  szProcessInfo[48];
    WORD   wInternalCode[256];
    WORD   wAltInternalCode[256];

#ifdef UNICODE
    if (uCodePage == UNICODE_CP) {
        LPUNATSTR lpszMethodName;

        lpszMethodName = (LPUNATSTR)lpIsvUsrDic->achMethodName;

        for (i = 0; i < sizeof(lpIsvUsrDic->achMethodName) / sizeof(TCHAR); i++) {
            szStr[i] = *lpszMethodName++;
        }

        szStr[i] = '\0';
    } else {
        UINT uLen;

        uLen = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED,
            (LPCSTR)lpIsvUsrDic->achMethodName,
            sizeof(lpIsvUsrDic->achMethodName),
            szStr,
            sizeof(szStr) / sizeof(TCHAR));

        szStr[uLen] = '\0';
    }
#else
    for (i = 0; i < sizeof(lpIsvUsrDic->achMethodName); i++) {
        szStr[i] = lpIsvUsrDic->achMethodName[i];
    }

    szStr[i] = '\0';
#endif

    hKL = MatchImeName(szStr);

    if (!hKL) {
        return (hKL);
    }

    LoadString(hAppInst, IDS_PROCESS_FMT, szProcessFmt, sizeof(szProcessFmt) / sizeof(TCHAR));
    LoadString(hAppInst, IDS_RESULT_FAIL, szResult[0], sizeof(szResult[0]) / sizeof(TCHAR));
    LoadString(hAppInst, IDS_RESULT_SUCCESS, szResult[1], sizeof(szResult[1]) / sizeof(TCHAR));

    LoadString(hAppInst, IDS_CHINESE_CHAR, szStr, sizeof(szStr) / sizeof(TCHAR));

    hDC = GetDC(NULL);

    GetTextExtentPoint(hDC, szStr, sizeof(WORD)/sizeof(TCHAR),
        &lTextSize);

    ReleaseDC(NULL, hDC);

    // show the processing in somewhere, don't need to be same as this
    rcProcess.left = 1;
    rcProcess.top  = 1;
    rcProcess.right = rcProcess.left + lTextSize.cx *
        sizeof(szProcessInfo) / sizeof(WORD);
    rcProcess.bottom = rcProcess.top + lTextSize.cy;

    // convert sequence code to internal code
    for (i = 0; i < sizeof(wInternalCode) / sizeof(WORD); i++) {
        LRESULT lRet;

        lRet = ImmEscape(hKL, (HIMC)NULL,
            IME_ESC_SEQUENCE_TO_INTERNAL, &i);

        if (HIWORD(lRet) == 0xFFFF) {
            // This is caused by sign extent in Win9x in the return value of
            // ImmEscape, it causes an invalid internal code.
            wAltInternalCode[i] = 0;
        } else {
            wAltInternalCode[i] = HIWORD(lRet);
        }

        wInternalCode[i] = LOWORD(lRet);

#ifndef UNICODE
        if (wAltInternalCode[i] > 0xFF) {
            // convert to multi byte string
            wAltInternalCode[i] = LOBYTE(wAltInternalCode[i]) << 8 |
                HIBYTE(wAltInternalCode[i]);
        }

        if (wInternalCode[i] > 0xFF) {
            // convert to multi byte string
            wInternalCode[i] = LOBYTE(wInternalCode[i]) << 8 |
                HIBYTE(wInternalCode[i]);
        }
#endif
    }

    // check for each record and register it
    // get to the first record and skip the Bank ID
    lpCurr = (LPBYTE)(lpIsvUsrDic + 1) + sizeof(WORD);
    lpEnd = (LPBYTE)lpIsvUsrDic + dwFileSize;

    for (; lpCurr < lpEnd;
        // internal code + sequence code + Bank ID of next record
        lpCurr += sizeof(WORD) + lpIsvUsrDic->cMethodKeySize + sizeof(WORD)) {

        int j;

        // quick way to init \0 for the register string
        *(LPDWORD)szStr = 0;

#ifdef UNICODE
        if (uCodePage == UNICODE_CP) {
            szStr[0] = *(LPUNATSTR)lpCurr;
        } else {
            CHAR szMultiByte[4];

            szMultiByte[0] = HIBYTE(*(LPUNATSTR)lpCurr);
            szMultiByte[1] = LOBYTE(*(LPUNATSTR)lpCurr);

            MultiByteToWideChar(uCodePage, MB_PRECOMPOSED,
                szMultiByte, 2, szStr, 2);
        }
#else
        szStr[1] = *lpCurr;
        szStr[0] = *(lpCurr + 1);
#endif

        for (i = 0, j = 0; i < lpIsvUsrDic->cMethodKeySize; i++) {
            if (!wAltInternalCode[*(LPBYTE)(lpCurr + sizeof(WORD) + i)]) {
            } else if (wAltInternalCode[*(LPBYTE)(lpCurr + sizeof(WORD) + i)] < 0xFF) {
                *(LPTSTR)&szStr[4 + j] = (TCHAR)
                    wAltInternalCode[*(LPBYTE)(lpCurr + sizeof(WORD) + i)];
                j += sizeof(TCHAR) / sizeof(TCHAR);
            } else {
                *(LPWSTR)&szStr[4 + j] = (WCHAR)
                    wAltInternalCode[*(LPBYTE)(lpCurr + sizeof(WORD) + i)];
                j += sizeof(WCHAR) / sizeof(TCHAR);
            }

            if (wInternalCode[*(LPBYTE)(lpCurr + sizeof(WORD) + i)] < 0xFF) {
                *(LPTSTR)&szStr[4 + j] = (TCHAR)
                    wInternalCode[*(LPBYTE)(lpCurr + sizeof(WORD) + i)];
                j += sizeof(TCHAR) / sizeof(TCHAR);
            } else {
                *(LPWSTR)&szStr[4 + j] = (WCHAR)
                    wInternalCode[*(LPBYTE)(lpCurr + sizeof(WORD) + i)];
                j += sizeof(WCHAR) / sizeof(TCHAR);
            }
        }

        szStr[4 + j] = szStr[4 + j + 1] = szStr[4 + j + 2] = '\0';

        fRet = ImmRegisterWord(hKL, &szStr[4], IME_REGWORD_STYLE_EUDC,
            szStr);

        wsprintf(szProcessInfo, szProcessFmt, (LPTSTR)szStr,
            (LPTSTR)&szStr[4], szResult[fRet]);

        hDC = GetDC(hWnd);

        // show the process information
        ExtTextOut(hDC, rcProcess.left, rcProcess.top, ETO_OPAQUE,
            &rcProcess, szProcessInfo, lstrlen(szProcessInfo),
            NULL);

        ReleaseDC(NULL, hDC);

        if (!fRet) {
            // wait 3 seconds for fail case
            Sleep(3000);
        }
    }

    return (hKL);
}

/************************************************************/
/*  BatchImeLink()                                          */
/************************************************************/
void BatchImeLink(
    HWND hWnd)
{
    HANDLE        hIsvUsrDicFile, hIsvUsrDic;
    LPUSRDICIMHDR lpIsvUsrDic;
    TCHAR         chReplace;
    int           i, cbString;
    DWORD         dwSize, dwFileSize;
    LPTSTR        szTitle, szMessage;
    int           iTitle, iMessage;

    OPENFILENAME  ofn;
    TCHAR         szFilter[64];
    TCHAR         szFileName[MAX_PATH];
    TCHAR         szDirName[MAX_PATH];

    // try to share the buffer
    szTitle = szFilter;
    iTitle = sizeof(szFilter) / sizeof(TCHAR);
    szMessage = szDirName;
    iMessage = sizeof(szDirName) / sizeof(TCHAR);

    // internal error, the data structure need byte alignment
    // it should not use WORD or DWORD alignment

    if (sizeof(USRDICIMHDR) != 256) {
        LoadString(hAppInst, IDS_INTERNAL_TITLE, szTitle, iTitle);
        LoadString(hAppInst, IDS_INTERNAL_MSG, szMessage, iMessage);

        MessageBox(hWnd, szMessage, szTitle, MB_OK);
        return;
    }

    // do we need to set a new file name
    cbString = LoadString(hAppInst, IDS_ISV_FILE_FILTER, szFilter,
        sizeof(szFilter) / sizeof(TCHAR));
    chReplace = szFilter[cbString - 1];

    for (i = 0; szFilter[i]; i++) {
        if (szFilter[i] == chReplace) {
            szFilter[i] = '\0';
        }
    }

    GetWindowsDirectory(szDirName, sizeof(szDirName) / sizeof(TCHAR));
    lstrcpy(szFileName, TEXT("*.TBL"));

    // prompt a open file dialog
    ofn.lStructSize = sizeof(OPENFILENAME);
    ofn.hwndOwner = hWnd;
    ofn.lpstrFilter = szFilter;
    ofn.lpstrCustomFilter = NULL;
    ofn.nMaxCustFilter = 0;
    ofn.nFilterIndex = 1;
    ofn.lpstrFile = szFileName;
    ofn.nMaxFile = sizeof(szFileName) / sizeof(TCHAR);
    ofn.lpstrFileTitle = NULL;
    ofn.nMaxFileTitle = 0;
    ofn.lpstrInitialDir = szDirName;
    ofn.lpstrTitle = NULL;;
    ofn.Flags = OFN_NOCHANGEDIR|OFN_HIDEREADONLY|OFN_CREATEPROMPT|
        OFN_PATHMUSTEXIST;
    ofn.lpstrDefExt = NULL;

    if (!GetOpenFileName(&ofn)) {
        return;
    }

    hIsvUsrDicFile = CreateFile(ofn.lpstrFile, GENERIC_READ, 0, NULL,
        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

    if (hIsvUsrDicFile == INVALID_HANDLE_VALUE) {
        LoadString(hAppInst, IDS_NOTOPEN_TITLE, szTitle, iTitle);
        LoadString(hAppInst, IDS_NOTOPEN_MSG, szMessage, iMessage);

        MessageBox(hWnd, szMessage, szTitle,
            MB_OK|MB_ICONHAND|MB_TASKMODAL|MB_TOPMOST);
        return;
    }

#if 0
    for (i = 0; i < sizeof(szFileName); i++) {
        if (szFileName[i] == '\\') {
            szFileName[i] = ' ';
        }
    }
#endif

    hIsvUsrDic = CreateFileMapping((HANDLE)hIsvUsrDicFile, NULL,
        PAGE_READONLY, 0, 0, NULL);

    if (!hIsvUsrDic) {
        LoadString(hAppInst, IDS_NOTOPEN_TITLE, szTitle, iTitle);
        LoadString(hAppInst, IDS_NOTOPEN_MSG, szMessage, iMessage);

        MessageBox(hWnd, szMessage, szTitle,
            MB_OK|MB_ICONHAND|MB_TASKMODAL|MB_TOPMOST);
        goto BatchCloseUsrDicFile;
    }

    lpIsvUsrDic = MapViewOfFile(hIsvUsrDic, FILE_MAP_READ, 0, 0, 0);

    if (!lpIsvUsrDic) {
        LoadString(hAppInst, IDS_NOTOPEN_TITLE, szTitle, iTitle);
        LoadString(hAppInst, IDS_NOTOPEN_MSG, szMessage, iMessage);

        MessageBox(hWnd, szMessage, szTitle,
            MB_OK|MB_ICONHAND|MB_TASKMODAL|MB_TOPMOST);
        goto BatchCloseUsrDic;
    }

    dwSize = lpIsvUsrDic->ulTableCount * (sizeof(WORD) + sizeof(WORD) +
        lpIsvUsrDic->cMethodKeySize) + 256;

    dwFileSize = GetFileSize(hIsvUsrDicFile, (LPDWORD)NULL);
#if 0       // temp code
    dwSize = dwFileSize;
#endif

    if (dwSize != dwFileSize) {
        LoadString(hAppInst, IDS_FILESIZE_TITLE, szTitle, iTitle);
        LoadString(hAppInst, IDS_FILESIZE_MSG, szMessage, iMessage);

        MessageBox(hWnd, szMessage, szTitle, MB_OK);
    } else if (lpIsvUsrDic->uHeaderSize != 256) {
        LoadString(hAppInst, IDS_HEADERSIZE_TITLE, szTitle, iTitle);
        LoadString(hAppInst, IDS_HEADERSIZE_MSG, szMessage, iMessage);

        MessageBox(hWnd, szMessage, szTitle, MB_OK);
    } else if (lpIsvUsrDic->uInfoSize != 13) {
        LoadString(hAppInst, IDS_INFOSIZE_TITLE, szTitle, iTitle);
        LoadString(hAppInst, IDS_INFOSIZE_MSG, szMessage, iMessage);

        MessageBox(hWnd, szMessage, szTitle, MB_OK);
    } else if (CodePageInfo(lpIsvUsrDic->idCP) == -1) {
        LoadString(hAppInst, IDS_CODEPAGE_TITLE, szTitle, iTitle);
        LoadString(hAppInst, IDS_CODEPAGE_MSG, szMessage, iMessage);

        MessageBox(hWnd, szMessage, szTitle, MB_OK);
    } else if (*(LPUNADWORD)lpIsvUsrDic->idUserCharInfoSign != SIGN_CWIN) {
        // != CWIN
        LoadString(hAppInst, IDS_CWINSIGN_TITLE, szTitle, iTitle);
        LoadString(hAppInst, IDS_CWINSIGN_MSG, szMessage, iMessage);

        MessageBox(hWnd, szMessage, szTitle, MB_OK);
    } else if (*(LPUNADWORD)((LPBYTE)lpIsvUsrDic->idUserCharInfoSign +
        sizeof(DWORD)) != SIGN__TBL) {
        // != _TBL
        LoadString(hAppInst, IDS_CWINSIGN_TITLE, szTitle, iTitle);
        LoadString(hAppInst, IDS_CWINSIGN_MSG, szMessage, iMessage);

        MessageBox(hWnd, szMessage, szTitle, MB_OK);
    } else if (!RegisterTable(hWnd, lpIsvUsrDic, dwFileSize, lpIsvUsrDic->idCP)) {
        LoadString(hAppInst, IDS_UNMATCHED_TITLE, szTitle, iTitle);
        LoadString(hAppInst, IDS_UNMATCHED_MSG, szMessage, iMessage);

        MessageBox(hWnd, szMessage, szTitle, MB_OK);
    } else {
        // OK
    }

    UnmapViewOfFile(lpIsvUsrDic);

BatchCloseUsrDic:
    CloseHandle(hIsvUsrDic);

BatchCloseUsrDicFile:
    CloseHandle(hIsvUsrDicFile);

    return;
}

/************************************************************/
/*  WndProc()                                               */
/************************************************************/
LRESULT CALLBACK WndProc(       // this is the window procedure of
                                // EUDC editor
    HWND   hWnd,
    UINT   uMsg,
    WPARAM wParam,
    LPARAM lParam)
{
#ifdef UNICODE
    static UINT uCode = 0xE000;
#else
    static UINT uCode = 0xFA40;
#endif

    switch (uMsg) {
    case WM_COMMAND:
        switch (wParam) {
        case IDM_NEW_EUDC:
            uCode++;
            break;
        case IDM_IME_LINK:
            ImeLink(hWnd, uCode);
            break;
        case IDM_BATCH_IME_LINK:
            BatchImeLink(hWnd);
            break;
        default:
            break;
        }
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        return (0L);
    default:
        return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }

    return (0L);
}

/************************************************************/
/*  WinMain()                                               */
/************************************************************/
int WINAPI WinMain(
    HINSTANCE hInst,
    HINSTANCE hPrevInst,
    LPSTR     lpszCmdLine,
    int       nCmdShow)
{
    WNDCLASS wcClass;
    HWND     hWnd;
    MSG      sMsg;

    hAppInst = hInst;

    wcClass.style = CS_HREDRAW|CS_VREDRAW;
    wcClass.lpfnWndProc = WndProc;
    wcClass.cbClsExtra = 0;
    wcClass.cbWndExtra = 0;
    wcClass.hInstance = hAppInst;
    wcClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wcClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcClass.hbrBackground = GetStockObject(LTGRAY_BRUSH);
    wcClass.lpszMenuName = szMenuName;
    wcClass.lpszClassName = szAppName;
    RegisterClass(&wcClass);

    hWnd = CreateWindowEx(WS_EX_WINDOWEDGE,
        szAppName,
        TEXT("Fake EUDC Editor"),
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT,
        CW_USEDEFAULT, CW_USEDEFAULT,
        NULL, NULL, hAppInst, NULL);

    ShowWindow(hWnd, SW_SHOWDEFAULT);
    UpdateWindow(hWnd);

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

    while (GetMessage(&sMsg, NULL, 0, 0)) {
        TranslateMessage(&sMsg);
        DispatchMessage(&sMsg);
    }

    return ((int) sMsg.wParam);
}