ReactOS  0.4.15-dev-5606-gf34e425
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_A2WLPENUM_WORD_A2W
 
typedef struct ENUM_WORD_W2A ENUM_WORD_W2A
 
typedef struct ENUM_WORD_W2ALPENUM_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

◆ ENUM_WORD_W2A

◆ LPENUM_WORD_A2W

◆ 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.

33 {
34  INT ret = 0;
35  LPENUM_WORD_A2W lpEnumData = lpData;
36  LPWSTR pszReadingW = NULL, pszRegisterW = NULL;
37 
38  if (pszReadingA)
39  {
40  pszReadingW = Imm32WideFromAnsi(lpEnumData->uCodePage, pszReadingA);
41  if (IS_NULL_UNEXPECTEDLY(pszReadingW))
42  goto Quit;
43  }
44 
45  if (pszRegisterA)
46  {
47  pszRegisterW = Imm32WideFromAnsi(lpEnumData->uCodePage, pszRegisterA);
48  if (IS_NULL_UNEXPECTEDLY(pszRegisterW))
49  goto Quit;
50  }
51 
52  ret = lpEnumData->lpfnEnumProc(pszReadingW, dwStyle, pszRegisterW, lpEnumData->lpData);
53  lpEnumData->ret = ret;
54 
55 Quit:
56  ImmLocalFree(pszReadingW);
57  ImmLocalFree(pszRegisterW);
58  return ret;
59 }
int32_t INT
Definition: typedefs.h:58
UINT uCodePage
Definition: regword.c:17
UINT ret
Definition: regword.c:16
REGISTERWORDENUMPROCW lpfnEnumProc
Definition: regword.c:14
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:120
#define ImmLocalFree(lpData)
Definition: precomp.h:89
int ret
LPWSTR APIENTRY Imm32WideFromAnsi(UINT uCodePage, LPCSTR pszA)
Definition: utils.c:227
LPVOID lpData
Definition: regword.c:15
#define NULL
Definition: types.h:112
WCHAR * LPWSTR
Definition: xmlstorage.h:184

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.

63 {
64  INT ret = 0;
65  LPENUM_WORD_W2A lpEnumData = lpData;
66  LPSTR pszReadingA = NULL, pszRegisterA = NULL;
67 
68  if (pszReadingW)
69  {
70  pszReadingA = Imm32AnsiFromWide(lpEnumData->uCodePage, pszReadingW);
71  if (IS_NULL_UNEXPECTEDLY(pszReadingW))
72  goto Quit;
73  }
74 
75  if (pszRegisterW)
76  {
77  pszRegisterA = Imm32AnsiFromWide(lpEnumData->uCodePage, pszRegisterW);
78  if (IS_NULL_UNEXPECTEDLY(pszRegisterA))
79  goto Quit;
80  }
81 
82  ret = lpEnumData->lpfnEnumProc(pszReadingA, dwStyle, pszRegisterA, lpEnumData->lpData);
83  lpEnumData->ret = ret;
84 
85 Quit:
86  ImmLocalFree(pszReadingA);
87  ImmLocalFree(pszRegisterA);
88  return ret;
89 }
LPVOID lpData
Definition: regword.c:23
LPSTR APIENTRY Imm32AnsiFromWide(UINT uCodePage, LPCWSTR pszW)
Definition: utils.c:238
char * LPSTR
Definition: xmlstorage.h:182
int32_t INT
Definition: typedefs.h:58
UINT ret
Definition: regword.c:24
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:120
#define ImmLocalFree(lpData)
Definition: precomp.h:89
int ret
REGISTERWORDENUMPROCA lpfnEnumProc
Definition: regword.c:22
#define NULL
Definition: types.h:112
UINT uCodePage
Definition: regword.c:25

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.

