compstr.c File Reference

#include "precomp.h"

Include dependency graph for compstr.c:

Go to the source code of this file.

Macros
#define	CS_StrA(pCS, Name)   ((LPCSTR)(pCS) + (pCS)->dw##Name##Offset)
#define	CS_StrW(pCS, Name)   ((LPCWSTR)CS_StrA(pCS, Name))
#define	CS_Attr(pCS, Name)   ((const BYTE *)CS_StrA(pCS, Name))
#define	CS_Clause(pCS, Name)   ((const DWORD *)CS_StrA(pCS, Name))
#define	CS_Size(pCS, Name)   ((pCS)->dw##Name##Len)
#define	CS_SizeA(pCS, Name)   (CS_Size(pCS, Name) * sizeof(CHAR))
#define	CS_SizeW(pCS, Name)   (CS_Size(pCS, Name) * sizeof(WCHAR))
#define	CS_DoStr(pCS, Name, AorW)
#define	CS_DoStrA(pCS, Name)   CS_DoStr(pCS, Name, A)
#define	CS_DoStrW(pCS, Name)   CS_DoStr(pCS, Name, W)
#define	CS_DoAttr   CS_DoStrA
#define	CS_DoClause   CS_DoStrA

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (imm)
BOOL	Imm32OpenICAndCS (HIMC hIMC, LPINPUTCONTEXT *ppIC, LPCOMPOSITIONSTRING *ppCS)
static LONG	Imm32CompStrAnsiToWide (LPCSTR psz, DWORD cb, LPWSTR lpBuf, DWORD dwBufLen, UINT uCodePage)
static LONG	Imm32CompStrWideToAnsi (LPCWSTR psz, DWORD cb, LPSTR lpBuf, DWORD dwBufLen, UINT uCodePage)
static INT	Imm32CompAttrWideToAnsi (const BYTE *src, INT src_len, LPCWSTR text, INT str_len, LPBYTE dst, INT dst_len, UINT uCodePage)
static INT	Imm32CompAttrAnsiToWide (const BYTE *src, INT src_len, LPCSTR text, INT str_len, LPBYTE dst, INT dst_len, UINT uCodePage)
static INT	Imm32CompClauseAnsiToWide (const DWORD *source, INT slen, LPCSTR text, LPDWORD target, INT tlen, UINT uCodePage)
static INT	Imm32CompClauseWideToAnsi (const DWORD *source, INT slen, LPCWSTR text, LPDWORD target, INT tlen, UINT uCodePage)
static LONG	Imm32GetCompStrA (HIMC hIMC, const COMPOSITIONSTRING *pCS, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen, BOOL bAnsiClient, UINT uCodePage)
static LONG	Imm32GetCompStrW (HIMC hIMC, const COMPOSITIONSTRING *pCS, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen, BOOL bAnsiClient, UINT uCodePage)
static BOOL	ImmSetCompositionStringAW (_In_ HIMC hIMC, _In_ DWORD dwIndex, _Inout_updates_bytes_opt_(dwCompLen) LPVOID pComp, _In_ DWORD dwCompLen, _Inout_updates_bytes_opt_(dwReadLen) LPVOID pRead, _In_ DWORD dwReadLen, _In_ BOOL bAnsiAPI)
LONG WINAPI	ImmGetCompositionStringA (_In_ HIMC hIMC, _In_ DWORD dwIndex, _Out_writes_bytes_opt_(dwBufLen) LPVOID lpBuf, _In_ DWORD dwBufLen)
LONG WINAPI	ImmGetCompositionStringW (_In_ HIMC hIMC, _In_ DWORD dwIndex, _Out_writes_bytes_opt_(dwBufLen) LPVOID lpBuf, _In_ DWORD dwBufLen)
BOOL WINAPI	ImmSetCompositionStringA (_In_ HIMC hIMC, _In_ DWORD dwIndex, _Inout_updates_bytes_opt_(dwCompLen) LPVOID lpComp, _In_ DWORD dwCompLen, _Inout_updates_bytes_opt_(dwReadLen) LPVOID lpRead, _In_ DWORD dwReadLen)
BOOL WINAPI	ImmSetCompositionStringW (_In_ HIMC hIMC, _In_ DWORD dwIndex, _Inout_updates_bytes_opt_(dwCompLen) LPVOID lpComp, _In_ DWORD dwCompLen, _Inout_updates_bytes_opt_(dwReadLen) LPVOID lpRead, _In_ DWORD dwReadLen)

Macro Definition Documentation

CS_Attr

#define CS_Attr	(		pCS,
			Name
	)		((const BYTE *)CS_StrA(pCS, Name))

Definition at line 196 of file compstr.c.

CS_Clause

#define CS_Clause	(		pCS,
			Name
	)		((const DWORD *)CS_StrA(pCS, Name))

Definition at line 197 of file compstr.c.

CS_DoAttr

#define CS_DoAttr   CS_DoStrA

Definition at line 214 of file compstr.c.

CS_DoClause

#define CS_DoClause   CS_DoStrA

Definition at line 215 of file compstr.c.

CS_DoStr

#define CS_DoStr	(		pCS,
			Name,
			AorW
	)

