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