⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 candui.c

📁 蒙古文输入法源码
💻 C
📖 第 1 页 / 共 3 页
字号:
    // get lpIMC
    lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
    if (!lpIMC) {
        return;
    }

    // get lpImcP
    lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
    if (!lpImcP) {
        return;
    }

    // get lpCandInfo
    lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);

    if (!lpCandInfo) {
        return;
    }
                                                 
    // get lpCandList and init dwCount & dwSelection
    lpCandList = (LPCANDIDATELIST)
        ((LPBYTE)lpCandInfo + lpCandInfo->dwOffset[0]);
    
    switch(uCandDownUp) {
    case uCandHome:
        ChooseCand(0x24, lpIMC, lpCandInfo, lpImcP);
        NotifyIME(hIMC, NI_CHANGECANDIDATELIST, 0, 0);
        break;
    case uCandUp:
        ChooseCand('-', lpIMC, lpCandInfo, lpImcP);
        NotifyIME(hIMC, NI_CHANGECANDIDATELIST, 0, 0);
        break;
    case uCandDown:
        ChooseCand('=', lpIMC, lpCandInfo, lpImcP);
        NotifyIME(hIMC, NI_CHANGECANDIDATELIST, 0, 0);
        break;
    case uCandEnd:
        ChooseCand(0x23, lpIMC, lpCandInfo, lpImcP);
        NotifyIME(hIMC, NI_CHANGECANDIDATELIST, 0, 0);
        break;
    default:
        break;
    }

    ImmUnlockIMCC(lpIMC->hPrivate);
    ImmUnlockIMCC(lpIMC->hCandInfo);
    ImmUnlockIMC(hIMC);

    // draw button down
    hDC = GetDC(hCandWnd);
    hCandHpBmp = LoadBitmap(hInst, TEXT("CandHp"));
    hCandUpBmp = LoadBitmap(hInst, TEXT("CandUp"));
    hCandDpBmp = LoadBitmap(hInst, TEXT("CandDp"));
    hCandEpBmp = LoadBitmap(hInst, TEXT("CandEp"));

    hMemDC = CreateCompatibleDC(hDC);

    switch(uCandDownUp) {
    case uCandHome:
        hOldBmp = SelectObject(hMemDC, hCandHpBmp);
        BitBlt(hDC, sImeG.rcCandBTH.left, sImeG.rcCandBTH.top,
            sImeG.rcCandBTH.right - sImeG.rcCandBTH.left,
            STATUS_DIM_Y,
            hMemDC, 0, 0, SRCCOPY);
        break;
    case uCandUp:
        hOldBmp = SelectObject(hMemDC, hCandUpBmp);
        BitBlt(hDC, sImeG.rcCandBTU.left, sImeG.rcCandBTU.top,
            sImeG.rcCandBTU.right - sImeG.rcCandBTU.left,
            STATUS_DIM_Y,
            hMemDC, 0, 0, SRCCOPY);
        break;
    case uCandDown:
        hOldBmp = SelectObject(hMemDC, hCandDpBmp);
        BitBlt(hDC, sImeG.rcCandBTD.left, sImeG.rcCandBTD.top,
            sImeG.rcCandBTD.right - sImeG.rcCandBTD.left,
            STATUS_DIM_Y,
            hMemDC, 0, 0, SRCCOPY);

        break;
    case uCandEnd:
        hOldBmp = SelectObject(hMemDC, hCandEpBmp);
        BitBlt(hDC, sImeG.rcCandBTE.left, sImeG.rcCandBTE.top,
            sImeG.rcCandBTE.right - sImeG.rcCandBTE.left,
            STATUS_DIM_Y,
            hMemDC, 0, 0, SRCCOPY);
        break;
    default:
        break;
    }
        
    SelectObject(hMemDC, hOldBmp);
    DeleteDC(hMemDC);
    DeleteObject(hCandEpBmp);
    DeleteObject(hCandDpBmp);
    DeleteObject(hCandUpBmp);
    DeleteObject(hCandHpBmp);
    ReleaseDC(hCandWnd, hDC);

    return;
}

