windows-xp/Source/XPSP1/NT/windows/feime/cht/offcaret.c

/*++

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

Module Name:

    OFFCARET.C
    
++*/

#include <windows.h>
#include <immdev.h>
#include "imeattr.h"
#include "imedefs.h"
#include "imerc.h"
#if defined(UNIIME)
#include "uniime.h"
#endif

/**********************************************************************/
/* DestroyOffCaretWindow()                                            */
/**********************************************************************/
void PASCAL DestroyOffCaretWindow(      // destroy composition window
    HWND hOffCaretWnd)
{
    HGLOBAL  hUIPrivate;
    LPUIPRIV lpUIPrivate;

    if (GetWindowLong(hOffCaretWnd, UI_MOVE_OFFSET) != WINDOW_NOT_DRAG) {
        // undo the drag border
        DrawDragBorder(hOffCaretWnd,
            GetWindowLong(hOffCaretWnd, UI_MOVE_XY),
            GetWindowLong(hOffCaretWnd, UI_MOVE_OFFSET));
    }

    hUIPrivate = (HGLOBAL)GetWindowLongPtr(GetWindow(hOffCaretWnd, GW_OWNER),
        IMMGWLP_PRIVATE);
    if (!hUIPrivate) {
        return;
    }

    lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
    if (!lpUIPrivate) {
        return;
    }

#if !defined(ROMANIME)
    lpUIPrivate->nShowCompCmd = lpUIPrivate->nShowCandCmd = SW_HIDE;
#endif

    lpUIPrivate->nShowStatusCmd = SW_HIDE;

#if !defined(ROMANIME)
    lpUIPrivate->hCompWnd = lpUIPrivate->hCandWnd = NULL;
#endif

    lpUIPrivate->hStatusWnd = NULL;

    GlobalUnlock(hUIPrivate);

    return;
}

#if !defined(ROMANIME)
/**********************************************************************/
/* MouseSelectOffCaretCandStr()                                       */
/**********************************************************************/
BOOL PASCAL MouseSelectOffCaretCandStr(
#if defined(UNIIME)
    LPINSTDATAL lpInstL,
    LPIMEL      lpImeL,
#endif
    HWND        hOffCaretWnd,
    LPPOINT     lpCursor)
{
    BOOL            fRet;
    HWND            hUIWnd;
    HIMC            hIMC;
    LPINPUTCONTEXT  lpIMC;
    HGLOBAL         hUIPrivate;
    LPUIPRIV        lpUIPrivate;
    LPCANDIDATEINFO lpCandInfo;
    LPCANDIDATELIST lpCandList;
    DWORD           dwValue, dwLimit;
    UINT            nMouseChars, nChars;

    fRet = FALSE;

    hUIWnd = GetWindow(hOffCaretWnd, GW_OWNER);

    hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
    if (!hIMC) {
        return (fRet);
    }

    hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
    if (!hUIPrivate) {
        return (fRet);
    }

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

    if (!lpIMC->hCandInfo) {
        goto MouseSelOffCaretCandStrUnlockIMC;
    }

    lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
    if (!lpUIPrivate) {
        goto MouseSelOffCaretCandStrUnlockIMC;
    }

    dwValue = lpUIPrivate->nShowCandCmd;

    GlobalUnlock(hUIPrivate);

    if (dwValue == SW_HIDE) {
        // may application draw the UI or currently is not in candidate list
        goto MouseSelOffCaretCandStrUnlockIMC;
    }

    // we can select candidate
    fRet = TRUE;

    lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
    if (!lpCandInfo) {
        goto MouseSelOffCaretCandStrUnlockIMC;
    }

    nMouseChars = (lpCursor->x - lpImeL->rcCandText.left) * 2 /
        sImeG.xChiCharWi;

    lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo +
        lpCandInfo->dwOffset[0]);

    dwValue = lpCandList->dwPageStart;

    // process one page
    dwLimit = dwValue + lpCandList->dwPageSize;

    if (dwLimit > lpCandList->dwCount) {
        dwLimit = lpCandList->dwCount;
    }

    for (nChars = 0; dwValue < dwLimit; dwValue++) {
        UINT   uStrLen;
#ifdef UNICODE
        LPTSTR lpTmpStr;
#endif

#ifdef UNICODE
        // this is not a real string length just an approximate char width
        uStrLen = 0;

        lpTmpStr = (LPTSTR)((LPBYTE)lpCandList +
            lpCandList->dwOffset[dwValue]);

        for (; *lpTmpStr; lpTmpStr++) {
            if (*lpTmpStr < 0x0200) {
                uStrLen += 1;
            } else {
                uStrLen += 2;
            }
        }
#else
        uStrLen =  lstrlen((LPTSTR)((LPBYTE)lpCandList +
            lpCandList->dwOffset[dwValue]));
#endif

#if defined(WINAR30)
        if (!uStrLen) {
            uStrLen = sizeof(WCHAR);
        }
#endif
        // + 1 for the '1' '2' '3' ....
        nChars += uStrLen + 1;

        if (nMouseChars < nChars) {
#if defined(UNIIME)
            UniNotifyIME(lpInstL, lpImeL, hIMC, NI_SELECTCANDIDATESTR, 0,
                dwValue);
#else
            NotifyIME(hIMC, NI_SELECTCANDIDATESTR, 0, dwValue);
#endif
            break;
        }
    }

    ImmUnlockIMCC(lpIMC->hCandInfo);

    if (nMouseChars >= nChars) {
        // invalid choice
        MessageBeep((UINT)-1);
    }

