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