ReactOS 0.4.16-dev-1025-gd3456f5
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(HKL hKL, REGISTERWORDENUMPROCA lpfnEnumProc,
96 LPCSTR lpszReading, DWORD dwStyle,
97 LPCSTR lpszRegister, LPVOID lpData)
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}
147
148/***********************************************************************
149 * ImmEnumRegisterWordW (IMM32.@)
150 */
151UINT WINAPI
152ImmEnumRegisterWordW(HKL hKL, REGISTERWORDENUMPROCW lpfnEnumProc,
153 LPCWSTR lpszReading, DWORD dwStyle,
154 LPCWSTR lpszRegister, LPVOID lpData)
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}
205
206/***********************************************************************
207 * ImmGetRegisterWordStyleA (IMM32.@)
208 */
209UINT WINAPI ImmGetRegisterWordStyleA(HKL hKL, UINT nItem, LPSTYLEBUFA lpStyleBuf)
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}
264
265/***********************************************************************
266 * ImmGetRegisterWordStyleW (IMM32.@)
267 */
268UINT WINAPI ImmGetRegisterWordStyleW(HKL hKL, UINT nItem, LPSTYLEBUFW lpStyleBuf)
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}
322
323/***********************************************************************
324 * ImmRegisterWordA (IMM32.@)
325 */
326BOOL WINAPI
327ImmRegisterWordA(HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister)
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}
369
370/***********************************************************************
371 * ImmRegisterWordW (IMM32.@)
372 */
373BOOL WINAPI
374ImmRegisterWordW(HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister)
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}
416
417/***********************************************************************
418 * ImmUnregisterWordA (IMM32.@)
419 */
420BOOL WINAPI
421ImmUnregisterWordA(HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszUnregister)
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}
463
464/***********************************************************************
465 * ImmUnregisterWordW (IMM32.@)
466 */
467BOOL WINAPI
468ImmUnregisterWordW(HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszUnregister)
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}
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
IS_NULL_UNEXPECTEDLY
#define IS_NULL_UNEXPECTEDLY(p)
Definition: debug.h:84
ImmUnlockImeDpi
VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi)
Definition: ime.c:1007
Imm32FindOrLoadImeDpi
PIMEDPI APIENTRY Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:343
Imm32AnsiFromWide
LPSTR APIENTRY Imm32AnsiFromWide(UINT uCodePage, LPCWSTR pszW)
Definition: utils.c:238
ImmLocalAlloc
LPVOID APIENTRY ImmLocalAlloc(DWORD dwFlags, DWORD dwBytes)
Definition: utils.c:415
ImmLocalFree
#define ImmLocalFree(lpData)
Definition: precomp.h:88
ImeDpi_IsUnicode
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:102
Imm32WideFromAnsi
LPWSTR APIENTRY Imm32WideFromAnsi(UINT uCodePage, LPCSTR pszA)
Definition: utils.c:227
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
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
HKL
UINT_PTR HKL
Definition: msctf.idl:143
UINT
unsigned int UINT
Definition: ndis.h:50
LPENUM_WORD_W2A
struct ENUM_WORD_W2A * LPENUM_WORD_W2A
ImmEnumRegisterWordW
UINT WINAPI ImmEnumRegisterWordW(HKL hKL, REGISTERWORDENUMPROCW lpfnEnumProc, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister, LPVOID lpData)
Definition: regword.c:152
ImmEnumRegisterWordA
UINT WINAPI ImmEnumRegisterWordA(HKL hKL, REGISTERWORDENUMPROCA lpfnEnumProc, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister, LPVOID lpData)
Definition: regword.c:95
Imm32EnumWordProcW2A
static INT CALLBACK Imm32EnumWordProcW2A(LPCWSTR pszReadingW, DWORD dwStyle, LPCWSTR pszRegisterW, LPVOID lpData)
Definition: regword.c:62
ImmRegisterWordW
BOOL WINAPI ImmRegisterWordW(HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister)
Definition: regword.c:374
ImmUnregisterWordA
BOOL WINAPI ImmUnregisterWordA(HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszUnregister)
Definition: regword.c:421
ImmGetRegisterWordStyleA
UINT WINAPI ImmGetRegisterWordStyleA(HKL hKL, UINT nItem, LPSTYLEBUFA lpStyleBuf)
Definition: regword.c:209
LPENUM_WORD_A2W
struct ENUM_WORD_A2W * LPENUM_WORD_A2W
ImmRegisterWordA
BOOL WINAPI ImmRegisterWordA(HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister)
Definition: regword.c:327
ImmUnregisterWordW
BOOL WINAPI ImmUnregisterWordW(HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszUnregister)
Definition: regword.c:468
ImmGetRegisterWordStyleW
UINT WINAPI ImmGetRegisterWordStyleW(HKL hKL, UINT nItem, LPSTYLEBUFW lpStyleBuf)
Definition: regword.c:268
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:68
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
WINAPI
#define WINAPI
Definition: msvc.h:6
MB_PRECOMPOSED
#define MB_PRECOMPOSED
Definition: winnls.h:283
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