dlls/windows.globalization/main.c

   1 /* WinRT Windows.Globalization implementation
   2  *
   3  * Copyright 2021 Rémi Bernon for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winstring.h"
  26 #include "wine/debug.h"
  27 #include "objbase.h"
  28
  29 #include "initguid.h"
  30 #include "activation.h"
  31
  32 #define WIDL_using_Windows_Foundation
  33 #define WIDL_using_Windows_Foundation_Collections
  34 #include "windows.foundation.h"
  35 #define WIDL_using_Windows_Globalization
  36 #include "windows.globalization.h"
  37 #define WIDL_using_Windows_System_UserProfile
  38 #include "windows.system.userprofile.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(locale);
  41
  42 struct hstring_vector
  43 {
  44     IVectorView_HSTRING IVectorView_HSTRING_iface;
  45     LONG ref;
  46
  47     ULONG count;
  48     HSTRING values[];
  49 };
  50
  51 C_ASSERT(sizeof(struct hstring_vector) == offsetof(struct hstring_vector, values[0]));
  52
  53 static inline struct hstring_vector *impl_from_IVectorView_HSTRING(IVectorView_HSTRING *iface)
  54 {
  55     return CONTAINING_RECORD(iface, struct hstring_vector, IVectorView_HSTRING_iface);
  56 }
  57
  58 static HRESULT STDMETHODCALLTYPE hstring_vector_QueryInterface(IVectorView_HSTRING *iface,
  59         REFIID iid, void **out)
  60 {
  61     struct hstring_vector *impl = impl_from_IVectorView_HSTRING(iface);
  62     TRACE("iface %p, iid %s, out %p stub!\n", iface, debugstr_guid(iid), out);
  63
  64     if (IsEqualGUID(iid, &IID_IUnknown) ||
  65         IsEqualGUID(iid, &IID_IInspectable) ||
  66         IsEqualGUID(iid, &IID_IAgileObject) ||
  67         IsEqualGUID(iid, &IID_IVectorView_HSTRING))
  68     {
  69         IUnknown_AddRef(iface);
  70         *out = &impl->IVectorView_HSTRING_iface;
  71         return S_OK;
  72     }
  73
  74     FIXME("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  75     *out = NULL;
  76     return E_NOINTERFACE;
  77 }
  78
  79 static ULONG STDMETHODCALLTYPE hstring_vector_AddRef(IVectorView_HSTRING *iface)
  80 {
  81     struct hstring_vector *impl = impl_from_IVectorView_HSTRING(iface);
  82     ULONG ref = InterlockedIncrement(&impl->ref);
  83     TRACE("iface %p, ref %lu.\n", iface, ref);
  84     return ref;
  85 }
  86
  87 static ULONG STDMETHODCALLTYPE hstring_vector_Release(IVectorView_HSTRING *iface)
  88 {
  89     struct hstring_vector *impl = impl_from_IVectorView_HSTRING(iface);
  90     ULONG ref = InterlockedDecrement(&impl->ref);
  91     TRACE("iface %p, ref %lu.\n", iface, ref);
  92     if (ref == 0)
  93     {
  94         while (impl->count--) WindowsDeleteString(impl->values[impl->count]);
  95         free(impl);
  96     }
  97     return ref;
  98 }
  99
 100 static HRESULT STDMETHODCALLTYPE hstring_vector_GetIids(IVectorView_HSTRING *iface,
 101         ULONG *iid_count, IID **iids)
 102 {
 103     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
 104     return E_NOTIMPL;
 105 }
 106
 107 static HRESULT STDMETHODCALLTYPE hstring_vector_GetRuntimeClassName(IVectorView_HSTRING *iface,
 108         HSTRING *class_name)
 109 {
 110     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 111     return E_NOTIMPL;
 112 }
 113
 114 static HRESULT STDMETHODCALLTYPE hstring_vector_GetTrustLevel(IVectorView_HSTRING *iface,
 115         TrustLevel *trust_level)
 116 {
 117     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 118     return E_NOTIMPL;
 119 }
 120
 121 static HRESULT STDMETHODCALLTYPE hstring_vector_GetAt(IVectorView_HSTRING *iface,
 122         UINT32 index, HSTRING *value)
 123 {
 124     struct hstring_vector *impl = impl_from_IVectorView_HSTRING(iface);
 125
 126     TRACE("iface %p, index %#x, value %p.\n", iface, index, value);
 127
 128     *value = NULL;
 129     if (index >= impl->count) return E_BOUNDS;
 130     return WindowsDuplicateString(impl->values[index], value);
 131 }
 132
 133 static HRESULT STDMETHODCALLTYPE hstring_vector_get_Size(IVectorView_HSTRING *iface,
 134         UINT32 *value)
 135 {
 136     struct hstring_vector *impl = impl_from_IVectorView_HSTRING(iface);
 137
 138     TRACE("iface %p, value %p.\n", iface, value);
 139
 140     *value = impl->count;
 141     return S_OK;
 142 }
 143
 144 static HRESULT STDMETHODCALLTYPE hstring_vector_IndexOf(IVectorView_HSTRING *iface,
 145         HSTRING element, UINT32 *index, BOOLEAN *found)
 146 {
 147     struct hstring_vector *impl = impl_from_IVectorView_HSTRING(iface);
 148     INT32 i, order;
 149
 150     TRACE("iface %p, element %p, index %p, found %p.\n", iface, element, index, found);
 151
 152     for (i = 0; i < impl->count; ++i)
 153         if (SUCCEEDED(WindowsCompareStringOrdinal(impl->values[i], element, &order)) && order == 0)
 154             break;
 155
 156     if (i < impl->count)
 157     {
 158         *found = TRUE;
 159         *index = i;
 160     }
 161     else
 162     {
 163         *found = FALSE;
 164         *index = 0;
 165     }
 166
 167     return S_OK;
 168 }
 169
 170 static HRESULT STDMETHODCALLTYPE hstring_vector_GetMany(IVectorView_HSTRING *iface,
 171         UINT32 start_index, UINT32 items_size, HSTRING *items, UINT *count)
 172 {
 173     struct hstring_vector *impl = impl_from_IVectorView_HSTRING(iface);
 174     HRESULT hr = S_OK;
 175     ULONG i;
 176
 177     TRACE("iface %p, start_index %#x, items %p, count %p.\n", iface, start_index, items, count);
 178
 179     memset(items, 0, items_size * sizeof(*items));
 180
 181     for (i = start_index; i < impl->count && i < start_index + items_size; ++i)
 182         if (FAILED(hr = WindowsDuplicateString(impl->values[i], items + i - start_index)))
 183             break;
 184
 185     if (FAILED(hr)) while (i-- > start_index) WindowsDeleteString(items[i - start_index]);
 186     *count = i - start_index;
 187     return hr;
 188 }
 189
 190 static const struct IVectorView_HSTRINGVtbl hstring_vector_vtbl =
 191 {
 192     hstring_vector_QueryInterface,
 193     hstring_vector_AddRef,
 194     hstring_vector_Release,
 195     /* IInspectable methods */
 196     hstring_vector_GetIids,
 197     hstring_vector_GetRuntimeClassName,
 198     hstring_vector_GetTrustLevel,
 199     /* IVectorView<HSTRING> methods */
 200     hstring_vector_GetAt,
 201     hstring_vector_get_Size,
 202     hstring_vector_IndexOf,
 203     hstring_vector_GetMany,
 204 };
 205
 206 static HRESULT hstring_vector_create(HSTRING *values, SIZE_T count, IVectorView_HSTRING **out)
 207 {
 208     struct hstring_vector *impl;
 209
 210     if (!(impl = malloc(offsetof(struct hstring_vector, values[count])))) return E_OUTOFMEMORY;
 211     impl->ref = 1;
 212
 213     impl->IVectorView_HSTRING_iface.lpVtbl = &hstring_vector_vtbl;
 214     impl->count = count;
 215     memcpy(impl->values, values, count * sizeof(HSTRING));
 216
 217     *out = &impl->IVectorView_HSTRING_iface;
 218     return S_OK;
 219 }
 220
 221 struct windows_globalization
 222 {
 223     IActivationFactory IActivationFactory_iface;
 224     IGlobalizationPreferencesStatics IGlobalizationPreferencesStatics_iface;
 225     LONG ref;
 226 };
 227
 228 struct language_factory
 229 {
 230     IActivationFactory IActivationFactory_iface;
 231     ILanguageFactory ILanguageFactory_iface;
 232     LONG ref;
 233 };
 234
 235 struct language
 236 {
 237     ILanguage ILanguage_iface;
 238     LONG ref;
 239     WCHAR name[LOCALE_NAME_MAX_LENGTH];
 240 };
 241
 242 static inline struct windows_globalization *impl_from_IActivationFactory(IActivationFactory *iface)
 243 {
 244     return CONTAINING_RECORD(iface, struct windows_globalization, IActivationFactory_iface);
 245 }
 246
 247 static inline struct language_factory *impl_language_factory_from_IActivationFactory(IActivationFactory *iface)
 248 {
 249     return CONTAINING_RECORD(iface, struct language_factory, IActivationFactory_iface);
 250 }
 251
 252 static inline struct windows_globalization *impl_from_IGlobalizationPreferencesStatics(IGlobalizationPreferencesStatics *iface)
 253 {
 254     return CONTAINING_RECORD(iface, struct windows_globalization, IGlobalizationPreferencesStatics_iface);
 255 }
 256
 257 static inline struct language_factory *impl_from_ILanguageFactory(ILanguageFactory *iface)
 258 {
 259     return CONTAINING_RECORD(iface, struct language_factory, ILanguageFactory_iface);
 260 }
 261
 262 static inline struct language *impl_from_ILanguage(ILanguage *iface)
 263 {
 264     return CONTAINING_RECORD(iface, struct language, ILanguage_iface);
 265 }
 266
 267 static HRESULT STDMETHODCALLTYPE language_QueryInterface(
 268         ILanguage *iface, REFIID iid, void **out)
 269 {
 270     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 271
 272     if (IsEqualGUID(iid, &IID_IUnknown) ||
 273         IsEqualGUID(iid, &IID_IInspectable) ||
 274         IsEqualGUID(iid, &IID_IAgileObject) ||
 275         IsEqualGUID(iid, &IID_ILanguage))
 276     {
 277         IUnknown_AddRef(iface);
 278         *out = iface;
 279         return S_OK;
 280     }
 281
 282     FIXME("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 283     *out = NULL;
 284     return E_NOINTERFACE;
 285 }
 286
 287 static ULONG STDMETHODCALLTYPE language_AddRef(
 288         ILanguage *iface)
 289 {
 290     struct language *language = impl_from_ILanguage(iface);
 291     ULONG ref = InterlockedIncrement(&language->ref);
 292     TRACE("iface %p, ref %lu.\n", iface, ref);
 293     return ref;
 294 }
 295
 296 static ULONG STDMETHODCALLTYPE language_Release(
 297         ILanguage *iface)
 298 {
 299     struct language *language = impl_from_ILanguage(iface);
 300     ULONG ref = InterlockedDecrement(&language->ref);
 301
 302     TRACE("iface %p, ref %lu.\n", iface, ref);
 303
 304     if (!ref)
 305         free(language);
 306
 307     return ref;
 308 }
 309
 310 static HRESULT STDMETHODCALLTYPE language_GetIids(
 311         ILanguage *iface, ULONG *iid_count, IID **iids)
 312 {
 313     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT STDMETHODCALLTYPE language_GetRuntimeClassName(
 318         ILanguage *iface, HSTRING *class_name)
 319 {
 320     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 321     return E_NOTIMPL;
 322 }
 323
 324 static HRESULT STDMETHODCALLTYPE language_GetTrustLevel(
 325         ILanguage *iface, TrustLevel *trust_level)
 326 {
 327     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 328     return E_NOTIMPL;
 329 }
 330
 331 static HRESULT STDMETHODCALLTYPE language_get_LanguageTag(
 332         ILanguage *iface, HSTRING *value)
 333 {
 334     struct language *language = impl_from_ILanguage(iface);
 335
 336     TRACE("iface %p, value %p.\n", iface, value);
 337
 338     return WindowsCreateString(language->name, wcslen(language->name), value);
 339 }
 340
 341 static HRESULT STDMETHODCALLTYPE language_get_DisplayName(
 342         ILanguage *iface, HSTRING *value)
 343 {
 344     FIXME("iface %p, value %p stub!\n", iface, value);
 345     return E_NOTIMPL;
 346 }
 347
 348 static HRESULT STDMETHODCALLTYPE language_get_NativeName(
 349         ILanguage *iface, HSTRING *value)
 350 {
 351     FIXME("iface %p, value %p stub!\n", iface, value);
 352     return E_NOTIMPL;
 353 }
 354
 355 static HRESULT STDMETHODCALLTYPE language_get_Script(
 356         ILanguage *iface, HSTRING *value)
 357 {
 358     FIXME("iface %p, value %p stub!\n", iface, value);
 359     return E_NOTIMPL;
 360 }
 361
 362 static const struct ILanguageVtbl language_vtbl =
 363 {
 364     language_QueryInterface,
 365     language_AddRef,
 366     language_Release,
 367     /* IInspectable methods */
 368     language_GetIids,
 369     language_GetRuntimeClassName,
 370     language_GetTrustLevel,
 371     /* ILanguage methods */
 372     language_get_LanguageTag,
 373     language_get_DisplayName,
 374     language_get_NativeName,
 375     language_get_Script,
 376 };
 377
 378 static HRESULT STDMETHODCALLTYPE windows_globalization_QueryInterface(
 379         IActivationFactory *iface, REFIID iid, void **out)
 380 {
 381     struct windows_globalization *impl = impl_from_IActivationFactory(iface);
 382     TRACE("iface %p, iid %s, out %p stub!\n", iface, debugstr_guid(iid), out);
 383
 384     if (IsEqualGUID(iid, &IID_IUnknown) ||
 385         IsEqualGUID(iid, &IID_IInspectable) ||
 386         IsEqualGUID(iid, &IID_IAgileObject) ||
 387         IsEqualGUID(iid, &IID_IActivationFactory))
 388     {
 389         IUnknown_AddRef(iface);
 390         *out = &impl->IActivationFactory_iface;
 391         return S_OK;
 392     }
 393
 394     if (IsEqualGUID(iid, &IID_IGlobalizationPreferencesStatics))
 395     {
 396         IUnknown_AddRef(iface);
 397         *out = &impl->IGlobalizationPreferencesStatics_iface;
 398         return S_OK;
 399     }
 400
 401     FIXME("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 402     *out = NULL;
 403     return E_NOINTERFACE;
 404 }
 405
 406 static ULONG STDMETHODCALLTYPE windows_globalization_AddRef(
 407         IActivationFactory *iface)
 408 {
 409     struct windows_globalization *impl = impl_from_IActivationFactory(iface);
 410     ULONG ref = InterlockedIncrement(&impl->ref);
 411     TRACE("iface %p, ref %lu.\n", iface, ref);
 412     return ref;
 413 }
 414
 415 static ULONG STDMETHODCALLTYPE windows_globalization_Release(
 416         IActivationFactory *iface)
 417 {
 418     struct windows_globalization *impl = impl_from_IActivationFactory(iface);
 419     ULONG ref = InterlockedDecrement(&impl->ref);
 420     TRACE("iface %p, ref %lu.\n", iface, ref);
 421     return ref;
 422 }
 423
 424 static HRESULT STDMETHODCALLTYPE windows_globalization_GetIids(
 425         IActivationFactory *iface, ULONG *iid_count, IID **iids)
 426 {
 427     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
 428     return E_NOTIMPL;
 429 }
 430
 431 static HRESULT STDMETHODCALLTYPE windows_globalization_GetRuntimeClassName(
 432         IActivationFactory *iface, HSTRING *class_name)
 433 {
 434     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 435     return E_NOTIMPL;
 436 }
 437
 438 static HRESULT STDMETHODCALLTYPE windows_globalization_GetTrustLevel(
 439         IActivationFactory *iface, TrustLevel *trust_level)
 440 {
 441     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 442     return E_NOTIMPL;
 443 }
 444
 445 static HRESULT STDMETHODCALLTYPE windows_globalization_ActivateInstance(
 446         IActivationFactory *iface, IInspectable **instance)
 447 {
 448     FIXME("iface %p, instance %p stub!\n", iface, instance);
 449     return E_NOTIMPL;
 450 }
 451
 452 static const struct IActivationFactoryVtbl activation_factory_vtbl =
 453 {
 454     windows_globalization_QueryInterface,
 455     windows_globalization_AddRef,
 456     windows_globalization_Release,
 457     /* IInspectable methods */
 458     windows_globalization_GetIids,
 459     windows_globalization_GetRuntimeClassName,
 460     windows_globalization_GetTrustLevel,
 461     /* IActivationFactory methods */
 462     windows_globalization_ActivateInstance,
 463 };
 464
 465 static HRESULT STDMETHODCALLTYPE globalization_preferences_QueryInterface(
 466         IGlobalizationPreferencesStatics *iface, REFIID iid, void **object)
 467 {
 468     struct windows_globalization *impl = impl_from_IGlobalizationPreferencesStatics(iface);
 469     return windows_globalization_QueryInterface(&impl->IActivationFactory_iface, iid, object);
 470 }
 471
 472 static ULONG STDMETHODCALLTYPE globalization_preferences_AddRef(
 473         IGlobalizationPreferencesStatics *iface)
 474 {
 475     struct windows_globalization *impl = impl_from_IGlobalizationPreferencesStatics(iface);
 476     return windows_globalization_AddRef(&impl->IActivationFactory_iface);
 477 }
 478
 479 static ULONG STDMETHODCALLTYPE globalization_preferences_Release(
 480         IGlobalizationPreferencesStatics *iface)
 481 {
 482     struct windows_globalization *impl = impl_from_IGlobalizationPreferencesStatics(iface);
 483     return windows_globalization_Release(&impl->IActivationFactory_iface);
 484 }
 485
 486 static HRESULT STDMETHODCALLTYPE globalization_preferences_GetIids(
 487         IGlobalizationPreferencesStatics *iface, ULONG *iid_count, IID **iids)
 488 {
 489     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
 490     return E_NOTIMPL;
 491 }
 492
 493 static HRESULT STDMETHODCALLTYPE globalization_preferences_GetRuntimeClassName(
 494         IGlobalizationPreferencesStatics *iface, HSTRING *class_name)
 495 {
 496     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 497     return E_NOTIMPL;
 498 }
 499
 500 static HRESULT STDMETHODCALLTYPE globalization_preferences_GetTrustLevel(
 501         IGlobalizationPreferencesStatics *iface, TrustLevel *trust_level)
 502 {
 503     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 504     return E_NOTIMPL;
 505 }
 506
 507 static HRESULT STDMETHODCALLTYPE globalization_preferences_get_Calendars(
 508         IGlobalizationPreferencesStatics *iface, IVectorView_HSTRING **out)
 509 {
 510     FIXME("iface %p, out %p stub!\n", iface, out);
 511     return hstring_vector_create(NULL, 0, out);
 512 }
 513
 514 static HRESULT STDMETHODCALLTYPE globalization_preferences_get_Clocks(
 515         IGlobalizationPreferencesStatics *iface, IVectorView_HSTRING **out)
 516 {
 517     FIXME("iface %p, out %p stub!\n", iface, out);
 518     return hstring_vector_create(NULL, 0, out);
 519 }
 520
 521 static HRESULT STDMETHODCALLTYPE globalization_preferences_get_Currencies(
 522         IGlobalizationPreferencesStatics *iface, IVectorView_HSTRING **out)
 523 {
 524     FIXME("iface %p, out %p stub!\n", iface, out);
 525     return hstring_vector_create(NULL, 0, out);
 526 }
 527
 528 static HRESULT STDMETHODCALLTYPE globalization_preferences_get_Languages(
 529         IGlobalizationPreferencesStatics *iface, IVectorView_HSTRING **out)
 530 {
 531     HSTRING hstring;
 532     HRESULT hr;
 533     WCHAR locale[LOCALE_NAME_MAX_LENGTH];
 534
 535     TRACE("iface %p, out %p.\n", iface, out);
 536
 537     if (!GetUserDefaultLocaleName(locale, LOCALE_NAME_MAX_LENGTH))
 538         return E_FAIL;
 539
 540     TRACE("returning language %s\n", debugstr_w(locale));
 541
 542     if (FAILED(hr = WindowsCreateString(locale, wcslen(locale), &hstring)))
 543         return hr;
 544
 545     return hstring_vector_create(&hstring, 1, out);
 546 }
 547
 548 static HRESULT STDMETHODCALLTYPE globalization_preferences_get_HomeGeographicRegion(
 549         IGlobalizationPreferencesStatics *iface, HSTRING* out)
 550 {
 551     WCHAR country[16];
 552
 553     TRACE("iface %p, out %p.\n", iface, out);
 554
 555     if (!GetUserDefaultGeoName(country, 16))
 556         return E_FAIL;
 557
 558     TRACE("returning country %s\n", debugstr_w(country));
 559
 560     return WindowsCreateString(country, wcslen(country), out);
 561 }
 562
 563 static HRESULT STDMETHODCALLTYPE globalization_preferences_get_WeekStartsOn(
 564         IGlobalizationPreferencesStatics *iface, enum DayOfWeek* out)
 565 {
 566     FIXME("iface %p, out %p stub!\n", iface, out);
 567     return E_NOTIMPL;
 568 }
 569
 570 static const struct IGlobalizationPreferencesStaticsVtbl globalization_preferences_vtbl =
 571 {
 572     globalization_preferences_QueryInterface,
 573     globalization_preferences_AddRef,
 574     globalization_preferences_Release,
 575     /* IInspectable methods */
 576     globalization_preferences_GetIids,
 577     globalization_preferences_GetRuntimeClassName,
 578     globalization_preferences_GetTrustLevel,
 579     /* IGlobalizationPreferencesStatics methods */
 580     globalization_preferences_get_Calendars,
 581     globalization_preferences_get_Clocks,
 582     globalization_preferences_get_Currencies,
 583     globalization_preferences_get_Languages,
 584     globalization_preferences_get_HomeGeographicRegion,
 585     globalization_preferences_get_WeekStartsOn,
 586 };
 587
 588 static struct windows_globalization userprofile_preferences =
 589 {
 590     {&activation_factory_vtbl},
 591     {&globalization_preferences_vtbl},
 592     0
 593 };
 594
 595 static HRESULT STDMETHODCALLTYPE windows_globalization_language_factory_QueryInterface(
 596         IActivationFactory *iface, REFIID iid, void **out)
 597 {
 598     struct language_factory *factory = impl_language_factory_from_IActivationFactory(iface);
 599
 600     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 601
 602     if (IsEqualGUID(iid, &IID_IUnknown) ||
 603         IsEqualGUID(iid, &IID_IInspectable) ||
 604         IsEqualGUID(iid, &IID_IAgileObject) ||
 605         IsEqualGUID(iid, &IID_IActivationFactory))
 606     {
 607         IUnknown_AddRef(iface);
 608         *out = iface;
 609         return S_OK;
 610     }
 611
 612     if (IsEqualGUID(iid, &IID_ILanguageFactory))
 613     {
 614         IUnknown_AddRef(iface);
 615         *out = &factory->ILanguageFactory_iface;
 616         return S_OK;
 617     }
 618
 619     FIXME("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 620     *out = NULL;
 621     return E_NOINTERFACE;
 622 }
 623
 624 static ULONG STDMETHODCALLTYPE windows_globalization_language_factory_AddRef(IActivationFactory *iface)
 625 {
 626     struct language_factory *factory = impl_language_factory_from_IActivationFactory(iface);
 627     return InterlockedIncrement(&factory->ref);
 628 }
 629
 630 static ULONG STDMETHODCALLTYPE windows_globalization_language_factory_Release(IActivationFactory *iface)
 631 {
 632     struct language_factory *factory = impl_language_factory_from_IActivationFactory(iface);
 633     return InterlockedDecrement(&factory->ref);
 634 }
 635
 636 static const struct IActivationFactoryVtbl activation_factory_language_vtbl =
 637 {
 638     windows_globalization_language_factory_QueryInterface,
 639     windows_globalization_language_factory_AddRef,
 640     windows_globalization_language_factory_Release,
 641     /* IInspectable methods */
 642     windows_globalization_GetIids,
 643     windows_globalization_GetRuntimeClassName,
 644     windows_globalization_GetTrustLevel,
 645     /* IActivationFactory methods */
 646     windows_globalization_ActivateInstance,
 647 };
 648
 649 static HRESULT STDMETHODCALLTYPE language_factory_QueryInterface(
 650         ILanguageFactory *iface, REFIID iid, void **object)
 651 {
 652     struct language_factory *factory = impl_from_ILanguageFactory(iface);
 653     return IActivationFactory_QueryInterface(&factory->IActivationFactory_iface, iid, object);
 654 }
 655
 656 static ULONG STDMETHODCALLTYPE language_factory_AddRef(
 657         ILanguageFactory *iface)
 658 {
 659     struct language_factory *factory = impl_from_ILanguageFactory(iface);
 660     return IActivationFactory_AddRef(&factory->IActivationFactory_iface);
 661 }
 662
 663 static ULONG STDMETHODCALLTYPE language_factory_Release(
 664         ILanguageFactory *iface)
 665 {
 666     struct language_factory *factory = impl_from_ILanguageFactory(iface);
 667     return IActivationFactory_Release(&factory->IActivationFactory_iface);
 668 }
 669
 670 static HRESULT STDMETHODCALLTYPE language_factory_GetIids(
 671         ILanguageFactory *iface, ULONG *iid_count, IID **iids)
 672 {
 673     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
 674     return E_NOTIMPL;
 675 }
 676
 677 static HRESULT STDMETHODCALLTYPE language_factory_GetRuntimeClassName(
 678         ILanguageFactory *iface, HSTRING *class_name)
 679 {
 680     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 681     return E_NOTIMPL;
 682 }
 683
 684 static HRESULT STDMETHODCALLTYPE language_factory_GetTrustLevel(
 685         ILanguageFactory *iface, TrustLevel *trust_level)
 686 {
 687     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 688     return E_NOTIMPL;
 689 }
 690
 691 static HRESULT STDMETHODCALLTYPE language_factory_CreateLanguage(
 692         ILanguageFactory *iface, HSTRING tag, ILanguage **value)
 693 {
 694     const WCHAR *name = WindowsGetStringRawBuffer(tag, NULL);
 695     WCHAR buffer[LOCALE_NAME_MAX_LENGTH];
 696     struct language *language;
 697
 698     TRACE("iface %p, tag %p, value %p.\n", iface, tag, value);
 699
 700     if (!GetLocaleInfoEx(name, LOCALE_SNAME, buffer, ARRAY_SIZE(buffer)))
 701         return E_INVALIDARG;
 702
 703     if (!(language = calloc(1, sizeof(*language))))
 704         return E_OUTOFMEMORY;
 705
 706     language->ILanguage_iface.lpVtbl = &language_vtbl;
 707     language->ref = 1;
 708     wcscpy(language->name, buffer);
 709
 710     *value = &language->ILanguage_iface;
 711
 712     return S_OK;
 713 }
 714
 715 static const struct ILanguageFactoryVtbl language_factory_vtbl =
 716 {
 717     language_factory_QueryInterface,
 718     language_factory_AddRef,
 719     language_factory_Release,
 720     /* IInspectable methods */
 721     language_factory_GetIids,
 722     language_factory_GetRuntimeClassName,
 723     language_factory_GetTrustLevel,
 724     /* ILanguageFactory methods */
 725     language_factory_CreateLanguage,
 726 };
 727
 728 static struct language_factory language_factory =
 729 {
 730     {&activation_factory_language_vtbl},
 731     {&language_factory_vtbl},
 732     0
 733 };
 734
 735 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID riid, void **out)
 736 {
 737     FIXME("clsid %s, riid %s, out %p stub!\n", debugstr_guid(clsid), debugstr_guid(riid), out);
 738     return CLASS_E_CLASSNOTAVAILABLE;
 739 }
 740
 741 HRESULT WINAPI DllGetActivationFactory(HSTRING classid, IActivationFactory **factory)
 742 {
 743     const WCHAR *name = WindowsGetStringRawBuffer(classid, NULL);
 744
 745     TRACE("classid %s, factory %p.\n", debugstr_hstring(classid), factory);
 746
 747     *factory = NULL;
 748
 749     if (!wcscmp(name, RuntimeClass_Windows_System_UserProfile_GlobalizationPreferences))
 750     {
 751         *factory = &userprofile_preferences.IActivationFactory_iface;
 752         IUnknown_AddRef(*factory);
 753     }
 754     else if (!wcscmp(name, RuntimeClass_Windows_Globalization_Language))
 755     {
 756         *factory = &language_factory.IActivationFactory_iface;
 757         IUnknown_AddRef(*factory);
 758     }
 759
 760     if (*factory) return S_OK;
 761     return CLASS_E_CLASSNOTAVAILABLE;
 762 }