ReactOS 0.4.16-dev-1946-g52006dd
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 (_In_ HKL hKL, _In_ REGISTERWORDENUMPROCA lpfnEnumProc, _In_opt_ LPCSTR lpszReading, _In_ DWORD dwStyle, _In_opt_ LPCSTR lpszRegister, _Inout_opt_ LPVOID lpData)
 
UINT WINAPI ImmEnumRegisterWordW (_In_ HKL hKL, _In_ REGISTERWORDENUMPROCW lpfnEnumProc, _In_opt_ LPCWSTR lpszReading, _In_ DWORD dwStyle, _In_opt_ LPCWSTR lpszRegister, _Inout_opt_ LPVOID lpData)
 
UINT WINAPI ImmGetRegisterWordStyleA (_In_ HKL hKL, _In_ UINT nItem, _Out_writes_(nItem) LPSTYLEBUFA lpStyleBuf)
 
UINT WINAPI ImmGetRegisterWordStyleW (_In_ HKL hKL, _In_ UINT nItem, _Out_writes_(nItem) LPSTYLEBUFW lpStyleBuf)
 
BOOL WINAPI ImmRegisterWordA (_In_ HKL hKL, _In_opt_ LPCSTR lpszReading, _In_ DWORD dwStyle, _In_opt_ LPCSTR lpszRegister)
 
BOOL WINAPI ImmRegisterWordW (_In_ HKL hKL, _In_opt_ LPCWSTR lpszReading, _In_ DWORD dwStyle, _In_opt_ LPCWSTR lpszRegister)
 
BOOL WINAPI ImmUnregisterWordA (_In_ HKL hKL, _In_opt_ LPCSTR lpszReading, _In_ DWORD dwStyle, _In_opt_ LPCSTR lpszUnregister)
 
BOOL WINAPI ImmUnregisterWordW (_In_ HKL hKL, _In_opt_ LPCWSTR lpszReading, _In_ DWORD dwStyle, _In_opt_ 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
ret
return ret
Definition: mutex.c:146
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
ImmLocalFree
#define ImmLocalFree(lpData)
Definition: precomp.h:105
Imm32WideFromAnsi
LPWSTR Imm32WideFromAnsi(UINT uCodePage, LPCSTR pszA)
Definition: utils.c:96
IS_NULL_UNEXPECTEDLY
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:66
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}
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
Imm32AnsiFromWide
LPSTR Imm32AnsiFromWide(UINT uCodePage, LPCWSTR pszW)
Definition: utils.c:107
LPSTR
char * LPSTR
Definition: xmlstorage.h:182

Referenced by ImmEnumRegisterWordA().

◆ ImmEnumRegisterWordA()

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

Definition at line 95 of file regword.c.

102{
103 UINT ret = 0;
104 LPWSTR pszReadingW = NULL, pszRegisterW = NULL;
105 ENUM_WORD_W2A EnumDataW2A;
106 PIMEDPI pImeDpi;
107
108 TRACE("(%p, %p, %s, 0x%lX, %s, %p)\n", hKL, lpfnEnumProc, debugstr_a(lpszReading),
109 dwStyle, debugstr_a(lpszRegister), lpData);
110
111 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
112 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
113 return 0;
114
115 if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
116 {
117 ret = pImeDpi->ImeEnumRegisterWord(lpfnEnumProc, lpszReading, dwStyle,
118 lpszRegister, lpData);
119 ImmUnlockImeDpi(pImeDpi);
120 return ret;
121 }
122
123 if (lpszReading)
124 {
125 pszReadingW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszReading);
126 if (IS_NULL_UNEXPECTEDLY(pszReadingW))
127 goto Quit;
128 }
129
130 if (lpszRegister)
131 {
132 pszRegisterW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszRegister);
133 if (IS_NULL_UNEXPECTEDLY(pszRegisterW))
134 goto Quit;
135 }
136
137 EnumDataW2A.lpfnEnumProc = lpfnEnumProc;
138 EnumDataW2A.lpData = lpData;
139 EnumDataW2A.ret = 0;
140 EnumDataW2A.uCodePage = pImeDpi->uCodePage;
141 pImeDpi->ImeEnumRegisterWord(Imm32EnumWordProcW2A, pszReadingW, dwStyle,
142 pszRegisterW, &EnumDataW2A);
143 ret = EnumDataW2A.ret;
144
145Quit:
146 ImmLocalFree(pszReadingW);
147 ImmLocalFree(pszRegisterW);
148 ImmUnlockImeDpi(pImeDpi);
149 return ret;
150}
Imm32FindOrLoadImeDpi
PIMEDPI Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:350
ImmUnlockImeDpi
VOID WINAPI ImmUnlockImeDpi(_Inout_opt_ PIMEDPI pImeDpi)
Definition: ime.c:561
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: imm32_undoc.h:95
ImeDpi_IsUnicode
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:120