Value:

    do { \
    if (dwBufLen == 0) { \
        dwBufLen = CS_Size##AorW((pCS), Name); \
    } else { \
        if (dwBufLen > CS_Size##AorW((pCS), Name)) \
            dwBufLen = CS_Size##AorW((pCS), Name); \
        RtlCopyMemory(lpBuf, CS_Str##AorW((pCS), Name), dwBufLen); \
    } \
} while (0)

Definition at line 202 of file compstr.c.

CS_DoStrA

#define CS_DoStrA	(		pCS,
			Name
	)		CS_DoStr(pCS, Name, A)

Definition at line 212 of file compstr.c.

CS_DoStrW

#define CS_DoStrW	(		pCS,
			Name
	)		CS_DoStr(pCS, Name, W)

Definition at line 213 of file compstr.c.

CS_Size

#define CS_Size	(		pCS,
			Name
	)		((pCS)->dw##Name##Len)

Definition at line 198 of file compstr.c.

CS_SizeA

#define CS_SizeA	(		pCS,
			Name
	)		(CS_Size(pCS, Name) * sizeof(CHAR))

Definition at line 199 of file compstr.c.

CS_SizeW

#define CS_SizeW	(		pCS,
			Name
	)		(CS_Size(pCS, Name) * sizeof(WCHAR))

Definition at line 200 of file compstr.c.

CS_StrA

#define CS_StrA	(		pCS,
			Name
	)		((LPCSTR)(pCS) + (pCS)->dw##Name##Offset)

Definition at line 194 of file compstr.c.

CS_StrW

#define CS_StrW	(		pCS,
			Name
	)		((LPCWSTR)CS_StrA(pCS, Name))

Definition at line 195 of file compstr.c.

Function Documentation

Imm32CompAttrAnsiToWide()

static INT Imm32CompAttrAnsiToWide ( const BYTE *  src, INT  src_len, LPCSTR  text, INT  str_len, LPBYTE  dst, INT  dst_len, UINT  uCodePage  )

static

Definition at line 98 of file compstr.c.

{
    INT rc;
    INT i, j = 0;
 
    if (!src_len)
        return 0;
 
    str_len /= sizeof(CHAR);
    rc = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, text, str_len, NULL, 0);
 
    if (dst_len)
    {
        if (dst_len > rc)
            dst_len = rc;
 
        for (i = 0; i < str_len; ++i)
        {
            if (IsDBCSLeadByteEx(uCodePage, text[i]) && text[i + 1])
                continue;
 
            dst[j++] = src[i];
 
            if (dst_len <= j)
                break;
        }
 
        rc = j;
    }
 
    return rc * sizeof(BYTE);
}

Referenced by Imm32GetCompStrW(), and ImmSetCompositionStringAW().

Imm32CompAttrWideToAnsi()

static INT Imm32CompAttrWideToAnsi ( const BYTE *  src, INT  src_len, LPCWSTR  text, INT  str_len, LPBYTE  dst, INT  dst_len, UINT  uCodePage  )

static

Definition at line 62 of file compstr.c.

{
    INT rc;
    INT i, j = 0, k = 0, len;
 
    if (!src_len)
        return 0;
 
    str_len /= sizeof(WCHAR);
    rc = WideCharToMultiByte(uCodePage, 0, text, str_len, NULL, 0, NULL, NULL);
 
    if (dst_len)
    {
        if (dst_len > rc)
            dst_len = rc;
 
        for (i = 0; i < str_len; ++i, ++k)
        {
            len = WideCharToMultiByte(uCodePage, 0, &text[i], 1, NULL, 0, NULL, NULL);
            for (; len > 0; --len)
            {
                dst[j++] = src[k];
 
                if (dst_len <= j)
                    goto end;
            }
        }
end:
        rc = j;
    }
 
    return rc * sizeof(BYTE);
}

Referenced by Imm32GetCompStrA(), and ImmSetCompositionStringAW().

Imm32CompClauseAnsiToWide()

static INT Imm32CompClauseAnsiToWide ( const DWORD *  source, INT  slen, LPCSTR  text, LPDWORD  target, INT  tlen, UINT  uCodePage  )

static

Definition at line 133 of file compstr.c.

{
    INT rc, i;
 
    if (!slen)
        return 0;
 
    if (tlen)
    {
        if (tlen > slen)
            tlen = slen;
 
        tlen /= sizeof(DWORD);
 
        for (i = 0; i < tlen; ++i)
        {
            target[i] = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, text, source[i], NULL, 0);
        }
 
        rc = sizeof(DWORD) * i;
    }
    else
    {
        rc = slen;
    }
 
    return rc;
}

Referenced by Imm32GetCompStrW(), and ImmSetCompositionStringAW().

Imm32CompClauseWideToAnsi()

static INT Imm32CompClauseWideToAnsi ( const DWORD *  source, INT  slen, LPCWSTR  text, LPDWORD  target, INT  tlen, UINT  uCodePage  )

static

Definition at line 164 of file compstr.c.

{
    INT rc, i;
 
    if (!slen)
        return 0;
 
    if (tlen)
    {
        if (tlen > slen)
            tlen = slen;
 
        tlen /= sizeof(DWORD);
 
        for (i = 0; i < tlen; ++i)
        {
            target[i] = WideCharToMultiByte(uCodePage, 0, text, source[i], NULL, 0, NULL, NULL);
        }
 
        rc = sizeof(DWORD) * i;
    }
    else
    {
        rc = slen;
    }
 
    return rc;
}

Referenced by Imm32GetCompStrA(), and ImmSetCompositionStringAW().

