[MSCTF] Sync with Wine Staging 3.3. CORE-14434
[reactos.git] / dll / win32 / msctf / msctf.c
1 /*
2 * MSCTF Server DLL
3 *
4 * Copyright 2008 Aric Stewart, CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22
23 #include <stdarg.h>
24 #include <stdio.h>
25
26 #define COBJMACROS
27
28 #include "wine/debug.h"
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winreg.h"
32 #include "shlwapi.h"
33 #include "shlguid.h"
34 #include "comcat.h"
35 #include "olectl.h"
36 #include "rpcproxy.h"
37 #include "msctf.h"
38 #include "inputscope.h"
39
40 #include "msctf_internal.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(msctf);
43
44 static HINSTANCE MSCTF_hinstance;
45
46 typedef struct
47 {
48 DWORD id;
49 DWORD magic;
50 LPVOID data;
51 } CookieInternal;
52
53 typedef struct {
54 TF_LANGUAGEPROFILE LanguageProfile;
55 ITfTextInputProcessor *pITfTextInputProcessor;
56 ITfThreadMgrEx *pITfThreadMgrEx;
57 ITfKeyEventSink *pITfKeyEventSink;
58 TfClientId tid;
59 } ActivatedTextService;
60
61 typedef struct
62 {
63 struct list entry;
64 ActivatedTextService *ats;
65 } AtsEntry;
66
67 static CookieInternal *cookies;
68 static UINT id_last;
69 static UINT array_size;
70
71 static struct list AtsList = LIST_INIT(AtsList);
72 static UINT activated = 0;
73
74 DWORD tlsIndex = 0;
75 TfClientId processId = 0;
76 ITfCompartmentMgr *globalCompartmentMgr = NULL;
77
78 const WCHAR szwSystemTIPKey[] = {'S','O','F','T','W','A','R','E','\\','M','i','c','r','o','s','o','f','t','\\','C','T','F','\\','T','I','P',0};
79 const WCHAR szwSystemCTFKey[] = {'S','O','F','T','W','A','R','E','\\','M','i','c','r','o','s','o','f','t','\\','C','T','F',0};
80
81 typedef HRESULT (*LPFNCONSTRUCTOR)(IUnknown *pUnkOuter, IUnknown **ppvOut);
82
83 static const struct {
84 REFCLSID clsid;
85 LPFNCONSTRUCTOR ctor;
86 } ClassesTable[] = {
87 {&CLSID_TF_ThreadMgr, ThreadMgr_Constructor},
88 {&CLSID_TF_InputProcessorProfiles, InputProcessorProfiles_Constructor},
89 {&CLSID_TF_CategoryMgr, CategoryMgr_Constructor},
90 {&CLSID_TF_LangBarMgr, LangBarMgr_Constructor},
91 {&CLSID_TF_DisplayAttributeMgr, DisplayAttributeMgr_Constructor},
92 {NULL, NULL}
93 };
94
95 typedef struct tagClassFactory
96 {
97 IClassFactory IClassFactory_iface;
98 LONG ref;
99 LPFNCONSTRUCTOR ctor;
100 } ClassFactory;
101
102 static inline ClassFactory *impl_from_IClassFactory(IClassFactory *iface)
103 {
104 return CONTAINING_RECORD(iface, ClassFactory, IClassFactory_iface);
105 }
106
107 static void ClassFactory_Destructor(ClassFactory *This)
108 {
109 TRACE("Destroying class factory %p\n", This);
110 HeapFree(GetProcessHeap(),0,This);
111 }
112
113 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, LPVOID *ppvOut)
114 {
115 *ppvOut = NULL;
116 if (IsEqualIID(riid, &IID_IClassFactory) || IsEqualIID(riid, &IID_IUnknown)) {
117 IClassFactory_AddRef(iface);
118 *ppvOut = iface;
119 return S_OK;
120 }
121
122 WARN("Unknown interface %s\n", debugstr_guid(riid));
123 return E_NOINTERFACE;
124 }
125
126 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
127 {
128 ClassFactory *This = impl_from_IClassFactory(iface);
129 return InterlockedIncrement(&This->ref);
130 }
131
132 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
133 {
134 ClassFactory *This = impl_from_IClassFactory(iface);
135 ULONG ret = InterlockedDecrement(&This->ref);
136
137 if (ret == 0)
138 ClassFactory_Destructor(This);
139 return ret;
140 }
141
142 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *punkOuter, REFIID iid, LPVOID *ppvOut)
143 {
144 ClassFactory *This = impl_from_IClassFactory(iface);
145 HRESULT ret;
146 IUnknown *obj;
147
148 TRACE("(%p, %p, %s, %p)\n", iface, punkOuter, debugstr_guid(iid), ppvOut);
149 ret = This->ctor(punkOuter, &obj);
150 if (FAILED(ret))
151 return ret;
152 ret = IUnknown_QueryInterface(obj, iid, ppvOut);
153 IUnknown_Release(obj);
154 return ret;
155 }
156
157 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock)
158 {
159 ClassFactory *This = impl_from_IClassFactory(iface);
160
161 TRACE("(%p)->(%x)\n", This, fLock);
162
163 return S_OK;
164 }
165
166 static const IClassFactoryVtbl ClassFactoryVtbl = {
167 /* IUnknown */
168 ClassFactory_QueryInterface,
169 ClassFactory_AddRef,
170 ClassFactory_Release,
171
172 /* IClassFactory*/
173 ClassFactory_CreateInstance,
174 ClassFactory_LockServer
175 };
176
177 static HRESULT ClassFactory_Constructor(LPFNCONSTRUCTOR ctor, LPVOID *ppvOut)
178 {
179 ClassFactory *This = HeapAlloc(GetProcessHeap(),0,sizeof(ClassFactory));
180 This->IClassFactory_iface.lpVtbl = &ClassFactoryVtbl;
181 This->ref = 1;
182 This->ctor = ctor;
183 *ppvOut = &This->IClassFactory_iface;
184 TRACE("Created class factory %p\n", This);
185 return S_OK;
186 }
187
188 /*************************************************************************
189 * DWORD Cookie Management
190 */
191 DWORD generate_Cookie(DWORD magic, LPVOID data)
192 {
193 UINT i;
194
195 /* try to reuse IDs if possible */
196 for (i = 0; i < id_last; i++)
197 if (cookies[i].id == 0) break;
198
199 if (i == array_size)
200 {
201 if (!array_size)
202 {
203 cookies = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CookieInternal) * 10);
204 if (!cookies)
205 {
206 ERR("Out of memory, Unable to alloc cookies array\n");
207 return 0;
208 }
209 array_size = 10;
210 }
211 else
212 {
213 CookieInternal *new_cookies = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cookies,
214 sizeof(CookieInternal) * (array_size * 2));
215 if (!new_cookies)
216 {
217 ERR("Out of memory, Unable to realloc cookies array\n");
218 return 0;
219 }
220 cookies = new_cookies;
221 array_size *= 2;
222 }
223 }
224
225 cookies[i].id = i + 1; /* a return of 0 is used for failure */
226 cookies[i].magic = magic;
227 cookies[i].data = data;
228
229 if (i == id_last)
230 id_last++;
231
232 return cookies[i].id;
233 }
234
235 DWORD get_Cookie_magic(DWORD id)
236 {
237 UINT index = id - 1;
238
239 if (index >= id_last)
240 return 0;
241
242 if (cookies[index].id == 0)
243 return 0;
244
245 return cookies[index].magic;
246 }
247
248 LPVOID get_Cookie_data(DWORD id)
249 {
250 UINT index = id - 1;
251
252 if (index >= id_last)
253 return NULL;
254
255 if (cookies[index].id == 0)
256 return NULL;
257
258 return cookies[index].data;
259 }
260
261 LPVOID remove_Cookie(DWORD id)
262 {
263 UINT index = id - 1;
264
265 if (index >= id_last)
266 return NULL;
267
268 if (cookies[index].id == 0)
269 return NULL;
270
271 cookies[index].id = 0;
272 return cookies[index].data;
273 }
274
275 DWORD enumerate_Cookie(DWORD magic, DWORD *index)
276 {
277 unsigned int i;
278 for (i = *index; i < id_last; i++)
279 if (cookies[i].id != 0 && cookies[i].magic == magic)
280 {
281 *index = (i+1);
282 return cookies[i].id;
283 }
284 return 0x0;
285 }
286
287 HRESULT advise_sink(struct list *sink_list, REFIID riid, DWORD cookie_magic, IUnknown *unk, DWORD *cookie)
288 {
289 Sink *sink;
290
291 sink = HeapAlloc(GetProcessHeap(), 0, sizeof(*sink));
292 if (!sink)
293 return E_OUTOFMEMORY;
294
295 if (FAILED(IUnknown_QueryInterface(unk, riid, (void**)&sink->interfaces.pIUnknown)))
296 {
297 HeapFree(GetProcessHeap(), 0, sink);
298 return CONNECT_E_CANNOTCONNECT;
299 }
300
301 list_add_head(sink_list, &sink->entry);
302 *cookie = generate_Cookie(cookie_magic, sink);
303 TRACE("cookie %x\n", *cookie);
304 return S_OK;
305 }
306
307 static void free_sink(Sink *sink)
308 {
309 list_remove(&sink->entry);
310 IUnknown_Release(sink->interfaces.pIUnknown);
311 HeapFree(GetProcessHeap(), 0, sink);
312 }
313
314 HRESULT unadvise_sink(DWORD cookie)
315 {
316 Sink *sink;
317
318 sink = remove_Cookie(cookie);
319 if (!sink)
320 return CONNECT_E_NOCONNECTION;
321
322 free_sink(sink);
323 return S_OK;
324 }
325
326 void free_sinks(struct list *sink_list)
327 {
328 while(!list_empty(sink_list))
329 {
330 Sink* sink = LIST_ENTRY(sink_list->next, Sink, entry);
331 free_sink(sink);
332 }
333 }
334
335 /*****************************************************************************
336 * Active Text Service Management
337 *****************************************************************************/
338 static HRESULT activate_given_ts(ActivatedTextService *actsvr, ITfThreadMgrEx *tm)
339 {
340 HRESULT hr;
341
342 /* Already Active? */
343 if (actsvr->pITfTextInputProcessor)
344 return S_OK;
345
346 hr = CoCreateInstance (&actsvr->LanguageProfile.clsid, NULL, CLSCTX_INPROC_SERVER,
347 &IID_ITfTextInputProcessor, (void**)&actsvr->pITfTextInputProcessor);
348 if (FAILED(hr)) return hr;
349
350 hr = ITfTextInputProcessor_Activate(actsvr->pITfTextInputProcessor, (ITfThreadMgr *)tm, actsvr->tid);
351 if (FAILED(hr))
352 {
353 ITfTextInputProcessor_Release(actsvr->pITfTextInputProcessor);
354 actsvr->pITfTextInputProcessor = NULL;
355 return hr;
356 }
357
358 actsvr->pITfThreadMgrEx = tm;
359 ITfThreadMgrEx_AddRef(tm);
360 return hr;
361 }
362
363 static HRESULT deactivate_given_ts(ActivatedTextService *actsvr)
364 {
365 HRESULT hr = S_OK;
366
367 if (actsvr->pITfTextInputProcessor)
368 {
369 hr = ITfTextInputProcessor_Deactivate(actsvr->pITfTextInputProcessor);
370 ITfTextInputProcessor_Release(actsvr->pITfTextInputProcessor);
371 ITfThreadMgrEx_Release(actsvr->pITfThreadMgrEx);
372 actsvr->pITfTextInputProcessor = NULL;
373 actsvr->pITfThreadMgrEx = NULL;
374 }
375
376 return hr;
377 }
378
379 static void deactivate_remove_conflicting_ts(REFCLSID catid)
380 {
381 AtsEntry *ats, *cursor2;
382
383 LIST_FOR_EACH_ENTRY_SAFE(ats, cursor2, &AtsList, AtsEntry, entry)
384 {
385 if (IsEqualCLSID(catid,&ats->ats->LanguageProfile.catid))
386 {
387 deactivate_given_ts(ats->ats);
388 list_remove(&ats->entry);
389 HeapFree(GetProcessHeap(),0,ats->ats);
390 HeapFree(GetProcessHeap(),0,ats);
391 /* we are guaranteeing there is only 1 */
392 break;
393 }
394 }
395 }
396
397 HRESULT add_active_textservice(TF_LANGUAGEPROFILE *lp)
398 {
399 ActivatedTextService *actsvr;
400 ITfCategoryMgr *catmgr;
401 AtsEntry *entry;
402 ITfThreadMgrEx *tm = TlsGetValue(tlsIndex);
403 ITfClientId *clientid;
404
405 if (!tm) return E_UNEXPECTED;
406
407 actsvr = HeapAlloc(GetProcessHeap(),0,sizeof(ActivatedTextService));
408 if (!actsvr) return E_OUTOFMEMORY;
409
410 ITfThreadMgrEx_QueryInterface(tm, &IID_ITfClientId, (void **)&clientid);
411 ITfClientId_GetClientId(clientid, &lp->clsid, &actsvr->tid);
412 ITfClientId_Release(clientid);
413
414 if (!actsvr->tid)
415 {
416 HeapFree(GetProcessHeap(),0,actsvr);
417 return E_OUTOFMEMORY;
418 }
419
420 actsvr->pITfTextInputProcessor = NULL;
421 actsvr->LanguageProfile = *lp;
422 actsvr->pITfKeyEventSink = NULL;
423
424 /* get TIP category */
425 if (SUCCEEDED(CategoryMgr_Constructor(NULL,(IUnknown**)&catmgr)))
426 {
427 static const GUID *list[3] = {&GUID_TFCAT_TIP_SPEECH, &GUID_TFCAT_TIP_KEYBOARD, &GUID_TFCAT_TIP_HANDWRITING};
428
429 ITfCategoryMgr_FindClosestCategory(catmgr,
430 &actsvr->LanguageProfile.clsid, &actsvr->LanguageProfile.catid,
431 list, 3);
432
433 ITfCategoryMgr_Release(catmgr);
434 }
435 else
436 {
437 ERR("CategoryMgr construction failed\n");
438 actsvr->LanguageProfile.catid = GUID_NULL;
439 }
440
441 if (!IsEqualGUID(&actsvr->LanguageProfile.catid,&GUID_NULL))
442 deactivate_remove_conflicting_ts(&actsvr->LanguageProfile.catid);
443
444 if (activated > 0)
445 activate_given_ts(actsvr, tm);
446
447 entry = HeapAlloc(GetProcessHeap(),0,sizeof(AtsEntry));
448
449 if (!entry)
450 {
451 HeapFree(GetProcessHeap(),0,actsvr);
452 return E_OUTOFMEMORY;
453 }
454
455 entry->ats = actsvr;
456 list_add_head(&AtsList, &entry->entry);
457
458 return S_OK;
459 }
460
461 BOOL get_active_textservice(REFCLSID rclsid, TF_LANGUAGEPROFILE *profile)
462 {
463 AtsEntry *ats;
464
465 LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
466 {
467 if (IsEqualCLSID(rclsid,&ats->ats->LanguageProfile.clsid))
468 {
469 if (profile)
470 *profile = ats->ats->LanguageProfile;
471 return TRUE;
472 }
473 }
474 return FALSE;
475 }
476
477 HRESULT activate_textservices(ITfThreadMgrEx *tm)
478 {
479 HRESULT hr = S_OK;
480 AtsEntry *ats;
481
482 activated ++;
483 if (activated > 1)
484 return S_OK;
485
486 LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
487 {
488 hr = activate_given_ts(ats->ats, tm);
489 if (FAILED(hr))
490 FIXME("Failed to activate text service\n");
491 }
492 return hr;
493 }
494
495 HRESULT deactivate_textservices(void)
496 {
497 AtsEntry *ats;
498
499 if (activated > 0)
500 activated --;
501
502 if (activated == 0)
503 LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
504 deactivate_given_ts(ats->ats);
505
506 return S_OK;
507 }
508
509 CLSID get_textservice_clsid(TfClientId tid)
510 {
511 AtsEntry *ats;
512
513 LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
514 if (ats->ats->tid == tid)
515 return ats->ats->LanguageProfile.clsid;
516 return GUID_NULL;
517 }
518
519 HRESULT get_textservice_sink(TfClientId tid, REFCLSID iid, IUnknown **sink)
520 {
521 AtsEntry *ats;
522
523 if (!IsEqualCLSID(iid,&IID_ITfKeyEventSink))
524 return E_NOINTERFACE;
525
526 LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
527 if (ats->ats->tid == tid)
528 {
529 *sink = (IUnknown*)ats->ats->pITfKeyEventSink;
530 return S_OK;
531 }
532
533 return E_FAIL;
534 }
535
536 HRESULT set_textservice_sink(TfClientId tid, REFCLSID iid, IUnknown* sink)
537 {
538 AtsEntry *ats;
539
540 if (!IsEqualCLSID(iid,&IID_ITfKeyEventSink))
541 return E_NOINTERFACE;
542
543 LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
544 if (ats->ats->tid == tid)
545 {
546 ats->ats->pITfKeyEventSink = (ITfKeyEventSink*)sink;
547 return S_OK;
548 }
549
550 return E_FAIL;
551 }
552
553 /*************************************************************************
554 * MSCTF DllMain
555 */
556 BOOL WINAPI DllMain(HINSTANCE hinst, DWORD fdwReason, LPVOID fImpLoad)
557 {
558 TRACE("%p 0x%x %p\n", hinst, fdwReason, fImpLoad);
559 switch (fdwReason)
560 {
561 case DLL_WINE_PREATTACH:
562 return FALSE; /* prefer native version */
563 case DLL_PROCESS_ATTACH:
564 MSCTF_hinstance = hinst;
565 tlsIndex = TlsAlloc();
566 break;
567 case DLL_PROCESS_DETACH:
568 if (fImpLoad) break;
569 TlsFree(tlsIndex);
570 break;
571 }
572 return TRUE;
573 }
574
575 /*************************************************************************
576 * DllCanUnloadNow (MSCTF.@)
577 */
578 HRESULT WINAPI DllCanUnloadNow(void)
579 {
580 return S_FALSE;
581 }
582
583 /***********************************************************************
584 * DllGetClassObject (MSCTF.@)
585 */
586 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, LPVOID *ppvOut)
587 {
588 int i;
589
590 *ppvOut = NULL;
591 if (!IsEqualIID(iid, &IID_IUnknown) && !IsEqualIID(iid, &IID_IClassFactory))
592 return E_NOINTERFACE;
593
594 for (i = 0; ClassesTable[i].clsid != NULL; i++)
595 if (IsEqualCLSID(ClassesTable[i].clsid, clsid)) {
596 return ClassFactory_Constructor(ClassesTable[i].ctor, ppvOut);
597 }
598 FIXME("CLSID %s not supported\n", debugstr_guid(clsid));
599 return CLASS_E_CLASSNOTAVAILABLE;
600 }
601
602 /***********************************************************************
603 * DllRegisterServer (MSCTF.@)
604 */
605 HRESULT WINAPI DllRegisterServer(void)
606 {
607 return __wine_register_resources( MSCTF_hinstance );
608 }
609
610 /***********************************************************************
611 * DllUnregisterServer (MSCTF.@)
612 */
613 HRESULT WINAPI DllUnregisterServer(void)
614 {
615 return __wine_unregister_resources( MSCTF_hinstance );
616 }
617
618 /***********************************************************************
619 * TF_CreateThreadMgr (MSCTF.@)
620 */
621 HRESULT WINAPI TF_CreateThreadMgr(ITfThreadMgr **pptim)
622 {
623 TRACE("\n");
624 return ThreadMgr_Constructor(NULL,(IUnknown**)pptim);
625 }
626
627 /***********************************************************************
628 * TF_GetThreadMgr (MSCTF.@)
629 */
630 HRESULT WINAPI TF_GetThreadMgr(ITfThreadMgr **pptim)
631 {
632 TRACE("\n");
633 *pptim = TlsGetValue(tlsIndex);
634
635 if (*pptim)
636 ITfThreadMgr_AddRef(*pptim);
637
638 return S_OK;
639 }
640
641 /***********************************************************************
642 * SetInputScope(MSCTF.@)
643 */
644 HRESULT WINAPI SetInputScope(HWND hwnd, InputScope inputscope)
645 {
646 FIXME("STUB: %p %i\n",hwnd,inputscope);
647 return S_OK;
648 }
649
650 /***********************************************************************
651 * SetInputScopes(MSCTF.@)
652 */
653 HRESULT WINAPI SetInputScopes(HWND hwnd, const InputScope *pInputScopes,
654 UINT cInputScopes, WCHAR **ppszPhraseList,
655 UINT cPhrases, WCHAR *pszRegExp, WCHAR *pszSRGS)
656 {
657 UINT i;
658 FIXME("STUB: %p ... %s %s\n",hwnd, debugstr_w(pszRegExp), debugstr_w(pszSRGS));
659 for (i = 0; i < cInputScopes; i++)
660 TRACE("\tScope[%u] = %i\n",i,pInputScopes[i]);
661 for (i = 0; i < cPhrases; i++)
662 TRACE("\tPhrase[%u] = %s\n",i,debugstr_w(ppszPhraseList[i]));
663
664 return S_OK;
665 }
666
667 /***********************************************************************
668 * TF_CreateInputProcessorProfiles(MSCTF.@)
669 */
670 HRESULT WINAPI TF_CreateInputProcessorProfiles(
671 ITfInputProcessorProfiles **ppipr)
672 {
673 return InputProcessorProfiles_Constructor(NULL,(IUnknown**)ppipr);
674 }
675
676 /***********************************************************************
677 * TF_InvalidAssemblyListCacheIfExist(MSCTF.@)
678 */
679 HRESULT WINAPI TF_InvalidAssemblyListCacheIfExist(void)
680 {
681 FIXME("Stub\n");
682 return S_OK;
683 }
684
685 /***********************************************************************
686 * TF_CreateLangBarMgr (MSCTF.@)
687 */
688 HRESULT WINAPI TF_CreateLangBarMgr(ITfLangBarMgr **pppbm)
689 {
690 TRACE("\n");
691 return LangBarMgr_Constructor(NULL,(IUnknown**)pppbm);
692 }
693
694 HRESULT WINAPI TF_CreateLangBarItemMgr(ITfLangBarItemMgr **pplbim)
695 {
696 FIXME("stub %p\n", pplbim);
697 *pplbim = NULL;
698
699 return E_NOTIMPL;
700 }
701
702 /***********************************************************************
703 * TF_InitMlngInfo (MSCTF.@)
704 */
705 HRESULT WINAPI TF_InitMlngInfo(void)
706 {
707 FIXME("stub\n");
708 return S_OK;
709 }