98 {
99  UINT ret = 0;
100  LPWSTR pszReadingW = NULL, pszRegisterW = NULL;
101  ENUM_WORD_W2A EnumDataW2A;
102  PIMEDPI pImeDpi;
103 
104  TRACE("(%p, %p, %s, 0x%lX, %s, %p)\n", hKL, lpfnEnumProc, debugstr_a(lpszReading),
105  dwStyle, debugstr_a(lpszRegister), lpData);
106 
107  pImeDpi = Imm32FindOrLoadImeDpi(hKL);
108  if (IS_NULL_UNEXPECTEDLY(pImeDpi))
109  return 0;
110 
111  if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
112  {
113  ret = pImeDpi->ImeEnumRegisterWord(lpfnEnumProc, lpszReading, dwStyle,
114  lpszRegister, lpData);
115  ImmUnlockImeDpi(pImeDpi);
116  return ret;
117  }
118 
119  if (lpszReading)
120  {
121  pszReadingW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszReading);
122  if (IS_NULL_UNEXPECTEDLY(pszReadingW))
123  goto Quit;
124  }
125 
126  if (lpszRegister)
127  {
128  pszRegisterW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszRegister);
129  if (IS_NULL_UNEXPECTEDLY(pszRegisterW))
130  goto Quit;
131  }
132 
133  EnumDataW2A.lpfnEnumProc = lpfnEnumProc;
134  EnumDataW2A.lpData = lpData;
135  EnumDataW2A.ret = 0;
136  EnumDataW2A.uCodePage = pImeDpi->uCodePage;
137  pImeDpi->ImeEnumRegisterWord(Imm32EnumWordProcW2A, pszReadingW, dwStyle,
138  pszRegisterW, &EnumDataW2A);
139  ret = EnumDataW2A.ret;
140 
141 Quit:
142  ImmLocalFree(pszReadingW);
143  ImmLocalFree(pszRegisterW);
144  ImmUnlockImeDpi(pImeDpi);
145  return ret;
146 }
VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi)
Definition: ime.c:1016
UINT uCodePage
Definition: ntuser.h:1285
LPVOID lpData
Definition: regword.c:23
UINT ret
Definition: regword.c:24
static INT CALLBACK Imm32EnumWordProcW2A(LPCWSTR pszReadingW, DWORD dwStyle, LPCWSTR pszRegisterW, LPVOID lpData)
Definition: regword.c:62
#define TRACE(s)
Definition: solgame.cpp:4
#define debugstr_a
Definition: kernel32.h:31
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:120
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:145
#define ImmLocalFree(lpData)
Definition: precomp.h:89
int ret
REGISTERWORDENUMPROCA lpfnEnumProc
Definition: regword.c:22
LPWSTR APIENTRY Imm32WideFromAnsi(UINT uCodePage, LPCSTR pszA)
Definition: utils.c:227
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
PIMEDPI APIENTRY Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:343
UINT uCodePage
Definition: regword.c:25
WCHAR * LPWSTR
Definition: xmlstorage.h:184

◆ ImmEnumRegisterWordW()

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

Definition at line 152 of file regword.c.

155 {
156  UINT ret = 0;
157  LPSTR pszReadingA = NULL, pszRegisterA = NULL;
158  ENUM_WORD_A2W EnumDataA2W;
159  PIMEDPI pImeDpi;
160 
161  TRACE("(%p, %p, %s, 0x%lX, %s, %p)\n", hKL, lpfnEnumProc, debugstr_w(lpszReading),
162  dwStyle, debugstr_w(lpszRegister), lpData);
163 
164  pImeDpi = Imm32FindOrLoadImeDpi(hKL);
165  if (IS_NULL_UNEXPECTEDLY(pImeDpi))
166  return 0;
167 
168  if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
169  {
170  ret = pImeDpi->ImeEnumRegisterWord(lpfnEnumProc, lpszReading, dwStyle,
171  lpszRegister, lpData);
172  ImmUnlockImeDpi(pImeDpi);
173  return ret;
174  }
175 
176  if (lpszReading)
177  {
178  pszReadingA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszReading);
179  if (IS_NULL_UNEXPECTEDLY(pszReadingA))
180  goto Quit;
181  }
182 
183  if (lpszRegister)
184  {
185  pszRegisterA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszRegister);
186  if (IS_NULL_UNEXPECTEDLY(pszRegisterA))
187  goto Quit;
188  }
189 
190  EnumDataA2W.lpfnEnumProc = lpfnEnumProc;
191  EnumDataA2W.lpData = lpData;
192  EnumDataA2W.ret = 0;
193  EnumDataA2W.uCodePage = pImeDpi->uCodePage;
194  pImeDpi->ImeEnumRegisterWord(Imm32EnumWordProcA2W, pszReadingA, dwStyle,
195  pszRegisterA, &EnumDataA2W);
196  ret = EnumDataA2W.ret;
197 
198 Quit:
199  ImmLocalFree(pszReadingA);
200  ImmLocalFree(pszRegisterA);
201  ImmUnlockImeDpi(pImeDpi);
202  TRACE("ret: %u\n", ret);
203  return ret;
204 }
VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi)
Definition: ime.c:1016
UINT uCodePage
Definition: ntuser.h:1285
LPSTR APIENTRY Imm32AnsiFromWide(UINT uCodePage, LPCWSTR pszW)
Definition: utils.c:238
char * LPSTR
Definition: xmlstorage.h:182
#define debugstr_w
Definition: kernel32.h:32
UINT uCodePage
Definition: regword.c:17
#define TRACE(s)
Definition: solgame.cpp:4
UINT ret
Definition: regword.c:16
REGISTERWORDENUMPROCW lpfnEnumProc
Definition: regword.c:14
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:120
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:145
#define ImmLocalFree(lpData)
Definition: precomp.h:89
int ret
LPVOID lpData
Definition: regword.c:15
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
PIMEDPI APIENTRY Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:343
static INT CALLBACK Imm32EnumWordProcA2W(LPCSTR pszReadingA, DWORD dwStyle, LPCSTR pszRegisterA, LPVOID lpData)
Definition: regword.c:32

