regword.c File Reference

#include "precomp.h"

Include dependency graph for regword.c:

Go to the source code of this file.

Classes
struct	ENUM_WORD_A2W
struct	ENUM_WORD_W2A

Typedefs
typedef struct ENUM_WORD_A2W	ENUM_WORD_A2W
typedef struct ENUM_WORD_A2W *	LPENUM_WORD_A2W
typedef struct ENUM_WORD_W2A	ENUM_WORD_W2A
typedef struct ENUM_WORD_W2A *	LPENUM_WORD_W2A

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (imm)
static INT CALLBACK	Imm32EnumWordProcA2W (LPCSTR pszReadingA, DWORD dwStyle, LPCSTR pszRegisterA, LPVOID lpData)
static INT CALLBACK	Imm32EnumWordProcW2A (LPCWSTR pszReadingW, DWORD dwStyle, LPCWSTR pszRegisterW, LPVOID lpData)
UINT WINAPI	ImmEnumRegisterWordA (HKL hKL, REGISTERWORDENUMPROCA lpfnEnumProc, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister, LPVOID lpData)
UINT WINAPI	ImmEnumRegisterWordW (HKL hKL, REGISTERWORDENUMPROCW lpfnEnumProc, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister, LPVOID lpData)
UINT WINAPI	ImmGetRegisterWordStyleA (HKL hKL, UINT nItem, LPSTYLEBUFA lpStyleBuf)
UINT WINAPI	ImmGetRegisterWordStyleW (HKL hKL, UINT nItem, LPSTYLEBUFW lpStyleBuf)
BOOL WINAPI	ImmRegisterWordA (HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister)
BOOL WINAPI	ImmRegisterWordW (HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister)
BOOL WINAPI	ImmUnregisterWordA (HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszUnregister)
BOOL WINAPI	ImmUnregisterWordW (HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszUnregister)

Typedef Documentation

ENUM_WORD_A2W

typedef struct ENUM_WORD_A2W ENUM_WORD_A2W

ENUM_WORD_W2A

typedef struct ENUM_WORD_W2A ENUM_WORD_W2A

LPENUM_WORD_A2W

typedef struct ENUM_WORD_A2W * LPENUM_WORD_A2W

LPENUM_WORD_W2A

typedef struct ENUM_WORD_W2A * LPENUM_WORD_W2A

Function Documentation

Imm32EnumWordProcA2W()

static INT CALLBACK Imm32EnumWordProcA2W ( LPCSTR  pszReadingA, DWORD  dwStyle, LPCSTR  pszRegisterA, LPVOID  lpData  )

static

Definition at line 32 of file regword.c.

{
    INT ret = 0;
    LPENUM_WORD_A2W lpEnumData = lpData;
    LPWSTR pszReadingW = NULL, pszRegisterW = NULL;

    if (pszReadingA)
    {
        pszReadingW = Imm32WideFromAnsi(lpEnumData->uCodePage, pszReadingA);
        if (IS_NULL_UNEXPECTEDLY(pszReadingW))
            goto Quit;
    }

    if (pszRegisterA)
    {
        pszRegisterW = Imm32WideFromAnsi(lpEnumData->uCodePage, pszRegisterA);
        if (IS_NULL_UNEXPECTEDLY(pszRegisterW))
            goto Quit;
    }

    ret = lpEnumData->lpfnEnumProc(pszReadingW, dwStyle, pszRegisterW, lpEnumData->lpData);
    lpEnumData->ret = ret;

Quit:
    ImmLocalFree(pszReadingW);
    ImmLocalFree(pszRegisterW);
    return ret;
}

Referenced by ImmEnumRegisterWordW().

Imm32EnumWordProcW2A()

static INT CALLBACK Imm32EnumWordProcW2A ( LPCWSTR  pszReadingW, DWORD  dwStyle, LPCWSTR  pszRegisterW, LPVOID  lpData  )

static

Definition at line 62 of file regword.c.