Imm32CompStrAnsiToWide()

static LONG Imm32CompStrAnsiToWide ( LPCSTR  psz, DWORD  cb, LPWSTR  lpBuf, DWORD  dwBufLen, UINT  uCodePage  )

inlinestatic

Definition at line 42 of file compstr.c.

{
    DWORD ret = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, psz, cb / sizeof(CHAR),
                                    lpBuf, dwBufLen / sizeof(WCHAR));
    if (lpBuf && (ret + 1) * sizeof(WCHAR) <= dwBufLen)
        lpBuf[ret] = UNICODE_NULL;
    return ret * sizeof(WCHAR);
}

Referenced by Imm32GetCompStrW(), and ImmSetCompositionStringAW().

Imm32CompStrWideToAnsi()

static LONG Imm32CompStrWideToAnsi ( LPCWSTR  psz, DWORD  cb, LPSTR  lpBuf, DWORD  dwBufLen, UINT  uCodePage  )

inlinestatic

Definition at line 52 of file compstr.c.

{
    DWORD ret = WideCharToMultiByte(uCodePage, 0, psz, cb / sizeof(WCHAR),
                                    lpBuf, dwBufLen / sizeof(CHAR), NULL, NULL);
    if (lpBuf && (ret + 1) * sizeof(CHAR) <= dwBufLen)
        lpBuf[ret] = ANSI_NULL;
    return ret * sizeof(CHAR);
}

Referenced by Imm32GetCompStrA(), and ImmSetCompositionStringAW().

Imm32GetCompStrA()

static LONG Imm32GetCompStrA ( HIMC  hIMC, const COMPOSITIONSTRING *  pCS, DWORD  dwIndex, LPVOID  lpBuf, DWORD  dwBufLen, BOOL  bAnsiClient, UINT  uCodePage  )

static

Definition at line 218 of file compstr.c.