◆ ImmGetRegisterWordStyleA()

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

Definition at line 209 of file regword.c.

210 {
211  UINT iItem, ret = 0;
212  PIMEDPI pImeDpi;
213  LPSTYLEBUFA pDestA;
214  LPSTYLEBUFW pSrcW, pNewStylesW = NULL;
215  size_t cchW;
216  INT cchA;
217 
218  TRACE("(%p, %u, %p)\n", hKL, nItem, lpStyleBuf);
219 
220  pImeDpi = Imm32FindOrLoadImeDpi(hKL);
221  if (IS_NULL_UNEXPECTEDLY(pImeDpi))
222  return 0;
223 
224  if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
225  {
226  ret = pImeDpi->ImeGetRegisterWordStyle(nItem, lpStyleBuf);
227  goto Quit;
228  }
229 
230  if (nItem > 0)
231  {
232  pNewStylesW = ImmLocalAlloc(0, nItem * sizeof(STYLEBUFW));
233  if (IS_NULL_UNEXPECTEDLY(pNewStylesW))
234  goto Quit;
235  }
236 
237  ret = pImeDpi->ImeGetRegisterWordStyle(nItem, pNewStylesW);
238 
239  if (nItem > 0)
240  {
241  /* lpStyleBuf <-- pNewStylesW */
242  for (iItem = 0; iItem < ret; ++iItem)
243  {
244  pSrcW = &pNewStylesW[iItem];
245  pDestA = &lpStyleBuf[iItem];
246  pDestA->dwStyle = pSrcW->dwStyle;
247  StringCchLengthW(pSrcW->szDescription, _countof(pSrcW->szDescription), &cchW);
249  pSrcW->szDescription, (INT)cchW,
250  pDestA->szDescription, _countof(pDestA->szDescription),
251  NULL, NULL);
252  if (cchA > _countof(pDestA->szDescription) - 1)
253  cchA = _countof(pDestA->szDescription) - 1;
254  pDestA->szDescription[cchA] = 0;
255  }
256  }
257 
258 Quit:
259  ImmLocalFree(pNewStylesW);
260  ImmUnlockImeDpi(pImeDpi);
261  TRACE("ret: %u\n", ret);
262  return ret;
263 }
VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi)
Definition: ime.c:1016
UINT uCodePage
Definition: ntuser.h:1285
DWORD dwStyle
Definition: imm.h:88
#define WideCharToMultiByte
Definition: compat.h:111
LPVOID APIENTRY ImmLocalAlloc(DWORD dwFlags, DWORD dwBytes)
Definition: utils.c:415
#define MB_PRECOMPOSED
Definition: winnls.h:281
DWORD dwStyle
Definition: imm.h:82
int32_t INT
Definition: typedefs.h:58
#define TRACE(s)
Definition: solgame.cpp:4
WCHAR szDescription[32]
Definition: imm.h:89
#define _countof(array)
Definition: sndvol32.h:68
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:120
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:145
#define ImmLocalFree(lpData)
Definition: precomp.h:89
int ret
CHAR szDescription[32]
Definition: imm.h:83
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
STRSAFEAPI StringCchLengthW(STRSAFE_LPCWSTR psz, size_t cchMax, size_t *pcchLength)
Definition: strsafe.h:842
PIMEDPI APIENTRY Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:343