◆ ImmEnumRegisterWordW()

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

Definition at line 156 of file regword.c.

163{
164 UINT ret = 0;
165 LPSTR pszReadingA = NULL, pszRegisterA = NULL;
166 ENUM_WORD_A2W EnumDataA2W;
167 PIMEDPI pImeDpi;
168
169 TRACE("(%p, %p, %s, 0x%lX, %s, %p)\n", hKL, lpfnEnumProc, debugstr_w(lpszReading),
170 dwStyle, debugstr_w(lpszRegister), lpData);
171
172 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
173 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
174 return 0;
175
176 if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
177 {
178 ret = pImeDpi->ImeEnumRegisterWord(lpfnEnumProc, lpszReading, dwStyle,
179 lpszRegister, lpData);
180 ImmUnlockImeDpi(pImeDpi);
181 return ret;
182 }
183
184 if (lpszReading)
185 {
186 pszReadingA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszReading);
187 if (IS_NULL_UNEXPECTEDLY(pszReadingA))
188 goto Quit;
189 }
190
191 if (lpszRegister)
192 {
193 pszRegisterA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszRegister);
194 if (IS_NULL_UNEXPECTEDLY(pszRegisterA))
195 goto Quit;
196 }
197
198 EnumDataA2W.lpfnEnumProc = lpfnEnumProc;
199 EnumDataA2W.lpData = lpData;
200 EnumDataA2W.ret = 0;
201 EnumDataA2W.uCodePage = pImeDpi->uCodePage;
202 pImeDpi->ImeEnumRegisterWord(Imm32EnumWordProcA2W, pszReadingA, dwStyle,
203 pszRegisterA, &EnumDataA2W);
204 ret = EnumDataA2W.ret;
205
206Quit:
207 ImmLocalFree(pszReadingA);
208 ImmLocalFree(pszRegisterA);
209 ImmUnlockImeDpi(pImeDpi);
210 TRACE("ret: %u\n", ret);
211 return ret;
212}
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 ( _In_ HKL  hKL,
_In_ UINT  nItem,
_Out_writes_(nItem) LPSTYLEBUFA  lpStyleBuf 
)

Definition at line 218 of file regword.c.

222{
223 UINT iItem, ret = 0;
224 PIMEDPI pImeDpi;
225 LPSTYLEBUFA pDestA;
226 LPSTYLEBUFW pSrcW, pNewStylesW = NULL;
227 size_t cchW;
228 INT cchA;
229
230 TRACE("(%p, %u, %p)\n", hKL, nItem, lpStyleBuf);
231
232 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
233 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
234 return 0;
235
236 if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
237 {
238 ret = pImeDpi->ImeGetRegisterWordStyle(nItem, lpStyleBuf);
239 goto Quit;
240 }
241
242 if (nItem > 0)
243 {
244 pNewStylesW = ImmLocalAlloc(0, nItem * sizeof(STYLEBUFW));
245 if (IS_NULL_UNEXPECTEDLY(pNewStylesW))
246 goto Quit;
247 }
248
249 ret = pImeDpi->ImeGetRegisterWordStyle(nItem, pNewStylesW);
250
251 if (nItem > 0)
252 {
253 /* lpStyleBuf <-- pNewStylesW */
254 for (iItem = 0; iItem < ret; ++iItem)
255 {
256 pSrcW = &pNewStylesW[iItem];
257 pDestA = &lpStyleBuf[iItem];
258 pDestA->dwStyle = pSrcW->dwStyle;
259 StringCchLengthW(pSrcW->szDescription, _countof(pSrcW->szDescription), &cchW);
260 cchA = WideCharToMultiByte(pImeDpi->uCodePage, MB_PRECOMPOSED,
261 pSrcW->szDescription, (INT)cchW,
262 pDestA->szDescription, _countof(pDestA->szDescription),
263 NULL, NULL);
264 if (cchA > _countof(pDestA->szDescription) - 1)
265 cchA = _countof(pDestA->szDescription) - 1;
266 pDestA->szDescription[cchA] = ANSI_NULL;
267 }
268 }
269
270Quit:
271 ImmLocalFree(pNewStylesW);
272 ImmUnlockImeDpi(pImeDpi);
273 TRACE("ret: %u\n", ret);
274 return ret;
275}
WideCharToMultiByte
#define WideCharToMultiByte
Definition: compat.h:111
ANSI_NULL
#define ANSI_NULL
_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
ImmLocalAlloc
LPVOID ImmLocalAlloc(_In_ DWORD dwFlags, _In_ DWORD dwBytes)
Definition: utils.c:275
MB_PRECOMPOSED
#define MB_PRECOMPOSED
Definition: winnls.h:299