MouseSelOffCaretCandStrUnlockIMC:
    ImmUnlockIMC(hIMC);

    return (fRet);
}

/**********************************************************************/
/* MouseSelectCandPage()                                              */
/**********************************************************************/
BOOL PASCAL MouseSelectCandPage(
#if defined(UNIIME)
    LPIMEL lpImeL,
#endif
    HWND   hCandWnd,
    WORD   wCharCode)
{
    BOOL            fRet;
    HWND            hUIWnd;
    HIMC            hIMC;
    LPINPUTCONTEXT  lpIMC;
    HGLOBAL         hUIPrivate;
    LPUIPRIV        lpUIPrivate;
    LPCANDIDATEINFO lpCandInfo;
    LPPRIVCONTEXT   lpImcP;

    fRet = FALSE;

    hUIWnd = GetWindow(hCandWnd, GW_OWNER);

    hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
    if (!hIMC) {
        return (fRet);
    }

    hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
    if (!hUIPrivate) {
        return (fRet);
    }

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

    if (!lpIMC->hCandInfo) {
        goto MouseSelCandPageUnlockIMC;
    }

    if (!lpIMC->hPrivate) {
        goto MouseSelCandPageUnlockIMC;
    }

    lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
    if (!lpUIPrivate) {
        goto MouseSelCandPageUnlockIMC;
    }

    if (lpUIPrivate->nShowCandCmd == SW_HIDE) {
        // may application draw the UI or currently is not in candidate list
        goto MouseSelCandPageUnlockIMC;
    }

    // we can select candidate
    fRet = TRUE;

    lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
    if (!lpCandInfo) {
        goto MouseSelCandPageUnlockUIPriv;
    }

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

    ChooseCand(
#if defined(UNIIME)
        NULL, lpImeL,
#endif
        wCharCode, hIMC, lpIMC, lpCandInfo, lpImcP);

    GenerateMessage(hIMC, lpIMC, lpImcP);

    ImmUnlockIMCC(lpIMC->hPrivate);

MouseSelCandPageUnlockCandInfo:
    ImmUnlockIMCC(lpIMC->hCandInfo);

MouseSelCandPageUnlockUIPriv:
    GlobalUnlock(hUIPrivate);

MouseSelCandPageUnlockIMC:
    ImmUnlockIMC(hIMC);

    return (fRet);
}
#endif

