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 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     ITfThreadMgr            *pITfThreadMgr;
  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;
 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 /*****************************************************************************
 288  * Active Text Service Management
 289  *****************************************************************************/
 290 static HRESULT activate_given_ts(ActivatedTextService *actsvr, ITfThreadMgr* tm)
 291 {
 292     HRESULT hr;
 293
 294     /* Already Active? */
 295     if (actsvr->pITfTextInputProcessor)
 296         return S_OK;
 297
 298     hr = CoCreateInstance (&actsvr->LanguageProfile.clsid, NULL, CLSCTX_INPROC_SERVER,
 299         &IID_ITfTextInputProcessor, (void**)&actsvr->pITfTextInputProcessor);
 300     if (FAILED(hr)) return hr;
 301
 302     hr = ITfTextInputProcessor_Activate(actsvr->pITfTextInputProcessor, tm, actsvr->tid);
 303     if (FAILED(hr))
 304     {
 305         ITfTextInputProcessor_Release(actsvr->pITfTextInputProcessor);
 306         actsvr->pITfTextInputProcessor = NULL;
 307         return hr;
 308     }
 309
 310     actsvr->pITfThreadMgr = tm;
 311     ITfThreadMgr_AddRef(tm);
 312     return hr;
 313 }
 314
 315 static HRESULT deactivate_given_ts(ActivatedTextService *actsvr)
 316 {
 317     HRESULT hr = S_OK;
 318
 319     if (actsvr->pITfTextInputProcessor)
 320     {
 321         hr = ITfTextInputProcessor_Deactivate(actsvr->pITfTextInputProcessor);
 322         ITfTextInputProcessor_Release(actsvr->pITfTextInputProcessor);
 323         ITfThreadMgr_Release(actsvr->pITfThreadMgr);
 324         actsvr->pITfTextInputProcessor = NULL;
 325         actsvr->pITfThreadMgr = NULL;
 326     }
 327
 328     return hr;
 329 }
 330
 331 static void deactivate_remove_conflicting_ts(REFCLSID catid)
 332 {
 333     AtsEntry *ats, *cursor2;
 334
 335     LIST_FOR_EACH_ENTRY_SAFE(ats, cursor2, &AtsList, AtsEntry, entry)
 336     {
 337         if (IsEqualCLSID(catid,&ats->ats->LanguageProfile.catid))
 338         {
 339             deactivate_given_ts(ats->ats);
 340             list_remove(&ats->entry);
 341             HeapFree(GetProcessHeap(),0,ats->ats);
 342             HeapFree(GetProcessHeap(),0,ats);
 343             /* we are guarenteeing there is only 1 */
 344             break;
 345         }
 346     }
 347 }
 348
 349 HRESULT add_active_textservice(TF_LANGUAGEPROFILE *lp)
 350 {
 351     ActivatedTextService *actsvr;
 352     ITfCategoryMgr *catmgr;
 353     AtsEntry *entry;
 354     ITfThreadMgr *tm = TlsGetValue(tlsIndex);
 355     ITfClientId *clientid;
 356
 357     if (!tm) return E_UNEXPECTED;
 358
 359     actsvr = HeapAlloc(GetProcessHeap(),0,sizeof(ActivatedTextService));
 360     if (!actsvr) return E_OUTOFMEMORY;
 361
 362     ITfThreadMgr_QueryInterface(tm,&IID_ITfClientId,(LPVOID)&clientid);
 363     ITfClientId_GetClientId(clientid, &lp->clsid, &actsvr->tid);
 364     ITfClientId_Release(clientid);
 365
 366     if (!actsvr->tid)
 367     {
 368         HeapFree(GetProcessHeap(),0,actsvr);
 369         return E_OUTOFMEMORY;
 370     }
 371
 372     actsvr->pITfTextInputProcessor = NULL;
 373     actsvr->LanguageProfile = *lp;
 374     actsvr->pITfKeyEventSink = NULL;
 375
 376     /* get TIP category */
 377     if (SUCCEEDED(CategoryMgr_Constructor(NULL,(IUnknown**)&catmgr)))
 378     {
 379         static const GUID *list[3] = {&GUID_TFCAT_TIP_SPEECH, &GUID_TFCAT_TIP_KEYBOARD, &GUID_TFCAT_TIP_HANDWRITING};
 380
 381         ITfCategoryMgr_FindClosestCategory(catmgr,
 382                 &actsvr->LanguageProfile.clsid, &actsvr->LanguageProfile.catid,
 383                 list, 3);
 384
 385         ITfCategoryMgr_Release(catmgr);
 386     }
 387     else
 388     {
 389         ERR("CategoryMgr construction failed\n");
 390         actsvr->LanguageProfile.catid = GUID_NULL;
 391     }
 392
 393     if (!IsEqualGUID(&actsvr->LanguageProfile.catid,&GUID_NULL))
 394         deactivate_remove_conflicting_ts(&actsvr->LanguageProfile.catid);
 395
 396     if (activated > 0)
 397         activate_given_ts(actsvr, tm);
 398
 399     entry = HeapAlloc(GetProcessHeap(),0,sizeof(AtsEntry));
 400
 401     if (!entry)
 402     {
 403         HeapFree(GetProcessHeap(),0,actsvr);
 404         return E_OUTOFMEMORY;
 405     }
 406
 407     entry->ats = actsvr;
 408     list_add_head(&AtsList, &entry->entry);
 409
 410     return S_OK;
 411 }
 412
 413 BOOL get_active_textservice(REFCLSID rclsid, TF_LANGUAGEPROFILE *profile)
 414 {
 415     AtsEntry *ats;
 416
 417     LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
 418     {
 419         if (IsEqualCLSID(rclsid,&ats->ats->LanguageProfile.clsid))
 420         {
 421             if (profile)
 422                 *profile = ats->ats->LanguageProfile;
 423             return TRUE;
 424         }
 425     }
 426     return FALSE;
 427 }
 428
 429 HRESULT activate_textservices(ITfThreadMgr *tm)
 430 {
 431     HRESULT hr = S_OK;
 432     AtsEntry *ats;
 433
 434     activated ++;
 435     if (activated > 1)
 436         return S_OK;
 437
 438     LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
 439     {
 440         hr = activate_given_ts(ats->ats, tm);
 441         if (FAILED(hr))
 442             FIXME("Failed to activate text service\n");
 443     }
 444     return hr;
 445 }
 446
 447 HRESULT deactivate_textservices(void)
 448 {
 449     AtsEntry *ats;
 450
 451     if (activated > 0)
 452         activated --;
 453
 454     if (activated == 0)
 455         LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
 456             deactivate_given_ts(ats->ats);
 457
 458     return S_OK;
 459 }
 460
 461 CLSID get_textservice_clsid(TfClientId tid)
 462 {
 463     AtsEntry *ats;
 464
 465     LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
 466         if (ats->ats->tid == tid)
 467             return ats->ats->LanguageProfile.clsid;
 468     return GUID_NULL;
 469 }
 470
 471 HRESULT get_textservice_sink(TfClientId tid, REFCLSID iid, IUnknown **sink)
 472 {
 473     AtsEntry *ats;
 474
 475     if (!IsEqualCLSID(iid,&IID_ITfKeyEventSink))
 476         return E_NOINTERFACE;
 477
 478     LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
 479         if (ats->ats->tid == tid)
 480         {
 481             *sink = (IUnknown*)ats->ats->pITfKeyEventSink;
 482             return S_OK;
 483         }
 484
 485     return E_FAIL;
 486 }
 487
 488 HRESULT set_textservice_sink(TfClientId tid, REFCLSID iid, IUnknown* sink)
 489 {
 490     AtsEntry *ats;
 491
 492     if (!IsEqualCLSID(iid,&IID_ITfKeyEventSink))
 493         return E_NOINTERFACE;
 494
 495     LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
 496         if (ats->ats->tid == tid)
 497         {
 498             ats->ats->pITfKeyEventSink = (ITfKeyEventSink*)sink;
 499             return S_OK;
 500         }
 501
 502     return E_FAIL;
 503 }
 504
 505 /*************************************************************************
 506  * MSCTF DllMain
 507  */
 508 BOOL WINAPI DllMain(HINSTANCE hinst, DWORD fdwReason, LPVOID fImpLoad)
 509 {
 510     TRACE("%p 0x%x %p\n", hinst, fdwReason, fImpLoad);
 511     switch (fdwReason)
 512     {
 513         case DLL_WINE_PREATTACH:
 514             return FALSE;   /* prefer native version */
 515         case DLL_PROCESS_ATTACH:
 516             MSCTF_hinstance = hinst;
 517             tlsIndex = TlsAlloc();
 518             break;
 519         case DLL_PROCESS_DETACH:
 520             if (fImpLoad) break;
 521             TlsFree(tlsIndex);
 522             break;
 523     }
 524     return TRUE;
 525 }
 526
 527 /*************************************************************************
 528  *              DllCanUnloadNow (MSCTF.@)
 529  */
 530 HRESULT WINAPI DllCanUnloadNow(void)
 531 {
 532     return S_FALSE;
 533 }
 534
 535 /***********************************************************************
 536  *              DllGetClassObject (MSCTF.@)
 537  */
 538 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, LPVOID *ppvOut)
 539 {
 540     int i;
 541
 542     *ppvOut = NULL;
 543     if (!IsEqualIID(iid, &IID_IUnknown) && !IsEqualIID(iid, &IID_IClassFactory))
 544         return E_NOINTERFACE;
 545
 546     for (i = 0; ClassesTable[i].clsid != NULL; i++)
 547         if (IsEqualCLSID(ClassesTable[i].clsid, clsid)) {
 548             return ClassFactory_Constructor(ClassesTable[i].ctor, ppvOut);
 549         }
 550     FIXME("CLSID %s not supported\n", debugstr_guid(clsid));
 551     return CLASS_E_CLASSNOTAVAILABLE;
 552 }
 553
 554 /***********************************************************************
 555  *              DllRegisterServer (MSCTF.@)
 556  */
 557 HRESULT WINAPI DllRegisterServer(void)
 558 {
 559     return __wine_register_resources( MSCTF_hinstance );
 560 }
 561
 562 /***********************************************************************
 563  *              DllUnregisterServer (MSCTF.@)
 564  */
 565 HRESULT WINAPI DllUnregisterServer(void)
 566 {
 567     return __wine_unregister_resources( MSCTF_hinstance );
 568 }
 569
 570 /***********************************************************************
 571  *              TF_CreateThreadMgr (MSCTF.@)
 572  */
 573 HRESULT WINAPI TF_CreateThreadMgr(ITfThreadMgr **pptim)
 574 {
 575     TRACE("\n");
 576     return ThreadMgr_Constructor(NULL,(IUnknown**)pptim);
 577 }
 578
 579 /***********************************************************************
 580  *              TF_GetThreadMgr (MSCTF.@)
 581  */
 582 HRESULT WINAPI TF_GetThreadMgr(ITfThreadMgr **pptim)
 583 {
 584     TRACE("\n");
 585     *pptim = TlsGetValue(tlsIndex);
 586
 587     if (*pptim)
 588         ITfThreadMgr_AddRef(*pptim);
 589
 590     return S_OK;
 591 }
 592
 593 /***********************************************************************
 594  *              SetInputScope(MSCTF.@)
 595  */
 596 HRESULT WINAPI SetInputScope(HWND hwnd, InputScope inputscope)
 597 {
 598     FIXME("STUB: %p %i\n",hwnd,inputscope);
 599     return S_OK;
 600 }
 601
 602 /***********************************************************************
 603  *              SetInputScopes(MSCTF.@)
 604  */
 605 HRESULT WINAPI SetInputScopes(HWND hwnd, const InputScope *pInputScopes,
 606                               UINT cInputScopes, WCHAR **ppszPhraseList,
 607                               UINT cPhrases, WCHAR *pszRegExp, WCHAR *pszSRGS)
 608 {
 609     UINT i;
 610     FIXME("STUB: %p ... %s %s\n",hwnd, debugstr_w(pszRegExp), debugstr_w(pszSRGS));
 611     for (i = 0; i < cInputScopes; i++)
 612         TRACE("\tScope[%u] = %i\n",i,pInputScopes[i]);
 613     for (i = 0; i < cPhrases; i++)
 614         TRACE("\tPhrase[%u] = %s\n",i,debugstr_w(ppszPhraseList[i]));
 615
 616     return S_OK;
 617 }
 618
 619 /***********************************************************************
 620  *              TF_CreateInputProcessorProfiles(MSCTF.@)
 621  */
 622 HRESULT WINAPI TF_CreateInputProcessorProfiles(
 623                         ITfInputProcessorProfiles **ppipr)
 624 {
 625     return InputProcessorProfiles_Constructor(NULL,(IUnknown**)ppipr);
 626 }
 627
 628 /***********************************************************************
 629  *              TF_InvalidAssemblyListCacheIfExist(MSCTF.@)
 630  */
 631 HRESULT WINAPI TF_InvalidAssemblyListCacheIfExist(void)
 632 {
 633     FIXME("Stub\n");
 634     return S_OK;
 635 }
 636
 637 /***********************************************************************
 638  *              TF_CreateLangBarMgr (MSCTF.@)
 639  */
 640 HRESULT WINAPI TF_CreateLangBarMgr(ITfLangBarMgr **pppbm)
 641 {
 642     TRACE("\n");
 643     return LangBarMgr_Constructor(NULL,(IUnknown**)pppbm);
 644 }
 645
 646 HRESULT WINAPI TF_CreateLangBarItemMgr(ITfLangBarItemMgr **pplbim)
 647 {
 648     FIXME("stub %p\n", pplbim);
 649     *pplbim = NULL;
 650
 651     return E_NOTIMPL;
 652 }
 653
 654 /***********************************************************************
 655  *              TF_InitMlngInfo (MSCTF.@)
 656  */
 657 HRESULT WINAPI TF_InitMlngInfo(void)
 658 {
 659     FIXME("stub\n");
 660     return S_OK;
 661 }