ReactOS 0.4.16-dev-1067-ge98bba2
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
IS_NULL_UNEXPECTEDLY
#define IS_NULL_UNEXPECTEDLY(p)
Definition: debug.h:84
ImmLocalFree
#define ImmLocalFree(lpData)
Definition: precomp.h:88
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, lpszReading,
105 dwStyle, 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:1007
Imm32FindOrLoadImeDpi
PIMEDPI APIENTRY Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:343
ImeDpi_IsUnicode
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:102
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: imm32_undoc.h:68

◆ 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, lpszReading,
162 dwStyle, 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}
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:70
StringCchLengthW
STRSAFEAPI StringCchLengthW(STRSAFE_LPCWSTR psz, size_t cchMax, size_t *pcchLength)
Definition: strsafe.h:842
tagSTYLEBUFA::szDescription
CHAR szDescription[STYLE_DESCRIPTION_SIZE]
Definition: imm.h:70
tagSTYLEBUFA::dwStyle
DWORD dwStyle
Definition: imm.h:69
tagSTYLEBUFW::szDescription
WCHAR szDescription[STYLE_DESCRIPTION_SIZE]
Definition: imm.h:75
tagSTYLEBUFW::dwStyle
DWORD dwStyle
Definition: imm.h:74
MB_PRECOMPOSED
#define MB_PRECOMPOSED
Definition: winnls.h:283

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, lpszReading, dwStyle, lpszRegister);
334
335 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
336 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
337 return FALSE;
338
339 if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
340 {
341 ret = pImeDpi->ImeRegisterWord(lpszReading, dwStyle, lpszRegister);
342 ImmUnlockImeDpi(pImeDpi);
343 return ret;
344 }
345
346 if (lpszReading)
347 {
348 pszReadingW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszReading);
349 if (IS_NULL_UNEXPECTEDLY(pszReadingW))
350 goto Quit;
351 }
352
353 if (lpszRegister)
354 {
355 pszRegisterW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszRegister);
356 if (IS_NULL_UNEXPECTEDLY(pszRegisterW))
357 goto Quit;
358 }
359
360 ret = pImeDpi->ImeRegisterWord(pszReadingW, dwStyle, pszRegisterW);
361
362Quit:
363 ImmLocalFree(pszReadingW);
364 ImmLocalFree(pszRegisterW);
365 ImmUnlockImeDpi(pImeDpi);
366 TRACE("ret: %d\n", ret);
367 return ret;
368}
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 374 of file regword.c.

375{
376 BOOL ret = FALSE;
377 PIMEDPI pImeDpi;
378 LPSTR pszReadingA = NULL, pszRegisterA = NULL;
379
380 TRACE("(%p, %S, 0x%lX, %S)\n", hKL, lpszReading, dwStyle, lpszRegister);
381
382 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
383 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
384 return FALSE;
385
386 if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
387 {
388 ret = pImeDpi->ImeRegisterWord(lpszReading, dwStyle, lpszRegister);
389 ImmUnlockImeDpi(pImeDpi);
390 return ret;
391 }
392
393 if (lpszReading)
394 {
395 pszReadingA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszReading);
396 if (IS_NULL_UNEXPECTEDLY(pszReadingA))
397 goto Quit;
398 }
399
400 if (lpszRegister)
401 {
402 pszRegisterA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszRegister);
403 if (IS_NULL_UNEXPECTEDLY(pszRegisterA))
404 goto Quit;
405 }
406
407 ret = pImeDpi->ImeRegisterWord(pszReadingA, dwStyle, pszRegisterA);
408
409Quit:
410 ImmLocalFree(pszReadingA);
411 ImmLocalFree(pszRegisterA);
412 ImmUnlockImeDpi(pImeDpi);
413 TRACE("ret: %d\n", ret);
414 return ret;
415}

Referenced by ActiveIMMApp_RegisterWordW().

◆ ImmUnregisterWordA()

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

Definition at line 421 of file regword.c.

422{
423 BOOL ret = FALSE;
424 PIMEDPI pImeDpi;
425 LPWSTR pszReadingW = NULL, pszUnregisterW = NULL;
426
427 TRACE("(%p, %s, 0x%lX, %s)\n", hKL, lpszReading, dwStyle, lpszUnregister);
428
429 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
430 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
431 return FALSE;
432
433 if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
434 {
435 ret = pImeDpi->ImeUnregisterWord(lpszReading, dwStyle, lpszUnregister);
436 ImmUnlockImeDpi(pImeDpi);
437 return ret;
438 }
439
440 if (lpszReading)
441 {
442 pszReadingW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszReading);
443 if (IS_NULL_UNEXPECTEDLY(pszReadingW))
444 goto Quit;
445 }
446
447 if (lpszUnregister)
448 {
449 pszUnregisterW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszUnregister);
450 if (IS_NULL_UNEXPECTEDLY(pszUnregisterW))
451 goto Quit;
452 }
453
454 ret = pImeDpi->ImeUnregisterWord(pszReadingW, dwStyle, pszUnregisterW);
455
456Quit:
457 ImmLocalFree(pszReadingW);
458 ImmLocalFree(pszUnregisterW);
459 ImmUnlockImeDpi(pImeDpi);
460 TRACE("ret: %d\n", ret);
461 return ret;
462}

Referenced by ActiveIMMApp_UnregisterWordA().

◆ ImmUnregisterWordW()

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

Definition at line 468 of file regword.c.

469{
470 BOOL ret = FALSE;
471 PIMEDPI pImeDpi;
472 LPSTR pszReadingA = NULL, pszUnregisterA = NULL;
473
474 TRACE("(%p, %S, 0x%lX, %S)\n", hKL, lpszReading, dwStyle, lpszUnregister);
475
476 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
477 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
478 return FALSE;
479
480 if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
481 {
482 ret = pImeDpi->ImeUnregisterWord(lpszReading, dwStyle, lpszUnregister);
483 ImmUnlockImeDpi(pImeDpi);
484 return ret;
485 }
486
487 if (lpszReading)
488 {
489 pszReadingA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszReading);
490 if (IS_NULL_UNEXPECTEDLY(pszReadingA))
491 goto Quit;
492 }
493
494 if (lpszUnregister)
495 {
496 pszUnregisterA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszUnregister);
497 if (IS_NULL_UNEXPECTEDLY(pszUnregisterA))
498 goto Quit;
499 }
500
501 ret = pImeDpi->ImeUnregisterWord(pszReadingA, dwStyle, pszUnregisterA);
502
503Quit:
504 ImmLocalFree(pszReadingA);
505 ImmLocalFree(pszUnregisterA);
506 ImmUnlockImeDpi(pImeDpi);
507 TRACE("ret: %d\n", ret);
508 return ret;
509}

Referenced by ActiveIMMApp_UnregisterWordW().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( imm  )