?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
janitorial: Pass HEAP_ZERO_MEMORY as flag to HeapAlloc() instead of zeroing out the...
[wine/wine-kai.git] / dlls / imm32 / imm.c
blobbc3f7a9f10a45bc86a9eadd0e7c5e6f0ce631125
1 /*
2 * IMM32 library
3 *
4 * Copyright 1998 Patrik Stridvall
5 * Copyright 2002, 2003 CodeWeavers, Aric Stewart
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdarg.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "wingdi.h"
27 #include "winuser.h"
28 #include "winerror.h"
29 #include "wine/debug.h"
30 #include "imm.h"
31 #include "winnls.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(imm);
34
35 #define FROM_IME 0xcafe1337
36
37 static void (*pX11DRV_ForceXIMReset)(HWND);
38
39 typedef struct tagInputContextData
40 {
41 LPBYTE CompositionString;
42 LPBYTE CompositionReadingString;
43 LPBYTE ResultString;
44 LPBYTE ResultReadingString;
45 DWORD dwCompStringSize; /* buffer size */
46 DWORD dwCompStringLength; /* string length (in bytes) */
47 DWORD dwCompReadStringSize;
48 DWORD dwResultStringSize;
49 DWORD dwResultReadStringSize;
50 HWND hwnd;
51 BOOL bOpen;
52 BOOL bInternalState;
53 BOOL bRead;
54 BOOL bInComposition;
55 LOGFONTW font;
56 HFONT textfont;
57 COMPOSITIONFORM CompForm;
58 } InputContextData;
59
60 static InputContextData *root_context = NULL;
61 static HWND hwndDefault = NULL;
62 static HANDLE hImeInst;
63 static const WCHAR WC_IMECLASSNAME[] = {'I','M','E',0};
64 static ATOM atIMEClass = 0;
65
66 /* MSIME messages */
67 static UINT WM_MSIME_SERVICE;
68 static UINT WM_MSIME_RECONVERTOPTIONS;
69 static UINT WM_MSIME_MOUSE;
70 static UINT WM_MSIME_RECONVERTREQUEST;
71 static UINT WM_MSIME_RECONVERT;
72 static UINT WM_MSIME_QUERYPOSITION;
73 static UINT WM_MSIME_DOCUMENTFEED;
74
75 /*
76 * prototypes
77 */
78 static LRESULT WINAPI IME_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam,
79 LPARAM lParam);
80 static void UpdateDataInDefaultIMEWindow(HWND hwnd);
81 static void ImmInternalPostIMEMessage(UINT, WPARAM, LPARAM);
82 static void ImmInternalSetOpenStatus(BOOL fOpen);
83
84 static VOID IMM_PostResult(InputContextData *data)
85 {
86 unsigned int i;
87 TRACE("Posting result as IME_CHAR\n");
88
89 for (i = 0; i < data->dwResultStringSize / sizeof (WCHAR); i++)
90 ImmInternalPostIMEMessage (WM_IME_CHAR, ((WCHAR*)data->ResultString)[i],
91 1);
92
93 /* clear the buffer */
94 if (data->dwResultStringSize)
95 HeapFree(GetProcessHeap(),0,data->ResultString);
96 data->dwResultStringSize = 0;
97 data->ResultString = NULL;
98 }
99
100 static void IMM_Register(void)
101 {
102 WNDCLASSW wndClass;
103 ZeroMemory(&wndClass, sizeof(WNDCLASSW));
104 wndClass.style = CS_GLOBALCLASS | CS_IME | CS_HREDRAW | CS_VREDRAW;
105 wndClass.lpfnWndProc = (WNDPROC) IME_WindowProc;
106 wndClass.cbClsExtra = 0;
107 wndClass.cbWndExtra = 0;
108 wndClass.hInstance = hImeInst;
109 wndClass.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
110 wndClass.hIcon = NULL;
111 wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW +1);
112 wndClass.lpszMenuName = 0;
113 wndClass.lpszClassName = WC_IMECLASSNAME;
114 atIMEClass = RegisterClassW(&wndClass);
115 }
116
117 static void IMM_Unregister(void)
118 {
119 if (atIMEClass) {
120 UnregisterClassW(WC_IMECLASSNAME, NULL);
121 }
122 }
123
124 static void IMM_RegisterMessages(void)
125 {
126 WM_MSIME_SERVICE = RegisterWindowMessageA("MSIMEService");
127 WM_MSIME_RECONVERTOPTIONS = RegisterWindowMessageA("MSIMEReconvertOptions");
128 WM_MSIME_MOUSE = RegisterWindowMessageA("MSIMEMouseOperation");
129 WM_MSIME_RECONVERTREQUEST = RegisterWindowMessageA("MSIMEReconvertRequest");
130 WM_MSIME_RECONVERT = RegisterWindowMessageA("MSIMEReconvert");
131 WM_MSIME_QUERYPOSITION = RegisterWindowMessageA("MSIMEQueryPosition");
132 WM_MSIME_DOCUMENTFEED = RegisterWindowMessageA("MSIMEDocumentFeed");
133 }
134
135
136 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpReserved)
137 {
138 HMODULE x11drv;
139
140 TRACE("%p, %x, %p\n",hInstDLL,fdwReason,lpReserved);
141 switch (fdwReason)
142 {
143 case DLL_PROCESS_ATTACH:
144 DisableThreadLibraryCalls(hInstDLL);
145 hImeInst = hInstDLL;
146 IMM_RegisterMessages();
147 x11drv = GetModuleHandleA("winex11.drv");
148 if (x11drv) pX11DRV_ForceXIMReset = (void *)GetProcAddress( x11drv, "ForceXIMReset");
149 break;
150 case DLL_PROCESS_DETACH:
151 if (hwndDefault)
152 {
153 DestroyWindow(hwndDefault);
154 hwndDefault = 0;
155 }
156 IMM_Unregister();
157 break;
158 }
159 return TRUE;
160 }
161
162 /* for posting messages as the IME */
163 static void ImmInternalPostIMEMessage(UINT msg, WPARAM wParam, LPARAM lParam)
164 {
165 HWND target = GetFocus();
166 if (!target)
167 PostMessageW(root_context->hwnd,msg,wParam,lParam);
168 else
169 PostMessageW(target, msg, wParam, lParam);
170 }
171
172 static LRESULT ImmInternalSendIMENotify(WPARAM notify, LPARAM lParam)
173 {
174 HWND target;
175
176 target = root_context->hwnd;
177 if (!target) target = GetFocus();
178
179 if (target)
180 return SendMessageW(target, WM_IME_NOTIFY, notify, lParam);
181
182 return 0;
183 }
184
185 static void ImmInternalSetOpenStatus(BOOL fOpen)
186 {
187 TRACE("Setting internal state to %s\n",(fOpen)?"OPEN":"CLOSED");
188
189 root_context->bOpen = fOpen;
190 root_context->bInternalState = fOpen;
191
192 if (fOpen == FALSE)
193 {
194 ShowWindow(hwndDefault,SW_HIDE);
195
196 if (root_context->dwCompStringSize)
197 HeapFree(GetProcessHeap(),0,root_context->CompositionString);
198 if (root_context->dwCompReadStringSize)
199 HeapFree(GetProcessHeap(),0,root_context->CompositionReadingString);
200 if (root_context->dwResultStringSize)
201 HeapFree(GetProcessHeap(),0,root_context->ResultString);
202 if (root_context->dwResultReadStringSize)
203 HeapFree(GetProcessHeap(),0,root_context->ResultReadingString);
204 root_context->dwCompStringSize = 0;
205 root_context->dwCompStringLength = 0;
206 root_context->CompositionString = NULL;
207 root_context->dwCompReadStringSize = 0;
208 root_context->CompositionReadingString = NULL;
209 root_context->dwResultStringSize = 0;
210 root_context->ResultString = NULL;
211 root_context->dwResultReadStringSize = 0;
212 root_context->ResultReadingString = NULL;
213 }
214 else
215 ShowWindow(hwndDefault, SW_SHOWNOACTIVATE);
216
217 ImmInternalSendIMENotify(IMN_SETOPENSTATUS, 0);
218 }
219
220
221 /***********************************************************************
222 * ImmAssociateContext (IMM32.@)
223 */
224 HIMC WINAPI ImmAssociateContext(HWND hWnd, HIMC hIMC)
225 {
226 InputContextData *data = (InputContextData*)hIMC;
227
228 WARN("(%p, %p): semi-stub\n", hWnd, hIMC);
229
230 if (!hIMC)
231 return NULL;
232
233 /*
234 * WINE SPECIFIC! MAY CONFLICT
235 * associate the root context we have an XIM created
236 */
237 if (hWnd == 0x000)
238 {
239 root_context = (InputContextData*)hIMC;
240 }
241
242 /*
243 * If already associated just return
244 */
245 if (data->hwnd == hWnd)
246 return hIMC;
247
248 if (IsWindow(data->hwnd))
249 {
250 /*
251 * Post a message that your context is switching
252 */
253 SendMessageW(data->hwnd, WM_IME_SETCONTEXT, FALSE, ISC_SHOWUIALL);
254 }
255
256 data->hwnd = hWnd;
257
258 if (IsWindow(data->hwnd))
259 {
260 /*
261 * Post a message that your context is switching
262 */
263 SendMessageW(data->hwnd, WM_IME_SETCONTEXT, TRUE, ISC_SHOWUIALL);
264 }
265
266 /*
267 * TODO: We need to keep track of the old context associated
268 * with a window and return it for now we will return NULL;
269 */
270 return NULL;
271 }
272
273 /***********************************************************************
274 * ImmAssociateContextEx (IMM32.@)
275 */
276 BOOL WINAPI ImmAssociateContextEx(HWND hWnd, HIMC hIMC, DWORD dwFlags)
277 {
278 FIXME("(%p, %p, %d): stub\n", hWnd, hIMC, dwFlags);
279 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
280 return FALSE;
281 }
282
283 /***********************************************************************
284 * ImmConfigureIMEA (IMM32.@)
285 */
286 BOOL WINAPI ImmConfigureIMEA(
287 HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
288 {
289 FIXME("(%p, %p, %d, %p): stub\n",
290 hKL, hWnd, dwMode, lpData
291 );
292 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
293 return FALSE;
294 }
295
296 /***********************************************************************
297 * ImmConfigureIMEW (IMM32.@)
298 */
299 BOOL WINAPI ImmConfigureIMEW(
300 HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
301 {
302 FIXME("(%p, %p, %d, %p): stub\n",
303 hKL, hWnd, dwMode, lpData
304 );
305 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
306 return FALSE;
307 }
308
309 /***********************************************************************
310 * ImmCreateContext (IMM32.@)
311 */
312 HIMC WINAPI ImmCreateContext(void)
313 {
314 InputContextData *new_context;
315
316 new_context = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(InputContextData));
317
318 return (HIMC)new_context;
319 }
320
321 /***********************************************************************
322 * ImmDestroyContext (IMM32.@)
323 */
324 BOOL WINAPI ImmDestroyContext(HIMC hIMC)
325 {
326 InputContextData *data = (InputContextData*)hIMC;
327
328 TRACE("Destroying %p\n",hIMC);
329
330 if (hIMC)
331 {
332 if (data->dwCompStringSize)
333 HeapFree(GetProcessHeap(),0,data->CompositionString);
334 if (data->dwCompReadStringSize)
335 HeapFree(GetProcessHeap(),0,data->CompositionReadingString);
336 if (data->dwResultStringSize)
337 HeapFree(GetProcessHeap(),0,data->ResultString);
338 if (data->dwResultReadStringSize)
339 HeapFree(GetProcessHeap(),0,data->ResultReadingString);
340
341 if (data->textfont)
342 {
343 DeleteObject(data->textfont);
344 data->textfont = NULL;
345 }
346
347 HeapFree(GetProcessHeap(),0,data);
348 }
349 return TRUE;
350 }
351
352 /***********************************************************************
353 * ImmDisableIME (IMM32.@)
354 */
355 BOOL WINAPI ImmDisableIME(DWORD idThread)
356 {
357 FIXME("(%d): stub\n", idThread);
358 return TRUE;
359 }
360
361 /***********************************************************************
362 * ImmEnumRegisterWordA (IMM32.@)
363 */
364 UINT WINAPI ImmEnumRegisterWordA(
365 HKL hKL, REGISTERWORDENUMPROCA lpfnEnumProc,
366 LPCSTR lpszReading, DWORD dwStyle,
367 LPCSTR lpszRegister, LPVOID lpData)
368 {
369 FIXME("(%p, %p, %s, %d, %s, %p): stub\n",
370 hKL, lpfnEnumProc,
371 debugstr_a(lpszReading), dwStyle,
372 debugstr_a(lpszRegister), lpData
373 );
374 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
375 return 0;
376 }
377
378 /***********************************************************************
379 * ImmEnumRegisterWordW (IMM32.@)
380 */
381 UINT WINAPI ImmEnumRegisterWordW(
382 HKL hKL, REGISTERWORDENUMPROCW lpfnEnumProc,
383 LPCWSTR lpszReading, DWORD dwStyle,
384 LPCWSTR lpszRegister, LPVOID lpData)
385 {
386 FIXME("(%p, %p, %s, %d, %s, %p): stub\n",
387 hKL, lpfnEnumProc,
388 debugstr_w(lpszReading), dwStyle,
389 debugstr_w(lpszRegister), lpData
390 );
391 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
392 return 0;
393 }
394
395 /***********************************************************************
396 * ImmEscapeA (IMM32.@)
397 */
398 LRESULT WINAPI ImmEscapeA(
399 HKL hKL, HIMC hIMC,
400 UINT uEscape, LPVOID lpData)
401 {
402 FIXME("(%p, %p, %d, %p): stub\n",
403 hKL, hIMC, uEscape, lpData
404 );
405 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
406 return 0;
407 }
408
409 /***********************************************************************
410 * ImmEscapeW (IMM32.@)
411 */
412 LRESULT WINAPI ImmEscapeW(
413 HKL hKL, HIMC hIMC,
414 UINT uEscape, LPVOID lpData)
415 {
416 FIXME("(%p, %p, %d, %p): stub\n",
417 hKL, hIMC, uEscape, lpData
418 );
419 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
420 return 0;
421 }
422
423 /***********************************************************************
424 * ImmGetCandidateListA (IMM32.@)
425 */
426 DWORD WINAPI ImmGetCandidateListA(
427 HIMC hIMC, DWORD deIndex,
428 LPCANDIDATELIST lpCandList, DWORD dwBufLen)
429 {
430 FIXME("(%p, %d, %p, %d): stub\n",
431 hIMC, deIndex,
432 lpCandList, dwBufLen
433 );
434 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
435 return 0;
436 }
437
438 /***********************************************************************
439 * ImmGetCandidateListCountA (IMM32.@)
440 */
441 DWORD WINAPI ImmGetCandidateListCountA(
442 HIMC hIMC, LPDWORD lpdwListCount)
443 {
444 FIXME("(%p, %p): stub\n", hIMC, lpdwListCount);
445 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
446 return 0;
447 }
448
449 /***********************************************************************
450 * ImmGetCandidateListCountW (IMM32.@)
451 */
452 DWORD WINAPI ImmGetCandidateListCountW(
453 HIMC hIMC, LPDWORD lpdwListCount)
454 {
455 FIXME("(%p, %p): stub\n", hIMC, lpdwListCount);
456 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
457 return 0;
458 }
459
460 /***********************************************************************
461 * ImmGetCandidateListW (IMM32.@)
462 */
463 DWORD WINAPI ImmGetCandidateListW(
464 HIMC hIMC, DWORD deIndex,
465 LPCANDIDATELIST lpCandList, DWORD dwBufLen)
466 {
467 FIXME("(%p, %d, %p, %d): stub\n",
468 hIMC, deIndex,
469 lpCandList, dwBufLen
470 );
471 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
472 return 0;
473 }
474
475 /***********************************************************************
476 * ImmGetCandidateWindow (IMM32.@)
477 */
478 BOOL WINAPI ImmGetCandidateWindow(
479 HIMC hIMC, DWORD dwBufLen, LPCANDIDATEFORM lpCandidate)
480 {
481 FIXME("(%p, %d, %p): stub\n", hIMC, dwBufLen, lpCandidate);
482 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
483 return FALSE;
484 }
485
486 /***********************************************************************
487 * ImmGetCompositionFontA (IMM32.@)
488 */
489 BOOL WINAPI ImmGetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
490 {
491 FIXME("(%p, %p): stub\n", hIMC, lplf);
492 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
493 return FALSE;
494 }
495
496 /***********************************************************************
497 * ImmGetCompositionFontW (IMM32.@)
498 */
499 BOOL WINAPI ImmGetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
500 {
501 FIXME("(%p, %p): stub\n", hIMC, lplf);
502 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
503 return FALSE;
504 }
505
506 /***********************************************************************
507 * ImmGetCompositionStringA (IMM32.@)
508 */
509 LONG WINAPI ImmGetCompositionStringA(
510 HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen)
511 {
512 CHAR *buf;
513 LONG rc = 0;
514 InputContextData *data = (InputContextData*)hIMC;
515
516 TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
517
518 if (!data)
519 return FALSE;
520
521 if (dwIndex == GCS_RESULTSTR)
522 {
523 TRACE("GSC_RESULTSTR %p %i\n",data->ResultString,
524 data->dwResultStringSize);
525
526 buf = HeapAlloc( GetProcessHeap(), 0, data->dwResultStringSize * 3 );
527 rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)data->ResultString,
528 data->dwResultStringSize / sizeof(WCHAR), buf,
529 data->dwResultStringSize * 3, NULL, NULL);
530 if (dwBufLen >= rc)
531 memcpy(lpBuf,buf,rc);
532
533 data->bRead = TRUE;
534 HeapFree( GetProcessHeap(), 0, buf );
535 }
536 else if (dwIndex == GCS_COMPSTR)
537 {
538 TRACE("GSC_COMPSTR %p %i\n", data->CompositionString, data->dwCompStringLength);
539
540 buf = HeapAlloc( GetProcessHeap(), 0, data->dwCompStringLength * 3 );
541 rc = WideCharToMultiByte(CP_ACP, 0,(LPWSTR)data->CompositionString,
542 data->dwCompStringLength/ sizeof(WCHAR), buf,
543 data->dwCompStringLength* 3, NULL, NULL);
544 if (dwBufLen >= rc)
545 memcpy(lpBuf,buf,rc);
546 HeapFree( GetProcessHeap(), 0, buf );
547 }
548 else if (dwIndex == GCS_COMPATTR)
549 {
550 TRACE("GSC_COMPATTR %p %i\n", data->CompositionString, data->dwCompStringLength);
551
552 rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)data->CompositionString,
553 data->dwCompStringLength/ sizeof(WCHAR), NULL,
554 0, NULL, NULL);
555
556 if (dwBufLen >= rc)
557 {
558 int i=0;
559 for (i = 0; i < rc; i++)
560 ((LPBYTE)lpBuf)[i] = ATTR_INPUT;
561 }
562 }
563 else if (dwIndex == GCS_COMPCLAUSE)
564 {
565 TRACE("GSC_COMPCLAUSE %p %i\n", data->CompositionString, data->dwCompStringLength);
566
567 rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)data->CompositionString,
568 data->dwCompStringLength/ sizeof(WCHAR), NULL,
569 0, NULL, NULL);
570
571 if (dwBufLen >= sizeof(DWORD)*2)
572 {
573 ((LPDWORD)lpBuf)[0] = 0;
574 ((LPDWORD)lpBuf)[1] = rc;
575 }
576 rc = sizeof(DWORD)*2;
577 }
578 else if (dwIndex == GCS_RESULTCLAUSE)
579 {
580 TRACE("GSC_RESULTCLAUSE %p %i\n", data->ResultString, data->dwResultStringSize);
581
582 rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)data->ResultString,
583 data->dwResultStringSize/ sizeof(WCHAR), NULL,
584 0, NULL, NULL);
585
586 if (dwBufLen >= sizeof(DWORD)*2)
587 {
588 ((LPDWORD)lpBuf)[0] = 0;
589 ((LPDWORD)lpBuf)[1] = rc;
590 }
591 rc = sizeof(DWORD)*2;
592 }
593 else
594 {
595 FIXME("Unhandled index 0x%x\n",dwIndex);
596 }
597
598 return rc;
599 }
600
601 /***********************************************************************
602 * ImmGetCompositionStringW (IMM32.@)
603 */
604 LONG WINAPI ImmGetCompositionStringW(
605 HIMC hIMC, DWORD dwIndex,
606 LPVOID lpBuf, DWORD dwBufLen)
607 {
608 LONG rc = 0;
609 InputContextData *data = (InputContextData*)hIMC;
610
611 TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
612
613 if (!data)
614 return FALSE;
615
616 if (dwIndex == GCS_RESULTSTR)
617 {
618 data->bRead = TRUE;
619
620 if (dwBufLen >= data->dwResultStringSize)
621 memcpy(lpBuf,data->ResultString,data->dwResultStringSize);
622
623 rc = data->dwResultStringSize;
624 }
625 else if (dwIndex == GCS_RESULTREADSTR)
626 {
627 if (dwBufLen >= data->dwResultReadStringSize)
628 memcpy(lpBuf,data->ResultReadingString,
629 data->dwResultReadStringSize);
630
631 rc = data->dwResultReadStringSize;
632 }
633 else if (dwIndex == GCS_COMPSTR)
634 {
635 if (dwBufLen >= data->dwCompStringLength)
636 memcpy(lpBuf,data->CompositionString,data->dwCompStringLength);
637
638 rc = data->dwCompStringLength;
639 }
640 else if (dwIndex == GCS_COMPATTR)
641 {
642 unsigned int len = data->dwCompStringLength;
643
644 if (dwBufLen >= len)
645 {
646 unsigned int i=0;
647 for (i = 0; i < len; i++)
648 ((LPBYTE)lpBuf)[i] = ATTR_INPUT;
649 }
650
651 rc = len;
652 }
653 else if (dwIndex == GCS_COMPCLAUSE)
654 {
655 if (dwBufLen >= sizeof(DWORD)*2)
656 {
657 ((LPDWORD)lpBuf)[0] = 0;
658 ((LPDWORD)lpBuf)[1] = data->dwCompStringLength/sizeof(WCHAR);
659 }
660 rc = sizeof(DWORD)*2;
661 }
662 else if (dwIndex == GCS_COMPREADSTR)
663 {
664 if (dwBufLen >= data->dwCompReadStringSize)
665 memcpy(lpBuf,data->CompositionReadingString,
666 data->dwCompReadStringSize);
667
668 rc = data->dwCompReadStringSize;
669 }
670 else
671 {
672 FIXME("Unhandled index 0x%x\n",dwIndex);
673 }
674
675 return rc;
676 }
677
678 /***********************************************************************
679 * ImmGetCompositionWindow (IMM32.@)
680 */
681 BOOL WINAPI ImmGetCompositionWindow(HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
682 {
683 InputContextData *data = (InputContextData*)hIMC;
684
685 TRACE("(%p, %p)\n", hIMC, lpCompForm);
686
687 if (!data)
688 return FALSE;
689
690 memcpy(lpCompForm,&(data->CompForm),sizeof(COMPOSITIONFORM));
691 return 1;
692 }
693
694 /***********************************************************************
695 * ImmGetContext (IMM32.@)
696 *
697 */
698 HIMC WINAPI ImmGetContext(HWND hWnd)
699 {
700 TRACE("%p\n", hWnd);
701
702 if (!root_context)
703 return NULL;
704
705 root_context->hwnd = hWnd;
706 return (HIMC)root_context;
707 }
708
709 /***********************************************************************
710 * ImmGetConversionListA (IMM32.@)
711 */
712 DWORD WINAPI ImmGetConversionListA(
713 HKL hKL, HIMC hIMC,
714 LPCSTR pSrc, LPCANDIDATELIST lpDst,
715 DWORD dwBufLen, UINT uFlag)
716 {
717 FIXME("(%p, %p, %s, %p, %d, %d): stub\n",
718 hKL, hIMC, debugstr_a(pSrc), lpDst, dwBufLen, uFlag
719 );
720 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
721 return 0;
722 }
723
724 /***********************************************************************
725 * ImmGetConversionListW (IMM32.@)
726 */
727 DWORD WINAPI ImmGetConversionListW(
728 HKL hKL, HIMC hIMC,
729 LPCWSTR pSrc, LPCANDIDATELIST lpDst,
730 DWORD dwBufLen, UINT uFlag)
731 {
732 FIXME("(%p, %p, %s, %p, %d, %d): stub\n",
733 hKL, hIMC, debugstr_w(pSrc), lpDst, dwBufLen, uFlag
734 );
735 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
736 return 0;
737 }
738
739 /***********************************************************************
740 * ImmGetConversionStatus (IMM32.@)
741 */
742 BOOL WINAPI ImmGetConversionStatus(
743 HIMC hIMC, LPDWORD lpfdwConversion, LPDWORD lpfdwSentence)
744 {
745 TRACE("(%p, %p, %p): best guess\n", hIMC, lpfdwConversion, lpfdwSentence);
746 if (lpfdwConversion)
747 *lpfdwConversion = IME_CMODE_NATIVE;
748 if (lpfdwSentence)
749 *lpfdwSentence = IME_SMODE_NONE;
750 return TRUE;
751 }
752
753 /***********************************************************************
754 * ImmGetDefaultIMEWnd (IMM32.@)
755 */
756 HWND WINAPI ImmGetDefaultIMEWnd(HWND hWnd)
757 {
758 FIXME("(%p - %p %p ): semi-stub\n", hWnd,hwndDefault, root_context);
759
760 if (hwndDefault == NULL)
761 {
762 static const WCHAR the_name[] = {'I','M','E','\0'};
763
764 IMM_Register();
765 hwndDefault = CreateWindowExW( WS_EX_TOOLWINDOW, WC_IMECLASSNAME,
766 the_name, WS_POPUP, 0, 0, 1, 1, 0, 0,
767 hImeInst, 0);
768
769 TRACE("Default created (%p)\n",hwndDefault);
770 }
771
772 return (HWND)hwndDefault;
773 }
774
775 /***********************************************************************
776 * ImmGetDescriptionA (IMM32.@)
777 */
778 UINT WINAPI ImmGetDescriptionA(
779 HKL hKL, LPSTR lpszDescription, UINT uBufLen)
780 {
781 WCHAR *buf;
782 DWORD len;
783
784 TRACE("%p %p %d\n", hKL, lpszDescription, uBufLen);
785
786 /* find out how many characters in the unicode buffer */
787 len = ImmGetDescriptionW( hKL, NULL, 0 );
788
789 /* allocate a buffer of that size */
790 buf = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof (WCHAR) );
791 if( !buf )
792 return 0;
793
794 /* fetch the unicode buffer */
795 len = ImmGetDescriptionW( hKL, buf, len + 1 );
796
797 /* convert it back to ASCII */
798 len = WideCharToMultiByte( CP_ACP, 0, buf, len + 1,
799 lpszDescription, uBufLen, NULL, NULL );
800
801 HeapFree( GetProcessHeap(), 0, buf );
802
803 return len;
804 }
805
806 /***********************************************************************
807 * ImmGetDescriptionW (IMM32.@)
808 */
809 UINT WINAPI ImmGetDescriptionW(HKL hKL, LPWSTR lpszDescription, UINT uBufLen)
810 {
811 static const WCHAR name[] = { 'W','i','n','e',' ','X','I','M',0 };
812
813 FIXME("(%p, %p, %d): semi stub\n", hKL, lpszDescription, uBufLen);
814
815 if (!uBufLen) return lstrlenW( name );
816 lstrcpynW( lpszDescription, name, uBufLen );
817 return lstrlenW( lpszDescription );
818 }
819
820 /***********************************************************************
821 * ImmGetGuideLineA (IMM32.@)
822 */
823 DWORD WINAPI ImmGetGuideLineA(
824 HIMC hIMC, DWORD dwIndex, LPSTR lpBuf, DWORD dwBufLen)
825 {
826 FIXME("(%p, %d, %s, %d): stub\n",
827 hIMC, dwIndex, debugstr_a(lpBuf), dwBufLen
828 );
829 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
830 return 0;
831 }
832
833 /***********************************************************************
834 * ImmGetGuideLineW (IMM32.@)
835 */
836 DWORD WINAPI ImmGetGuideLineW(HIMC hIMC, DWORD dwIndex, LPWSTR lpBuf, DWORD dwBufLen)
837 {
838 FIXME("(%p, %d, %s, %d): stub\n",
839 hIMC, dwIndex, debugstr_w(lpBuf), dwBufLen
840 );
841 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
842 return 0;
843 }
844
845 /***********************************************************************
846 * ImmGetIMEFileNameA (IMM32.@)
847 */
848 UINT WINAPI ImmGetIMEFileNameA(
849 HKL hKL, LPSTR lpszFileName, UINT uBufLen)
850 {
851 FIXME("(%p, %p, %d): stub\n", hKL, lpszFileName, uBufLen);
852 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
853 return 0;
854 }
855
856 /***********************************************************************
857 * ImmGetIMEFileNameW (IMM32.@)
858 */
859 UINT WINAPI ImmGetIMEFileNameW(
860 HKL hKL, LPWSTR lpszFileName, UINT uBufLen)
861 {
862 FIXME("(%p, %p, %d): stub\n", hKL, lpszFileName, uBufLen);
863 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
864 return 0;
865 }
866
867 /***********************************************************************
868 * ImmGetOpenStatus (IMM32.@)
869 */
870 BOOL WINAPI ImmGetOpenStatus(HIMC hIMC)
871 {
872 InputContextData *data = (InputContextData*)hIMC;
873
874 if (!data)
875 return FALSE;
876 FIXME("(%p): semi-stub\n", hIMC);
877
878 return data->bOpen;
879 }
880
881 /***********************************************************************
882 * ImmGetProperty (IMM32.@)
883 */
884 DWORD WINAPI ImmGetProperty(HKL hKL, DWORD fdwIndex)
885 {
886 DWORD rc = 0;
887 TRACE("(%p, %d)\n", hKL, fdwIndex);
888
889 switch (fdwIndex)
890 {
891 case IGP_PROPERTY:
892 TRACE("(%s)\n", "IGP_PROPERTY");
893 rc = IME_PROP_UNICODE | IME_PROP_AT_CARET;
894 break;
895 case IGP_CONVERSION:
896 FIXME("(%s)\n", "IGP_CONVERSION");
897 rc = IME_CMODE_NATIVE;
898 break;
899 case IGP_SENTENCE:
900 FIXME("%s)\n", "IGP_SENTENCE");
901 rc = IME_SMODE_AUTOMATIC;
902 break;
903 case IGP_SETCOMPSTR:
904 TRACE("(%s)\n", "IGP_SETCOMPSTR");
905 rc = 0;
906 break;
907 case IGP_SELECT:
908 TRACE("(%s)\n", "IGP_SELECT");
909 rc = SELECT_CAP_CONVERSION | SELECT_CAP_SENTENCE;
910 break;
911 case IGP_GETIMEVERSION:
912 TRACE("(%s)\n", "IGP_GETIMEVERSION");
913 rc = IMEVER_0400;
914 break;
915 case IGP_UI:
916 TRACE("(%s)\n", "IGP_UI");
917 rc = 0;
918 break;
919 default:
920 rc = 0;
921 }
922 return rc;
923 }
924
925 /***********************************************************************
926 * ImmGetRegisterWordStyleA (IMM32.@)
927 */
928 UINT WINAPI ImmGetRegisterWordStyleA(
929 HKL hKL, UINT nItem, LPSTYLEBUFA lpStyleBuf)
930 {
931 FIXME("(%p, %d, %p): stub\n", hKL, nItem, lpStyleBuf);
932 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
933 return 0;
934 }
935
936 /***********************************************************************
937 * ImmGetRegisterWordStyleW (IMM32.@)
938 */
939 UINT WINAPI ImmGetRegisterWordStyleW(
940 HKL hKL, UINT nItem, LPSTYLEBUFW lpStyleBuf)
941 {
942 FIXME("(%p, %d, %p): stub\n", hKL, nItem, lpStyleBuf);
943 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
944 return 0;
945 }
946
947 /***********************************************************************
948 * ImmGetStatusWindowPos (IMM32.@)
949 */
950 BOOL WINAPI ImmGetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
951 {
952 FIXME("(%p, %p): stub\n", hIMC, lpptPos);
953 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
954 return FALSE;
955 }
956
957 /***********************************************************************
958 * ImmGetVirtualKey (IMM32.@)
959 */
960 UINT WINAPI ImmGetVirtualKey(HWND hWnd)
961 {
962 OSVERSIONINFOA version;
963 FIXME("(%p): stub\n", hWnd);
964 GetVersionExA( &version );
965 switch(version.dwPlatformId)
966 {
967 case VER_PLATFORM_WIN32_WINDOWS:
968 return VK_PROCESSKEY;
969 case VER_PLATFORM_WIN32_NT:
970 return 0;
971 default:
972 FIXME("%d not supported\n",version.dwPlatformId);
973 return VK_PROCESSKEY;
974 }
975 }
976
977 /***********************************************************************
978 * ImmInstallIMEA (IMM32.@)
979 */
980 HKL WINAPI ImmInstallIMEA(
981 LPCSTR lpszIMEFileName, LPCSTR lpszLayoutText)
982 {
983 FIXME("(%s, %s): stub\n",
984 debugstr_a(lpszIMEFileName), debugstr_a(lpszLayoutText)
985 );
986 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
987 return NULL;
988 }
989
990 /***********************************************************************
991 * ImmInstallIMEW (IMM32.@)
992 */
993 HKL WINAPI ImmInstallIMEW(
994 LPCWSTR lpszIMEFileName, LPCWSTR lpszLayoutText)
995 {
996 FIXME("(%s, %s): stub\n",
997 debugstr_w(lpszIMEFileName), debugstr_w(lpszLayoutText)
998 );
999 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1000 return NULL;
1001 }
1002
1003 /***********************************************************************
1004 * ImmIsIME (IMM32.@)
1005 */
1006 BOOL WINAPI ImmIsIME(HKL hKL)
1007 {
1008 TRACE("(%p): semi-stub\n", hKL);
1009 /*
1010 * FIXME: Dead key locales will return TRUE here when they should not
1011 * There is probably a more proper way to check this.
1012 */
1013 return (root_context != NULL);
1014 }
1015
1016 /***********************************************************************
1017 * ImmIsUIMessageA (IMM32.@)
1018 */
1019 BOOL WINAPI ImmIsUIMessageA(
1020 HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
1021 {
1022 BOOL rc = FALSE;
1023
1024 TRACE("(%p, %x, %d, %ld)\n", hWndIME, msg, wParam, lParam);
1025 if ((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
1026 (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP) ||
1027 (msg == WM_MSIME_SERVICE) ||
1028 (msg == WM_MSIME_RECONVERTOPTIONS) ||
1029 (msg == WM_MSIME_MOUSE) ||
1030 (msg == WM_MSIME_RECONVERTREQUEST) ||
1031 (msg == WM_MSIME_RECONVERT) ||
1032 (msg == WM_MSIME_QUERYPOSITION) ||
1033 (msg == WM_MSIME_DOCUMENTFEED))
1034
1035 {
1036 if (!hwndDefault)
1037 ImmGetDefaultIMEWnd(NULL);
1038
1039 if (hWndIME == NULL)
1040 PostMessageA(hwndDefault, msg, wParam, lParam);
1041
1042 rc = TRUE;
1043 }
1044 return rc;
1045 }
1046
1047 /***********************************************************************
1048 * ImmIsUIMessageW (IMM32.@)
1049 */
1050 BOOL WINAPI ImmIsUIMessageW(
1051 HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
1052 {
1053 BOOL rc = FALSE;
1054 TRACE("(%p, %d, %d, %ld): stub\n", hWndIME, msg, wParam, lParam);
1055 if ((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
1056 (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP) ||
1057 (msg == WM_MSIME_SERVICE) ||
1058 (msg == WM_MSIME_RECONVERTOPTIONS) ||
1059 (msg == WM_MSIME_MOUSE) ||
1060 (msg == WM_MSIME_RECONVERTREQUEST) ||
1061 (msg == WM_MSIME_RECONVERT) ||
1062 (msg == WM_MSIME_QUERYPOSITION) ||
1063 (msg == WM_MSIME_DOCUMENTFEED))
1064 rc = TRUE;
1065 return rc;
1066 }
1067
1068 /***********************************************************************
1069 * ImmNotifyIME (IMM32.@)
1070 */
1071 BOOL WINAPI ImmNotifyIME(
1072 HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue)
1073 {
1074 BOOL rc = FALSE;
1075
1076 TRACE("(%p, %d, %d, %d)\n",
1077 hIMC, dwAction, dwIndex, dwValue);
1078
1079 if (!root_context)
1080 return rc;
1081
1082 switch(dwAction)
1083 {
1084 case NI_CHANGECANDIDATELIST:
1085 FIXME("%s\n","NI_CHANGECANDIDATELIST");
1086 break;
1087 case NI_CLOSECANDIDATE:
1088 FIXME("%s\n","NI_CLOSECANDIDATE");
1089 break;
1090 case NI_COMPOSITIONSTR:
1091 switch (dwIndex)
1092 {
1093 case CPS_CANCEL:
1094 TRACE("%s - %s\n","NI_COMPOSITIONSTR","CPS_CANCEL");
1095 if (pX11DRV_ForceXIMReset)
1096 pX11DRV_ForceXIMReset(root_context->hwnd);
1097 if (root_context->dwCompStringSize)
1098 {
1099 HeapFree(GetProcessHeap(),0,
1100 root_context->CompositionString);
1101 root_context->dwCompStringSize = 0;
1102 root_context->dwCompStringLength = 0;
1103 root_context->CompositionString = NULL;
1104 ImmInternalPostIMEMessage(WM_IME_COMPOSITION, 0,
1105 GCS_COMPSTR);
1106 }
1107 rc = TRUE;
1108 break;
1109 case CPS_COMPLETE:
1110 TRACE("%s - %s\n","NI_COMPOSITIONSTR","CPS_COMPLETE");
1111 if (hIMC != (HIMC)FROM_IME && pX11DRV_ForceXIMReset)
1112 pX11DRV_ForceXIMReset(root_context->hwnd);
1113
1114 if (root_context->dwResultStringSize)
1115 {
1116 HeapFree(GetProcessHeap(),0,root_context->ResultString);
1117 root_context->dwResultStringSize = 0;
1118 root_context->ResultString = NULL;
1119 }
1120 if (root_context->dwCompStringLength)
1121 {
1122 root_context->ResultString = HeapAlloc(
1123 GetProcessHeap(), 0, root_context->dwCompStringLength);
1124 root_context->dwResultStringSize =
1125 root_context->dwCompStringLength;
1126
1127 memcpy(root_context->ResultString,
1128 root_context->CompositionString,
1129 root_context->dwCompStringLength);
1130
1131 HeapFree(GetProcessHeap(),0,
1132 root_context->CompositionString);
1133
1134 root_context->dwCompStringSize = 0;
1135 root_context->dwCompStringLength = 0;
1136 root_context->CompositionString = NULL;
1137 root_context->bRead = FALSE;
1138
1139 ImmInternalPostIMEMessage(WM_IME_COMPOSITION, 0,
1140 GCS_COMPSTR);
1141
1142 ImmInternalPostIMEMessage(WM_IME_COMPOSITION,
1143 root_context->ResultString[0],
1144 GCS_RESULTSTR|GCS_RESULTCLAUSE);
1145
1146 ImmInternalPostIMEMessage(WM_IME_ENDCOMPOSITION, 0, 0);
1147 root_context->bInComposition = FALSE;
1148 }
1149 break;
1150 case CPS_CONVERT:
1151 FIXME("%s - %s\n","NI_COMPOSITIONSTR","CPS_CONVERT");
1152 break;
1153 case CPS_REVERT:
1154 FIXME("%s - %s\n","NI_COMPOSITIONSTR","CPS_REVERT");
1155 break;
1156 default:
1157 ERR("%s - %s (%i)\n","NI_COMPOSITIONSTR","UNKNOWN",dwIndex);
1158 break;
1159 }
1160 break;
1161 case NI_IMEMENUSELECTED:
1162 FIXME("%s\n", "NI_IMEMENUSELECTED");
1163 break;
1164 case NI_OPENCANDIDATE:
1165 FIXME("%s\n", "NI_OPENCANDIDATE");
1166 break;
1167 case NI_SELECTCANDIDATESTR:
1168 FIXME("%s\n", "NI_SELECTCANDIDATESTR");
1169 break;
1170 case NI_SETCANDIDATE_PAGESIZE:
1171 FIXME("%s\n", "NI_SETCANDIDATE_PAGESIZE");
1172 break;
1173 case NI_SETCANDIDATE_PAGESTART:
1174 FIXME("%s\n", "NI_SETCANDIDATE_PAGESTART");
1175 break;
1176 default:
1177 ERR("Unknown\n");
1178 }
1179
1180 return rc;
1181 }
1182
1183 /***********************************************************************
1184 * ImmRegisterWordA (IMM32.@)
1185 */
1186 BOOL WINAPI ImmRegisterWordA(
1187 HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister)
1188 {
1189 FIXME("(%p, %s, %d, %s): stub\n",
1190 hKL, debugstr_a(lpszReading), dwStyle, debugstr_a(lpszRegister)
1191 );
1192 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1193 return FALSE;
1194 }
1195
1196 /***********************************************************************
1197 * ImmRegisterWordW (IMM32.@)
1198 */
1199 BOOL WINAPI ImmRegisterWordW(
1200 HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister)
1201 {
1202 FIXME("(%p, %s, %d, %s): stub\n",
1203 hKL, debugstr_w(lpszReading), dwStyle, debugstr_w(lpszRegister)
1204 );
1205 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1206 return FALSE;
1207 }
1208
1209 /***********************************************************************
1210 * ImmReleaseContext (IMM32.@)
1211 */
1212 BOOL WINAPI ImmReleaseContext(HWND hWnd, HIMC hIMC)
1213 {
1214 FIXME("(%p, %p): stub\n", hWnd, hIMC);
1215
1216 return TRUE;
1217 }
1218
1219 /***********************************************************************
1220 * ImmSetCandidateWindow (IMM32.@)
1221 */
1222 BOOL WINAPI ImmSetCandidateWindow(
1223 HIMC hIMC, LPCANDIDATEFORM lpCandidate)
1224 {
1225 FIXME("(%p, %p): stub\n", hIMC, lpCandidate);
1226 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1227 return FALSE;
1228 }
1229
1230 /***********************************************************************
1231 * ImmSetCompositionFontA (IMM32.@)
1232 */
1233 BOOL WINAPI ImmSetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
1234 {
1235 InputContextData *data = (InputContextData*)hIMC;
1236 TRACE("(%p, %p)\n", hIMC, lplf);
1237
1238 if (!data)
1239 return FALSE;
1240
1241 memcpy(&data->font,lplf,sizeof(LOGFONTA));
1242 MultiByteToWideChar(CP_ACP, 0, lplf->lfFaceName, -1, data->font.lfFaceName,
1243 LF_FACESIZE);
1244
1245 ImmInternalSendIMENotify(IMN_SETCOMPOSITIONFONT, 0);
1246
1247 if (data->textfont)
1248 {
1249 DeleteObject(data->textfont);
1250 data->textfont = NULL;
1251 }
1252
1253 data->textfont = CreateFontIndirectW(&data->font);
1254 return TRUE;
1255 }
1256
1257 /***********************************************************************
1258 * ImmSetCompositionFontW (IMM32.@)
1259 */
1260 BOOL WINAPI ImmSetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
1261 {
1262 InputContextData *data = (InputContextData*)hIMC;
1263 TRACE("(%p, %p)\n", hIMC, lplf);
1264
1265 if (!data)
1266 return FALSE;
1267
1268 memcpy(&data->font,lplf,sizeof(LOGFONTW));
1269 ImmInternalSendIMENotify(IMN_SETCOMPOSITIONFONT, 0);
1270
1271 if (data->textfont)
1272 {
1273 DeleteObject(data->textfont);
1274 data->textfont = NULL;
1275 }
1276 data->textfont = CreateFontIndirectW(&data->font);
1277 return TRUE;
1278 }
1279
1280 /***********************************************************************
1281 * ImmSetCompositionStringA (IMM32.@)
1282 */
1283 BOOL WINAPI ImmSetCompositionStringA(
1284 HIMC hIMC, DWORD dwIndex,
1285 LPCVOID lpComp, DWORD dwCompLen,
1286 LPCVOID lpRead, DWORD dwReadLen)
1287 {
1288 DWORD comp_len;
1289 DWORD read_len;
1290 WCHAR *CompBuffer = NULL;
1291 WCHAR *ReadBuffer = NULL;
1292 BOOL rc;
1293
1294 TRACE("(%p, %d, %p, %d, %p, %d): stub\n",
1295 hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
1296
1297 comp_len = MultiByteToWideChar(CP_ACP, 0, lpComp, dwCompLen, NULL, 0);
1298 if (comp_len)
1299 {
1300 CompBuffer = HeapAlloc(GetProcessHeap(),0,comp_len * sizeof(WCHAR));
1301 MultiByteToWideChar(CP_ACP, 0, lpComp, dwCompLen, CompBuffer, comp_len);
1302 }
1303
1304 read_len = MultiByteToWideChar(CP_ACP, 0, lpRead, dwReadLen, NULL, 0);
1305 if (read_len)
1306 {
1307 ReadBuffer = HeapAlloc(GetProcessHeap(),0,read_len * sizeof(WCHAR));
1308 MultiByteToWideChar(CP_ACP, 0, lpRead, dwReadLen, ReadBuffer, read_len);
1309 }
1310
1311 rc = ImmSetCompositionStringW(hIMC, dwIndex, CompBuffer, comp_len,
1312 ReadBuffer, read_len);
1313
1314 HeapFree(GetProcessHeap(), 0, CompBuffer);
1315 HeapFree(GetProcessHeap(), 0, ReadBuffer);
1316
1317 return rc;
1318 }
1319
1320 /***********************************************************************
1321 * ImmSetCompositionStringW (IMM32.@)
1322 */
1323 BOOL WINAPI ImmSetCompositionStringW(
1324 HIMC hIMC, DWORD dwIndex,
1325 LPCVOID lpComp, DWORD dwCompLen,
1326 LPCVOID lpRead, DWORD dwReadLen)
1327 {
1328 DWORD flags = 0;
1329 WCHAR wParam = 0;
1330
1331 TRACE("(%p, %d, %p, %d, %p, %d): stub\n",
1332 hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
1333
1334
1335 if (hIMC != (HIMC)FROM_IME)
1336 FIXME("PROBLEM: This only sets the wine level string\n");
1337
1338 /*
1339 * Explanation:
1340 * this sets the composition string in the imm32.dll level
1341 * of the composition buffer. we cannot manipulate the xim level
1342 * buffer, which means that once the xim level buffer changes again
1343 * any call to this function from the application will be lost
1344 */
1345
1346 if (lpRead && dwReadLen)
1347 FIXME("Reading string unimplemented\n");
1348
1349 /*
1350 * app operating this api to also receive the message from xim
1351 */
1352
1353 if (dwIndex == SCS_SETSTR)
1354 {
1355 if (!root_context->bInComposition)
1356 {
1357 ImmInternalPostIMEMessage(WM_IME_STARTCOMPOSITION, 0, 0);
1358 root_context->bInComposition = TRUE;
1359 }
1360
1361 flags = GCS_COMPSTR;
1362
1363 if (root_context->dwCompStringLength)
1364 HeapFree(GetProcessHeap(),0,root_context->CompositionString);
1365
1366 root_context->dwCompStringLength = dwCompLen;
1367 root_context->dwCompStringSize = dwCompLen;
1368
1369 if (dwCompLen && lpComp)
1370 {
1371 root_context->CompositionString = HeapAlloc(GetProcessHeap(), 0,
1372 dwCompLen);
1373 memcpy(root_context->CompositionString,lpComp,dwCompLen);
1374
1375 wParam = ((const WCHAR*)lpComp)[0];
1376 flags |= GCS_COMPCLAUSE | GCS_COMPATTR;
1377 }
1378 else
1379 root_context->CompositionString = NULL;
1380
1381 }
1382
1383 UpdateDataInDefaultIMEWindow(hwndDefault);
1384
1385 ImmInternalPostIMEMessage(WM_IME_COMPOSITION, wParam, flags);
1386
1387 return TRUE;
1388 }
1389
1390 /***********************************************************************
1391 * ImmSetCompositionWindow (IMM32.@)
1392 */
1393 BOOL WINAPI ImmSetCompositionWindow(
1394 HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
1395 {
1396 BOOL reshow = FALSE;
1397 InputContextData *data = (InputContextData*)hIMC;
1398
1399 TRACE("(%p, %p)\n", hIMC, lpCompForm);
1400 TRACE("\t%x, (%i,%i), (%i,%i - %i,%i)\n",lpCompForm->dwStyle,
1401 lpCompForm->ptCurrentPos.x, lpCompForm->ptCurrentPos.y, lpCompForm->rcArea.top,
1402 lpCompForm->rcArea.left, lpCompForm->rcArea.bottom, lpCompForm->rcArea.right);
1403
1404 if (!data)
1405 return FALSE;
1406
1407 memcpy(&data->CompForm,lpCompForm,sizeof(COMPOSITIONFORM));
1408
1409 if (IsWindowVisible(hwndDefault))
1410 {
1411 reshow = TRUE;
1412 ShowWindow(hwndDefault,SW_HIDE);
1413 }
1414
1415 /* FIXME: this is a partial stub */
1416
1417 if (reshow)
1418 ShowWindow(hwndDefault,SW_SHOWNOACTIVATE);
1419
1420 ImmInternalSendIMENotify(IMN_SETCOMPOSITIONWINDOW, 0);
1421 return TRUE;
1422 }
1423
1424 /***********************************************************************
1425 * ImmSetConversionStatus (IMM32.@)
1426 */
1427 BOOL WINAPI ImmSetConversionStatus(
1428 HIMC hIMC, DWORD fdwConversion, DWORD fdwSentence)
1429 {
1430 FIXME("(%p, %d, %d): stub\n",
1431 hIMC, fdwConversion, fdwSentence
1432 );
1433 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1434 return FALSE;
1435 }
1436
1437 /***********************************************************************
1438 * ImmSetOpenStatus (IMM32.@)
1439 */
1440 BOOL WINAPI ImmSetOpenStatus(HIMC hIMC, BOOL fOpen)
1441 {
1442 InputContextData *data = (InputContextData*)hIMC;
1443
1444 TRACE("%p %d\n", hIMC, fOpen);
1445
1446 if (hIMC == (HIMC)FROM_IME)
1447 {
1448 ImmInternalSetOpenStatus(fOpen);
1449 ImmInternalSendIMENotify(IMN_SETOPENSTATUS, 0);
1450 return TRUE;
1451 }
1452
1453 if (!data)
1454 return FALSE;
1455
1456 if (fOpen != data->bInternalState)
1457 {
1458 if (fOpen == FALSE && pX11DRV_ForceXIMReset)
1459 pX11DRV_ForceXIMReset(data->hwnd);
1460
1461 if (fOpen == FALSE)
1462 ImmInternalPostIMEMessage(WM_IME_ENDCOMPOSITION,0,0);
1463 else
1464 ImmInternalPostIMEMessage(WM_IME_STARTCOMPOSITION,0,0);
1465
1466 ImmInternalSetOpenStatus(fOpen);
1467 ImmInternalSetOpenStatus(!fOpen);
1468
1469 if (data->bOpen == FALSE)
1470 ImmInternalPostIMEMessage(WM_IME_ENDCOMPOSITION,0,0);
1471 else
1472 ImmInternalPostIMEMessage(WM_IME_STARTCOMPOSITION,0,0);
1473
1474 return FALSE;
1475 }
1476 return TRUE;
1477 }
1478
1479 /***********************************************************************
1480 * ImmSetStatusWindowPos (IMM32.@)
1481 */
1482 BOOL WINAPI ImmSetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
1483 {
1484 FIXME("(%p, %p): stub\n", hIMC, lpptPos);
1485 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1486 return FALSE;
1487 }
1488
1489 /***********************************************************************
1490 * ImmSimulateHotKey (IMM32.@)
1491 */
1492 BOOL WINAPI ImmSimulateHotKey(HWND hWnd, DWORD dwHotKeyID)
1493 {
1494 FIXME("(%p, %d): stub\n", hWnd, dwHotKeyID);
1495 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1496 return FALSE;
1497 }
1498
1499 /***********************************************************************
1500 * ImmUnregisterWordA (IMM32.@)
1501 */
1502 BOOL WINAPI ImmUnregisterWordA(
1503 HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszUnregister)
1504 {
1505 FIXME("(%p, %s, %d, %s): stub\n",
1506 hKL, debugstr_a(lpszReading), dwStyle, debugstr_a(lpszUnregister)
1507 );
1508 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1509 return FALSE;
1510 }
1511
1512 /***********************************************************************
1513 * ImmUnregisterWordW (IMM32.@)
1514 */
1515 BOOL WINAPI ImmUnregisterWordW(
1516 HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszUnregister)
1517 {
1518 FIXME("(%p, %s, %d, %s): stub\n",
1519 hKL, debugstr_w(lpszReading), dwStyle, debugstr_w(lpszUnregister)
1520 );
1521 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1522 return FALSE;
1523 }
1524
1525 /***********************************************************************
1526 * ImmGetImeMenuItemsA (IMM32.@)
1527 */
1528 DWORD WINAPI ImmGetImeMenuItemsA( HIMC hIMC, DWORD dwFlags, DWORD dwType,
1529 LPIMEMENUITEMINFOA lpImeParentMenu, LPIMEMENUITEMINFOA lpImeMenu,
1530 DWORD dwSize)
1531 {
1532 FIXME("(%p, %i, %i, %p, %p, %i): stub\n", hIMC, dwFlags, dwType,
1533 lpImeParentMenu, lpImeMenu, dwSize);
1534 return 0;
1535 }
1536
1537 /***********************************************************************
1538 * ImmGetImeMenuItemsW (IMM32.@)
1539 */
1540 DWORD WINAPI ImmGetImeMenuItemsW( HIMC hIMC, DWORD dwFlags, DWORD dwType,
1541 LPIMEMENUITEMINFOW lpImeParentMenu, LPIMEMENUITEMINFOW lpImeMenu,
1542 DWORD dwSize)
1543 {
1544 FIXME("(%p, %i, %i, %p, %p, %i): stub\n", hIMC, dwFlags, dwType,
1545 lpImeParentMenu, lpImeMenu, dwSize);
1546 return 0;
1547 }
1548
1549 /*****
1550 * Internal functions to help with IME window management
1551 */
1552 static void PaintDefaultIMEWnd(HWND hwnd)
1553 {
1554 PAINTSTRUCT ps;
1555 RECT rect;
1556 HDC hdc = BeginPaint(hwnd,&ps);
1557 GetClientRect(hwnd,&rect);
1558 FillRect(hdc, &rect, (HBRUSH)(COLOR_WINDOW + 1));
1559
1560 if (root_context->dwCompStringLength && root_context->CompositionString)
1561 {
1562 SIZE size;
1563 POINT pt;
1564 HFONT oldfont = NULL;
1565
1566 if (root_context->textfont)
1567 oldfont = SelectObject(hdc,root_context->textfont);
1568
1569
1570 GetTextExtentPoint32W(hdc, (LPWSTR)root_context->CompositionString,
1571 root_context->dwCompStringLength / sizeof(WCHAR),
1572 &size);
1573 pt.x = size.cx;
1574 pt.y = size.cy;
1575 LPtoDP(hdc,&pt,1);
1576
1577 if (root_context->CompForm.dwStyle == CFS_POINT ||
1578 root_context->CompForm.dwStyle == CFS_FORCE_POSITION)
1579 {
1580 POINT cpt = root_context->CompForm.ptCurrentPos;
1581 ClientToScreen(root_context->hwnd,&cpt);
1582 rect.left = cpt.x;
1583 rect.top = cpt.y;
1584 rect.right = rect.left + pt.x + 20;
1585 rect.bottom = rect.top + pt.y + 20;
1586 }
1587 else if (root_context->CompForm.dwStyle == CFS_RECT)
1588 {
1589 POINT cpt;
1590 cpt.x = root_context->CompForm.rcArea.left;
1591 cpt.y = root_context->CompForm.rcArea.top;
1592 ClientToScreen(root_context->hwnd,&cpt);
1593 rect.left = cpt.x;
1594 rect.top = cpt.y;
1595 cpt.x = root_context->CompForm.rcArea.right;
1596 cpt.y = root_context->CompForm.rcArea.bottom;
1597 ClientToScreen(root_context->hwnd,&cpt);
1598 rect.right = cpt.x;
1599 rect.bottom = cpt.y;
1600 }
1601 else
1602 {
1603 rect.right = rect.left + pt.x + 20;
1604 rect.bottom = rect.top + pt.y + 20;
1605 }
1606 MoveWindow(hwnd, rect.left, rect.top, rect.right - rect.left ,
1607 rect.bottom - rect.top, FALSE);
1608 TextOutW(hdc, 10,10,(LPWSTR)root_context->CompositionString,
1609 root_context->dwCompStringLength / sizeof(WCHAR));
1610
1611 if (oldfont)
1612 SelectObject(hdc,oldfont);
1613 }
1614 EndPaint(hwnd,&ps);
1615 }
1616
1617 static void UpdateDataInDefaultIMEWindow(HWND hwnd)
1618 {
1619 RedrawWindow(hwnd,NULL,NULL,RDW_ERASENOW|RDW_INVALIDATE);
1620 }
1621
1622 /*
1623 * The window proc for the default IME window
1624 */
1625 static LRESULT WINAPI IME_WindowProc(HWND hwnd, UINT msg, WPARAM wParam,
1626 LPARAM lParam)
1627 {
1628 LRESULT rc = 0;
1629
1630 TRACE("Incoming Message 0x%x (0x%08x, 0x%08x)\n", msg, (UINT)wParam,
1631 (UINT)lParam);
1632
1633 switch(msg)
1634 {
1635 case WM_PAINT:
1636 PaintDefaultIMEWnd(hwnd);
1637 return FALSE;
1638
1639 case WM_NCCREATE:
1640 return TRUE;
1641
1642 case WM_CREATE:
1643 SetWindowTextA(hwnd,"Wine Ime Active");
1644 return TRUE;
1645
1646 case WM_SETFOCUS:
1647 if (wParam)
1648 SetFocus((HWND)wParam);
1649 else
1650 FIXME("Received focus, should never have focus\n");
1651 break;
1652 case WM_IME_COMPOSITION:
1653 TRACE("IME message %s, 0x%x, 0x%x (%i)\n",
1654 "WM_IME_COMPOSITION", (UINT)wParam, (UINT)lParam,
1655 root_context->bRead);
1656 if (lParam & GCS_RESULTSTR)
1657 IMM_PostResult(root_context);
1658 else
1659 UpdateDataInDefaultIMEWindow(hwnd);
1660 break;
1661 case WM_IME_STARTCOMPOSITION:
1662 TRACE("IME message %s, 0x%x, 0x%x\n",
1663 "WM_IME_STARTCOMPOSITION", (UINT)wParam, (UINT)lParam);
1664 root_context->hwnd = GetFocus();
1665 ShowWindow(hwndDefault,SW_SHOWNOACTIVATE);
1666 break;
1667 case WM_IME_ENDCOMPOSITION:
1668 TRACE("IME message %s, 0x%x, 0x%x\n",
1669 "WM_IME_ENDCOMPOSITION", (UINT)wParam, (UINT)lParam);
1670 ShowWindow(hwndDefault,SW_HIDE);
1671 break;
1672 case WM_IME_SELECT:
1673 TRACE("IME message %s, 0x%x, 0x%x\n","WM_IME_SELECT",
1674 (UINT)wParam, (UINT)lParam);
1675 break;
1676 case WM_IME_CONTROL:
1677 TRACE("IME message %s, 0x%x, 0x%x\n","WM_IME_CONTROL",
1678 (UINT)wParam, (UINT)lParam);
1679 rc = 1;
1680 break;
1681 case WM_IME_NOTIFY:
1682 TRACE("!! IME NOTIFY\n");
1683 break;
1684 default:
1685 TRACE("Non-standard message 0x%x\n",msg);
1686 }
1687 /* check the MSIME messages */
1688 if (msg == WM_MSIME_SERVICE)
1689 {
1690 TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_SERVICE",
1691 (UINT)wParam, (UINT)lParam);
1692 rc = FALSE;
1693 }
1694 else if (msg == WM_MSIME_RECONVERTOPTIONS)
1695 {
1696 TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_RECONVERTOPTIONS",
1697 (UINT)wParam, (UINT)lParam);
1698 }
1699 else if (msg == WM_MSIME_MOUSE)
1700 {
1701 TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_MOUSE",
1702 (UINT)wParam, (UINT)lParam);
1703 }
1704 else if (msg == WM_MSIME_RECONVERTREQUEST)
1705 {
1706 TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_RECONVERTREQUEST",
1707 (UINT)wParam, (UINT)lParam);
1708 }
1709 else if (msg == WM_MSIME_RECONVERT)
1710 {
1711 TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_RECONVERT",
1712 (UINT)wParam, (UINT)lParam);
1713 }
1714 else if (msg == WM_MSIME_QUERYPOSITION)
1715 {
1716 TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_QUERYPOSITION",
1717 (UINT)wParam, (UINT)lParam);
1718 }
1719 else if (msg == WM_MSIME_DOCUMENTFEED)
1720 {
1721 TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_DOCUMENTFEED",
1722 (UINT)wParam, (UINT)lParam);
1723 }
1724 /* DefWndProc if not an IME message */
1725 else if (!rc && !((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
1726 (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP)))
1727 rc = DefWindowProcW(hwnd,msg,wParam,lParam);
1728
1729 return rc;
1730 }
Work in progress by Kai Blin