candidate.c File Reference

#include "precomp.h"

Include dependency graph for candidate.c:

Go to the source code of this file.

Macros
#define	ROUNDUP4(n)   (((n) + 3) & ~3) /* DWORD alignment */

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (imm)
DWORD	CandidateListWideToAnsi (const CANDIDATELIST *pWideCL, LPCANDIDATELIST pAnsiCL, DWORD dwBufLen, UINT uCodePage)
DWORD	CandidateListAnsiToWide (const CANDIDATELIST *pAnsiCL, LPCANDIDATELIST pWideCL, DWORD dwBufLen, UINT uCodePage)
static DWORD	ImmGetCandidateListAW (_In_ HIMC hIMC, _In_ DWORD dwIndex, _Out_writes_bytes_opt_(dwBufLen) LPCANDIDATELIST lpCandList, _In_ DWORD dwBufLen, _In_ BOOL bAnsi)
static DWORD	ImmGetCandidateListCountAW (_In_ HIMC hIMC, _Out_ LPDWORD lpdwListCount, _In_ BOOL bAnsi)
DWORD WINAPI	ImmGetCandidateListA (_In_ HIMC hIMC, _In_ DWORD dwIndex, _Out_writes_bytes_opt_(dwBufLen) LPCANDIDATELIST lpCandList, _In_ DWORD dwBufLen)
DWORD WINAPI	ImmGetCandidateListCountA (_In_ HIMC hIMC, _Out_ LPDWORD lpdwListCount)
DWORD WINAPI	ImmGetCandidateListCountW (_In_ HIMC hIMC, _Out_ LPDWORD lpdwListCount)
DWORD WINAPI	ImmGetCandidateListW (_In_ HIMC hIMC, _In_ DWORD dwIndex, _Out_writes_bytes_opt_(dwBufLen) LPCANDIDATELIST lpCandList, _In_ DWORD dwBufLen)
BOOL WINAPI	ImmGetCandidateWindow (_In_ HIMC hIMC, _In_ DWORD dwIndex, _Out_ LPCANDIDATEFORM lpCandidate)
BOOL WINAPI	ImmSetCandidateWindow (_In_ HIMC hIMC, _In_ LPCANDIDATEFORM lpCandidate)

Macro Definition Documentation

ROUNDUP4

#define ROUNDUP4

(

n

)

(((n) + 3) & ~3) /* DWORD alignment */

Definition at line 12 of file candidate.c.

Function Documentation

CandidateListAnsiToWide()

DWORD CandidateListAnsiToWide	(	const CANDIDATELIST *	pAnsiCL,
		LPCANDIDATELIST	pWideCL,
		DWORD	dwBufLen,
		UINT	uCodePage
	)

Definition at line 84 of file candidate.c.

{
    DWORD dwSize, dwIndex, cchGot, cbGot, cbLeft;
    const BYTE *pbAnsi;
    LPBYTE pbWide;
    LPDWORD pibOffsets;
 
    /* calculate total wide size */
    if (pAnsiCL->dwCount > 0)
    {
        dwSize = sizeof(CANDIDATELIST) + ((pAnsiCL->dwCount - 1) * sizeof(DWORD));
        for (dwIndex = 0; dwIndex < pAnsiCL->dwCount; ++dwIndex)
        {
            pbAnsi = (const BYTE *)pAnsiCL + pAnsiCL->dwOffset[dwIndex];
            cchGot = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, (LPCSTR)pbAnsi, -1, NULL, 0);
            dwSize += cchGot * sizeof(WCHAR);
        }
    }
    else
    {
        dwSize = sizeof(CANDIDATELIST);
    }
 
    dwSize = ROUNDUP4(dwSize);
    if (dwBufLen == 0)
        return dwSize;
    if (dwBufLen < dwSize)
        return 0;
 
    /* store to wide */
    pWideCL->dwSize = dwBufLen;
    pWideCL->dwStyle = pAnsiCL->dwStyle;
    pWideCL->dwCount = pAnsiCL->dwCount;
    pWideCL->dwSelection = pAnsiCL->dwSelection;
    pWideCL->dwPageStart = pAnsiCL->dwPageStart;
    pWideCL->dwPageSize = pAnsiCL->dwPageSize;
 
    pibOffsets = pWideCL->dwOffset;
    if (pAnsiCL->dwCount > 0)
    {
        pibOffsets[0] = sizeof(CANDIDATELIST) + ((pWideCL->dwCount - 1) * sizeof(DWORD));
        cbLeft = dwBufLen - pibOffsets[0];
 
        for (dwIndex = 0; dwIndex < pAnsiCL->dwCount; ++dwIndex)
        {
            pbAnsi = (const BYTE *)pAnsiCL + pAnsiCL->dwOffset[dwIndex];
            pbWide = (LPBYTE)pWideCL + pibOffsets[dwIndex];
 
            /* convert to wide */
            cchGot = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, (LPCSTR)pbAnsi, -1,
                                         (LPWSTR)pbWide, cbLeft / sizeof(WCHAR));
            cbGot = cchGot * sizeof(WCHAR);
            cbLeft -= cbGot;
 
            if (dwIndex + 1 < pAnsiCL->dwCount)
                pibOffsets[dwIndex + 1] = pibOffsets[dwIndex] + cbGot;
        }
    }
    else
    {
        pibOffsets[0] = sizeof(CANDIDATELIST);
    }
 
    return dwBufLen;
}

Referenced by ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetConversionListW(), and ImmGetGuideLineAW().

CandidateListWideToAnsi()

DWORD CandidateListWideToAnsi	(	const CANDIDATELIST *	pWideCL,
		LPCANDIDATELIST	pAnsiCL,
		DWORD	dwBufLen,
		UINT	uCodePage
	)

Definition at line 15 of file candidate.c.

{
    BOOL bUsedDefault;
    DWORD dwSize, dwIndex, cbGot, cbLeft;
    const BYTE *pbWide;
    LPBYTE pbAnsi;
    LPDWORD pibOffsets;
 
    /* calculate total ansi size */
    if (pWideCL->dwCount > 0)
    {
        dwSize = sizeof(CANDIDATELIST) + ((pWideCL->dwCount - 1) * sizeof(DWORD));
        for (dwIndex = 0; dwIndex < pWideCL->dwCount; ++dwIndex)
        {
            pbWide = (const BYTE *)pWideCL + pWideCL->dwOffset[dwIndex];
            cbGot = WideCharToMultiByte(uCodePage, 0, (LPCWSTR)pbWide, -1, NULL, 0,
                                        NULL, &bUsedDefault);
            dwSize += cbGot;
        }
    }
    else
    {
        dwSize = sizeof(CANDIDATELIST);
    }
 
    dwSize = ROUNDUP4(dwSize);
    if (dwBufLen == 0)
        return dwSize;
    if (dwBufLen < dwSize)
        return 0;
 
    /* store to ansi */
    pAnsiCL->dwSize = dwBufLen;
    pAnsiCL->dwStyle = pWideCL->dwStyle;
    pAnsiCL->dwCount = pWideCL->dwCount;
    pAnsiCL->dwSelection = pWideCL->dwSelection;
    pAnsiCL->dwPageStart = pWideCL->dwPageStart;
    pAnsiCL->dwPageSize = pWideCL->dwPageSize;
 
    pibOffsets = pAnsiCL->dwOffset;
    if (pWideCL->dwCount > 0)
    {
        pibOffsets[0] = sizeof(CANDIDATELIST) + ((pWideCL->dwCount - 1) * sizeof(DWORD));
        cbLeft = dwBufLen - pibOffsets[0];
 
        for (dwIndex = 0; dwIndex < pWideCL->dwCount; ++dwIndex)
        {
            pbWide = (const BYTE *)pWideCL + pWideCL->dwOffset[dwIndex];
            pbAnsi = (LPBYTE)pAnsiCL + pibOffsets[dwIndex];
 
            /* convert to ansi */
            cbGot = WideCharToMultiByte(uCodePage, 0, (LPCWSTR)pbWide, -1,
                                        (LPSTR)pbAnsi, cbLeft, NULL, &bUsedDefault);
            cbLeft -= cbGot;
 
            if (dwIndex < pWideCL->dwCount - 1)
                pibOffsets[dwIndex + 1] = pibOffsets[dwIndex] + cbGot;
        }
    }
    else
    {
        pibOffsets[0] = sizeof(CANDIDATELIST);
    }
 
    return dwBufLen;
}

Referenced by ImmGetCandidateListAW(), ImmGetCandidateListCountAW(), ImmGetConversionListA(), and ImmGetGuideLineAW().

ImmGetCandidateListA()

DWORD WINAPI ImmGetCandidateListA	(	_In_ HIMC	hIMC,
		_In_ DWORD	dwIndex,
		_Out_writes_bytes_opt_(dwBufLen) LPCANDIDATELIST	lpCandList,
		_In_ DWORD	dwBufLen
	)

Definition at line 348 of file candidate.c.

{
    return ImmGetCandidateListAW(hIMC, dwIndex, lpCandList, dwBufLen, TRUE);
}

Referenced by ActiveIMMApp_GetCandidateListA(), and test_InvalidIMC().

ImmGetCandidateListAW()

static DWORD ImmGetCandidateListAW ( _In_ HIMC  hIMC, _In_ DWORD  dwIndex, _Out_writes_bytes_opt_(dwBufLen) LPCANDIDATELIST  lpCandList, _In_ DWORD  dwBufLen, _In_ BOOL  bAnsi  )

static

Definition at line 152 of file candidate.c.

{
    DWORD dwSize, ret = 0;
    UINT uCodePage;
    LPINPUTCONTEXT pIC;
    PCLIENTIMC pClientImc;
    LPCANDIDATEINFO pCI;
    LPCANDIDATELIST pCL;
 
    pClientImc = ImmLockClientImc(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pClientImc))
        return 0;
 
    uCodePage = pClientImc->uCodePage;
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
    {
        ImmUnlockClientImc(pClientImc);
        return 0;
    }
 
    pCI = ImmLockIMCC(pIC->hCandInfo);
    if (IS_NULL_UNEXPECTEDLY(pCI))
    {
        ImmUnlockIMC(hIMC);
        ImmUnlockClientImc(pClientImc);
        return 0;
    }
 
    if (pCI->dwSize < sizeof(CANDIDATEINFO))
    {
        ERR("Too small\n");
        goto Quit;
    }
 
    if (pCI->dwCount <= dwIndex)
    {
        ERR("Out of boundary\n");
        goto Quit;
    }
 
    /* get required size */
    pCL = (LPCANDIDATELIST)((LPBYTE)pCI + pCI->dwOffset[dwIndex]);
    if (bAnsi)
    {
        if (pClientImc->dwFlags & CLIENTIMC_WIDE)
            dwSize = CandidateListAnsiToWide(pCL, NULL, 0, uCodePage);
        else
            dwSize = pCL->dwSize;
    }
    else
    {
        if (pClientImc->dwFlags & CLIENTIMC_WIDE)
            dwSize = pCL->dwSize;
        else
            dwSize = CandidateListWideToAnsi(pCL, NULL, 0, uCodePage);
    }
 
    if (dwBufLen != 0 && dwSize != 0)
    {
        if (lpCandList == NULL || dwBufLen < dwSize)
            goto Quit;
 
        /* store */
        if (bAnsi)
        {
            if (pClientImc->dwFlags & CLIENTIMC_WIDE)
                CandidateListAnsiToWide(pCL, lpCandList, dwSize, uCodePage);
            else
                RtlCopyMemory(lpCandList, pCL, dwSize);
        }
        else
        {
            if (pClientImc->dwFlags & CLIENTIMC_WIDE)
                RtlCopyMemory(lpCandList, pCL, dwSize);
            else
                CandidateListWideToAnsi(pCL, lpCandList, dwSize, uCodePage);
        }
    }
 
    ret = dwSize;
 
Quit:
    ImmUnlockIMCC(pIC->hCandInfo);
    ImmUnlockIMC(hIMC);
    ImmUnlockClientImc(pClientImc);
    TRACE("ret: 0x%X\n", ret);
    return ret;
}

Referenced by ImmGetCandidateListA(), and ImmGetCandidateListW().

ImmGetCandidateListCountA()

DWORD WINAPI ImmGetCandidateListCountA	(	_In_ HIMC	hIMC,
		_Out_ LPDWORD	lpdwListCount
	)

Definition at line 361 of file candidate.c.

{
    return ImmGetCandidateListCountAW(hIMC, lpdwListCount, TRUE);
}

Referenced by ActiveIMMApp_GetCandidateListCountA(), ActiveIMMApp_GetCandidateListCountW(), and test_InvalidIMC().

ImmGetCandidateListCountAW()

static DWORD ImmGetCandidateListCountAW ( _In_ HIMC  hIMC, _Out_ LPDWORD  lpdwListCount, _In_ BOOL  bAnsi  )

static

Definition at line 248 of file candidate.c.

{
    DWORD ret = 0, cbGot, dwIndex;
    PCLIENTIMC pClientImc;
    LPINPUTCONTEXT pIC;
    UINT uCodePage;
    const CANDIDATEINFO *pCI;
    const BYTE *pb;
    const CANDIDATELIST *pCL;
    const DWORD *pdwOffsets;
 
    if (IS_NULL_UNEXPECTEDLY(lpdwListCount))
        return 0;
 
    *lpdwListCount = 0;
 
    pClientImc = ImmLockClientImc(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pClientImc))
        return 0;
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
    {
        ImmUnlockClientImc(pClientImc);
        return 0;
    }
 
    uCodePage = pClientImc->uCodePage;
 
    pCI = ImmLockIMCC(pIC->hCandInfo);
    if (IS_NULL_UNEXPECTEDLY(pCI))
    {
        ImmUnlockIMC(hIMC);
        ImmUnlockClientImc(pClientImc);
        return 0;
    }
 
    if (pCI->dwSize < sizeof(CANDIDATEINFO))
    {
        ERR("Too small\n");
        goto Quit;
    }
 
    *lpdwListCount = pCI->dwCount; /* the number of candidate lists */
 
    /* calculate total size of candidate lists */
    if (bAnsi)
    {
        if (pClientImc->dwFlags & CLIENTIMC_WIDE)
        {
            ret = ROUNDUP4(pCI->dwPrivateSize);
            pdwOffsets = pCI->dwOffset;
            for (dwIndex = 0; dwIndex < pCI->dwCount; ++dwIndex)
            {
                pb = (const BYTE *)pCI + pdwOffsets[dwIndex];
                pCL = (const CANDIDATELIST *)pb;
                cbGot = CandidateListWideToAnsi(pCL, NULL, 0, uCodePage);
                ret += cbGot;
            }
        }
        else
        {
            ret = pCI->dwSize;
        }
    }
    else
    {
        if (pClientImc->dwFlags & CLIENTIMC_WIDE)
        {
            ret = pCI->dwSize;
        }
        else
        {
            ret = ROUNDUP4(pCI->dwPrivateSize);
            pdwOffsets = pCI->dwOffset;
            for (dwIndex = 0; dwIndex < pCI->dwCount; ++dwIndex)
            {
                pb = (const BYTE *)pCI + pdwOffsets[dwIndex];
                pCL = (const CANDIDATELIST *)pb;
                cbGot = CandidateListAnsiToWide(pCL, NULL, 0, uCodePage);
                ret += cbGot;
            }
        }
    }
 
Quit:
    ImmUnlockIMCC(pIC->hCandInfo);
    ImmUnlockIMC(hIMC);
    ImmUnlockClientImc(pClientImc);
    TRACE("ret: 0x%X\n", ret);
    return ret;
}

Referenced by ImmGetCandidateListCountA(), and ImmGetCandidateListCountW().

ImmGetCandidateListCountW()

DWORD WINAPI ImmGetCandidateListCountW	(	_In_ HIMC	hIMC,
		_Out_ LPDWORD	lpdwListCount
	)

Definition at line 372 of file candidate.c.

{
    return ImmGetCandidateListCountAW(hIMC, lpdwListCount, FALSE);
}

ImmGetCandidateListW()

DWORD WINAPI ImmGetCandidateListW	(	_In_ HIMC	hIMC,
		_In_ DWORD	dwIndex,
		_Out_writes_bytes_opt_(dwBufLen) LPCANDIDATELIST	lpCandList,
		_In_ DWORD	dwBufLen
	)

Definition at line 383 of file candidate.c.

{
    return ImmGetCandidateListAW(hIMC, dwIndex, lpCandList, dwBufLen, FALSE);
}

Referenced by ActiveIMMApp_GetCandidateListW().

ImmGetCandidateWindow()

BOOL WINAPI ImmGetCandidateWindow	(	_In_ HIMC	hIMC,
		_In_ DWORD	dwIndex,
		_Out_ LPCANDIDATEFORM	lpCandidate
	)

Definition at line 396 of file candidate.c.

{
    BOOL ret = FALSE;
    LPINPUTCONTEXT pIC;
    LPCANDIDATEFORM pCF;
 
    TRACE("(%p, %lu, %p)\n", hIMC, dwIndex, lpCandidate);
 
    if (dwIndex >= MAX_CANDIDATEFORM) /* Windows didn't check but we do for security reason */
    {
        ERR("Out of boundary\n");
        return FALSE;
    }
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return FALSE;
 
    pCF = &pIC->cfCandForm[dwIndex];
    if (pCF->dwIndex != IMM_INVALID_CANDFORM)
    {
        *lpCandidate = *pCF;
        ret = TRUE;
    }
 
    ImmUnlockIMC(hIMC);
    TRACE("ret: %d\n", ret);
    return ret;
}

Referenced by ActiveIMMApp_GetCandidateWindow(), ImeWnd_OnImeSystem(), test_ImmThreads(), and test_InvalidIMC().

ImmSetCandidateWindow()

BOOL WINAPI ImmSetCandidateWindow	(	_In_ HIMC	hIMC,
		_In_ LPCANDIDATEFORM	lpCandidate
	)

Definition at line 433 of file candidate.c.

{
    HWND hWnd;
    LPINPUTCONTEXT pIC;
 
    TRACE("(%p, %p)\n", hIMC, lpCandidate);
 
    if (lpCandidate->dwIndex >= MAX_CANDIDATEFORM)
    {
        ERR("Out of boundary\n");
        return FALSE;
    }
 
    if (IS_CROSS_THREAD_HIMC(hIMC))
        return FALSE;
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return FALSE;
 
    hWnd = pIC->hWnd;
    pIC->cfCandForm[lpCandidate->dwIndex] = *lpCandidate;
 
    ImmUnlockIMC(hIMC);
 
    Imm32MakeIMENotify(hIMC, hWnd, NI_CONTEXTUPDATED, 0, IMC_SETCANDIDATEPOS,
                       IMN_SETCANDIDATEPOS, (1 << (BYTE)lpCandidate->dwIndex));
    return TRUE;
}

Referenced by ActiveIMMApp_SetCandidateWindow(), ImeWnd_OnImeControl(), ImeWnd_OnImeSystem(), ImmGetContextThreadFunc(), and test_ImmThreads().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

imm

)