{
    INT ret = 0;
    LPENUM_WORD_W2A lpEnumData = lpData;
    LPSTR pszReadingA = NULL, pszRegisterA = NULL;

    if (pszReadingW)
    {
        pszReadingA = Imm32AnsiFromWide(lpEnumData->uCodePage, pszReadingW);
        if (IS_NULL_UNEXPECTEDLY(pszReadingW))
            goto Quit;
    }

    if (pszRegisterW)
    {
        pszRegisterA = Imm32AnsiFromWide(lpEnumData->uCodePage, pszRegisterW);
        if (IS_NULL_UNEXPECTEDLY(pszRegisterA))
            goto Quit;
    }

    ret = lpEnumData->lpfnEnumProc(pszReadingA, dwStyle, pszRegisterA, lpEnumData->lpData);
    lpEnumData->ret = ret;

Quit:
    ImmLocalFree(pszReadingA);
    ImmLocalFree(pszRegisterA);
    return ret;
}

Referenced by ImmEnumRegisterWordA().

ImmEnumRegisterWordA()

UINT WINAPI ImmEnumRegisterWordA	(	HKL	hKL,
		REGISTERWORDENUMPROCA	lpfnEnumProc,
		LPCSTR	lpszReading,
		DWORD	dwStyle,
		LPCSTR	lpszRegister,
		LPVOID	lpData
	)

Definition at line 95 of file regword.c.

{
    UINT ret = 0;
    LPWSTR pszReadingW = NULL, pszRegisterW = NULL;
    ENUM_WORD_W2A EnumDataW2A;
    PIMEDPI pImeDpi;

    TRACE("(%p, %p, %s, 0x%lX, %s, %p)\n", hKL, lpfnEnumProc, debugstr_a(lpszReading),
          dwStyle, debugstr_a(lpszRegister), lpData);

    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return 0;

    if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
    {
        ret = pImeDpi->ImeEnumRegisterWord(lpfnEnumProc, lpszReading, dwStyle,
                                           lpszRegister, lpData);
        ImmUnlockImeDpi(pImeDpi);
        return ret;
    }

    if (lpszReading)
    {
        pszReadingW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszReading);
        if (IS_NULL_UNEXPECTEDLY(pszReadingW))
            goto Quit;
    }

    if (lpszRegister)
    {
        pszRegisterW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszRegister);
        if (IS_NULL_UNEXPECTEDLY(pszRegisterW))
            goto Quit;
    }

    EnumDataW2A.lpfnEnumProc = lpfnEnumProc;
    EnumDataW2A.lpData = lpData;
    EnumDataW2A.ret = 0;
    EnumDataW2A.uCodePage = pImeDpi->uCodePage;
    pImeDpi->ImeEnumRegisterWord(Imm32EnumWordProcW2A, pszReadingW, dwStyle,
                                 pszRegisterW, &EnumDataW2A);
    ret = EnumDataW2A.ret;

Quit:
    ImmLocalFree(pszReadingW);
    ImmLocalFree(pszRegisterW);
    ImmUnlockImeDpi(pImeDpi);
    return ret;
}

ImmEnumRegisterWordW()

UINT WINAPI ImmEnumRegisterWordW	(	HKL	hKL,
		REGISTERWORDENUMPROCW	lpfnEnumProc,
		LPCWSTR	lpszReading,
		DWORD	dwStyle,
		LPCWSTR	lpszRegister,
		LPVOID	lpData
	)

Definition at line 152 of file regword.c.

