ddis.c

This folder includes IME sample source code for Simplified Chinese IMEs

        return (TRUE);
    default:
        return (FALSE);
    }

    return (TRUE);
}

/**********************************************************************/
/* 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
{*/
BOOL WINAPI ImeConfigure(      // configurate the IME setting
    HKL     hKL,               // hKL of this IME
    HWND    hAppWnd,           // the owner window
    DWORD   dwMode,
    LPVOID  lpData)            // mode of dialog
{
    switch (dwMode) {
    case IME_CONFIG_GENERAL:
        DialogBox(hInst, TEXT("ImeSet"), (HWND)hAppWnd, (DLGPROC)ImeSetDlgProc);
        break;
    default:
        return (FALSE);
        break;
    }
    return (TRUE);
}


/**********************************************************************/
/* XGBConversion()                                                       */
/**********************************************************************/
DWORD PASCAL XGBConversion(
    LPCTSTR         lpszReading,
    LPCANDIDATELIST lpCandList,
    UINT            uBufLen)
{
    UINT        MAX_COMP;
    UINT        uMaxCand;
    UINT        iRet;
    WORD        wCode;
    LPPRIVCONTEXT lpImcP;
    HGLOBAL       hImcP;
    int         i;
    DWORD       dwSize;
    if (!(lstrlen (lpszReading) == 4)) {
      return (0);
    }

    hImcP = GlobalAlloc (GMEM_MOVEABLE,sizeof (PRIVCONTEXT));
    if(!hImcP){
        return(0);
    }
    lpImcP= GlobalLock (hImcP);
    if(!lpImcP){
        GlobalFree(hImcP);
        return(0);
    }
    lstrcpy (lpImcP->bSeq,lpszReading);
    if(lpImcP->bSeq[3] == TEXT('?')){
      MAX_COMP = 178;
    } else {
      MAX_COMP = 1;
      }
    dwSize =        // similar to ClearCand
        // header length
        sizeof(CANDIDATELIST) +
        // candidate string pointers
        sizeof(DWORD) * MAX_COMP +
        // string plus NULL terminator
        (sizeof(WORD) + sizeof(TCHAR)) * MAX_COMP;
    if (!uBufLen) {
        return (dwSize);
    }

    uMaxCand = uBufLen - sizeof(CANDIDATELIST);

    uMaxCand /= sizeof(DWORD) + sizeof(WORD) + sizeof(TCHAR);
    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);
      lpImcP->bSeq[0] = 0;
      lpImcP->bSeq[1] = 0;
      lpImcP->bSeq[2] = 0;
      lpImcP->bSeq[3] = 0;

    for (i=0;i<4;i++) {
       iRet = XGBProcessKey(*(LPBYTE)((LPBYTE)lpszReading+i),lpImcP);
       if (iRet == CST_INPUT) {
          lpImcP->bSeq[i] = *(LPBYTE)((LPBYTE)lpszReading+i);
       } else {
          return (DWORD)0;
       }
    }
                        wCode = XGBEngine(lpImcP);
    
                wCode = HIBYTE(wCode) | (LOBYTE(wCode) << 8);

                for (i = 0; i < (0x7e-0x40+1); i++, wCode++) {
                XGBAddCodeIntoCand(lpCandList, wCode);
                }
                wCode ++;
                for (i = 0; i < (0xfe-0x80+1); i++, wCode++) {
                XGBAddCodeIntoCand(lpCandList, wCode);
                }

     GlobalUnlock (hImcP);
     GlobalFree (hImcP);
    return (dwSize);
}