/**********************************************************************/
/* OffCaretSetCursor()                                                */
/**********************************************************************/
void PASCAL OffCaretSetCursor(
#if defined(UNIIME)
    LPINSTDATAL lpInstL,
    LPIMEL      lpImeL,
#endif
    HWND        hOffCaretWnd,
    LPARAM      lParam)
{
    POINT ptCursor, ptSavCursor;
    RECT  rcWnd;
 
    if (GetWindowLong(hOffCaretWnd, UI_MOVE_OFFSET) != WINDOW_NOT_DRAG) {
        SetCursor(LoadCursor(NULL, IDC_SIZEALL));
        return;
    }

    GetCursorPos(&ptCursor);
    ptSavCursor = ptCursor;

    ScreenToClient(hOffCaretWnd, &ptCursor);

    if (PtInRect(&lpImeL->rcStatusText, ptCursor)) {
        SetCursor(LoadCursor(hInst, MAKEINTRESOURCE(IDCR_HAND_CURSOR)));

        if (HIWORD(lParam) == WM_LBUTTONDOWN) {
            HWND hStatusWnd;

            SystemParametersInfo(SPI_GETWORKAREA, 0, &sImeG.rcWorkArea, 0);

            hStatusWnd = GetStatusWnd(GetWindow(hOffCaretWnd, GW_OWNER));
            if (hStatusWnd) {
                SetStatus(
#if defined(UNIIME)
                    lpImeL,
#endif
                    hStatusWnd, &ptCursor);
                return;
            } else {
               SetCursor(LoadCursor(NULL, IDC_SIZEALL));
            }
        } else if (HIWORD(lParam) == WM_RBUTTONUP) {
            static BOOL fImeConfigure = FALSE;

            HWND           hUIWnd, hStatusWnd;

            // prevent recursive
            if (fImeConfigure) {
                // configuration already bring up
                return;
            }

            hUIWnd = GetWindow(hOffCaretWnd, GW_OWNER);

            hStatusWnd = GetStatusWnd(hUIWnd);
            if (!hStatusWnd) {
                return;
            }

            fImeConfigure = TRUE;

            ContextMenu(
#if defined(UNIIME)
                lpInstL, lpImeL,
#endif
                hStatusWnd, ptSavCursor.x, ptSavCursor.y);

            fImeConfigure = FALSE;

            return;
        } else {
            return;
        }
#if !defined(ROMANIME)
    } else if (PtInRect(&lpImeL->rcCandText, ptCursor)) {
        if (HIWORD(lParam) != WM_LBUTTONDOWN) {
            SetCursor(LoadCursor(hInst, MAKEINTRESOURCE(IDCR_HAND_CURSOR)));
            return;
        }

        if (MouseSelectOffCaretCandStr(
#if defined(UNIIME)
            lpInstL, lpImeL,
#endif
            hOffCaretWnd, &ptCursor)) {
            return;
        }

        SetCursor(LoadCursor(NULL, IDC_SIZEALL));
#if defined(WINAR30)
    } else if (PtInRect(&lpImeL->rcCompText, ptCursor)) {
        SetCursor(LoadCursor(NULL, IDC_SIZEALL));

        if (HIWORD(lParam) != WM_LBUTTONDOWN) {
            return;
        }
#endif
    } else if (PtInRect(&lpImeL->rcCandPageUp, ptCursor)) {
        if (HIWORD(lParam) != WM_LBUTTONDOWN) {
            SetCursor(LoadCursor(hInst, MAKEINTRESOURCE(IDCR_HAND_CURSOR)));
            return;
        }

        if (MouseSelectCandPage(
#if defined(UNIIME)
            lpImeL,
#endif
            hOffCaretWnd, CHOOSE_PREVPAGE)) {
            return;
        }

        SetCursor(LoadCursor(NULL, IDC_SIZEALL));
    } else if (PtInRect(&lpImeL->rcCandHome, ptCursor)) {
        if (HIWORD(lParam) != WM_LBUTTONDOWN) {
            SetCursor(LoadCursor(hInst, MAKEINTRESOURCE(IDCR_HAND_CURSOR)));
            return;
        }

        if (MouseSelectCandPage(
#if defined(UNIIME)
            lpImeL,
#endif
            hOffCaretWnd, CHOOSE_HOME)) {
            return;
        }

        SetCursor(LoadCursor(NULL, IDC_SIZEALL));
    } else if (PtInRect(&lpImeL->rcCandPageDn, ptCursor)) {
        if (HIWORD(lParam) != WM_LBUTTONDOWN) {
            SetCursor(LoadCursor(hInst, MAKEINTRESOURCE(IDCR_HAND_CURSOR)));
            return;
        }

        if (MouseSelectCandPage(
#if defined(UNIIME)
            lpImeL,
#endif
            hOffCaretWnd, CHOOSE_NEXTPAGE)) {
            return;
        }

        SetCursor(LoadCursor(NULL, IDC_SIZEALL));
#endif
    } else {
        SetCursor(LoadCursor(NULL, IDC_SIZEALL));

        if (HIWORD(lParam) != WM_LBUTTONDOWN) {
            return;
        }
    }

    SetCapture(hOffCaretWnd);
    SetWindowLong(hOffCaretWnd, UI_MOVE_XY,
        MAKELONG(ptSavCursor.x, ptSavCursor.y));
    GetWindowRect(hOffCaretWnd, &rcWnd);
    SetWindowLong(hOffCaretWnd, UI_MOVE_OFFSET,
        MAKELONG(ptSavCursor.x - rcWnd.left, ptSavCursor.y - rcWnd.top));

    DrawDragBorder(hOffCaretWnd, MAKELONG(ptSavCursor.x, ptSavCursor.y),
        GetWindowLong(hOffCaretWnd, UI_MOVE_OFFSET));

    return;
}

/**********************************************************************/
/* PaintOffCaretStatus()                                              */
/**********************************************************************/
void PASCAL PaintOffCaretStatus(
#if defined(UNIIME)
    LPINSTDATAL lpInstL,
    LPIMEL      lpImeL,
#endif
    HWND        hOffCaretWnd,
    HDC         hDC)
{
    HGLOBAL  hUIPrivate;
    LPUIPRIV lpUIPrivate;

    hUIPrivate = (HGLOBAL)GetWindowLongPtr(GetWindow(hOffCaretWnd, GW_OWNER),
        IMMGWLP_PRIVATE);
    if (!hUIPrivate) {
        return;
    }

    lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
    if (!lpUIPrivate) {
        return;
    }

    if (lpUIPrivate->fdwSetContext & ISC_OPEN_STATUS_WINDOW) {
        PaintStatusWindow(
#if defined(UNIIME)
            lpInstL, lpImeL,
#endif
            hOffCaretWnd, hDC);
    }

    GlobalUnlock(hUIPrivate);

    return;
}

