ReactOS 0.4.16-dev-1273-g5b94656
regword.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS IMM32
3 * LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
4 * PURPOSE: Implementing IMM32 registering/unregistering words
5 * COPYRIGHT: Copyright 2020-2021 Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
6 */
7
8#include "precomp.h"
9
10WINE_DEFAULT_DEBUG_CHANNEL(imm);
11
12typedef struct ENUM_WORD_A2W
13{
14 REGISTERWORDENUMPROCW lpfnEnumProc;
15 LPVOID lpData;
16 UINT ret;
17 UINT uCodePage;
18} ENUM_WORD_A2W, *LPENUM_WORD_A2W;
19
20typedef struct ENUM_WORD_W2A
21{
22 REGISTERWORDENUMPROCA lpfnEnumProc;
23 LPVOID lpData;
24 UINT ret;
25 UINT uCodePage;
26} ENUM_WORD_W2A, *LPENUM_WORD_W2A;
27
28/*
29 * These functions absorb the difference between Ansi and Wide.
30 */
31static INT CALLBACK
32Imm32EnumWordProcA2W(LPCSTR pszReadingA, DWORD dwStyle, LPCSTR pszRegisterA, LPVOID lpData)
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}
60
61static INT CALLBACK
62Imm32EnumWordProcW2A(LPCWSTR pszReadingW, DWORD dwStyle, LPCWSTR pszRegisterW, LPVOID lpData)
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}
90
91/***********************************************************************
92 * ImmEnumRegisterWordA (IMM32.@)
93 */
94UINT WINAPI
95ImmEnumRegisterWordA(
96 _In_ HKL hKL,
97 _In_ REGISTERWORDENUMPROCA lpfnEnumProc,
98 _In_opt_ LPCSTR lpszReading,
99 _In_ DWORD dwStyle,
100 _In_opt_ LPCSTR lpszRegister,
101 _Inout_opt_ LPVOID lpData)
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}
151
152/***********************************************************************
153 * ImmEnumRegisterWordW (IMM32.@)
154 */
155UINT WINAPI
156ImmEnumRegisterWordW(
157 _In_ HKL hKL,
158 _In_ REGISTERWORDENUMPROCW lpfnEnumProc,
159 _In_opt_ LPCWSTR lpszReading,
160 _In_ DWORD dwStyle,
161 _In_opt_ LPCWSTR lpszRegister,
162 _Inout_opt_ LPVOID lpData)
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}
213
214/***********************************************************************
215 * ImmGetRegisterWordStyleA (IMM32.@)
216 */
217UINT WINAPI
218ImmGetRegisterWordStyleA(
219 _In_ HKL hKL,
220 _In_ UINT nItem,
221 _Out_writes_(nItem) LPSTYLEBUFA lpStyleBuf)
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] = 0;
267 }
268 }
269
270Quit:
271 ImmLocalFree(pNewStylesW);
272 ImmUnlockImeDpi(pImeDpi);
273 TRACE("ret: %u\n", ret);
274 return ret;
275}
276
277/***********************************************************************
278 * ImmGetRegisterWordStyleW (IMM32.@)
279 */
280UINT WINAPI
281ImmGetRegisterWordStyleW(
282 _In_ HKL hKL,
283 _In_ UINT nItem,
284 _Out_writes_(nItem) LPSTYLEBUFW lpStyleBuf)
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] = 0;
329 }
330 }
331
332Quit:
333 ImmLocalFree(pNewStylesA);
334 ImmUnlockImeDpi(pImeDpi);
335 TRACE("ret: %u\n", ret);
336 return ret;
337}
338
339/***********************************************************************
340 * ImmRegisterWordA (IMM32.@)
341 */
342BOOL WINAPI
343ImmRegisterWordA(
344 _In_ HKL hKL,
345 _In_opt_ LPCSTR lpszReading,
346 _In_ DWORD dwStyle,
347 _In_opt_ LPCSTR lpszRegister)
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}
389
390/***********************************************************************
391 * ImmRegisterWordW (IMM32.@)
392 */
393BOOL WINAPI
394ImmRegisterWordW(
395 _In_ HKL hKL,
396 _In_opt_ LPCWSTR lpszReading,
397 _In_ DWORD dwStyle,
398 _In_opt_ LPCWSTR lpszRegister)
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}
441
442/***********************************************************************
443 * ImmUnregisterWordA (IMM32.@)
444 */
445BOOL WINAPI
446ImmUnregisterWordA(
447 _In_ HKL hKL,
448 _In_opt_ LPCSTR lpszReading,
449 _In_ DWORD dwStyle,
450 _In_opt_ LPCSTR lpszUnregister)
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}
493
494/***********************************************************************
495 * ImmUnregisterWordW (IMM32.@)
496 */
497BOOL WINAPI
498ImmUnregisterWordW(
499 _In_ HKL hKL,
500 _In_opt_ LPCWSTR lpszReading,
501 _In_ DWORD dwStyle,
502 _In_opt_ LPCWSTR lpszUnregister)
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}
WINE_DEFAULT_DEBUG_CHANNEL
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
NULL
#define NULL
Definition: types.h:112
FALSE
#define FALSE
Definition: types.h:117
CALLBACK
#define CALLBACK
Definition: compat.h:35
WideCharToMultiByte
#define WideCharToMultiByte
Definition: compat.h:111
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
Imm32FindOrLoadImeDpi
PIMEDPI Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:350
ImmUnlockImeDpi
VOID WINAPI ImmUnlockImeDpi(_Inout_opt_ PIMEDPI pImeDpi)
Definition: ime.c:561
REGISTERWORDENUMPROCA
INT(CALLBACK * REGISTERWORDENUMPROCA)(_In_ LPCSTR lpszReading, _In_ DWORD dwStyle, _In_ LPCSTR lpszRegister, _Inout_opt_ LPVOID lpData)
Definition: imm.h:37
REGISTERWORDENUMPROCW
INT(CALLBACK * REGISTERWORDENUMPROCW)(_In_ LPCWSTR lpszReading, _In_ DWORD dwStyle, _In_ LPCWSTR lpszRegister, _Inout_opt_ LPVOID lpData)
Definition: imm.h:43
debugstr_a
#define debugstr_a
Definition: kernel32.h:31
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
HKL
UINT_PTR HKL
Definition: msctf.idl:125
UINT
unsigned int UINT
Definition: ndis.h:50
_Inout_opt_
#define _Inout_opt_
Definition: no_sal2.h:216
_Out_writes_
#define _Out_writes_(s)
Definition: no_sal2.h:176
_In_
#define _In_
Definition: no_sal2.h:158
_In_opt_
#define _In_opt_
Definition: no_sal2.h:212
LPENUM_WORD_W2A
struct ENUM_WORD_W2A * LPENUM_WORD_W2A
ImmUnregisterWordA
BOOL WINAPI ImmUnregisterWordA(_In_ HKL hKL, _In_opt_ LPCSTR lpszReading, _In_ DWORD dwStyle, _In_opt_ LPCSTR lpszUnregister)
Definition: regword.c:446
Imm32EnumWordProcW2A
static INT CALLBACK Imm32EnumWordProcW2A(LPCWSTR pszReadingW, DWORD dwStyle, LPCWSTR pszRegisterW, LPVOID lpData)
Definition: regword.c:62
ImmGetRegisterWordStyleW
UINT WINAPI ImmGetRegisterWordStyleW(_In_ HKL hKL, _In_ UINT nItem, _Out_writes_(nItem) LPSTYLEBUFW lpStyleBuf)
Definition: regword.c:281
ImmUnregisterWordW
BOOL WINAPI ImmUnregisterWordW(_In_ HKL hKL, _In_opt_ LPCWSTR lpszReading, _In_ DWORD dwStyle, _In_opt_ LPCWSTR lpszUnregister)
Definition: regword.c:498
LPENUM_WORD_A2W
struct ENUM_WORD_A2W * LPENUM_WORD_A2W
ImmGetRegisterWordStyleA
UINT WINAPI ImmGetRegisterWordStyleA(_In_ HKL hKL, _In_ UINT nItem, _Out_writes_(nItem) LPSTYLEBUFA lpStyleBuf)
Definition: regword.c:218
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: regword.c:95
ImmRegisterWordA
BOOL WINAPI ImmRegisterWordA(_In_ HKL hKL, _In_opt_ LPCSTR lpszReading, _In_ DWORD dwStyle, _In_opt_ LPCSTR lpszRegister)
Definition: regword.c:343
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: regword.c:156
ImmRegisterWordW
BOOL WINAPI ImmRegisterWordW(_In_ HKL hKL, _In_opt_ LPCWSTR lpszReading, _In_ DWORD dwStyle, _In_opt_ LPCWSTR lpszRegister)
Definition: regword.c:394
Imm32EnumWordProcA2W
static INT CALLBACK Imm32EnumWordProcA2W(LPCSTR pszReadingA, DWORD dwStyle, LPCSTR pszRegisterA, LPVOID lpData)
Definition: regword.c:32
_countof
#define _countof(array)
Definition: sndvol32.h:70
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
StringCchLengthA
STRSAFEAPI StringCchLengthA(STRSAFE_LPCSTR psz, size_t cchMax, size_t *pcchLength)
Definition: strsafe.h:832
StringCchLengthW
STRSAFEAPI StringCchLengthW(STRSAFE_LPCWSTR psz, size_t cchMax, size_t *pcchLength)
Definition: strsafe.h:842
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
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
IMEDPI::uCodePage
UINT uCodePage
Definition: imm32_undoc.h:95
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
INT
int32_t INT
Definition: typedefs.h:58
ret
int ret
Definition: wcstombs-tests.c:31
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
Imm32AnsiFromWide
LPSTR Imm32AnsiFromWide(UINT uCodePage, LPCWSTR pszW)
Definition: utils.c:107
ImmLocalAlloc
LPVOID ImmLocalAlloc(_In_ DWORD dwFlags, _In_ DWORD dwBytes)
Definition: utils.c:275
ImeDpi_IsUnicode
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:120
WINAPI
#define WINAPI
Definition: msvc.h:6
MB_PRECOMPOSED
#define MB_PRECOMPOSED
Definition: winnls.h:299
LPCSTR
const char * LPCSTR
Definition: xmlstorage.h:183
LPSTR
char * LPSTR
Definition: xmlstorage.h:182
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
LPCWSTR
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185