candui.c

This folder includes IME sample source code for Simplified Chinese IMEs

        GetClientRect(hCandWnd, &rcWnd);
        DrawConcaveRect(hDC,
            rcWnd.left,
            rcWnd.top + UI_CANDINF,
            rcWnd.right - 1,
            rcWnd.bottom - 1);
    } else {
        RECT rcWnd;

        GetClientRect(hCandWnd, &rcWnd);
        DrawConcaveRect(hDC,
            sImeG.rcCandText.left - 1,
            rcWnd.top,
            sImeG.rcCandText.right + 1,
            rcWnd.bottom - 1);
    }

    SetTextColor(hDC, RGB(0x00, 0x00, 0x00));
    SetBkColor(hDC, RGB(0xC0, 0xC0, 0xC0));

    if (sImeG.IC_Trace) {
        ExtTextOut(hDC, sImeG.rcCandText.left, sImeG.rcCandText.top,
            ETO_OPAQUE, &sImeG.rcCandText, NULL, 0, NULL);
        szStrBuf[0] = TEXT('1');
        szStrBuf[1] = TEXT(':');

        for (i = 0; dwStart < dwEnd; dwStart++, i++) {
            int  iLen;

            szStrBuf[0] = szDigit[i + CAND_START];

#if defined(COMBO_IME)
            if(sImeL.dwRegImeIndex == INDEX_GB || sImeL.dwRegImeIndex == INDEX_GBK){
                iLen = lstrlen((LPTSTR)((LPBYTE)lpCandList +
                    lpCandList->dwOffset[dwStart]));

                if (iLen > 10 * 2 / sizeof(TCHAR)) {
                    iLen = 10 * 2 / sizeof(TCHAR);
                    CopyMemory(&szStrBuf[2],
                        ((LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[dwStart])),
                        (iLen - 2) * sizeof(TCHAR));
                    // maybe not good for UNICODE
                    szStrBuf[iLen] = TEXT('.');
                    szStrBuf[iLen+1] = TEXT('.');
                    szStrBuf[iLen+2] = TEXT('\0');
                } else {
                    CopyMemory(&szStrBuf[2],
                        (LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[dwStart]),
                        iLen*sizeof(TCHAR));
                }
               }else if(sImeL.dwRegImeIndex == INDEX_UNICODE){
                WORD  wCode;
                wCode = *(LPUNAWORD)((LPBYTE)lpCandList + lpCandList->dwOffset[dwStart]);

#ifdef UNICODE
                szStrBuf[2]= wCode;
                szStrBuf[3]=TEXT('\0');
#else
                szStrBuf[2]= LOBYTE(wCode);
                szStrBuf[3]= HIBYTE(wCode);
                szStrBuf[4]=TEXT('\0');
#endif
                iLen = 2/sizeof(TCHAR);
            }

#else
            iLen = lstrlen((LPTSTR)((LPBYTE)lpCandList +
                lpCandList->dwOffset[dwStart]));

            if (iLen > 10 * 2 / sizeof(TCHAR)) {
                iLen = 10 * 2 / sizeof(TCHAR);
                CopyMemory(&szStrBuf[2],
                    ((LPBYTE)lpCandList + lpCandList->dwOffset[dwStart]),
                    (iLen - 2) * sizeof(TCHAR));
                szStrBuf[iLen] = TEXT('.');
                szStrBuf[iLen+1] = TEXT('.');
                szStrBuf[iLen+2] = TEXT('\0');
            } else {
                CopyMemory(&szStrBuf[2],
                    ((LPBYTE)lpCandList + lpCandList->dwOffset[dwStart]),
                    iLen*sizeof(TCHAR));
            }
#endif //COMBO_IME

            ExtTextOut(hDC, sImeG.rcCandText.left,
                sImeG.rcCandText.top + i * sImeG.yChiCharHi,
                (UINT)0, NULL,
                szStrBuf,
                iLen + 2, NULL);
    
           // QW/GB info
           {

             int   iMyLen;
             WORD  wCode, wGB;
             TCHAR  AbSeq[5];
             TCHAR  GbSeq[5];
             TCHAR szMyStrBuf[12 * sizeof(WCHAR) / sizeof(TCHAR)];
             RECT  GBARInfo;

#ifdef UNICODE


             wCode = *(LPUNAWORD)((LPBYTE)lpCandList + lpCandList->dwOffset[dwStart]);
             AbSeq[0] = wCode;
             AbSeq[1] = TEXT('\0');
             //  change the CP_ACP to 936, so that it can work under Multilingul Env.
             WideCharToMultiByte(NATIVE_ANSI_CP, WC_COMPOSITECHECK, AbSeq, 1, (BYTE*)GbSeq, sizeof(GbSeq), NULL, NULL);
                          
             wGB = HIBYTE(GbSeq[0]) | (LOBYTE(GbSeq[0]) << 8);

             wsprintf (GbSeq,TEXT("%04lx"),wGB);    // get GB string
             wGB -= 0xa0a0;
             wsprintf (AbSeq,TEXT("%02d%02d"),HIBYTE(wGB),LOBYTE(wGB));
#else
             wCode = *(LPUNAWORD)((LPBYTE)lpCandList + lpCandList->dwOffset[dwStart]);
             MultiByteToWideChar(CP_ACP, NULL, &wCode, 2, &wGB, 1);    
                          
             wCode = HIBYTE(wCode) | (LOBYTE(wCode) << 8);

             wsprintf (GbSeq,"%04lx",wCode);    // get GB string
            
             wCode -= 0xa0a0;

             wsprintf (AbSeq,"%02d%02d",HIBYTE(wCode),LOBYTE(wCode));
#endif
//             if (lpImcP->fdwGB & IME_SELECT_GB) {
#if defined(COMBO_IME)
        switch(sImeL.dwRegImeIndex){
        case INDEX_GB:
                lstrcpy (szMyStrBuf,TEXT("("));
                lstrcat (szMyStrBuf,GbSeq);
                lstrcat (szMyStrBuf,TEXT(", "));
                lstrcat (szMyStrBuf,AbSeq);
                lstrcat (szMyStrBuf,TEXT(")"));
                iMyLen = 12;

            break;
        case INDEX_GBK:
                lstrcpy (szMyStrBuf,TEXT("    "));
                lstrcat (szMyStrBuf,TEXT("("));
                lstrcat (szMyStrBuf,GbSeq);
                lstrcat (szMyStrBuf,TEXT(")"));
                iMyLen = 10;

            break;
        case INDEX_UNICODE:        //adjust code display info
                lstrcpy (szMyStrBuf,TEXT("("));
                lstrcat (szMyStrBuf,GbSeq);
                lstrcat (szMyStrBuf,TEXT(", "));
                wsprintf (AbSeq,TEXT("%04lx"),wCode);
                lstrcat (szMyStrBuf, AbSeq);
                lstrcat (szMyStrBuf,TEXT(")"));
                iMyLen = lstrlen(szMyStrBuf);
            break;
        }
#else //COMBO_IME
#ifdef GB
                lstrcpy (szMyStrBuf,TEXT("("));
                lstrcat (szMyStrBuf,GbSeq);
                lstrcat (szMyStrBuf,TEXT(", "));
                lstrcat (szMyStrBuf,AbSeq);
                lstrcat (szMyStrBuf,TEXT(")"));
                iMyLen = 12;

#else
                lstrcpy (szMyStrBuf,TEXT("    "));
                lstrcat (szMyStrBuf,TEXT("("));
                lstrcat (szMyStrBuf,GbSeq);
                lstrcat (szMyStrBuf,TEXT(")"));
                iMyLen = 10;

#endif //GB        
#endif //COMBO_IME
        
             GBARInfo.top = sImeG.rcCandText.top + i * sImeG.yChiCharHi;
             GBARInfo.left = sImeG.rcCandText.left;
             GBARInfo.right = sImeG.rcCandText.right;
             GBARInfo.bottom = sImeG.rcCandText.bottom;
             DrawText(hDC, szMyStrBuf, lstrlen(szMyStrBuf),
                     &GBARInfo, DT_RIGHT | DT_SINGLELINE);
           }
        }

    } else {
        int  nX;

        ExtTextOut(hDC, sImeG.rcCandText.left, sImeG.rcCandText.top + 1,
            ETO_OPAQUE, &sImeG.rcCandText, NULL, 0, NULL);
        nX = 0;
        for (i = 0; dwStart < dwEnd; dwStart++, i++) {
            int  iLen;
            int j, k;
            TCHAR AnsiStr[MAXCODE+1];
            SIZE StrSize;

            // display numbers
            AnsiStr[0] = szDigit[i + CAND_START];
            AnsiStr[1] = TEXT(':');
            AnsiStr[2] = 0;
            ExtTextOut(hDC, sImeG.rcCandText.left + nX,
                    sImeG.rcCandText.top + 1,
                    ETO_CLIPPED, &sImeG.rcCandText,
                    AnsiStr,
                    lstrlen(AnsiStr), NULL);
            if(!GetTextExtentPoint(hDC, (LPCTSTR)AnsiStr, lstrlen(AnsiStr), &StrSize))
                memset(&StrSize, 0, sizeof(SIZE));
            nX += StrSize.cx;

            // display chinese word and code
            iLen = lstrlen((LPTSTR)((LPBYTE)lpCandList +
                lpCandList->dwOffset[dwStart]));

            CopyMemory(szStrBuf,
                ((LPBYTE)lpCandList + lpCandList->dwOffset[dwStart]),
                iLen*sizeof(TCHAR));

            for(j=0; j<iLen; j++) {
#ifdef UNICODE
                if(szStrBuf[j] > 0x100) {
#else
                if(szStrBuf[j] & 0x80) {
#endif
                    j++;
                    continue;
                }
                break;
            }
            
            k = j-1;
            for(j=0; j<iLen - k; j++) {
                AnsiStr[j] = szStrBuf[j+k];
            }
            AnsiStr[j] = 0;
            szStrBuf[k] = 0;


            ExtTextOut(hDC, sImeG.rcCandText.left + nX,
                    sImeG.rcCandText.top + 1,
                    ETO_CLIPPED, &sImeG.rcCandText,
                    szStrBuf,
                    lstrlen(szStrBuf), NULL);

            if(!GetTextExtentPoint(hDC, (LPCTSTR)szStrBuf, lstrlen(szStrBuf), &StrSize))
                memset(&StrSize, 0, sizeof(SIZE));
            nX += StrSize.cx;

            ExtTextOut(hDC, sImeG.rcCandText.left + nX,
                    sImeG.rcCandText.top + 1,
                    ETO_CLIPPED, &sImeG.rcCandText,
                    AnsiStr,
                    lstrlen(AnsiStr), NULL);

            if(!GetTextExtentPoint(hDC, (LPCTSTR)AnsiStr, lstrlen(AnsiStr), &StrSize))
                memset(&StrSize, 0, sizeof(SIZE));
            nX += StrSize.cx;

        }
    }
    
    // load all bitmap
    if (sImeG.IC_Trace) {
        hCandInfBmp = LoadBitmap(hInst, TEXT("Candinf"));
    } else {
        hCandInfBmp = NULL;
    }

    hCandHBmp = LoadBitmap(hInst, TEXT("CandH"));
    hCandUBmp = LoadBitmap(hInst, TEXT("CandU"));
    hCandDBmp = LoadBitmap(hInst, TEXT("CandD"));
    hCandEBmp = LoadBitmap(hInst, TEXT("CandE"));
    hCandIconBmp = LoadBitmap(hInst, TEXT("CandSel"));

    hMemDC = CreateCompatibleDC(hDC);

    hOldBmp = SelectObject(hMemDC, hCandIconBmp);

    BitBlt(hDC, sImeG.rcCandIcon.left, sImeG.rcCandIcon.top,
        sImeG.rcCandIcon.right - sImeG.rcCandIcon.left,
        STATUS_DIM_Y,
        hMemDC, 0, 0, SRCCOPY);

    if(hCandInfBmp) {
        SelectObject(hMemDC, hCandInfBmp);

        BitBlt(hDC, sImeG.rcCandInf.left, sImeG.rcCandInf.top,
            sImeG.rcCandInf.right - sImeG.rcCandInf.left,
            STATUS_DIM_Y,
            hMemDC, 0, 0, SRCCOPY);
    }

    SelectObject(hMemDC, hCandHBmp);

    BitBlt(hDC, sImeG.rcCandBTH.left, sImeG.rcCandBTH.top,
        sImeG.rcCandBTH.right - sImeG.rcCandBTH.left,
        STATUS_DIM_Y,
        hMemDC, 0, 0, SRCCOPY);

    SelectObject(hMemDC, hCandUBmp);

    BitBlt(hDC, sImeG.rcCandBTU.left, sImeG.rcCandBTU.top,
        sImeG.rcCandBTU.right - sImeG.rcCandBTU.left,
        STATUS_DIM_Y,
        hMemDC, 0, 0, SRCCOPY);

    SelectObject(hMemDC, hCandDBmp);

    BitBlt(hDC, sImeG.rcCandBTD.left, sImeG.rcCandBTD.top,
        sImeG.rcCandBTD.right - sImeG.rcCandBTD.left,
        STATUS_DIM_Y,
        hMemDC, 0, 0, SRCCOPY);

    SelectObject(hMemDC, hCandEBmp);

    BitBlt(hDC, sImeG.rcCandBTE.left, sImeG.rcCandBTE.top,
        sImeG.rcCandBTE.right - sImeG.rcCandBTE.left,
        STATUS_DIM_Y,
        hMemDC, 0, 0, SRCCOPY);

    SelectObject(hMemDC, hOldBmp);
    DeleteDC(hMemDC);
    DeleteObject(hCandIconBmp);
    DeleteObject(hCandEBmp);
    DeleteObject(hCandDBmp);
    DeleteObject(hCandUBmp);
    DeleteObject(hCandHBmp);
    DeleteObject(hCandInfBmp);

    if (sImeG.fDiffSysCharSet) {
        DeleteObject(SelectObject(hDC, hOldFont));
    }

    ImmUnlockIMCC(lpIMC->hPrivate);
UpCandW2UnlockCandInfo:
    ImmUnlockIMCC(lpIMC->hCandInfo);
UpCandW2UnlockIMC:
    ImmUnlockIMC(hIMC);

    return;
}

