ReactOS 0.4.15-dev-7906-g1b85a5f
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
11
12typedef struct ENUM_WORD_A2W
13{
19
20typedef struct ENUM_WORD_W2A
21{
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 */
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, 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}
147
148/***********************************************************************
149 * ImmEnumRegisterWordW (IMM32.@)
150 */
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, 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}
205
206/***********************************************************************
207 * ImmGetRegisterWordStyleA (IMM32.@)
208 */
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;
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 */
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;
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 */
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, 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}
370
371/***********************************************************************
372 * ImmRegisterWordW (IMM32.@)
373 */
375ImmRegisterWordW(HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister)
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}
418
419/***********************************************************************
420 * ImmUnregisterWordA (IMM32.@)
421 */
423ImmUnregisterWordA(HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszUnregister)
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}
466
467/***********************************************************************
468 * ImmUnregisterWordW (IMM32.@)
469 */
471ImmUnregisterWordW(HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszUnregister)
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}
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define NULL
Definition: types.h:112
#define FALSE
Definition: types.h:117
#define CALLBACK
Definition: compat.h:35
#define WideCharToMultiByte
Definition: compat.h:111
#define MultiByteToWideChar
Definition: compat.h:110
VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi)
Definition: ime.c:1007
PIMEDPI APIENTRY Imm32FindOrLoadImeDpi(HKL hKL)
Definition: ime.c:343
LPSTR APIENTRY Imm32AnsiFromWide(UINT uCodePage, LPCWSTR pszW)
Definition: utils.c:238
LPVOID APIENTRY ImmLocalAlloc(DWORD dwFlags, DWORD dwBytes)
Definition: utils.c:415
#define ImmLocalFree(lpData)
Definition: precomp.h:89
#define IS_NULL_UNEXPECTEDLY(p)
Definition: precomp.h:125
#define ImeDpi_IsUnicode(pImeDpi)
Definition: precomp.h:150
LPWSTR APIENTRY Imm32WideFromAnsi(UINT uCodePage, LPCSTR pszA)
Definition: utils.c:227
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
INT(CALLBACK * REGISTERWORDENUMPROCA)(_In_ LPCSTR lpszReading, _In_ DWORD dwStyle, _In_ LPCSTR lpszRegister, _Inout_opt_ LPVOID lpData)
Definition: imm.h:37
INT(CALLBACK * REGISTERWORDENUMPROCW)(_In_ LPCWSTR lpszReading, _In_ DWORD dwStyle, _In_ LPCWSTR lpszRegister, _Inout_opt_ LPVOID lpData)
Definition: imm.h:43
#define debugstr_a
Definition: kernel32.h:31
#define debugstr_w
Definition: kernel32.h:32
UINT_PTR HKL
Definition: msctf.idl:143
unsigned int UINT
Definition: ndis.h:50
struct ENUM_WORD_W2A * LPENUM_WORD_W2A
UINT WINAPI ImmEnumRegisterWordW(HKL hKL, REGISTERWORDENUMPROCW lpfnEnumProc, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister, LPVOID lpData)
Definition: regword.c:152
UINT WINAPI ImmEnumRegisterWordA(HKL hKL, REGISTERWORDENUMPROCA lpfnEnumProc, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister, LPVOID lpData)
Definition: regword.c:95
static INT CALLBACK Imm32EnumWordProcW2A(LPCWSTR pszReadingW, DWORD dwStyle, LPCWSTR pszRegisterW, LPVOID lpData)
Definition: regword.c:62
BOOL WINAPI ImmRegisterWordW(HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister)
Definition: regword.c:375
BOOL WINAPI ImmUnregisterWordA(HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszUnregister)
Definition: regword.c:423
UINT WINAPI ImmGetRegisterWordStyleA(HKL hKL, UINT nItem, LPSTYLEBUFA lpStyleBuf)
Definition: regword.c:209
struct ENUM_WORD_A2W * LPENUM_WORD_A2W
BOOL WINAPI ImmRegisterWordA(HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister)
Definition: regword.c:327
BOOL WINAPI ImmUnregisterWordW(HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszUnregister)
Definition: regword.c:471
UINT WINAPI ImmGetRegisterWordStyleW(HKL hKL, UINT nItem, LPSTYLEBUFW lpStyleBuf)
Definition: regword.c:268
static INT CALLBACK Imm32EnumWordProcA2W(LPCSTR pszReadingA, DWORD dwStyle, LPCSTR pszRegisterA, LPVOID lpData)
Definition: regword.c:32
#define _countof(array)
Definition: sndvol32.h:68
#define TRACE(s)
Definition: solgame.cpp:4
STRSAFEAPI StringCchLengthA(STRSAFE_LPCSTR psz, size_t cchMax, size_t *pcchLength)
Definition: strsafe.h:832
STRSAFEAPI StringCchLengthW(STRSAFE_LPCWSTR psz, size_t cchMax, size_t *pcchLength)
Definition: strsafe.h:842
UINT uCodePage
Definition: regword.c:17
REGISTERWORDENUMPROCW lpfnEnumProc
Definition: regword.c:14
LPVOID lpData
Definition: regword.c:15
UINT ret
Definition: regword.c:16
LPVOID lpData
Definition: regword.c:23
UINT uCodePage
Definition: regword.c:25
REGISTERWORDENUMPROCA lpfnEnumProc
Definition: regword.c:22
UINT ret
Definition: regword.c:24
UINT uCodePage
Definition: imm32_undoc.h:64
CHAR szDescription[STYLE_DESCRIPTION_SIZE]
Definition: imm.h:70
DWORD dwStyle
Definition: imm.h:69
WCHAR szDescription[STYLE_DESCRIPTION_SIZE]
Definition: imm.h:75
DWORD dwStyle
Definition: imm.h:74
int32_t INT
Definition: typedefs.h:58
int ret
#define WINAPI
Definition: msvc.h:6
#define MB_PRECOMPOSED
Definition: winnls.h:281
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185