{
    UINT ret = 0;
    LPSTR pszReadingA = NULL, pszRegisterA = NULL;
    ENUM_WORD_A2W EnumDataA2W;
    PIMEDPI pImeDpi;

    TRACE("(%p, %p, %s, 0x%lX, %s, %p)\n", hKL, lpfnEnumProc, debugstr_w(lpszReading),
          dwStyle, debugstr_w(lpszRegister), lpData);

    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return 0;

    if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
    {
        ret = pImeDpi->ImeEnumRegisterWord(lpfnEnumProc, lpszReading, dwStyle,
                                           lpszRegister, lpData);
        ImmUnlockImeDpi(pImeDpi);
        return ret;
    }

    if (lpszReading)
    {
        pszReadingA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszReading);
        if (IS_NULL_UNEXPECTEDLY(pszReadingA))
            goto Quit;
    }

    if (lpszRegister)
    {
        pszRegisterA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszRegister);
        if (IS_NULL_UNEXPECTEDLY(pszRegisterA))
            goto Quit;
    }

    EnumDataA2W.lpfnEnumProc = lpfnEnumProc;
    EnumDataA2W.lpData = lpData;
    EnumDataA2W.ret = 0;
    EnumDataA2W.uCodePage = pImeDpi->uCodePage;
    pImeDpi->ImeEnumRegisterWord(Imm32EnumWordProcA2W, pszReadingA, dwStyle,
                                 pszRegisterA, &EnumDataA2W);
    ret = EnumDataA2W.ret;

Quit:
    ImmLocalFree(pszReadingA);
    ImmLocalFree(pszRegisterA);
    ImmUnlockImeDpi(pImeDpi);
    TRACE("ret: %u\n", ret);
    return ret;
}

ImmGetRegisterWordStyleA()

UINT WINAPI ImmGetRegisterWordStyleA	(	HKL	hKL,
		UINT	nItem,
		LPSTYLEBUFA	lpStyleBuf
	)

Definition at line 209 of file regword.c.

{
    UINT iItem, ret = 0;
    PIMEDPI pImeDpi;
    LPSTYLEBUFA pDestA;
    LPSTYLEBUFW pSrcW, pNewStylesW = NULL;
    size_t cchW;
    INT cchA;

    TRACE("(%p, %u, %p)\n", hKL, nItem, lpStyleBuf);

    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return 0;

    if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
    {
        ret = pImeDpi->ImeGetRegisterWordStyle(nItem, lpStyleBuf);
        goto Quit;
    }

    if (nItem > 0)
    {
        pNewStylesW = ImmLocalAlloc(0, nItem * sizeof(STYLEBUFW));
        if (IS_NULL_UNEXPECTEDLY(pNewStylesW))
            goto Quit;
    }

    ret = pImeDpi->ImeGetRegisterWordStyle(nItem, pNewStylesW);

    if (nItem > 0)
    {
        /* lpStyleBuf <-- pNewStylesW */
        for (iItem = 0; iItem < ret; ++iItem)
        {
            pSrcW = &pNewStylesW[iItem];
            pDestA = &lpStyleBuf[iItem];
            pDestA->dwStyle = pSrcW->dwStyle;
            StringCchLengthW(pSrcW->szDescription, _countof(pSrcW->szDescription), &cchW);
            cchA = WideCharToMultiByte(pImeDpi->uCodePage, MB_PRECOMPOSED,
                                       pSrcW->szDescription, (INT)cchW,
                                       pDestA->szDescription, _countof(pDestA->szDescription),
                                       NULL, NULL);
            if (cchA > _countof(pDestA->szDescription) - 1)
                cchA = _countof(pDestA->szDescription) - 1;
            pDestA->szDescription[cchA] = 0;
        }
    }

Quit:
    ImmLocalFree(pNewStylesW);
    ImmUnlockImeDpi(pImeDpi);
    TRACE("ret: %u\n", ret);
    return ret;
}

Referenced by ActiveIMMApp_GetRegisterWordStyleA().

ImmGetRegisterWordStyleW()

UINT WINAPI ImmGetRegisterWordStyleW	(	HKL	hKL,
		UINT	nItem,
		LPSTYLEBUFW	lpStyleBuf
	)

Definition at line 268 of file regword.c.