#if !defined(ROMANIME)
/**********************************************************************/
/* PaintOffCaretCandPage()                                            */
/**********************************************************************/
void PASCAL PaintOffCaretCandPage(
#if defined(UNIIME)
    LPIMEL          lpImeL,
#endif
    HDC             hDC,
    UINT            uCandMode,
    LPCANDIDATELIST lpCandList)
{
    HBITMAP hCandPromptBmp;
    HBITMAP hPageUpBmp, hHomeBmp, hPageDnBmp, hOldBmp;
    HDC     hMemDC;

    hMemDC = CreateCompatibleDC(hDC);

    if ( hMemDC == NULL )
    {
       return;
    }

    if (uCandMode == CAND_PROMPT_PHRASE) {
        hCandPromptBmp = LoadBitmap(hInst,
            MAKEINTRESOURCE(IDBM_CAND_PROMPT_PHRASE));
#if defined(WINAR30)
    } else if (uCandMode == CAND_PROMPT_QUICK_VIEW) {
        hCandPromptBmp = LoadBitmap(hInst,
            MAKEINTRESOURCE(IDBM_CAND_PROMPT_QUICK_VIEW));
#endif
    } else {
        hCandPromptBmp = LoadBitmap(hInst,
            MAKEINTRESOURCE(IDBM_CAND_PROMPT_NORMAL));
    }

    if ( hCandPromptBmp == NULL )
    {
       DeleteDC(hMemDC);
       return;
    }
       
    hOldBmp = SelectObject(hMemDC, hCandPromptBmp);

    BitBlt(hDC, lpImeL->rcCandPrompt.left, lpImeL->rcCandPrompt.top,
        lpImeL->rcCandPrompt.right - lpImeL->rcCandPrompt.left,
        lpImeL->rcCandPrompt.bottom - lpImeL->rcCandPrompt.top,
        hMemDC, 0, 0, SRCCOPY);

    if (lpCandList->dwCount <= lpCandList->dwPageSize) {
        goto PaintOffCaretCandPageOvr;
    }

    if (lpCandList->dwPageStart > 0) {
        hPageUpBmp = LoadBitmap(hInst, MAKEINTRESOURCE(IDBM_PAGEUP_HORIZ));
    } else {
        hPageUpBmp = LoadBitmap(hInst, MAKEINTRESOURCE(IDBM_NO_PAGEUP_HORIZ));
    }

    if ( hPageUpBmp == NULL )
    {
       goto PaintOffCaretCandPageOvr;
    }

    if (lpCandList->dwPageStart > 0) {
        hHomeBmp = LoadBitmap(hInst, MAKEINTRESOURCE(IDBM_HOME_HORIZ));
    } else {
        hHomeBmp = LoadBitmap(hInst, MAKEINTRESOURCE(IDBM_NO_HOME_HORIZ));
    }

    if ( hHomeBmp == NULL )
    {
       DeleteObject(hPageUpBmp);
       goto PaintOffCaretCandPageOvr;
    }   

    if ((lpCandList->dwPageStart + lpCandList->dwPageSize) <
        lpCandList->dwCount) {
        hPageDnBmp = LoadBitmap(hInst, MAKEINTRESOURCE(IDBM_PAGEDN_HORIZ));
    } else {
        hPageDnBmp = LoadBitmap(hInst, MAKEINTRESOURCE(IDBM_NO_PAGEDN_HORIZ));
    }

    if ( hPageDnBmp == NULL )
    {
      DeleteObject(hPageUpBmp);
      DeleteObject(hHomeBmp);
      goto PaintOffCaretCandPageOvr;
    }


    SelectObject(hMemDC, hPageUpBmp);

    BitBlt(hDC, lpImeL->rcCandPageUp.left, lpImeL->rcCandPageUp.top,
        lpImeL->rcCandPageUp.right - lpImeL->rcCandPageUp.left,
        lpImeL->rcCandPageUp.bottom - lpImeL->rcCandPageUp.top,
        hMemDC, 0, 0, SRCCOPY);

    SelectObject(hMemDC, hHomeBmp);

    BitBlt(hDC, lpImeL->rcCandHome.left, lpImeL->rcCandHome.top,
        lpImeL->rcCandHome.right - lpImeL->rcCandHome.left,
        lpImeL->rcCandHome.bottom - lpImeL->rcCandHome.top,
        hMemDC, 0, 0, SRCCOPY);

    SelectObject(hMemDC, hPageDnBmp);

    BitBlt(hDC, lpImeL->rcCandPageDn.left, lpImeL->rcCandPageDn.top,
        lpImeL->rcCandPageDn.right - lpImeL->rcCandPageDn.left,
        lpImeL->rcCandPageDn.bottom - lpImeL->rcCandPageDn.top,
        hMemDC, 0, 0, SRCCOPY);

    SelectObject(hMemDC, hOldBmp);

    DeleteObject(hPageUpBmp);
    DeleteObject(hHomeBmp);
    DeleteObject(hPageDnBmp);

PaintOffCaretCandPageOvr:
    SelectObject(hMemDC, hOldBmp);

    DeleteDC(hMemDC);

    DeleteObject(hCandPromptBmp);

    return;
}

