wined3d: Implement a detection for the MacOS OpenGL implementation.
[wine] / dlls / imm32 / imm.c
1 /*
2  * IMM32 library
3  *
4  * Copyright 1998 Patrik Stridvall
5  * Copyright 2002, 2003, 2007 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 "ddk/imm.h"
32 #include "winnls.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(imm);
35
36 #define FROM_IME 0xcafe1337
37
38 static void (*pX11DRV_ForceXIMReset)(HWND);
39
40 typedef struct tagIMCCInternal
41 {
42     DWORD dwLock;
43     DWORD dwSize;
44 } IMCCInternal;
45
46 typedef struct tagInputContextData
47 {
48         BOOL            bInternalState;
49         BOOL            bRead;
50         BOOL            bInComposition;
51         HFONT           textfont;
52
53         DWORD           dwLock;
54         INPUTCONTEXT    IMC;
55 } InputContextData;
56
57 static InputContextData *root_context = NULL;
58 static HWND hwndDefault = NULL;
59 static HANDLE hImeInst;
60 static const WCHAR WC_IMECLASSNAME[] = {'I','M','E',0};
61 static ATOM atIMEClass = 0;
62
63 /* MSIME messages */
64 static UINT WM_MSIME_SERVICE;
65 static UINT WM_MSIME_RECONVERTOPTIONS;
66 static UINT WM_MSIME_MOUSE;
67 static UINT WM_MSIME_RECONVERTREQUEST;
68 static UINT WM_MSIME_RECONVERT;
69 static UINT WM_MSIME_QUERYPOSITION;
70 static UINT WM_MSIME_DOCUMENTFEED;
71
72 /*
73  * prototypes
74  */
75 static LRESULT WINAPI IME_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam,
76                                           LPARAM lParam);
77 static void UpdateDataInDefaultIMEWindow(HWND hwnd, BOOL showable);
78 static void ImmInternalPostIMEMessage(UINT, WPARAM, LPARAM);
79 static void ImmInternalSetOpenStatus(BOOL fOpen);
80 static HIMCC updateResultStr(HIMCC old, LPWSTR resultstr, DWORD len);
81
82 static VOID IMM_PostResult(InputContextData *data)
83 {
84     unsigned int i;
85     LPCOMPOSITIONSTRING compstr;
86     LPBYTE compdata;
87     LPWSTR ResultStr;
88     HIMCC newCompStr;
89
90     TRACE("Posting result as IME_CHAR\n");
91     compdata = ImmLockIMCC(root_context->IMC.hCompStr);
92     compstr = (LPCOMPOSITIONSTRING)compdata;
93     ResultStr = (LPWSTR)(compdata + compstr->dwResultStrOffset);
94
95     for (i = 0; i < compstr->dwResultStrLen; i++)
96         ImmInternalPostIMEMessage (WM_IME_CHAR, ResultStr[i], 1);
97
98     ImmUnlockIMCC(root_context->IMC.hCompStr);
99
100     /* clear the buffer */
101     newCompStr = updateResultStr(root_context->IMC.hCompStr, NULL, 0);
102     ImmDestroyIMCC(root_context->IMC.hCompStr);
103     root_context->IMC.hCompStr = newCompStr;
104 }
105
106 static void IMM_Register(void)
107 {
108     WNDCLASSW wndClass;
109     ZeroMemory(&wndClass, sizeof(WNDCLASSW));
110     wndClass.style = CS_GLOBALCLASS | CS_IME | CS_HREDRAW | CS_VREDRAW;
111     wndClass.lpfnWndProc = (WNDPROC) IME_WindowProc;
112     wndClass.cbClsExtra = 0;
113     wndClass.cbWndExtra = 0;
114     wndClass.hInstance = hImeInst;
115     wndClass.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
116     wndClass.hIcon = NULL;
117     wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW +1);
118     wndClass.lpszMenuName   = 0;
119     wndClass.lpszClassName = WC_IMECLASSNAME;
120     atIMEClass = RegisterClassW(&wndClass);
121 }
122
123 static void IMM_Unregister(void)
124 {
125     if (atIMEClass) {
126         UnregisterClassW(WC_IMECLASSNAME, NULL);
127     }
128 }
129
130 static void IMM_RegisterMessages(void)
131 {
132     WM_MSIME_SERVICE = RegisterWindowMessageA("MSIMEService");
133     WM_MSIME_RECONVERTOPTIONS = RegisterWindowMessageA("MSIMEReconvertOptions");
134     WM_MSIME_MOUSE = RegisterWindowMessageA("MSIMEMouseOperation");
135     WM_MSIME_RECONVERTREQUEST = RegisterWindowMessageA("MSIMEReconvertRequest");
136     WM_MSIME_RECONVERT = RegisterWindowMessageA("MSIMEReconvert");
137     WM_MSIME_QUERYPOSITION = RegisterWindowMessageA("MSIMEQueryPosition");
138     WM_MSIME_DOCUMENTFEED = RegisterWindowMessageA("MSIMEDocumentFeed");
139 }
140
141
142 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpReserved)
143 {
144     HMODULE x11drv;
145
146     TRACE("%p, %x, %p\n",hInstDLL,fdwReason,lpReserved);
147     switch (fdwReason)
148     {
149         case DLL_PROCESS_ATTACH:
150             DisableThreadLibraryCalls(hInstDLL);
151             hImeInst = hInstDLL;
152             IMM_RegisterMessages();
153             x11drv = GetModuleHandleA("winex11.drv");
154             if (x11drv) pX11DRV_ForceXIMReset = (void *)GetProcAddress( x11drv, "ForceXIMReset");
155             break;
156         case DLL_PROCESS_DETACH:
157             if (hwndDefault)
158             {
159                 DestroyWindow(hwndDefault);
160                 hwndDefault = 0;
161             }
162             IMM_Unregister();
163             break;
164     }
165     return TRUE;
166 }
167
168 /* for posting messages as the IME */
169 static void ImmInternalPostIMEMessage(UINT msg, WPARAM wParam, LPARAM lParam)
170 {
171     HWND target = GetFocus();
172     if (!target)
173        PostMessageW(root_context->IMC.hWnd,msg,wParam,lParam);
174     else
175        PostMessageW(target, msg, wParam, lParam);
176 }
177
178 static LRESULT ImmInternalSendIMENotify(WPARAM notify, LPARAM lParam)
179 {
180     HWND target;
181
182     target = root_context->IMC.hWnd;
183     if (!target) target = GetFocus();
184
185     if (target)
186        return SendMessageW(target, WM_IME_NOTIFY, notify, lParam);
187
188     return 0;
189 }
190
191 static void ImmInternalSetOpenStatus(BOOL fOpen)
192 {
193     TRACE("Setting internal state to %s\n",(fOpen)?"OPEN":"CLOSED");
194
195    root_context->IMC.fOpen = fOpen;
196    root_context->bInternalState = fOpen;
197
198    if (fOpen == FALSE)
199    {
200         ShowWindow(hwndDefault,SW_HIDE);
201         ImmDestroyIMCC(root_context->IMC.hCompStr);
202         root_context->IMC.hCompStr = NULL;
203     }
204     else
205         ShowWindow(hwndDefault, SW_SHOWNOACTIVATE);
206
207    ImmInternalSendIMENotify(IMN_SETOPENSTATUS, 0);
208 }
209
210 static int updateField(DWORD origLen, DWORD origOffset, DWORD currentOffset,
211                        LPBYTE target, LPBYTE source, DWORD* lenParam,
212                        DWORD* offsetParam, BOOL wchars )
213 {
214      if (origLen > 0 && origOffset > 0)
215      {
216         int truelen = origLen;
217         if (wchars)
218             truelen *= sizeof(WCHAR);
219
220         memcpy(&target[currentOffset], &source[origOffset], truelen);
221
222         *lenParam = origLen;
223         *offsetParam = currentOffset;
224         currentOffset += truelen;
225      }
226      return currentOffset;
227 }
228
229 static HIMCC updateCompStr(HIMCC old, LPWSTR compstr, DWORD len)
230 {
231     /* we need to make sure the CompStr, CompClaus and CompAttr fields are all
232      * set and correct */
233     int needed_size;
234     HIMCC   rc;
235     LPBYTE newdata = NULL;
236     LPBYTE olddata = NULL;
237     LPCOMPOSITIONSTRING new_one;
238     LPCOMPOSITIONSTRING lpcs = NULL;
239     INT current_offset = 0;
240
241     TRACE("%s, %i\n",debugstr_wn(compstr,len),len);
242
243     if (old != NULL)
244     {
245         olddata = ImmLockIMCC(old);
246         lpcs = (LPCOMPOSITIONSTRING)olddata;
247     }
248
249     needed_size = sizeof(COMPOSITIONSTRING) + len * sizeof(WCHAR) +
250                   len + sizeof(DWORD) * 2;
251
252     if (lpcs != NULL)
253     {
254         needed_size += lpcs->dwCompReadAttrLen;
255         needed_size += lpcs->dwCompReadClauseLen;
256         needed_size += lpcs->dwCompReadStrLen * sizeof(DWORD);
257         needed_size += lpcs->dwResultReadClauseLen;
258         needed_size += lpcs->dwResultReadStrLen * sizeof(DWORD);
259         needed_size += lpcs->dwResultClauseLen;
260         needed_size += lpcs->dwResultStrLen * sizeof(DWORD);
261         needed_size += lpcs->dwPrivateSize;
262     }
263     rc = ImmCreateIMCC(needed_size);
264     newdata = ImmLockIMCC(rc);
265     new_one = (LPCOMPOSITIONSTRING)newdata;
266
267     new_one->dwSize = needed_size;
268     current_offset = sizeof(COMPOSITIONSTRING);
269     if (lpcs != NULL)
270     {
271         current_offset = updateField(lpcs->dwCompReadAttrLen,
272                                      lpcs->dwCompReadAttrOffset,
273                                      current_offset, newdata, olddata,
274                                      &new_one->dwCompReadAttrLen,
275                                      &new_one->dwCompReadAttrOffset, FALSE);
276
277         current_offset = updateField(lpcs->dwCompReadClauseLen,
278                                      lpcs->dwCompReadClauseOffset,
279                                      current_offset, newdata, olddata,
280                                      &new_one->dwCompReadClauseLen,
281                                      &new_one->dwCompReadClauseOffset, FALSE);
282
283         current_offset = updateField(lpcs->dwCompReadStrLen,
284                                      lpcs->dwCompReadStrOffset,
285                                      current_offset, newdata, olddata,
286                                      &new_one->dwCompReadStrLen,
287                                      &new_one->dwCompReadStrOffset, TRUE);
288
289         /* new CompAttr, CompClause, CompStr, dwCursorPos */
290         new_one->dwDeltaStart = 0;
291
292         current_offset = updateField(lpcs->dwResultReadClauseLen,
293                                      lpcs->dwResultReadClauseOffset,
294                                      current_offset, newdata, olddata,
295                                      &new_one->dwResultReadClauseLen,
296                                      &new_one->dwResultReadClauseOffset, FALSE);
297
298         current_offset = updateField(lpcs->dwResultReadStrLen,
299                                      lpcs->dwResultReadStrOffset,
300                                      current_offset, newdata, olddata,
301                                      &new_one->dwResultReadStrLen,
302                                      &new_one->dwResultReadStrOffset, TRUE);
303
304         current_offset = updateField(lpcs->dwResultClauseLen,
305                                      lpcs->dwResultClauseOffset,
306                                      current_offset, newdata, olddata,
307                                      &new_one->dwResultClauseLen,
308                                      &new_one->dwResultClauseOffset, FALSE);
309
310         current_offset = updateField(lpcs->dwResultStrLen,
311                                      lpcs->dwResultStrOffset,
312                                      current_offset, newdata, olddata,
313                                      &new_one->dwResultStrLen,
314                                      &new_one->dwResultStrOffset, TRUE);
315
316         current_offset = updateField(lpcs->dwPrivateSize,
317                                      lpcs->dwPrivateOffset,
318                                      current_offset, newdata, olddata,
319                                      &new_one->dwPrivateSize,
320                                      &new_one->dwPrivateOffset, FALSE);
321     }
322
323     /* set new data */
324     /* CompAttr */
325     new_one->dwCompAttrLen = len;
326     if (len > 0)
327     {
328         new_one->dwCompAttrOffset = current_offset;
329         memset(&newdata[current_offset],ATTR_INPUT,len);
330         current_offset += len;
331     }
332
333     /* CompClause */
334     if (len > 0)
335     {
336         new_one->dwCompClauseLen = sizeof(DWORD) * 2;
337         new_one->dwCompClauseOffset = current_offset;
338         *(DWORD*)(&newdata[current_offset]) = 0;
339         current_offset += sizeof(DWORD);
340         *(DWORD*)(&newdata[current_offset]) = len;
341         current_offset += sizeof(DWORD);
342     }
343
344     /* CompStr */
345     new_one->dwCompStrLen = len;
346     if (len > 0)
347     {
348         new_one->dwCompStrOffset = current_offset;
349         memcpy(&newdata[current_offset],compstr,len*sizeof(WCHAR));
350     }
351
352     /* CursorPos */
353     new_one->dwCursorPos = len;
354
355     ImmUnlockIMCC(rc);
356     if (lpcs)
357         ImmUnlockIMCC(old);
358
359     return rc;
360 }
361
362 static HIMCC updateResultStr(HIMCC old, LPWSTR resultstr, DWORD len)
363 {
364     /* we need to make sure the ResultStr and ResultClause fields are all
365      * set and correct */
366     int needed_size;
367     HIMCC   rc;
368     LPBYTE newdata = NULL;
369     LPBYTE olddata = NULL;
370     LPCOMPOSITIONSTRING new_one;
371     LPCOMPOSITIONSTRING lpcs = NULL;
372     INT current_offset = 0;
373
374     TRACE("%s, %i\n",debugstr_wn(resultstr,len),len);
375
376     if (old != NULL)
377     {
378         olddata = ImmLockIMCC(old);
379         lpcs = (LPCOMPOSITIONSTRING)olddata;
380     }
381
382     needed_size = sizeof(COMPOSITIONSTRING) + len * sizeof(WCHAR) +
383                   sizeof(DWORD) * 2;
384
385     if (lpcs != NULL)
386     {
387         needed_size += lpcs->dwCompReadAttrLen;
388         needed_size += lpcs->dwCompReadClauseLen;
389         needed_size += lpcs->dwCompReadStrLen * sizeof(DWORD);
390         needed_size += lpcs->dwCompAttrLen;
391         needed_size += lpcs->dwCompClauseLen;
392         needed_size += lpcs->dwCompStrLen * sizeof(DWORD);
393         needed_size += lpcs->dwResultReadClauseLen;
394         needed_size += lpcs->dwResultReadStrLen * sizeof(DWORD);
395         needed_size += lpcs->dwPrivateSize;
396     }
397     rc = ImmCreateIMCC(needed_size);
398     newdata = ImmLockIMCC(rc);
399     new_one = (LPCOMPOSITIONSTRING)newdata;
400
401     new_one->dwSize = needed_size;
402     current_offset = sizeof(COMPOSITIONSTRING);
403     if (lpcs != NULL)
404     {
405         current_offset = updateField(lpcs->dwCompReadAttrLen,
406                                      lpcs->dwCompReadAttrOffset,
407                                      current_offset, newdata, olddata,
408                                      &new_one->dwCompReadAttrLen,
409                                      &new_one->dwCompReadAttrOffset, FALSE);
410
411         current_offset = updateField(lpcs->dwCompReadClauseLen,
412                                      lpcs->dwCompReadClauseOffset,
413                                      current_offset, newdata, olddata,
414                                      &new_one->dwCompReadClauseLen,
415                                      &new_one->dwCompReadClauseOffset, FALSE);
416
417         current_offset = updateField(lpcs->dwCompReadStrLen,
418                                      lpcs->dwCompReadStrOffset,
419                                      current_offset, newdata, olddata,
420                                      &new_one->dwCompReadStrLen,
421                                      &new_one->dwCompReadStrOffset, TRUE);
422
423         current_offset = updateField(lpcs->dwCompAttrLen,
424                                      lpcs->dwCompAttrOffset,
425                                      current_offset, newdata, olddata,
426                                      &new_one->dwCompAttrLen,
427                                      &new_one->dwCompAttrOffset, FALSE);
428
429         current_offset = updateField(lpcs->dwCompClauseLen,
430                                      lpcs->dwCompClauseOffset,
431                                      current_offset, newdata, olddata,
432                                      &new_one->dwCompClauseLen,
433                                      &new_one->dwCompClauseOffset, FALSE);
434
435         current_offset = updateField(lpcs->dwCompStrLen,
436                                      lpcs->dwCompStrOffset,
437                                      current_offset, newdata, olddata,
438                                      &new_one->dwCompStrLen,
439                                      &new_one->dwCompStrOffset, TRUE);
440
441         new_one->dwCursorPos = lpcs->dwCursorPos;
442         new_one->dwDeltaStart = 0;
443
444         current_offset = updateField(lpcs->dwResultReadClauseLen,
445                                      lpcs->dwResultReadClauseOffset,
446                                      current_offset, newdata, olddata,
447                                      &new_one->dwResultReadClauseLen,
448                                      &new_one->dwResultReadClauseOffset, FALSE);
449
450         current_offset = updateField(lpcs->dwResultReadStrLen,
451                                      lpcs->dwResultReadStrOffset,
452                                      current_offset, newdata, olddata,
453                                      &new_one->dwResultReadStrLen,
454                                      &new_one->dwResultReadStrOffset, TRUE);
455
456         /* new ResultClause , ResultStr */
457
458         current_offset = updateField(lpcs->dwPrivateSize,
459                                      lpcs->dwPrivateOffset,
460                                      current_offset, newdata, olddata,
461                                      &new_one->dwPrivateSize,
462                                      &new_one->dwPrivateOffset, FALSE);
463     }
464
465     /* set new data */
466     /* ResultClause */
467     if (len > 0)
468     {
469         new_one->dwResultClauseLen = sizeof(DWORD) * 2;
470         new_one->dwResultClauseOffset = current_offset;
471         *(DWORD*)(&newdata[current_offset]) = 0;
472         current_offset += sizeof(DWORD);
473         *(DWORD*)(&newdata[current_offset]) = len;
474         current_offset += sizeof(DWORD);
475     }
476
477     /* ResultStr */
478     new_one->dwResultStrLen = len;
479     if (len > 0)
480     {
481         new_one->dwResultStrOffset = current_offset;
482         memcpy(&newdata[current_offset],resultstr,len*sizeof(WCHAR));
483     }
484     ImmUnlockIMCC(rc);
485     if (lpcs)
486         ImmUnlockIMCC(old);
487
488     return rc;
489 }
490
491
492
493 /***********************************************************************
494  *              ImmAssociateContext (IMM32.@)
495  */
496 HIMC WINAPI ImmAssociateContext(HWND hWnd, HIMC hIMC)
497 {
498     InputContextData *data = (InputContextData*)hIMC;
499
500     WARN("(%p, %p): semi-stub\n", hWnd, hIMC);
501
502     if (!hIMC)
503         return NULL;
504
505     /*
506      * WINE SPECIFIC! MAY CONFLICT
507      * associate the root context we have an XIM created
508      */
509     if (hWnd == 0x000)
510     {
511         root_context = (InputContextData*)hIMC;
512     }
513
514     /*
515      * If already associated just return
516      */
517     if (data->IMC.hWnd == hWnd)
518         return hIMC;
519
520     if (IsWindow(data->IMC.hWnd))
521     {
522         /*
523          * Post a message that your context is switching
524          */
525         SendMessageW(data->IMC.hWnd, WM_IME_SETCONTEXT, FALSE, ISC_SHOWUIALL);
526     }
527
528     data->IMC.hWnd = hWnd;
529
530     if (IsWindow(data->IMC.hWnd))
531     {
532         /*
533          * Post a message that your context is switching
534          */
535         SendMessageW(data->IMC.hWnd, WM_IME_SETCONTEXT, TRUE, ISC_SHOWUIALL);
536     }
537
538     /*
539      * TODO: We need to keep track of the old context associated
540      * with a window and return it for now we will return NULL;
541      */
542     return NULL;
543 }
544
545 /***********************************************************************
546  *              ImmAssociateContextEx (IMM32.@)
547  */
548 BOOL WINAPI ImmAssociateContextEx(HWND hWnd, HIMC hIMC, DWORD dwFlags)
549 {
550     FIXME("(%p, %p, %d): stub\n", hWnd, hIMC, dwFlags);
551     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
552     return FALSE;
553 }
554
555 /***********************************************************************
556  *              ImmConfigureIMEA (IMM32.@)
557  */
558 BOOL WINAPI ImmConfigureIMEA(
559   HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
560 {
561   FIXME("(%p, %p, %d, %p): stub\n",
562     hKL, hWnd, dwMode, lpData
563   );
564   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
565   return FALSE;
566 }
567
568 /***********************************************************************
569  *              ImmConfigureIMEW (IMM32.@)
570  */
571 BOOL WINAPI ImmConfigureIMEW(
572   HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
573 {
574   FIXME("(%p, %p, %d, %p): stub\n",
575     hKL, hWnd, dwMode, lpData
576   );
577   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
578   return FALSE;
579 }
580
581 /***********************************************************************
582  *              ImmCreateContext (IMM32.@)
583  */
584 HIMC WINAPI ImmCreateContext(void)
585 {
586     InputContextData *new_context;
587
588     new_context = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(InputContextData));
589
590     return (HIMC)new_context;
591 }
592
593 /***********************************************************************
594  *              ImmDestroyContext (IMM32.@)
595  */
596 BOOL WINAPI ImmDestroyContext(HIMC hIMC)
597 {
598     InputContextData *data = (InputContextData*)hIMC;
599
600     TRACE("Destroying %p\n",hIMC);
601
602     if (hIMC)
603     {
604         ImmDestroyIMCC(root_context->IMC.hCompStr);
605         ImmDestroyIMCC(root_context->IMC.hCandInfo);
606         ImmDestroyIMCC(root_context->IMC.hGuideLine);
607         ImmDestroyIMCC(root_context->IMC.hPrivate);
608         ImmDestroyIMCC(root_context->IMC.hMsgBuf);
609
610         if (data->textfont)
611         {
612             DeleteObject(data->textfont);
613             data->textfont = NULL;
614         }
615
616         HeapFree(GetProcessHeap(),0,data);
617     }
618     return TRUE;
619 }
620
621 /***********************************************************************
622  *              ImmDisableIME (IMM32.@)
623  */
624 BOOL WINAPI ImmDisableIME(DWORD idThread)
625 {
626     FIXME("(%d): stub\n", idThread);
627     return TRUE;
628 }
629
630 /***********************************************************************
631  *              ImmEnumRegisterWordA (IMM32.@)
632  */
633 UINT WINAPI ImmEnumRegisterWordA(
634   HKL hKL, REGISTERWORDENUMPROCA lpfnEnumProc,
635   LPCSTR lpszReading, DWORD dwStyle,
636   LPCSTR lpszRegister, LPVOID lpData)
637 {
638   FIXME("(%p, %p, %s, %d, %s, %p): stub\n",
639     hKL, lpfnEnumProc,
640     debugstr_a(lpszReading), dwStyle,
641     debugstr_a(lpszRegister), lpData
642   );
643   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
644   return 0;
645 }
646
647 /***********************************************************************
648  *              ImmEnumRegisterWordW (IMM32.@)
649  */
650 UINT WINAPI ImmEnumRegisterWordW(
651   HKL hKL, REGISTERWORDENUMPROCW lpfnEnumProc,
652   LPCWSTR lpszReading, DWORD dwStyle,
653   LPCWSTR lpszRegister, LPVOID lpData)
654 {
655   FIXME("(%p, %p, %s, %d, %s, %p): stub\n",
656     hKL, lpfnEnumProc,
657     debugstr_w(lpszReading), dwStyle,
658     debugstr_w(lpszRegister), lpData
659   );
660   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
661   return 0;
662 }
663
664 /***********************************************************************
665  *              ImmEscapeA (IMM32.@)
666  */
667 LRESULT WINAPI ImmEscapeA(
668   HKL hKL, HIMC hIMC,
669   UINT uEscape, LPVOID lpData)
670 {
671   FIXME("(%p, %p, %d, %p): stub\n",
672     hKL, hIMC, uEscape, lpData
673   );
674   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
675   return 0;
676 }
677
678 /***********************************************************************
679  *              ImmEscapeW (IMM32.@)
680  */
681 LRESULT WINAPI ImmEscapeW(
682   HKL hKL, HIMC hIMC,
683   UINT uEscape, LPVOID lpData)
684 {
685   FIXME("(%p, %p, %d, %p): stub\n",
686     hKL, hIMC, uEscape, lpData
687   );
688   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
689   return 0;
690 }
691
692 /***********************************************************************
693  *              ImmGetCandidateListA (IMM32.@)
694  */
695 DWORD WINAPI ImmGetCandidateListA(
696   HIMC hIMC, DWORD deIndex,
697   LPCANDIDATELIST lpCandList, DWORD dwBufLen)
698 {
699   FIXME("(%p, %d, %p, %d): stub\n",
700     hIMC, deIndex,
701     lpCandList, dwBufLen
702   );
703   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
704   return 0;
705 }
706
707 /***********************************************************************
708  *              ImmGetCandidateListCountA (IMM32.@)
709  */
710 DWORD WINAPI ImmGetCandidateListCountA(
711   HIMC hIMC, LPDWORD lpdwListCount)
712 {
713   FIXME("(%p, %p): stub\n", hIMC, lpdwListCount);
714   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
715   return 0;
716 }
717
718 /***********************************************************************
719  *              ImmGetCandidateListCountW (IMM32.@)
720  */
721 DWORD WINAPI ImmGetCandidateListCountW(
722   HIMC hIMC, LPDWORD lpdwListCount)
723 {
724   FIXME("(%p, %p): stub\n", hIMC, lpdwListCount);
725   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
726   return 0;
727 }
728
729 /***********************************************************************
730  *              ImmGetCandidateListW (IMM32.@)
731  */
732 DWORD WINAPI ImmGetCandidateListW(
733   HIMC hIMC, DWORD deIndex,
734   LPCANDIDATELIST lpCandList, DWORD dwBufLen)
735 {
736   FIXME("(%p, %d, %p, %d): stub\n",
737     hIMC, deIndex,
738     lpCandList, dwBufLen
739   );
740   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
741   return 0;
742 }
743
744 /***********************************************************************
745  *              ImmGetCandidateWindow (IMM32.@)
746  */
747 BOOL WINAPI ImmGetCandidateWindow(
748   HIMC hIMC, DWORD dwBufLen, LPCANDIDATEFORM lpCandidate)
749 {
750   FIXME("(%p, %d, %p): stub\n", hIMC, dwBufLen, lpCandidate);
751   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
752   return FALSE;
753 }
754
755 /***********************************************************************
756  *              ImmGetCompositionFontA (IMM32.@)
757  */
758 BOOL WINAPI ImmGetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
759 {
760   FIXME("(%p, %p): stub\n", hIMC, lplf);
761   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
762   return FALSE;
763 }
764
765 /***********************************************************************
766  *              ImmGetCompositionFontW (IMM32.@)
767  */
768 BOOL WINAPI ImmGetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
769 {
770   FIXME("(%p, %p): stub\n", hIMC, lplf);
771   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
772   return FALSE;
773 }
774
775 /***********************************************************************
776  *              ImmGetCompositionStringA (IMM32.@)
777  */
778 LONG WINAPI ImmGetCompositionStringA(
779   HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen)
780 {
781     CHAR *buf;
782     LONG rc = 0;
783     InputContextData *data = (InputContextData*)hIMC;
784     LPCOMPOSITIONSTRING compstr;
785     LPBYTE compdata;
786
787     TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
788
789     if (!data)
790        return FALSE;
791
792     if (!data->IMC.hCompStr)
793        return FALSE;
794
795     compdata = ImmLockIMCC(data->IMC.hCompStr);
796     compstr = (LPCOMPOSITIONSTRING)compdata;
797
798     if (dwIndex == GCS_RESULTSTR && compstr->dwResultStrLen > 0 &&
799         compstr->dwResultStrOffset > 0)
800     {
801         LPWSTR ResultStr = (LPWSTR)(compdata + compstr->dwResultStrOffset);
802
803         TRACE("GSC_RESULTSTR %p %i\n",ResultStr,
804                                     compstr->dwResultStrLen);
805
806         buf = HeapAlloc( GetProcessHeap(), 0, compstr->dwResultStrLen * 3 );
807         rc = WideCharToMultiByte(CP_ACP, 0, ResultStr,
808                                  compstr->dwResultStrLen , buf,
809                                  compstr->dwResultStrLen * 3, NULL, NULL);
810         if (dwBufLen >= rc)
811             memcpy(lpBuf,buf,rc);
812
813         data->bRead = TRUE;
814         HeapFree( GetProcessHeap(), 0, buf );
815     }
816     else if (dwIndex == GCS_COMPSTR && compstr->dwCompStrLen > 0 &&
817               compstr->dwCompStrOffset > 0)
818     {
819         LPWSTR CompString = (LPWSTR)(compdata + compstr->dwCompStrOffset);
820
821         TRACE("GSC_COMPSTR %p %i\n", CompString, compstr->dwCompStrLen);
822
823         buf = HeapAlloc( GetProcessHeap(), 0, compstr->dwCompStrLen * 3 );
824         rc = WideCharToMultiByte(CP_ACP, 0, CompString,
825                                  compstr->dwCompStrLen, buf,
826                                  compstr->dwCompStrLen * 3, NULL, NULL);
827         if (dwBufLen >= rc)
828             memcpy(lpBuf,buf,rc);
829         HeapFree( GetProcessHeap(), 0, buf );
830     }
831     else if (dwIndex == GCS_COMPATTR && compstr->dwCompAttrLen > 0 &&
832              compstr->dwCompAttrOffset > 0)
833     {
834         LPWSTR Compattr = (LPWSTR)(compdata + compstr->dwCompAttrOffset);
835         TRACE("GSC_COMPATTR %p %i\n", Compattr , compstr->dwCompAttrLen);
836
837         rc = compstr->dwCompAttrLen;
838         if (dwBufLen >= rc)
839             memcpy(lpBuf,Compattr,rc);
840     }
841     else if (dwIndex == GCS_COMPCLAUSE && compstr->dwCompClauseLen > 0 &&
842              compstr->dwCompClauseOffset > 0)
843     {
844         LPWSTR Compclause = (LPWSTR)(compdata + compstr->dwCompClauseOffset);
845         TRACE("GSC_COMPCLAUSE %p %i\n", Compclause, compstr->dwCompClauseLen);
846
847         rc = compstr->dwCompClauseLen;
848         if (dwBufLen >= compstr->dwCompClauseLen)
849             memcpy(lpBuf,Compclause,rc);
850     }
851     else if (dwIndex == GCS_RESULTCLAUSE && compstr->dwResultClauseLen > 0 &&
852              compstr->dwResultClauseOffset > 0)
853     {
854         LPWSTR Resultclause = (LPWSTR)(compdata + compstr->dwResultClauseOffset);
855         TRACE("GSC_RESULTCLAUSE %p %i\n", Resultclause, compstr->dwResultClauseLen);
856
857         rc = compstr->dwResultClauseLen;
858         if (dwBufLen >= compstr->dwResultClauseLen)
859             memcpy(lpBuf,Resultclause,rc);
860     }
861     else if (dwIndex == GCS_CURSORPOS)
862     {
863         TRACE("GSC_CURSORPOS\n");
864         rc = compstr->dwCursorPos;
865     }
866     else if (dwIndex == GCS_DELTASTART)
867     {
868         TRACE("GCS_DELTASTART\n");
869         rc = compstr->dwDeltaStart;
870     }
871     else
872     {
873         FIXME("Unhandled index 0x%x\n",dwIndex);
874     }
875
876     ImmUnlockIMCC(data->IMC.hCompStr);
877
878     return rc;
879 }
880
881 /***********************************************************************
882  *              ImmGetCompositionStringW (IMM32.@)
883  */
884 LONG WINAPI ImmGetCompositionStringW(
885   HIMC hIMC, DWORD dwIndex,
886   LPVOID lpBuf, DWORD dwBufLen)
887 {
888     LONG rc = 0;
889     InputContextData *data = (InputContextData*)hIMC;
890     LPCOMPOSITIONSTRING compstr;
891     LPBYTE compdata;
892
893     TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
894
895     if (!data)
896        return FALSE;
897
898     if (!data->IMC.hCompStr)
899        return FALSE;
900
901     compdata = ImmLockIMCC(data->IMC.hCompStr);
902     compstr = (LPCOMPOSITIONSTRING)compdata;
903
904     if (dwIndex == GCS_RESULTSTR && compstr->dwResultStrLen > 0 &&
905         compstr->dwResultStrOffset > 0)
906     {
907         LPWSTR ResultStr = (LPWSTR)(compdata + compstr->dwResultStrOffset);
908         data->bRead = TRUE;
909         rc =  compstr->dwResultStrLen * sizeof(WCHAR);
910
911         if (dwBufLen >= rc)
912             memcpy(lpBuf,ResultStr,rc);
913     }
914     else if (dwIndex == GCS_RESULTREADSTR && compstr->dwResultReadStrLen > 0 &&
915              compstr->dwResultReadStrOffset > 0)
916     {
917         LPWSTR ResultReadString = (LPWSTR)(compdata + compstr->dwResultReadStrOffset);
918
919         rc = compstr->dwResultReadStrLen * sizeof(WCHAR);
920         if (dwBufLen >= rc)
921             memcpy(lpBuf,ResultReadString,rc);
922     }
923     else if (dwIndex == GCS_COMPSTR && compstr->dwCompStrLen > 0 &&
924               compstr->dwCompStrOffset > 0)
925     {
926         LPWSTR CompString = (LPWSTR)(compdata + compstr->dwCompStrOffset);
927         rc = compstr->dwCompStrLen * sizeof(WCHAR);
928         if (dwBufLen >= rc)
929             memcpy(lpBuf,CompString,rc);
930     }
931     else if (dwIndex == GCS_COMPATTR && compstr->dwCompAttrLen > 0 &&
932              compstr->dwCompAttrOffset > 0)
933     {
934
935         LPWSTR Compattr = (LPWSTR)(compdata + compstr->dwCompAttrOffset);
936
937         rc = compstr->dwCompAttrLen;
938         if (dwBufLen >= rc)
939             memcpy(lpBuf,Compattr,rc);
940     }
941     else if (dwIndex == GCS_COMPCLAUSE && compstr->dwCompClauseLen > 0 &&
942              compstr->dwCompClauseOffset > 0)
943     {
944         LPWSTR Compclause = (LPWSTR)(compdata + compstr->dwCompClauseOffset);
945
946         rc = compstr->dwCompClauseLen;
947         if (dwBufLen >= compstr->dwCompClauseLen)
948             memcpy(lpBuf,Compclause,rc);
949     }
950     else if (dwIndex == GCS_COMPREADSTR && compstr->dwCompReadStrLen > 0 &&
951               compstr->dwCompReadStrOffset > 0)
952     {
953         LPWSTR CompReadString = (LPWSTR)(compdata + compstr->dwCompReadStrOffset);
954
955         rc = compstr->dwCompReadStrLen * sizeof(WCHAR);
956
957         if (dwBufLen >= rc)
958             memcpy(lpBuf,CompReadString,rc);
959     }
960     else if (dwIndex == GCS_CURSORPOS)
961     {
962         TRACE("GSC_CURSORPOS\n");
963         rc = compstr->dwCursorPos;
964     }
965     else if (dwIndex == GCS_DELTASTART)
966     {
967         TRACE("GCS_DELTASTART\n");
968         rc = compstr->dwDeltaStart;
969     }
970     else
971     {
972         FIXME("Unhandled index 0x%x\n",dwIndex);
973     }   
974
975     ImmUnlockIMCC(data->IMC.hCompStr);
976
977     return rc;
978 }
979
980 /***********************************************************************
981  *              ImmGetCompositionWindow (IMM32.@)
982  */
983 BOOL WINAPI ImmGetCompositionWindow(HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
984 {
985     InputContextData *data = (InputContextData*)hIMC;
986
987     TRACE("(%p, %p)\n", hIMC, lpCompForm);
988
989     if (!data)
990         return FALSE;
991
992     memcpy(lpCompForm,&(data->IMC.cfCompForm),sizeof(COMPOSITIONFORM));
993     return 1;
994 }
995
996 /***********************************************************************
997  *              ImmGetContext (IMM32.@)
998  *
999  */
1000 HIMC WINAPI ImmGetContext(HWND hWnd)
1001 {
1002     TRACE("%p\n", hWnd);
1003
1004     if (!root_context)
1005         return NULL;
1006
1007     root_context->IMC.hWnd = hWnd;
1008     return (HIMC)root_context;
1009 }
1010
1011 /***********************************************************************
1012  *              ImmGetConversionListA (IMM32.@)
1013  */
1014 DWORD WINAPI ImmGetConversionListA(
1015   HKL hKL, HIMC hIMC,
1016   LPCSTR pSrc, LPCANDIDATELIST lpDst,
1017   DWORD dwBufLen, UINT uFlag)
1018 {
1019   FIXME("(%p, %p, %s, %p, %d, %d): stub\n",
1020     hKL, hIMC, debugstr_a(pSrc), lpDst, dwBufLen, uFlag
1021   );
1022   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1023   return 0;
1024 }
1025
1026 /***********************************************************************
1027  *              ImmGetConversionListW (IMM32.@)
1028  */
1029 DWORD WINAPI ImmGetConversionListW(
1030   HKL hKL, HIMC hIMC,
1031   LPCWSTR pSrc, LPCANDIDATELIST lpDst,
1032   DWORD dwBufLen, UINT uFlag)
1033 {
1034   FIXME("(%p, %p, %s, %p, %d, %d): stub\n",
1035     hKL, hIMC, debugstr_w(pSrc), lpDst, dwBufLen, uFlag
1036   );
1037   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1038   return 0;
1039 }
1040
1041 /***********************************************************************
1042  *              ImmGetConversionStatus (IMM32.@)
1043  */
1044 BOOL WINAPI ImmGetConversionStatus(
1045   HIMC hIMC, LPDWORD lpfdwConversion, LPDWORD lpfdwSentence)
1046 {
1047     TRACE("(%p, %p, %p): best guess\n", hIMC, lpfdwConversion, lpfdwSentence);
1048     if (lpfdwConversion)
1049         *lpfdwConversion = IME_CMODE_NATIVE;
1050     if (lpfdwSentence)
1051         *lpfdwSentence = IME_SMODE_NONE;
1052     return TRUE;
1053 }
1054
1055 /***********************************************************************
1056  *              ImmGetDefaultIMEWnd (IMM32.@)
1057  */
1058 HWND WINAPI ImmGetDefaultIMEWnd(HWND hWnd)
1059 {
1060   static int shown = 0;
1061
1062   if (!shown) {
1063         FIXME("(%p - %p %p ): semi-stub\n", hWnd,hwndDefault, root_context);
1064         shown = 1;
1065   }
1066
1067   if (hwndDefault == NULL)
1068   {
1069         static const WCHAR the_name[] = {'I','M','E','\0'};
1070
1071         IMM_Register();
1072         hwndDefault = CreateWindowExW( WS_EX_TOOLWINDOW, WC_IMECLASSNAME,
1073                 the_name, WS_POPUP, 0, 0, 1, 1, 0, 0,
1074                 hImeInst, 0);
1075
1076         TRACE("Default created (%p)\n",hwndDefault);
1077   }
1078
1079   return (HWND)hwndDefault;
1080 }
1081
1082 /***********************************************************************
1083  *              ImmGetDescriptionA (IMM32.@)
1084  */
1085 UINT WINAPI ImmGetDescriptionA(
1086   HKL hKL, LPSTR lpszDescription, UINT uBufLen)
1087 {
1088   WCHAR *buf;
1089   DWORD len;
1090
1091   TRACE("%p %p %d\n", hKL, lpszDescription, uBufLen);
1092
1093   /* find out how many characters in the unicode buffer */
1094   len = ImmGetDescriptionW( hKL, NULL, 0 );
1095
1096   /* allocate a buffer of that size */
1097   buf = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof (WCHAR) );
1098   if( !buf )
1099   return 0;
1100
1101   /* fetch the unicode buffer */
1102   len = ImmGetDescriptionW( hKL, buf, len + 1 );
1103
1104   /* convert it back to ASCII */
1105   len = WideCharToMultiByte( CP_ACP, 0, buf, len + 1,
1106                              lpszDescription, uBufLen, NULL, NULL );
1107
1108   HeapFree( GetProcessHeap(), 0, buf );
1109
1110   return len;
1111 }
1112
1113 /***********************************************************************
1114  *              ImmGetDescriptionW (IMM32.@)
1115  */
1116 UINT WINAPI ImmGetDescriptionW(HKL hKL, LPWSTR lpszDescription, UINT uBufLen)
1117 {
1118   static const WCHAR name[] = { 'W','i','n','e',' ','X','I','M',0 };
1119
1120   FIXME("(%p, %p, %d): semi stub\n", hKL, lpszDescription, uBufLen);
1121
1122   if (!uBufLen) return lstrlenW( name );
1123   lstrcpynW( lpszDescription, name, uBufLen );
1124   return lstrlenW( lpszDescription );
1125 }
1126
1127 /***********************************************************************
1128  *              ImmGetGuideLineA (IMM32.@)
1129  */
1130 DWORD WINAPI ImmGetGuideLineA(
1131   HIMC hIMC, DWORD dwIndex, LPSTR lpBuf, DWORD dwBufLen)
1132 {
1133   FIXME("(%p, %d, %s, %d): stub\n",
1134     hIMC, dwIndex, debugstr_a(lpBuf), dwBufLen
1135   );
1136   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1137   return 0;
1138 }
1139
1140 /***********************************************************************
1141  *              ImmGetGuideLineW (IMM32.@)
1142  */
1143 DWORD WINAPI ImmGetGuideLineW(HIMC hIMC, DWORD dwIndex, LPWSTR lpBuf, DWORD dwBufLen)
1144 {
1145   FIXME("(%p, %d, %s, %d): stub\n",
1146     hIMC, dwIndex, debugstr_w(lpBuf), dwBufLen
1147   );
1148   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1149   return 0;
1150 }
1151
1152 /***********************************************************************
1153  *              ImmGetIMEFileNameA (IMM32.@)
1154  */
1155 UINT WINAPI ImmGetIMEFileNameA(
1156   HKL hKL, LPSTR lpszFileName, UINT uBufLen)
1157 {
1158   FIXME("(%p, %p, %d): stub\n", hKL, lpszFileName, uBufLen);
1159   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1160   return 0;
1161 }
1162
1163 /***********************************************************************
1164  *              ImmGetIMEFileNameW (IMM32.@)
1165  */
1166 UINT WINAPI ImmGetIMEFileNameW(
1167   HKL hKL, LPWSTR lpszFileName, UINT uBufLen)
1168 {
1169   FIXME("(%p, %p, %d): stub\n", hKL, lpszFileName, uBufLen);
1170   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1171   return 0;
1172 }
1173
1174 /***********************************************************************
1175  *              ImmGetOpenStatus (IMM32.@)
1176  */
1177 BOOL WINAPI ImmGetOpenStatus(HIMC hIMC)
1178 {
1179   InputContextData *data = (InputContextData*)hIMC;
1180
1181     if (!data)
1182         return FALSE;
1183   FIXME("(%p): semi-stub\n", hIMC);
1184
1185   return data->IMC.fOpen;
1186 }
1187
1188 /***********************************************************************
1189  *              ImmGetProperty (IMM32.@)
1190  */
1191 DWORD WINAPI ImmGetProperty(HKL hKL, DWORD fdwIndex)
1192 {
1193     DWORD rc = 0;
1194     TRACE("(%p, %d)\n", hKL, fdwIndex);
1195
1196     switch (fdwIndex)
1197     {
1198         case IGP_PROPERTY:
1199             TRACE("(%s)\n", "IGP_PROPERTY");
1200             rc = IME_PROP_UNICODE | IME_PROP_AT_CARET;
1201             break;
1202         case IGP_CONVERSION:
1203             FIXME("(%s)\n", "IGP_CONVERSION");
1204             rc = IME_CMODE_NATIVE;
1205             break;
1206         case IGP_SENTENCE:
1207             FIXME("%s)\n", "IGP_SENTENCE");
1208             rc = IME_SMODE_AUTOMATIC;
1209             break;
1210         case IGP_SETCOMPSTR:
1211             TRACE("(%s)\n", "IGP_SETCOMPSTR");
1212             rc = 0;
1213             break;
1214         case IGP_SELECT:
1215             TRACE("(%s)\n", "IGP_SELECT");
1216             rc = SELECT_CAP_CONVERSION | SELECT_CAP_SENTENCE;
1217             break;
1218         case IGP_GETIMEVERSION:
1219             TRACE("(%s)\n", "IGP_GETIMEVERSION");
1220             rc = IMEVER_0400;
1221             break;
1222         case IGP_UI:
1223             TRACE("(%s)\n", "IGP_UI");
1224             rc = 0;
1225             break;
1226         default:
1227             rc = 0;
1228     }
1229     return rc;
1230 }
1231
1232 /***********************************************************************
1233  *              ImmGetRegisterWordStyleA (IMM32.@)
1234  */
1235 UINT WINAPI ImmGetRegisterWordStyleA(
1236   HKL hKL, UINT nItem, LPSTYLEBUFA lpStyleBuf)
1237 {
1238   FIXME("(%p, %d, %p): stub\n", hKL, nItem, lpStyleBuf);
1239   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1240   return 0;
1241 }
1242
1243 /***********************************************************************
1244  *              ImmGetRegisterWordStyleW (IMM32.@)
1245  */
1246 UINT WINAPI ImmGetRegisterWordStyleW(
1247   HKL hKL, UINT nItem, LPSTYLEBUFW lpStyleBuf)
1248 {
1249   FIXME("(%p, %d, %p): stub\n", hKL, nItem, lpStyleBuf);
1250   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1251   return 0;
1252 }
1253
1254 /***********************************************************************
1255  *              ImmGetStatusWindowPos (IMM32.@)
1256  */
1257 BOOL WINAPI ImmGetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
1258 {
1259   FIXME("(%p, %p): stub\n", hIMC, lpptPos);
1260   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1261   return FALSE;
1262 }
1263
1264 /***********************************************************************
1265  *              ImmGetVirtualKey (IMM32.@)
1266  */
1267 UINT WINAPI ImmGetVirtualKey(HWND hWnd)
1268 {
1269   OSVERSIONINFOA version;
1270   FIXME("(%p): stub\n", hWnd);
1271   GetVersionExA( &version );
1272   switch(version.dwPlatformId)
1273   {
1274   case VER_PLATFORM_WIN32_WINDOWS:
1275       return VK_PROCESSKEY;
1276   case VER_PLATFORM_WIN32_NT:
1277       return 0;
1278   default:
1279       FIXME("%d not supported\n",version.dwPlatformId);
1280       return VK_PROCESSKEY;
1281   }
1282 }
1283
1284 /***********************************************************************
1285  *              ImmInstallIMEA (IMM32.@)
1286  */
1287 HKL WINAPI ImmInstallIMEA(
1288   LPCSTR lpszIMEFileName, LPCSTR lpszLayoutText)
1289 {
1290   FIXME("(%s, %s): stub\n",
1291     debugstr_a(lpszIMEFileName), debugstr_a(lpszLayoutText)
1292   );
1293   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1294   return NULL;
1295 }
1296
1297 /***********************************************************************
1298  *              ImmInstallIMEW (IMM32.@)
1299  */
1300 HKL WINAPI ImmInstallIMEW(
1301   LPCWSTR lpszIMEFileName, LPCWSTR lpszLayoutText)
1302 {
1303   FIXME("(%s, %s): stub\n",
1304     debugstr_w(lpszIMEFileName), debugstr_w(lpszLayoutText)
1305   );
1306   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1307   return NULL;
1308 }
1309
1310 /***********************************************************************
1311  *              ImmIsIME (IMM32.@)
1312  */
1313 BOOL WINAPI ImmIsIME(HKL hKL)
1314 {
1315   TRACE("(%p): semi-stub\n", hKL);
1316   /*
1317    * FIXME: Dead key locales will return TRUE here when they should not
1318    * There is probably a more proper way to check this.
1319    */
1320   return (root_context != NULL);
1321 }
1322
1323 /***********************************************************************
1324  *              ImmIsUIMessageA (IMM32.@)
1325  */
1326 BOOL WINAPI ImmIsUIMessageA(
1327   HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
1328 {
1329     BOOL rc = FALSE;
1330
1331     TRACE("(%p, %x, %ld, %ld)\n", hWndIME, msg, wParam, lParam);
1332     if ((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
1333         (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP) ||
1334         (msg == WM_MSIME_SERVICE) ||
1335         (msg == WM_MSIME_RECONVERTOPTIONS) ||
1336         (msg == WM_MSIME_MOUSE) ||
1337         (msg == WM_MSIME_RECONVERTREQUEST) ||
1338         (msg == WM_MSIME_RECONVERT) ||
1339         (msg == WM_MSIME_QUERYPOSITION) ||
1340         (msg == WM_MSIME_DOCUMENTFEED))
1341
1342     {
1343         if (!hwndDefault)
1344             ImmGetDefaultIMEWnd(NULL);
1345
1346         if (hWndIME == NULL)
1347             PostMessageA(hwndDefault, msg, wParam, lParam);
1348
1349         rc = TRUE;
1350     }
1351     return rc;
1352 }
1353
1354 /***********************************************************************
1355  *              ImmIsUIMessageW (IMM32.@)
1356  */
1357 BOOL WINAPI ImmIsUIMessageW(
1358   HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
1359 {
1360     BOOL rc = FALSE;
1361     TRACE("(%p, %d, %ld, %ld): stub\n", hWndIME, msg, wParam, lParam);
1362     if ((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
1363         (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP) ||
1364         (msg == WM_MSIME_SERVICE) ||
1365         (msg == WM_MSIME_RECONVERTOPTIONS) ||
1366         (msg == WM_MSIME_MOUSE) ||
1367         (msg == WM_MSIME_RECONVERTREQUEST) ||
1368         (msg == WM_MSIME_RECONVERT) ||
1369         (msg == WM_MSIME_QUERYPOSITION) ||
1370         (msg == WM_MSIME_DOCUMENTFEED))
1371         rc = TRUE;
1372     return rc;
1373 }
1374
1375 /***********************************************************************
1376  *              ImmNotifyIME (IMM32.@)
1377  */
1378 BOOL WINAPI ImmNotifyIME(
1379   HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue)
1380 {
1381     BOOL rc = FALSE;
1382
1383     TRACE("(%p, %d, %d, %d)\n",
1384         hIMC, dwAction, dwIndex, dwValue);
1385
1386     if (!root_context)
1387         return rc;
1388
1389     switch(dwAction)
1390     {
1391         case NI_CHANGECANDIDATELIST:
1392             FIXME("%s\n","NI_CHANGECANDIDATELIST");
1393             break;
1394         case NI_CLOSECANDIDATE:
1395             FIXME("%s\n","NI_CLOSECANDIDATE");
1396             break;
1397         case NI_COMPOSITIONSTR:
1398             switch (dwIndex)
1399             {
1400                 case CPS_CANCEL:
1401                     TRACE("%s - %s\n","NI_COMPOSITIONSTR","CPS_CANCEL");
1402                     {
1403                         HIMCC newCompStr;
1404                         if (pX11DRV_ForceXIMReset)
1405                             pX11DRV_ForceXIMReset(root_context->IMC.hWnd);
1406
1407                         newCompStr = updateCompStr(root_context->IMC.hCompStr, NULL, 0);
1408                         ImmDestroyIMCC(root_context->IMC.hCompStr);
1409                         root_context->IMC.hCompStr = newCompStr;
1410
1411                         ImmInternalPostIMEMessage(WM_IME_COMPOSITION, 0,
1412                                                   GCS_COMPSTR);
1413                         rc = TRUE;
1414                     }
1415                     break;
1416                 case CPS_COMPLETE:
1417                     TRACE("%s - %s\n","NI_COMPOSITIONSTR","CPS_COMPLETE");
1418                     if (hIMC != (HIMC)FROM_IME && pX11DRV_ForceXIMReset)
1419                         pX11DRV_ForceXIMReset(root_context->IMC.hWnd);
1420                     {
1421                         HIMCC newCompStr;
1422                         DWORD cplen;
1423                         LPWSTR cpstr;
1424                         LPCOMPOSITIONSTRING cs = NULL;
1425                         LPBYTE cdata = NULL;
1426
1427                         /* clear existing result */
1428                         newCompStr = updateResultStr(root_context->IMC.hCompStr, NULL, 0);
1429                         ImmDestroyIMCC(root_context->IMC.hCompStr);
1430                         root_context->IMC.hCompStr = newCompStr;
1431
1432                         cdata = ImmLockIMCC(root_context->IMC.hCompStr);
1433                         cs = (LPCOMPOSITIONSTRING)cdata;
1434                         cplen = cs->dwCompStrLen;
1435                         cpstr = (LPWSTR)&(cdata[cs->dwCompStrOffset]);
1436                         ImmUnlockIMCC(root_context->IMC.hCompStr);
1437                         if (cplen > 0)
1438                         {
1439                             WCHAR param = cpstr[0];
1440                             newCompStr = updateResultStr(root_context->IMC.hCompStr, cpstr, cplen);
1441                             ImmDestroyIMCC(root_context->IMC.hCompStr);
1442                             root_context->IMC.hCompStr = newCompStr;
1443                             newCompStr = updateCompStr(root_context->IMC.hCompStr, NULL, 0);
1444                             ImmDestroyIMCC(root_context->IMC.hCompStr);
1445                             root_context->IMC.hCompStr = newCompStr;
1446
1447                             root_context->bRead = FALSE;
1448
1449                             ImmInternalPostIMEMessage(WM_IME_COMPOSITION, 0,
1450                                                   GCS_COMPSTR);
1451
1452                             ImmInternalPostIMEMessage(WM_IME_COMPOSITION,
1453                                             param,
1454                                             GCS_RESULTSTR|GCS_RESULTCLAUSE);
1455                         }
1456
1457                         ImmInternalPostIMEMessage(WM_IME_ENDCOMPOSITION, 0, 0);
1458                         root_context->bInComposition = FALSE;
1459                     }
1460                     break;
1461                 case CPS_CONVERT:
1462                     FIXME("%s - %s\n","NI_COMPOSITIONSTR","CPS_CONVERT");
1463                     break;
1464                 case CPS_REVERT:
1465                     FIXME("%s - %s\n","NI_COMPOSITIONSTR","CPS_REVERT");
1466                     break;
1467                 default:
1468                     ERR("%s - %s (%i)\n","NI_COMPOSITIONSTR","UNKNOWN",dwIndex);
1469                     break;
1470             }
1471             break;
1472         case NI_IMEMENUSELECTED:
1473             FIXME("%s\n", "NI_IMEMENUSELECTED");
1474             break;
1475         case NI_OPENCANDIDATE:
1476             FIXME("%s\n", "NI_OPENCANDIDATE");
1477             break;
1478         case NI_SELECTCANDIDATESTR:
1479             FIXME("%s\n", "NI_SELECTCANDIDATESTR");
1480             break;
1481         case NI_SETCANDIDATE_PAGESIZE:
1482             FIXME("%s\n", "NI_SETCANDIDATE_PAGESIZE");
1483             break;
1484         case NI_SETCANDIDATE_PAGESTART:
1485             FIXME("%s\n", "NI_SETCANDIDATE_PAGESTART");
1486             break;
1487         default:
1488             ERR("Unknown\n");
1489     }
1490
1491     return rc;
1492 }
1493
1494 /***********************************************************************
1495  *              ImmRegisterWordA (IMM32.@)
1496  */
1497 BOOL WINAPI ImmRegisterWordA(
1498   HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister)
1499 {
1500   FIXME("(%p, %s, %d, %s): stub\n",
1501     hKL, debugstr_a(lpszReading), dwStyle, debugstr_a(lpszRegister)
1502   );
1503   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1504   return FALSE;
1505 }
1506
1507 /***********************************************************************
1508  *              ImmRegisterWordW (IMM32.@)
1509  */
1510 BOOL WINAPI ImmRegisterWordW(
1511   HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister)
1512 {
1513   FIXME("(%p, %s, %d, %s): stub\n",
1514     hKL, debugstr_w(lpszReading), dwStyle, debugstr_w(lpszRegister)
1515   );
1516   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1517   return FALSE;
1518 }
1519
1520 /***********************************************************************
1521  *              ImmReleaseContext (IMM32.@)
1522  */
1523 BOOL WINAPI ImmReleaseContext(HWND hWnd, HIMC hIMC)
1524 {
1525   static int shown = 0;
1526
1527   if (!shown) {
1528      FIXME("(%p, %p): stub\n", hWnd, hIMC);
1529      shown = 1;
1530   }
1531   return TRUE;
1532 }
1533
1534 /***********************************************************************
1535  *              ImmSetCandidateWindow (IMM32.@)
1536  */
1537 BOOL WINAPI ImmSetCandidateWindow(
1538   HIMC hIMC, LPCANDIDATEFORM lpCandidate)
1539 {
1540   FIXME("(%p, %p): stub\n", hIMC, lpCandidate);
1541   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1542   return FALSE;
1543 }
1544
1545 /***********************************************************************
1546  *              ImmSetCompositionFontA (IMM32.@)
1547  */
1548 BOOL WINAPI ImmSetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
1549 {
1550     InputContextData *data = (InputContextData*)hIMC;
1551     TRACE("(%p, %p)\n", hIMC, lplf);
1552
1553     if (!data)
1554         return FALSE;
1555
1556     memcpy(&data->IMC.lfFont.W,lplf,sizeof(LOGFONTA));
1557     MultiByteToWideChar(CP_ACP, 0, lplf->lfFaceName, -1, data->IMC.lfFont.W.lfFaceName,
1558                         LF_FACESIZE);
1559
1560     ImmInternalSendIMENotify(IMN_SETCOMPOSITIONFONT, 0);
1561
1562     if (data->textfont)
1563     {
1564         DeleteObject(data->textfont);
1565         data->textfont = NULL;
1566     }
1567
1568     data->textfont = CreateFontIndirectW(&data->IMC.lfFont.W);
1569     return TRUE;
1570 }
1571
1572 /***********************************************************************
1573  *              ImmSetCompositionFontW (IMM32.@)
1574  */
1575 BOOL WINAPI ImmSetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
1576 {
1577     InputContextData *data = (InputContextData*)hIMC;
1578     TRACE("(%p, %p)\n", hIMC, lplf);
1579
1580     if (!data)
1581         return FALSE;
1582
1583     memcpy(&data->IMC.lfFont.W,lplf,sizeof(LOGFONTW));
1584     ImmInternalSendIMENotify(IMN_SETCOMPOSITIONFONT, 0);
1585
1586     if (data->textfont)
1587     {
1588         DeleteObject(data->textfont);
1589         data->textfont = NULL;
1590     }
1591     data->textfont = CreateFontIndirectW(&data->IMC.lfFont.W);
1592     return TRUE;
1593 }
1594
1595 /***********************************************************************
1596  *              ImmSetCompositionStringA (IMM32.@)
1597  */
1598 BOOL WINAPI ImmSetCompositionStringA(
1599   HIMC hIMC, DWORD dwIndex,
1600   LPCVOID lpComp, DWORD dwCompLen,
1601   LPCVOID lpRead, DWORD dwReadLen)
1602 {
1603     DWORD comp_len;
1604     DWORD read_len;
1605     WCHAR *CompBuffer = NULL;
1606     WCHAR *ReadBuffer = NULL;
1607     BOOL rc;
1608
1609     TRACE("(%p, %d, %p, %d, %p, %d): stub\n",
1610             hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
1611
1612     comp_len = MultiByteToWideChar(CP_ACP, 0, lpComp, dwCompLen, NULL, 0);
1613     if (comp_len)
1614     {
1615         CompBuffer = HeapAlloc(GetProcessHeap(),0,comp_len * sizeof(WCHAR));
1616         MultiByteToWideChar(CP_ACP, 0, lpComp, dwCompLen, CompBuffer, comp_len);
1617     }
1618
1619     read_len = MultiByteToWideChar(CP_ACP, 0, lpRead, dwReadLen, NULL, 0);
1620     if (read_len)
1621     {
1622         ReadBuffer = HeapAlloc(GetProcessHeap(),0,read_len * sizeof(WCHAR));
1623         MultiByteToWideChar(CP_ACP, 0, lpRead, dwReadLen, ReadBuffer, read_len);
1624     }
1625
1626     rc =  ImmSetCompositionStringW(hIMC, dwIndex, CompBuffer, comp_len,
1627                                    ReadBuffer, read_len);
1628
1629     HeapFree(GetProcessHeap(), 0, CompBuffer);
1630     HeapFree(GetProcessHeap(), 0, ReadBuffer);
1631
1632     return rc;
1633 }
1634
1635 /***********************************************************************
1636  *              ImmSetCompositionStringW (IMM32.@)
1637  */
1638 BOOL WINAPI ImmSetCompositionStringW(
1639         HIMC hIMC, DWORD dwIndex,
1640         LPCVOID lpComp, DWORD dwCompLen,
1641         LPCVOID lpRead, DWORD dwReadLen)
1642 {
1643      DWORD flags = 0;
1644      WCHAR wParam  = 0;
1645
1646      TRACE("(%p, %d, %p, %d, %p, %d): stub\n",
1647              hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
1648
1649
1650      if (hIMC != (HIMC)FROM_IME)
1651          FIXME("PROBLEM: This only sets the wine level string\n");
1652
1653      /*
1654       * Explanation:
1655       *  this sets the composition string in the imm32.dll level
1656       *  of the composition buffer. we cannot manipulate the xim level
1657       *  buffer, which means that once the xim level buffer changes again
1658       *  any call to this function from the application will be lost
1659       */
1660
1661      if (lpRead && dwReadLen)
1662          FIXME("Reading string unimplemented\n");
1663
1664      /*
1665       * app operating this api to also receive the message from xim
1666       */
1667
1668     if (dwIndex == SCS_SETSTR)
1669     {
1670         HIMCC newCompStr;
1671         if (!root_context->bInComposition)
1672         {
1673             ImmInternalPostIMEMessage(WM_IME_STARTCOMPOSITION, 0, 0);
1674             root_context->bInComposition = TRUE;
1675         }
1676
1677         flags = GCS_COMPSTR;
1678
1679         if (dwCompLen && lpComp)
1680         {
1681             newCompStr = updateCompStr(root_context->IMC.hCompStr, (LPWSTR)lpComp, dwCompLen / sizeof(WCHAR));
1682             ImmDestroyIMCC(root_context->IMC.hCompStr);
1683             root_context->IMC.hCompStr = newCompStr;
1684
1685              wParam = ((const WCHAR*)lpComp)[0];
1686              flags |= GCS_COMPCLAUSE | GCS_COMPATTR | GCS_DELTASTART;
1687         }
1688         else
1689         {
1690             newCompStr = updateCompStr(root_context->IMC.hCompStr, NULL, 0);
1691             ImmDestroyIMCC(root_context->IMC.hCompStr);
1692             root_context->IMC.hCompStr = newCompStr;
1693         }
1694     }
1695
1696      UpdateDataInDefaultIMEWindow(hwndDefault,FALSE);
1697
1698      ImmInternalPostIMEMessage(WM_IME_COMPOSITION, wParam, flags);
1699
1700      return TRUE;
1701 }
1702
1703 /***********************************************************************
1704  *              ImmSetCompositionWindow (IMM32.@)
1705  */
1706 BOOL WINAPI ImmSetCompositionWindow(
1707   HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
1708 {
1709     BOOL reshow = FALSE;
1710     InputContextData *data = (InputContextData*)hIMC;
1711
1712     TRACE("(%p, %p)\n", hIMC, lpCompForm);
1713     TRACE("\t%x, (%i,%i), (%i,%i - %i,%i)\n",lpCompForm->dwStyle,
1714           lpCompForm->ptCurrentPos.x, lpCompForm->ptCurrentPos.y, lpCompForm->rcArea.top,
1715           lpCompForm->rcArea.left, lpCompForm->rcArea.bottom, lpCompForm->rcArea.right);
1716
1717     if (!data)
1718         return FALSE;
1719
1720     memcpy(&data->IMC.cfCompForm,lpCompForm,sizeof(COMPOSITIONFORM));
1721
1722     if (IsWindowVisible(hwndDefault))
1723     {
1724         reshow = TRUE;
1725         ShowWindow(hwndDefault,SW_HIDE);
1726     }
1727
1728     /* FIXME: this is a partial stub */
1729
1730     if (reshow)
1731         ShowWindow(hwndDefault,SW_SHOWNOACTIVATE);
1732
1733     ImmInternalSendIMENotify(IMN_SETCOMPOSITIONWINDOW, 0);
1734     return TRUE;
1735 }
1736
1737 /***********************************************************************
1738  *              ImmSetConversionStatus (IMM32.@)
1739  */
1740 BOOL WINAPI ImmSetConversionStatus(
1741   HIMC hIMC, DWORD fdwConversion, DWORD fdwSentence)
1742 {
1743   static int shown = 0;
1744
1745   if (!shown) {
1746       FIXME("(%p, %d, %d): stub\n",
1747           hIMC, fdwConversion, fdwSentence
1748       );
1749       shown = 1;
1750   }
1751   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1752   return FALSE;
1753 }
1754
1755 /***********************************************************************
1756  *              ImmSetOpenStatus (IMM32.@)
1757  */
1758 BOOL WINAPI ImmSetOpenStatus(HIMC hIMC, BOOL fOpen)
1759 {
1760     InputContextData *data = (InputContextData*)hIMC;
1761
1762     TRACE("%p %d\n", hIMC, fOpen);
1763
1764     if (hIMC == (HIMC)FROM_IME)
1765     {
1766         ImmInternalSetOpenStatus(fOpen);
1767         ImmInternalSendIMENotify(IMN_SETOPENSTATUS, 0);
1768         return TRUE;
1769     }
1770
1771     if (!data)
1772         return FALSE;
1773
1774     if (fOpen != data->bInternalState)
1775     {
1776         if (fOpen == FALSE && pX11DRV_ForceXIMReset)
1777             pX11DRV_ForceXIMReset(data->IMC.hWnd);
1778
1779         if (fOpen == FALSE)
1780             ImmInternalPostIMEMessage(WM_IME_ENDCOMPOSITION,0,0);
1781         else
1782             ImmInternalPostIMEMessage(WM_IME_STARTCOMPOSITION,0,0);
1783
1784         ImmInternalSetOpenStatus(fOpen);
1785         ImmInternalSetOpenStatus(!fOpen);
1786
1787         if (data->IMC.fOpen == FALSE)
1788             ImmInternalPostIMEMessage(WM_IME_ENDCOMPOSITION,0,0);
1789         else
1790             ImmInternalPostIMEMessage(WM_IME_STARTCOMPOSITION,0,0);
1791
1792         return FALSE;
1793     }
1794     return TRUE;
1795 }
1796
1797 /***********************************************************************
1798  *              ImmSetStatusWindowPos (IMM32.@)
1799  */
1800 BOOL WINAPI ImmSetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
1801 {
1802   FIXME("(%p, %p): stub\n", hIMC, lpptPos);
1803   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1804   return FALSE;
1805 }
1806
1807 /***********************************************************************
1808  *              ImmSimulateHotKey (IMM32.@)
1809  */
1810 BOOL WINAPI ImmSimulateHotKey(HWND hWnd, DWORD dwHotKeyID)
1811 {
1812   FIXME("(%p, %d): stub\n", hWnd, dwHotKeyID);
1813   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1814   return FALSE;
1815 }
1816
1817 /***********************************************************************
1818  *              ImmUnregisterWordA (IMM32.@)
1819  */
1820 BOOL WINAPI ImmUnregisterWordA(
1821   HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszUnregister)
1822 {
1823   FIXME("(%p, %s, %d, %s): stub\n",
1824     hKL, debugstr_a(lpszReading), dwStyle, debugstr_a(lpszUnregister)
1825   );
1826   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1827   return FALSE;
1828 }
1829
1830 /***********************************************************************
1831  *              ImmUnregisterWordW (IMM32.@)
1832  */
1833 BOOL WINAPI ImmUnregisterWordW(
1834   HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszUnregister)
1835 {
1836   FIXME("(%p, %s, %d, %s): stub\n",
1837     hKL, debugstr_w(lpszReading), dwStyle, debugstr_w(lpszUnregister)
1838   );
1839   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1840   return FALSE;
1841 }
1842
1843 /***********************************************************************
1844  *              ImmGetImeMenuItemsA (IMM32.@)
1845  */
1846 DWORD WINAPI ImmGetImeMenuItemsA( HIMC hIMC, DWORD dwFlags, DWORD dwType,
1847    LPIMEMENUITEMINFOA lpImeParentMenu, LPIMEMENUITEMINFOA lpImeMenu,
1848     DWORD dwSize)
1849 {
1850   FIXME("(%p, %i, %i, %p, %p, %i): stub\n", hIMC, dwFlags, dwType,
1851     lpImeParentMenu, lpImeMenu, dwSize);
1852   return 0;
1853 }
1854
1855 /***********************************************************************
1856 *               ImmGetImeMenuItemsW (IMM32.@)
1857 */
1858 DWORD WINAPI ImmGetImeMenuItemsW( HIMC hIMC, DWORD dwFlags, DWORD dwType,
1859    LPIMEMENUITEMINFOW lpImeParentMenu, LPIMEMENUITEMINFOW lpImeMenu,
1860    DWORD dwSize)
1861 {
1862   FIXME("(%p, %i, %i, %p, %p, %i): stub\n", hIMC, dwFlags, dwType,
1863     lpImeParentMenu, lpImeMenu, dwSize);
1864   return 0;
1865 }
1866
1867 /***********************************************************************
1868 *               ImmLockIMC(IMM32.@)
1869 */
1870 LPINPUTCONTEXT WINAPI ImmLockIMC(HIMC hIMC)
1871 {
1872     InputContextData *data = (InputContextData*)hIMC;
1873
1874     if (!data)
1875         return NULL;
1876     data->dwLock++;
1877     return &data->IMC;
1878 }
1879
1880 /***********************************************************************
1881 *               ImmUnlockIMC(IMM32.@)
1882 */
1883 BOOL WINAPI ImmUnlockIMC(HIMC hIMC)
1884 {
1885     InputContextData *data = (InputContextData*)hIMC;
1886     data->dwLock--;
1887     return (data->dwLock!=0);
1888 }
1889
1890 /***********************************************************************
1891 *               ImmGetIMCLockCount(IMM32.@)
1892 */
1893 DWORD WINAPI ImmGetIMCLockCount(HIMC hIMC)
1894 {
1895     InputContextData *data = (InputContextData*)hIMC;
1896     return data->dwLock;
1897 }
1898
1899 /***********************************************************************
1900 *               ImmCreateIMCC(IMM32.@)
1901 */
1902 HIMCC  WINAPI ImmCreateIMCC(DWORD size)
1903 {
1904     IMCCInternal *internal;
1905     int real_size = size + sizeof(IMCCInternal);
1906
1907     internal = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, real_size);
1908     if (internal == NULL)
1909         return NULL;
1910
1911     internal->dwSize = size;
1912     return  (HIMCC)internal;
1913 }
1914
1915 /***********************************************************************
1916 *       ImmDestroyIMCC(IMM32.@)
1917 */
1918 HIMCC WINAPI ImmDestroyIMCC(HIMCC block)
1919 {
1920     HeapFree(GetProcessHeap(),0,block);
1921     return NULL;
1922 }
1923
1924 /***********************************************************************
1925 *               ImmLockIMCC(IMM32.@)
1926 */
1927 LPVOID WINAPI ImmLockIMCC(HIMCC imcc)
1928 {
1929     IMCCInternal *internal;
1930     internal = (IMCCInternal*) imcc;
1931
1932     internal->dwLock ++;
1933     return internal + 1;
1934 }
1935
1936 /***********************************************************************
1937 *               ImmUnlockIMCC(IMM32.@)
1938 */
1939 BOOL WINAPI ImmUnlockIMCC(HIMCC imcc)
1940 {
1941     IMCCInternal *internal;
1942     internal = (IMCCInternal*) imcc;
1943
1944     internal->dwLock --;
1945     return (internal->dwLock!=0);
1946 }
1947
1948 /***********************************************************************
1949 *               ImmGetIMCCLockCount(IMM32.@)
1950 */
1951 DWORD WINAPI ImmGetIMCCLockCount(HIMCC imcc)
1952 {
1953     IMCCInternal *internal;
1954     internal = (IMCCInternal*) imcc;
1955
1956     return internal->dwLock;
1957 }
1958
1959 /***********************************************************************
1960 *               ImmReSizeIMCC(IMM32.@)
1961 */
1962 HIMCC  WINAPI ImmReSizeIMCC(HIMCC imcc, DWORD size)
1963 {
1964     IMCCInternal *internal,*newone;
1965     int real_size = size + sizeof(IMCCInternal);
1966
1967     internal = (IMCCInternal*) imcc;
1968
1969     newone = HeapReAlloc(GetProcessHeap(), 0, internal, real_size);
1970     newone->dwSize = size;
1971
1972     return newone;
1973 }
1974
1975 /***********************************************************************
1976 *               ImmGetIMCCSize(IMM32.@)
1977 */
1978 DWORD WINAPI ImmGetIMCCSize(HIMCC imcc)
1979 {
1980     IMCCInternal *internal;
1981     internal = (IMCCInternal*) imcc;
1982
1983     return internal->dwSize;
1984 }
1985
1986 /*****
1987  * Internal functions to help with IME window management
1988  */
1989 static void PaintDefaultIMEWnd(HWND hwnd)
1990 {
1991     PAINTSTRUCT ps;
1992     RECT rect;
1993     HDC hdc = BeginPaint(hwnd,&ps);
1994     LPCOMPOSITIONSTRING compstr;
1995     LPBYTE compdata = NULL;
1996     HMONITOR monitor;
1997     MONITORINFO mon_info;
1998     INT offX=0, offY=0;
1999
2000     GetClientRect(hwnd,&rect);
2001     FillRect(hdc, &rect, (HBRUSH)(COLOR_WINDOW + 1));
2002
2003     compdata = ImmLockIMCC(root_context->IMC.hCompStr);
2004     compstr = (LPCOMPOSITIONSTRING)compdata;
2005
2006     if (compstr->dwCompStrLen && compstr->dwCompStrOffset)
2007     {
2008         SIZE size;
2009         POINT pt;
2010         HFONT oldfont = NULL;
2011         LPWSTR CompString;
2012
2013         CompString = (LPWSTR)(compdata + compstr->dwCompStrOffset);
2014         if (root_context->textfont)
2015             oldfont = SelectObject(hdc,root_context->textfont);
2016
2017
2018         GetTextExtentPoint32W(hdc, CompString, compstr->dwCompStrLen, &size);
2019         pt.x = size.cx;
2020         pt.y = size.cy;
2021         LPtoDP(hdc,&pt,1);
2022
2023         /*
2024          * How this works based on tests on windows:
2025          * CFS_POINT: then we start our window at the point and grow it as large
2026          *    as it needs to be for the string.
2027          * CFS_RECT:  we still use the ptCurrentPos as a starting point and our
2028          *    window is only as large as we need for the string, but we do not
2029          *    grow such that our window exceeds the given rect.  Wrapping if
2030          *    needed and possible.   If our ptCurrentPos is outside of our rect
2031          *    then no window is displayed.
2032          * CFS_FORCE_POSITION: appears to behave just like CFS_POINT
2033          *    maybe becase the default MSIME does not do any IME adjusting.
2034          */
2035         if (root_context->IMC.cfCompForm.dwStyle != CFS_DEFAULT)
2036         {
2037             POINT cpt = root_context->IMC.cfCompForm.ptCurrentPos;
2038             ClientToScreen(root_context->IMC.hWnd,&cpt);
2039             rect.left = cpt.x;
2040             rect.top = cpt.y;
2041             rect.right = rect.left + pt.x;
2042             rect.bottom = rect.top + pt.y;
2043             offX=offY=10;
2044             monitor = MonitorFromPoint(cpt, MONITOR_DEFAULTTOPRIMARY);
2045         }
2046         else /* CFS_DEFAULT */
2047         {
2048             /* Windows places the default IME window in the bottom left */
2049             HWND target = root_context->IMC.hWnd;
2050             if (!target) target = GetFocus();
2051
2052             GetWindowRect(target,&rect);
2053             rect.top = rect.bottom;
2054             rect.right = rect.left + pt.x + 20;
2055             rect.bottom = rect.top + pt.y + 20;
2056             offX=offY=10;
2057             monitor = MonitorFromWindow(target, MONITOR_DEFAULTTOPRIMARY);
2058         }
2059
2060         if (root_context->IMC.cfCompForm.dwStyle == CFS_RECT)
2061         {
2062             RECT client;
2063             client =root_context->IMC.cfCompForm.rcArea;
2064             MapWindowPoints( root_context->IMC.hWnd, 0, (POINT *)&client, 2 );
2065             IntersectRect(&rect,&rect,&client);
2066             /* TODO:  Wrap the input if needed */
2067         }
2068
2069         if (root_context->IMC.cfCompForm.dwStyle == CFS_DEFAULT)
2070         {
2071             /* make sure we are on the desktop */
2072             mon_info.cbSize = sizeof(mon_info);
2073             GetMonitorInfoW(monitor, &mon_info);
2074
2075             if (rect.bottom > mon_info.rcWork.bottom)
2076             {
2077                 int shift = rect.bottom - mon_info.rcWork.bottom;
2078                 rect.top -= shift;
2079                 rect.bottom -= shift;
2080             }
2081             if (rect.left < 0)
2082             {
2083                 rect.right -= rect.left;
2084                 rect.left = 0;
2085             }
2086             if (rect.right > mon_info.rcWork.right)
2087             {
2088                 int shift = rect.right - mon_info.rcWork.right;
2089                 rect.left -= shift;
2090                 rect.right -= shift;
2091             }
2092         }
2093
2094         SetWindowPos(hwnd, HWND_TOPMOST, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_NOACTIVATE);
2095
2096         TextOutW(hdc, offX,offY, CompString, compstr->dwCompStrLen);
2097
2098         if (oldfont)
2099             SelectObject(hdc,oldfont);
2100     }
2101
2102     ImmUnlockIMCC(root_context->IMC.hCompStr);
2103
2104     EndPaint(hwnd,&ps);
2105 }
2106
2107 static void UpdateDataInDefaultIMEWindow(HWND hwnd, BOOL showable)
2108 {
2109     LPCOMPOSITIONSTRING compstr;
2110
2111     if (root_context->IMC.hCompStr)
2112         compstr = ImmLockIMCC(root_context->IMC.hCompStr);
2113     else
2114         compstr = NULL;
2115
2116     if (compstr == NULL || compstr->dwCompStrLen == 0)
2117         ShowWindow(hwndDefault,SW_HIDE);
2118     else if (showable)
2119         ShowWindow(hwndDefault,SW_SHOWNOACTIVATE);
2120
2121     RedrawWindow(hwnd,NULL,NULL,RDW_ERASENOW|RDW_INVALIDATE);
2122
2123     if (compstr != NULL)
2124         ImmUnlockIMCC(root_context->IMC.hCompStr);
2125 }
2126
2127 /*
2128  * The window proc for the default IME window
2129  */
2130 static LRESULT WINAPI IME_WindowProc(HWND hwnd, UINT msg, WPARAM wParam,
2131                                           LPARAM lParam)
2132 {
2133     LRESULT rc = 0;
2134
2135     TRACE("Incoming Message 0x%x  (0x%08x, 0x%08x)\n", msg, (UINT)wParam,
2136            (UINT)lParam);
2137
2138     switch(msg)
2139     {
2140         case WM_PAINT:
2141             PaintDefaultIMEWnd(hwnd);
2142             return FALSE;
2143
2144         case WM_NCCREATE:
2145             return TRUE;
2146
2147         case WM_CREATE:
2148             SetWindowTextA(hwnd,"Wine Ime Active");
2149             return TRUE;
2150
2151         case WM_SETFOCUS:
2152             if (wParam)
2153                 SetFocus((HWND)wParam);
2154             else
2155                 FIXME("Received focus, should never have focus\n");
2156             break;
2157         case WM_IME_COMPOSITION:
2158             TRACE("IME message %s, 0x%x, 0x%x (%i)\n",
2159                     "WM_IME_COMPOSITION", (UINT)wParam, (UINT)lParam,
2160                      root_context->bRead);
2161             if (lParam & GCS_RESULTSTR)
2162                     IMM_PostResult(root_context);
2163             else
2164                  UpdateDataInDefaultIMEWindow(hwnd,TRUE);
2165             break;
2166         case WM_IME_STARTCOMPOSITION:
2167             TRACE("IME message %s, 0x%x, 0x%x\n",
2168                     "WM_IME_STARTCOMPOSITION", (UINT)wParam, (UINT)lParam);
2169             root_context->IMC.hWnd = GetFocus();
2170             ShowWindow(hwndDefault,SW_SHOWNOACTIVATE);
2171             break;
2172         case WM_IME_ENDCOMPOSITION:
2173             TRACE("IME message %s, 0x%x, 0x%x\n",
2174                     "WM_IME_ENDCOMPOSITION", (UINT)wParam, (UINT)lParam);
2175             ShowWindow(hwndDefault,SW_HIDE);
2176             break;
2177         case WM_IME_SELECT:
2178             TRACE("IME message %s, 0x%x, 0x%x\n","WM_IME_SELECT",
2179                 (UINT)wParam, (UINT)lParam);
2180             break;
2181         case WM_IME_CONTROL:
2182             TRACE("IME message %s, 0x%x, 0x%x\n","WM_IME_CONTROL",
2183                 (UINT)wParam, (UINT)lParam);
2184             rc = 1;
2185             break;
2186         case WM_IME_NOTIFY:
2187             TRACE("!! IME NOTIFY\n");
2188             break;
2189        default:
2190             TRACE("Non-standard message 0x%x\n",msg);
2191     }
2192     /* check the MSIME messages */
2193     if (msg == WM_MSIME_SERVICE)
2194     {
2195             TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_SERVICE",
2196                 (UINT)wParam, (UINT)lParam);
2197             rc = FALSE;
2198     }
2199     else if (msg == WM_MSIME_RECONVERTOPTIONS)
2200     {
2201             TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_RECONVERTOPTIONS",
2202                 (UINT)wParam, (UINT)lParam);
2203     }
2204     else if (msg == WM_MSIME_MOUSE)
2205     {
2206             TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_MOUSE",
2207                 (UINT)wParam, (UINT)lParam);
2208     }
2209     else if (msg == WM_MSIME_RECONVERTREQUEST)
2210     {
2211             TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_RECONVERTREQUEST",
2212                 (UINT)wParam, (UINT)lParam);
2213     }
2214     else if (msg == WM_MSIME_RECONVERT)
2215     {
2216             TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_RECONVERT",
2217                 (UINT)wParam, (UINT)lParam);
2218     }
2219     else if (msg == WM_MSIME_QUERYPOSITION)
2220     {
2221             TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_QUERYPOSITION",
2222                 (UINT)wParam, (UINT)lParam);
2223     }
2224     else if (msg == WM_MSIME_DOCUMENTFEED)
2225     {
2226             TRACE("IME message %s, 0x%x, 0x%x\n","WM_MSIME_DOCUMENTFEED",
2227                 (UINT)wParam, (UINT)lParam);
2228     }
2229     /* DefWndProc if not an IME message */
2230     else if (!rc && !((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
2231                       (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP)))
2232         rc = DefWindowProcW(hwnd,msg,wParam,lParam);
2233
2234     return rc;
2235 }