{
    UINT iItem, ret = 0;
    PIMEDPI pImeDpi;
    LPSTYLEBUFA pSrcA, pNewStylesA = NULL;
    LPSTYLEBUFW pDestW;
    size_t cchA;
    INT cchW;

    TRACE("(%p, %u, %p)\n", hKL, nItem, lpStyleBuf);

    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return 0;

    if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
    {
        ret = pImeDpi->ImeGetRegisterWordStyle(nItem, lpStyleBuf);
        goto Quit;
    }

    if (nItem > 0)
    {
        pNewStylesA = ImmLocalAlloc(0, nItem * sizeof(STYLEBUFA));
        if (IS_NULL_UNEXPECTEDLY(pNewStylesA))
            goto Quit;
    }

    ret = pImeDpi->ImeGetRegisterWordStyle(nItem, pNewStylesA);

    if (nItem > 0)
    {
        /* lpStyleBuf <-- pNewStylesA */
        for (iItem = 0; iItem < ret; ++iItem)
        {
            pSrcA = &pNewStylesA[iItem];
            pDestW = &lpStyleBuf[iItem];
            pDestW->dwStyle = pSrcA->dwStyle;
            StringCchLengthA(pSrcA->szDescription, _countof(pSrcA->szDescription), &cchA);
            cchW = MultiByteToWideChar(pImeDpi->uCodePage, MB_PRECOMPOSED,
                                       pSrcA->szDescription, (INT)cchA,
                                       pDestW->szDescription, _countof(pDestW->szDescription));
            if (cchW > _countof(pDestW->szDescription) - 1)
                cchW = _countof(pDestW->szDescription) - 1;
            pDestW->szDescription[cchW] = 0;
        }
    }

Quit:
    ImmLocalFree(pNewStylesA);
    ImmUnlockImeDpi(pImeDpi);
    TRACE("ret: %u\n", ret);
    return ret;
}

Referenced by ActiveIMMApp_GetRegisterWordStyleW().

ImmRegisterWordA()

BOOL WINAPI ImmRegisterWordA	(	HKL	hKL,
		LPCSTR	lpszReading,
		DWORD	dwStyle,
		LPCSTR	lpszRegister
	)

Definition at line 327 of file regword.c.

{
    BOOL ret = FALSE;
    PIMEDPI pImeDpi;
    LPWSTR pszReadingW = NULL, pszRegisterW = NULL;

    TRACE("(%p, %s, 0x%lX, %s)\n", hKL, debugstr_a(lpszReading), dwStyle,
          debugstr_a(lpszRegister));

    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return FALSE;

    if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
    {
        ret = pImeDpi->ImeRegisterWord(lpszReading, dwStyle, lpszRegister);
        ImmUnlockImeDpi(pImeDpi);
        return ret;
    }

    if (lpszReading)
    {
        pszReadingW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszReading);
        if (IS_NULL_UNEXPECTEDLY(pszReadingW))
            goto Quit;
    }

    if (lpszRegister)
    {
        pszRegisterW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszRegister);
        if (IS_NULL_UNEXPECTEDLY(pszRegisterW))
            goto Quit;
    }

    ret = pImeDpi->ImeRegisterWord(pszReadingW, dwStyle, pszRegisterW);

Quit:
    ImmLocalFree(pszReadingW);
    ImmLocalFree(pszRegisterW);
    ImmUnlockImeDpi(pImeDpi);
    TRACE("ret: %d\n", ret);
    return ret;
}

Referenced by ActiveIMMApp_RegisterWordA().

ImmRegisterWordW()

BOOL WINAPI ImmRegisterWordW	(	HKL	hKL,
		LPCWSTR	lpszReading,
		DWORD	dwStyle,
		LPCWSTR	lpszRegister
	)

Definition at line 375 of file regword.c.

{
    BOOL ret = FALSE;
    PIMEDPI pImeDpi;
    LPSTR pszReadingA = NULL, pszRegisterA = NULL;

    TRACE("(%p, %s, 0x%lX, %s)\n", hKL, debugstr_w(lpszReading), dwStyle,
          debugstr_w(lpszRegister));

    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return FALSE;

    if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
    {
        ret = pImeDpi->ImeRegisterWord(lpszReading, dwStyle, lpszRegister);
        ImmUnlockImeDpi(pImeDpi);
        return ret;
    }

    if (lpszReading)
    {
        pszReadingA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszReading);
        if (IS_NULL_UNEXPECTEDLY(pszReadingA))
            goto Quit;
    }

    if (lpszRegister)
    {
        pszRegisterA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszRegister);
        if (IS_NULL_UNEXPECTEDLY(pszRegisterA))
            goto Quit;
    }

    ret = pImeDpi->ImeRegisterWord(pszReadingA, dwStyle, pszRegisterA);