/**********************************************************************/
/* CandSetCursor()                                                    */
/**********************************************************************/
void PASCAL CandSetCursor(
    HWND   hCandWnd,
    LPARAM lParam)
{
    POINT ptCursor;
    RECT  rcWnd;

    if (GetWindowLong(hCandWnd, UI_MOVE_OFFSET) !=
        WINDOW_NOT_DRAG) {
        SetCursor(LoadCursor(NULL, IDC_SIZEALL));
        return;
    }

    if (HIWORD(lParam) == WM_LBUTTONDOWN) {
        SystemParametersInfo(SPI_GETWORKAREA, 0, &sImeG.rcWorkArea, 0);

        GetCursorPos(&ptCursor);
        ScreenToClient(hCandWnd, &ptCursor);

        if (PtInRect(&sImeG.rcCandText, ptCursor)
           && sImeG.IC_Trace) {
            SetCursor(LoadCursor(hInst, szHandCursor));
            MouseSelectCandStr(hCandWnd, &ptCursor);
            return;
        } else if (PtInRect(&sImeG.rcCandBTH, ptCursor)) {
            CandPageDownUP(hCandWnd, uCandHome);
            return;
        } else if (PtInRect(&sImeG.rcCandBTU, ptCursor)) {
            CandPageDownUP(hCandWnd, uCandUp);
            return;
        } else if (PtInRect(&sImeG.rcCandBTD, ptCursor)) {
            CandPageDownUP(hCandWnd, uCandDown);
            return;
        } else if (PtInRect(&sImeG.rcCandBTE, ptCursor)) {
            CandPageDownUP(hCandWnd, uCandEnd);
            return;
        } else {
            SetCursor(LoadCursor(NULL, IDC_SIZEALL));
        }
    } else if (HIWORD(lParam) == WM_LBUTTONUP) {
        HDC             hDC;
        HBITMAP         hCandHBmp, hCandUBmp, hCandDBmp, hCandEBmp;
        HBITMAP         hOldBmp;
        HDC             hMemDC;

        hDC = GetDC(hCandWnd);

        hCandHBmp = LoadBitmap(hInst, TEXT("CandH"));
        hCandUBmp = LoadBitmap(hInst, TEXT("CandU"));
        hCandDBmp = LoadBitmap(hInst, TEXT("CandD"));
        hCandEBmp = LoadBitmap(hInst, TEXT("CandE"));
        hMemDC = CreateCompatibleDC(hDC);

        hOldBmp = 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);
        DeleteObject(hCandEBmp);
        DeleteObject(hCandDBmp);
        DeleteObject(hCandUBmp);
        DeleteObject(hCandEBmp);
        DeleteDC(hMemDC);
        ReleaseDC(hCandWnd, hDC);

        return;
    } else {
        SystemParametersInfo(SPI_GETWORKAREA, 0, &sImeG.rcWorkArea, 0);

        GetCursorPos(&ptCursor);
        ScreenToClient(hCandWnd, &ptCursor);

        if (PtInRect(&sImeG.rcCandText, ptCursor)) {
            SetCursor(LoadCursor(hInst, szHandCursor));
            return;
        } else if (PtInRect(&sImeG.rcCandBTH, ptCursor)) {
            SetCursor(LoadCursor(hInst, szHandCursor));
        } else if (PtInRect(&sImeG.rcCandBTU, ptCursor)) {
            SetCursor(LoadCursor(hInst, szHandCursor));
        } else if (PtInRect(&sImeG.rcCandBTD, ptCursor)) {
            SetCursor(LoadCursor(hInst, szHandCursor));
        } else if (PtInRect(&sImeG.rcCandBTE, ptCursor)) {
            SetCursor(LoadCursor(hInst, szHandCursor));
        } else {
            SetCursor(LoadCursor(NULL, IDC_SIZEALL));
        }

        return;
    }

    SetCapture(hCandWnd);
    GetCursorPos(&ptCursor);
    SetWindowLong(hCandWnd, UI_MOVE_XY,
        MAKELONG(ptCursor.x, ptCursor.y));
    GetWindowRect(hCandWnd, &rcWnd);
    SetWindowLong(hCandWnd, UI_MOVE_OFFSET,
        MAKELONG(ptCursor.x - rcWnd.left, ptCursor.y - rcWnd.top));

    DrawDragBorder(hCandWnd, MAKELONG(ptCursor.x, ptCursor.y),
        GetWindowLong(hCandWnd, UI_MOVE_OFFSET));

    return;
}

