dlls/dwrite/main.c

   1 /*
   2  *    DWrite
   3  *
   4  * Copyright 2012 Nikolay Sivov for 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 #define COBJMACROS
  22
  23 #include <stdarg.h>
  24 #include <math.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29
  30 #include "initguid.h"
  31
  32 #include "dwrite_private.h"
  33 #include "unixlib.h"
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(dwrite);
  37
  38 HMODULE dwrite_module = 0;
  39 unixlib_handle_t unixlib_handle = 0;
  40 static IDWriteFactory7 *shared_factory;
  41 static void release_shared_factory(IDWriteFactory7 *factory);
  42
  43 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD reason, LPVOID reserved)
  44 {
  45     switch (reason)
  46     {
  47     case DLL_PROCESS_ATTACH:
  48         dwrite_module = hinstDLL;
  49         DisableThreadLibraryCalls( hinstDLL );
  50         if (!NtQueryVirtualMemory(GetCurrentProcess(), hinstDLL, MemoryWineUnixFuncs,
  51                 &unixlib_handle, sizeof(unixlib_handle), NULL))
  52             UNIX_CALL(process_attach, NULL);
  53         init_local_fontfile_loader();
  54         break;
  55     case DLL_PROCESS_DETACH:
  56         if (reserved) break;
  57         release_shared_factory(shared_factory);
  58         if (unixlib_handle) UNIX_CALL(process_detach, NULL);
  59     }
  60     return TRUE;
  61 }
  62
  63 struct renderingparams
  64 {
  65     IDWriteRenderingParams3 IDWriteRenderingParams3_iface;
  66     LONG refcount;
  67
  68     float gamma;
  69     float contrast;
  70     float grayscalecontrast;
  71     float cleartype_level;
  72     DWRITE_PIXEL_GEOMETRY geometry;
  73     DWRITE_RENDERING_MODE1 mode;
  74     DWRITE_GRID_FIT_MODE gridfit;
  75 };
  76
  77 static inline struct renderingparams *impl_from_IDWriteRenderingParams3(IDWriteRenderingParams3 *iface)
  78 {
  79     return CONTAINING_RECORD(iface, struct renderingparams, IDWriteRenderingParams3_iface);
  80 }
  81
  82 static HRESULT WINAPI renderingparams_QueryInterface(IDWriteRenderingParams3 *iface, REFIID riid, void **obj)
  83 {
  84     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
  85
  86     if (IsEqualIID(riid, &IID_IDWriteRenderingParams3) ||
  87         IsEqualIID(riid, &IID_IDWriteRenderingParams2) ||
  88         IsEqualIID(riid, &IID_IDWriteRenderingParams1) ||
  89         IsEqualIID(riid, &IID_IDWriteRenderingParams) ||
  90         IsEqualIID(riid, &IID_IUnknown))
  91     {
  92         *obj = iface;
  93         IDWriteRenderingParams3_AddRef(iface);
  94         return S_OK;
  95     }
  96
  97     *obj = NULL;
  98
  99     return E_NOINTERFACE;
 100 }
 101
 102 static ULONG WINAPI renderingparams_AddRef(IDWriteRenderingParams3 *iface)
 103 {
 104     struct renderingparams *params = impl_from_IDWriteRenderingParams3(iface);
 105     ULONG refcount = InterlockedIncrement(&params->refcount);
 106
 107     TRACE("%p, refcount %ld.\n", iface, refcount);
 108
 109     return refcount;
 110 }
 111
 112 static ULONG WINAPI renderingparams_Release(IDWriteRenderingParams3 *iface)
 113 {
 114     struct renderingparams *params = impl_from_IDWriteRenderingParams3(iface);
 115     ULONG refcount = InterlockedDecrement(&params->refcount);
 116
 117     TRACE("%p, refcount %ld.\n", iface, refcount);
 118
 119     if (!refcount)
 120         free(params);
 121
 122     return refcount;
 123 }
 124
 125 static float WINAPI renderingparams_GetGamma(IDWriteRenderingParams3 *iface)
 126 {
 127     struct renderingparams *params = impl_from_IDWriteRenderingParams3(iface);
 128
 129     TRACE("%p.\n", iface);
 130
 131     return params->gamma;
 132 }
 133
 134 static float WINAPI renderingparams_GetEnhancedContrast(IDWriteRenderingParams3 *iface)
 135 {
 136     struct renderingparams *params = impl_from_IDWriteRenderingParams3(iface);
 137
 138     TRACE("%p.\n", iface);
 139
 140     return params->contrast;
 141 }
 142
 143 static float WINAPI renderingparams_GetClearTypeLevel(IDWriteRenderingParams3 *iface)
 144 {
 145     struct renderingparams *params = impl_from_IDWriteRenderingParams3(iface);
 146
 147     TRACE("%p.\n", iface);
 148
 149     return params->cleartype_level;
 150 }
 151
 152 static DWRITE_PIXEL_GEOMETRY WINAPI renderingparams_GetPixelGeometry(IDWriteRenderingParams3 *iface)
 153 {
 154     struct renderingparams *params = impl_from_IDWriteRenderingParams3(iface);
 155
 156     TRACE("%p.\n", iface);
 157
 158     return params->geometry;
 159 }
 160
 161 static DWRITE_RENDERING_MODE rendering_mode_from_mode1(DWRITE_RENDERING_MODE1 mode)
 162 {
 163     static const DWRITE_RENDERING_MODE rendering_modes[] = {
 164         DWRITE_RENDERING_MODE_DEFAULT,           /* DWRITE_RENDERING_MODE1_DEFAULT */
 165         DWRITE_RENDERING_MODE_ALIASED,           /* DWRITE_RENDERING_MODE1_ALIASED */
 166         DWRITE_RENDERING_MODE_GDI_CLASSIC,       /* DWRITE_RENDERING_MODE1_GDI_CLASSIC */
 167         DWRITE_RENDERING_MODE_GDI_NATURAL,       /* DWRITE_RENDERING_MODE1_GDI_NATURAL */
 168         DWRITE_RENDERING_MODE_NATURAL,           /* DWRITE_RENDERING_MODE1_NATURAL */
 169         DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC, /* DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC */
 170         DWRITE_RENDERING_MODE_OUTLINE,           /* DWRITE_RENDERING_MODE1_OUTLINE */
 171         DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC, /* DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC_DOWNSAMPLED */
 172     };
 173
 174     return rendering_modes[mode];
 175 }
 176
 177 static DWRITE_RENDERING_MODE WINAPI renderingparams_GetRenderingMode(IDWriteRenderingParams3 *iface)
 178 {
 179     struct renderingparams *params = impl_from_IDWriteRenderingParams3(iface);
 180
 181     TRACE("%p.\n", iface);
 182
 183     return rendering_mode_from_mode1(params->mode);
 184 }
 185
 186 static float WINAPI renderingparams1_GetGrayscaleEnhancedContrast(IDWriteRenderingParams3 *iface)
 187 {
 188     struct renderingparams *params = impl_from_IDWriteRenderingParams3(iface);
 189
 190     TRACE("%p.\n", iface);
 191
 192     return params->grayscalecontrast;
 193 }
 194
 195 static DWRITE_GRID_FIT_MODE WINAPI renderingparams2_GetGridFitMode(IDWriteRenderingParams3 *iface)
 196 {
 197     struct renderingparams *params = impl_from_IDWriteRenderingParams3(iface);
 198
 199     TRACE("%p.\n", iface);
 200
 201     return params->gridfit;
 202 }
 203
 204 static DWRITE_RENDERING_MODE1 WINAPI renderingparams3_GetRenderingMode1(IDWriteRenderingParams3 *iface)
 205 {
 206     struct renderingparams *params = impl_from_IDWriteRenderingParams3(iface);
 207
 208     TRACE("%p.\n", iface);
 209
 210     return params->mode;
 211 }
 212
 213 static const IDWriteRenderingParams3Vtbl renderingparamsvtbl =
 214 {
 215     renderingparams_QueryInterface,
 216     renderingparams_AddRef,
 217     renderingparams_Release,
 218     renderingparams_GetGamma,
 219     renderingparams_GetEnhancedContrast,
 220     renderingparams_GetClearTypeLevel,
 221     renderingparams_GetPixelGeometry,
 222     renderingparams_GetRenderingMode,
 223     renderingparams1_GetGrayscaleEnhancedContrast,
 224     renderingparams2_GetGridFitMode,
 225     renderingparams3_GetRenderingMode1
 226 };
 227
 228 static HRESULT create_renderingparams(float gamma, float contrast, float grayscalecontrast, float cleartype_level,
 229         DWRITE_PIXEL_GEOMETRY geometry, DWRITE_RENDERING_MODE1 mode, DWRITE_GRID_FIT_MODE gridfit,
 230         IDWriteRenderingParams3 **params)
 231 {
 232     struct renderingparams *object;
 233
 234     *params = NULL;
 235
 236     if (gamma <= 0.0f || contrast < 0.0f || grayscalecontrast < 0.0f || cleartype_level < 0.0f)
 237         return E_INVALIDARG;
 238
 239     if ((UINT32)gridfit > DWRITE_GRID_FIT_MODE_ENABLED || (UINT32)geometry > DWRITE_PIXEL_GEOMETRY_BGR)
 240         return E_INVALIDARG;
 241
 242     if (!(object = malloc(sizeof(*object))))
 243         return E_OUTOFMEMORY;
 244
 245     object->IDWriteRenderingParams3_iface.lpVtbl = &renderingparamsvtbl;
 246     object->refcount = 1;
 247
 248     object->gamma = gamma;
 249     object->contrast = contrast;
 250     object->grayscalecontrast = grayscalecontrast;
 251     object->cleartype_level = cleartype_level;
 252     object->geometry = geometry;
 253     object->mode = mode;
 254     object->gridfit = gridfit;
 255
 256     *params = &object->IDWriteRenderingParams3_iface;
 257
 258     return S_OK;
 259 }
 260
 261 struct localizedpair {
 262     WCHAR *locale;
 263     WCHAR *string;
 264 };
 265
 266 struct localizedstrings
 267 {
 268     IDWriteLocalizedStrings IDWriteLocalizedStrings_iface;
 269     LONG refcount;
 270
 271     struct localizedpair *data;
 272     size_t size;
 273     size_t count;
 274 };
 275
 276 static inline struct localizedstrings *impl_from_IDWriteLocalizedStrings(IDWriteLocalizedStrings *iface)
 277 {
 278     return CONTAINING_RECORD(iface, struct localizedstrings, IDWriteLocalizedStrings_iface);
 279 }
 280
 281 static HRESULT WINAPI localizedstrings_QueryInterface(IDWriteLocalizedStrings *iface, REFIID riid, void **obj)
 282 {
 283     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 284
 285     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDWriteLocalizedStrings))
 286     {
 287         *obj = iface;
 288         IDWriteLocalizedStrings_AddRef(iface);
 289         return S_OK;
 290     }
 291
 292     *obj = NULL;
 293
 294     return E_NOINTERFACE;
 295 }
 296
 297 static ULONG WINAPI localizedstrings_AddRef(IDWriteLocalizedStrings *iface)
 298 {
 299     struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
 300     ULONG refcount = InterlockedIncrement(&strings->refcount);
 301
 302     TRACE("%p, refcount %ld.\n", iface, refcount);
 303
 304     return refcount;
 305 }
 306
 307 static ULONG WINAPI localizedstrings_Release(IDWriteLocalizedStrings *iface)
 308 {
 309     struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
 310     ULONG refcount = InterlockedDecrement(&strings->refcount);
 311     size_t i;
 312
 313     TRACE("%p, refcount %ld.\n", iface, refcount);
 314
 315     if (!refcount)
 316     {
 317         for (i = 0; i < strings->count; ++i)
 318         {
 319             free(strings->data[i].locale);
 320             free(strings->data[i].string);
 321         }
 322
 323         free(strings->data);
 324         free(strings);
 325     }
 326
 327     return refcount;
 328 }
 329
 330 static UINT32 WINAPI localizedstrings_GetCount(IDWriteLocalizedStrings *iface)
 331 {
 332     TRACE("%p.\n", iface);
 333
 334     return get_localizedstrings_count(iface);
 335 }
 336
 337 static HRESULT WINAPI localizedstrings_FindLocaleName(IDWriteLocalizedStrings *iface,
 338     WCHAR const *locale_name, UINT32 *index, BOOL *exists)
 339 {
 340     struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
 341     size_t i;
 342
 343     TRACE("%p, %s, %p, %p.\n", iface, debugstr_w(locale_name), index, exists);
 344
 345     *exists = FALSE;
 346     *index = ~0;
 347
 348     for (i = 0; i < strings->count; ++i)
 349     {
 350         if (!wcsicmp(strings->data[i].locale, locale_name))
 351         {
 352             *exists = TRUE;
 353             *index = i;
 354             break;
 355         }
 356     }
 357
 358     return S_OK;
 359 }
 360
 361 static HRESULT WINAPI localizedstrings_GetLocaleNameLength(IDWriteLocalizedStrings *iface, UINT32 index, UINT32 *length)
 362 {
 363     struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
 364
 365     TRACE("%p, %u, %p.\n", iface, index, length);
 366
 367     if (index >= strings->count)
 368     {
 369         *length = (UINT32)-1;
 370         return E_FAIL;
 371     }
 372
 373     *length = wcslen(strings->data[index].locale);
 374     return S_OK;
 375 }
 376
 377 static HRESULT WINAPI localizedstrings_GetLocaleName(IDWriteLocalizedStrings *iface, UINT32 index, WCHAR *buffer, UINT32 size)
 378 {
 379     struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
 380
 381     TRACE("%p, %u, %p, %u.\n", iface, index, buffer, size);
 382
 383     if (index >= strings->count)
 384     {
 385         if (buffer) *buffer = 0;
 386         return E_FAIL;
 387     }
 388
 389     if (size < wcslen(strings->data[index].locale) + 1)
 390     {
 391         if (buffer) *buffer = 0;
 392         return E_NOT_SUFFICIENT_BUFFER;
 393     }
 394
 395     wcscpy(buffer, strings->data[index].locale);
 396     return S_OK;
 397 }
 398
 399 static HRESULT WINAPI localizedstrings_GetStringLength(IDWriteLocalizedStrings *iface, UINT32 index, UINT32 *length)
 400 {
 401     struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
 402
 403     TRACE("%p, %u, %p.\n", iface, index, length);
 404
 405     if (index >= strings->count)
 406     {
 407         *length = ~0u;
 408         return E_FAIL;
 409     }
 410
 411     *length = wcslen(strings->data[index].string);
 412     return S_OK;
 413 }
 414
 415 static HRESULT WINAPI localizedstrings_GetString(IDWriteLocalizedStrings *iface, UINT32 index, WCHAR *buffer, UINT32 size)
 416 {
 417     struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
 418
 419     TRACE("%p, %u, %p, %u.\n", iface, index, buffer, size);
 420
 421     if (index >= strings->count)
 422     {
 423         if (buffer) *buffer = 0;
 424         return E_FAIL;
 425     }
 426
 427     if (size < wcslen(strings->data[index].string) + 1)
 428     {
 429         if (buffer) *buffer = 0;
 430         return E_NOT_SUFFICIENT_BUFFER;
 431     }
 432
 433     wcscpy(buffer, strings->data[index].string);
 434     return S_OK;
 435 }
 436
 437 static const IDWriteLocalizedStringsVtbl localizedstringsvtbl =
 438 {
 439     localizedstrings_QueryInterface,
 440     localizedstrings_AddRef,
 441     localizedstrings_Release,
 442     localizedstrings_GetCount,
 443     localizedstrings_FindLocaleName,
 444     localizedstrings_GetLocaleNameLength,
 445     localizedstrings_GetLocaleName,
 446     localizedstrings_GetStringLength,
 447     localizedstrings_GetString
 448 };
 449
 450 HRESULT create_localizedstrings(IDWriteLocalizedStrings **strings)
 451 {
 452     struct localizedstrings *object;
 453
 454     *strings = NULL;
 455
 456     if (!(object = calloc(1, sizeof(*object))))
 457         return E_OUTOFMEMORY;
 458
 459     object->IDWriteLocalizedStrings_iface.lpVtbl = &localizedstringsvtbl;
 460     object->refcount = 1;
 461
 462     *strings = &object->IDWriteLocalizedStrings_iface;
 463
 464     return S_OK;
 465 }
 466
 467 HRESULT add_localizedstring(IDWriteLocalizedStrings *iface, const WCHAR *locale, const WCHAR *string)
 468 {
 469     struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
 470     size_t i, count = strings->count;
 471
 472     /* Make sure there's no duplicates, unless it's empty. This is used by dlng/slng entries of 'meta' table. */
 473     if (*locale)
 474     {
 475         for (i = 0; i < count; i++)
 476             if (!wcsicmp(strings->data[i].locale, locale))
 477                 return S_OK;
 478     }
 479
 480     if (!dwrite_array_reserve((void **)&strings->data, &strings->size, strings->count + 1, sizeof(*strings->data)))
 481         return E_OUTOFMEMORY;
 482
 483     strings->data[count].locale = wcsdup(locale);
 484     strings->data[count].string = wcsdup(string);
 485     if (!strings->data[count].locale || !strings->data[count].string)
 486     {
 487         free(strings->data[count].locale);
 488         free(strings->data[count].string);
 489         return E_OUTOFMEMORY;
 490     }
 491     wcslwr(strings->data[count].locale);
 492
 493     strings->count++;
 494
 495     return S_OK;
 496 }
 497
 498 HRESULT clone_localizedstrings(IDWriteLocalizedStrings *iface, IDWriteLocalizedStrings **ret)
 499 {
 500     struct localizedstrings *strings, *strings_clone;
 501     size_t i;
 502
 503     *ret = NULL;
 504
 505     if (!iface)
 506         return S_FALSE;
 507
 508     strings = impl_from_IDWriteLocalizedStrings(iface);
 509     if (!(strings_clone = calloc(1, sizeof(*strings_clone))))
 510         return E_OUTOFMEMORY;
 511
 512     if (!dwrite_array_reserve((void **)&strings_clone->data, &strings_clone->size, strings->count,
 513             sizeof(*strings_clone->data)))
 514     {
 515         free(strings_clone);
 516         return E_OUTOFMEMORY;
 517     }
 518
 519     strings_clone->IDWriteLocalizedStrings_iface.lpVtbl = &localizedstringsvtbl;
 520     strings_clone->refcount = 1;
 521     strings_clone->count = strings->count;
 522
 523     for (i = 0; i < strings_clone->count; ++i)
 524     {
 525         strings_clone->data[i].locale = wcsdup(strings->data[i].locale);
 526         strings_clone->data[i].string = wcsdup(strings->data[i].string);
 527     }
 528
 529     *ret = &strings_clone->IDWriteLocalizedStrings_iface;
 530
 531     return S_OK;
 532 }
 533
 534 void set_en_localizedstring(IDWriteLocalizedStrings *iface, const WCHAR *string)
 535 {
 536     struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
 537     UINT32 i;
 538
 539     for (i = 0; i < strings->count; i++)
 540     {
 541         if (!wcsicmp(strings->data[i].locale, L"en-US"))
 542         {
 543             free(strings->data[i].string);
 544             strings->data[i].string = wcsdup(string);
 545             break;
 546         }
 547     }
 548 }
 549
 550 static int __cdecl localizedstrings_sorting_compare(const void *left, const void *right)
 551 {
 552     const struct localizedpair *_l = left, *_r = right;
 553
 554     return wcscmp(_l->locale, _r->locale);
 555 };
 556
 557 void sort_localizedstrings(IDWriteLocalizedStrings *iface)
 558 {
 559     struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
 560
 561     qsort(strings->data, strings->count, sizeof(*strings->data), localizedstrings_sorting_compare);
 562 }
 563
 564 unsigned int get_localizedstrings_count(IDWriteLocalizedStrings *iface)
 565 {
 566     struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
 567     return strings->count;
 568 }
 569
 570 BOOL localizedstrings_contains(IDWriteLocalizedStrings *iface, const WCHAR *str)
 571 {
 572     struct localizedstrings *strings = impl_from_IDWriteLocalizedStrings(iface);
 573     unsigned int i;
 574
 575     for (i = 0; i < strings->count; ++i)
 576     {
 577         if (!wcsicmp(strings->data[i].string, str)) return TRUE;
 578     }
 579
 580     return FALSE;
 581 }
 582
 583 struct collectionloader
 584 {
 585     struct list entry;
 586     IDWriteFontCollectionLoader *loader;
 587 };
 588
 589 struct fileloader
 590 {
 591     struct list entry;
 592     struct list fontfaces;
 593     IDWriteFontFileLoader *loader;
 594 };
 595
 596 struct dwritefactory
 597 {
 598     IDWriteFactory7 IDWriteFactory7_iface;
 599     LONG refcount;
 600
 601     IDWriteFontCollection1 *system_collection;
 602     IDWriteFontCollection1 *eudc_collection;
 603     IDWriteGdiInterop1 *gdiinterop;
 604     IDWriteFontFallback1 *fallback;
 605
 606     IDWriteFontFileLoader *localfontfileloader;
 607     struct list localfontfaces;
 608
 609     struct list collection_loaders;
 610     struct list file_loaders;
 611
 612     CRITICAL_SECTION cs;
 613 };
 614
 615 static inline struct dwritefactory *impl_from_IDWriteFactory7(IDWriteFactory7 *iface)
 616 {
 617     return CONTAINING_RECORD(iface, struct dwritefactory, IDWriteFactory7_iface);
 618 }
 619
 620 static void release_fontface_cache(struct list *fontfaces)
 621 {
 622     struct fontfacecached *fontface, *fontface2;
 623
 624     LIST_FOR_EACH_ENTRY_SAFE(fontface, fontface2, fontfaces, struct fontfacecached, entry) {
 625         list_remove(&fontface->entry);
 626         fontface_detach_from_cache(fontface->fontface);
 627         free(fontface);
 628     }
 629 }
 630
 631 static void release_fileloader(struct fileloader *fileloader)
 632 {
 633     list_remove(&fileloader->entry);
 634     release_fontface_cache(&fileloader->fontfaces);
 635     IDWriteFontFileLoader_Release(fileloader->loader);
 636     free(fileloader);
 637 }
 638
 639 static void release_dwritefactory(struct dwritefactory *factory)
 640 {
 641     struct fileloader *fileloader, *fileloader2;
 642     struct collectionloader *loader, *loader2;
 643
 644     EnterCriticalSection(&factory->cs);
 645     release_fontface_cache(&factory->localfontfaces);
 646     LeaveCriticalSection(&factory->cs);
 647
 648     LIST_FOR_EACH_ENTRY_SAFE(loader, loader2, &factory->collection_loaders, struct collectionloader, entry) {
 649         list_remove(&loader->entry);
 650         IDWriteFontCollectionLoader_Release(loader->loader);
 651         free(loader);
 652     }
 653
 654     LIST_FOR_EACH_ENTRY_SAFE(fileloader, fileloader2, &factory->file_loaders, struct fileloader, entry)
 655         release_fileloader(fileloader);
 656
 657     if (factory->system_collection)
 658         IDWriteFontCollection1_Release(factory->system_collection);
 659     if (factory->eudc_collection)
 660         IDWriteFontCollection1_Release(factory->eudc_collection);
 661     if (factory->fallback)
 662         release_system_fontfallback(factory->fallback);
 663
 664     factory->cs.DebugInfo->Spare[0] = 0;
 665     DeleteCriticalSection(&factory->cs);
 666     free(factory);
 667 }
 668
 669 static void release_shared_factory(IDWriteFactory7 *iface)
 670 {
 671     struct dwritefactory *factory;
 672     if (!iface) return;
 673     factory = impl_from_IDWriteFactory7(iface);
 674     release_dwritefactory(factory);
 675 }
 676
 677 static struct fileloader *factory_get_file_loader(struct dwritefactory *factory, IDWriteFontFileLoader *loader)
 678 {
 679     struct fileloader *entry, *found = NULL;
 680
 681     LIST_FOR_EACH_ENTRY(entry, &factory->file_loaders, struct fileloader, entry) {
 682         if (entry->loader == loader) {
 683             found = entry;
 684             break;
 685         }
 686     }
 687
 688     return found;
 689 }
 690
 691 static struct collectionloader *factory_get_collection_loader(struct dwritefactory *factory,
 692         IDWriteFontCollectionLoader *loader)
 693 {
 694     struct collectionloader *entry, *found = NULL;
 695
 696     LIST_FOR_EACH_ENTRY(entry, &factory->collection_loaders, struct collectionloader, entry) {
 697         if (entry->loader == loader) {
 698             found = entry;
 699             break;
 700         }
 701     }
 702
 703     return found;
 704 }
 705
 706 static IDWriteFontCollection1 *factory_get_system_collection(struct dwritefactory *factory)
 707 {
 708     IDWriteFontCollection1 *collection;
 709     HRESULT hr;
 710
 711     if (factory->system_collection) {
 712         IDWriteFontCollection1_AddRef(factory->system_collection);
 713         return factory->system_collection;
 714     }
 715
 716     if (FAILED(hr = get_system_fontcollection(&factory->IDWriteFactory7_iface, &collection)))
 717     {
 718         WARN("Failed to create system font collection, hr %#lx.\n", hr);
 719         return NULL;
 720     }
 721
 722     if (InterlockedCompareExchangePointer((void **)&factory->system_collection, collection, NULL))
 723         IDWriteFontCollection1_Release(collection);
 724
 725     return factory->system_collection;
 726 }
 727
 728 static HRESULT WINAPI dwritefactory_QueryInterface(IDWriteFactory7 *iface, REFIID riid, void **obj)
 729 {
 730     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 731
 732     if (IsEqualIID(riid, &IID_IDWriteFactory7) ||
 733         IsEqualIID(riid, &IID_IDWriteFactory6) ||
 734         IsEqualIID(riid, &IID_IDWriteFactory5) ||
 735         IsEqualIID(riid, &IID_IDWriteFactory4) ||
 736         IsEqualIID(riid, &IID_IDWriteFactory3) ||
 737         IsEqualIID(riid, &IID_IDWriteFactory2) ||
 738         IsEqualIID(riid, &IID_IDWriteFactory1) ||
 739         IsEqualIID(riid, &IID_IDWriteFactory) ||
 740         IsEqualIID(riid, &IID_IUnknown))
 741    {
 742         *obj = iface;
 743         IDWriteFactory7_AddRef(iface);
 744         return S_OK;
 745     }
 746
 747     *obj = NULL;
 748
 749     return E_NOINTERFACE;
 750 }
 751
 752 static ULONG WINAPI dwritefactory_AddRef(IDWriteFactory7 *iface)
 753 {
 754     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
 755     ULONG refcount = InterlockedIncrement(&factory->refcount);
 756
 757     TRACE("%p, refcount %lu.\n", iface, refcount);
 758
 759     return refcount;
 760 }
 761
 762 static ULONG WINAPI dwritefactory_Release(IDWriteFactory7 *iface)
 763 {
 764     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
 765     ULONG refcount = InterlockedDecrement(&factory->refcount);
 766
 767     TRACE("%p, refcount %lu.\n", iface, refcount);
 768
 769     if (!refcount)
 770         release_dwritefactory(factory);
 771
 772     return refcount;
 773 }
 774
 775 static HRESULT WINAPI dwritefactory_GetSystemFontCollection(IDWriteFactory7 *iface,
 776     IDWriteFontCollection **collection, BOOL check_for_updates)
 777 {
 778     return IDWriteFactory5_GetSystemFontCollection((IDWriteFactory5 *)iface, FALSE, (IDWriteFontCollection1 **)collection,
 779             check_for_updates);
 780 }
 781
 782 static HRESULT WINAPI dwritefactory_CreateCustomFontCollection(IDWriteFactory7 *iface,
 783     IDWriteFontCollectionLoader *loader, void const *key, UINT32 key_size, IDWriteFontCollection **collection)
 784 {
 785     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
 786     IDWriteFontFileEnumerator *enumerator;
 787     struct collectionloader *found;
 788     HRESULT hr;
 789
 790     TRACE("%p, %p, %p, %u, %p.\n", iface, loader, key, key_size, collection);
 791
 792     *collection = NULL;
 793
 794     if (!loader)
 795         return E_INVALIDARG;
 796
 797     found = factory_get_collection_loader(factory, loader);
 798     if (!found)
 799         return E_INVALIDARG;
 800
 801     hr = IDWriteFontCollectionLoader_CreateEnumeratorFromKey(found->loader, (IDWriteFactory *)iface,
 802             key, key_size, &enumerator);
 803     if (FAILED(hr))
 804         return hr;
 805
 806     hr = create_font_collection(iface, enumerator, FALSE, (IDWriteFontCollection3 **)collection);
 807     IDWriteFontFileEnumerator_Release(enumerator);
 808     return hr;
 809 }
 810
 811 static HRESULT WINAPI dwritefactory_RegisterFontCollectionLoader(IDWriteFactory7 *iface,
 812     IDWriteFontCollectionLoader *loader)
 813 {
 814     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
 815     struct collectionloader *entry;
 816
 817     TRACE("%p, %p.\n", iface, loader);
 818
 819     if (!loader)
 820         return E_INVALIDARG;
 821
 822     if (factory_get_collection_loader(factory, loader))
 823         return DWRITE_E_ALREADYREGISTERED;
 824
 825     if (!(entry = malloc(sizeof(*entry))))
 826         return E_OUTOFMEMORY;
 827
 828     entry->loader = loader;
 829     IDWriteFontCollectionLoader_AddRef(loader);
 830     list_add_tail(&factory->collection_loaders, &entry->entry);
 831
 832     return S_OK;
 833 }
 834
 835 static HRESULT WINAPI dwritefactory_UnregisterFontCollectionLoader(IDWriteFactory7 *iface,
 836     IDWriteFontCollectionLoader *loader)
 837 {
 838     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
 839     struct collectionloader *found;
 840
 841     TRACE("%p, %p.\n", iface, loader);
 842
 843     if (!loader)
 844         return E_INVALIDARG;
 845
 846     found = factory_get_collection_loader(factory, loader);
 847     if (!found)
 848         return E_INVALIDARG;
 849
 850     IDWriteFontCollectionLoader_Release(found->loader);
 851     list_remove(&found->entry);
 852     free(found);
 853
 854     return S_OK;
 855 }
 856
 857 static HRESULT WINAPI dwritefactory_CreateFontFileReference(IDWriteFactory7 *iface,
 858     WCHAR const *path, FILETIME const *writetime, IDWriteFontFile **font_file)
 859 {
 860     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
 861     UINT32 key_size;
 862     HRESULT hr;
 863     void *key;
 864
 865     TRACE("%p, %s, %p, %p.\n", iface, debugstr_w(path), writetime, font_file);
 866
 867     *font_file = NULL;
 868
 869     /* Get a reference key in local file loader format. */
 870     hr = get_local_refkey(path, writetime, &key, &key_size);
 871     if (FAILED(hr))
 872         return hr;
 873
 874     hr = create_font_file(factory->localfontfileloader, key, key_size, font_file);
 875     free(key);
 876
 877     return hr;
 878 }
 879
 880 static HRESULT WINAPI dwritefactory_CreateCustomFontFileReference(IDWriteFactory7 *iface,
 881     void const *reference_key, UINT32 key_size, IDWriteFontFileLoader *loader, IDWriteFontFile **font_file)
 882 {
 883     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
 884
 885     TRACE("%p, %p, %u, %p, %p.\n", iface, reference_key, key_size, loader, font_file);
 886
 887     *font_file = NULL;
 888
 889     if (!loader || !(factory_get_file_loader(factory, loader) || factory->localfontfileloader == loader))
 890         return E_INVALIDARG;
 891
 892     return create_font_file(loader, reference_key, key_size, font_file);
 893 }
 894
 895 void factory_lock(IDWriteFactory7 *iface)
 896 {
 897     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
 898     EnterCriticalSection(&factory->cs);
 899 }
 900
 901 void factory_unlock(IDWriteFactory7 *iface)
 902 {
 903     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
 904     LeaveCriticalSection(&factory->cs);
 905 }
 906
 907 HRESULT factory_get_cached_fontface(IDWriteFactory7 *iface, IDWriteFontFile * const *font_files, UINT32 index,
 908         DWRITE_FONT_SIMULATIONS simulations, struct list **cached_list, REFIID riid, void **obj)
 909 {
 910     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
 911     struct fontfacecached *cached;
 912     IDWriteFontFileLoader *loader;
 913     struct list *fontfaces;
 914     UINT32 key_size;
 915     const void *key;
 916     HRESULT hr;
 917
 918     *obj = NULL;
 919     *cached_list = NULL;
 920
 921     hr = IDWriteFontFile_GetReferenceKey(*font_files, &key, &key_size);
 922     if (FAILED(hr))
 923         return hr;
 924
 925     hr = IDWriteFontFile_GetLoader(*font_files, &loader);
 926     if (FAILED(hr))
 927         return hr;
 928
 929     if (loader == factory->localfontfileloader) {
 930         fontfaces = &factory->localfontfaces;
 931         IDWriteFontFileLoader_Release(loader);
 932     }
 933     else {
 934         struct fileloader *fileloader = factory_get_file_loader(factory, loader);
 935         IDWriteFontFileLoader_Release(loader);
 936         if (!fileloader)
 937             return E_INVALIDARG;
 938         fontfaces = &fileloader->fontfaces;
 939     }
 940
 941     *cached_list = fontfaces;
 942
 943     EnterCriticalSection(&factory->cs);
 944
 945     /* search through cache list */
 946     LIST_FOR_EACH_ENTRY(cached, fontfaces, struct fontfacecached, entry) {
 947         UINT32 cached_key_size, count = 1, cached_face_index;
 948         DWRITE_FONT_SIMULATIONS cached_simulations;
 949         const void *cached_key;
 950         IDWriteFontFile *file;
 951
 952         cached_face_index = IDWriteFontFace5_GetIndex(cached->fontface);
 953         cached_simulations = IDWriteFontFace5_GetSimulations(cached->fontface);
 954
 955         /* skip earlier */
 956         if (cached_face_index != index || cached_simulations != simulations)
 957             continue;
 958
 959         hr = IDWriteFontFace5_GetFiles(cached->fontface, &count, &file);
 960         if (FAILED(hr))
 961             break;
 962
 963         hr = IDWriteFontFile_GetReferenceKey(file, &cached_key, &cached_key_size);
 964         IDWriteFontFile_Release(file);
 965         if (FAILED(hr))
 966             break;
 967
 968         if (cached_key_size == key_size && !memcmp(cached_key, key, key_size))
 969         {
 970             if (FAILED(hr = IDWriteFontFace5_QueryInterface(cached->fontface, riid, obj)))
 971                 WARN("Failed to get %s from fontface, hr %#lx.\n", debugstr_guid(riid), hr);
 972
 973             TRACE("returning cached fontface %p\n", cached->fontface);
 974             break;
 975         }
 976     }
 977
 978     LeaveCriticalSection(&factory->cs);
 979
 980     return *obj ? S_OK : S_FALSE;
 981 }
 982
 983 struct fontfacecached *factory_cache_fontface(IDWriteFactory7 *iface, struct list *fontfaces,
 984         IDWriteFontFace5 *fontface)
 985 {
 986     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
 987     struct fontfacecached *cached;
 988
 989     /* new cache entry */
 990     if (!(cached = malloc(sizeof(*cached))))
 991         return NULL;
 992
 993     cached->fontface = fontface;
 994     EnterCriticalSection(&factory->cs);
 995     list_add_tail(fontfaces, &cached->entry);
 996     LeaveCriticalSection(&factory->cs);
 997
 998     return cached;
 999 }