/**********************************************************************/
/* PaintOffCaretComposition()                                         */
/**********************************************************************/
void PASCAL PaintOffCaretComposition(
#if defined(UNIIME)
    LPIMEL lpImeL,
#endif
    HWND   hOffCaretWnd,
    HDC    hDC)
{
    HWND            hUIWnd;
    HIMC            hIMC;
    LPINPUTCONTEXT  lpIMC;
    HGLOBAL         hUIPrivate;
    LPUIPRIV        lpUIPrivate;
    LPPRIVCONTEXT   lpImcP;
    HGDIOBJ         hOldFont;
    LPTSTR          lpStr;
    RECT            rcSunken;
    LOGFONT         lfFont;
    HFONT           hNewFont;

    hUIWnd = GetWindow(hOffCaretWnd, GW_OWNER);

    hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
    if (!hIMC) {
        return;
    }

    hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
    if (!hUIPrivate) {
        return;
    }

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

    lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
    if (!lpUIPrivate) {
        goto PaintOffCaretCompUnlockIMC;
    }

    rcSunken = lpImeL->rcCompText;

    rcSunken.left -= lpImeL->cxCompBorder;
    rcSunken.top -= lpImeL->cyCompBorder;
    rcSunken.right += lpImeL->cxCompBorder;
    rcSunken.bottom += lpImeL->cyCompBorder;

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

    hOldFont = GetCurrentObject(hDC, OBJ_FONT);
    GetObject(hOldFont, sizeof(lfFont), &lfFont);

    if (sImeG.fDiffSysCharSet) {
        lfFont.lfCharSet = NATIVE_CHARSET;
        lfFont.lfFaceName[0] = TEXT('\0');
    }
    lfFont.lfWeight = FW_DONTCARE;

    hNewFont = CreateFontIndirect(&lfFont);

    if ( hNewFont != NULL )
    {
      SelectObject(hDC, (HGDIOBJ)hNewFont);
    }
    else
    {
    //  return error
        GlobalUnlock(hUIPrivate);
        ImmUnlockIMC(hIMC);
        return;
    }


#if defined(WINAR30)
    rcSunken = lpImeL->rcCandText;

    rcSunken.left -= lpImeL->cxCandMargin;
    rcSunken.top -= lpImeL->cyCandMargin;
    rcSunken.right += lpImeL->cxCandMargin;
    rcSunken.bottom += lpImeL->cyCandMargin;

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

    // light gray background
    SetBkColor(hDC, RGB(0xC0, 0xC0, 0xC0));

    if (lpUIPrivate->nShowCandCmd != SW_HIDE) {
        LPCANDIDATEINFO lpCandInfo;
        LPCANDIDATELIST lpCandList;
        BOOL            fCandidate;
        DWORD           dwStart, dwEnd;
        UINT            uCandMode;
        int             i, nChars, nHalfChars;
        TCHAR           szStrBuf[CANDPERPAGE * 3 + 1];
#ifdef UNICODE
        int             iDx[CANDPERPAGE * 3 + 1];
#endif

        fCandidate = FALSE;

        if (!lpIMC->hCandInfo) {
            goto PaintOffCaretCompChkCandInfo;
        }

        lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
        if (!lpCandInfo) {
            goto PaintOffCaretCompChkCandInfo;
        }

        if (!lpCandInfo->dwCount) {
            goto PaintOffCaretCompUnlockCandInfo;
        }

        lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo +
            lpCandInfo->dwOffset[0]);

        if (!lpCandList->dwCount) {
            goto PaintOffCaretCompUnlockCandInfo;
        }

        dwStart = lpCandList->dwPageStart;

        dwEnd = dwStart + lpCandList->dwPageSize;

        if (dwEnd > lpCandList->dwCount) {
            dwEnd = lpCandList->dwCount;
        }

        fCandidate = TRUE;

        lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);

        if (!lpImcP) {
            uCandMode = CAND_PROMPT_NORMAL;
        } else if (lpImcP->iImeState == CST_INIT) {
            // phrase prediction
            SetTextColor(hDC, RGB(0x00, 0x80, 0x00));
            uCandMode = CAND_PROMPT_PHRASE;
#if defined(WINAR30)
        } else if (lpImcP->iImeState != CST_CHOOSE) {
            // quick key
            SetTextColor(hDC, RGB(0x80, 0x00, 0x80));
            uCandMode = CAND_PROMPT_QUICK_VIEW;
#endif
        } else {
            uCandMode = CAND_PROMPT_NORMAL;
        }

        if (lpImcP) {
            ImmUnlockIMCC(lpIMC->hPrivate);
        }

        PaintOffCaretCandPage(
#if defined(UNIIME)
            lpImeL,
#endif
            hDC, uCandMode, lpCandList);

        for (i = 0, nChars = 0, nHalfChars = 0; dwStart < dwEnd;
            dwStart++, i++) {
            int    nCharsInOneStr;
            int    nHalfCharsInOneStr;  // how many half width chars
                                        // one full width char ==
                                        // 2 half width chars
            int    nLimit;      // the room left to the candidate window
#ifdef UNICODE
            LPTSTR lpTmpStr;
#endif

            lpStr = (LPTSTR)((LPBYTE)lpCandList +
                lpCandList->dwOffset[dwStart]);

            nLimit = CANDPERPAGE * 3 - nHalfChars;

            if (nLimit <= 1) {
                break;
            }

            szStrBuf[nChars] = szDigit[i + lpImeL->wCandStart];

#ifdef UNICODE
            // the digit for select candidate
            iDx[nChars] = sImeG.xChiCharWi / 2;

            nCharsInOneStr = nHalfCharsInOneStr = 1;
#if defined(WINAR30) //1996/12/12
            iDx[nChars + nCharsInOneStr] = sImeG.xChiCharWi;
#endif

            for (lpTmpStr = lpStr; *lpTmpStr; lpTmpStr++, nCharsInOneStr++) {
                if (nHalfCharsInOneStr > nLimit) {
                    break;
                } else if (*lpTmpStr < 0x0200) {
                    nHalfCharsInOneStr += 1;
                    iDx[nChars + nCharsInOneStr] = sImeG.xChiCharWi / 2;
                } else {
                    nHalfCharsInOneStr += 2;
                    iDx[nChars + nCharsInOneStr] = sImeG.xChiCharWi;
                }
            }
#else
            nHalfCharsInOneStr = nCharsInOneStr = lstrlen(lpStr) + 1;
#endif

            if (nHalfCharsInOneStr <= nLimit) {
                // the room is enough, nChars + 1 for "1", "2", "3", ...
                CopyMemory(&szStrBuf[nChars + 1], lpStr,
                    (nCharsInOneStr - 1) * sizeof(TCHAR));
            } else if (i) {
                break;
            } else {
#ifdef UNICODE
                if (lpStr[nCharsInOneStr - 2 - 1] < 0x0200) {
                    // we need more room to put ".."
                    nCharsInOneStr -= 2;
                } else {
                    nCharsInOneStr -= 1;
                }
#else
                nHalfCharsInOneStr = nCharsInOneStr = nLimit - 2;
#endif
                // nChars + 1 for "1", "2", "3", ...
                CopyMemory(&szStrBuf[nChars + 1], lpStr,
                    (nCharsInOneStr - 1) * sizeof(TCHAR));

#ifdef UNICODE
                // unicode of ..
                iDx[nChars + nCharsInOneStr] = sImeG.xChiCharWi;
                szStrBuf[nChars + nCharsInOneStr++] = 0x2025;
#else
                szStrBuf[nChars + nCharsInOneStr++] = '.';
                szStrBuf[nChars + nCharsInOneStr++] = '.';
#endif
            }
#if defined(WINAR30)
        if (nCharsInOneStr <= 1) {
#ifdef UNICODE
            // add unicode 0x25A1
            *(LPWSTR)&szStrBuf[nChars +1] = 0x25A1;
#else
            // add big-5 0xA1BC
            *(LPWSTR)&szStrBuf[nChars +1] = 0xBCA1;
#endif
            nCharsInOneStr =1+ sizeof(WCHAR) / sizeof(TCHAR);
        }
#endif

            nChars += nCharsInOneStr;
            nHalfChars += nHalfCharsInOneStr;

            if (nHalfCharsInOneStr >= nLimit) {
                break;
            }
        }

        ExtTextOut(hDC, lpImeL->rcCandText.left, lpImeL->rcCandText.top,
            ETO_OPAQUE, &lpImeL->rcCandText,
            szStrBuf, nChars, iDx);