/**********************************************************************/
/* CandButtonUp()                                                     */
/**********************************************************************/
BOOL PASCAL CandButtonUp(
    HWND hCandWnd)
{
    LONG           lTmpCursor, lTmpOffset;
    POINT          pt;
    HWND           hUIWnd;
    HIMC           hIMC;
    LPINPUTCONTEXT lpIMC;

    if (GetWindowLong(hCandWnd, UI_MOVE_OFFSET) == WINDOW_NOT_DRAG) {
        return (FALSE);
    }

    lTmpCursor = GetWindowLong(hCandWnd, UI_MOVE_XY);

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

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

    DrawDragBorder(hCandWnd, lTmpCursor, lTmpOffset);
    SetWindowLong(hCandWnd, UI_MOVE_OFFSET, WINDOW_NOT_DRAG);
    ReleaseCapture();

    hUIWnd = GetWindow(hCandWnd, GW_OWNER);

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

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

    AdjustCandBoundry(&pt);

    ScreenToClient(lpIMC->hWnd, &pt);

    lpIMC->cfCandForm[0].dwStyle |= CFS_CANDIDATEPOS;
    lpIMC->cfCandForm[0].ptCurrentPos = pt;

    ImmUnlockIMC(hIMC);

    PostMessage(hCandWnd, WM_IME_NOTIFY, IMN_SETCANDIDATEPOS, 0x0001);

    return (TRUE);
}

/**********************************************************************/
/* UpdateCandWindow()                                                 */
/**********************************************************************/
void PASCAL PaintCandWindow(
    HWND hCandWnd,
    HDC  hDC)
{
    HIMC            hIMC;
    LPINPUTCONTEXT  lpIMC;
    LPCANDIDATEINFO lpCandInfo;
    LPCANDIDATELIST lpCandList;
    LPPRIVCONTEXT   lpImcP;
    HGDIOBJ         hOldFont;
    DWORD           dwStart, dwEnd;
    TCHAR           szStrBuf[2 * MAXSTRLEN * sizeof(WCHAR) / sizeof(TCHAR) + 1];
	TCHAR			szStrHead[5];
	TCHAR			szStrChar[2];
    int             i, j;
    HBITMAP         hCandIconBmp, hCandInfBmp;
    HBITMAP         hOldBmp, hCandHBmp, hCandUBmp, hCandDBmp, hCandEBmp;
    HDC             hMemDC;

    hIMC = (HIMC)GetWindowLongPtr(GetWindow(hCandWnd, GW_OWNER), IMMGWLP_IMC);
    if (!hIMC) {
        return;
    }

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

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

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

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

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

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

    dwStart = lpCandList->dwSelection;
    dwEnd = dwStart + lpCandList->dwPageSize;

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

    // draw CandWnd Layout
    if (sImeG.IC_Trace) {
        RECT rcWnd;

        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);
        szStrHead[0] = TEXT('1');
        szStrHead[1] = TEXT('\0');
        szStrHead[2] = TEXT('\0');
        szStrHead[3] = TEXT('\0');
        szStrHead[4] = TEXT('\0');

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

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

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

            if (iLen > 40 * 2 / sizeof(TCHAR)) {
                iLen = 40 * 2 / sizeof(TCHAR);
                CopyMemory(szStrBuf,
                    ((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,
                    (LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[dwStart]),
                    iLen*sizeof(TCHAR));
            }

			{
				{
					LOGFONT lfFont;
					// set font
					if (sImeG.fDiffSysCharSet) {
						ZeroMemory(&lfFont, sizeof(lfFont));
						hOldFont = GetCurrentObject(hDC, OBJ_FONT);
						lfFont.lfHeight = -MulDiv(12, GetDeviceCaps(hDC, LOGPIXELSY), 72);
						lfFont.lfCharSet = NATIVE_CHARSET;
						lstrcpy(lfFont.lfFaceName, TEXT("Simsun"));
						if( SelectObject(hDC, CreateFontIndirect(&lfFont)) == HGDI_ERROR )
						{
							//__asm int 3;
						}
					}
            		ExtTextOut(hDC, sImeG.rcCandText.left + i * (sImeG.xChiCharWi+4) + 10,
						sImeG.rcCandText.top,
						(UINT)0, NULL,
						szStrHead,
						lstrlen(szStrHead ), NULL);
				}
				{
					LOGFONT lfFont;
					ZeroMemory(&lfFont, sizeof(lfFont));
					lfFont.lfHeight = -MulDiv(12, GetDeviceCaps(hDC, LOGPIXELSY), 72);
					lfFont.lfCharSet = ANSI_CHARSET;
					lfFont.lfEscapement = 2700;
					lstrcpy(lfFont.lfFaceName, TEXT("SaiyinWebCaganTig"));//Saiyin1 

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -