guideline.c File Reference

#include "precomp.h"

Include dependency graph for guideline.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (imm)
static DWORD	ImmGetGuideLineAW (_In_ HIMC hIMC, _In_ DWORD dwIndex, _Out_writes_bytes_opt_(dwBufLen) LPVOID lpBuf, _In_ DWORD dwBufLen, _In_ BOOL bAnsi)
DWORD WINAPI	ImmGetGuideLineA (_In_ HIMC hIMC, _In_ DWORD dwIndex, _Out_writes_bytes_opt_(dwBufLen) LPSTR lpBuf, _In_ DWORD dwBufLen)
DWORD WINAPI	ImmGetGuideLineW (_In_ HIMC hIMC, _In_ DWORD dwIndex, _Out_writes_bytes_opt_(dwBufLen) LPWSTR lpBuf, _In_ DWORD dwBufLen)

Function Documentation

ImmGetGuideLineA()

DWORD WINAPI ImmGetGuideLineA	(	_In_ HIMC	hIMC,
		_In_ DWORD	dwIndex,
		_Out_writes_bytes_opt_(dwBufLen) LPSTR	lpBuf,
		_In_ DWORD	dwBufLen
	)

Definition at line 205 of file guideline.c.

{
    TRACE("(%p, %lu, %p, %lu)\n", hIMC, dwIndex, lpBuf, dwBufLen);
    return ImmGetGuideLineAW(hIMC, dwIndex, lpBuf, dwBufLen, TRUE);
}

Referenced by ActiveIMMApp_GetGuideLineA().

ImmGetGuideLineAW()

static DWORD ImmGetGuideLineAW ( _In_ HIMC  hIMC, _In_ DWORD  dwIndex, _Out_writes_bytes_opt_(dwBufLen) LPVOID  lpBuf, _In_ DWORD  dwBufLen, _In_ BOOL  bAnsi  )

static

Definition at line 13 of file guideline.c.

{
    PCLIENTIMC pClientImc;
    LPINPUTCONTEXT pIC;
    LPGUIDELINE pGuideLine;
    DWORD cb, ret = 0;
    LPVOID pvStr, pvPrivate;
    BOOL bUsedDefault;
    UINT uCodePage;
 
    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;
    }
 
    pGuideLine = ImmLockIMCC(pIC->hGuideLine);
    if (IS_NULL_UNEXPECTEDLY(pGuideLine))
    {
        ImmUnlockIMC(hIMC);
        ImmUnlockClientImc(pClientImc);
        return 0;
    }
 
    if (dwIndex == GGL_LEVEL)
    {
        ret = pGuideLine->dwLevel;
        goto Quit;
    }
 
    if (dwIndex == GGL_INDEX)
    {
        ret = pGuideLine->dwIndex;
        goto Quit;
    }
 
    if (dwIndex == GGL_STRING)
    {
        pvStr = (LPBYTE)pGuideLine + pGuideLine->dwStrOffset;
 
        /* get size */
        if (bAnsi)
        {
            if (pClientImc->dwFlags & CLIENTIMC_WIDE)
            {
                cb = WideCharToMultiByte(uCodePage, 0, pvStr, pGuideLine->dwStrLen,
                                         NULL, 0, NULL, &bUsedDefault);
            }
            else
            {
                cb = pGuideLine->dwStrLen * sizeof(CHAR);
            }
        }
        else
        {
            if (pClientImc->dwFlags & CLIENTIMC_WIDE)
            {
                cb = pGuideLine->dwStrLen * sizeof(WCHAR);
            }
            else
            {
                cb = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, pvStr, pGuideLine->dwStrLen,
                                         NULL, 0) * sizeof(WCHAR);
            }
        }
 
        if (dwBufLen == 0)
        {
            ret = cb;
            goto Quit;
        }
        if (cb == 0 || lpBuf == NULL || dwBufLen < cb)
        {
            ret = 0; /* Error */
            goto Quit;
        }
 
        /* store to buffer */
        if (bAnsi)
        {
            if (pClientImc->dwFlags & CLIENTIMC_WIDE)
            {
                ret = WideCharToMultiByte(uCodePage, 0, pvStr, pGuideLine->dwStrLen,
                                          lpBuf, dwBufLen, NULL, &bUsedDefault);
                goto Quit;
            }
        }
        else
        {
            if (!(pClientImc->dwFlags & CLIENTIMC_WIDE))
            {
                ret = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, pvStr, pGuideLine->dwStrLen,
                                          lpBuf, dwBufLen) * sizeof(WCHAR);
                goto Quit;
            }
        }
 
        RtlCopyMemory(lpBuf, pvStr, cb);
        ret = cb;
        goto Quit;
    }
 
    if (dwIndex == GGL_PRIVATE)
    {
        pvPrivate = (LPBYTE)pGuideLine + pGuideLine->dwPrivateOffset;
 
        /* get size */
        if (bAnsi)
        {
            if ((pClientImc->dwFlags & CLIENTIMC_WIDE) &&
                pGuideLine->dwIndex == GL_ID_REVERSECONVERSION)
            {
                cb = CandidateListWideToAnsi(pvPrivate, NULL, 0, uCodePage);
            }
            else
            {
                cb = pGuideLine->dwPrivateSize;
            }
        }
        else
        {
            if (!(pClientImc->dwFlags & CLIENTIMC_WIDE) &&
                pGuideLine->dwIndex == GL_ID_REVERSECONVERSION)
            {
                cb = CandidateListAnsiToWide(pvPrivate, NULL, 0, uCodePage);
            }
            else
            {
                cb = pGuideLine->dwPrivateSize;
            }
        }
 
        if (dwBufLen == 0)
        {
            ret = cb;
            goto Quit;
        }
        if (cb == 0 || lpBuf == NULL || dwBufLen < cb)
        {
            ret = 0; /* Error */
            goto Quit;
        }
 
        /* store to buffer */
        if (bAnsi)
        {
            if ((pClientImc->dwFlags & CLIENTIMC_WIDE) &&
                pGuideLine->dwIndex == GL_ID_REVERSECONVERSION)
            {
                ret = CandidateListWideToAnsi(pvPrivate, lpBuf, cb, uCodePage);
                goto Quit;
            }
        }
        else
        {
            if (!(pClientImc->dwFlags & CLIENTIMC_WIDE) &&
                pGuideLine->dwIndex == GL_ID_REVERSECONVERSION)
            {
                ret = CandidateListAnsiToWide(pvPrivate, lpBuf, cb, uCodePage);
                goto Quit;
            }
        }
 
        RtlCopyMemory(lpBuf, pvPrivate, cb);
        ret = cb;
        goto Quit;
    }
 
Quit:
    ImmUnlockIMCC(pIC->hGuideLine);
    ImmUnlockIMC(hIMC);
    ImmUnlockClientImc(pClientImc);
    TRACE("ret: 0x%X\n", ret);
    return ret;
}

Referenced by ImmGetGuideLineA(), and ImmGetGuideLineW().

ImmGetGuideLineW()

DWORD WINAPI ImmGetGuideLineW	(	_In_ HIMC	hIMC,
		_In_ DWORD	dwIndex,
		_Out_writes_bytes_opt_(dwBufLen) LPWSTR	lpBuf,
		_In_ DWORD	dwBufLen
	)

Definition at line 219 of file guideline.c.

{
    TRACE("(%p, %lu, %p, %lu)\n", hIMC, dwIndex, lpBuf, dwBufLen);
    return ImmGetGuideLineAW(hIMC, dwIndex, lpBuf, dwBufLen, FALSE);
}

Referenced by ActiveIMMApp_GetGuideLineW(), and ConIme_OnNotifyGuideLine().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

imm

)