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