ReactOS 0.4.15-dev-6679-g945ee4b
Classes | Typedefs | Functions
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.

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
55Quit:
56 ImmLocalFree(pszReadingW);
57 ImmLocalFree(pszRegisterW);
58 return ret;
59}
NULL
#define NULL
Definition: types.h:112
ImmLocalFree
#define ImmLocalFree(lpData)
Definition: precomp.h:89
IS_NULL_UNEXPECTEDLY
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:120
Imm32WideFromAnsi
LPWSTR APIENTRY Imm32WideFromAnsi(UINT uCodePage, LPCSTR pszA)
Definition: utils.c:227
ENUM_WORD_A2W
Definition: regword.c:13
ENUM_WORD_A2W::uCodePage
UINT uCodePage
Definition: regword.c:17
ENUM_WORD_A2W::lpfnEnumProc
REGISTERWORDENUMPROCW lpfnEnumProc
Definition: regword.c:14
ENUM_WORD_A2W::lpData
LPVOID lpData
Definition: regword.c:15
ENUM_WORD_A2W::ret
UINT ret
Definition: regword.c:16
INT
int32_t INT
Definition: typedefs.h:58
ret
int ret
Definition: wcstombs-tests.c:31
LPWSTR
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
85Quit:
86 ImmLocalFree(pszReadingA);
87 ImmLocalFree(pszRegisterA);
88 return ret;
89}
Imm32AnsiFromWide
LPSTR APIENTRY Imm32AnsiFromWide(UINT uCodePage, LPCWSTR pszW)
Definition: utils.c:238
ENUM_WORD_W2A
Definition: regword.c:21
ENUM_WORD_W2A::lpData
LPVOID lpData
Definition: regword.c:23
ENUM_WORD_W2A::uCodePage
UINT uCodePage
Definition: regword.c:25
ENUM_WORD_W2A::lpfnEnumProc
REGISTERWORDENUMPROCA lpfnEnumProc
Definition: regword.c:22
ENUM_WORD_W2A::ret
UINT ret
Definition: regword.c:24
LPSTR
char * LPSTR
Definition: xmlstorage.h:182

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
141Quit:
142 ImmLocalFree(pszReadingW);
143 ImmLocalFree(pszRegisterW);
144 ImmUnlockImeDpi(pImeDpi);
145 return ret;
146}
ImmUnlockImeDpi
VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi)
Definition: ime.c:1016
Imm32FindOrLoadImeDpi
PIMEDPI APIENTRY Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:343
ImeDpi_IsUnicode
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:145
debugstr_a
#define debugstr_a
Definition: kernel32.h:31
UINT
unsigned int UINT
Definition: ndis.h:50
Imm32EnumWordProcW2A
static INT CALLBACK Imm32EnumWordProcW2A(LPCWSTR pszReadingW, DWORD dwStyle, LPCWSTR pszRegisterW, LPVOID lpData)
Definition: regword.c:62
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
IMEDPI::uCodePage
UINT uCodePage
Definition: ntuser.h:1285

◆ 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
198Quit:
199 ImmLocalFree(pszReadingA);
200 ImmLocalFree(pszRegisterA);
201 ImmUnlockImeDpi(pImeDpi);
202 TRACE("ret: %u\n", ret);
203 return ret;
204}
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
Imm32EnumWordProcA2W
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);
248 cchA = WideCharToMultiByte(pImeDpi->uCodePage, MB_PRECOMPOSED,
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
258Quit:
259 ImmLocalFree(pNewStylesW);
260 ImmUnlockImeDpi(pImeDpi);
261 TRACE("ret: %u\n", ret);
262 return ret;
263}
WideCharToMultiByte
#define WideCharToMultiByte
Definition: compat.h:111
ImmLocalAlloc
LPVOID APIENTRY ImmLocalAlloc(DWORD dwFlags, DWORD dwBytes)
Definition: utils.c:415
_countof
#define _countof(array)
Definition: sndvol32.h:68
StringCchLengthW
STRSAFEAPI StringCchLengthW(STRSAFE_LPCWSTR psz, size_t cchMax, size_t *pcchLength)
Definition: strsafe.h:842
tagSTYLEBUFA::dwStyle
DWORD dwStyle
Definition: imm.h:82
tagSTYLEBUFA::szDescription
CHAR szDescription[32]
Definition: imm.h:83
tagSTYLEBUFW::dwStyle
DWORD dwStyle
Definition: imm.h:88
tagSTYLEBUFW::szDescription
WCHAR szDescription[32]
Definition: imm.h:89
MB_PRECOMPOSED
#define MB_PRECOMPOSED
Definition: winnls.h:281

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);
307 cchW = MultiByteToWideChar(pImeDpi->uCodePage, MB_PRECOMPOSED,
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
316Quit:
317 ImmLocalFree(pNewStylesA);
318 ImmUnlockImeDpi(pImeDpi);
319 TRACE("ret: %u\n", ret);
320 return ret;
321}
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110
StringCchLengthA
STRSAFEAPI StringCchLengthA(STRSAFE_LPCSTR psz, size_t cchMax, size_t *pcchLength)
Definition: strsafe.h:832

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
363Quit:
364 ImmLocalFree(pszReadingW);
365 ImmLocalFree(pszRegisterW);
366 ImmUnlockImeDpi(pImeDpi);
367 TRACE("ret: %d\n", ret);
368 return ret;
369}
FALSE
#define FALSE
Definition: types.h:117
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94

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
411Quit:
412 ImmLocalFree(pszReadingA);
413 ImmLocalFree(pszRegisterA);
414 ImmUnlockImeDpi(pImeDpi);
415 TRACE("ret: %d\n", ret);
416 return ret;
417}

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
459Quit:
460 ImmLocalFree(pszReadingW);
461 ImmLocalFree(pszUnregisterW);
462 ImmUnlockImeDpi(pImeDpi);
463 TRACE("ret: %d\n", ret);
464 return ret;
465}

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
507Quit:
508 ImmLocalFree(pszReadingA);
509 ImmLocalFree(pszUnregisterA);
510 ImmUnlockImeDpi(pImeDpi);
511 TRACE("ret: %d\n", ret);
512 return ret;
513}

Referenced by ActiveIMMApp_UnregisterWordW().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( imm  )