Referenced by ActiveIMMApp_GetRegisterWordStyleA().

◆ ImmGetRegisterWordStyleW()

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

Definition at line 281 of file regword.c.

285{
286 UINT iItem, ret = 0;
287 PIMEDPI pImeDpi;
288 LPSTYLEBUFA pSrcA, pNewStylesA = NULL;
289 LPSTYLEBUFW pDestW;
290 size_t cchA;
291 INT cchW;
292
293 TRACE("(%p, %u, %p)\n", hKL, nItem, lpStyleBuf);
294
295 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
296 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
297 return 0;
298
299 if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
300 {
301 ret = pImeDpi->ImeGetRegisterWordStyle(nItem, lpStyleBuf);
302 goto Quit;
303 }
304
305 if (nItem > 0)
306 {
307 pNewStylesA = ImmLocalAlloc(0, nItem * sizeof(STYLEBUFA));
308 if (IS_NULL_UNEXPECTEDLY(pNewStylesA))
309 goto Quit;
310 }
311
312 ret = pImeDpi->ImeGetRegisterWordStyle(nItem, pNewStylesA);
313
314 if (nItem > 0)
315 {
316 /* lpStyleBuf <-- pNewStylesA */
317 for (iItem = 0; iItem < ret; ++iItem)
318 {
319 pSrcA = &pNewStylesA[iItem];
320 pDestW = &lpStyleBuf[iItem];
321 pDestW->dwStyle = pSrcA->dwStyle;
322 StringCchLengthA(pSrcA->szDescription, _countof(pSrcA->szDescription), &cchA);
323 cchW = MultiByteToWideChar(pImeDpi->uCodePage, MB_PRECOMPOSED,
324 pSrcA->szDescription, (INT)cchA,
325 pDestW->szDescription, _countof(pDestW->szDescription));
326 if (cchW > _countof(pDestW->szDescription) - 1)
327 cchW = _countof(pDestW->szDescription) - 1;
328 pDestW->szDescription[cchW] = UNICODE_NULL;
329 }
330 }
331
332Quit:
333 ImmLocalFree(pNewStylesA);
334 ImmUnlockImeDpi(pImeDpi);
335 TRACE("ret: %u\n", ret);
336 return ret;
337}
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110
UNICODE_NULL
#define UNICODE_NULL
StringCchLengthA
STRSAFEAPI StringCchLengthA(STRSAFE_LPCSTR psz, size_t cchMax, size_t *pcchLength)
Definition: strsafe.h:832

Referenced by ActiveIMMApp_GetRegisterWordStyleW().

◆ ImmRegisterWordA()

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

Definition at line 343 of file regword.c.

348{
349 BOOL ret = FALSE;
350 PIMEDPI pImeDpi;
351 LPWSTR pszReadingW = NULL, pszRegisterW = NULL;
352
353 TRACE("(%p, %s, 0x%lX, %s)\n", hKL, debugstr_a(lpszReading), dwStyle, debugstr_a(lpszRegister));
354
355 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
356 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
357 return FALSE;
358
359 if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
360 {
361 ret = pImeDpi->ImeRegisterWord(lpszReading, dwStyle, lpszRegister);
362 ImmUnlockImeDpi(pImeDpi);
363 return ret;
364 }
365
366 if (lpszReading)
367 {
368 pszReadingW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszReading);
369 if (IS_NULL_UNEXPECTEDLY(pszReadingW))
370 goto Quit;
371 }
372
373 if (lpszRegister)
374 {
375 pszRegisterW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszRegister);
376 if (IS_NULL_UNEXPECTEDLY(pszRegisterW))
377 goto Quit;
378 }
379
380 ret = pImeDpi->ImeRegisterWord(pszReadingW, dwStyle, pszRegisterW);
381
382Quit:
383 ImmLocalFree(pszReadingW);
384 ImmLocalFree(pszRegisterW);
385 ImmUnlockImeDpi(pImeDpi);
386 TRACE("ret: %d\n", ret);
387 return ret;
388}
FALSE
#define FALSE
Definition: types.h:117
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94

Referenced by ActiveIMMApp_RegisterWordA().

◆ ImmRegisterWordW()

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

Definition at line 394 of file regword.c.