{
    if (bAnsiClient)
    {
        switch (dwIndex)
        {
            case GCS_COMPREADSTR:
                CS_DoStrA(pCS, CompReadStr);
                break;
 
            case GCS_COMPREADATTR:
                CS_DoAttr(pCS, CompReadAttr);
                break;
 
            case GCS_COMPREADCLAUSE:
                CS_DoClause(pCS, CompReadClause);
                break;
 
            case GCS_COMPSTR:
                CS_DoStrA(pCS, CompStr);
                break;
 
            case GCS_COMPATTR:
                CS_DoAttr(pCS, CompAttr);
                break;
 
            case GCS_COMPCLAUSE:
                CS_DoClause(pCS, CompClause);
                break;
 
            case GCS_CURSORPOS:
                dwBufLen = pCS->dwCursorPos;
                break;
 
            case GCS_DELTASTART:
                dwBufLen = pCS->dwDeltaStart;
                break;
 
            case GCS_RESULTREADSTR:
                CS_DoStrA(pCS, ResultReadStr);
                break;
 
            case GCS_RESULTREADCLAUSE:
                CS_DoClause(pCS, ResultReadClause);
                break;
 
            case GCS_RESULTSTR:
                CS_DoStrA(pCS, ResultStr);
                break;
 
            case GCS_RESULTCLAUSE:
                CS_DoClause(pCS, ResultClause);
                break;
 
            default:
                FIXME("0x%X\n", dwIndex);
                return IMM_ERROR_GENERAL;
        }
    }
    else /* !bAnsiClient */
    {
        switch (dwIndex)
        {
            case GCS_COMPREADSTR:
                dwBufLen = Imm32CompStrWideToAnsi(CS_StrW(pCS, CompReadStr),
                                                  CS_SizeW(pCS, CompReadStr),
                                                  lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_COMPREADATTR:
                dwBufLen = Imm32CompAttrWideToAnsi(CS_Attr(pCS, CompReadAttr),
                                                   CS_Size(pCS, CompReadAttr),
                                                   CS_StrW(pCS, CompReadStr),
                                                   CS_SizeW(pCS, CompReadStr),
                                                   lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_COMPREADCLAUSE:
                dwBufLen = Imm32CompClauseWideToAnsi(CS_Clause(pCS, CompReadClause),
                                                     CS_Size(pCS, CompReadClause),
                                                     CS_StrW(pCS, CompReadStr),
                                                     lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_COMPSTR:
                dwBufLen = Imm32CompStrWideToAnsi(CS_StrW(pCS, CompStr),
                                                  CS_SizeW(pCS, CompStr),
                                                  lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_COMPATTR:
                dwBufLen = Imm32CompAttrWideToAnsi(CS_Attr(pCS, CompAttr),
                                                   CS_Size(pCS, CompAttr),
                                                   CS_StrW(pCS, CompStr),
                                                   CS_SizeW(pCS, CompStr),
                                                   lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_COMPCLAUSE:
                dwBufLen = Imm32CompClauseWideToAnsi(CS_Clause(pCS, CompClause),
                                                     CS_Size(pCS, CompClause),
                                                     CS_StrW(pCS, CompStr),
                                                     lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_CURSORPOS:
                dwBufLen = IchAnsiFromWide(pCS->dwCursorPos, CS_StrW(pCS, CompStr), uCodePage);
                break;
 
            case GCS_DELTASTART:
                dwBufLen = IchAnsiFromWide(pCS->dwDeltaStart, CS_StrW(pCS, CompStr), uCodePage);
                break;
 
            case GCS_RESULTREADSTR:
                dwBufLen = Imm32CompStrWideToAnsi(CS_StrW(pCS, ResultReadStr),
                                                  CS_SizeW(pCS, ResultReadStr),
                                                  lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_RESULTREADCLAUSE:
                dwBufLen = Imm32CompClauseWideToAnsi(CS_Clause(pCS, ResultReadClause),
                                                     CS_Size(pCS, ResultReadClause),
                                                     CS_StrW(pCS, ResultReadStr),
                                                     lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_RESULTSTR:
                dwBufLen = Imm32CompStrWideToAnsi(CS_StrW(pCS, ResultStr),
                                                  CS_SizeW(pCS, ResultStr),
                                                  lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_RESULTCLAUSE:
                dwBufLen = Imm32CompClauseWideToAnsi(CS_Clause(pCS, ResultClause),
                                                     CS_Size(pCS, ResultClause),
                                                     CS_StrW(pCS, ResultStr),
                                                     lpBuf, dwBufLen, uCodePage);
                break;
 
            default:
                FIXME("0x%X\n", dwIndex);
                return IMM_ERROR_GENERAL;
        }
    }
 
    return dwBufLen;
}

Referenced by ImmGetCompositionStringA().

Imm32GetCompStrW()

static LONG Imm32GetCompStrW ( HIMC  hIMC, const COMPOSITIONSTRING *  pCS, DWORD  dwIndex, LPVOID  lpBuf, DWORD  dwBufLen, BOOL  bAnsiClient, UINT  uCodePage  )

static

Definition at line 368 of file compstr.c.

{
    if (bAnsiClient)
    {
        switch (dwIndex)
        {
            case GCS_COMPREADSTR:
                dwBufLen = Imm32CompStrAnsiToWide(CS_StrA(pCS, CompReadStr),
                                                  CS_SizeA(pCS, CompReadStr),
                                                  lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_COMPREADATTR:
                dwBufLen = Imm32CompAttrAnsiToWide(CS_Attr(pCS, CompReadAttr),
                                                   CS_Size(pCS, CompReadAttr),
                                                   CS_StrA(pCS, CompReadStr),
                                                   CS_SizeA(pCS, CompReadStr),
                                                   lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_COMPREADCLAUSE:
                dwBufLen = Imm32CompClauseAnsiToWide(CS_Clause(pCS, CompReadClause),
                                                     CS_Size(pCS, CompReadClause),
                                                     CS_StrA(pCS, CompReadStr),
                                                     lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_COMPSTR:
                dwBufLen = Imm32CompStrAnsiToWide(CS_StrA(pCS, CompStr),
                                                  CS_SizeA(pCS, CompStr),
                                                  lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_COMPATTR:
                dwBufLen = Imm32CompAttrAnsiToWide(CS_Attr(pCS, CompAttr),
                                                   CS_Size(pCS, CompAttr),
                                                   CS_StrA(pCS, CompStr), CS_SizeA(pCS, CompStr),
                                                   lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_COMPCLAUSE:
                dwBufLen = Imm32CompClauseAnsiToWide(CS_Clause(pCS, CompClause),
                                                     CS_Size(pCS, CompClause),
                                                     CS_StrA(pCS, CompStr),
                                                     lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_CURSORPOS:
                dwBufLen = IchWideFromAnsi(pCS->dwCursorPos, CS_StrA(pCS, CompStr), uCodePage);
                break;
 
            case GCS_DELTASTART:
                dwBufLen = IchWideFromAnsi(pCS->dwDeltaStart, CS_StrA(pCS, CompStr), uCodePage);
                break;
 
            case GCS_RESULTREADSTR:
                dwBufLen = Imm32CompStrAnsiToWide(CS_StrA(pCS, ResultReadStr),
                                                  CS_SizeA(pCS, ResultReadStr),
                                                  lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_RESULTREADCLAUSE:
                dwBufLen = Imm32CompClauseAnsiToWide(CS_Clause(pCS, ResultReadClause),
                                                     CS_Size(pCS, ResultReadClause),
                                                     CS_StrA(pCS, ResultReadStr),
                                                     lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_RESULTSTR:
                dwBufLen = Imm32CompStrAnsiToWide(CS_StrA(pCS, ResultStr),
                                                  CS_SizeA(pCS, ResultStr),
                                                  lpBuf, dwBufLen, uCodePage);
                break;
 
            case GCS_RESULTCLAUSE:
                dwBufLen = Imm32CompClauseAnsiToWide(CS_Clause(pCS, ResultClause),
                                                     CS_Size(pCS, ResultClause),
                                                     CS_StrA(pCS, ResultStr),
                                                     lpBuf, dwBufLen, uCodePage);
                break;
 
            default:
                FIXME("0x%X\n", dwIndex);
                return IMM_ERROR_GENERAL;
        }
    }
    else /* !bAnsiClient */
    {
        switch (dwIndex)
        {
            case GCS_COMPREADSTR:
                CS_DoStrW(pCS, CompReadStr);
                break;
 
            case GCS_COMPREADATTR:
                CS_DoAttr(pCS, CompReadAttr);
                break;
 
            case GCS_COMPREADCLAUSE:
                CS_DoClause(pCS, CompReadClause);
                break;
 
            case GCS_COMPSTR:
                CS_DoStrW(pCS, CompStr);
                break;
 
            case GCS_COMPATTR:
                CS_DoAttr(pCS, CompAttr);
                break;
 
            case GCS_COMPCLAUSE:
                CS_DoClause(pCS, CompClause);
                break;
 
            case GCS_CURSORPOS:
                dwBufLen = pCS->dwCursorPos;
                break;
 
            case GCS_DELTASTART:
                dwBufLen = pCS->dwDeltaStart;
                break;
 
            case GCS_RESULTREADSTR:
                CS_DoStrW(pCS, ResultReadStr);
                break;
 
            case GCS_RESULTREADCLAUSE:
                CS_DoClause(pCS, ResultReadClause);
                break;
 
            case GCS_RESULTSTR:
                CS_DoStrW(pCS, ResultStr);
                break;
 
            case GCS_RESULTCLAUSE:
                CS_DoClause(pCS, ResultClause);
                break;
 
            default:
                FIXME("0x%X\n", dwIndex);
                return IMM_ERROR_GENERAL;
        }
    }
 
    return dwBufLen;
}

Referenced by ImmGetCompositionStringW().

Imm32OpenICAndCS()

BOOL Imm32OpenICAndCS	(	HIMC	hIMC,
		LPINPUTCONTEXT *	ppIC,
		LPCOMPOSITIONSTRING *	ppCS
	)

Definition at line 17 of file compstr.c.

{
    LPINPUTCONTEXT pIC;
    LPCOMPOSITIONSTRING pCS;
 
    *ppIC = NULL;
    *ppCS = NULL;
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return FALSE;
 
    pCS = ImmLockIMCC(pIC->hCompStr);
    if (IS_NULL_UNEXPECTEDLY(pCS))
    {
        ImmUnlockIMC(hIMC);
        return FALSE;
    }
 
    *ppIC = pIC;
    *ppCS = pCS;
    return TRUE;
}

Referenced by ImmSetCompositionStringAW().

ImmGetCompositionStringA()

LONG WINAPI ImmGetCompositionStringA	(	_In_ HIMC	hIMC,
		_In_ DWORD	dwIndex,
		_Out_writes_bytes_opt_(dwBufLen) LPVOID	lpBuf,
		_In_ DWORD	dwBufLen
	)

Definition at line 860 of file compstr.c.

{
    LONG ret = 0;
    LPINPUTCONTEXT pIC;
    PCLIENTIMC pClientImc;
    LPCOMPOSITIONSTRING pCS;
    BOOL bAnsiClient;
    UINT uCodePage;
 
    TRACE("(%p, %lu, %p, %lu)\n", hIMC, dwIndex, lpBuf, dwBufLen);
 
    if (dwBufLen && IS_NULL_UNEXPECTEDLY(lpBuf))
        return 0;
 
    pClientImc = ImmLockClientImc(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pClientImc))
        return 0;
 
    bAnsiClient = !(pClientImc->dwFlags & CLIENTIMC_WIDE);
    uCodePage = pClientImc->uCodePage;
    ImmUnlockClientImc(pClientImc);
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return 0;
 
    pCS = ImmLockIMCC(pIC->hCompStr);
    if (IS_NULL_UNEXPECTEDLY(pCS))
    {
        ImmUnlockIMC(hIMC);
        return 0;
    }
 
    ret = Imm32GetCompStrA(hIMC, pCS, dwIndex, lpBuf, dwBufLen, bAnsiClient, uCodePage);
    ImmUnlockIMCC(pIC->hCompStr);
    ImmUnlockIMC(hIMC);
    TRACE("ret: %ld\n", ret);
    return ret;
}

Referenced by ActiveIMMApp_GetCompositionStringA(), Imm32ProcessRequest(), RealDefWindowProcA(), test_ImmGetCompositionString(), test_ImmNotifyIME(), and test_InvalidIMC().

ImmGetCompositionStringW()

LONG WINAPI ImmGetCompositionStringW	(	_In_ HIMC	hIMC,
		_In_ DWORD	dwIndex,
		_Out_writes_bytes_opt_(dwBufLen) LPVOID	lpBuf,
		_In_ DWORD	dwBufLen
	)

Definition at line 908 of file compstr.c.

{
    LONG ret = 0;
    LPINPUTCONTEXT pIC;
    PCLIENTIMC pClientImc;
    LPCOMPOSITIONSTRING pCS;
    BOOL bAnsiClient;
    UINT uCodePage;
 
    TRACE("(%p, %lu, %p, %lu)\n", hIMC, dwIndex, lpBuf, dwBufLen);
 
    if (dwBufLen && IS_NULL_UNEXPECTEDLY(lpBuf))
        return 0;
 
    pClientImc = ImmLockClientImc(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pClientImc))
        return 0;
 
    bAnsiClient = !(pClientImc->dwFlags & CLIENTIMC_WIDE);
    uCodePage = pClientImc->uCodePage;
    ImmUnlockClientImc(pClientImc);
 
    pIC = ImmLockIMC(hIMC);
    if (IS_NULL_UNEXPECTEDLY(pIC))
        return 0;
 
    pCS = ImmLockIMCC(pIC->hCompStr);
    if (IS_NULL_UNEXPECTEDLY(pCS))
    {
        ImmUnlockIMC(hIMC);
        return 0;
    }
 
    ret = Imm32GetCompStrW(hIMC, pCS, dwIndex, lpBuf, dwBufLen, bAnsiClient, uCodePage);
    ImmUnlockIMCC(pIC->hCompStr);
    ImmUnlockIMC(hIMC);
    TRACE("ret: %ld\n", ret);
    return ret;
}

Referenced by ActiveIMMApp_GetCompositionStringW(), EDIT_GetCompositionStr(), EDIT_GetResultStr(), EDIT_ImeComposition(), editor_handle_message(), Imm32ProcessRequest(), RealDefWindowProcW(), test_ime_wnd_proc(), and test_ImmGetCompositionString().

ImmSetCompositionStringA()

BOOL WINAPI ImmSetCompositionStringA	(	_In_ HIMC	hIMC,
		_In_ DWORD	dwIndex,
		_Inout_updates_bytes_opt_(dwCompLen) LPVOID	lpComp,
		_In_ DWORD	dwCompLen,
		_Inout_updates_bytes_opt_(dwReadLen) LPVOID	lpRead,
		_In_ DWORD	dwReadLen
	)

Definition at line 956 of file compstr.c.

{
    TRACE("(%p, %lu, %p, %lu, %p, %lu)\n",
          hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
    return ImmSetCompositionStringAW(hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen, TRUE);
}

Referenced by ActiveIMMApp_SetCompositionStringA(), and test_ImmNotifyIME().

ImmSetCompositionStringAW()

static BOOL ImmSetCompositionStringAW ( _In_ HIMC  hIMC, _In_ DWORD  dwIndex, _Inout_updates_bytes_opt_(dwCompLen) LPVOID  pComp, _In_ DWORD  dwCompLen, _Inout_updates_bytes_opt_(dwReadLen) LPVOID  pRead, _In_ DWORD  dwReadLen, _In_ BOOL  bAnsiAPI  )

static

Definition at line 517 of file compstr.c.

{
    BOOL ret = FALSE, bAnsiClient;
    LPVOID pCompNew = NULL, pReadNew = NULL;
    DWORD dwThreadId, cbCompNew = 0, cbReadNew = 0;
    LPINPUTCONTEXT pIC;
    LPCOMPOSITIONSTRING pCS;
    HKL hKL;
    PIMEDPI pImeDpi;
    UINT uCodePage;
    LPRECONVERTSTRING pRS;
 
    dwThreadId = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
    if (dwThreadId != GetCurrentThreadId())
    {
        ERR("Thread mismatch\n");
        return FALSE;
    }
 
    hKL = GetKeyboardLayout(dwThreadId);
    pImeDpi = ImmLockImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return FALSE;
 
    uCodePage = pImeDpi->uCodePage;
    bAnsiClient = !ImeDpi_IsUnicode(pImeDpi);
 
    switch (dwIndex)
    {
        case SCS_SETSTR: case SCS_CHANGEATTR: case SCS_CHANGECLAUSE:
            break;
 
        case SCS_SETRECONVERTSTRING: case SCS_QUERYRECONVERTSTRING:
            if (pImeDpi->ImeInfo.fdwSCSCaps & SCS_CAP_SETRECONVERTSTRING)
                break;
            /* FALL THROUGH */
        default:
            ERR("0x%X\n", dwIndex);
            ImmUnlockImeDpi(pImeDpi);
            return FALSE;
    }
 
    if (bAnsiAPI == bAnsiClient || (!pComp && !pRead)) /* No conversion needed */
    {
        ret = pImeDpi->ImeSetCompositionString(hIMC, dwIndex, pComp, dwCompLen,
                                               pRead, dwReadLen);
        ImmUnlockImeDpi(pImeDpi);
        return ret;
    }
 
    if (!Imm32OpenICAndCS(hIMC, &pIC, &pCS))
    {
        ImmUnlockImeDpi(pImeDpi);
        return FALSE;
    }
 
    /*
     * This code is really too complicated. But I cannot simplify.
     * It converts like (pComp, dwCompLen) --> (pCompNew, cbCompNew) and
     * (pRead, dwReadLen) --> (pReadNew, cbReadNew).
     * (1) Check bAnsiClient, (2) Get the size, (3) Allocate a buffer for conversion,
     * (4) Store converted data into the buffer.
     */
    switch (dwIndex)
    {
        case SCS_SETSTR:
            if (pComp)
            {
                if (bAnsiClient)
                {
                    cbCompNew = Imm32CompStrWideToAnsi(pComp, dwCompLen, NULL, 0, uCodePage);
                    pCompNew = ImmLocalAlloc(0, cbCompNew);
                    if (IS_NULL_UNEXPECTEDLY(pCompNew))
                        goto Quit;
 
                    Imm32CompStrWideToAnsi(pComp, dwCompLen, pCompNew, cbCompNew, uCodePage);
                }
                else
                {
                    cbCompNew = Imm32CompStrAnsiToWide(pComp, dwCompLen, NULL, 0, uCodePage);
                    pCompNew = ImmLocalAlloc(0, cbCompNew);
                    if (IS_NULL_UNEXPECTEDLY(pCompNew))
                        goto Quit;
 
                    Imm32CompStrAnsiToWide(pComp, dwCompLen, pCompNew, cbCompNew, uCodePage);
                }
            }
 
            if (pRead)
            {
                if (bAnsiClient)
                {
                    cbReadNew = Imm32CompStrWideToAnsi(pRead, dwReadLen, NULL, 0, uCodePage);
                    pReadNew = ImmLocalAlloc(0, cbReadNew);
                    if (IS_NULL_UNEXPECTEDLY(pReadNew))
                        goto Quit;
 
                    Imm32CompStrWideToAnsi(pRead, dwReadLen, pReadNew, cbReadNew, uCodePage);
                }
                else
                {
                    cbReadNew = Imm32CompStrAnsiToWide(pRead, dwReadLen, NULL, 0, uCodePage);
                    pReadNew = ImmLocalAlloc(0, cbReadNew);
                    if (IS_NULL_UNEXPECTEDLY(pReadNew))
                        goto Quit;
 
                    Imm32CompStrAnsiToWide(pRead, dwReadLen, pReadNew, cbReadNew, uCodePage);
                }
            }
            break;
 
        case SCS_CHANGEATTR:
            if (pComp)
            {
                if (bAnsiClient)
                {
                    cbCompNew = Imm32CompAttrWideToAnsi(pComp, dwCompLen,
                                                        CS_StrW(pCS, CompStr),
                                                        CS_SizeW(pCS, CompStr),
                                                        NULL, 0, uCodePage);
                    pCompNew = ImmLocalAlloc(0, cbCompNew);
                    if (IS_NULL_UNEXPECTEDLY(pCompNew))
                        goto Quit;
 
                    Imm32CompAttrWideToAnsi(pComp, dwCompLen,
                                            CS_StrW(pCS, CompStr), CS_SizeW(pCS, CompStr),
                                            pCompNew, cbCompNew, uCodePage);
                }
                else
                {
                    cbCompNew = Imm32CompAttrAnsiToWide(pComp, dwCompLen,
                                                        CS_StrA(pCS, CompStr),
                                                        CS_SizeA(pCS, CompStr),
                                                        NULL, 0, uCodePage);
                    pCompNew = ImmLocalAlloc(0, cbCompNew);
                    if (IS_NULL_UNEXPECTEDLY(pCompNew))
                        goto Quit;
 
                    Imm32CompAttrAnsiToWide(pComp, dwCompLen,
                                            CS_StrA(pCS, CompStr), CS_SizeA(pCS, CompStr),
                                            pCompNew, cbCompNew, uCodePage);
                }
            }
 
            if (pRead)
            {
                if (bAnsiClient)
                {
                    cbReadNew = Imm32CompAttrWideToAnsi(pRead, dwReadLen,
                                                        CS_StrW(pCS, CompReadStr),
                                                        CS_SizeW(pCS, CompReadStr),
                                                        NULL, 0, uCodePage);
                    pReadNew = ImmLocalAlloc(0, cbReadNew);
                    if (IS_NULL_UNEXPECTEDLY(pReadNew))
                        goto Quit;
 
                    Imm32CompAttrWideToAnsi(pRead, dwReadLen,
                                            CS_StrW(pCS, CompReadStr), CS_SizeW(pCS, CompReadStr),
                                            pReadNew, cbReadNew, uCodePage);
                }
                else
                {
                    cbReadNew = Imm32CompAttrAnsiToWide(pRead, dwReadLen,
                                                        CS_StrA(pCS, CompReadStr),
                                                        CS_SizeA(pCS, CompReadStr),
                                                        NULL, 0, uCodePage);
                    pReadNew = ImmLocalAlloc(0, cbReadNew);
                    if (IS_NULL_UNEXPECTEDLY(pReadNew))
                        goto Quit;
 
                    Imm32CompAttrAnsiToWide(pRead, dwReadLen,
                                            CS_StrA(pCS, CompReadStr), CS_SizeA(pCS, CompReadStr),
                                            pReadNew, cbReadNew, uCodePage);
                }
            }
            break;
 
        case SCS_CHANGECLAUSE:
            if (pComp)
            {
                if (bAnsiClient)
                {
                    cbCompNew = Imm32CompClauseWideToAnsi(pComp, dwCompLen, CS_StrW(pCS, CompStr),
                                                          NULL, 0, uCodePage);
                    pCompNew = ImmLocalAlloc(0, cbCompNew);
                    if (IS_NULL_UNEXPECTEDLY(pCompNew))
                        goto Quit;
 
                    Imm32CompClauseWideToAnsi(pComp, dwCompLen, CS_StrW(pCS, CompStr),
                                              pCompNew, cbCompNew, uCodePage);
                }
                else
                {
                    cbCompNew = Imm32CompClauseAnsiToWide(pComp, dwCompLen, CS_StrA(pCS, CompStr),
                                                          NULL, 0, uCodePage);
                    pCompNew = ImmLocalAlloc(0, cbCompNew);
                    if (IS_NULL_UNEXPECTEDLY(pCompNew))
                        goto Quit;
 
                    Imm32CompClauseAnsiToWide(pComp, dwCompLen, CS_StrA(pCS, CompStr),
                                              pCompNew, cbCompNew, uCodePage);
                }
            }
 
            if (pRead)
            {
                if (bAnsiClient)
                {
                    cbReadNew = Imm32CompClauseWideToAnsi(pRead, dwReadLen, CS_StrW(pCS, CompReadStr),
                                                          NULL, 0, uCodePage);
                    pReadNew = ImmLocalAlloc(0, cbReadNew);
                    if (IS_NULL_UNEXPECTEDLY(pReadNew))
                        goto Quit;
 
                    Imm32CompClauseWideToAnsi(pRead, dwReadLen,
                                              CS_StrW(pCS, CompReadStr),
                                              pReadNew, cbReadNew, uCodePage);
                }
                else
                {
                    cbReadNew = Imm32CompClauseAnsiToWide(pRead, dwReadLen, CS_StrA(pCS, CompReadStr),
                                                          NULL, 0, uCodePage);
                    pReadNew = ImmLocalAlloc(0, cbReadNew);
                    if (IS_NULL_UNEXPECTEDLY(pReadNew))
                        goto Quit;
 
                    Imm32CompClauseAnsiToWide(pRead, dwReadLen, CS_StrA(pCS, CompReadStr),
                                              pReadNew, cbReadNew, uCodePage);
                }
            }
            break;
 
        case SCS_SETRECONVERTSTRING: case SCS_QUERYRECONVERTSTRING:
        {
            if (pComp)
            {
                if (bAnsiClient)
                {
                    cbCompNew = Imm32ReconvertAnsiFromWide(NULL, pComp, uCodePage);
                    pCompNew = ImmLocalAlloc(0, cbCompNew);
                    if (IS_NULL_UNEXPECTEDLY(pCompNew))
                        goto Quit;
 
                    pRS = pCompNew;
                    pRS->dwSize = cbCompNew;
                    pRS->dwVersion = 0;
                    Imm32ReconvertAnsiFromWide(pRS, pComp, uCodePage);
                }
                else
                {
                    cbCompNew = Imm32ReconvertWideFromAnsi(NULL, pComp, uCodePage);
                    pCompNew = ImmLocalAlloc(0, cbCompNew);
                    if (IS_NULL_UNEXPECTEDLY(pCompNew))
                        goto Quit;
 
                    pRS = pCompNew;
                    pRS->dwSize = cbCompNew;
                    pRS->dwVersion = 0;
                    Imm32ReconvertWideFromAnsi(pRS, pComp, uCodePage);
                }
            }
 
            if (pRead)
            {
                if (bAnsiClient)
                {
                    cbReadNew = Imm32ReconvertAnsiFromWide(NULL, pRead, uCodePage);
                    pReadNew = ImmLocalAlloc(0, cbReadNew);
                    if (IS_NULL_UNEXPECTEDLY(pReadNew))
                        goto Quit;
 
                    pRS = pReadNew;
                    pRS->dwSize = cbReadNew;
                    pRS->dwVersion = 0;
                    Imm32ReconvertAnsiFromWide(pRS, pRead, uCodePage);
                }
                else
                {
                    cbReadNew = Imm32ReconvertWideFromAnsi(NULL, pRead, uCodePage);
                    pReadNew = ImmLocalAlloc(0, cbReadNew);
                    if (IS_NULL_UNEXPECTEDLY(pReadNew))
                        goto Quit;
 
                    pRS = pReadNew;
                    pRS->dwSize = cbReadNew;
                    pRS->dwVersion = 0;
                    Imm32ReconvertWideFromAnsi(pRS, pRead, uCodePage);
                }
            }
            break;
        }
    }
 
    ImmUnlockIMCC(pIC->hCompStr);
    pCS = NULL;
    ImmUnlockIMC(hIMC);
    pIC = NULL;
 
    ret = pImeDpi->ImeSetCompositionString(hIMC, dwIndex, pCompNew, cbCompNew,
                                           pReadNew, cbReadNew);
 
    if (dwIndex == SCS_QUERYRECONVERTSTRING)
    {
        if (pComp)
        {
            if (bAnsiClient)
                ret = Imm32ReconvertWideFromAnsi(pComp, pCompNew, uCodePage);
            else
                ret = Imm32ReconvertAnsiFromWide(pComp, pCompNew, uCodePage);
        }
 
        if (pRead)
        {
            if (bAnsiClient)
                ret = Imm32ReconvertWideFromAnsi(pRead, pReadNew, uCodePage);
            else
                ret = Imm32ReconvertAnsiFromWide(pRead, pReadNew, uCodePage);
        }
    }
 
Quit:
    if (pCS)
        ImmUnlockIMCC(pIC->hCompStr);
    if (pIC)
        ImmUnlockIMC(hIMC);
    ImmLocalFree(pCompNew);
    ImmLocalFree(pReadNew);
    ImmUnlockImeDpi(pImeDpi);
    TRACE("ret: %d\n", ret);
    return ret;
}

Referenced by ImmSetCompositionStringA(), and ImmSetCompositionStringW().

ImmSetCompositionStringW()

BOOL WINAPI ImmSetCompositionStringW	(	_In_ HIMC	hIMC,
		_In_ DWORD	dwIndex,
		_Inout_updates_bytes_opt_(dwCompLen) LPVOID	lpComp,
		_In_ DWORD	dwCompLen,
		_Inout_updates_bytes_opt_(dwReadLen) LPVOID	lpRead,
		_In_ DWORD	dwReadLen
	)

Definition at line 973 of file compstr.c.

{
    TRACE("(%p, %lu, %p, %lu, %p, %lu)\n",
          hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
    return ImmSetCompositionStringAW(hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen, FALSE);
}

Referenced by ActiveIMMApp_SetCompositionStringW(), test_ImmGetCompositionString(), and test_ImmSetCompositionString().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

imm

)