Quit:
    ImmLocalFree(pszReadingA);
    ImmLocalFree(pszRegisterA);
    ImmUnlockImeDpi(pImeDpi);
    TRACE("ret: %d\n", ret);
    return ret;
}

Referenced by ActiveIMMApp_RegisterWordW().

ImmUnregisterWordA()

BOOL WINAPI ImmUnregisterWordA	(	HKL	hKL,
		LPCSTR	lpszReading,
		DWORD	dwStyle,
		LPCSTR	lpszUnregister
	)

Definition at line 423 of file regword.c.

{
    BOOL ret = FALSE;
    PIMEDPI pImeDpi;
    LPWSTR pszReadingW = NULL, pszUnregisterW = NULL;

    TRACE("(%p, %s, 0x%lX, %s)\n", hKL, debugstr_a(lpszReading), dwStyle,
          debugstr_a(lpszUnregister));

    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return FALSE;

    if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
    {
        ret = pImeDpi->ImeUnregisterWord(lpszReading, dwStyle, lpszUnregister);
        ImmUnlockImeDpi(pImeDpi);
        return ret;
    }

    if (lpszReading)
    {
        pszReadingW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszReading);
        if (IS_NULL_UNEXPECTEDLY(pszReadingW))
            goto Quit;
    }

    if (lpszUnregister)
    {
        pszUnregisterW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszUnregister);
        if (IS_NULL_UNEXPECTEDLY(pszUnregisterW))
            goto Quit;
    }

    ret = pImeDpi->ImeUnregisterWord(pszReadingW, dwStyle, pszUnregisterW);

Quit:
    ImmLocalFree(pszReadingW);
    ImmLocalFree(pszUnregisterW);
    ImmUnlockImeDpi(pImeDpi);
    TRACE("ret: %d\n", ret);
    return ret;
}

Referenced by ActiveIMMApp_UnregisterWordA().

ImmUnregisterWordW()

BOOL WINAPI ImmUnregisterWordW	(	HKL	hKL,
		LPCWSTR	lpszReading,
		DWORD	dwStyle,
		LPCWSTR	lpszUnregister
	)

Definition at line 471 of file regword.c.

{
    BOOL ret = FALSE;
    PIMEDPI pImeDpi;
    LPSTR pszReadingA = NULL, pszUnregisterA = NULL;

    TRACE("(%p, %s, 0x%lX, %s)\n", hKL, debugstr_w(lpszReading), dwStyle,
          debugstr_w(lpszUnregister));

    pImeDpi = Imm32FindOrLoadImeDpi(hKL);
    if (IS_NULL_UNEXPECTEDLY(pImeDpi))
        return FALSE;

    if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
    {
        ret = pImeDpi->ImeUnregisterWord(lpszReading, dwStyle, lpszUnregister);
        ImmUnlockImeDpi(pImeDpi);
        return ret;
    }

    if (lpszReading)
    {
        pszReadingA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszReading);
        if (IS_NULL_UNEXPECTEDLY(pszReadingA))
            goto Quit;
    }

    if (lpszUnregister)
    {
        pszUnregisterA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszUnregister);
        if (IS_NULL_UNEXPECTEDLY(pszUnregisterA))
            goto Quit;
    }

    ret = pImeDpi->ImeUnregisterWord(pszReadingA, dwStyle, pszUnregisterA);

Quit:
    ImmLocalFree(pszReadingA);
    ImmLocalFree(pszUnregisterA);
    ImmUnlockImeDpi(pImeDpi);
    TRACE("ret: %d\n", ret);
    return ret;
}

Referenced by ActiveIMMApp_UnregisterWordW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

imm

)