399{
400 BOOL ret = FALSE;
401 PIMEDPI pImeDpi;
402 LPSTR pszReadingA = NULL, pszRegisterA = NULL;
403
404 TRACE("(%p, %s, 0x%lX, %s)\n", hKL, debugstr_w(lpszReading), dwStyle,
405 debugstr_w(lpszRegister));
406
407 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
408 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
409 return FALSE;
410
411 if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
412 {
413 ret = pImeDpi->ImeRegisterWord(lpszReading, dwStyle, lpszRegister);
414 ImmUnlockImeDpi(pImeDpi);
415 return ret;
416 }
417
418 if (lpszReading)
419 {
420 pszReadingA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszReading);
421 if (IS_NULL_UNEXPECTEDLY(pszReadingA))
422 goto Quit;
423 }
424
425 if (lpszRegister)
426 {
427 pszRegisterA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszRegister);
428 if (IS_NULL_UNEXPECTEDLY(pszRegisterA))
429 goto Quit;
430 }
431
432 ret = pImeDpi->ImeRegisterWord(pszReadingA, dwStyle, pszRegisterA);
433
434Quit:
435 ImmLocalFree(pszReadingA);
436 ImmLocalFree(pszRegisterA);
437 ImmUnlockImeDpi(pImeDpi);
438 TRACE("ret: %d\n", ret);
439 return ret;
440}

Referenced by ActiveIMMApp_RegisterWordW().

◆ ImmUnregisterWordA()

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

Definition at line 446 of file regword.c.

451{
452 BOOL ret = FALSE;
453 PIMEDPI pImeDpi;
454 LPWSTR pszReadingW = NULL, pszUnregisterW = NULL;
455
456 TRACE("(%p, %s, 0x%lX, %s)\n", hKL, debugstr_a(lpszReading), dwStyle,
457 debugstr_a(lpszUnregister));
458
459 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
460 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
461 return FALSE;
462
463 if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
464 {
465 ret = pImeDpi->ImeUnregisterWord(lpszReading, dwStyle, lpszUnregister);
466 ImmUnlockImeDpi(pImeDpi);
467 return ret;
468 }
469
470 if (lpszReading)
471 {
472 pszReadingW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszReading);
473 if (IS_NULL_UNEXPECTEDLY(pszReadingW))
474 goto Quit;
475 }
476
477 if (lpszUnregister)
478 {
479 pszUnregisterW = Imm32WideFromAnsi(pImeDpi->uCodePage, lpszUnregister);
480 if (IS_NULL_UNEXPECTEDLY(pszUnregisterW))
481 goto Quit;
482 }
483
484 ret = pImeDpi->ImeUnregisterWord(pszReadingW, dwStyle, pszUnregisterW);
485
486Quit:
487 ImmLocalFree(pszReadingW);
488 ImmLocalFree(pszUnregisterW);
489 ImmUnlockImeDpi(pImeDpi);
490 TRACE("ret: %d\n", ret);
491 return ret;
492}

Referenced by ActiveIMMApp_UnregisterWordA().

◆ ImmUnregisterWordW()

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

Definition at line 498 of file regword.c.

503{
504 BOOL ret = FALSE;
505 PIMEDPI pImeDpi;
506 LPSTR pszReadingA = NULL, pszUnregisterA = NULL;
507
508 TRACE("(%p, %s, 0x%lX, %s)\n", hKL, debugstr_w(lpszReading), dwStyle,
509 debugstr_w(lpszUnregister));
510
511 pImeDpi = Imm32FindOrLoadImeDpi(hKL);
512 if (IS_NULL_UNEXPECTEDLY(pImeDpi))
513 return FALSE;
514
515 if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
516 {
517 ret = pImeDpi->ImeUnregisterWord(lpszReading, dwStyle, lpszUnregister);
518 ImmUnlockImeDpi(pImeDpi);
519 return ret;
520 }
521
522 if (lpszReading)
523 {
524 pszReadingA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszReading);
525 if (IS_NULL_UNEXPECTEDLY(pszReadingA))
526 goto Quit;
527 }
528
529 if (lpszUnregister)
530 {
531 pszUnregisterA = Imm32AnsiFromWide(pImeDpi->uCodePage, lpszUnregister);
532 if (IS_NULL_UNEXPECTEDLY(pszUnregisterA))
533 goto Quit;
534 }
535
536 ret = pImeDpi->ImeUnregisterWord(pszReadingA, dwStyle, pszUnregisterA);
537
538Quit:
539 ImmLocalFree(pszReadingA);
540 ImmLocalFree(pszUnregisterA);
541 ImmUnlockImeDpi(pImeDpi);
542 TRACE("ret: %d\n", ret);
543 return ret;
544}

Referenced by ActiveIMMApp_UnregisterWordW().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( imm  )