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