Referenced by ActiveIMMApp_GetRegisterWordStyleA().

◆ ImmGetRegisterWordStyleW()

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

Definition at line 268 of file regword.c.

269 {
270  UINT iItem, ret = 0;
271  PIMEDPI pImeDpi;
272  LPSTYLEBUFA pSrcA, pNewStylesA = NULL;
273  LPSTYLEBUFW pDestW;
274  size_t cchA;
275  INT cchW;
276 
277  TRACE("(%p, %u, %p)\n", hKL, nItem, lpStyleBuf);
278 
279  pImeDpi = Imm32FindOrLoadImeDpi(hKL);
280  if (IS_NULL_UNEXPECTEDLY(pImeDpi))
281  return 0;
282 
283  if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
284  {
285  ret = pImeDpi->ImeGetRegisterWordStyle(nItem, lpStyleBuf);
286  goto Quit;
287  }
288 
289  if (nItem > 0)
290  {
291  pNewStylesA = ImmLocalAlloc(0, nItem * sizeof(STYLEBUFA));
292  if (IS_NULL_UNEXPECTEDLY(pNewStylesA))
293  goto Quit;
294  }
295 
296  ret = pImeDpi->ImeGetRegisterWordStyle(nItem, pNewStylesA);
297 
298  if (nItem > 0)
299  {
300  /* lpStyleBuf <-- pNewStylesA */
301  for (iItem = 0; iItem < ret; ++iItem)
302  {
303  pSrcA = &pNewStylesA[iItem];
304  pDestW = &lpStyleBuf[iItem];
305  pDestW->dwStyle = pSrcA->dwStyle;
306  StringCchLengthA(pSrcA->szDescription, _countof(pSrcA->szDescription), &cchA);
308  pSrcA->szDescription, (INT)cchA,
309  pDestW->szDescription, _countof(pDestW->szDescription));
310  if (cchW > _countof(pDestW->szDescription) - 1)
311  cchW = _countof(pDestW->szDescription) - 1;
312  pDestW->szDescription[cchW] = 0;
313  }
314  }
315 
316 Quit:
317  ImmLocalFree(pNewStylesA);
318  ImmUnlockImeDpi(pImeDpi);
319  TRACE("ret: %u\n", ret);
320  return ret;
321 }
VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi)
Definition: ime.c:1016
UINT uCodePage
Definition: ntuser.h:1285
DWORD dwStyle
Definition: imm.h:88
LPVOID APIENTRY ImmLocalAlloc(DWORD dwFlags, DWORD dwBytes)
Definition: utils.c:415
#define MB_PRECOMPOSED
Definition: winnls.h:281
DWORD dwStyle
Definition: imm.h:82
int32_t INT
Definition: typedefs.h:58
#define TRACE(s)
Definition: solgame.cpp:4
WCHAR szDescription[32]
Definition: imm.h:89
#define _countof(array)
Definition: sndvol32.h:68
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:120
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:145
#define ImmLocalFree(lpData)
Definition: precomp.h:89
int ret
CHAR szDescription[32]
Definition: imm.h:83
STRSAFEAPI StringCchLengthA(STRSAFE_LPCSTR psz, size_t cchMax, size_t *pcchLength)
Definition: strsafe.h:832
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
#define MultiByteToWideChar
Definition: compat.h:110
PIMEDPI APIENTRY Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:343

Referenced by ActiveIMMApp_GetRegisterWordStyleW().

◆ ImmRegisterWordA()

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

Definition at line 327 of file regword.c.