/**********************************************************************/
/* Conversion()                                                       */
/**********************************************************************/
DWORD PASCAL Conversion(
    LPCTSTR         lpszReading,
    LPCANDIDATELIST lpCandList,
    UINT            uBufLen)
{
    UINT        MAX_COMP,i;
    UINT        uMaxCand;
    UINT        iRet;
    WORD        wCode;
    LPPRIVCONTEXT lpImcP;
    HGLOBAL       hImcP;
    
    DWORD       dwSize;
    if (!(lstrlen (lpszReading) == 4)) {
      return (0);
    }

    hImcP = GlobalAlloc (GMEM_MOVEABLE,sizeof (PRIVCONTEXT));
    if(!hImcP){
        return(0);
    }
    lpImcP= GlobalLock (hImcP);
    if(!lpImcP){
        GlobalFree(hImcP);
        return(0);
    }
    lstrcpy (lpImcP->bSeq,lpszReading);
    if(lpImcP->bSeq[3] == TEXT('?')){
      MAX_COMP = 94;
    } else {
      MAX_COMP = 1;
      }
    dwSize =        // similar to ClearCand
        // header length
        sizeof(CANDIDATELIST) +
        // candidate string pointers
        sizeof(DWORD) * MAX_COMP +
        // string plus NULL terminator
        (sizeof(WORD) + sizeof(TCHAR)) * MAX_COMP;
    if (!uBufLen) {
        return (dwSize);
    }

    uMaxCand = uBufLen - sizeof(CANDIDATELIST);

    uMaxCand /= sizeof(DWORD) + sizeof(WORD) + sizeof(TCHAR);
    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);
      lpImcP->bSeq[0] = 0;
      lpImcP->bSeq[1] = 0;
      lpImcP->bSeq[2] = 0;
      lpImcP->bSeq[3] = 0;

    for (i=0;i<4;i++) {
       iRet = GBProcessKey(*(LPBYTE)((LPBYTE)lpszReading+i),lpImcP);
       if (iRet == CST_INPUT) {
          lpImcP->bSeq[i] = *(LPBYTE)((LPBYTE)lpszReading+i);
       } else {
          return (DWORD)0;
       }
    }
       wCode = GBEngine (lpImcP);
                wCode = HIBYTE(wCode) | (LOBYTE(wCode) << 8);
                for (i = 0; i < MAX_COMP;i++, wCode++) {
                AddCodeIntoCand(lpCandList, wCode);
            }

     GlobalUnlock (hImcP);
     GlobalFree (hImcP);
    return (dwSize);
}
/**************************************************************************
BOOL DBCSToGBCode ( WORD    wCode, BYTE    AbSeq[5])
***************************************************************************/
BOOL DBCSToGBCode (
        WORD    wCode,
        TCHAR   AbSeq[5])
{        
    WORD    AreaCode;

#ifdef UNICODE
    //Converte Unicode to GBK
    // change CP_ACP to 936, so that it can work under Multilingul Env.
    WideCharToMultiByte(NATIVE_ANSI_CP, WC_COMPOSITECHECK, &wCode, 1, (char *)&AreaCode, 2, NULL, NULL);
    wCode = AreaCode;
#endif

//check valid GB range code first
#if defined(COMBO_IME)
    if(sImeL.dwRegImeIndex==INDEX_GB){
        if(LOBYTE(wCode) < 0xa1 || LOBYTE(wCode) > 0xfe 
        || HIBYTE(wCode) < 0xa1 || HIBYTE(wCode) > 0xfe)
            return FALSE;
       AbSeq[1] = ((wCode -0xa0) % 256) % 10;
       AbSeq[0] = ((wCode -0xa0) % 256) / 10;
       AreaCode = (wCode - 0xa0 -AbSeq[0] * 10 -AbSeq[1])/256;
       AbSeq[3] = ((AreaCode -0xa0) % 256) % 10;
       AbSeq[2] = ((AreaCode -0xa0) % 256) / 10; 
       AbSeq[4] = TEXT('\0';)
    }else if(sImeL.dwRegImeIndex==INDEX_GBK || sImeL.dwRegImeIndex==INDEX_UNICODE){
        WORD    tmp;
        tmp = HIBYTE(wCode) | (LOBYTE(wCode)<<8);
        wsprintf(AbSeq,TEXT("%04x"), tmp);
    }
#else //COMBO_IME
#ifdef GB
        if(LOBYTE(wCode) < 0xa1 || LOBYTE(wCode) > 0xfe 
        || HIBYTE(wCode) < 0xa1 || HIBYTE(wCode) > 0xfe)
            return FALSE;
       AbSeq[1] = ((wCode -0xa0) % 256) % 10;
       AbSeq[0] = ((wCode -0xa0) % 256) / 10;
       AreaCode = (wCode - 0xa0 -AbSeq[0] * 10 -AbSeq[1])/256;
       AbSeq[3] = ((AreaCode -0xa0) % 256) % 10;
       AbSeq[2] = ((AreaCode -0xa0) % 256) / 10; 
       AbSeq[4] = TEXT('\0');
#else
       {
        WORD    tmp;
        tmp = HIBYTE(wCode) | (LOBYTE(wCode)<<8);
        wsprintf(AbSeq,TEXT("%04x"), tmp);
       }
#endif //GB
#endif //COMBO_IME
       return TRUE;
}
/***************************************************************************
BOOL AreaToGB ( BYTE    AbSeq[5],BYTE    GbSeq[5])
***************************************************************************/
BOOL AreaToGB (
        TCHAR    AbSeq[5],
        TCHAR    GbSeq[5])
{
        TCHAR    MbSeq[3]; // Temp string
        // Area turn
        wsprintf (MbSeq,TEXT("%lx"),(AbSeq[0] * 10 + AbSeq[1]+0xa0));
        GbSeq[0] = MbSeq[0];
        GbSeq[1] = MbSeq[1];
        //position turn
        wsprintf (MbSeq,TEXT("%lx"),(AbSeq[2] * 10 + AbSeq[3]+0xa0));
        GbSeq[2] = MbSeq[0];
        GbSeq[3] = MbSeq[1];
        GbSeq[4] = TEXT('\0');
        return TRUE;
}

