dlls/msctf/inputprocessor.c

   1 /*
   2  *  ITfInputProcessorProfiles implementation
   3  *
   4  *  Copyright 2009 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
  25 #define COBJMACROS
  26
  27 #include "wine/debug.h"
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winreg.h"
  31 #include "winuser.h"
  32 #include "shlwapi.h"
  33 #include "winerror.h"
  34 #include "objbase.h"
  35 #include "olectl.h"
  36
  37 #include "wine/unicode.h"
  38 #include "wine/list.h"
  39
  40 #include "msctf.h"
  41 #include "msctf_internal.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(msctf);
  44
  45 static const WCHAR szwLngp[] = {'L','a','n','g','u','a','g','e','P','r','o','f','i','l','e',0};
  46 static const WCHAR szwEnable[] = {'E','n','a','b','l','e',0};
  47 static const WCHAR szwTipfmt[] = {'%','s','\\','%','s',0};
  48 static const WCHAR szwFullLangfmt[] = {'%','s','\\','%','s','\\','%','s','\\','0','x','%','0','8','x','\\','%','s',0};
  49
  50 static const WCHAR szwAssemblies[] = {'A','s','s','e','m','b','l','i','e','s',0};
  51 static const WCHAR szwDefault[] = {'D','e','f','a','u','l','t',0};
  52 static const WCHAR szwProfile[] = {'P','r','o','f','i','l','e',0};
  53 static const WCHAR szwDefaultFmt[] = {'%','s','\\','%','s','\\','0','x','%','0','8','x','\\','%','s',0};
  54
  55 typedef struct tagInputProcessorProfilesSink {
  56     struct list         entry;
  57     union {
  58         /* InputProcessorProfile Sinks */
  59         IUnknown            *pIUnknown;
  60         ITfLanguageProfileNotifySink *pITfLanguageProfileNotifySink;
  61     } interfaces;
  62 } InputProcessorProfilesSink;
  63
  64 typedef struct tagInputProcessorProfiles {
  65     ITfInputProcessorProfiles ITfInputProcessorProfiles_iface;
  66     ITfSource ITfSource_iface;
  67     /* const ITfInputProcessorProfileMgrVtbl *InputProcessorProfileMgrVtbl; */
  68     /* const ITfInputProcessorProfilesExVtbl *InputProcessorProfilesExVtbl; */
  69     /* const ITfInputProcessorProfileSubstituteLayoutVtbl *InputProcessorProfileSubstituteLayoutVtbl; */
  70     LONG refCount;
  71
  72     LANGID  currentLanguage;
  73
  74     struct list     LanguageProfileNotifySink;
  75 } InputProcessorProfiles;
  76
  77 typedef struct tagProfilesEnumGuid {
  78     IEnumGUID IEnumGUID_iface;
  79     LONG refCount;
  80
  81     HKEY key;
  82     DWORD next_index;
  83 } ProfilesEnumGuid;
  84
  85 typedef struct tagEnumTfLanguageProfiles {
  86     IEnumTfLanguageProfiles IEnumTfLanguageProfiles_iface;
  87     LONG refCount;
  88
  89     HKEY    tipkey;
  90     DWORD   tip_index;
  91     WCHAR   szwCurrentClsid[39];
  92
  93     HKEY    langkey;
  94     DWORD   lang_index;
  95
  96     LANGID  langid;
  97     ITfCategoryMgr *catmgr;
  98 } EnumTfLanguageProfiles;
  99
 100 static HRESULT ProfilesEnumGuid_Constructor(IEnumGUID **ppOut);
 101 static HRESULT EnumTfLanguageProfiles_Constructor(LANGID langid, IEnumTfLanguageProfiles **ppOut);
 102
 103 static inline InputProcessorProfiles *impl_from_ITfInputProcessorProfiles(ITfInputProcessorProfiles *iface)
 104 {
 105     return CONTAINING_RECORD(iface, InputProcessorProfiles, ITfInputProcessorProfiles_iface);
 106 }
 107
 108 static inline InputProcessorProfiles *impl_from_ITfSource(ITfSource *iface)
 109 {
 110     return CONTAINING_RECORD(iface, InputProcessorProfiles, ITfSource_iface);
 111 }
 112
 113 static inline ProfilesEnumGuid *impl_from_IEnumGUID(IEnumGUID *iface)
 114 {
 115     return CONTAINING_RECORD(iface, ProfilesEnumGuid, IEnumGUID_iface);
 116 }
 117
 118 static inline EnumTfLanguageProfiles *impl_from_IEnumTfLanguageProfiles(IEnumTfLanguageProfiles *iface)
 119 {
 120     return CONTAINING_RECORD(iface, EnumTfLanguageProfiles, IEnumTfLanguageProfiles_iface);
 121 }
 122
 123 static void free_sink(InputProcessorProfilesSink *sink)
 124 {
 125         IUnknown_Release(sink->interfaces.pIUnknown);
 126         HeapFree(GetProcessHeap(),0,sink);
 127 }
 128
 129 static void InputProcessorProfiles_Destructor(InputProcessorProfiles *This)
 130 {
 131     struct list *cursor, *cursor2;
 132     TRACE("destroying %p\n", This);
 133
 134     /* free sinks */
 135     LIST_FOR_EACH_SAFE(cursor, cursor2, &This->LanguageProfileNotifySink)
 136     {
 137         InputProcessorProfilesSink* sink = LIST_ENTRY(cursor,InputProcessorProfilesSink,entry);
 138         list_remove(cursor);
 139         free_sink(sink);
 140     }
 141
 142     HeapFree(GetProcessHeap(),0,This);
 143 }
 144
 145 static void add_userkey( REFCLSID rclsid, LANGID langid,
 146                                 REFGUID guidProfile)
 147 {
 148     HKEY key;
 149     WCHAR buf[39];
 150     WCHAR buf2[39];
 151     WCHAR fullkey[168];
 152     DWORD disposition = 0;
 153     ULONG res;
 154
 155     TRACE("\n");
 156
 157     StringFromGUID2(rclsid, buf, 39);
 158     StringFromGUID2(guidProfile, buf2, 39);
 159     sprintfW(fullkey,szwFullLangfmt,szwSystemTIPKey,buf,szwLngp,langid,buf2);
 160
 161     res = RegCreateKeyExW(HKEY_CURRENT_USER,fullkey, 0, NULL, 0,
 162                    KEY_READ | KEY_WRITE, NULL, &key, &disposition);
 163
 164     if (!res && disposition == REG_CREATED_NEW_KEY)
 165     {
 166         DWORD zero = 0x0;
 167         RegSetValueExW(key, szwEnable, 0, REG_DWORD, (LPBYTE)&zero, sizeof(DWORD));
 168     }
 169
 170     if (!res)
 171         RegCloseKey(key);
 172 }
 173
 174 static HRESULT WINAPI InputProcessorProfiles_QueryInterface(ITfInputProcessorProfiles *iface, REFIID iid, LPVOID *ppvOut)
 175 {
 176     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 177     *ppvOut = NULL;
 178
 179     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_ITfInputProcessorProfiles))
 180     {
 181         *ppvOut = &This->ITfInputProcessorProfiles_iface;
 182     }
 183     else if (IsEqualIID(iid, &IID_ITfSource))
 184     {
 185         *ppvOut = &This->ITfSource_iface;
 186     }
 187
 188     if (*ppvOut)
 189     {
 190         ITfInputProcessorProfiles_AddRef(iface);
 191         return S_OK;
 192     }
 193
 194     WARN("unsupported interface: %s\n", debugstr_guid(iid));
 195     return E_NOINTERFACE;
 196 }
 197
 198 static ULONG WINAPI InputProcessorProfiles_AddRef(ITfInputProcessorProfiles *iface)
 199 {
 200     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 201     return InterlockedIncrement(&This->refCount);
 202 }
 203
 204 static ULONG WINAPI InputProcessorProfiles_Release(ITfInputProcessorProfiles *iface)
 205 {
 206     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 207     ULONG ret;
 208
 209     ret = InterlockedDecrement(&This->refCount);
 210     if (ret == 0)
 211         InputProcessorProfiles_Destructor(This);
 212     return ret;
 213 }
 214
 215 /*****************************************************
 216  * ITfInputProcessorProfiles functions
 217  *****************************************************/
 218 static HRESULT WINAPI InputProcessorProfiles_Register(
 219         ITfInputProcessorProfiles *iface, REFCLSID rclsid)
 220 {
 221     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 222     HKEY tipkey;
 223     WCHAR buf[39];
 224     WCHAR fullkey[68];
 225
 226     TRACE("(%p) %s\n",This,debugstr_guid(rclsid));
 227
 228     StringFromGUID2(rclsid, buf, 39);
 229     sprintfW(fullkey,szwTipfmt,szwSystemTIPKey,buf);
 230
 231     if (RegCreateKeyExW(HKEY_LOCAL_MACHINE,fullkey, 0, NULL, 0,
 232                     KEY_READ | KEY_WRITE, NULL, &tipkey, NULL) != ERROR_SUCCESS)
 233         return E_FAIL;
 234
 235     RegCloseKey(tipkey);
 236
 237     return S_OK;
 238 }
 239
 240 static HRESULT WINAPI InputProcessorProfiles_Unregister(
 241         ITfInputProcessorProfiles *iface, REFCLSID rclsid)
 242 {
 243     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 244     WCHAR buf[39];
 245     WCHAR fullkey[68];
 246
 247     TRACE("(%p) %s\n",This,debugstr_guid(rclsid));
 248
 249     StringFromGUID2(rclsid, buf, 39);
 250     sprintfW(fullkey,szwTipfmt,szwSystemTIPKey,buf);
 251
 252     RegDeleteTreeW(HKEY_LOCAL_MACHINE, fullkey);
 253     RegDeleteTreeW(HKEY_CURRENT_USER, fullkey);
 254
 255     return S_OK;
 256 }
 257
 258 static HRESULT WINAPI InputProcessorProfiles_AddLanguageProfile(
 259         ITfInputProcessorProfiles *iface, REFCLSID rclsid,
 260         LANGID langid, REFGUID guidProfile, const WCHAR *pchDesc,
 261         ULONG cchDesc, const WCHAR *pchIconFile, ULONG cchFile,
 262         ULONG uIconIndex)
 263 {
 264     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 265     HKEY tipkey,fmtkey;
 266     WCHAR buf[39];
 267     WCHAR fullkey[100];
 268     ULONG res;
 269     DWORD disposition = 0;
 270
 271     static const WCHAR fmt2[] = {'%','s','\\','0','x','%','0','8','x','\\','%','s',0};
 272     static const WCHAR desc[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
 273     static const WCHAR icnf[] = {'I','c','o','n','F','i','l','e',0};
 274     static const WCHAR icni[] = {'I','c','o','n','I','n','d','e','x',0};
 275
 276     TRACE("(%p) %s %x %s %s %s %i\n",This,debugstr_guid(rclsid), langid,
 277             debugstr_guid(guidProfile), debugstr_wn(pchDesc,cchDesc),
 278             debugstr_wn(pchIconFile,cchFile),uIconIndex);
 279
 280     StringFromGUID2(rclsid, buf, 39);
 281     sprintfW(fullkey,szwTipfmt,szwSystemTIPKey,buf);
 282
 283     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,fullkey, 0, KEY_READ | KEY_WRITE,
 284                 &tipkey ) != ERROR_SUCCESS)
 285         return E_FAIL;
 286
 287     StringFromGUID2(guidProfile, buf, 39);
 288     sprintfW(fullkey,fmt2,szwLngp,langid,buf);
 289
 290     res = RegCreateKeyExW(tipkey,fullkey, 0, NULL, 0, KEY_READ | KEY_WRITE,
 291             NULL, &fmtkey, &disposition);
 292
 293     if (!res)
 294     {
 295         DWORD zero = 0x0;
 296         RegSetValueExW(fmtkey, desc, 0, REG_SZ, (const BYTE*)pchDesc, cchDesc * sizeof(WCHAR));
 297         RegSetValueExW(fmtkey, icnf, 0, REG_SZ, (const BYTE*)pchIconFile, cchFile * sizeof(WCHAR));
 298         RegSetValueExW(fmtkey, icni, 0, REG_DWORD, (LPBYTE)&uIconIndex, sizeof(DWORD));
 299         if (disposition == REG_CREATED_NEW_KEY)
 300             RegSetValueExW(fmtkey, szwEnable, 0, REG_DWORD, (LPBYTE)&zero, sizeof(DWORD));
 301         RegCloseKey(fmtkey);
 302
 303         add_userkey(rclsid, langid, guidProfile);
 304     }
 305     RegCloseKey(tipkey);
 306
 307     if (!res)
 308         return S_OK;
 309     else
 310         return E_FAIL;
 311 }
 312
 313 static HRESULT WINAPI InputProcessorProfiles_RemoveLanguageProfile(
 314         ITfInputProcessorProfiles *iface, REFCLSID rclsid, LANGID langid,
 315         REFGUID guidProfile)
 316 {
 317     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 318     FIXME("STUB:(%p)\n",This);
 319     return E_NOTIMPL;
 320 }
 321
 322 static HRESULT WINAPI InputProcessorProfiles_EnumInputProcessorInfo(
 323         ITfInputProcessorProfiles *iface, IEnumGUID **ppEnum)
 324 {
 325     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 326     TRACE("(%p) %p\n",This,ppEnum);
 327     return ProfilesEnumGuid_Constructor(ppEnum);
 328 }
 329
 330 static HRESULT WINAPI InputProcessorProfiles_GetDefaultLanguageProfile(
 331         ITfInputProcessorProfiles *iface, LANGID langid, REFGUID catid,
 332         CLSID *pclsid, GUID *pguidProfile)
 333 {
 334     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 335     WCHAR fullkey[168];
 336     WCHAR buf[39];
 337     HKEY hkey;
 338     DWORD count;
 339     ULONG res;
 340
 341     TRACE("%p) %x %s %p %p\n",This, langid, debugstr_guid(catid),pclsid,pguidProfile);
 342
 343     if (!catid || !pclsid || !pguidProfile)
 344         return E_INVALIDARG;
 345
 346     StringFromGUID2(catid, buf, 39);
 347     sprintfW(fullkey, szwDefaultFmt, szwSystemCTFKey, szwAssemblies, langid, buf);
 348
 349     if (RegOpenKeyExW(HKEY_CURRENT_USER, fullkey, 0, KEY_READ | KEY_WRITE,
 350                 &hkey ) != ERROR_SUCCESS)
 351         return S_FALSE;
 352
 353     count = sizeof(buf);
 354     res = RegQueryValueExW(hkey, szwDefault, 0, NULL, (LPBYTE)buf, &count);
 355     if (res != ERROR_SUCCESS)
 356     {
 357         RegCloseKey(hkey);
 358         return S_FALSE;
 359     }
 360     CLSIDFromString(buf,pclsid);
 361
 362     res = RegQueryValueExW(hkey, szwProfile, 0, NULL, (LPBYTE)buf, &count);
 363     if (res == ERROR_SUCCESS)
 364         CLSIDFromString(buf,pguidProfile);
 365
 366     RegCloseKey(hkey);
 367
 368     return S_OK;
 369 }
 370
 371 static HRESULT WINAPI InputProcessorProfiles_SetDefaultLanguageProfile(
 372         ITfInputProcessorProfiles *iface, LANGID langid, REFCLSID rclsid,
 373         REFGUID guidProfiles)
 374 {
 375     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 376     WCHAR fullkey[168];
 377     WCHAR buf[39];
 378     HKEY hkey;
 379     GUID catid;
 380     HRESULT hr;
 381     ITfCategoryMgr *catmgr;
 382     static const GUID * tipcats[3] = { &GUID_TFCAT_TIP_KEYBOARD,
 383                                        &GUID_TFCAT_TIP_SPEECH,
 384                                        &GUID_TFCAT_TIP_HANDWRITING };
 385
 386     TRACE("%p) %x %s %s\n",This, langid, debugstr_guid(rclsid),debugstr_guid(guidProfiles));
 387
 388     if (!rclsid || !guidProfiles)
 389         return E_INVALIDARG;
 390
 391     hr = CategoryMgr_Constructor(NULL,(IUnknown**)&catmgr);
 392
 393     if (FAILED(hr))
 394         return hr;
 395
 396     if (ITfCategoryMgr_FindClosestCategory(catmgr, rclsid,
 397             &catid, tipcats, 3) != S_OK)
 398         hr = ITfCategoryMgr_FindClosestCategory(catmgr, rclsid,
 399                 &catid, NULL, 0);
 400     ITfCategoryMgr_Release(catmgr);
 401
 402     if (FAILED(hr))
 403         return E_FAIL;
 404
 405     StringFromGUID2(&catid, buf, 39);
 406     sprintfW(fullkey, szwDefaultFmt, szwSystemCTFKey, szwAssemblies, langid, buf);
 407
 408     if (RegCreateKeyExW(HKEY_CURRENT_USER, fullkey, 0, NULL, 0, KEY_READ | KEY_WRITE,
 409                 NULL, &hkey, NULL ) != ERROR_SUCCESS)
 410         return E_FAIL;
 411
 412     StringFromGUID2(rclsid, buf, 39);
 413     RegSetValueExW(hkey, szwDefault, 0, REG_SZ, (LPBYTE)buf, sizeof(buf));
 414     StringFromGUID2(guidProfiles, buf, 39);
 415     RegSetValueExW(hkey, szwProfile, 0, REG_SZ, (LPBYTE)buf, sizeof(buf));
 416     RegCloseKey(hkey);
 417
 418     return S_OK;
 419 }
 420
 421 static HRESULT WINAPI InputProcessorProfiles_ActivateLanguageProfile(
 422         ITfInputProcessorProfiles *iface, REFCLSID rclsid, LANGID langid,
 423         REFGUID guidProfiles)
 424 {
 425     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 426     HRESULT hr;
 427     BOOL enabled;
 428     TF_LANGUAGEPROFILE LanguageProfile;
 429
 430     TRACE("(%p) %s %x %s\n",This,debugstr_guid(rclsid),langid,debugstr_guid(guidProfiles));
 431
 432     if (langid != This->currentLanguage) return E_INVALIDARG;
 433
 434     if (get_active_textservice(rclsid,NULL))
 435     {
 436         TRACE("Already Active\n");
 437         return E_FAIL;
 438     }
 439
 440     hr = ITfInputProcessorProfiles_IsEnabledLanguageProfile(iface, rclsid,
 441             langid, guidProfiles, &enabled);
 442     if (FAILED(hr) || !enabled)
 443     {
 444         TRACE("Not Enabled\n");
 445         return E_FAIL;
 446     }
 447
 448     LanguageProfile.clsid = *rclsid;
 449     LanguageProfile.langid = langid;
 450     LanguageProfile.guidProfile = *guidProfiles;
 451
 452     hr = add_active_textservice(&LanguageProfile);
 453
 454     return hr;
 455 }
 456
 457 static HRESULT WINAPI InputProcessorProfiles_GetActiveLanguageProfile(
 458         ITfInputProcessorProfiles *iface, REFCLSID rclsid, LANGID *plangid,
 459         GUID *pguidProfile)
 460 {
 461     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 462     TF_LANGUAGEPROFILE profile;
 463
 464     TRACE("(%p) %s %p %p\n",This,debugstr_guid(rclsid),plangid,pguidProfile);
 465
 466     if (!rclsid || !plangid || !pguidProfile)
 467         return E_INVALIDARG;
 468
 469     if (get_active_textservice(rclsid, &profile))
 470     {
 471         *plangid = profile.langid;
 472         *pguidProfile = profile.guidProfile;
 473         return S_OK;
 474     }
 475     else
 476     {
 477         *pguidProfile = GUID_NULL;
 478         return S_FALSE;
 479     }
 480 }
 481
 482 static HRESULT WINAPI InputProcessorProfiles_GetLanguageProfileDescription(
 483         ITfInputProcessorProfiles *iface, REFCLSID rclsid, LANGID langid,
 484         REFGUID guidProfile, BSTR *pbstrProfile)
 485 {
 486     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 487     FIXME("STUB:(%p)\n",This);
 488     return E_NOTIMPL;
 489 }
 490
 491 static HRESULT WINAPI InputProcessorProfiles_GetCurrentLanguage(
 492         ITfInputProcessorProfiles *iface, LANGID *plangid)
 493 {
 494     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 495     TRACE("(%p) 0x%x\n",This,This->currentLanguage);
 496
 497     if (!plangid)
 498         return E_INVALIDARG;
 499
 500     *plangid = This->currentLanguage;
 501
 502     return S_OK;
 503 }
 504
 505 static HRESULT WINAPI InputProcessorProfiles_ChangeCurrentLanguage(
 506         ITfInputProcessorProfiles *iface, LANGID langid)
 507 {
 508     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 509     struct list *cursor;
 510     BOOL accept;
 511
 512     FIXME("STUB:(%p)\n",This);
 513
 514     LIST_FOR_EACH(cursor, &This->LanguageProfileNotifySink)
 515     {
 516         InputProcessorProfilesSink* sink = LIST_ENTRY(cursor,InputProcessorProfilesSink,entry);
 517         accept = TRUE;
 518         ITfLanguageProfileNotifySink_OnLanguageChange(sink->interfaces.pITfLanguageProfileNotifySink, langid, &accept);
 519         if (!accept)
 520             return  E_FAIL;
 521     }
 522
 523     /* TODO:  On successful language change call OnLanguageChanged sink */
 524     return E_NOTIMPL;
 525 }
 526
 527 static HRESULT WINAPI InputProcessorProfiles_GetLanguageList(
 528         ITfInputProcessorProfiles *iface, LANGID **ppLangId, ULONG *pulCount)
 529 {
 530     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 531     FIXME("Semi-STUB:(%p)\n",This);
 532     *ppLangId = CoTaskMemAlloc(sizeof(LANGID));
 533     **ppLangId = This->currentLanguage;
 534     *pulCount = 1;
 535     return S_OK;
 536 }
 537
 538 static HRESULT WINAPI InputProcessorProfiles_EnumLanguageProfiles(
 539         ITfInputProcessorProfiles *iface, LANGID langid,
 540         IEnumTfLanguageProfiles **ppEnum)
 541 {
 542     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 543     TRACE("(%p) %x %p\n",This,langid,ppEnum);
 544     return EnumTfLanguageProfiles_Constructor(langid, ppEnum);
 545 }
 546
 547 static HRESULT WINAPI InputProcessorProfiles_EnableLanguageProfile(
 548         ITfInputProcessorProfiles *iface, REFCLSID rclsid, LANGID langid,
 549         REFGUID guidProfile, BOOL fEnable)
 550 {
 551     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 552     HKEY key;
 553     WCHAR buf[39];
 554     WCHAR buf2[39];
 555     WCHAR fullkey[168];
 556     ULONG res;
 557
 558     TRACE("(%p) %s %x %s %i\n",This, debugstr_guid(rclsid), langid, debugstr_guid(guidProfile), fEnable);
 559
 560     StringFromGUID2(rclsid, buf, 39);
 561     StringFromGUID2(guidProfile, buf2, 39);
 562     sprintfW(fullkey,szwFullLangfmt,szwSystemTIPKey,buf,szwLngp,langid,buf2);
 563
 564     res = RegOpenKeyExW(HKEY_CURRENT_USER, fullkey, 0, KEY_READ | KEY_WRITE, &key);
 565
 566     if (!res)
 567     {
 568         RegSetValueExW(key, szwEnable, 0, REG_DWORD, (LPBYTE)&fEnable, sizeof(DWORD));
 569         RegCloseKey(key);
 570     }
 571     else
 572         return E_FAIL;
 573
 574     return S_OK;
 575 }
 576
 577 static HRESULT WINAPI InputProcessorProfiles_IsEnabledLanguageProfile(
 578         ITfInputProcessorProfiles *iface, REFCLSID rclsid, LANGID langid,
 579         REFGUID guidProfile, BOOL *pfEnable)
 580 {
 581     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 582     HKEY key;
 583     WCHAR buf[39];
 584     WCHAR buf2[39];
 585     WCHAR fullkey[168];
 586     ULONG res;
 587
 588     TRACE("(%p) %s, %i, %s, %p\n",This,debugstr_guid(rclsid),langid,debugstr_guid(guidProfile),pfEnable);
 589
 590     if (!pfEnable)
 591         return E_INVALIDARG;
 592
 593     StringFromGUID2(rclsid, buf, 39);
 594     StringFromGUID2(guidProfile, buf2, 39);
 595     sprintfW(fullkey,szwFullLangfmt,szwSystemTIPKey,buf,szwLngp,langid,buf2);
 596
 597     res = RegOpenKeyExW(HKEY_CURRENT_USER, fullkey, 0, KEY_READ | KEY_WRITE, &key);
 598
 599     if (!res)
 600     {
 601         DWORD count = sizeof(DWORD);
 602         res = RegQueryValueExW(key, szwEnable, 0, NULL, (LPBYTE)pfEnable, &count);
 603         RegCloseKey(key);
 604     }
 605
 606     if (res)  /* Try Default */
 607     {
 608         res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, fullkey, 0, KEY_READ | KEY_WRITE, &key);
 609
 610         if (!res)
 611         {
 612             DWORD count = sizeof(DWORD);
 613             res = RegQueryValueExW(key, szwEnable, 0, NULL, (LPBYTE)pfEnable, &count);
 614             RegCloseKey(key);
 615         }
 616     }
 617
 618     if (!res)
 619         return S_OK;
 620     else
 621         return E_FAIL;
 622 }
 623
 624 static HRESULT WINAPI InputProcessorProfiles_EnableLanguageProfileByDefault(
 625         ITfInputProcessorProfiles *iface, REFCLSID rclsid, LANGID langid,
 626         REFGUID guidProfile, BOOL fEnable)
 627 {
 628     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 629     HKEY key;
 630     WCHAR buf[39];
 631     WCHAR buf2[39];
 632     WCHAR fullkey[168];
 633     ULONG res;
 634
 635     TRACE("(%p) %s %x %s %i\n",This,debugstr_guid(rclsid),langid,debugstr_guid(guidProfile),fEnable);
 636
 637     StringFromGUID2(rclsid, buf, 39);
 638     StringFromGUID2(guidProfile, buf2, 39);
 639     sprintfW(fullkey,szwFullLangfmt,szwSystemTIPKey,buf,szwLngp,langid,buf2);
 640
 641     res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, fullkey, 0, KEY_READ | KEY_WRITE, &key);
 642
 643     if (!res)
 644     {
 645         RegSetValueExW(key, szwEnable, 0, REG_DWORD, (LPBYTE)&fEnable, sizeof(DWORD));
 646         RegCloseKey(key);
 647     }
 648     else
 649         return E_FAIL;
 650
 651     return S_OK;
 652 }
 653
 654 static HRESULT WINAPI InputProcessorProfiles_SubstituteKeyboardLayout(
 655         ITfInputProcessorProfiles *iface, REFCLSID rclsid, LANGID langid,
 656         REFGUID guidProfile, HKL hKL)
 657 {
 658     InputProcessorProfiles *This = impl_from_ITfInputProcessorProfiles(iface);
 659     FIXME("STUB:(%p)\n",This);
 660     return E_NOTIMPL;
 661 }
 662
 663 static const ITfInputProcessorProfilesVtbl InputProcessorProfilesVtbl =
 664 {
 665     InputProcessorProfiles_QueryInterface,
 666     InputProcessorProfiles_AddRef,
 667     InputProcessorProfiles_Release,
 668     InputProcessorProfiles_Register,
 669     InputProcessorProfiles_Unregister,
 670     InputProcessorProfiles_AddLanguageProfile,
 671     InputProcessorProfiles_RemoveLanguageProfile,
 672     InputProcessorProfiles_EnumInputProcessorInfo,
 673     InputProcessorProfiles_GetDefaultLanguageProfile,
 674     InputProcessorProfiles_SetDefaultLanguageProfile,
 675     InputProcessorProfiles_ActivateLanguageProfile,
 676     InputProcessorProfiles_GetActiveLanguageProfile,
 677     InputProcessorProfiles_GetLanguageProfileDescription,
 678     InputProcessorProfiles_GetCurrentLanguage,
 679     InputProcessorProfiles_ChangeCurrentLanguage,
 680     InputProcessorProfiles_GetLanguageList,
 681     InputProcessorProfiles_EnumLanguageProfiles,
 682     InputProcessorProfiles_EnableLanguageProfile,
 683     InputProcessorProfiles_IsEnabledLanguageProfile,
 684     InputProcessorProfiles_EnableLanguageProfileByDefault,
 685     InputProcessorProfiles_SubstituteKeyboardLayout
 686 };
 687
 688 /*****************************************************
 689  * ITfSource functions
 690  *****************************************************/
 691 static HRESULT WINAPI IPPSource_QueryInterface(ITfSource *iface, REFIID iid, LPVOID *ppvOut)
 692 {
 693     InputProcessorProfiles *This = impl_from_ITfSource(iface);
 694     return ITfInputProcessorProfiles_QueryInterface(&This->ITfInputProcessorProfiles_iface, iid, ppvOut);
 695 }
 696
 697 static ULONG WINAPI IPPSource_AddRef(ITfSource *iface)
 698 {
 699     InputProcessorProfiles *This = impl_from_ITfSource(iface);
 700     return ITfInputProcessorProfiles_AddRef(&This->ITfInputProcessorProfiles_iface);
 701 }
 702
 703 static ULONG WINAPI IPPSource_Release(ITfSource *iface)
 704 {
 705     InputProcessorProfiles *This = impl_from_ITfSource(iface);
 706     return ITfInputProcessorProfiles_Release(&This->ITfInputProcessorProfiles_iface);
 707 }
 708
 709 static HRESULT WINAPI IPPSource_AdviseSink(ITfSource *iface,
 710         REFIID riid, IUnknown *punk, DWORD *pdwCookie)
 711 {
 712     InputProcessorProfiles *This = impl_from_ITfSource(iface);
 713     InputProcessorProfilesSink *ipps;
 714
 715     TRACE("(%p) %s %p %p\n",This,debugstr_guid(riid),punk,pdwCookie);
 716
 717     if (!riid || !punk || !pdwCookie)
 718         return E_INVALIDARG;
 719
 720     if (IsEqualIID(riid, &IID_ITfLanguageProfileNotifySink))
 721     {
 722         ipps = HeapAlloc(GetProcessHeap(),0,sizeof(InputProcessorProfilesSink));
 723         if (!ipps)
 724             return E_OUTOFMEMORY;
 725         if (FAILED(IUnknown_QueryInterface(punk, riid, (LPVOID *)&ipps->interfaces.pITfLanguageProfileNotifySink)))
 726         {
 727             HeapFree(GetProcessHeap(),0,ipps);
 728             return CONNECT_E_CANNOTCONNECT;
 729         }
 730         list_add_head(&This->LanguageProfileNotifySink,&ipps->entry);
 731         *pdwCookie = generate_Cookie(COOKIE_MAGIC_IPPSINK, ipps);
 732     }
 733     else
 734     {
 735         FIXME("(%p) Unhandled Sink: %s\n",This,debugstr_guid(riid));
 736         return E_NOTIMPL;
 737     }
 738
 739     TRACE("cookie %x\n",*pdwCookie);
 740
 741     return S_OK;
 742 }
 743
 744 static HRESULT WINAPI IPPSource_UnadviseSink(ITfSource *iface, DWORD pdwCookie)
 745 {
 746     InputProcessorProfiles *This = impl_from_ITfSource(iface);
 747     InputProcessorProfilesSink *sink;
 748
 749     TRACE("(%p) %x\n",This,pdwCookie);
 750
 751     if (get_Cookie_magic(pdwCookie)!=COOKIE_MAGIC_IPPSINK)
 752         return E_INVALIDARG;
 753
 754     sink = remove_Cookie(pdwCookie);
 755     if (!sink)
 756         return CONNECT_E_NOCONNECTION;
 757
 758     list_remove(&sink->entry);
 759     free_sink(sink);
 760
 761     return S_OK;
 762 }
 763
 764 static const ITfSourceVtbl InputProcessorProfilesSourceVtbl =
 765 {
 766     IPPSource_QueryInterface,
 767     IPPSource_AddRef,
 768     IPPSource_Release,
 769     IPPSource_AdviseSink,
 770     IPPSource_UnadviseSink,
 771 };
 772
 773 HRESULT InputProcessorProfiles_Constructor(IUnknown *pUnkOuter, IUnknown **ppOut)
 774 {
 775     InputProcessorProfiles *This;
 776     if (pUnkOuter)
 777         return CLASS_E_NOAGGREGATION;
 778
 779     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(InputProcessorProfiles));
 780     if (This == NULL)
 781         return E_OUTOFMEMORY;
 782
 783     This->ITfInputProcessorProfiles_iface.lpVtbl= &InputProcessorProfilesVtbl;
 784     This->ITfSource_iface.lpVtbl = &InputProcessorProfilesSourceVtbl;
 785     This->refCount = 1;
 786     This->currentLanguage = GetUserDefaultLCID();
 787
 788     list_init(&This->LanguageProfileNotifySink);
 789
 790     *ppOut = (IUnknown *)&This->ITfInputProcessorProfiles_iface;
 791     TRACE("returning %p\n", *ppOut);
 792     return S_OK;
 793 }
 794
 795 /**************************************************
 796  * IEnumGUID implementation for ITfInputProcessorProfiles::EnumInputProcessorInfo
 797  **************************************************/
 798 static void ProfilesEnumGuid_Destructor(ProfilesEnumGuid *This)
 799 {
 800     TRACE("destroying %p\n", This);
 801     RegCloseKey(This->key);
 802     HeapFree(GetProcessHeap(),0,This);
 803 }
 804
 805 static HRESULT WINAPI ProfilesEnumGuid_QueryInterface(IEnumGUID *iface, REFIID iid, LPVOID *ppvOut)
 806 {
 807     ProfilesEnumGuid *This = impl_from_IEnumGUID(iface);
 808     *ppvOut = NULL;
 809
 810     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_IEnumGUID))
 811     {
 812         *ppvOut = &This->IEnumGUID_iface;
 813     }
 814
 815     if (*ppvOut)
 816     {
 817         IEnumGUID_AddRef(iface);
 818         return S_OK;
 819     }
 820
 821     WARN("unsupported interface: %s\n", debugstr_guid(iid));
 822     return E_NOINTERFACE;
 823 }
 824
 825 static ULONG WINAPI ProfilesEnumGuid_AddRef(IEnumGUID *iface)
 826 {
 827     ProfilesEnumGuid *This = impl_from_IEnumGUID(iface);
 828     return InterlockedIncrement(&This->refCount);
 829 }
 830
 831 static ULONG WINAPI ProfilesEnumGuid_Release(IEnumGUID *iface)
 832 {
 833     ProfilesEnumGuid *This = impl_from_IEnumGUID(iface);
 834     ULONG ret;
 835
 836     ret = InterlockedDecrement(&This->refCount);
 837     if (ret == 0)
 838         ProfilesEnumGuid_Destructor(This);
 839     return ret;
 840 }
 841
 842 /*****************************************************
 843  * IEnumGuid functions
 844  *****************************************************/
 845 static HRESULT WINAPI ProfilesEnumGuid_Next( LPENUMGUID iface,
 846     ULONG celt, GUID *rgelt, ULONG *pceltFetched)
 847 {
 848     ProfilesEnumGuid *This = impl_from_IEnumGUID(iface);
 849     ULONG fetched = 0;
 850
 851     TRACE("(%p)\n",This);
 852
 853     if (rgelt == NULL) return E_POINTER;
 854
 855     if (This->key) while (fetched < celt)
 856     {
 857         LSTATUS res;
 858         HRESULT hr;
 859         WCHAR catid[39];
 860         DWORD cName = 39;
 861
 862         res = RegEnumKeyExW(This->key, This->next_index, catid, &cName,
 863                     NULL, NULL, NULL, NULL);
 864         if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break;
 865         ++(This->next_index);
 866
 867         hr = CLSIDFromString(catid, rgelt);
 868         if (FAILED(hr)) continue;
 869
 870         ++fetched;
 871         ++rgelt;
 872     }
 873
 874     if (pceltFetched) *pceltFetched = fetched;
 875     return fetched == celt ? S_OK : S_FALSE;
 876 }
 877
 878 static HRESULT WINAPI ProfilesEnumGuid_Skip( LPENUMGUID iface, ULONG celt)
 879 {
 880     ProfilesEnumGuid *This = impl_from_IEnumGUID(iface);
 881     TRACE("(%p)\n",This);
 882
 883     This->next_index += celt;
 884     return S_OK;
 885 }
 886
 887 static HRESULT WINAPI ProfilesEnumGuid_Reset( LPENUMGUID iface)
 888 {
 889     ProfilesEnumGuid *This = impl_from_IEnumGUID(iface);
 890     TRACE("(%p)\n",This);
 891     This->next_index = 0;
 892     return S_OK;
 893 }
 894
 895 static HRESULT WINAPI ProfilesEnumGuid_Clone( LPENUMGUID iface,
 896     IEnumGUID **ppenum)
 897 {
 898     ProfilesEnumGuid *This = impl_from_IEnumGUID(iface);
 899     HRESULT res;
 900
 901     TRACE("(%p)\n",This);
 902
 903     if (ppenum == NULL) return E_POINTER;
 904
 905     res = ProfilesEnumGuid_Constructor(ppenum);
 906     if (SUCCEEDED(res))
 907     {
 908         ProfilesEnumGuid *new_This = impl_from_IEnumGUID(*ppenum);
 909         new_This->next_index = This->next_index;
 910     }
 911     return res;
 912 }
 913
 914 static const IEnumGUIDVtbl EnumGUIDVtbl =
 915 {
 916     ProfilesEnumGuid_QueryInterface,
 917     ProfilesEnumGuid_AddRef,
 918     ProfilesEnumGuid_Release,
 919     ProfilesEnumGuid_Next,
 920     ProfilesEnumGuid_Skip,
 921     ProfilesEnumGuid_Reset,
 922     ProfilesEnumGuid_Clone
 923 };
 924
 925 static HRESULT ProfilesEnumGuid_Constructor(IEnumGUID **ppOut)
 926 {
 927     ProfilesEnumGuid *This;
 928
 929     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ProfilesEnumGuid));
 930     if (This == NULL)
 931         return E_OUTOFMEMORY;
 932
 933     This->IEnumGUID_iface.lpVtbl= &EnumGUIDVtbl;
 934     This->refCount = 1;
 935
 936     if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, szwSystemTIPKey, 0, NULL, 0,
 937                     KEY_READ | KEY_WRITE, NULL, &This->key, NULL) != ERROR_SUCCESS)
 938     {
 939         HeapFree(GetProcessHeap(), 0, This);
 940         return E_FAIL;
 941     }
 942
 943     *ppOut = &This->IEnumGUID_iface;
 944     TRACE("returning %p\n", *ppOut);
 945     return S_OK;
 946 }
 947
 948 /**************************************************
 949  * IEnumTfLanguageProfiles implementation
 950  **************************************************/
 951 static void EnumTfLanguageProfiles_Destructor(EnumTfLanguageProfiles *This)
 952 {
 953     TRACE("destroying %p\n", This);
 954     RegCloseKey(This->tipkey);
 955     if (This->langkey)
 956         RegCloseKey(This->langkey);
 957     ITfCategoryMgr_Release(This->catmgr);
 958     HeapFree(GetProcessHeap(),0,This);
 959 }
 960
 961 static HRESULT WINAPI EnumTfLanguageProfiles_QueryInterface(IEnumTfLanguageProfiles *iface, REFIID iid, LPVOID *ppvOut)
 962 {
 963     EnumTfLanguageProfiles *This = impl_from_IEnumTfLanguageProfiles(iface);
 964
 965     *ppvOut = NULL;
 966
 967     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_IEnumTfLanguageProfiles))
 968     {
 969         *ppvOut = &This->IEnumTfLanguageProfiles_iface;
 970     }
 971
 972     if (*ppvOut)
 973     {
 974         IEnumTfLanguageProfiles_AddRef(iface);
 975         return S_OK;
 976     }
 977
 978     WARN("unsupported interface: %s\n", debugstr_guid(iid));
 979     return E_NOINTERFACE;
 980 }
 981
 982 static ULONG WINAPI EnumTfLanguageProfiles_AddRef(IEnumTfLanguageProfiles *iface)
 983 {
 984     EnumTfLanguageProfiles *This = impl_from_IEnumTfLanguageProfiles(iface);
 985     return InterlockedIncrement(&This->refCount);
 986 }
 987
 988 static ULONG WINAPI EnumTfLanguageProfiles_Release(IEnumTfLanguageProfiles *iface)
 989 {
 990     EnumTfLanguageProfiles *This = impl_from_IEnumTfLanguageProfiles(iface);
 991     ULONG ret;
 992
 993     ret = InterlockedDecrement(&This->refCount);
 994     if (ret == 0)
 995         EnumTfLanguageProfiles_Destructor(This);
 996     return ret;
 997 }
 998
 999 /*****************************************************
1000  * IEnumGuid functions
1001  *****************************************************/
1002 static INT next_LanguageProfile(EnumTfLanguageProfiles *This, CLSID clsid, TF_LANGUAGEPROFILE *tflp)
1003 {
1004     WCHAR fullkey[168];
1005     ULONG res;
1006     WCHAR profileid[39];
1007     DWORD cName = 39;
1008     GUID  profile;
1009
1010     static const WCHAR fmt[] = {'%','s','\\','%','s','\\','0','x','%','0','8','x',0};
1011
1012     if (This->langkey == NULL)
1013     {
1014         sprintfW(fullkey,fmt,This->szwCurrentClsid,szwLngp,This->langid);
1015         res = RegOpenKeyExW(This->tipkey, fullkey, 0, KEY_READ | KEY_WRITE, &This->langkey);
1016         if (res)
1017         {
1018             This->langkey = NULL;
1019             return -1;
1020         }
1021         This->lang_index = 0;
1022     }
1023     res = RegEnumKeyExW(This->langkey, This->lang_index, profileid, &cName,
1024                 NULL, NULL, NULL, NULL);
1025     if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
1026     {
1027         RegCloseKey(This->langkey);
1028         This->langkey = NULL;
1029         return -1;
1030     }
1031     ++(This->lang_index);
1032
1033     if (tflp)
1034     {
1035         static const GUID * tipcats[3] = { &GUID_TFCAT_TIP_KEYBOARD,
1036                                            &GUID_TFCAT_TIP_SPEECH,
1037                                            &GUID_TFCAT_TIP_HANDWRITING };
1038         res = CLSIDFromString(profileid, &profile);
1039         if (FAILED(res)) return 0;
1040
1041         tflp->clsid = clsid;
1042         tflp->langid = This->langid;
1043         tflp->fActive = get_active_textservice(&clsid, NULL);
1044         tflp->guidProfile = profile;
1045         if (ITfCategoryMgr_FindClosestCategory(This->catmgr, &clsid,
1046                 &tflp->catid, tipcats, 3) != S_OK)
1047             ITfCategoryMgr_FindClosestCategory(This->catmgr, &clsid,
1048                     &tflp->catid, NULL, 0);
1049     }
1050
1051     return 1;
1052 }
1053
1054 static HRESULT WINAPI EnumTfLanguageProfiles_Next(IEnumTfLanguageProfiles *iface,
1055     ULONG ulCount, TF_LANGUAGEPROFILE *pProfile, ULONG *pcFetch)
1056 {
1057     EnumTfLanguageProfiles *This = impl_from_IEnumTfLanguageProfiles(iface);
1058     ULONG fetched = 0;
1059
1060     TRACE("(%p)\n",This);
1061
1062     if (pProfile == NULL) return E_POINTER;
1063
1064     if (This->tipkey) while (fetched < ulCount)
1065     {
1066         LSTATUS res;
1067         HRESULT hr;
1068         DWORD cName = 39;
1069         GUID clsid;
1070
1071         res = RegEnumKeyExW(This->tipkey, This->tip_index,
1072                     This->szwCurrentClsid, &cName, NULL, NULL, NULL, NULL);
1073         if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break;
1074         ++(This->tip_index);
1075         hr = CLSIDFromString(This->szwCurrentClsid, &clsid);
1076         if (FAILED(hr)) continue;
1077
1078         while ( fetched < ulCount)
1079         {
1080             INT res = next_LanguageProfile(This, clsid, pProfile);
1081             if (res == 1)
1082             {
1083                 ++fetched;
1084                 ++pProfile;
1085             }
1086             else if (res == -1)
1087                 break;
1088             else
1089                 continue;
1090         }
1091     }
1092
1093     if (pcFetch) *pcFetch = fetched;
1094     return fetched == ulCount ? S_OK : S_FALSE;
1095 }
1096
1097 static HRESULT WINAPI EnumTfLanguageProfiles_Skip( IEnumTfLanguageProfiles* iface, ULONG celt)
1098 {
1099     EnumTfLanguageProfiles *This = impl_from_IEnumTfLanguageProfiles(iface);
1100     FIXME("STUB (%p)\n",This);
1101     return E_NOTIMPL;
1102 }
1103
1104 static HRESULT WINAPI EnumTfLanguageProfiles_Reset( IEnumTfLanguageProfiles* iface)
1105 {
1106     EnumTfLanguageProfiles *This = impl_from_IEnumTfLanguageProfiles(iface);
1107     TRACE("(%p)\n",This);
1108     This->tip_index = 0;
1109     if (This->langkey)
1110         RegCloseKey(This->langkey);
1111     This->langkey = NULL;
1112     This->lang_index = 0;
1113     return S_OK;
1114 }
1115
1116 static HRESULT WINAPI EnumTfLanguageProfiles_Clone( IEnumTfLanguageProfiles *iface,
1117     IEnumTfLanguageProfiles **ppenum)
1118 {
1119     EnumTfLanguageProfiles *This = impl_from_IEnumTfLanguageProfiles(iface);
1120     HRESULT res;
1121
1122     TRACE("(%p)\n",This);
1123
1124     if (ppenum == NULL) return E_POINTER;
1125
1126     res = EnumTfLanguageProfiles_Constructor(This->langid, ppenum);
1127     if (SUCCEEDED(res))
1128     {
1129         EnumTfLanguageProfiles *new_This = (EnumTfLanguageProfiles *)*ppenum;
1130         new_This->tip_index = This->tip_index;
1131         lstrcpynW(new_This->szwCurrentClsid,This->szwCurrentClsid,39);
1132
1133         if (This->langkey)
1134         {
1135             WCHAR fullkey[168];
1136             static const WCHAR fmt[] = {'%','s','\\','%','s','\\','0','x','%','0','8','x',0};
1137
1138             sprintfW(fullkey,fmt,This->szwCurrentClsid,szwLngp,This->langid);
1139             res = RegOpenKeyExW(new_This->tipkey, fullkey, 0, KEY_READ | KEY_WRITE, &This->langkey);
1140             new_This->lang_index = This->lang_index;
1141         }
1142     }
1143     return res;
1144 }
1145
1146 static const IEnumTfLanguageProfilesVtbl EnumTfLanguageProfilesVtbl =
1147 {
1148     EnumTfLanguageProfiles_QueryInterface,
1149     EnumTfLanguageProfiles_AddRef,
1150     EnumTfLanguageProfiles_Release,
1151     EnumTfLanguageProfiles_Clone,
1152     EnumTfLanguageProfiles_Next,
1153     EnumTfLanguageProfiles_Reset,
1154     EnumTfLanguageProfiles_Skip
1155 };
1156
1157 static HRESULT EnumTfLanguageProfiles_Constructor(LANGID langid, IEnumTfLanguageProfiles **ppOut)
1158 {
1159     HRESULT hr;
1160     EnumTfLanguageProfiles *This;
1161
1162     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(EnumTfLanguageProfiles));
1163     if (This == NULL)
1164         return E_OUTOFMEMORY;
1165
1166     This->IEnumTfLanguageProfiles_iface.lpVtbl= &EnumTfLanguageProfilesVtbl;
1167     This->refCount = 1;
1168     This->langid = langid;
1169
1170     hr = CategoryMgr_Constructor(NULL,(IUnknown**)&This->catmgr);
1171     if (FAILED(hr))
1172     {
1173         HeapFree(GetProcessHeap(),0,This);
1174         return hr;
1175     }
1176
1177     if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, szwSystemTIPKey, 0, NULL, 0,
1178                     KEY_READ | KEY_WRITE, NULL, &This->tipkey, NULL) != ERROR_SUCCESS)
1179     {
1180         HeapFree(GetProcessHeap(), 0, This);
1181         return E_FAIL;
1182     }
1183
1184     *ppOut = &This->IEnumTfLanguageProfiles_iface;
1185     TRACE("returning %p\n", *ppOut);
1186     return S_OK;
1187 }