1000
1001 static HRESULT WINAPI dwritefactory_CreateFontFace(IDWriteFactory7 *iface, DWRITE_FONT_FACE_TYPE req_facetype,
1002     UINT32 files_number, IDWriteFontFile* const* font_files, UINT32 index, DWRITE_FONT_SIMULATIONS simulations,
1003     IDWriteFontFace **fontface)
1004 {
1005     DWRITE_FONT_FILE_TYPE file_type;
1006     DWRITE_FONT_FACE_TYPE face_type;
1007     IDWriteFontFileStream *stream;
1008     struct fontface_desc desc;
1009     struct list *fontfaces;
1010     BOOL is_supported;
1011     UINT32 face_count;
1012     HRESULT hr;
1013
1014     TRACE("%p, %d, %u, %p, %u, %#x, %p.\n", iface, req_facetype, files_number, font_files, index,
1015         simulations, fontface);
1016
1017     *fontface = NULL;
1018
1019     if (!is_face_type_supported(req_facetype))
1020         return E_INVALIDARG;
1021
1022     if (req_facetype != DWRITE_FONT_FACE_TYPE_OPENTYPE_COLLECTION && index)
1023         return E_INVALIDARG;
1024
1025     if (!is_simulation_valid(simulations))
1026         return E_INVALIDARG;
1027
1028     if (FAILED(hr = get_filestream_from_file(*font_files, &stream)))
1029         return hr;
1030
1031     /* check actual file/face type */
1032     is_supported = FALSE;
1033     face_type = DWRITE_FONT_FACE_TYPE_UNKNOWN;
1034     hr = opentype_analyze_font(stream, &is_supported, &file_type, &face_type, &face_count);
1035     if (FAILED(hr))
1036         goto failed;
1037
1038     if (!is_supported) {
1039         hr = E_FAIL;
1040         goto failed;
1041     }
1042
1043     if (face_type != req_facetype) {
1044         hr = DWRITE_E_FILEFORMAT;
1045         goto failed;
1046     }
1047
1048     hr = factory_get_cached_fontface(iface, font_files, index, simulations, &fontfaces,
1049             &IID_IDWriteFontFace, (void **)fontface);
1050     if (hr != S_FALSE)
1051         goto failed;
1052
1053     desc.factory = iface;
1054     desc.face_type = req_facetype;
1055     desc.file = *font_files;
1056     desc.stream = stream;
1057     desc.index = index;
1058     desc.simulations = simulations;
1059     desc.font_data = NULL;
1060     hr = create_fontface(&desc, fontfaces, (IDWriteFontFace5 **)fontface);
1061
1062 failed:
1063     IDWriteFontFileStream_Release(stream);
1064     return hr;
1065 }
1066
1067 static HRESULT WINAPI dwritefactory_CreateRenderingParams(IDWriteFactory7 *iface, IDWriteRenderingParams **params)
1068 {
1069     HMONITOR monitor;
1070     POINT pt;
1071
1072     TRACE("%p, %p.\n", iface, params);
1073
1074     pt.x = pt.y = 0;
1075     monitor = MonitorFromPoint(pt, MONITOR_DEFAULTTOPRIMARY);
1076     return IDWriteFactory7_CreateMonitorRenderingParams(iface, monitor, params);
1077 }
1078
1079 static HRESULT WINAPI dwritefactory_CreateMonitorRenderingParams(IDWriteFactory7 *iface, HMONITOR monitor,
1080     IDWriteRenderingParams **params)
1081 {
1082     IDWriteRenderingParams3 *params3;
1083     static int fixme_once = 0;
1084     HRESULT hr;
1085
1086     TRACE("%p, %p, %p.\n", iface, monitor, params);
1087
1088     if (!fixme_once++)
1089         FIXME("(%p): monitor setting ignored\n", monitor);
1090
1091     /* FIXME: use actual per-monitor gamma factor */
1092     hr = IDWriteFactory7_CreateCustomRenderingParams(iface, 2.0f, 0.0f, 1.0f, 0.0f, DWRITE_PIXEL_GEOMETRY_FLAT,
1093         DWRITE_RENDERING_MODE1_DEFAULT, DWRITE_GRID_FIT_MODE_DEFAULT, &params3);
1094     *params = (IDWriteRenderingParams*)params3;
1095     return hr;
1096 }
1097
1098 static HRESULT WINAPI dwritefactory_CreateCustomRenderingParams(IDWriteFactory7 *iface, FLOAT gamma,
1099         FLOAT enhancedContrast, FLOAT cleartype_level, DWRITE_PIXEL_GEOMETRY geometry, DWRITE_RENDERING_MODE mode,
1100         IDWriteRenderingParams **params)
1101 {
1102     IDWriteRenderingParams3 *params3;
1103     HRESULT hr;
1104
1105     TRACE("%p, %.8e, %.8e, %.8e, %d, %d, %p.\n", iface, gamma, enhancedContrast, cleartype_level, geometry, mode, params);
1106
1107     if ((UINT32)mode > DWRITE_RENDERING_MODE_OUTLINE) {
1108         *params = NULL;
1109         return E_INVALIDARG;
1110     }
1111
1112     hr = IDWriteFactory7_CreateCustomRenderingParams(iface, gamma, enhancedContrast, 1.0f, cleartype_level, geometry,
1113             (DWRITE_RENDERING_MODE1)mode, DWRITE_GRID_FIT_MODE_DEFAULT, &params3);
1114     *params = (IDWriteRenderingParams*)params3;
1115     return hr;
1116 }
1117
1118 static HRESULT WINAPI dwritefactory_RegisterFontFileLoader(IDWriteFactory7 *iface, IDWriteFontFileLoader *loader)
1119 {
1120     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
1121     struct fileloader *entry;
1122
1123     TRACE("%p, %p.\n", iface, loader);
1124
1125     if (!loader)
1126         return E_INVALIDARG;
1127
1128     if (factory_get_file_loader(factory, loader))
1129         return DWRITE_E_ALREADYREGISTERED;
1130
1131     if (!(entry = malloc(sizeof(*entry))))
1132         return E_OUTOFMEMORY;
1133
1134     entry->loader = loader;
1135     list_init(&entry->fontfaces);
1136     IDWriteFontFileLoader_AddRef(loader);
1137     list_add_tail(&factory->file_loaders, &entry->entry);
1138
1139     return S_OK;
1140 }
1141
1142 static HRESULT WINAPI dwritefactory_UnregisterFontFileLoader(IDWriteFactory7 *iface, IDWriteFontFileLoader *loader)
1143 {
1144     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
1145     struct fileloader *found;
1146
1147     TRACE("%p, %p.\n", iface, loader);
1148
1149     if (!loader)
1150         return E_INVALIDARG;
1151
1152     found = factory_get_file_loader(factory, loader);
1153     if (!found)
1154         return E_INVALIDARG;
1155
1156     release_fileloader(found);
1157     return S_OK;
1158 }
1159
1160 static HRESULT WINAPI dwritefactory_CreateTextFormat(IDWriteFactory7 *iface, WCHAR const* family_name,
1161     IDWriteFontCollection *collection, DWRITE_FONT_WEIGHT weight, DWRITE_FONT_STYLE style,
1162     DWRITE_FONT_STRETCH stretch, FLOAT size, WCHAR const *locale, IDWriteTextFormat **format)
1163 {
1164     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
1165     HRESULT hr;
1166
1167     TRACE("%p, %s, %p, %d, %d, %d, %.8e, %s, %p.\n", iface, debugstr_w(family_name), collection, weight, style, stretch,
1168         size, debugstr_w(locale), format);
1169
1170     if (collection)
1171         IDWriteFontCollection_AddRef(collection);
1172     else {
1173         collection = (IDWriteFontCollection *)factory_get_system_collection(factory);
1174         if (!collection) {
1175             *format = NULL;
1176             return E_FAIL;
1177         }
1178     }
1179
1180     hr = create_textformat(family_name, collection, weight, style, stretch, size, locale, format);
1181     IDWriteFontCollection_Release(collection);
1182     return hr;
1183 }
1184
1185 static HRESULT WINAPI dwritefactory_CreateTypography(IDWriteFactory7 *iface, IDWriteTypography **typography)
1186 {
1187     TRACE("%p, %p.\n", iface, typography);
1188
1189     return create_typography(typography);
1190 }
1191
1192 static HRESULT WINAPI dwritefactory_GetGdiInterop(IDWriteFactory7 *iface, IDWriteGdiInterop **gdi_interop)
1193 {
1194     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
1195     HRESULT hr = S_OK;
1196
1197     TRACE("%p, %p.\n", iface, gdi_interop);
1198
1199     if (factory->gdiinterop)
1200         IDWriteGdiInterop1_AddRef(factory->gdiinterop);
1201     else
1202         hr = create_gdiinterop(iface, &factory->gdiinterop);
1203
1204     *gdi_interop = (IDWriteGdiInterop *)factory->gdiinterop;
1205
1206     return hr;
1207 }
1208
1209 static HRESULT WINAPI dwritefactory_CreateTextLayout(IDWriteFactory7 *iface, WCHAR const* string,
1210     UINT32 length, IDWriteTextFormat *format, FLOAT max_width, FLOAT max_height, IDWriteTextLayout **layout)
1211 {
1212     struct textlayout_desc desc;
1213
1214     TRACE("%p, %s:%u, %p, %.8e, %.8e, %p.\n", iface, debugstr_wn(string, length), length, format, max_width, max_height, layout);
1215
1216     desc.factory = iface;
1217     desc.string = string;
1218     desc.length = length;
1219     desc.format = format;
1220     desc.max_width = max_width;
1221     desc.max_height = max_height;
1222     desc.is_gdi_compatible = FALSE;
1223     desc.ppdip = 1.0f;
1224     desc.transform = NULL;
1225     desc.use_gdi_natural = FALSE;
1226     return create_textlayout(&desc, layout);
1227 }
1228
1229 static HRESULT WINAPI dwritefactory_CreateGdiCompatibleTextLayout(IDWriteFactory7 *iface, WCHAR const* string,
1230     UINT32 length, IDWriteTextFormat *format, FLOAT max_width, FLOAT max_height, FLOAT pixels_per_dip,
1231     DWRITE_MATRIX const* transform, BOOL use_gdi_natural, IDWriteTextLayout **layout)
1232 {
1233     struct textlayout_desc desc;
1234
1235     TRACE("%p, %s:%u, %p, %.8e, %.8e, %.8e, %p, %d, %p.\n", iface, debugstr_wn(string, length), length, format,
1236             max_width, max_height, pixels_per_dip, transform, use_gdi_natural, layout);
1237
1238     desc.factory = iface;
1239     desc.string = string;
1240     desc.length = length;
1241     desc.format = format;
1242     desc.max_width = max_width;
1243     desc.max_height = max_height;
1244     desc.is_gdi_compatible = TRUE;
1245     desc.ppdip = pixels_per_dip;
1246     desc.transform = transform;
1247     desc.use_gdi_natural = use_gdi_natural;
1248     return create_textlayout(&desc, layout);
1249 }
1250
1251 static HRESULT WINAPI dwritefactory_CreateEllipsisTrimmingSign(IDWriteFactory7 *iface, IDWriteTextFormat *format,
1252     IDWriteInlineObject **trimming_sign)
1253 {
1254     TRACE("%p, %p, %p.\n", iface, format, trimming_sign);
1255
1256     return create_trimmingsign(iface, format, trimming_sign);
1257 }
1258
1259 static HRESULT WINAPI dwritefactory_CreateTextAnalyzer(IDWriteFactory7 *iface, IDWriteTextAnalyzer **analyzer)
1260 {
1261     TRACE("%p, %p.\n", iface, analyzer);
1262
1263     *analyzer = (IDWriteTextAnalyzer *)get_text_analyzer();
1264
1265     return S_OK;
1266 }
1267
1268 static HRESULT WINAPI dwritefactory_CreateNumberSubstitution(IDWriteFactory7 *iface,
1269         DWRITE_NUMBER_SUBSTITUTION_METHOD method, WCHAR const* locale, BOOL ignore_user_override,
1270         IDWriteNumberSubstitution **substitution)
1271 {
1272     TRACE("%p, %d, %s, %d, %p.\n", iface, method, debugstr_w(locale), ignore_user_override, substitution);
1273
1274     return create_numbersubstitution(method, locale, ignore_user_override, substitution);
1275 }
1276
1277 static inline void dwrite_matrix_multiply(DWRITE_MATRIX *a, const DWRITE_MATRIX *b)
1278 {
1279     DWRITE_MATRIX tmp = *a;
1280
1281     a->m11 = tmp.m11 * b->m11 + tmp.m12 * b->m21;
1282     a->m12 = tmp.m11 * b->m12 + tmp.m12 * b->m22;
1283     a->m21 = tmp.m21 * b->m11 + tmp.m22 * b->m21;
1284     a->m22 = tmp.m21 * b->m12 + tmp.m22 * b->m22;
1285     a->dx = tmp.dx * b->m11 + tmp.dy * b->m21 + b->dx;
1286     a->dy = tmp.dy * b->m12 + tmp.dy * b->m22 + b->dx;
1287 }
1288
1289 static HRESULT WINAPI dwritefactory_CreateGlyphRunAnalysis(IDWriteFactory7 *iface, DWRITE_GLYPH_RUN const *run,
1290     FLOAT ppdip, DWRITE_MATRIX const* transform, DWRITE_RENDERING_MODE rendering_mode,
1291     DWRITE_MEASURING_MODE measuring_mode, FLOAT originX, FLOAT originY, IDWriteGlyphRunAnalysis **analysis)
1292 {
1293     struct glyphrunanalysis_desc desc;
1294     DWRITE_MATRIX m, scale = { 0 };
1295
1296     TRACE("%p, %p, %.8e, %p, %d, %d, %.8e, %.8e, %p.\n", iface, run, ppdip, transform, rendering_mode,
1297         measuring_mode, originX, originY, analysis);
1298
1299     if (ppdip <= 0.0f) {
1300         *analysis = NULL;
1301         return E_INVALIDARG;
1302     }
1303
1304     m = transform ? *transform : identity;
1305     scale.m11 = ppdip;
1306     scale.m22 = ppdip;
1307     dwrite_matrix_multiply(&m, &scale);
1308     desc.run = run;
1309     desc.transform = &m;
1310     desc.rendering_mode = (DWRITE_RENDERING_MODE1)rendering_mode;
1311     desc.measuring_mode = measuring_mode;
1312     desc.gridfit_mode = DWRITE_GRID_FIT_MODE_DEFAULT;
1313     desc.aa_mode = DWRITE_TEXT_ANTIALIAS_MODE_CLEARTYPE;
1314     desc.origin.x = originX;
1315     desc.origin.y = originY;
1316     return create_glyphrunanalysis(&desc, analysis);
1317 }
1318
1319 static HRESULT WINAPI dwritefactory1_GetEudcFontCollection(IDWriteFactory7 *iface, IDWriteFontCollection **collection,
1320     BOOL check_for_updates)
1321 {
1322     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
1323     HRESULT hr = S_OK;
1324
1325     TRACE("%p, %p, %d.\n", iface, collection, check_for_updates);
1326
1327     if (check_for_updates)
1328         FIXME("checking for eudc updates not implemented\n");
1329
1330     if (factory->eudc_collection)
1331         IDWriteFontCollection1_AddRef(factory->eudc_collection);
1332     else {
1333         IDWriteFontCollection3 *eudc_collection;
1334
1335         if (FAILED(hr = get_eudc_fontcollection(iface, &eudc_collection)))
1336         {
1337             *collection = NULL;
1338             WARN("Failed to get EUDC collection, hr %#lx.\n", hr);
1339             return hr;
1340         }
1341
1342         if (InterlockedCompareExchangePointer((void **)&factory->eudc_collection, eudc_collection, NULL))
1343             IDWriteFontCollection3_Release(eudc_collection);
1344     }
1345
1346     *collection = (IDWriteFontCollection *)factory->eudc_collection;
1347
1348     return hr;
1349 }
1350
1351 static HRESULT WINAPI dwritefactory1_CreateCustomRenderingParams(IDWriteFactory7 *iface, FLOAT gamma,
1352     FLOAT enhcontrast, FLOAT enhcontrast_grayscale, FLOAT cleartype_level, DWRITE_PIXEL_GEOMETRY geometry,
1353     DWRITE_RENDERING_MODE mode, IDWriteRenderingParams1** params)
1354 {
1355     IDWriteRenderingParams3 *params3;
1356     HRESULT hr;
1357
1358     TRACE("%p, %.8e, %.8e, %.8e, %.8e, %d, %d, %p.\n", iface, gamma, enhcontrast, enhcontrast_grayscale,
1359         cleartype_level, geometry, mode, params);
1360
1361     if ((UINT32)mode > DWRITE_RENDERING_MODE_OUTLINE) {
1362         *params = NULL;
1363         return E_INVALIDARG;
1364     }
1365
1366     hr = IDWriteFactory7_CreateCustomRenderingParams(iface, gamma, enhcontrast, enhcontrast_grayscale,
1367         cleartype_level, geometry, (DWRITE_RENDERING_MODE1)mode, DWRITE_GRID_FIT_MODE_DEFAULT, &params3);
1368     *params = (IDWriteRenderingParams1*)params3;
1369     return hr;
1370 }
1371
1372 static HRESULT WINAPI dwritefactory2_GetSystemFontFallback(IDWriteFactory7 *iface, IDWriteFontFallback **fallback)
1373 {
1374     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
1375
1376     TRACE("%p, %p.\n", iface, fallback);
1377
1378     *fallback = NULL;
1379
1380     if (!factory->fallback)
1381     {
1382         HRESULT hr = create_system_fontfallback(iface, &factory->fallback);
1383         if (FAILED(hr))
1384             return hr;
1385     }
1386
1387     *fallback = (IDWriteFontFallback *)factory->fallback;
1388     IDWriteFontFallback_AddRef(*fallback);
1389     return S_OK;
1390 }
1391
1392 static HRESULT WINAPI dwritefactory2_CreateFontFallbackBuilder(IDWriteFactory7 *iface,
1393         IDWriteFontFallbackBuilder **fallbackbuilder)
1394 {
1395     TRACE("%p, %p.\n", iface, fallbackbuilder);
1396
1397     return create_fontfallback_builder(iface, fallbackbuilder);
1398 }
1399
1400 static HRESULT WINAPI dwritefactory2_TranslateColorGlyphRun(IDWriteFactory7 *iface, FLOAT originX, FLOAT originY,
1401     const DWRITE_GLYPH_RUN *run, const DWRITE_GLYPH_RUN_DESCRIPTION *run_desc, DWRITE_MEASURING_MODE measuring_mode,
1402     const DWRITE_MATRIX *transform, UINT32 palette, IDWriteColorGlyphRunEnumerator **layers)
1403 {
1404     D2D1_POINT_2F origin = { originX, originY };
1405
1406     TRACE("%p, %.8e, %.8e, %p, %p, %d, %p, %u, %p.\n", iface, originX, originY, run, run_desc, measuring_mode,
1407             transform, palette, layers);
1408
1409     return create_colorglyphenum(origin, run, run_desc, DWRITE_GLYPH_IMAGE_FORMATS_TRUETYPE
1410             | DWRITE_GLYPH_IMAGE_FORMATS_CFF | DWRITE_GLYPH_IMAGE_FORMATS_COLR,
1411             measuring_mode, transform, palette, (IDWriteColorGlyphRunEnumerator1 **)layers);
1412 }
1413
1414 static HRESULT WINAPI dwritefactory2_CreateCustomRenderingParams(IDWriteFactory7 *iface, FLOAT gamma, FLOAT contrast,
1415     FLOAT grayscalecontrast, FLOAT cleartype_level, DWRITE_PIXEL_GEOMETRY geometry, DWRITE_RENDERING_MODE mode,
1416     DWRITE_GRID_FIT_MODE gridfit, IDWriteRenderingParams2 **params)
1417 {
1418     IDWriteRenderingParams3 *params3;
1419     HRESULT hr;
1420
1421     TRACE("%p, %.8e, %.8e, %.8e, %.8e, %d, %d, %d, %p.\n", iface, gamma, contrast, grayscalecontrast, cleartype_level,
1422         geometry, mode, gridfit, params);
1423
1424     if ((UINT32)mode > DWRITE_RENDERING_MODE_OUTLINE) {
1425         *params = NULL;
1426         return E_INVALIDARG;
1427     }
1428
1429     hr = IDWriteFactory7_CreateCustomRenderingParams(iface, gamma, contrast, grayscalecontrast,
1430         cleartype_level, geometry, (DWRITE_RENDERING_MODE1)mode, DWRITE_GRID_FIT_MODE_DEFAULT, &params3);
1431     *params = (IDWriteRenderingParams2*)params3;
1432     return hr;
1433 }
1434
1435 static HRESULT factory_create_glyphrun_analysis(const DWRITE_GLYPH_RUN *run, const DWRITE_MATRIX *transform,
1436     DWRITE_RENDERING_MODE1 rendering_mode, DWRITE_MEASURING_MODE measuring_mode, DWRITE_GRID_FIT_MODE gridfit_mode,
1437     DWRITE_TEXT_ANTIALIAS_MODE aa_mode, FLOAT originX, FLOAT originY, IDWriteGlyphRunAnalysis **analysis)
1438 {
1439     struct glyphrunanalysis_desc desc;
1440
1441     desc.run = run;
1442     desc.transform = transform;
1443     desc.rendering_mode = rendering_mode;
1444     desc.measuring_mode = measuring_mode;
1445     desc.gridfit_mode = gridfit_mode;
1446     desc.aa_mode = aa_mode;
1447     desc.origin.x = originX;
1448     desc.origin.y = originY;
1449     return create_glyphrunanalysis(&desc, analysis);
1450 }
1451
1452 static HRESULT WINAPI dwritefactory2_CreateGlyphRunAnalysis(IDWriteFactory7 *iface, const DWRITE_GLYPH_RUN *run,
1453     const DWRITE_MATRIX *transform, DWRITE_RENDERING_MODE rendering_mode, DWRITE_MEASURING_MODE measuring_mode,
1454     DWRITE_GRID_FIT_MODE gridfit_mode, DWRITE_TEXT_ANTIALIAS_MODE aa_mode, FLOAT originX, FLOAT originY,
1455     IDWriteGlyphRunAnalysis **analysis)
1456 {
1457     TRACE("%p, %p, %p, %d, %d, %d, %d, %.8e, %.8e, %p.\n", iface, run, transform, rendering_mode, measuring_mode,
1458         gridfit_mode, aa_mode, originX, originY, analysis);
1459
1460     return factory_create_glyphrun_analysis(run, transform, (DWRITE_RENDERING_MODE1)rendering_mode, measuring_mode,
1461         gridfit_mode, aa_mode, originX, originY, analysis);
1462 }
1463
1464 static HRESULT WINAPI dwritefactory3_CreateGlyphRunAnalysis(IDWriteFactory7 *iface, DWRITE_GLYPH_RUN const *run,
1465     DWRITE_MATRIX const *transform, DWRITE_RENDERING_MODE1 rendering_mode, DWRITE_MEASURING_MODE measuring_mode,
1466     DWRITE_GRID_FIT_MODE gridfit_mode, DWRITE_TEXT_ANTIALIAS_MODE aa_mode, FLOAT originX, FLOAT originY,
1467     IDWriteGlyphRunAnalysis **analysis)
1468 {
1469     TRACE("%p, %p, %p, %d, %d, %d, %d, %.8e, %.8e, %p.\n", iface, run, transform, rendering_mode, measuring_mode,
1470         gridfit_mode, aa_mode, originX, originY, analysis);
1471
1472     return factory_create_glyphrun_analysis(run, transform, rendering_mode, measuring_mode, gridfit_mode,
1473         aa_mode, originX, originY, analysis);
1474 }
1475
1476 static HRESULT WINAPI dwritefactory3_CreateCustomRenderingParams(IDWriteFactory7 *iface, FLOAT gamma, FLOAT contrast,
1477         FLOAT grayscale_contrast, FLOAT cleartype_level, DWRITE_PIXEL_GEOMETRY pixel_geometry,
1478         DWRITE_RENDERING_MODE1 rendering_mode, DWRITE_GRID_FIT_MODE gridfit_mode, IDWriteRenderingParams3 **params)
1479 {
1480     TRACE("%p, %.8e, %.8e, %.8e, %.8e, %d, %d, %d, %p.\n", iface, gamma, contrast, grayscale_contrast, cleartype_level,
1481         pixel_geometry, rendering_mode, gridfit_mode, params);
1482
1483     return create_renderingparams(gamma, contrast, grayscale_contrast, cleartype_level, pixel_geometry, rendering_mode,
1484         gridfit_mode, params);
1485 }
1486
1487 static HRESULT WINAPI dwritefactory3_CreateFontFaceReference_(IDWriteFactory7 *iface, IDWriteFontFile *file,
1488         UINT32 index, DWRITE_FONT_SIMULATIONS simulations, IDWriteFontFaceReference **reference)
1489 {
1490     TRACE("%p, %p, %u, %x, %p.\n", iface, file, index, simulations, reference);
1491
1492     return create_fontfacereference(iface, file, index, simulations, NULL, 0, (IDWriteFontFaceReference1 **)reference);
1493 }
1494
1495 static HRESULT WINAPI dwritefactory3_CreateFontFaceReference(IDWriteFactory7 *iface, WCHAR const *path,
1496         FILETIME const *writetime, UINT32 index, DWRITE_FONT_SIMULATIONS simulations,
1497         IDWriteFontFaceReference **reference)
1498 {
1499     IDWriteFontFile *file;
1500     HRESULT hr;
1501
1502     TRACE("%p, %s, %p, %u, %#x, %p.\n", iface, debugstr_w(path), writetime, index, simulations, reference);
1503
1504     hr = IDWriteFactory7_CreateFontFileReference(iface, path, writetime, &file);
1505     if (FAILED(hr))
1506     {
1507         *reference = NULL;
1508         return hr;
1509     }
1510
1511     hr = create_fontfacereference(iface, file, index, simulations, NULL, 0, (IDWriteFontFaceReference1 **)reference);
1512     IDWriteFontFile_Release(file);
1513     return hr;
1514 }
1515
1516 static HRESULT create_system_path_list(WCHAR ***ret, unsigned int *ret_count)
1517 {
1518     unsigned int index = 0, value_size, max_name_count;
1519     WCHAR **paths = NULL, *name, *value = NULL;
1520     DWORD name_count, type, data_size;
1521     size_t capacity = 0, count = 0;
1522     HKEY hkey;
1523     LONG r;
1524
1525     if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts",
1526             0, GENERIC_READ, &hkey))
1527     {
1528         return E_UNEXPECTED;
1529     }
1530
1531     value_size = MAX_PATH * sizeof(*value);
1532     value = malloc(value_size);
1533
1534     max_name_count = MAX_PATH;
1535     name = malloc(max_name_count * sizeof(*name));
1536
1537     for (;;)
1538     {
1539         if (!value)
1540         {
1541             value_size = MAX_PATH * sizeof(*value);
1542             value = malloc(value_size);
1543         }
1544
1545         do
1546         {
1547             name_count = max_name_count;
1548             data_size = value_size - sizeof(*value);
1549
1550             r = RegEnumValueW(hkey, index, name, &name_count, NULL, &type, (BYTE *)value, &data_size);
1551             if (r == ERROR_MORE_DATA)
1552             {
1553                 if (name_count >= max_name_count)
1554                 {
1555                     max_name_count *= 2;
1556                     free(name);
1557                     name = malloc(max_name_count * sizeof(*name));
1558                 }
1559
1560                 if (data_size > value_size - sizeof(*value))
1561                 {
1562                     free(value);
1563                     value_size = max(data_size + sizeof(*value), value_size * 2);
1564                     value = malloc(value_size);
1565                 }
1566             }
1567         } while (r == ERROR_MORE_DATA);
1568
1569         if (r != ERROR_SUCCESS)
1570             break;
1571
1572         value[data_size / sizeof(*value)] = 0;
1573         if (type == REG_SZ && *name != '@')
1574         {
1575             if (dwrite_array_reserve((void **)&paths, &capacity, count + 1, sizeof(*paths)))
1576             {
1577                 if (!wcschr(value, '\\'))
1578                 {
1579                     WCHAR *ptrW;
1580
1581                     ptrW = malloc((MAX_PATH + wcslen(value)) * sizeof(WCHAR));
1582                     GetWindowsDirectoryW(ptrW, MAX_PATH);
1583                     wcscat(ptrW, L"\\fonts\\");
1584                     wcscat(ptrW, value);
1585
1586                     free(value);
1587                     value = ptrW;
1588                 }
1589
1590                 paths[count++] = value;
1591                 value = NULL;
1592             }
1593         }
1594         index++;
1595     }
1596
1597     free(value);
1598     free(name);
1599
1600     *ret = paths;
1601     *ret_count = count;
1602
1603     RegCloseKey(hkey);
1604
1605     return S_OK;
1606 }
1607
1608 static int __cdecl create_system_fontset_compare(const void *left, const void *right)
1609 {
1610     const WCHAR *_l = *(WCHAR **)left, *_r = *(WCHAR **)right;
1611     return wcsicmp(_l, _r);
1612 };
1613
1614 static HRESULT create_system_fontset(IDWriteFactory7 *factory, REFIID riid, void **obj)
1615 {
1616     IDWriteFontSetBuilder2 *builder;
1617     IDWriteFontSet *fontset;
1618     unsigned int i, j, count;
1619     WCHAR **paths;
1620     HRESULT hr;
1621
1622     *obj = NULL;
1623
1624     if (FAILED(hr = create_fontset_builder(factory, &builder))) return hr;
1625
1626     if (SUCCEEDED(hr = create_system_path_list(&paths, &count)))
1627     {
1628         /* Sort, skip duplicates. */
1629
1630         qsort(paths, count, sizeof(*paths), create_system_fontset_compare);
1631
1632         for (i = 0, j = 0; i < count; ++i)
1633         {
1634             if (i != j && !wcsicmp(paths[i], paths[j])) continue;
1635
1636             if (FAILED(hr = IDWriteFontSetBuilder2_AddFontFile(builder, paths[i])) && hr != DWRITE_E_FILEFORMAT)
1637                 WARN("Failed to add font file, hr %#lx, path %s.\n", hr, debugstr_w(paths[i]));
1638
1639             j = i;
1640         }
1641
1642         for (i = 0; i < count; ++i)
1643             free(paths[i]);
1644         free(paths);
1645     }
1646
1647     if (SUCCEEDED(hr = IDWriteFontSetBuilder2_CreateFontSet(builder, &fontset)))
1648     {
1649         hr = IDWriteFontSet_QueryInterface(fontset, riid, obj);
1650         IDWriteFontSet_Release(fontset);
1651     }
1652
1653     IDWriteFontSetBuilder2_Release(builder);
1654
1655     return hr;
1656 }
1657
1658 static HRESULT WINAPI dwritefactory3_GetSystemFontSet(IDWriteFactory7 *iface, IDWriteFontSet **fontset)
1659 {
1660     TRACE("%p, %p.\n", iface, fontset);
1661
1662     return create_system_fontset(iface, &IID_IDWriteFontSet, (void **)fontset);
1663 }
1664
1665 static HRESULT WINAPI dwritefactory3_CreateFontSetBuilder(IDWriteFactory7 *iface, IDWriteFontSetBuilder **builder)
1666 {
1667     TRACE("%p, %p.\n", iface, builder);
1668
1669     return create_fontset_builder(iface, (IDWriteFontSetBuilder2 **)builder);
1670 }
1671
1672 static HRESULT WINAPI dwritefactory3_CreateFontCollectionFromFontSet(IDWriteFactory7 *iface, IDWriteFontSet *fontset,
1673     IDWriteFontCollection1 **collection)
1674 {
1675     FIXME("%p, %p, %p: stub\n", iface, fontset, collection);
1676
1677     return E_NOTIMPL;
1678 }
1679
1680 static HRESULT WINAPI dwritefactory3_GetSystemFontCollection(IDWriteFactory7 *iface, BOOL include_downloadable,
1681     IDWriteFontCollection1 **collection, BOOL check_for_updates)
1682 {
1683     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
1684
1685     TRACE("%p, %d, %p, %d.\n", iface, include_downloadable, collection, check_for_updates);
1686
1687     if (include_downloadable)
1688         FIXME("remote fonts are not supported\n");
1689
1690     if (check_for_updates)
1691         FIXME("checking for system font updates not implemented\n");
1692
1693     *collection = factory_get_system_collection(factory);
1694
1695     return *collection ? S_OK : E_FAIL;
1696 }
1697
1698 static HRESULT WINAPI dwritefactory3_GetFontDownloadQueue(IDWriteFactory7 *iface, IDWriteFontDownloadQueue **queue)
1699 {
1700     FIXME("%p, %p: stub\n", iface, queue);
1701
1702     return E_NOTIMPL;
1703 }
1704
1705 static HRESULT WINAPI dwritefactory4_TranslateColorGlyphRun(IDWriteFactory7 *iface, D2D1_POINT_2F origin,
1706         DWRITE_GLYPH_RUN const *run, DWRITE_GLYPH_RUN_DESCRIPTION const *run_desc,
1707         DWRITE_GLYPH_IMAGE_FORMATS desired_formats, DWRITE_MEASURING_MODE measuring_mode, DWRITE_MATRIX const *transform,
1708         UINT32 palette, IDWriteColorGlyphRunEnumerator1 **layers)
1709 {
1710     TRACE("%p, %.8e, %.8e, %p, %p, %u, %d, %p, %u, %p.\n", iface, origin.x, origin.y, run, run_desc, desired_formats,
1711             measuring_mode, transform, palette, layers);
1712
1713     return create_colorglyphenum(origin, run, run_desc, desired_formats, measuring_mode, transform, palette, layers);
1714 }
1715
1716 HRESULT compute_glyph_origins(DWRITE_GLYPH_RUN const *run, DWRITE_MEASURING_MODE measuring_mode,
1717     D2D1_POINT_2F baseline_origin, DWRITE_MATRIX const *transform, D2D1_POINT_2F *origins)
1718 {
1719     struct dwrite_fontface *font_obj;
1720     unsigned int i;
1721     float advance;
1722
1723     font_obj = unsafe_impl_from_IDWriteFontFace(run->fontFace);
1724
1725     for (i = 0; i < run->glyphCount; ++i)
1726     {
1727         origins[i] = baseline_origin;
1728
1729         if (run->bidiLevel & 1)
1730         {
1731             advance = fontface_get_scaled_design_advance(font_obj, measuring_mode, run->fontEmSize,
1732                     1.0f, transform, run->glyphIndices[i], run->isSideways);
1733
1734             origins[i].x -= advance;
1735
1736             if (run->glyphOffsets)
1737             {
1738                 origins[i].x -= run->glyphOffsets[i].advanceOffset;
1739                 origins[i].y -= run->glyphOffsets[i].ascenderOffset;
1740             }
1741
1742             baseline_origin.x -= run->glyphAdvances ? run->glyphAdvances[i] : advance;
1743         }
1744         else
1745         {
1746             if (run->glyphOffsets)
1747             {
1748                 origins[i].x += run->glyphOffsets[i].advanceOffset;
1749                 origins[i].y -= run->glyphOffsets[i].ascenderOffset;
1750             }
1751
1752             baseline_origin.x += run->glyphAdvances ? run->glyphAdvances[i] :
1753                     fontface_get_scaled_design_advance(font_obj, measuring_mode, run->fontEmSize, 1.0f, transform,
1754                             run->glyphIndices[i], run->isSideways);
1755
1756         }
1757     }
1758
1759     return S_OK;
1760 }
1761
1762 static HRESULT WINAPI dwritefactory4_ComputeGlyphOrigins_(IDWriteFactory7 *iface, DWRITE_GLYPH_RUN const *run,
1763     D2D1_POINT_2F baseline_origin, D2D1_POINT_2F *origins)
1764 {
1765     TRACE("%p, %p, {%.8e,%.8e}, %p.\n", iface, run, baseline_origin.x, baseline_origin.y, origins);
1766
1767     return compute_glyph_origins(run, DWRITE_MEASURING_MODE_NATURAL, baseline_origin, NULL, origins);
1768 }
1769
1770 static HRESULT WINAPI dwritefactory4_ComputeGlyphOrigins(IDWriteFactory7 *iface, DWRITE_GLYPH_RUN const *run,
1771     DWRITE_MEASURING_MODE measuring_mode, D2D1_POINT_2F baseline_origin, DWRITE_MATRIX const *transform,
1772     D2D1_POINT_2F *origins)
1773 {
1774     TRACE("%p, %p, %d, {%.8e,%.8e}, %p, %p.\n", iface, run, measuring_mode, baseline_origin.x, baseline_origin.y,
1775         transform, origins);
1776
1777     return compute_glyph_origins(run, measuring_mode, baseline_origin, transform, origins);
1778 }
1779
1780 static HRESULT WINAPI dwritefactory5_CreateFontSetBuilder(IDWriteFactory7 *iface, IDWriteFontSetBuilder1 **builder)
1781 {
1782     TRACE("%p, %p.\n", iface, builder);
1783
1784     return create_fontset_builder(iface, (IDWriteFontSetBuilder2 **)builder);
1785 }
1786
1787 static HRESULT WINAPI dwritefactory5_CreateInMemoryFontFileLoader(IDWriteFactory7 *iface,
1788         IDWriteInMemoryFontFileLoader **loader)
1789 {
1790     TRACE("%p, %p.\n", iface, loader);
1791
1792     return create_inmemory_fileloader(loader);
1793 }
1794
1795 static HRESULT WINAPI dwritefactory5_CreateHttpFontFileLoader(IDWriteFactory7 *iface, WCHAR const *referrer_url,
1796         WCHAR const *extra_headers, IDWriteRemoteFontFileLoader **loader)
1797 {
1798     FIXME("%p, %s, %s, %p: stub\n", iface, debugstr_w(referrer_url), wine_dbgstr_w(extra_headers), loader);
1799
1800     return E_NOTIMPL;
1801 }
1802
1803 static DWRITE_CONTAINER_TYPE WINAPI dwritefactory5_AnalyzeContainerType(IDWriteFactory7 *iface, void const *data,
1804         UINT32 data_size)
1805 {
1806     TRACE("%p, %p, %u.\n", iface, data, data_size);
1807
1808     return opentype_analyze_container_type(data, data_size);
1809 }
1810
1811 static HRESULT WINAPI dwritefactory5_UnpackFontFile(IDWriteFactory7 *iface, DWRITE_CONTAINER_TYPE container_type, void const *data,
1812         UINT32 data_size, IDWriteFontFileStream **stream)
1813 {
1814     FIXME("%p, %d, %p, %u, %p: stub\n", iface, container_type, data, data_size, stream);
1815
1816     return E_NOTIMPL;
1817 }
1818
1819 static HRESULT WINAPI dwritefactory6_CreateFontFaceReference(IDWriteFactory7 *iface, IDWriteFontFile *file,
1820         UINT32 face_index, DWRITE_FONT_SIMULATIONS simulations, DWRITE_FONT_AXIS_VALUE const *axis_values,
1821         UINT32 axis_values_count, IDWriteFontFaceReference1 **reference)
1822 {
1823     TRACE("%p, %p, %u, %#x, %p, %u, %p.\n", iface, file, face_index, simulations, axis_values, axis_values_count,
1824             reference);
1825
1826     return create_fontfacereference(iface, file, face_index, simulations, axis_values, axis_values_count, reference);
1827 }
1828
1829 static HRESULT WINAPI dwritefactory6_CreateFontResource(IDWriteFactory7 *iface, IDWriteFontFile *file,
1830         UINT32 face_index, IDWriteFontResource **resource)
1831 {
1832     TRACE("%p, %p, %u, %p.\n", iface, file, face_index, resource);
1833
1834     return create_font_resource(iface, file, face_index, resource);
1835 }
1836
1837 static HRESULT WINAPI dwritefactory6_GetSystemFontSet(IDWriteFactory7 *iface, BOOL include_downloadable,
1838         IDWriteFontSet1 **fontset)
1839 {
1840     TRACE("%p, %d, %p.\n", iface, include_downloadable, fontset);
1841
1842     if (include_downloadable)
1843         FIXME("Downloadable fonts are not supported.\n");
1844
1845     return create_system_fontset(iface, &IID_IDWriteFontSet1, (void **)fontset);
1846 }
1847
1848 static HRESULT WINAPI dwritefactory6_GetSystemFontCollection(IDWriteFactory7 *iface, BOOL include_downloadable,
1849         DWRITE_FONT_FAMILY_MODEL family_model, IDWriteFontCollection2 **collection)
1850 {
1851     FIXME("%p, %d, %d, %p.\n", iface, include_downloadable, family_model, collection);
1852
1853     return E_NOTIMPL;
1854 }
1855
1856 static HRESULT WINAPI dwritefactory6_CreateFontCollectionFromFontSet(IDWriteFactory7 *iface, IDWriteFontSet *fontset,
1857         DWRITE_FONT_FAMILY_MODEL family_model, IDWriteFontCollection2 **collection)
1858 {
1859     FIXME("%p, %p, %d, %p.\n", iface, fontset, family_model, collection);
1860
1861     return E_NOTIMPL;
1862 }
1863
1864 static HRESULT WINAPI dwritefactory6_CreateFontSetBuilder(IDWriteFactory7 *iface, IDWriteFontSetBuilder2 **builder)
1865 {
1866     TRACE("%p, %p.\n", iface, builder);
1867
1868     return create_fontset_builder(iface, builder);
1869 }
1870
1871 static HRESULT WINAPI dwritefactory6_CreateTextFormat(IDWriteFactory7 *iface, const WCHAR *familyname,
1872         IDWriteFontCollection *collection, DWRITE_FONT_AXIS_VALUE const *axis_values, UINT32 num_axis,
1873         FLOAT fontsize, const WCHAR *localename, IDWriteTextFormat3 **format)
1874 {
1875     FIXME("%p, %s, %p, %p, %u, %.8e, %s, %p.\n", iface, debugstr_w(familyname), collection, axis_values, num_axis,
1876             fontsize, debugstr_w(localename), format);
1877
1878     return E_NOTIMPL;
1879 }
1880
1881 static HRESULT WINAPI dwritefactory7_GetSystemFontSet(IDWriteFactory7 *iface, BOOL include_downloadable,
1882         IDWriteFontSet2 **fontset)
1883 {
1884     TRACE("%p, %d, %p.\n", iface, include_downloadable, fontset);
1885
1886     if (include_downloadable)
1887         FIXME("Downloadable fonts are not supported.\n");
1888
1889     return create_system_fontset(iface, &IID_IDWriteFontSet2, (void **)fontset);
1890 }
1891
1892 static HRESULT WINAPI dwritefactory7_GetSystemFontCollection(IDWriteFactory7 *iface, BOOL include_downloadable,
1893         DWRITE_FONT_FAMILY_MODEL family_model, IDWriteFontCollection3 **collection)
1894 {
1895     FIXME("%p, %d, %d, %p.\n", iface, include_downloadable, family_model, collection);
1896
1897     return E_NOTIMPL;
1898 }
1899
1900 static const IDWriteFactory7Vtbl dwritefactoryvtbl =
1901 {
1902     dwritefactory_QueryInterface,
1903     dwritefactory_AddRef,
1904     dwritefactory_Release,
1905     dwritefactory_GetSystemFontCollection,
1906     dwritefactory_CreateCustomFontCollection,
1907     dwritefactory_RegisterFontCollectionLoader,
1908     dwritefactory_UnregisterFontCollectionLoader,
1909     dwritefactory_CreateFontFileReference,
1910     dwritefactory_CreateCustomFontFileReference,
1911     dwritefactory_CreateFontFace,
1912     dwritefactory_CreateRenderingParams,
1913     dwritefactory_CreateMonitorRenderingParams,
1914     dwritefactory_CreateCustomRenderingParams,
1915     dwritefactory_RegisterFontFileLoader,
1916     dwritefactory_UnregisterFontFileLoader,
1917     dwritefactory_CreateTextFormat,
1918     dwritefactory_CreateTypography,
1919     dwritefactory_GetGdiInterop,
1920     dwritefactory_CreateTextLayout,
1921     dwritefactory_CreateGdiCompatibleTextLayout,
1922     dwritefactory_CreateEllipsisTrimmingSign,
1923     dwritefactory_CreateTextAnalyzer,
1924     dwritefactory_CreateNumberSubstitution,
1925     dwritefactory_CreateGlyphRunAnalysis,
1926     dwritefactory1_GetEudcFontCollection,
1927     dwritefactory1_CreateCustomRenderingParams,
1928     dwritefactory2_GetSystemFontFallback,
1929     dwritefactory2_CreateFontFallbackBuilder,
1930     dwritefactory2_TranslateColorGlyphRun,
1931     dwritefactory2_CreateCustomRenderingParams,
1932     dwritefactory2_CreateGlyphRunAnalysis,
1933     dwritefactory3_CreateGlyphRunAnalysis,
1934     dwritefactory3_CreateCustomRenderingParams,
1935     dwritefactory3_CreateFontFaceReference_,
1936     dwritefactory3_CreateFontFaceReference,
1937     dwritefactory3_GetSystemFontSet,
1938     dwritefactory3_CreateFontSetBuilder,
1939     dwritefactory3_CreateFontCollectionFromFontSet,
1940     dwritefactory3_GetSystemFontCollection,
1941     dwritefactory3_GetFontDownloadQueue,
1942     dwritefactory4_TranslateColorGlyphRun,
1943     dwritefactory4_ComputeGlyphOrigins_,
1944     dwritefactory4_ComputeGlyphOrigins,
1945     dwritefactory5_CreateFontSetBuilder,
1946     dwritefactory5_CreateInMemoryFontFileLoader,
1947     dwritefactory5_CreateHttpFontFileLoader,
1948     dwritefactory5_AnalyzeContainerType,
1949     dwritefactory5_UnpackFontFile,
1950     dwritefactory6_CreateFontFaceReference,
1951     dwritefactory6_CreateFontResource,
1952     dwritefactory6_GetSystemFontSet,
1953     dwritefactory6_GetSystemFontCollection,
1954     dwritefactory6_CreateFontCollectionFromFontSet,
1955     dwritefactory6_CreateFontSetBuilder,
1956     dwritefactory6_CreateTextFormat,
1957     dwritefactory7_GetSystemFontSet,
1958     dwritefactory7_GetSystemFontCollection,
1959 };
1960
1961 static ULONG WINAPI shareddwritefactory_AddRef(IDWriteFactory7 *iface)
1962 {
1963     TRACE("%p.\n", iface);
1964
1965     return 2;
1966 }
1967
1968 static ULONG WINAPI shareddwritefactory_Release(IDWriteFactory7 *iface)
1969 {
1970     TRACE("%p.\n", iface);
1971
1972     return 1;
1973 }
1974
1975 static const IDWriteFactory7Vtbl shareddwritefactoryvtbl =
1976 {
1977     dwritefactory_QueryInterface,
1978     shareddwritefactory_AddRef,
1979     shareddwritefactory_Release,
1980     dwritefactory_GetSystemFontCollection,
1981     dwritefactory_CreateCustomFontCollection,
1982     dwritefactory_RegisterFontCollectionLoader,
1983     dwritefactory_UnregisterFontCollectionLoader,
1984     dwritefactory_CreateFontFileReference,
1985     dwritefactory_CreateCustomFontFileReference,
1986     dwritefactory_CreateFontFace,
1987     dwritefactory_CreateRenderingParams,
1988     dwritefactory_CreateMonitorRenderingParams,
1989     dwritefactory_CreateCustomRenderingParams,
1990     dwritefactory_RegisterFontFileLoader,
1991     dwritefactory_UnregisterFontFileLoader,
1992     dwritefactory_CreateTextFormat,
1993     dwritefactory_CreateTypography,
1994     dwritefactory_GetGdiInterop,
1995     dwritefactory_CreateTextLayout,
1996     dwritefactory_CreateGdiCompatibleTextLayout,
1997     dwritefactory_CreateEllipsisTrimmingSign,
1998     dwritefactory_CreateTextAnalyzer,
1999     dwritefactory_CreateNumberSubstitution,
2000     dwritefactory_CreateGlyphRunAnalysis,
2001     dwritefactory1_GetEudcFontCollection,
2002     dwritefactory1_CreateCustomRenderingParams,
2003     dwritefactory2_GetSystemFontFallback,
2004     dwritefactory2_CreateFontFallbackBuilder,
2005     dwritefactory2_TranslateColorGlyphRun,
2006     dwritefactory2_CreateCustomRenderingParams,
2007     dwritefactory2_CreateGlyphRunAnalysis,
2008     dwritefactory3_CreateGlyphRunAnalysis,
2009     dwritefactory3_CreateCustomRenderingParams,
2010     dwritefactory3_CreateFontFaceReference_,
2011     dwritefactory3_CreateFontFaceReference,
2012     dwritefactory3_GetSystemFontSet,
2013     dwritefactory3_CreateFontSetBuilder,
2014     dwritefactory3_CreateFontCollectionFromFontSet,
2015     dwritefactory3_GetSystemFontCollection,
2016     dwritefactory3_GetFontDownloadQueue,
2017     dwritefactory4_TranslateColorGlyphRun,
2018     dwritefactory4_ComputeGlyphOrigins_,
2019     dwritefactory4_ComputeGlyphOrigins,
2020     dwritefactory5_CreateFontSetBuilder,
2021     dwritefactory5_CreateInMemoryFontFileLoader,
2022     dwritefactory5_CreateHttpFontFileLoader,
2023     dwritefactory5_AnalyzeContainerType,
2024     dwritefactory5_UnpackFontFile,
2025     dwritefactory6_CreateFontFaceReference,
2026     dwritefactory6_CreateFontResource,
2027     dwritefactory6_GetSystemFontSet,
2028     dwritefactory6_GetSystemFontCollection,
2029     dwritefactory6_CreateFontCollectionFromFontSet,
2030     dwritefactory6_CreateFontSetBuilder,
2031     dwritefactory6_CreateTextFormat,
2032     dwritefactory7_GetSystemFontSet,
2033     dwritefactory7_GetSystemFontCollection,
2034 };
2035
2036 static void init_dwritefactory(struct dwritefactory *factory, DWRITE_FACTORY_TYPE type)
2037 {
2038     factory->IDWriteFactory7_iface.lpVtbl = type == DWRITE_FACTORY_TYPE_SHARED ?
2039             &shareddwritefactoryvtbl : &dwritefactoryvtbl;
2040     factory->refcount = 1;
2041     factory->localfontfileloader = get_local_fontfile_loader();
2042     factory->system_collection = NULL;
2043     factory->eudc_collection = NULL;
2044     factory->gdiinterop = NULL;
2045     factory->fallback = NULL;
2046
2047     list_init(&factory->collection_loaders);
2048     list_init(&factory->file_loaders);
2049     list_init(&factory->localfontfaces);
2050
2051     InitializeCriticalSection(&factory->cs);
2052     factory->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": dwritefactory.lock");
2053 }
2054
2055 void factory_detach_fontcollection(IDWriteFactory7 *iface, IDWriteFontCollection3 *collection)
2056 {
2057     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
2058     InterlockedCompareExchangePointer((void **)&factory->system_collection, NULL, collection);
2059     InterlockedCompareExchangePointer((void **)&factory->eudc_collection, NULL, collection);
2060     IDWriteFactory7_Release(iface);
2061 }
2062
2063 void factory_detach_gdiinterop(IDWriteFactory7 *iface, IDWriteGdiInterop1 *interop)
2064 {
2065     struct dwritefactory *factory = impl_from_IDWriteFactory7(iface);
2066     factory->gdiinterop = NULL;
2067     IDWriteFactory7_Release(iface);
2068 }
2069
2070 HRESULT WINAPI DWriteCreateFactory(DWRITE_FACTORY_TYPE type, REFIID riid, IUnknown **ret)
2071 {
2072     struct dwritefactory *factory;
2073     HRESULT hr;
2074
2075     TRACE("%d, %s, %p.\n", type, debugstr_guid(riid), ret);
2076
2077     *ret = NULL;
2078
2079     if (type == DWRITE_FACTORY_TYPE_SHARED && shared_factory)
2080         return IDWriteFactory7_QueryInterface(shared_factory, riid, (void**)ret);
2081
2082     if (!(factory = calloc(1, sizeof(*factory))))
2083         return E_OUTOFMEMORY;
2084
2085     init_dwritefactory(factory, type);
2086
2087     if (type == DWRITE_FACTORY_TYPE_SHARED)
2088         if (InterlockedCompareExchangePointer((void **)&shared_factory, &factory->IDWriteFactory7_iface, NULL))
2089         {
2090             release_shared_factory(&factory->IDWriteFactory7_iface);
2091             return IDWriteFactory7_QueryInterface(shared_factory, riid, (void**)ret);
2092         }
2093
2094     hr = IDWriteFactory7_QueryInterface(&factory->IDWriteFactory7_iface, riid, (void**)ret);
2095     IDWriteFactory7_Release(&factory->IDWriteFactory7_iface);
2096     return hr;
2097 }