#if defined(COMBO_IME)
/**********************************************************************/
/* UnicodeReverseConversion()                                                */
/**********************************************************************/
DWORD PASCAL UnicodeReverseConversion(
    WORD            wCode,
    LPCANDIDATELIST lpCandList,
    UINT            uBufLen)
{
    UINT   MAX_COMP = 1;
    UINT   nMaxKey  = 4;
    TCHAR  AbSeq[5];
    UINT   uMaxCand;
    DWORD  dwSize =         // similar to ClearCand
        // header length
        sizeof(CANDIDATELIST) +
        // candidate string pointers
        sizeof(DWORD) * MAX_COMP +
        // string plus NULL terminator
        (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));

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

    uMaxCand = uBufLen - sizeof(CANDIDATELIST);

    uMaxCand /= sizeof(DWORD) +
        (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));
    if (uMaxCand == 0) {
        // can not put one string
        return (0);
    }

    lpCandList->dwSize = sizeof(CANDIDATELIST) +
        sizeof(DWORD) * uMaxCand +
        (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));
    lpCandList->dwStyle = IME_CAND_READ;
    lpCandList->dwCount = 0;
    lpCandList->dwSelection = 0;
    //lpCandList->dwPageSize = CANDPERPAGE; New Spac
    lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) ;

#ifndef UNICODE
    {
        WCHAR szWideStr[2];
        int i;

        memset(szWideStr, 0, sizeof(szWideStr));
        // change CP_ACP to 936, so that it can work under Multilingul Env.
        MultiByteToWideChar(NATIVE_ANSI_CP, 0, (LPCSTR)&wCode, sizeof(WORD), szWideStr, sizeof(szWideStr));

        wCode = HIBYTE((WORD)szWideStr[0]) | (LOBYTE((WORD)szWideStr[0]) << 8 );
    }
    if(!DBCSToGBCode (wCode, AbSeq))
        return 0;  //actual is DBCSToGBInternalCode
#endif

    wsprintf(AbSeq,TEXT("%04x"), wCode);
    lstrcpy((LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[0]),AbSeq);
     

    // string count ++
    lpCandList->dwCount = 1;

    return (dwSize);
}
#endif //COMBO_IME

/**********************************************************************/
/* XGBReverseConversion()                                                */
/**********************************************************************/
DWORD PASCAL XGBReverseConversion(
    WORD            wCode,
    LPCANDIDATELIST lpCandList,
    UINT            uBufLen)
{
    UINT   MAX_COMP = 1;
    UINT   nMaxKey  = 4;
    TCHAR    AbSeq[5];
    UINT   uMaxCand;
    DWORD  dwSize =         // similar to ClearCand
        // header length
        sizeof(CANDIDATELIST) +
        // candidate string pointers
        sizeof(DWORD) * MAX_COMP +
        // string plus NULL terminator
        (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));

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

    uMaxCand = uBufLen - sizeof(CANDIDATELIST);

    uMaxCand /= sizeof(DWORD) +
        (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));
    if (uMaxCand == 0) {
        // can not put one string
        return (0);
    }

    lpCandList->dwSize = sizeof(CANDIDATELIST) +
        sizeof(DWORD) * uMaxCand +
        (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));
    lpCandList->dwStyle = IME_CAND_READ;
    lpCandList->dwCount = 0;
    lpCandList->dwSelection = 0;
    //lpCandList->dwPageSize = CANDPERPAGE; New Spac
    lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) ;

    if(!DBCSToGBCode (wCode, AbSeq))
        return 0;  //actual is DBCSToGBInternalCode


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