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