PaintOffCaretCompUnlockCandInfo:
        ImmUnlockIMCC(lpIMC->hCandInfo);

PaintOffCaretCompChkCandInfo:
        if (fCandidate) {
#if !defined(WINAR30)
            goto PaintOffCaretCompUnlockUIPriv;
#else
        } else {
            goto PaintOffCaretCandNone;
#endif
        }
#if defined(WINAR30)
    } else {
PaintOffCaretCandNone:
        ExtTextOut(hDC, lpImeL->rcCandText.left, lpImeL->rcCandText.top,
            ETO_OPAQUE, &lpImeL->rcCandText, (LPTSTR)NULL, 0, NULL);
#endif
    }

    // the composition window has daul function 1. composition window
    // 2. guideline so we need more check on ISC_xxx flags

    if (lpUIPrivate->nShowCompCmd == SW_HIDE) {
        goto PaintOffCaretCompNone;
    } else if (lpUIPrivate->fdwSetContext & ISC_SHOWUICOMPOSITIONWINDOW) {
        LPCOMPOSITIONSTRING lpCompStr;
        DWORD               dwCompStrLen;

        if (!lpIMC->hCompStr) {
            goto PaintOffCaretCompGuideLine;
        }

        lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
        if (!lpCompStr) {
            goto PaintOffCaretCompGuideLine;
        }

        dwCompStrLen = lpCompStr->dwCompStrLen;

        if (!lpCompStr->dwCompStrLen) {
            goto PaintOffCaretCompUnlockCompStr;
        }

        // black text for compistion string
        SetTextColor(hDC, RGB(0x00, 0x00, 0x00));

        ExtTextOut(hDC, lpImeL->rcCompText.left, lpImeL->rcCompText.top,
            ETO_OPAQUE, &lpImeL->rcCompText,
            (LPTSTR)((LPBYTE)lpCompStr + lpCompStr->dwCompStrOffset),
            lpCompStr->dwCompStrLen, iDx);

        if (lpCompStr->dwCompStrLen <= lpCompStr->dwCursorPos) {
            goto PaintOffCaretCompUnlockCompStr;
        }

        // there is error part
        // red text for error
        SetTextColor(hDC, RGB(0xFF, 0x00, 0x00));
        // dark gray background for error
        SetBkColor(hDC, RGB(0x80, 0x80, 0x80));

        ExtTextOut(hDC, lpImeL->rcCompText.left +
            lpCompStr->dwCursorPos * sImeG.xChiCharWi /
                (sizeof(WCHAR) / sizeof(TCHAR)),
            lpImeL->rcCompText.top,
            ETO_OPAQUE, NULL,
            (LPTSTR)((LPBYTE)lpCompStr + lpCompStr->dwCompStrOffset +
            lpCompStr->dwCursorPos),
            (lpCompStr->dwCompStrLen - lpCompStr->dwCursorPos), iDx);

PaintOffCaretCompUnlockCompStr:
        ImmUnlockIMCC(lpIMC->hCompStr);

        if (!dwCompStrLen) {
            goto PaintOffCaretCompGuideLine;
        }
    } else if (lpUIPrivate->fdwSetContext & ISC_SHOWUIGUIDELINE) {
        LPGUIDELINE     lpGuideLine;
        BOOL            fGuideLine;
        LPCANDIDATELIST lpCandList;
        UINT            uStrLen;

PaintOffCaretCompGuideLine:
        if (!lpIMC->hGuideLine) {
            goto PaintOffCaretCompNone;
        }

        lpGuideLine = (LPGUIDELINE)ImmLockIMCC(lpIMC->hGuideLine);
        if (!lpGuideLine) {
            goto PaintOffCaretCompNone;
        }

        fGuideLine = FALSE;

        if (lpGuideLine->dwLevel != GL_LEVEL_INFORMATION) {
            goto PaintOffCaretCompUnlockGuideLine;
        } else if (lpGuideLine->dwIndex != GL_ID_REVERSECONVERSION) {
            goto PaintOffCaretCompUnlockGuideLine;
        } else {
        }

        lpCandList = (LPCANDIDATELIST)((LPBYTE)lpGuideLine +
            lpGuideLine->dwPrivateOffset);

        if (!lpCandList) {
            goto PaintOffCaretCompUnlockGuideLine;
        } else if (!lpCandList->dwCount) {
            goto PaintOffCaretCompUnlockGuideLine;
        } else {
            fGuideLine = TRUE;
        }

        // green text for information
        SetTextColor(hDC, RGB(0x00, 0x80, 0x00));

        lpStr = (LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[0]);

        uStrLen = lstrlen(lpStr);

        ExtTextOut(hDC, lpImeL->rcCompText.left, lpImeL->rcCompText.top,
            ETO_OPAQUE, &lpImeL->rcCompText, lpStr, uStrLen, iDx);

PaintOffCaretCompUnlockGuideLine:
        ImmUnlockIMCC(lpIMC->hGuideLine);

        if (!fGuideLine) {
            goto PaintOffCaretCompNone;
        }
    } else {
PaintOffCaretCompNone:
        ExtTextOut(hDC, lpImeL->rcCompText.left, lpImeL->rcCompText.top,
            ETO_OPAQUE, &lpImeL->rcCompText, (LPTSTR)NULL, 0, NULL);
    }

    DeleteObject(SelectObject(hDC, hOldFont));

