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     HeapFree(GetProcessHeap(),0,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 = HeapAlloc(GetProcessHeap(),0,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 = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CookieInternal) * 10);
 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 = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cookies,
 210                                                       sizeof(CookieInternal) * (array_size * 2));
 211             if (!new_cookies)
 212             {
 213                 ERR("Out of memory, Unable to realloc cookies array\n");
 214                 return 0;
 215             }
 216             cookies = new_cookies;
 217             array_size *= 2;
 218         }
 219     }
 220
 221     cookies[i].id = i + 1; /* a return of 0 is used for failure */
 222     cookies[i].magic = magic;
 223     cookies[i].data = data;
 224
 225     if (i == id_last)
 226         id_last++;
 227
 228     return cookies[i].id;
 229 }
 230
 231 DWORD get_Cookie_magic(DWORD id)
 232 {
 233     UINT index = id - 1;
 234
 235     if (index >= id_last)
 236         return 0;
 237
 238     if (cookies[index].id == 0)
 239         return 0;
 240
 241     return cookies[index].magic;
 242 }
 243
 244 LPVOID get_Cookie_data(DWORD id)
 245 {
 246     UINT index = id - 1;
 247
 248     if (index >= id_last)
 249         return NULL;
 250
 251     if (cookies[index].id == 0)
 252         return NULL;
 253
 254     return cookies[index].data;
 255 }
 256
 257 LPVOID remove_Cookie(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     cookies[index].id = 0;
 268     return cookies[index].data;
 269 }
 270
 271 DWORD enumerate_Cookie(DWORD magic, DWORD *index)
 272 {
 273     unsigned int i;
 274     for (i = *index; i < id_last; i++)
 275         if (cookies[i].id != 0 && cookies[i].magic == magic)
 276         {
 277             *index = (i+1);
 278             return cookies[i].id;
 279         }
 280     return 0x0;
 281 }
 282
 283 HRESULT advise_sink(struct list *sink_list, REFIID riid, DWORD cookie_magic, IUnknown *unk, DWORD *cookie)
 284 {
 285     Sink *sink;
 286
 287     sink = HeapAlloc(GetProcessHeap(), 0, sizeof(*sink));
 288     if (!sink)
 289         return E_OUTOFMEMORY;
 290
 291     if (FAILED(IUnknown_QueryInterface(unk, riid, (void**)&sink->interfaces.pIUnknown)))
 292     {
 293         HeapFree(GetProcessHeap(), 0, sink);
 294         return CONNECT_E_CANNOTCONNECT;
 295     }
 296
 297     list_add_head(sink_list, &sink->entry);
 298     *cookie = generate_Cookie(cookie_magic, sink);
 299     TRACE("cookie %x\n", *cookie);
 300     return S_OK;
 301 }
 302
 303 static void free_sink(Sink *sink)
 304 {
 305     list_remove(&sink->entry);
 306     IUnknown_Release(sink->interfaces.pIUnknown);
 307     HeapFree(GetProcessHeap(), 0, sink);
 308 }
 309
 310 HRESULT unadvise_sink(DWORD cookie)
 311 {
 312     Sink *sink;
 313
 314     sink = remove_Cookie(cookie);
 315     if (!sink)
 316         return CONNECT_E_NOCONNECTION;
 317
 318     free_sink(sink);
 319     return S_OK;
 320 }
 321
 322 void free_sinks(struct list *sink_list)
 323 {
 324     while(!list_empty(sink_list))
 325     {
 326         Sink* sink = LIST_ENTRY(sink_list->next, Sink, entry);
 327         free_sink(sink);
 328     }
 329 }
 330
 331 /*****************************************************************************
 332  * Active Text Service Management
 333  *****************************************************************************/
 334 static HRESULT activate_given_ts(ActivatedTextService *actsvr, ITfThreadMgrEx *tm)
 335 {
 336     HRESULT hr;
 337
 338     /* Already Active? */
 339     if (actsvr->pITfTextInputProcessor)
 340         return S_OK;
 341
 342     hr = CoCreateInstance (&actsvr->LanguageProfile.clsid, NULL, CLSCTX_INPROC_SERVER,
 343         &IID_ITfTextInputProcessor, (void**)&actsvr->pITfTextInputProcessor);
 344     if (FAILED(hr)) return hr;
 345
 346     hr = ITfTextInputProcessor_Activate(actsvr->pITfTextInputProcessor, (ITfThreadMgr *)tm, actsvr->tid);
 347     if (FAILED(hr))
 348     {
 349         ITfTextInputProcessor_Release(actsvr->pITfTextInputProcessor);
 350         actsvr->pITfTextInputProcessor = NULL;
 351         return hr;
 352     }
 353
 354     actsvr->pITfThreadMgrEx = tm;
 355     ITfThreadMgrEx_AddRef(tm);
 356     return hr;
 357 }
 358
 359 static HRESULT deactivate_given_ts(ActivatedTextService *actsvr)
 360 {
 361     HRESULT hr = S_OK;
 362
 363     if (actsvr->pITfTextInputProcessor)
 364     {
 365         hr = ITfTextInputProcessor_Deactivate(actsvr->pITfTextInputProcessor);
 366         ITfTextInputProcessor_Release(actsvr->pITfTextInputProcessor);
 367         ITfThreadMgrEx_Release(actsvr->pITfThreadMgrEx);
 368         actsvr->pITfTextInputProcessor = NULL;
 369         actsvr->pITfThreadMgrEx = NULL;
 370     }
 371
 372     return hr;
 373 }
 374
 375 static void deactivate_remove_conflicting_ts(REFCLSID catid)
 376 {
 377     AtsEntry *ats, *cursor2;
 378
 379     LIST_FOR_EACH_ENTRY_SAFE(ats, cursor2, &AtsList, AtsEntry, entry)
 380     {
 381         if (IsEqualCLSID(catid,&ats->ats->LanguageProfile.catid))
 382         {
 383             deactivate_given_ts(ats->ats);
 384             list_remove(&ats->entry);
 385             HeapFree(GetProcessHeap(),0,ats->ats);
 386             HeapFree(GetProcessHeap(),0,ats);
 387             /* we are guaranteeing there is only 1 */
 388             break;
 389         }
 390     }
 391 }
 392
 393 HRESULT add_active_textservice(TF_LANGUAGEPROFILE *lp)
 394 {
 395     ActivatedTextService *actsvr;
 396     ITfCategoryMgr *catmgr;
 397     AtsEntry *entry;
 398     ITfThreadMgrEx *tm = TlsGetValue(tlsIndex);
 399     ITfClientId *clientid;
 400
 401     if (!tm) return E_UNEXPECTED;
 402
 403     actsvr = HeapAlloc(GetProcessHeap(),0,sizeof(ActivatedTextService));
 404     if (!actsvr) return E_OUTOFMEMORY;
 405
 406     ITfThreadMgrEx_QueryInterface(tm, &IID_ITfClientId, (void **)&clientid);
 407     ITfClientId_GetClientId(clientid, &lp->clsid, &actsvr->tid);
 408     ITfClientId_Release(clientid);
 409
 410     if (!actsvr->tid)
 411     {
 412         HeapFree(GetProcessHeap(),0,actsvr);
 413         return E_OUTOFMEMORY;
 414     }
 415
 416     actsvr->pITfTextInputProcessor = NULL;
 417     actsvr->LanguageProfile = *lp;
 418     actsvr->pITfKeyEventSink = NULL;
 419
 420     /* get TIP category */
 421     if (SUCCEEDED(CategoryMgr_Constructor(NULL,(IUnknown**)&catmgr)))
 422     {
 423         static const GUID *list[3] = {&GUID_TFCAT_TIP_SPEECH, &GUID_TFCAT_TIP_KEYBOARD, &GUID_TFCAT_TIP_HANDWRITING};
 424
 425         ITfCategoryMgr_FindClosestCategory(catmgr,
 426                 &actsvr->LanguageProfile.clsid, &actsvr->LanguageProfile.catid,
 427                 list, 3);
 428
 429         ITfCategoryMgr_Release(catmgr);
 430     }
 431     else
 432     {
 433         ERR("CategoryMgr construction failed\n");
 434         actsvr->LanguageProfile.catid = GUID_NULL;
 435     }
 436
 437     if (!IsEqualGUID(&actsvr->LanguageProfile.catid,&GUID_NULL))
 438         deactivate_remove_conflicting_ts(&actsvr->LanguageProfile.catid);
 439
 440     if (activated > 0)
 441         activate_given_ts(actsvr, tm);
 442
 443     entry = HeapAlloc(GetProcessHeap(),0,sizeof(AtsEntry));
 444
 445     if (!entry)
 446     {
 447         HeapFree(GetProcessHeap(),0,actsvr);
 448         return E_OUTOFMEMORY;
 449     }
 450
 451     entry->ats = actsvr;
 452     list_add_head(&AtsList, &entry->entry);
 453
 454     return S_OK;
 455 }
 456
 457 BOOL get_active_textservice(REFCLSID rclsid, TF_LANGUAGEPROFILE *profile)
 458 {
 459     AtsEntry *ats;
 460
 461     LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
 462     {
 463         if (IsEqualCLSID(rclsid,&ats->ats->LanguageProfile.clsid))
 464         {
 465             if (profile)
 466                 *profile = ats->ats->LanguageProfile;
 467             return TRUE;
 468         }
 469     }
 470     return FALSE;
 471 }
 472
 473 HRESULT activate_textservices(ITfThreadMgrEx *tm)
 474 {
 475     HRESULT hr = S_OK;
 476     AtsEntry *ats;
 477
 478     activated ++;
 479     if (activated > 1)
 480         return S_OK;
 481
 482     LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
 483     {
 484         hr = activate_given_ts(ats->ats, tm);
 485         if (FAILED(hr))
 486             FIXME("Failed to activate text service\n");
 487     }
 488     return hr;
 489 }
 490
 491 HRESULT deactivate_textservices(void)
 492 {
 493     AtsEntry *ats;
 494
 495     if (activated > 0)
 496         activated --;
 497
 498     if (activated == 0)
 499         LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
 500             deactivate_given_ts(ats->ats);
 501
 502     return S_OK;
 503 }
 504
 505 CLSID get_textservice_clsid(TfClientId tid)
 506 {
 507     AtsEntry *ats;
 508
 509     LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
 510         if (ats->ats->tid == tid)
 511             return ats->ats->LanguageProfile.clsid;
 512     return GUID_NULL;
 513 }
 514
 515 HRESULT get_textservice_sink(TfClientId tid, REFCLSID iid, IUnknown **sink)
 516 {
 517     AtsEntry *ats;
 518
 519     if (!IsEqualCLSID(iid,&IID_ITfKeyEventSink))
 520         return E_NOINTERFACE;
 521
 522     LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
 523         if (ats->ats->tid == tid)
 524         {
 525             *sink = (IUnknown*)ats->ats->pITfKeyEventSink;
 526             return S_OK;
 527         }
 528
 529     return E_FAIL;
 530 }
 531
 532 HRESULT set_textservice_sink(TfClientId tid, REFCLSID iid, IUnknown* sink)
 533 {
 534     AtsEntry *ats;
 535
 536     if (!IsEqualCLSID(iid,&IID_ITfKeyEventSink))
 537         return E_NOINTERFACE;
 538
 539     LIST_FOR_EACH_ENTRY(ats, &AtsList, AtsEntry, entry)
 540         if (ats->ats->tid == tid)
 541         {
 542             ats->ats->pITfKeyEventSink = (ITfKeyEventSink*)sink;
 543             return S_OK;
 544         }
 545
 546     return E_FAIL;
 547 }
 548
 549 /*************************************************************************
 550  * MSCTF DllMain
 551  */
 552 BOOL WINAPI DllMain(HINSTANCE hinst, DWORD fdwReason, LPVOID fImpLoad)
 553 {
 554     TRACE("%p 0x%x %p\n", hinst, fdwReason, fImpLoad);
 555     switch (fdwReason)
 556     {
 557         case DLL_PROCESS_ATTACH:
 558             tlsIndex = TlsAlloc();
 559             break;
 560         case DLL_PROCESS_DETACH:
 561             if (fImpLoad) break;
 562             TlsFree(tlsIndex);
 563             break;
 564     }
 565     return TRUE;
 566 }
 567
 568 /***********************************************************************
 569  *              DllGetClassObject (MSCTF.@)
 570  */
 571 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, LPVOID *ppvOut)
 572 {
 573     int i;
 574
 575     *ppvOut = NULL;
 576     if (!IsEqualIID(iid, &IID_IUnknown) && !IsEqualIID(iid, &IID_IClassFactory))
 577         return E_NOINTERFACE;
 578
 579     for (i = 0; ClassesTable[i].clsid != NULL; i++)
 580         if (IsEqualCLSID(ClassesTable[i].clsid, clsid)) {
 581             return ClassFactory_Constructor(ClassesTable[i].ctor, ppvOut);
 582         }
 583     FIXME("CLSID %s not supported\n", debugstr_guid(clsid));
 584     return CLASS_E_CLASSNOTAVAILABLE;
 585 }
 586
 587 /***********************************************************************
 588  *              TF_CreateThreadMgr (MSCTF.@)
 589  */
 590 HRESULT WINAPI TF_CreateThreadMgr(ITfThreadMgr **pptim)
 591 {
 592     TRACE("\n");
 593     return ThreadMgr_Constructor(NULL,(IUnknown**)pptim);
 594 }
 595
 596 /***********************************************************************
 597  *              TF_GetThreadMgr (MSCTF.@)
 598  */
 599 HRESULT WINAPI TF_GetThreadMgr(ITfThreadMgr **pptim)
 600 {
 601     TRACE("\n");
 602     *pptim = TlsGetValue(tlsIndex);
 603
 604     if (*pptim)
 605         ITfThreadMgr_AddRef(*pptim);
 606
 607     return S_OK;
 608 }
 609
 610 /***********************************************************************
 611  *              SetInputScope(MSCTF.@)
 612  */
 613 HRESULT WINAPI SetInputScope(HWND hwnd, InputScope inputscope)
 614 {
 615     FIXME("STUB: %p %i\n",hwnd,inputscope);
 616     return S_OK;
 617 }
 618
 619 /***********************************************************************
 620  *              SetInputScopes(MSCTF.@)
 621  */
 622 HRESULT WINAPI SetInputScopes(HWND hwnd, const InputScope *pInputScopes,
 623                               UINT cInputScopes, WCHAR **ppszPhraseList,
 624                               UINT cPhrases, WCHAR *pszRegExp, WCHAR *pszSRGS)
 625 {
 626     UINT i;
 627     FIXME("STUB: %p ... %s %s\n",hwnd, debugstr_w(pszRegExp), debugstr_w(pszSRGS));
 628     for (i = 0; i < cInputScopes; i++)
 629         TRACE("\tScope[%u] = %i\n",i,pInputScopes[i]);
 630     for (i = 0; i < cPhrases; i++)
 631         TRACE("\tPhrase[%u] = %s\n",i,debugstr_w(ppszPhraseList[i]));
 632
 633     return S_OK;
 634 }
 635
 636 /***********************************************************************
 637  *              TF_CreateInputProcessorProfiles(MSCTF.@)
 638  */
 639 HRESULT WINAPI TF_CreateInputProcessorProfiles(
 640                         ITfInputProcessorProfiles **ppipr)
 641 {
 642     return InputProcessorProfiles_Constructor(NULL,(IUnknown**)ppipr);
 643 }
 644
 645 /***********************************************************************
 646  *              TF_InvalidAssemblyListCacheIfExist(MSCTF.@)
 647  */
 648 HRESULT WINAPI TF_InvalidAssemblyListCacheIfExist(void)
 649 {
 650     FIXME("Stub\n");
 651     return S_OK;
 652 }
 653
 654 /***********************************************************************
 655  *              TF_CreateLangBarMgr (MSCTF.@)
 656  */
 657 HRESULT WINAPI TF_CreateLangBarMgr(ITfLangBarMgr **pppbm)
 658 {
 659     TRACE("\n");
 660     return LangBarMgr_Constructor(NULL,(IUnknown**)pppbm);
 661 }
 662
 663 HRESULT WINAPI TF_CreateLangBarItemMgr(ITfLangBarItemMgr **pplbim)
 664 {
 665     FIXME("stub %p\n", pplbim);
 666     *pplbim = NULL;
 667
 668     return E_NOTIMPL;
 669 }
 670
 671 /***********************************************************************
 672  *              TF_InitMlngInfo (MSCTF.@)
 673  */
 674 HRESULT WINAPI TF_InitMlngInfo(void)
 675 {
 676     FIXME("stub\n");
 677     return S_OK;
 678 }