328 {
329  BOOL ret = FALSE;
330  PIMEDPI pImeDpi;
331  LPWSTR pszReadingW = NULL, pszRegisterW = NULL;
332 
333  TRACE("(%p, %s, 0x%lX, %s)\n", hKL, debugstr_a(lpszReading), dwStyle,
334  debugstr_a(lpszRegister));
335 
336  pImeDpi = Imm32FindOrLoadImeDpi(hKL);
337  if (IS_NULL_UNEXPECTEDLY(pImeDpi))
338  return FALSE;
339 
340  if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
341  {
342  ret = pImeDpi->ImeRegisterWord(lpszReading, dwStyle, lpszRegister);
343  ImmUnlockImeDpi(pImeDpi);
344  return ret;
345  }
346 
347  if (lpszReading)
348  {
349  pszReadingW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszReading);
350  if (IS_NULL_UNEXPECTEDLY(pszReadingW))
351  goto Quit;
352  }
353 
354  if (lpszRegister)
355  {
356  pszRegisterW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszRegister);
357  if (IS_NULL_UNEXPECTEDLY(pszRegisterW))
358  goto Quit;
359  }
360 
361  ret = pImeDpi->ImeRegisterWord(pszReadingW, dwStyle, pszRegisterW);
362 
363 Quit:
364  ImmLocalFree(pszReadingW);
365  ImmLocalFree(pszRegisterW);
366  ImmUnlockImeDpi(pImeDpi);
367  TRACE("ret: %d\n", ret);
368  return ret;
369 }
VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi)
Definition: ime.c:1016
UINT uCodePage
Definition: ntuser.h:1285
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
#define TRACE(s)
Definition: solgame.cpp:4
#define debugstr_a
Definition: kernel32.h:31
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:120
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:145
#define ImmLocalFree(lpData)
Definition: precomp.h:89
int ret
LPWSTR APIENTRY Imm32WideFromAnsi(UINT uCodePage, LPCSTR pszA)
Definition: utils.c:227
#define NULL
Definition: types.h:112
PIMEDPI APIENTRY Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:343
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by ActiveIMMApp_RegisterWordA().

◆ ImmRegisterWordW()

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

Definition at line 375 of file regword.c.

376 {
377  BOOL ret = FALSE;
378  PIMEDPI pImeDpi;
379  LPSTR pszReadingA = NULL, pszRegisterA = NULL;
380 
381  TRACE("(%p, %s, 0x%lX, %s)\n", hKL, debugstr_w(lpszReading), dwStyle,
382  debugstr_w(lpszRegister));
383 
384  pImeDpi = Imm32FindOrLoadImeDpi(hKL);
385  if (IS_NULL_UNEXPECTEDLY(pImeDpi))
386  return FALSE;
387 
388  if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
389  {
390  ret = pImeDpi->ImeRegisterWord(lpszReading, dwStyle, lpszRegister);
391  ImmUnlockImeDpi(pImeDpi);
392  return ret;
393  }
394 
395  if (lpszReading)
396  {
397  pszReadingA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszReading);
398  if (IS_NULL_UNEXPECTEDLY(pszReadingA))
399  goto Quit;
400  }
401 
402  if (lpszRegister)
403  {
404  pszRegisterA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszRegister);
405  if (IS_NULL_UNEXPECTEDLY(pszRegisterA))
406  goto Quit;
407  }
408 
409  ret = pImeDpi->ImeRegisterWord(pszReadingA, dwStyle, pszRegisterA);
410 
411 Quit:
412  ImmLocalFree(pszReadingA);
413  ImmLocalFree(pszRegisterA);
414  ImmUnlockImeDpi(pImeDpi);
415  TRACE("ret: %d\n", ret);
416  return ret;
417 }
VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi)
Definition: ime.c:1016
UINT uCodePage
Definition: ntuser.h:1285
LPSTR APIENTRY Imm32AnsiFromWide(UINT uCodePage, LPCWSTR pszW)
Definition: utils.c:238
char * LPSTR
Definition: xmlstorage.h:182
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
#define debugstr_w
Definition: kernel32.h:32
#define TRACE(s)
Definition: solgame.cpp:4
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:120
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:145
#define ImmLocalFree(lpData)
Definition: precomp.h:89
int ret
#define NULL
Definition: types.h:112
PIMEDPI APIENTRY Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:343

Referenced by ActiveIMMApp_RegisterWordW().

◆ ImmUnregisterWordA()

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

Definition at line 423 of file regword.c.