/**********************************************************************/
/* CandWndProc()                                                      */
/**********************************************************************/
LRESULT CALLBACK CandWndProc(
    HWND   hCandWnd,
    UINT   uMsg,
    WPARAM wParam,
    LPARAM lParam)
{
    switch (uMsg) {
    case WM_DESTROY:
        DestroyCandWindow(hCandWnd);
        break;
    case WM_SETCURSOR:
        CandSetCursor(hCandWnd, lParam);
        break;
    case WM_MOUSEMOVE:
        if (GetWindowLong(hCandWnd, UI_MOVE_OFFSET) != WINDOW_NOT_DRAG) {
            POINT ptCursor;

            DrawDragBorder(hCandWnd,
                GetWindowLong(hCandWnd, UI_MOVE_XY),
                GetWindowLong(hCandWnd, UI_MOVE_OFFSET));
            GetCursorPos(&ptCursor);
            SetWindowLong(hCandWnd, UI_MOVE_XY,
                MAKELONG(ptCursor.x, ptCursor.y));
            DrawDragBorder(hCandWnd, MAKELONG(ptCursor.x, ptCursor.y),
                GetWindowLong(hCandWnd, UI_MOVE_OFFSET));
        } else {
            return DefWindowProc(hCandWnd, uMsg, wParam, lParam);
        }
        break;
    case WM_LBUTTONUP:
        if (!CandButtonUp(hCandWnd)) {
            return DefWindowProc(hCandWnd, uMsg, wParam, lParam);
        }
        break;
    case WM_IME_NOTIFY:
        if (wParam == IMN_SETCANDIDATEPOS) {
            return SetCandPosition(hCandWnd);
        }
        break;
    case WM_PAINT:
        {
            HDC         hDC;
            PAINTSTRUCT ps;

            hDC = BeginPaint(hCandWnd, &ps);
            PaintCandWindow(hCandWnd, hDC);
            EndPaint(hCandWnd, &ps);
        }
        break;
    case WM_MOUSEACTIVATE:
        return (MA_NOACTIVATE);
    default:
        return DefWindowProc(hCandWnd, uMsg, wParam, lParam);
    }

    return (0L);
}