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