424 {
425  BOOL ret = FALSE;
426  PIMEDPI pImeDpi;
427  LPWSTR pszReadingW = NULL, pszUnregisterW = NULL;
428 
429  TRACE("(%p, %s, 0x%lX, %s)\n", hKL, debugstr_a(lpszReading), dwStyle,
430  debugstr_a(lpszUnregister));
431 
432  pImeDpi = Imm32FindOrLoadImeDpi(hKL);
433  if (IS_NULL_UNEXPECTEDLY(pImeDpi))
434  return FALSE;
435 
436  if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
437  {
438  ret = pImeDpi->ImeUnregisterWord(lpszReading, dwStyle, lpszUnregister);
439  ImmUnlockImeDpi(pImeDpi);
440  return ret;
441  }
442 
443  if (lpszReading)
444  {
445  pszReadingW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszReading);
446  if (IS_NULL_UNEXPECTEDLY(pszReadingW))
447  goto Quit;
448  }
449 
450  if (lpszUnregister)
451  {
452  pszUnregisterW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszUnregister);
453  if (IS_NULL_UNEXPECTEDLY(pszUnregisterW))
454  goto Quit;
455  }
456 
457  ret = pImeDpi->ImeUnregisterWord(pszReadingW, dwStyle, pszUnregisterW);
458 
459 Quit:
460  ImmLocalFree(pszReadingW);
461  ImmLocalFree(pszUnregisterW);
462  ImmUnlockImeDpi(pImeDpi);
463  TRACE("ret: %d\n", ret);
464  return ret;
465 }
VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi)
Definition: ime.c:1016
UINT uCodePage
Definition: ntuser.h:1285
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
#define TRACE(s)
Definition: solgame.cpp:4
#define debugstr_a
Definition: kernel32.h:31
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:120
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:145
#define ImmLocalFree(lpData)
Definition: precomp.h:89
int ret
LPWSTR APIENTRY Imm32WideFromAnsi(UINT uCodePage, LPCSTR pszA)
Definition: utils.c:227
#define NULL
Definition: types.h:112
PIMEDPI APIENTRY Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:343
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by ActiveIMMApp_UnregisterWordA().

◆ ImmUnregisterWordW()

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

Definition at line 471 of file regword.c.

472 {
473  BOOL ret = FALSE;
474  PIMEDPI pImeDpi;
475  LPSTR pszReadingA = NULL, pszUnregisterA = NULL;
476 
477  TRACE("(%p, %s, 0x%lX, %s)\n", hKL, debugstr_w(lpszReading), dwStyle,
478  debugstr_w(lpszUnregister));
479 
480  pImeDpi = Imm32FindOrLoadImeDpi(hKL);
481  if (IS_NULL_UNEXPECTEDLY(pImeDpi))
482  return FALSE;
483 
484  if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
485  {
486  ret = pImeDpi->ImeUnregisterWord(lpszReading, dwStyle, lpszUnregister);
487  ImmUnlockImeDpi(pImeDpi);
488  return ret;
489  }
490 
491  if (lpszReading)
492  {
493  pszReadingA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszReading);
494  if (IS_NULL_UNEXPECTEDLY(pszReadingA))
495  goto Quit;
496  }
497 
498  if (lpszUnregister)
499  {
500  pszUnregisterA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszUnregister);
501  if (IS_NULL_UNEXPECTEDLY(pszUnregisterA))
502  goto Quit;
503  }
504 
505  ret = pImeDpi->ImeUnregisterWord(pszReadingA, dwStyle, pszUnregisterA);
506 
507 Quit:
508  ImmLocalFree(pszReadingA);
509  ImmLocalFree(pszUnregisterA);
510  ImmUnlockImeDpi(pImeDpi);
511  TRACE("ret: %d\n", ret);
512  return ret;
513 }
VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi)
Definition: ime.c:1016
UINT uCodePage
Definition: ntuser.h:1285
LPSTR APIENTRY Imm32AnsiFromWide(UINT uCodePage, LPCWSTR pszW)
Definition: utils.c:238
char * LPSTR
Definition: xmlstorage.h:182
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
#define debugstr_w
Definition: kernel32.h:32
#define TRACE(s)
Definition: solgame.cpp:4
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:120
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:145
#define ImmLocalFree(lpData)
Definition: precomp.h:89
int ret
#define NULL
Definition: types.h:112
PIMEDPI APIENTRY Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:343

Referenced by ActiveIMMApp_UnregisterWordW().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( imm  )