#if !defined(WINAR30)
PaintOffCaretCompUnlockUIPriv:
#endif
    GlobalUnlock(hUIPrivate);

PaintOffCaretCompUnlockIMC:
    ImmUnlockIMC(hIMC);
    return;
}
#endif

/**********************************************************************/
/* OffCaretWndProc() / UniOffCaretWndProc()                           */
/**********************************************************************/
#if defined(UNIIME)
LRESULT WINAPI   UniOffCaretWndProc(
    LPINSTDATAL lpInstL,
    LPIMEL      lpImeL,
#else
LRESULT CALLBACK OffCaretWndProc(
#endif
    HWND   hOffCaretWnd,
    UINT   uMsg,
    WPARAM wParam,
    LPARAM lParam)
{
    switch (uMsg) {
    case WM_DESTROY:
        DestroyOffCaretWindow(hOffCaretWnd);
        break;
    case WM_SETCURSOR:
        OffCaretSetCursor(
#if defined(UNIIME)
            lpInstL, lpImeL,
#endif
            hOffCaretWnd, lParam);
        break;
    case WM_MOUSEMOVE:
        if (GetWindowLong(hOffCaretWnd, UI_MOVE_OFFSET) != WINDOW_NOT_DRAG) {
            POINT ptCursor;

            DrawDragBorder(hOffCaretWnd,
                GetWindowLong(hOffCaretWnd, UI_MOVE_XY),
                GetWindowLong(hOffCaretWnd, UI_MOVE_OFFSET));
            GetCursorPos(&ptCursor);
            SetWindowLong(hOffCaretWnd, UI_MOVE_XY,
                MAKELONG(ptCursor.x, ptCursor.y));
            DrawDragBorder(hOffCaretWnd, MAKELONG(ptCursor.x, ptCursor.y),
                GetWindowLong(hOffCaretWnd, UI_MOVE_OFFSET));
        } else {
            return DefWindowProc(hOffCaretWnd, uMsg, wParam, lParam);
        }
        break;
    case WM_LBUTTONUP:
        if (GetWindowLong(hOffCaretWnd, UI_MOVE_OFFSET) != WINDOW_NOT_DRAG) {
            LONG   lTmpCursor, lTmpOffset;
            POINT  ptCursor;
            HWND   hUIWnd;

            lTmpCursor = GetWindowLong(hOffCaretWnd, UI_MOVE_XY);

            // calculate the org by the offset
            lTmpOffset = GetWindowLong(hOffCaretWnd, UI_MOVE_OFFSET);

            DrawDragBorder(hOffCaretWnd, lTmpCursor, lTmpOffset);

            ptCursor.x = (*(LPPOINTS)&lTmpCursor).x - (*(LPPOINTS)&lTmpOffset).x;
            ptCursor.y = (*(LPPOINTS)&lTmpCursor).y - (*(LPPOINTS)&lTmpOffset).y;

            SetWindowLong(hOffCaretWnd, UI_MOVE_OFFSET, WINDOW_NOT_DRAG);
            ReleaseCapture();

            AdjustStatusBoundary(
#if defined(UNIIME)
                lpImeL,
#endif
                &ptCursor);

            hUIWnd = GetWindow(hOffCaretWnd, GW_OWNER);

            ImmSetStatusWindowPos((HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC),
                &ptCursor);
        } else {
            return DefWindowProc(hOffCaretWnd, uMsg, wParam, lParam);
        }
        break;
    case WM_IME_NOTIFY:
        if (wParam == IMN_SETSTATUSWINDOWPOS) {
            SetStatusWindowPos(
#if defined(UNIIME)
                lpImeL,
#endif
                hOffCaretWnd);
        }
        break;
    case WM_PAINT:
        {
            HDC         hDC;
            PAINTSTRUCT ps;

            hDC = BeginPaint(hOffCaretWnd, &ps);
            PaintOffCaretStatus(
#if defined(UNIIME)
                lpInstL, lpImeL,
#endif
                hOffCaretWnd, hDC);
#if !defined(ROMANIME)
            PaintOffCaretComposition(
#if defined(UNIIME)
                lpImeL,
#endif
                hOffCaretWnd, hDC);
#endif
            EndPaint(hOffCaretWnd, &ps);
        }
        break;
    case WM_MOUSEACTIVATE:
        return (MA_NOACTIVATE);
    default:
        return DefWindowProc(hOffCaretWnd, uMsg, wParam, lParam);
    }

    return (0L);
}