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