dlls/dwrite/font.c

   1 /*
   2  *    Font and collections
   3  *
   4  * Copyright 2011 Huw Davies
   5  * Copyright 2012, 2014-2017 Nikolay Sivov for CodeWeavers
   6  * Copyright 2014 Aric Stewart for CodeWeavers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <assert.h>
  24 #include <math.h>
  25
  26 #define COBJMACROS
  27
  28 #include "dwrite_private.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(dwrite);
  31 WINE_DECLARE_DEBUG_CHANNEL(dwrite_file);
  32
  33 #define MS_HEAD_TAG DWRITE_MAKE_OPENTYPE_TAG('h','e','a','d')
  34 #define MS_OS2_TAG  DWRITE_MAKE_OPENTYPE_TAG('O','S','/','2')
  35 #define MS_CMAP_TAG DWRITE_MAKE_OPENTYPE_TAG('c','m','a','p')
  36 #define MS_NAME_TAG DWRITE_MAKE_OPENTYPE_TAG('n','a','m','e')
  37 #define MS_VDMX_TAG DWRITE_MAKE_OPENTYPE_TAG('V','D','M','X')
  38 #define MS_GASP_TAG DWRITE_MAKE_OPENTYPE_TAG('g','a','s','p')
  39 #define MS_CPAL_TAG DWRITE_MAKE_OPENTYPE_TAG('C','P','A','L')
  40 #define MS_COLR_TAG DWRITE_MAKE_OPENTYPE_TAG('C','O','L','R')
  41
  42 static const IID IID_issystemcollection = {0x14d88047,0x331f,0x4cd3,{0xbc,0xa8,0x3e,0x67,0x99,0xaf,0x34,0x75}};
  43
  44 static const FLOAT RECOMMENDED_OUTLINE_AA_THRESHOLD = 100.0f;
  45 static const FLOAT RECOMMENDED_OUTLINE_A_THRESHOLD = 350.0f;
  46 static const FLOAT RECOMMENDED_NATURAL_PPEM = 20.0f;
  47
  48 static const struct font_backend_funcs *font_funcs;
  49
  50 void dwrite_fontface_get_glyph_bbox(struct dwrite_glyphbitmap *bitmap)
  51 {
  52     font_funcs->get_glyph_bbox(bitmap);
  53 }
  54
  55 struct dwrite_font_propvec {
  56     FLOAT stretch;
  57     FLOAT style;
  58     FLOAT weight;
  59 };
  60
  61 struct dwrite_font_data
  62 {
  63     LONG refcount;
  64
  65     DWRITE_FONT_STYLE style;
  66     DWRITE_FONT_STRETCH stretch;
  67     DWRITE_FONT_WEIGHT weight;
  68     DWRITE_PANOSE panose;
  69     FONTSIGNATURE fontsig;
  70     UINT32 flags; /* enum font_flags */
  71     struct dwrite_font_propvec propvec;
  72     struct dwrite_cmap cmap;
  73     /* Static axis for weight/width/italic. */
  74     DWRITE_FONT_AXIS_VALUE axis[3];
  75
  76     DWRITE_FONT_METRICS1 metrics;
  77     IDWriteLocalizedStrings *info_strings[DWRITE_INFORMATIONAL_STRING_SUPPORTED_SCRIPT_LANGUAGE_TAG + 1];
  78     IDWriteLocalizedStrings *family_names;
  79     IDWriteLocalizedStrings *names;
  80
  81     /* data needed to create fontface instance */
  82     DWRITE_FONT_FACE_TYPE face_type;
  83     IDWriteFontFile *file;
  84     UINT32 face_index;
  85
  86     WCHAR *facename;
  87
  88     USHORT simulations;
  89
  90     LOGFONTW lf;
  91
  92     /* used to mark font as tested when scanning for simulation candidate */
  93     unsigned int bold_sim_tested : 1;
  94     unsigned int oblique_sim_tested : 1;
  95 };
  96
  97 struct dwrite_fontfamily_data
  98 {
  99     LONG refcount;
 100
 101     IDWriteLocalizedStrings *familyname;
 102
 103     struct dwrite_font_data **fonts;
 104     size_t size;
 105     size_t count;
 106
 107     unsigned int has_normal_face : 1;
 108     unsigned int has_oblique_face : 1;
 109     unsigned int has_italic_face : 1;
 110 };
 111
 112 struct dwrite_fontcollection
 113 {
 114     IDWriteFontCollection3 IDWriteFontCollection3_iface;
 115     LONG refcount;
 116
 117     IDWriteFactory7 *factory;
 118     struct dwrite_fontfamily_data **family_data;
 119     size_t size;
 120     size_t count;
 121 };
 122
 123 struct dwrite_fontfamily
 124 {
 125     IDWriteFontFamily2 IDWriteFontFamily2_iface;
 126     IDWriteFontList2 IDWriteFontList2_iface;
 127     LONG refcount;
 128
 129     struct dwrite_fontfamily_data *data;
 130     struct dwrite_fontcollection *collection;
 131 };
 132
 133 struct dwrite_fontlist
 134 {
 135     IDWriteFontList2 IDWriteFontList2_iface;
 136     LONG refcount;
 137
 138     struct dwrite_font_data **fonts;
 139     UINT32 font_count;
 140     struct dwrite_fontfamily *family;
 141 };
 142
 143 struct dwrite_font
 144 {
 145     IDWriteFont3 IDWriteFont3_iface;
 146     LONG refcount;
 147
 148     DWRITE_FONT_STYLE style;
 149     struct dwrite_font_data *data;
 150     struct dwrite_fontfamily *family;
 151 };
 152
 153 enum runanalysis_flags {
 154     RUNANALYSIS_BOUNDS_READY  = 1 << 0,
 155     RUNANALYSIS_BITMAP_READY  = 1 << 1,
 156     RUNANALYSIS_USE_TRANSFORM = 1 << 2
 157 };
 158
 159 struct dwrite_glyphrunanalysis
 160 {
 161     IDWriteGlyphRunAnalysis IDWriteGlyphRunAnalysis_iface;
 162     LONG refcount;
 163
 164     DWRITE_RENDERING_MODE1 rendering_mode;
 165     DWRITE_TEXTURE_TYPE texture_type; /* derived from rendering mode specified on creation */
 166     DWRITE_GLYPH_RUN run; /* glyphAdvances and glyphOffsets are not used */
 167     DWRITE_MATRIX m;
 168     UINT16 *glyphs;
 169     D2D_POINT_2F *origins;
 170
 171     UINT8 flags;
 172     RECT bounds;
 173     BYTE *bitmap;
 174     UINT32 max_glyph_bitmap_size;
 175 };
 176
 177 struct dwrite_colorglyphenum
 178 {
 179     IDWriteColorGlyphRunEnumerator1 IDWriteColorGlyphRunEnumerator1_iface;
 180     LONG refcount;
 181
 182     FLOAT origin_x;                   /* original run origin */
 183     FLOAT origin_y;
 184
 185     IDWriteFontFace5 *fontface;       /* for convenience */
 186     DWRITE_COLOR_GLYPH_RUN1 colorrun; /* returned with GetCurrentRun() */
 187     DWRITE_GLYPH_RUN run;             /* base run */
 188     UINT32 palette;                   /* palette index to get layer color from */
 189     FLOAT *advances;                  /* original or measured advances for base glyphs */
 190     FLOAT *color_advances;            /* returned color run points to this */
 191     DWRITE_GLYPH_OFFSET *offsets;     /* original offsets, or NULL */
 192     DWRITE_GLYPH_OFFSET *color_offsets; /* returned color run offsets, or NULL */
 193     UINT16 *glyphindices;             /* returned color run points to this */
 194     struct dwrite_colorglyph *glyphs; /* current glyph color info */
 195     BOOL has_regular_glyphs;          /* TRUE if there's any glyph without a color */
 196     UINT16 current_layer;             /* enumerator position, updated with MoveNext */
 197     UINT16 max_layer_num;             /* max number of layers for this run */
 198     struct dwrite_fonttable colr;     /* used to access layers */
 199 };
 200
 201 #define GLYPH_BLOCK_SHIFT 8
 202 #define GLYPH_BLOCK_SIZE  (1UL << GLYPH_BLOCK_SHIFT)
 203 #define GLYPH_BLOCK_MASK  (GLYPH_BLOCK_SIZE - 1)
 204 #define GLYPH_MAX         65536
 205
 206 struct dwrite_fontfile
 207 {
 208     IDWriteFontFile IDWriteFontFile_iface;
 209     LONG refcount;
 210
 211     IDWriteFontFileLoader *loader;
 212     void *reference_key;
 213     UINT32 key_size;
 214     IDWriteFontFileStream *stream;
 215 };
 216
 217 struct dwrite_fontfacereference
 218 {
 219     IDWriteFontFaceReference1 IDWriteFontFaceReference1_iface;
 220     LONG refcount;
 221
 222     IDWriteFontFile *file;
 223     UINT32 index;
 224     USHORT simulations;
 225     DWRITE_FONT_AXIS_VALUE *axis_values;
 226     UINT32 axis_values_count;
 227     IDWriteFactory7 *factory;
 228 };
 229
 230 static const IDWriteFontFaceReference1Vtbl fontfacereferencevtbl;
 231
 232 struct dwrite_fontresource
 233 {
 234     IDWriteFontResource IDWriteFontResource_iface;
 235     LONG refcount;
 236
 237     IDWriteFontFile *file;
 238     UINT32 face_index;
 239     IDWriteFactory7 *factory;
 240 };
 241
 242 struct dwrite_fontset_entry
 243 {
 244     LONG refcount;
 245     IDWriteFontFile *file;
 246     DWRITE_FONT_FACE_TYPE face_type;
 247     unsigned int face_index;
 248     unsigned int simulations;
 249     IDWriteLocalizedStrings *props[DWRITE_FONT_PROPERTY_ID_TYPOGRAPHIC_FACE_NAME + 1];
 250 };
 251
 252 struct dwrite_fontset
 253 {
 254     IDWriteFontSet3 IDWriteFontSet3_iface;
 255     LONG refcount;
 256     IDWriteFactory7 *factory;
 257
 258     struct dwrite_fontset_entry **entries;
 259     unsigned int count;
 260 };
 261
 262 struct dwrite_fontset_builder
 263 {
 264     IDWriteFontSetBuilder2 IDWriteFontSetBuilder2_iface;
 265     LONG refcount;
 266     IDWriteFactory7 *factory;
 267
 268     struct dwrite_fontset_entry **entries;
 269     size_t count;
 270     size_t capacity;
 271 };
 272
 273 static HRESULT fontset_create_from_font_data(IDWriteFactory7 *factory, struct dwrite_font_data **fonts,
 274         unsigned int count, IDWriteFontSet1 **ret);
 275
 276 static void dwrite_grab_font_table(void *context, UINT32 table, const BYTE **data, UINT32 *size, void **data_context)
 277 {
 278     struct dwrite_fontface *fontface = context;
 279     BOOL exists = FALSE;
 280
 281     if (FAILED(IDWriteFontFace5_TryGetFontTable(&fontface->IDWriteFontFace5_iface, table, (const void **)data,
 282             size, data_context, &exists)) || !exists)
 283     {
 284         *data = NULL;
 285         *size = 0;
 286         *data_context = NULL;
 287     }
 288 }
 289
 290 static void dwrite_release_font_table(void *context, void *data_context)
 291 {
 292     struct dwrite_fontface *fontface = context;
 293     IDWriteFontFace5_ReleaseFontTable(&fontface->IDWriteFontFace5_iface, data_context);
 294 }
 295
 296 static UINT16 dwrite_get_font_upem(void *context)
 297 {
 298     struct dwrite_fontface *fontface = context;
 299     return fontface->metrics.designUnitsPerEm;
 300 }
 301
 302 static UINT16 dwritefontface_get_glyph(struct dwrite_fontface *fontface, unsigned int ch)
 303 {
 304     dwrite_cmap_init(&fontface->cmap, NULL, fontface->index, fontface->type);
 305     return opentype_cmap_get_glyph(&fontface->cmap, ch);
 306 }
 307
 308 static BOOL dwrite_has_glyph(void *context, unsigned int codepoint)
 309 {
 310     struct dwrite_fontface *fontface = context;
 311     return !!dwritefontface_get_glyph(fontface, codepoint);
 312 }
 313
 314 static UINT16 dwrite_get_glyph(void *context, unsigned int codepoint)
 315 {
 316     struct dwrite_fontface *fontface = context;
 317     return dwritefontface_get_glyph(fontface, codepoint);
 318 }
 319
 320 static const struct shaping_font_ops dwrite_font_ops =
 321 {
 322     dwrite_grab_font_table,
 323     dwrite_release_font_table,
 324     dwrite_get_font_upem,
 325     dwrite_has_glyph,
 326     dwrite_get_glyph,
 327 };
 328
 329 struct scriptshaping_cache *fontface_get_shaping_cache(struct dwrite_fontface *fontface)
 330 {
 331     if (fontface->shaping_cache)
 332         return fontface->shaping_cache;
 333
 334     return fontface->shaping_cache = create_scriptshaping_cache(fontface, &dwrite_font_ops);
 335 }
 336
 337 static inline struct dwrite_fontface *impl_from_IDWriteFontFace5(IDWriteFontFace5 *iface)
 338 {
 339     return CONTAINING_RECORD(iface, struct dwrite_fontface, IDWriteFontFace5_iface);
 340 }
 341
 342 static struct dwrite_fontface *impl_from_IDWriteFontFaceReference(IDWriteFontFaceReference *iface)
 343 {
 344     return CONTAINING_RECORD(iface, struct dwrite_fontface, IDWriteFontFaceReference_iface);
 345 }
 346
 347 static inline struct dwrite_font *impl_from_IDWriteFont3(IDWriteFont3 *iface)
 348 {
 349     return CONTAINING_RECORD(iface, struct dwrite_font, IDWriteFont3_iface);
 350 }
 351
 352 static struct dwrite_font *unsafe_impl_from_IDWriteFont(IDWriteFont *iface);
 353
 354 static inline struct dwrite_fontfile *impl_from_IDWriteFontFile(IDWriteFontFile *iface)
 355 {
 356     return CONTAINING_RECORD(iface, struct dwrite_fontfile, IDWriteFontFile_iface);
 357 }
 358
 359 static inline struct dwrite_fontfamily *impl_from_IDWriteFontFamily2(IDWriteFontFamily2 *iface)
 360 {
 361     return CONTAINING_RECORD(iface, struct dwrite_fontfamily, IDWriteFontFamily2_iface);
 362 }
 363
 364 static inline struct dwrite_fontfamily *impl_family_from_IDWriteFontList2(IDWriteFontList2 *iface)
 365 {
 366     return CONTAINING_RECORD(iface, struct dwrite_fontfamily, IDWriteFontList2_iface);
 367 }
 368
 369 static inline struct dwrite_fontcollection *impl_from_IDWriteFontCollection3(IDWriteFontCollection3 *iface)
 370 {
 371     return CONTAINING_RECORD(iface, struct dwrite_fontcollection, IDWriteFontCollection3_iface);
 372 }
 373
 374 static inline struct dwrite_glyphrunanalysis *impl_from_IDWriteGlyphRunAnalysis(IDWriteGlyphRunAnalysis *iface)
 375 {
 376     return CONTAINING_RECORD(iface, struct dwrite_glyphrunanalysis, IDWriteGlyphRunAnalysis_iface);
 377 }
 378
 379 static inline struct dwrite_colorglyphenum *impl_from_IDWriteColorGlyphRunEnumerator1(IDWriteColorGlyphRunEnumerator1 *iface)
 380 {
 381     return CONTAINING_RECORD(iface, struct dwrite_colorglyphenum, IDWriteColorGlyphRunEnumerator1_iface);
 382 }
 383
 384 static inline struct dwrite_fontlist *impl_from_IDWriteFontList2(IDWriteFontList2 *iface)
 385 {
 386     return CONTAINING_RECORD(iface, struct dwrite_fontlist, IDWriteFontList2_iface);
 387 }
 388
 389 static inline struct dwrite_fontfacereference *impl_from_IDWriteFontFaceReference1(IDWriteFontFaceReference1 *iface)
 390 {
 391     return CONTAINING_RECORD(iface, struct dwrite_fontfacereference, IDWriteFontFaceReference1_iface);
 392 }
 393
 394 static struct dwrite_fontresource *impl_from_IDWriteFontResource(IDWriteFontResource *iface)
 395 {
 396     return CONTAINING_RECORD(iface, struct dwrite_fontresource, IDWriteFontResource_iface);
 397 }
 398
 399 static struct dwrite_fontset_builder *impl_from_IDWriteFontSetBuilder2(IDWriteFontSetBuilder2 *iface)
 400 {
 401     return CONTAINING_RECORD(iface, struct dwrite_fontset_builder, IDWriteFontSetBuilder2_iface);
 402 }
 403
 404 static struct dwrite_fontset *impl_from_IDWriteFontSet3(IDWriteFontSet3 *iface)
 405 {
 406     return CONTAINING_RECORD(iface, struct dwrite_fontset, IDWriteFontSet3_iface);
 407 }
 408
 409 static HRESULT get_cached_glyph_metrics(struct dwrite_fontface *fontface, UINT16 glyph, DWRITE_GLYPH_METRICS *metrics)
 410 {
 411     static const DWRITE_GLYPH_METRICS nil;
 412     DWRITE_GLYPH_METRICS *block = fontface->glyphs[glyph >> GLYPH_BLOCK_SHIFT];
 413
 414     if (!block || !memcmp(&block[glyph & GLYPH_BLOCK_MASK], &nil, sizeof(DWRITE_GLYPH_METRICS))) return S_FALSE;
 415     memcpy(metrics, &block[glyph & GLYPH_BLOCK_MASK], sizeof(*metrics));
 416     return S_OK;
 417 }
 418
 419 static HRESULT set_cached_glyph_metrics(struct dwrite_fontface *fontface, UINT16 glyph, DWRITE_GLYPH_METRICS *metrics)
 420 {
 421     DWRITE_GLYPH_METRICS **block = &fontface->glyphs[glyph >> GLYPH_BLOCK_SHIFT];
 422
 423     if (!*block) {
 424         /* start new block */
 425         *block = heap_alloc_zero(sizeof(*metrics) * GLYPH_BLOCK_SIZE);
 426         if (!*block)
 427             return E_OUTOFMEMORY;
 428     }
 429
 430     memcpy(&(*block)[glyph & GLYPH_BLOCK_MASK], metrics, sizeof(*metrics));
 431     return S_OK;
 432 }
 433
 434 const void* get_fontface_table(IDWriteFontFace5 *fontface, UINT32 tag, struct dwrite_fonttable *table)
 435 {
 436     HRESULT hr;
 437
 438     if (table->data || !table->exists)
 439         return table->data;
 440
 441     table->exists = FALSE;
 442     hr = IDWriteFontFace5_TryGetFontTable(fontface, tag, (const void **)&table->data, &table->size, &table->context,
 443         &table->exists);
 444     if (FAILED(hr) || !table->exists) {
 445         TRACE("Font does not have %s table\n", debugstr_tag(tag));
 446         return NULL;
 447     }
 448
 449     return table->data;
 450 }
 451
 452 static void init_font_prop_vec(DWRITE_FONT_WEIGHT weight, DWRITE_FONT_STRETCH stretch, DWRITE_FONT_STYLE style,
 453     struct dwrite_font_propvec *vec)
 454 {
 455     vec->stretch = ((INT32)stretch - DWRITE_FONT_STRETCH_NORMAL) * 11.0f;
 456     vec->style = style * 7.0f;
 457     vec->weight = ((INT32)weight - DWRITE_FONT_WEIGHT_NORMAL) / 100.0f * 5.0f;
 458 }
 459
 460 static FLOAT get_font_prop_vec_distance(const struct dwrite_font_propvec *left, const struct dwrite_font_propvec *right)
 461 {
 462     return powf(left->stretch - right->stretch, 2) + powf(left->style - right->style, 2) + powf(left->weight - right->weight, 2);
 463 }
 464
 465 static FLOAT get_font_prop_vec_dotproduct(const struct dwrite_font_propvec *left, const struct dwrite_font_propvec *right)
 466 {
 467     return left->stretch * right->stretch + left->style * right->style + left->weight * right->weight;
 468 }
 469
 470 static const struct dwrite_fonttable *get_fontface_vdmx(struct dwrite_fontface *fontface)
 471 {
 472     get_fontface_table(&fontface->IDWriteFontFace5_iface, MS_VDMX_TAG, &fontface->vdmx);
 473     return &fontface->vdmx;
 474 }
 475
 476 static const struct dwrite_fonttable *get_fontface_gasp(struct dwrite_fontface *fontface)
 477 {
 478     get_fontface_table(&fontface->IDWriteFontFace5_iface, MS_GASP_TAG, &fontface->gasp);
 479     return &fontface->gasp;
 480 }
 481
 482 static const struct dwrite_fonttable *get_fontface_cpal(struct dwrite_fontface *fontface)
 483 {
 484     get_fontface_table(&fontface->IDWriteFontFace5_iface, MS_CPAL_TAG, &fontface->cpal);
 485     return &fontface->cpal;
 486 }
 487
 488 static struct dwrite_font_data * addref_font_data(struct dwrite_font_data *data)
 489 {
 490     InterlockedIncrement(&data->refcount);
 491     return data;
 492 }
 493
 494 static void release_font_data(struct dwrite_font_data *data)
 495 {
 496     int i;
 497
 498     if (InterlockedDecrement(&data->refcount) > 0)
 499         return;
 500
 501     for (i = 0; i < ARRAY_SIZE(data->info_strings); ++i)
 502     {
 503         if (data->info_strings[i])
 504             IDWriteLocalizedStrings_Release(data->info_strings[i]);
 505     }
 506     if (data->names)
 507         IDWriteLocalizedStrings_Release(data->names);
 508
 509     if (data->family_names)
 510         IDWriteLocalizedStrings_Release(data->family_names);
 511
 512     dwrite_cmap_release(&data->cmap);
 513     IDWriteFontFile_Release(data->file);
 514     heap_free(data->facename);
 515     heap_free(data);
 516 }
 517
 518 static void release_fontfamily_data(struct dwrite_fontfamily_data *data)
 519 {
 520     size_t i;
 521
 522     if (InterlockedDecrement(&data->refcount) > 0)
 523         return;
 524
 525     for (i = 0; i < data->count; ++i)
 526         release_font_data(data->fonts[i]);
 527     heap_free(data->fonts);
 528     IDWriteLocalizedStrings_Release(data->familyname);
 529     heap_free(data);
 530 }
 531
 532 void fontface_detach_from_cache(IDWriteFontFace5 *iface)
 533 {
 534     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 535     fontface->cached = NULL;
 536 }
 537
 538 static BOOL is_same_fontfile(IDWriteFontFile *left, IDWriteFontFile *right)
 539 {
 540     UINT32 left_key_size, right_key_size;
 541     const void *left_key, *right_key;
 542     HRESULT hr;
 543
 544     if (left == right)
 545         return TRUE;
 546
 547     hr = IDWriteFontFile_GetReferenceKey(left, &left_key, &left_key_size);
 548     if (FAILED(hr))
 549         return FALSE;
 550
 551     hr = IDWriteFontFile_GetReferenceKey(right, &right_key, &right_key_size);
 552     if (FAILED(hr))
 553         return FALSE;
 554
 555     if (left_key_size != right_key_size)
 556         return FALSE;
 557
 558     return !memcmp(left_key, right_key, left_key_size);
 559 }
 560
 561 static HRESULT WINAPI dwritefontface_QueryInterface(IDWriteFontFace5 *iface, REFIID riid, void **obj)
 562 {
 563     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 564
 565     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 566
 567     if (IsEqualIID(riid, &IID_IDWriteFontFace5) ||
 568         IsEqualIID(riid, &IID_IDWriteFontFace4) ||
 569         IsEqualIID(riid, &IID_IDWriteFontFace3) ||
 570         IsEqualIID(riid, &IID_IDWriteFontFace2) ||
 571         IsEqualIID(riid, &IID_IDWriteFontFace1) ||
 572         IsEqualIID(riid, &IID_IDWriteFontFace) ||
 573         IsEqualIID(riid, &IID_IUnknown))
 574     {
 575         *obj = iface;
 576     }
 577     else if (IsEqualIID(riid, &IID_IDWriteFontFaceReference))
 578         *obj = &fontface->IDWriteFontFaceReference_iface;
 579     else
 580         *obj = NULL;
 581
 582     if (*obj)
 583     {
 584         if (InterlockedIncrement(&fontface->refcount) == 1)
 585         {
 586             InterlockedDecrement(&fontface->refcount);
 587             *obj = NULL;
 588             return E_FAIL;
 589         }
 590         return S_OK;
 591     }
 592
 593     WARN("%s not implemented.\n", debugstr_guid(riid));
 594
 595     return E_NOINTERFACE;
 596 }
 597
 598 static ULONG WINAPI dwritefontface_AddRef(IDWriteFontFace5 *iface)
 599 {
 600     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 601     ULONG refcount = InterlockedIncrement(&fontface->refcount);
 602
 603     TRACE("%p, refcount %u.\n", iface, refcount);
 604
 605     return refcount;
 606 }
 607
 608 static ULONG WINAPI dwritefontface_Release(IDWriteFontFace5 *iface)
 609 {
 610     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 611     ULONG refcount = InterlockedDecrement(&fontface->refcount);
 612
 613     TRACE("%p, refcount %u.\n", iface, refcount);
 614
 615     if (!refcount)
 616     {
 617         UINT32 i;
 618
 619         if (fontface->cached)
 620         {
 621             factory_lock(fontface->factory);
 622             list_remove(&fontface->cached->entry);
 623             factory_unlock(fontface->factory);
 624             heap_free(fontface->cached);
 625         }
 626         release_scriptshaping_cache(fontface->shaping_cache);
 627         if (fontface->vdmx.context)
 628             IDWriteFontFace5_ReleaseFontTable(iface, fontface->vdmx.context);
 629         if (fontface->gasp.context)
 630             IDWriteFontFace5_ReleaseFontTable(iface, fontface->gasp.context);
 631         if (fontface->cpal.context)
 632             IDWriteFontFace5_ReleaseFontTable(iface, fontface->cpal.context);
 633         if (fontface->colr.context)
 634             IDWriteFontFace5_ReleaseFontTable(iface, fontface->colr.context);
 635         if (fontface->kern.context)
 636             IDWriteFontFace5_ReleaseFontTable(iface, fontface->kern.context);
 637         if (fontface->file)
 638             IDWriteFontFile_Release(fontface->file);
 639         if (fontface->stream)
 640             IDWriteFontFileStream_Release(fontface->stream);
 641         if (fontface->names)
 642             IDWriteLocalizedStrings_Release(fontface->names);
 643         if (fontface->family_names)
 644             IDWriteLocalizedStrings_Release(fontface->family_names);
 645         for (i = 0; i < ARRAY_SIZE(fontface->info_strings); ++i)
 646         {
 647             if (fontface->info_strings[i])
 648                 IDWriteLocalizedStrings_Release(fontface->info_strings[i]);
 649         }
 650
 651         for (i = 0; i < ARRAY_SIZE(fontface->glyphs); i++)
 652             heap_free(fontface->glyphs[i]);
 653
 654         font_funcs->notify_release(iface);
 655
 656         dwrite_cmap_release(&fontface->cmap);
 657         IDWriteFactory7_Release(fontface->factory);
 658         heap_free(fontface);
 659     }
 660
 661     return refcount;
 662 }
 663
 664 static DWRITE_FONT_FACE_TYPE WINAPI dwritefontface_GetType(IDWriteFontFace5 *iface)
 665 {
 666     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 667
 668     TRACE("%p.\n", iface);
 669
 670     return fontface->type;
 671 }
 672
 673 static HRESULT WINAPI dwritefontface_GetFiles(IDWriteFontFace5 *iface, UINT32 *number_of_files,
 674     IDWriteFontFile **fontfiles)
 675 {
 676     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 677
 678     TRACE("%p, %p, %p.\n", iface, number_of_files, fontfiles);
 679
 680     if (!fontfiles)
 681     {
 682         *number_of_files = 1;
 683         return S_OK;
 684     }
 685
 686     if (!*number_of_files)
 687         return E_INVALIDARG;
 688
 689     IDWriteFontFile_AddRef(fontface->file);
 690     *fontfiles = fontface->file;
 691
 692     return S_OK;
 693 }
 694
 695 static UINT32 WINAPI dwritefontface_GetIndex(IDWriteFontFace5 *iface)
 696 {
 697     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 698
 699     TRACE("%p.\n", iface);
 700
 701     return fontface->index;
 702 }
 703
 704 static DWRITE_FONT_SIMULATIONS WINAPI dwritefontface_GetSimulations(IDWriteFontFace5 *iface)
 705 {
 706     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 707
 708     TRACE("%p.\n", iface);
 709
 710     return fontface->simulations;
 711 }
 712
 713 static BOOL WINAPI dwritefontface_IsSymbolFont(IDWriteFontFace5 *iface)
 714 {
 715     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 716
 717     TRACE("%p.\n", iface);
 718
 719     return !!(fontface->flags & FONT_IS_SYMBOL);
 720 }
 721
 722 static void WINAPI dwritefontface_GetMetrics(IDWriteFontFace5 *iface, DWRITE_FONT_METRICS *metrics)
 723 {
 724     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 725
 726     TRACE("%p, %p.\n", iface, metrics);
 727
 728     memcpy(metrics, &fontface->metrics, sizeof(*metrics));
 729 }
 730
 731 static UINT16 WINAPI dwritefontface_GetGlyphCount(IDWriteFontFace5 *iface)
 732 {
 733     TRACE("%p.\n", iface);
 734
 735     return font_funcs->get_glyph_count(iface);
 736 }
 737
 738 static HRESULT WINAPI dwritefontface_GetDesignGlyphMetrics(IDWriteFontFace5 *iface,
 739     UINT16 const *glyphs, UINT32 glyph_count, DWRITE_GLYPH_METRICS *ret, BOOL is_sideways)
 740 {
 741     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 742     unsigned int i;
 743     HRESULT hr;
 744
 745     TRACE("%p, %p, %u, %p, %d.\n", iface, glyphs, glyph_count, ret, is_sideways);
 746
 747     if (!glyphs)
 748         return E_INVALIDARG;
 749
 750     if (is_sideways)
 751         FIXME("sideways metrics are not supported.\n");
 752
 753     for (i = 0; i < glyph_count; i++) {
 754         DWRITE_GLYPH_METRICS metrics;
 755
 756         hr = get_cached_glyph_metrics(fontface, glyphs[i], &metrics);
 757         if (hr != S_OK)
 758         {
 759             font_funcs->get_design_glyph_metrics(iface, fontface->metrics.designUnitsPerEm,
 760                     fontface->typo_metrics.ascent, fontface->simulations, glyphs[i], &metrics);
 761             hr = set_cached_glyph_metrics(fontface, glyphs[i], &metrics);
 762             if (FAILED(hr))
 763                 return hr;
 764         }
 765         ret[i] = metrics;
 766     }
 767
 768     return S_OK;
 769 }
 770
 771 static HRESULT WINAPI dwritefontface_GetGlyphIndices(IDWriteFontFace5 *iface, UINT32 const *codepoints,
 772     UINT32 count, UINT16 *glyphs)
 773 {
 774     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 775     unsigned int i;
 776
 777     TRACE("%p, %p, %u, %p.\n", iface, codepoints, count, glyphs);
 778
 779     if (!glyphs)
 780         return E_INVALIDARG;
 781
 782     if (!codepoints)
 783     {
 784         memset(glyphs, 0, count * sizeof(*glyphs));
 785         return E_INVALIDARG;
 786     }
 787
 788     for (i = 0; i < count; ++i)
 789         glyphs[i] = dwritefontface_get_glyph(fontface, codepoints[i]);
 790
 791     return S_OK;
 792 }
 793
 794 static HRESULT WINAPI dwritefontface_TryGetFontTable(IDWriteFontFace5 *iface, UINT32 table_tag,
 795     const void **table_data, UINT32 *table_size, void **context, BOOL *exists)
 796 {
 797     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 798     struct file_stream_desc stream_desc;
 799
 800     TRACE("%p, %s, %p, %p, %p, %p.\n", iface, debugstr_tag(table_tag), table_data, table_size, context, exists);
 801
 802     stream_desc.stream = fontface->stream;
 803     stream_desc.face_type = fontface->type;
 804     stream_desc.face_index = fontface->index;
 805     return opentype_try_get_font_table(&stream_desc, table_tag, table_data, context, table_size, exists);
 806 }
 807
 808 static void WINAPI dwritefontface_ReleaseFontTable(IDWriteFontFace5 *iface, void *table_context)
 809 {
 810     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 811
 812     TRACE("%p, %p.\n", iface, table_context);
 813
 814     IDWriteFontFileStream_ReleaseFileFragment(fontface->stream, table_context);
 815 }
 816
 817 static void apply_outline_point_offset(const D2D1_POINT_2F *src, const D2D1_POINT_2F *offset,
 818         D2D1_POINT_2F *dst)
 819 {
 820     dst->x = src->x + offset->x;
 821     dst->y = src->y + offset->y;
 822 }
 823
 824 static HRESULT WINAPI dwritefontface_GetGlyphRunOutline(IDWriteFontFace5 *iface, FLOAT emSize,
 825     UINT16 const *glyphs, FLOAT const* advances, DWRITE_GLYPH_OFFSET const *offsets,
 826     UINT32 count, BOOL is_sideways, BOOL is_rtl, IDWriteGeometrySink *sink)
 827 {
 828     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 829     D2D1_POINT_2F *origins, baseline_origin = { 0 };
 830     struct dwrite_outline outline = {{ 0 }};
 831     D2D1_BEZIER_SEGMENT segment;
 832     D2D1_POINT_2F point;
 833     DWRITE_GLYPH_RUN run;
 834     unsigned int i, j, p;
 835     HRESULT hr;
 836
 837     TRACE("%p, %.8e, %p, %p, %p, %u, %d, %d, %p.\n", iface, emSize, glyphs, advances, offsets,
 838         count, is_sideways, is_rtl, sink);
 839
 840     if (!glyphs || !sink)
 841         return E_INVALIDARG;
 842
 843     if (!count)
 844         return S_OK;
 845
 846     run.fontFace = (IDWriteFontFace *)iface;
 847     run.fontEmSize = emSize;
 848     run.glyphCount = count;
 849     run.glyphIndices = glyphs;
 850     run.glyphAdvances = advances;
 851     run.glyphOffsets = offsets;
 852     run.isSideways = is_sideways;
 853     run.bidiLevel = is_rtl ? 1 : 0;
 854
 855     if (!(origins = heap_alloc(sizeof(*origins) * count)))
 856         return E_OUTOFMEMORY;
 857
 858     if (FAILED(hr = compute_glyph_origins(&run, DWRITE_MEASURING_MODE_NATURAL, baseline_origin, NULL, origins)))
 859     {
 860         heap_free(origins);
 861         return hr;
 862     }
 863
 864     ID2D1SimplifiedGeometrySink_SetFillMode(sink, D2D1_FILL_MODE_WINDING);
 865
 866     for (i = 0; i < count; ++i)
 867     {
 868         outline.tags.count = outline.points.count = 0;
 869         if (font_funcs->get_glyph_outline(iface, emSize, fontface->simulations, glyphs[i], &outline))
 870         {
 871             WARN("Failed to get glyph outline for glyph %u.\n", glyphs[i]);
 872             continue;
 873         }
 874
 875         for (j = 0, p = 0; j < outline.tags.count; ++j)
 876         {
 877             switch (outline.tags.values[j])
 878             {
 879                 case OUTLINE_BEGIN_FIGURE:
 880                     apply_outline_point_offset(&outline.points.values[p++], &origins[i], &point);
 881                     ID2D1SimplifiedGeometrySink_BeginFigure(sink, point, D2D1_FIGURE_BEGIN_FILLED);
 882                     break;
 883                 case OUTLINE_END_FIGURE:
 884                     ID2D1SimplifiedGeometrySink_EndFigure(sink, D2D1_FIGURE_END_CLOSED);
 885                     break;
 886                 case OUTLINE_LINE:
 887                     apply_outline_point_offset(&outline.points.values[p++], &origins[i], &point);
 888                     ID2D1SimplifiedGeometrySink_AddLines(sink, &point, 1);
 889                     break;
 890                 case OUTLINE_BEZIER:
 891                     apply_outline_point_offset(&outline.points.values[p++], &origins[i], &segment.point1);
 892                     apply_outline_point_offset(&outline.points.values[p++], &origins[i], &segment.point2);
 893                     apply_outline_point_offset(&outline.points.values[p++], &origins[i], &segment.point3);
 894                     ID2D1SimplifiedGeometrySink_AddBeziers(sink, &segment, 1);
 895                     break;
 896             }
 897         }
 898     }
 899
 900     heap_free(outline.tags.values);
 901     heap_free(outline.points.values);
 902     heap_free(origins);
 903
 904     return S_OK;
 905 }
 906
 907 static DWRITE_RENDERING_MODE fontface_renderingmode_from_measuringmode(DWRITE_MEASURING_MODE measuring,
 908         float ppem, unsigned int gasp)
 909 {
 910     DWRITE_RENDERING_MODE mode = DWRITE_RENDERING_MODE_DEFAULT;
 911
 912     switch (measuring)
 913     {
 914     case DWRITE_MEASURING_MODE_NATURAL:
 915     {
 916         if (!(gasp & GASP_SYMMETRIC_SMOOTHING) && (ppem <= RECOMMENDED_NATURAL_PPEM))
 917             mode = DWRITE_RENDERING_MODE_NATURAL;
 918         else
 919             mode = DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC;
 920         break;
 921     }
 922     case DWRITE_MEASURING_MODE_GDI_CLASSIC:
 923         mode = DWRITE_RENDERING_MODE_GDI_CLASSIC;
 924         break;
 925     case DWRITE_MEASURING_MODE_GDI_NATURAL:
 926         mode = DWRITE_RENDERING_MODE_GDI_NATURAL;
 927         break;
 928     default:
 929         ;
 930     }
 931
 932     return mode;
 933 }
 934
 935 static HRESULT WINAPI dwritefontface_GetRecommendedRenderingMode(IDWriteFontFace5 *iface, FLOAT emSize,
 936     FLOAT ppdip, DWRITE_MEASURING_MODE measuring, IDWriteRenderingParams *params, DWRITE_RENDERING_MODE *mode)
 937 {
 938     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 939     unsigned int flags;
 940     FLOAT ppem;
 941
 942     TRACE("%p, %.8e, %.8e, %d, %p, %p.\n", iface, emSize, ppdip, measuring, params, mode);
 943
 944     if (!params) {
 945         *mode = DWRITE_RENDERING_MODE_DEFAULT;
 946         return E_INVALIDARG;
 947     }
 948
 949     *mode = IDWriteRenderingParams_GetRenderingMode(params);
 950     if (*mode != DWRITE_RENDERING_MODE_DEFAULT)
 951         return S_OK;
 952
 953     ppem = emSize * ppdip;
 954
 955     if (ppem >= RECOMMENDED_OUTLINE_AA_THRESHOLD) {
 956         *mode = DWRITE_RENDERING_MODE_OUTLINE;
 957         return S_OK;
 958     }
 959
 960     flags = opentype_get_gasp_flags(get_fontface_gasp(fontface), ppem);
 961     *mode = fontface_renderingmode_from_measuringmode(measuring, ppem, flags);
 962     return S_OK;
 963 }
 964
 965 static HRESULT WINAPI dwritefontface_GetGdiCompatibleMetrics(IDWriteFontFace5 *iface, FLOAT emSize, FLOAT pixels_per_dip,
 966     DWRITE_MATRIX const *transform, DWRITE_FONT_METRICS *metrics)
 967 {
 968     DWRITE_FONT_METRICS1 metrics1;
 969     HRESULT hr = IDWriteFontFace5_GetGdiCompatibleMetrics(iface, emSize, pixels_per_dip, transform, &metrics1);
 970     memcpy(metrics, &metrics1, sizeof(*metrics));
 971     return hr;
 972 }
 973
 974 static inline int round_metric(FLOAT metric)
 975 {
 976     return (int)floorf(metric + 0.5f);
 977 }
 978
 979 static UINT32 fontface_get_horz_metric_adjustment(const struct dwrite_fontface *fontface)
 980 {
 981     if (!(fontface->simulations & DWRITE_FONT_SIMULATIONS_BOLD))
 982         return 0;
 983
 984     return (fontface->metrics.designUnitsPerEm + 49) / 50;
 985 }
 986
 987 static HRESULT WINAPI dwritefontface_GetGdiCompatibleGlyphMetrics(IDWriteFontFace5 *iface, FLOAT emSize, FLOAT ppdip,
 988     DWRITE_MATRIX const *m, BOOL use_gdi_natural, UINT16 const *glyphs, UINT32 glyph_count,
 989     DWRITE_GLYPH_METRICS *metrics, BOOL is_sideways)
 990 {
 991     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
 992     UINT32 adjustment = fontface_get_horz_metric_adjustment(fontface);
 993     DWRITE_MEASURING_MODE mode;
 994     FLOAT scale, size;
 995     HRESULT hr;
 996     UINT32 i;
 997
 998     TRACE("%p, %.8e, %.8e, %p, %d, %p, %u, %p, %d.\n", iface, emSize, ppdip, m, use_gdi_natural, glyphs,
 999         glyph_count, metrics, is_sideways);
1000
1001     if (m && memcmp(m, &identity, sizeof(*m)))
1002         FIXME("transform is not supported, %s\n", debugstr_matrix(m));
1003
1004     size = emSize * ppdip;
1005     scale = size / fontface->metrics.designUnitsPerEm;
1006     mode = use_gdi_natural ? DWRITE_MEASURING_MODE_GDI_NATURAL : DWRITE_MEASURING_MODE_GDI_CLASSIC;
1007
1008     for (i = 0; i < glyph_count; i++) {
1009         DWRITE_GLYPH_METRICS *ret = metrics + i;
1010         DWRITE_GLYPH_METRICS design;
1011         BOOL has_contours;
1012
1013         hr = IDWriteFontFace5_GetDesignGlyphMetrics(iface, glyphs + i, 1, &design, is_sideways);
1014         if (FAILED(hr))
1015             return hr;
1016
1017         ret->advanceWidth = font_funcs->get_glyph_advance(iface, size, glyphs[i], mode, &has_contours);
1018         if (has_contours)
1019             ret->advanceWidth = round_metric(ret->advanceWidth * fontface->metrics.designUnitsPerEm / size + adjustment);
1020         else
1021             ret->advanceWidth = round_metric(ret->advanceWidth * fontface->metrics.designUnitsPerEm / size);
1022
1023 #define SCALE_METRIC(x) ret->x = round_metric(round_metric((design.x) * scale) / scale)
1024         SCALE_METRIC(leftSideBearing);
1025         SCALE_METRIC(rightSideBearing);
1026         SCALE_METRIC(topSideBearing);
1027         SCALE_METRIC(advanceHeight);
1028         SCALE_METRIC(bottomSideBearing);
1029         SCALE_METRIC(verticalOriginY);
1030 #undef  SCALE_METRIC
1031     }
1032
1033     return S_OK;
1034 }
1035
1036 static void WINAPI dwritefontface1_GetMetrics(IDWriteFontFace5 *iface, DWRITE_FONT_METRICS1 *metrics)
1037 {
1038     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1039
1040     TRACE("%p, %p.\n", iface, metrics);
1041
1042     *metrics = fontface->metrics;
1043 }
1044
1045 static HRESULT WINAPI dwritefontface1_GetGdiCompatibleMetrics(IDWriteFontFace5 *iface, FLOAT em_size,
1046         FLOAT pixels_per_dip, const DWRITE_MATRIX *m, DWRITE_FONT_METRICS1 *metrics)
1047 {
1048     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1049     const DWRITE_FONT_METRICS1 *design = &fontface->metrics;
1050     UINT16 ascent, descent;
1051     FLOAT scale;
1052
1053     TRACE("%p, %.8e, %.8e, %p, %p.\n", iface, em_size, pixels_per_dip, m, metrics);
1054
1055     if (em_size <= 0.0f || pixels_per_dip <= 0.0f) {
1056         memset(metrics, 0, sizeof(*metrics));
1057         return E_INVALIDARG;
1058     }
1059
1060     em_size *= pixels_per_dip;
1061     if (m && m->m22 != 0.0f)
1062         em_size *= fabs(m->m22);
1063
1064     scale = em_size / design->designUnitsPerEm;
1065     if (!opentype_get_vdmx_size(get_fontface_vdmx(fontface), em_size, &ascent, &descent))
1066     {
1067         ascent = round_metric(design->ascent * scale);
1068         descent = round_metric(design->descent * scale);
1069     }
1070
1071 #define SCALE_METRIC(x) metrics->x = round_metric(round_metric((design->x) * scale) / scale)
1072     metrics->designUnitsPerEm = design->designUnitsPerEm;
1073     metrics->ascent = round_metric(ascent / scale);
1074     metrics->descent = round_metric(descent / scale);
1075
1076     SCALE_METRIC(lineGap);
1077     SCALE_METRIC(capHeight);
1078     SCALE_METRIC(xHeight);
1079     SCALE_METRIC(underlinePosition);
1080     SCALE_METRIC(underlineThickness);
1081     SCALE_METRIC(strikethroughPosition);
1082     SCALE_METRIC(strikethroughThickness);
1083     SCALE_METRIC(glyphBoxLeft);
1084     SCALE_METRIC(glyphBoxTop);
1085     SCALE_METRIC(glyphBoxRight);
1086     SCALE_METRIC(glyphBoxBottom);
1087     SCALE_METRIC(subscriptPositionX);
1088     SCALE_METRIC(subscriptPositionY);
1089     SCALE_METRIC(subscriptSizeX);
1090     SCALE_METRIC(subscriptSizeY);
1091     SCALE_METRIC(superscriptPositionX);
1092     SCALE_METRIC(superscriptPositionY);
1093     SCALE_METRIC(superscriptSizeX);
1094     SCALE_METRIC(superscriptSizeY);
1095
1096     metrics->hasTypographicMetrics = design->hasTypographicMetrics;
1097 #undef SCALE_METRIC
1098
1099     return S_OK;
1100 }
1101
1102 static void WINAPI dwritefontface1_GetCaretMetrics(IDWriteFontFace5 *iface, DWRITE_CARET_METRICS *metrics)
1103 {
1104     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1105
1106     TRACE("%p, %p.\n", iface, metrics);
1107
1108     *metrics = fontface->caret;
1109 }
1110
1111 static HRESULT WINAPI dwritefontface1_GetUnicodeRanges(IDWriteFontFace5 *iface, UINT32 max_count,
1112     DWRITE_UNICODE_RANGE *ranges, UINT32 *count)
1113 {
1114     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1115
1116     TRACE("%p, %u, %p, %p.\n", iface, max_count, ranges, count);
1117
1118     *count = 0;
1119     if (max_count && !ranges)
1120         return E_INVALIDARG;
1121
1122     dwrite_cmap_init(&fontface->cmap, NULL, fontface->index, fontface->type);
1123     return opentype_cmap_get_unicode_ranges(&fontface->cmap, max_count, ranges, count);
1124 }
1125
1126 static BOOL WINAPI dwritefontface1_IsMonospacedFont(IDWriteFontFace5 *iface)
1127 {
1128     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1129
1130     TRACE("%p.\n", iface);
1131
1132     return !!(fontface->flags & FONT_IS_MONOSPACED);
1133 }
1134
1135 static int fontface_get_design_advance(struct dwrite_fontface *fontface, DWRITE_MEASURING_MODE measuring_mode,
1136         float emsize, float ppdip, const DWRITE_MATRIX *transform, UINT16 glyph, BOOL is_sideways)
1137 {
1138     unsigned int adjustment = fontface_get_horz_metric_adjustment(fontface);
1139     BOOL has_contours;
1140     int advance;
1141
1142     if (is_sideways)
1143         FIXME("Sideways mode is not supported.\n");
1144
1145     switch (measuring_mode)
1146     {
1147         case DWRITE_MEASURING_MODE_NATURAL:
1148             advance = font_funcs->get_glyph_advance(&fontface->IDWriteFontFace5_iface, fontface->metrics.designUnitsPerEm,
1149                     glyph, measuring_mode, &has_contours);
1150             if (has_contours)
1151                 advance += adjustment;
1152
1153             return advance;
1154         case DWRITE_MEASURING_MODE_GDI_NATURAL:
1155         case DWRITE_MEASURING_MODE_GDI_CLASSIC:
1156             emsize *= ppdip;
1157             if (emsize == 0.0f)
1158                 return 0.0f;
1159
1160             if (transform && memcmp(transform, &identity, sizeof(*transform)))
1161                 FIXME("Transform is not supported.\n");
1162
1163             advance = font_funcs->get_glyph_advance(&fontface->IDWriteFontFace5_iface, emsize, glyph, measuring_mode,
1164                     &has_contours);
1165             if (has_contours)
1166                 advance = round_metric(advance * fontface->metrics.designUnitsPerEm / emsize + adjustment);
1167             else
1168                 advance = round_metric(advance * fontface->metrics.designUnitsPerEm / emsize);
1169
1170             return advance;
1171         default:
1172             WARN("Unknown measuring mode %u.\n", measuring_mode);
1173             return 0;
1174     }
1175 }
1176
1177 static HRESULT WINAPI dwritefontface1_GetDesignGlyphAdvances(IDWriteFontFace5 *iface,
1178     UINT32 glyph_count, UINT16 const *glyphs, INT32 *advances, BOOL is_sideways)
1179 {
1180     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1181     unsigned int i;
1182
1183     TRACE("%p, %u, %p, %p, %d.\n", iface, glyph_count, glyphs, advances, is_sideways);
1184
1185     if (is_sideways)
1186         FIXME("sideways mode not supported\n");
1187
1188     for (i = 0; i < glyph_count; ++i)
1189     {
1190         advances[i] = fontface_get_design_advance(fontface, DWRITE_MEASURING_MODE_NATURAL,
1191                 fontface->metrics.designUnitsPerEm, 1.0f, NULL, glyphs[i], is_sideways);
1192     }
1193
1194     return S_OK;
1195 }
1196
1197 static HRESULT WINAPI dwritefontface1_GetGdiCompatibleGlyphAdvances(IDWriteFontFace5 *iface,
1198     float em_size, float ppdip, const DWRITE_MATRIX *transform, BOOL use_gdi_natural,
1199     BOOL is_sideways, UINT32 glyph_count, UINT16 const *glyphs, INT32 *advances)
1200 {
1201     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1202     DWRITE_MEASURING_MODE measuring_mode;
1203     UINT32 i;
1204
1205     TRACE("%p, %.8e, %.8e, %p, %d, %d, %u, %p, %p.\n", iface, em_size, ppdip, transform,
1206         use_gdi_natural, is_sideways, glyph_count, glyphs, advances);
1207
1208     if (em_size < 0.0f || ppdip <= 0.0f) {
1209         memset(advances, 0, sizeof(*advances) * glyph_count);
1210         return E_INVALIDARG;
1211     }
1212
1213     if (em_size == 0.0f) {
1214         memset(advances, 0, sizeof(*advances) * glyph_count);
1215         return S_OK;
1216     }
1217
1218     measuring_mode = use_gdi_natural ? DWRITE_MEASURING_MODE_GDI_NATURAL : DWRITE_MEASURING_MODE_GDI_CLASSIC;
1219     for (i = 0; i < glyph_count; ++i)
1220     {
1221         advances[i] = fontface_get_design_advance(fontface, measuring_mode, em_size, ppdip, transform,
1222                 glyphs[i], is_sideways);
1223     }
1224
1225     return S_OK;
1226 }
1227
1228 static HRESULT WINAPI dwritefontface1_GetKerningPairAdjustments(IDWriteFontFace5 *iface, UINT32 count,
1229     const UINT16 *glyphs, INT32 *values)
1230 {
1231     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1232
1233     TRACE("%p, %u, %p, %p.\n", iface, count, glyphs, values);
1234
1235     if (!(glyphs || values) || !count)
1236         return E_INVALIDARG;
1237
1238     if (!glyphs || count == 1)
1239     {
1240         memset(values, 0, count * sizeof(*values));
1241         return E_INVALIDARG;
1242     }
1243
1244     return opentype_get_kerning_pairs(fontface, count, glyphs, values);
1245 }
1246
1247 static BOOL WINAPI dwritefontface1_HasKerningPairs(IDWriteFontFace5 *iface)
1248 {
1249     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1250
1251     TRACE("%p.\n", iface);
1252
1253     return opentype_has_kerning_pairs(fontface);
1254 }
1255
1256 static HRESULT WINAPI dwritefontface1_GetRecommendedRenderingMode(IDWriteFontFace5 *iface,
1257     FLOAT font_emsize, FLOAT dpiX, FLOAT dpiY, const DWRITE_MATRIX *transform, BOOL is_sideways,
1258     DWRITE_OUTLINE_THRESHOLD threshold, DWRITE_MEASURING_MODE measuring_mode, DWRITE_RENDERING_MODE *rendering_mode)
1259 {
1260     DWRITE_GRID_FIT_MODE gridfitmode;
1261     return IDWriteFontFace2_GetRecommendedRenderingMode((IDWriteFontFace2 *)iface, font_emsize, dpiX, dpiY, transform,
1262             is_sideways, threshold, measuring_mode, NULL, rendering_mode, &gridfitmode);
1263 }
1264
1265 static HRESULT WINAPI dwritefontface1_GetVerticalGlyphVariants(IDWriteFontFace5 *iface, UINT32 glyph_count,
1266         const UINT16 *nominal_glyphs, UINT16 *glyphs)
1267 {
1268     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1269
1270     TRACE("%p, %u, %p, %p.\n", iface, glyph_count, nominal_glyphs, glyphs);
1271
1272     return opentype_get_vertical_glyph_variants(fontface, glyph_count, nominal_glyphs, glyphs);
1273 }
1274
1275 static BOOL WINAPI dwritefontface1_HasVerticalGlyphVariants(IDWriteFontFace5 *iface)
1276 {
1277     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1278
1279     TRACE("%p.\n", iface);
1280
1281     return opentype_has_vertical_variants(fontface);
1282 }
1283
1284 static BOOL WINAPI dwritefontface2_IsColorFont(IDWriteFontFace5 *iface)
1285 {
1286     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1287
1288     TRACE("%p.\n", iface);
1289
1290     return !!(fontface->flags & FONT_IS_COLORED);
1291 }
1292
1293 static UINT32 WINAPI dwritefontface2_GetColorPaletteCount(IDWriteFontFace5 *iface)
1294 {
1295     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1296
1297     TRACE("%p.\n", iface);
1298
1299     return opentype_get_cpal_palettecount(get_fontface_cpal(fontface));
1300 }
1301
1302 static UINT32 WINAPI dwritefontface2_GetPaletteEntryCount(IDWriteFontFace5 *iface)
1303 {
1304     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1305
1306     TRACE("%p.\n", iface);
1307
1308     return opentype_get_cpal_paletteentrycount(get_fontface_cpal(fontface));
1309 }
1310
1311 static HRESULT WINAPI dwritefontface2_GetPaletteEntries(IDWriteFontFace5 *iface, UINT32 palette_index,
1312     UINT32 first_entry_index, UINT32 entry_count, DWRITE_COLOR_F *entries)
1313 {
1314     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1315
1316     TRACE("%p, %u, %u, %u, %p.\n", iface, palette_index, first_entry_index, entry_count, entries);
1317
1318     return opentype_get_cpal_entries(get_fontface_cpal(fontface), palette_index, first_entry_index, entry_count, entries);
1319 }
1320
1321 static HRESULT WINAPI dwritefontface2_GetRecommendedRenderingMode(IDWriteFontFace5 *iface, FLOAT emSize,
1322     FLOAT dpiX, FLOAT dpiY, DWRITE_MATRIX const *m, BOOL is_sideways, DWRITE_OUTLINE_THRESHOLD threshold,
1323     DWRITE_MEASURING_MODE measuringmode, IDWriteRenderingParams *params, DWRITE_RENDERING_MODE *renderingmode,
1324     DWRITE_GRID_FIT_MODE *gridfitmode)
1325 {
1326     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1327     unsigned int flags;
1328     FLOAT emthreshold;
1329
1330     TRACE("%p, %.8e, %.8e, %.8e, %p, %d, %d, %d, %p, %p, %p.\n", iface, emSize, dpiX, dpiY, m, is_sideways, threshold,
1331         measuringmode, params, renderingmode, gridfitmode);
1332
1333     if (m && memcmp(m, &identity, sizeof(*m)))
1334         FIXME("transform not supported %s\n", debugstr_matrix(m));
1335
1336     if (is_sideways)
1337         FIXME("sideways mode not supported\n");
1338
1339     emSize *= max(dpiX, dpiY) / 96.0f;
1340
1341     *renderingmode = DWRITE_RENDERING_MODE_DEFAULT;
1342     *gridfitmode = DWRITE_GRID_FIT_MODE_DEFAULT;
1343     if (params) {
1344         IDWriteRenderingParams2 *params2;
1345         HRESULT hr;
1346
1347         hr = IDWriteRenderingParams_QueryInterface(params, &IID_IDWriteRenderingParams2, (void**)&params2);
1348         if (hr == S_OK) {
1349             *renderingmode = IDWriteRenderingParams2_GetRenderingMode(params2);
1350             *gridfitmode = IDWriteRenderingParams2_GetGridFitMode(params2);
1351             IDWriteRenderingParams2_Release(params2);
1352         }
1353         else
1354             *renderingmode = IDWriteRenderingParams_GetRenderingMode(params);
1355     }
1356
1357     emthreshold = threshold == DWRITE_OUTLINE_THRESHOLD_ANTIALIASED ? RECOMMENDED_OUTLINE_AA_THRESHOLD : RECOMMENDED_OUTLINE_A_THRESHOLD;
1358
1359     flags = opentype_get_gasp_flags(get_fontface_gasp(fontface), emSize);
1360
1361     if (*renderingmode == DWRITE_RENDERING_MODE_DEFAULT) {
1362         if (emSize >= emthreshold)
1363             *renderingmode = DWRITE_RENDERING_MODE_OUTLINE;
1364         else
1365             *renderingmode = fontface_renderingmode_from_measuringmode(measuringmode, emSize, flags);
1366     }
1367
1368     if (*gridfitmode == DWRITE_GRID_FIT_MODE_DEFAULT) {
1369         if (emSize >= emthreshold)
1370             *gridfitmode = DWRITE_GRID_FIT_MODE_DISABLED;
1371         else if (measuringmode == DWRITE_MEASURING_MODE_GDI_CLASSIC || measuringmode == DWRITE_MEASURING_MODE_GDI_NATURAL)
1372             *gridfitmode = DWRITE_GRID_FIT_MODE_ENABLED;
1373         else
1374             *gridfitmode = flags & (GASP_GRIDFIT|GASP_SYMMETRIC_GRIDFIT) ?
1375                     DWRITE_GRID_FIT_MODE_ENABLED : DWRITE_GRID_FIT_MODE_DISABLED;
1376     }
1377
1378     return S_OK;
1379 }
1380
1381 static HRESULT WINAPI dwritefontface3_GetFontFaceReference(IDWriteFontFace5 *iface,
1382         IDWriteFontFaceReference **reference)
1383 {
1384     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1385
1386     TRACE("%p, %p.\n", iface, reference);
1387
1388     *reference = &fontface->IDWriteFontFaceReference_iface;
1389     IDWriteFontFaceReference_AddRef(*reference);
1390
1391     return S_OK;
1392 }
1393
1394 static void WINAPI dwritefontface3_GetPanose(IDWriteFontFace5 *iface, DWRITE_PANOSE *panose)
1395 {
1396     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1397
1398     TRACE("%p, %p.\n", iface, panose);
1399
1400     *panose = fontface->panose;
1401 }
1402
1403 static DWRITE_FONT_WEIGHT WINAPI dwritefontface3_GetWeight(IDWriteFontFace5 *iface)
1404 {
1405     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1406
1407     TRACE("%p.\n", iface);
1408
1409     return fontface->weight;
1410 }
1411
1412 static DWRITE_FONT_STRETCH WINAPI dwritefontface3_GetStretch(IDWriteFontFace5 *iface)
1413 {
1414     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1415
1416     TRACE("%p.\n", iface);
1417
1418     return fontface->stretch;
1419 }
1420
1421 static DWRITE_FONT_STYLE WINAPI dwritefontface3_GetStyle(IDWriteFontFace5 *iface)
1422 {
1423     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1424
1425     TRACE("%p.\n", iface);
1426
1427     return fontface->style;
1428 }
1429
1430 static HRESULT WINAPI dwritefontface3_GetFamilyNames(IDWriteFontFace5 *iface, IDWriteLocalizedStrings **names)
1431 {
1432     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1433
1434     TRACE("%p, %p.\n", iface, names);
1435
1436     return clone_localizedstrings(fontface->family_names, names);
1437 }
1438
1439 static HRESULT WINAPI dwritefontface3_GetFaceNames(IDWriteFontFace5 *iface, IDWriteLocalizedStrings **names)
1440 {
1441     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1442
1443     TRACE("%p, %p.\n", iface, names);
1444
1445     return clone_localizedstrings(fontface->names, names);
1446 }
1447
1448 static HRESULT get_font_info_strings(const struct file_stream_desc *stream_desc, IDWriteFontFile *file,
1449         DWRITE_INFORMATIONAL_STRING_ID stringid, IDWriteLocalizedStrings **strings_cache,
1450         IDWriteLocalizedStrings **ret, BOOL *exists)
1451 {
1452     HRESULT hr = S_OK;
1453
1454     *exists = FALSE;
1455     *ret = NULL;
1456
1457     if (stringid > DWRITE_INFORMATIONAL_STRING_SUPPORTED_SCRIPT_LANGUAGE_TAG
1458             || stringid <= DWRITE_INFORMATIONAL_STRING_NONE)
1459     {
1460         return S_OK;
1461     }
1462
1463     if (!strings_cache[stringid])
1464     {
1465         struct file_stream_desc desc = *stream_desc;
1466
1467         if (!desc.stream)
1468             hr = get_filestream_from_file(file, &desc.stream);
1469         if (SUCCEEDED(hr))
1470             opentype_get_font_info_strings(&desc, stringid, &strings_cache[stringid]);
1471
1472         if (!stream_desc->stream && desc.stream)
1473             IDWriteFontFileStream_Release(desc.stream);
1474     }
1475
1476     if (SUCCEEDED(hr) && strings_cache[stringid])
1477     {
1478         hr = clone_localizedstrings(strings_cache[stringid], ret);
1479         if (SUCCEEDED(hr))
1480             *exists = TRUE;
1481     }
1482
1483     return hr;
1484 }
1485
1486 static HRESULT WINAPI dwritefontface3_GetInformationalStrings(IDWriteFontFace5 *iface,
1487         DWRITE_INFORMATIONAL_STRING_ID stringid, IDWriteLocalizedStrings **strings, BOOL *exists)
1488 {
1489     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1490     struct file_stream_desc stream_desc;
1491
1492     TRACE("%p, %u, %p, %p.\n", iface, stringid, strings, exists);
1493
1494     stream_desc.stream = fontface->stream;
1495     stream_desc.face_index = fontface->index;
1496     stream_desc.face_type = fontface->type;
1497     return get_font_info_strings(&stream_desc, NULL, stringid, fontface->info_strings, strings, exists);
1498 }
1499
1500 static BOOL WINAPI dwritefontface3_HasCharacter(IDWriteFontFace5 *iface, UINT32 ch)
1501 {
1502     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1503
1504     TRACE("%p, %#x.\n", iface, ch);
1505
1506     return !!dwritefontface_get_glyph(fontface, ch);
1507 }
1508
1509 static HRESULT WINAPI dwritefontface3_GetRecommendedRenderingMode(IDWriteFontFace5 *iface, FLOAT emSize, FLOAT dpiX, FLOAT dpiY,
1510     DWRITE_MATRIX const *m, BOOL is_sideways, DWRITE_OUTLINE_THRESHOLD threshold, DWRITE_MEASURING_MODE measuring_mode,
1511     IDWriteRenderingParams *params, DWRITE_RENDERING_MODE1 *rendering_mode, DWRITE_GRID_FIT_MODE *gridfit_mode)
1512 {
1513     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1514     unsigned int flags;
1515     FLOAT emthreshold;
1516
1517     TRACE("%p, %.8e, %.8e, %.8e, %p, %d, %d, %d, %p, %p, %p.\n", iface, emSize, dpiX, dpiY, m, is_sideways, threshold,
1518         measuring_mode, params, rendering_mode, gridfit_mode);
1519
1520     if (m && memcmp(m, &identity, sizeof(*m)))
1521         FIXME("transform not supported %s\n", debugstr_matrix(m));
1522
1523     if (is_sideways)
1524         FIXME("sideways mode not supported\n");
1525
1526     emSize *= max(dpiX, dpiY) / 96.0f;
1527
1528     *rendering_mode = DWRITE_RENDERING_MODE1_DEFAULT;
1529     *gridfit_mode = DWRITE_GRID_FIT_MODE_DEFAULT;
1530     if (params) {
1531         IDWriteRenderingParams3 *params3;
1532         HRESULT hr;
1533
1534         hr = IDWriteRenderingParams_QueryInterface(params, &IID_IDWriteRenderingParams3, (void**)&params3);
1535         if (hr == S_OK) {
1536             *rendering_mode = IDWriteRenderingParams3_GetRenderingMode1(params3);
1537             *gridfit_mode = IDWriteRenderingParams3_GetGridFitMode(params3);
1538             IDWriteRenderingParams3_Release(params3);
1539         }
1540         else
1541             *rendering_mode = IDWriteRenderingParams_GetRenderingMode(params);
1542     }
1543
1544     emthreshold = threshold == DWRITE_OUTLINE_THRESHOLD_ANTIALIASED ? RECOMMENDED_OUTLINE_AA_THRESHOLD : RECOMMENDED_OUTLINE_A_THRESHOLD;
1545
1546     flags = opentype_get_gasp_flags(get_fontface_gasp(fontface), emSize);
1547
1548     if (*rendering_mode == DWRITE_RENDERING_MODE1_DEFAULT) {
1549         if (emSize >= emthreshold)
1550             *rendering_mode = DWRITE_RENDERING_MODE1_OUTLINE;
1551         else
1552             *rendering_mode = fontface_renderingmode_from_measuringmode(measuring_mode, emSize, flags);
1553     }
1554
1555     if (*gridfit_mode == DWRITE_GRID_FIT_MODE_DEFAULT) {
1556         if (emSize >= emthreshold)
1557             *gridfit_mode = DWRITE_GRID_FIT_MODE_DISABLED;
1558         else if (measuring_mode == DWRITE_MEASURING_MODE_GDI_CLASSIC || measuring_mode == DWRITE_MEASURING_MODE_GDI_NATURAL)
1559             *gridfit_mode = DWRITE_GRID_FIT_MODE_ENABLED;
1560         else
1561             *gridfit_mode = flags & (GASP_GRIDFIT|GASP_SYMMETRIC_GRIDFIT) ?
1562                     DWRITE_GRID_FIT_MODE_ENABLED : DWRITE_GRID_FIT_MODE_DISABLED;
1563     }
1564
1565     return S_OK;
1566 }
1567
1568 static BOOL WINAPI dwritefontface3_IsCharacterLocal(IDWriteFontFace5 *iface, UINT32 ch)
1569 {
1570     FIXME("%p, %#x: stub\n", iface, ch);
1571
1572     return FALSE;
1573 }
1574
1575 static BOOL WINAPI dwritefontface3_IsGlyphLocal(IDWriteFontFace5 *iface, UINT16 glyph)
1576 {
1577     FIXME("%p, %u: stub\n", iface, glyph);
1578
1579     return FALSE;
1580 }
1581
1582 static HRESULT WINAPI dwritefontface3_AreCharactersLocal(IDWriteFontFace5 *iface, WCHAR const *text,
1583     UINT32 count, BOOL enqueue_if_not, BOOL *are_local)
1584 {
1585     FIXME("%p, %s:%u, %d %p: stub\n", iface, debugstr_wn(text, count), count, enqueue_if_not, are_local);
1586
1587     return E_NOTIMPL;
1588 }
1589
1590 static HRESULT WINAPI dwritefontface3_AreGlyphsLocal(IDWriteFontFace5 *iface, UINT16 const *glyphs,
1591     UINT32 count, BOOL enqueue_if_not, BOOL *are_local)
1592 {
1593     FIXME("%p, %p, %u, %d, %p: stub\n", iface, glyphs, count, enqueue_if_not, are_local);
1594
1595     return E_NOTIMPL;
1596 }
1597
1598 static HRESULT WINAPI dwritefontface4_GetGlyphImageFormats_(IDWriteFontFace5 *iface, UINT16 glyph,
1599     UINT32 ppem_first, UINT32 ppem_last, DWRITE_GLYPH_IMAGE_FORMATS *formats)
1600 {
1601     FIXME("%p, %u, %u, %u, %p: stub\n", iface, glyph, ppem_first, ppem_last, formats);
1602
1603     return E_NOTIMPL;
1604 }
1605
1606 static DWRITE_GLYPH_IMAGE_FORMATS WINAPI dwritefontface4_GetGlyphImageFormats(IDWriteFontFace5 *iface)
1607 {
1608     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1609
1610     TRACE("%p.\n", iface);
1611
1612     return fontface->glyph_image_formats;
1613 }
1614
1615 static HRESULT WINAPI dwritefontface4_GetGlyphImageData(IDWriteFontFace5 *iface, UINT16 glyph,
1616     UINT32 ppem, DWRITE_GLYPH_IMAGE_FORMATS format, DWRITE_GLYPH_IMAGE_DATA *data, void **context)
1617 {
1618     FIXME("%p, %u, %u, %d, %p, %p: stub\n", iface, glyph, ppem, format, data, context);
1619
1620     return E_NOTIMPL;
1621 }
1622
1623 static void WINAPI dwritefontface4_ReleaseGlyphImageData(IDWriteFontFace5 *iface, void *context)
1624 {
1625     FIXME("%p, %p: stub\n", iface, context);
1626 }
1627
1628 static UINT32 WINAPI dwritefontface5_GetFontAxisValueCount(IDWriteFontFace5 *iface)
1629 {
1630     FIXME("%p: stub\n", iface);
1631
1632     return 0;
1633 }
1634
1635 static HRESULT WINAPI dwritefontface5_GetFontAxisValues(IDWriteFontFace5 *iface, DWRITE_FONT_AXIS_VALUE *axis_values,
1636         UINT32 value_count)
1637 {
1638     FIXME("%p, %p, %u: stub\n", iface, axis_values, value_count);
1639
1640     return E_NOTIMPL;
1641 }
1642
1643 static BOOL WINAPI dwritefontface5_HasVariations(IDWriteFontFace5 *iface)
1644 {
1645     static int once;
1646
1647     if (!once++)
1648         FIXME("%p: stub\n", iface);
1649
1650     return FALSE;
1651 }
1652
1653 static HRESULT WINAPI dwritefontface5_GetFontResource(IDWriteFontFace5 *iface, IDWriteFontResource **resource)
1654 {
1655     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface);
1656
1657     TRACE("%p, %p.\n", iface, resource);
1658
1659     return IDWriteFactory7_CreateFontResource(fontface->factory, fontface->file, fontface->index, resource);
1660 }
1661
1662 static BOOL WINAPI dwritefontface5_Equals(IDWriteFontFace5 *iface, IDWriteFontFace *other)
1663 {
1664     struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface), *other_face;
1665
1666     TRACE("%p, %p.\n", iface, other);
1667
1668     if (!(other_face = unsafe_impl_from_IDWriteFontFace(other)))
1669         return FALSE;
1670
1671     /* TODO: add variations support */
1672
1673     return fontface->index == other_face->index &&
1674             fontface->simulations == other_face->simulations &&
1675             is_same_fontfile(fontface->file, other_face->file);
1676 }
1677
1678 static const IDWriteFontFace5Vtbl dwritefontfacevtbl =
1679 {
1680     dwritefontface_QueryInterface,
1681     dwritefontface_AddRef,
1682     dwritefontface_Release,
1683     dwritefontface_GetType,
1684     dwritefontface_GetFiles,
1685     dwritefontface_GetIndex,
1686     dwritefontface_GetSimulations,
1687     dwritefontface_IsSymbolFont,
1688     dwritefontface_GetMetrics,
1689     dwritefontface_GetGlyphCount,
1690     dwritefontface_GetDesignGlyphMetrics,
1691     dwritefontface_GetGlyphIndices,
1692     dwritefontface_TryGetFontTable,
1693     dwritefontface_ReleaseFontTable,
1694     dwritefontface_GetGlyphRunOutline,
1695     dwritefontface_GetRecommendedRenderingMode,
1696     dwritefontface_GetGdiCompatibleMetrics,
1697     dwritefontface_GetGdiCompatibleGlyphMetrics,
1698     dwritefontface1_GetMetrics,
1699     dwritefontface1_GetGdiCompatibleMetrics,
1700     dwritefontface1_GetCaretMetrics,
1701     dwritefontface1_GetUnicodeRanges,
1702     dwritefontface1_IsMonospacedFont,
1703     dwritefontface1_GetDesignGlyphAdvances,
1704     dwritefontface1_GetGdiCompatibleGlyphAdvances,
1705     dwritefontface1_GetKerningPairAdjustments,
1706     dwritefontface1_HasKerningPairs,
1707     dwritefontface1_GetRecommendedRenderingMode,
1708     dwritefontface1_GetVerticalGlyphVariants,
1709     dwritefontface1_HasVerticalGlyphVariants,
1710     dwritefontface2_IsColorFont,
1711     dwritefontface2_GetColorPaletteCount,
1712     dwritefontface2_GetPaletteEntryCount,
1713     dwritefontface2_GetPaletteEntries,
1714     dwritefontface2_GetRecommendedRenderingMode,
1715     dwritefontface3_GetFontFaceReference,
1716     dwritefontface3_GetPanose,
1717     dwritefontface3_GetWeight,
1718     dwritefontface3_GetStretch,
1719     dwritefontface3_GetStyle,
1720     dwritefontface3_GetFamilyNames,
1721     dwritefontface3_GetFaceNames,
1722     dwritefontface3_GetInformationalStrings,
1723     dwritefontface3_HasCharacter,
1724     dwritefontface3_GetRecommendedRenderingMode,
1725     dwritefontface3_IsCharacterLocal,
1726     dwritefontface3_IsGlyphLocal,
1727     dwritefontface3_AreCharactersLocal,
1728     dwritefontface3_AreGlyphsLocal,
1729     dwritefontface4_GetGlyphImageFormats_,
1730     dwritefontface4_GetGlyphImageFormats,
1731     dwritefontface4_GetGlyphImageData,
1732     dwritefontface4_ReleaseGlyphImageData,
1733     dwritefontface5_GetFontAxisValueCount,
1734     dwritefontface5_GetFontAxisValues,
1735     dwritefontface5_HasVariations,
1736     dwritefontface5_GetFontResource,
1737     dwritefontface5_Equals,
1738 };
1739
1740 static HRESULT WINAPI dwritefontface_reference_QueryInterface(IDWriteFontFaceReference *iface, REFIID riid, void **obj)
1741 {
1742     struct dwrite_fontface *fontface = impl_from_IDWriteFontFaceReference(iface);
1743     return IDWriteFontFace5_QueryInterface(&fontface->IDWriteFontFace5_iface, riid, obj);
1744 }
1745
1746 static ULONG WINAPI dwritefontface_reference_AddRef(IDWriteFontFaceReference *iface)
1747 {
1748     struct dwrite_fontface *fontface = impl_from_IDWriteFontFaceReference(iface);
1749     return IDWriteFontFace5_AddRef(&fontface->IDWriteFontFace5_iface);
1750 }
1751
1752 static ULONG WINAPI dwritefontface_reference_Release(IDWriteFontFaceReference *iface)
1753 {
1754     struct dwrite_fontface *fontface = impl_from_IDWriteFontFaceReference(iface);
1755     return IDWriteFontFace5_Release(&fontface->IDWriteFontFace5_iface);
1756 }
1757
1758 static HRESULT WINAPI dwritefontface_reference_CreateFontFace(IDWriteFontFaceReference *iface,
1759         IDWriteFontFace3 **ret)
1760 {
1761     struct dwrite_fontface *fontface = impl_from_IDWriteFontFaceReference(iface);
1762
1763     TRACE("%p, %p.\n", iface, ret);
1764
1765     *ret = (IDWriteFontFace3 *)&fontface->IDWriteFontFace5_iface;
1766     IDWriteFontFace3_AddRef(*ret);
1767
1768     return S_OK;
1769 }
1770
1771 static HRESULT WINAPI dwritefontface_reference_CreateFontFaceWithSimulations(IDWriteFontFaceReference *iface,
1772         DWRITE_FONT_SIMULATIONS simulations, IDWriteFontFace3 **ret)
1773 {
1774     struct dwrite_fontface *fontface = impl_from_IDWriteFontFaceReference(iface);
1775     DWRITE_FONT_FILE_TYPE file_type;
1776     DWRITE_FONT_FACE_TYPE face_type;
1777     IDWriteFontFace *face;
1778     BOOL is_supported;
1779     UINT32 face_num;
1780     HRESULT hr;
1781
1782     TRACE("%p, %#x, %p.\n", iface, simulations, ret);
1783
1784     hr = IDWriteFontFile_Analyze(fontface->file, &is_supported, &file_type, &face_type, &face_num);
1785     if (FAILED(hr))
1786         return hr;
1787
1788     hr = IDWriteFactory7_CreateFontFace(fontface->factory, face_type, 1, &fontface->file, fontface->index,
1789             simulations, &face);
1790     if (SUCCEEDED(hr))
1791     {
1792         hr = IDWriteFontFace_QueryInterface(face, &IID_IDWriteFontFace3, (void **)ret);
1793         IDWriteFontFace_Release(face);
1794     }
1795
1796     return hr;
1797 }
1798
1799 static BOOL WINAPI dwritefontface_reference_Equals(IDWriteFontFaceReference *iface, IDWriteFontFaceReference *ref)
1800 {
1801     FIXME("%p, %p.\n", iface, ref);
1802
1803     return E_NOTIMPL;
1804 }
1805
1806 static UINT32 WINAPI dwritefontface_reference_GetFontFaceIndex(IDWriteFontFaceReference *iface)
1807 {
1808     struct dwrite_fontface *fontface = impl_from_IDWriteFontFaceReference(iface);
1809
1810     TRACE("%p.\n", iface);
1811
1812     return fontface->index;
1813 }
1814
1815 static DWRITE_FONT_SIMULATIONS WINAPI dwritefontface_reference_GetSimulations(IDWriteFontFaceReference *iface)
1816 {
1817     struct dwrite_fontface *fontface = impl_from_IDWriteFontFaceReference(iface);
1818
1819     TRACE("%p.\n", iface);
1820
1821     return fontface->simulations;
1822 }
1823
1824 static HRESULT WINAPI dwritefontface_reference_GetFontFile(IDWriteFontFaceReference *iface, IDWriteFontFile **file)
1825 {
1826     struct dwrite_fontface *fontface = impl_from_IDWriteFontFaceReference(iface);
1827
1828     TRACE("%p, %p.\n", iface, file);
1829
1830     *file = fontface->file;
1831     IDWriteFontFile_AddRef(*file);
1832
1833     return S_OK;
1834 }
1835
1836 static UINT64 WINAPI dwritefontface_reference_GetLocalFileSize(IDWriteFontFaceReference *iface)
1837 {
1838     FIXME("%p.\n", iface);
1839
1840     return 0;
1841 }
1842
1843 static UINT64 WINAPI dwritefontface_reference_GetFileSize(IDWriteFontFaceReference *iface)
1844 {
1845     FIXME("%p.\n", iface);
1846
1847     return 0;
1848 }
1849
1850 static HRESULT WINAPI dwritefontface_reference_GetFileTime(IDWriteFontFaceReference *iface, FILETIME *writetime)
1851 {
1852     FIXME("%p, %p.\n", iface, writetime);
1853
1854     return E_NOTIMPL;
1855 }
1856
1857 static DWRITE_LOCALITY WINAPI dwritefontface_reference_GetLocality(IDWriteFontFaceReference *iface)
1858 {
1859     FIXME("%p.\n", iface);
1860
1861     return DWRITE_LOCALITY_LOCAL;
1862 }
1863
1864 static HRESULT WINAPI dwritefontface_reference_EnqueueFontDownloadRequest(IDWriteFontFaceReference *iface)
1865 {
1866     FIXME("%p.\n", iface);
1867
1868     return E_NOTIMPL;
1869 }
1870
1871 static HRESULT WINAPI dwritefontface_reference_EnqueueCharacterDownloadRequest(IDWriteFontFaceReference *iface,
1872         WCHAR const *chars, UINT32 count)
1873 {
1874     FIXME("%p, %s, %u.\n", iface, debugstr_wn(chars, count), count);
1875
1876     return E_NOTIMPL;
1877 }
1878
1879 static HRESULT WINAPI dwritefontface_reference_EnqueueGlyphDownloadRequest(IDWriteFontFaceReference *iface,
1880         UINT16 const *glyphs, UINT32 count)
1881 {
1882     FIXME("%p, %p, %u.\n", iface, glyphs, count);
1883
1884     return E_NOTIMPL;
1885 }
1886
1887 static HRESULT WINAPI dwritefontface_reference_EnqueueFileFragmentDownloadRequest(IDWriteFontFaceReference *iface,
1888         UINT64 offset, UINT64 size)
1889 {
1890     FIXME("%p, 0x%s, 0x%s.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(size));
1891
1892     return E_NOTIMPL;
1893 }
1894
1895 static const IDWriteFontFaceReferenceVtbl dwritefontface_reference_vtbl =
1896 {
1897     dwritefontface_reference_QueryInterface,
1898     dwritefontface_reference_AddRef,
1899     dwritefontface_reference_Release,
1900     dwritefontface_reference_CreateFontFace,
1901     dwritefontface_reference_CreateFontFaceWithSimulations,
1902     dwritefontface_reference_Equals,
1903     dwritefontface_reference_GetFontFaceIndex,
1904     dwritefontface_reference_GetSimulations,
1905     dwritefontface_reference_GetFontFile,
1906     dwritefontface_reference_GetLocalFileSize,
1907     dwritefontface_reference_GetFileSize,
1908     dwritefontface_reference_GetFileTime,
1909     dwritefontface_reference_GetLocality,
1910     dwritefontface_reference_EnqueueFontDownloadRequest,
1911     dwritefontface_reference_EnqueueCharacterDownloadRequest,
1912     dwritefontface_reference_EnqueueGlyphDownloadRequest,
1913     dwritefontface_reference_EnqueueFileFragmentDownloadRequest,
1914 };
1915
1916 static HRESULT get_fontface_from_font(struct dwrite_font *font, IDWriteFontFace5 **fontface)
1917 {
1918     struct dwrite_font_data *data = font->data;
1919     struct fontface_desc desc;
1920     struct list *cached_list;
1921     HRESULT hr;
1922
1923     *fontface = NULL;
1924
1925     hr = factory_get_cached_fontface(font->family->collection->factory, &data->file, data->face_index,
1926             font->data->simulations, &cached_list, &IID_IDWriteFontFace4, (void **)fontface);
1927     if (hr == S_OK)
1928         return hr;
1929
1930     if (FAILED(hr = get_filestream_from_file(data->file, &desc.stream)))
1931         return hr;
1932
1933     desc.factory = font->family->collection->factory;
1934     desc.face_type = data->face_type;
1935     desc.file = data->file;
1936     desc.index = data->face_index;
1937     desc.simulations = data->simulations;
1938     desc.font_data = data;
1939     hr = create_fontface(&desc, cached_list, fontface);
1940
1941     IDWriteFontFileStream_Release(desc.stream);
1942     return hr;
1943 }
1944
1945 static HRESULT WINAPI dwritefont_QueryInterface(IDWriteFont3 *iface, REFIID riid, void **obj)
1946 {
1947     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1948
1949     if (IsEqualIID(riid, &IID_IDWriteFont3) ||
1950         IsEqualIID(riid, &IID_IDWriteFont2) ||
1951         IsEqualIID(riid, &IID_IDWriteFont1) ||
1952         IsEqualIID(riid, &IID_IDWriteFont)  ||
1953         IsEqualIID(riid, &IID_IUnknown))
1954     {
1955         *obj = iface;
1956         IDWriteFont3_AddRef(iface);
1957         return S_OK;
1958     }
1959
1960     WARN("%s not implemented.\n", debugstr_guid(riid));
1961
1962     *obj = NULL;
1963     return E_NOINTERFACE;
1964 }
1965
1966 static ULONG WINAPI dwritefont_AddRef(IDWriteFont3 *iface)
1967 {
1968     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
1969     ULONG refcount = InterlockedIncrement(&font->refcount);
1970
1971     TRACE("%p, refcount %d.\n", iface, refcount);
1972
1973     return refcount;
1974 }
1975
1976 static ULONG WINAPI dwritefont_Release(IDWriteFont3 *iface)
1977 {
1978     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
1979     ULONG refcount = InterlockedDecrement(&font->refcount);
1980
1981     TRACE("%p, refcount %d.\n", iface, refcount);
1982
1983     if (!refcount)
1984     {
1985         IDWriteFontFamily2_Release(&font->family->IDWriteFontFamily2_iface);
1986         release_font_data(font->data);
1987         heap_free(font);
1988     }
1989
1990     return refcount;
1991 }
1992
1993 static HRESULT WINAPI dwritefont_GetFontFamily(IDWriteFont3 *iface, IDWriteFontFamily **family)
1994 {
1995     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
1996
1997     TRACE("%p, %p.\n", iface, family);
1998
1999     *family = (IDWriteFontFamily *)font->family;
2000     IDWriteFontFamily_AddRef(*family);
2001     return S_OK;
2002 }
2003
2004 static DWRITE_FONT_WEIGHT WINAPI dwritefont_GetWeight(IDWriteFont3 *iface)
2005 {
2006     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2007
2008     TRACE("%p.\n", iface);
2009
2010     return font->data->weight;
2011 }
2012
2013 static DWRITE_FONT_STRETCH WINAPI dwritefont_GetStretch(IDWriteFont3 *iface)
2014 {
2015     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2016
2017     TRACE("%p.\n", iface);
2018
2019     return font->data->stretch;
2020 }
2021
2022 static DWRITE_FONT_STYLE WINAPI dwritefont_GetStyle(IDWriteFont3 *iface)
2023 {
2024     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2025
2026     TRACE("%p.\n", iface);
2027
2028     return font->style;
2029 }
2030
2031 static BOOL WINAPI dwritefont_IsSymbolFont(IDWriteFont3 *iface)
2032 {
2033     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2034
2035     TRACE("%p.\n", iface);
2036
2037     return !!(font->data->flags & FONT_IS_SYMBOL);
2038 }
2039
2040 static HRESULT WINAPI dwritefont_GetFaceNames(IDWriteFont3 *iface, IDWriteLocalizedStrings **names)
2041 {
2042     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2043
2044     TRACE("%p, %p.\n", iface, names);
2045
2046     return clone_localizedstrings(font->data->names, names);
2047 }
2048
2049 static HRESULT WINAPI dwritefont_GetInformationalStrings(IDWriteFont3 *iface,
2050     DWRITE_INFORMATIONAL_STRING_ID stringid, IDWriteLocalizedStrings **strings, BOOL *exists)
2051 {
2052     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2053     struct dwrite_font_data *data = font->data;
2054     struct file_stream_desc stream_desc;
2055
2056     TRACE("%p, %d, %p, %p.\n", iface, stringid, strings, exists);
2057
2058     /* Stream will be created if necessary. */
2059     stream_desc.stream = NULL;
2060     stream_desc.face_index = data->face_index;
2061     stream_desc.face_type = data->face_type;
2062     return get_font_info_strings(&stream_desc, data->file, stringid, data->info_strings, strings, exists);
2063 }
2064
2065 static DWRITE_FONT_SIMULATIONS WINAPI dwritefont_GetSimulations(IDWriteFont3 *iface)
2066 {
2067     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2068
2069     TRACE("%p.\n", iface);
2070
2071     return font->data->simulations;
2072 }
2073
2074 static void WINAPI dwritefont_GetMetrics(IDWriteFont3 *iface, DWRITE_FONT_METRICS *metrics)
2075 {
2076     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2077
2078     TRACE("%p, %p.\n", iface, metrics);
2079
2080     memcpy(metrics, &font->data->metrics, sizeof(*metrics));
2081 }
2082
2083 static BOOL dwritefont_has_character(struct dwrite_font *font, UINT32 ch)
2084 {
2085     UINT16 glyph;
2086     dwrite_cmap_init(&font->data->cmap, font->data->file, font->data->face_index, font->data->face_type);
2087     glyph = opentype_cmap_get_glyph(&font->data->cmap, ch);
2088     return glyph != 0;
2089 }
2090
2091 static HRESULT WINAPI dwritefont_HasCharacter(IDWriteFont3 *iface, UINT32 ch, BOOL *exists)
2092 {
2093     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2094
2095     TRACE("%p, %#x, %p.\n", iface, ch, exists);
2096
2097     *exists = dwritefont_has_character(font, ch);
2098
2099     return S_OK;
2100 }
2101
2102 static HRESULT WINAPI dwritefont_CreateFontFace(IDWriteFont3 *iface, IDWriteFontFace **fontface)
2103 {
2104     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2105
2106     TRACE("%p, %p.\n", iface, fontface);
2107
2108     return get_fontface_from_font(font, (IDWriteFontFace5 **)fontface);
2109 }
2110
2111 static void WINAPI dwritefont1_GetMetrics(IDWriteFont3 *iface, DWRITE_FONT_METRICS1 *metrics)
2112 {
2113     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2114
2115     TRACE("%p, %p.\n", iface, metrics);
2116
2117     *metrics = font->data->metrics;
2118 }
2119
2120 static void WINAPI dwritefont1_GetPanose(IDWriteFont3 *iface, DWRITE_PANOSE *panose)
2121 {
2122     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2123
2124     TRACE("%p, %p.\n", iface, panose);
2125
2126     *panose = font->data->panose;
2127 }
2128
2129 static HRESULT WINAPI dwritefont1_GetUnicodeRanges(IDWriteFont3 *iface, UINT32 max_count, DWRITE_UNICODE_RANGE *ranges,
2130         UINT32 *count)
2131 {
2132     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2133
2134     TRACE("%p, %u, %p, %p.\n", iface, max_count, ranges, count);
2135
2136     *count = 0;
2137     if (max_count && !ranges)
2138         return E_INVALIDARG;
2139
2140     dwrite_cmap_init(&font->data->cmap, font->data->file, font->data->face_index, font->data->face_type);
2141     return opentype_cmap_get_unicode_ranges(&font->data->cmap, max_count, ranges, count);
2142 }
2143
2144 static BOOL WINAPI dwritefont1_IsMonospacedFont(IDWriteFont3 *iface)
2145 {
2146     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2147
2148     TRACE("%p.\n", iface);
2149
2150     return !!(font->data->flags & FONT_IS_MONOSPACED);
2151 }
2152
2153 static BOOL WINAPI dwritefont2_IsColorFont(IDWriteFont3 *iface)
2154 {
2155     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2156
2157     TRACE("%p.\n", iface);
2158
2159     return !!(font->data->flags & FONT_IS_COLORED);
2160 }
2161
2162 static HRESULT WINAPI dwritefont3_CreateFontFace(IDWriteFont3 *iface, IDWriteFontFace3 **fontface)
2163 {
2164     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2165
2166     TRACE("%p, %p.\n", iface, fontface);
2167
2168     return get_fontface_from_font(font, (IDWriteFontFace5 **)fontface);
2169 }
2170
2171 static BOOL WINAPI dwritefont3_Equals(IDWriteFont3 *iface, IDWriteFont *other)
2172 {
2173     struct dwrite_font *font = impl_from_IDWriteFont3(iface), *other_font;
2174
2175     TRACE("%p, %p.\n", iface, other);
2176
2177     if (!(other_font = unsafe_impl_from_IDWriteFont(other)))
2178         return FALSE;
2179
2180     return font->data->face_index == other_font->data->face_index
2181             && font->data->simulations == other_font->data->simulations
2182             && is_same_fontfile(font->data->file, other_font->data->file);
2183 }
2184
2185 static HRESULT WINAPI dwritefont3_GetFontFaceReference(IDWriteFont3 *iface, IDWriteFontFaceReference **reference)
2186 {
2187     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2188
2189     TRACE("%p, %p.\n", iface, reference);
2190
2191     return IDWriteFactory7_CreateFontFaceReference(font->family->collection->factory, font->data->file,
2192             font->data->face_index, font->data->simulations, font->data->axis, ARRAY_SIZE(font->data->axis),
2193             (IDWriteFontFaceReference1 **)reference);
2194 }
2195
2196 static BOOL WINAPI dwritefont3_HasCharacter(IDWriteFont3 *iface, UINT32 ch)
2197 {
2198     struct dwrite_font *font = impl_from_IDWriteFont3(iface);
2199
2200     TRACE("%p, %#x.\n", iface, ch);
2201
2202     return dwritefont_has_character(font, ch);
2203 }
2204
2205 static DWRITE_LOCALITY WINAPI dwritefont3_GetLocality(IDWriteFont3 *iface)
2206 {
2207     FIXME("%p: stub.\n", iface);
2208
2209     return DWRITE_LOCALITY_LOCAL;
2210 }
2211
2212 static const IDWriteFont3Vtbl dwritefontvtbl = {
2213     dwritefont_QueryInterface,
2214     dwritefont_AddRef,
2215     dwritefont_Release,
2216     dwritefont_GetFontFamily,
2217     dwritefont_GetWeight,
2218     dwritefont_GetStretch,
2219     dwritefont_GetStyle,
2220     dwritefont_IsSymbolFont,
2221     dwritefont_GetFaceNames,
2222     dwritefont_GetInformationalStrings,
2223     dwritefont_GetSimulations,
2224     dwritefont_GetMetrics,
2225     dwritefont_HasCharacter,
2226     dwritefont_CreateFontFace,
2227     dwritefont1_GetMetrics,
2228     dwritefont1_GetPanose,
2229     dwritefont1_GetUnicodeRanges,
2230     dwritefont1_IsMonospacedFont,
2231     dwritefont2_IsColorFont,
2232     dwritefont3_CreateFontFace,
2233     dwritefont3_Equals,
2234     dwritefont3_GetFontFaceReference,
2235     dwritefont3_HasCharacter,
2236     dwritefont3_GetLocality
2237 };
2238
2239 static struct dwrite_font *unsafe_impl_from_IDWriteFont(IDWriteFont *iface)
2240 {
2241     if (!iface)
2242         return NULL;
2243     assert(iface->lpVtbl == (IDWriteFontVtbl*)&dwritefontvtbl);
2244     return CONTAINING_RECORD(iface, struct dwrite_font, IDWriteFont3_iface);
2245 }
2246
2247 struct dwrite_fontface *unsafe_impl_from_IDWriteFontFace(IDWriteFontFace *iface)
2248 {
2249     if (!iface)
2250         return NULL;
2251     assert(iface->lpVtbl == (IDWriteFontFaceVtbl*)&dwritefontfacevtbl);
2252     return CONTAINING_RECORD(iface, struct dwrite_fontface, IDWriteFontFace5_iface);
2253 }
2254
2255 static struct dwrite_fontfacereference *unsafe_impl_from_IDWriteFontFaceReference(IDWriteFontFaceReference *iface)
2256 {
2257     if (!iface)
2258         return NULL;
2259     if (iface->lpVtbl != (IDWriteFontFaceReferenceVtbl *)&fontfacereferencevtbl)
2260         return NULL;
2261     return CONTAINING_RECORD((IDWriteFontFaceReference1 *)iface, struct dwrite_fontfacereference,
2262             IDWriteFontFaceReference1_iface);
2263 }
2264
2265 void get_logfont_from_font(IDWriteFont *iface, LOGFONTW *lf)
2266 {
2267     struct dwrite_font *font = unsafe_impl_from_IDWriteFont(iface);
2268     *lf = font->data->lf;
2269 }
2270
2271 void get_logfont_from_fontface(IDWriteFontFace *iface, LOGFONTW *lf)
2272 {
2273     struct dwrite_fontface *fontface = unsafe_impl_from_IDWriteFontFace(iface);
2274     *lf = fontface->lf;
2275 }
2276
2277 HRESULT get_fontsig_from_font(IDWriteFont *iface, FONTSIGNATURE *fontsig)
2278 {
2279     struct dwrite_font *font = unsafe_impl_from_IDWriteFont(iface);
2280     *fontsig = font->data->fontsig;
2281     return S_OK;
2282 }
2283
2284 HRESULT get_fontsig_from_fontface(IDWriteFontFace *iface, FONTSIGNATURE *fontsig)
2285 {
2286     struct dwrite_fontface *fontface = unsafe_impl_from_IDWriteFontFace(iface);
2287     *fontsig = fontface->fontsig;
2288     return S_OK;
2289 }
2290
2291 static HRESULT create_font(struct dwrite_fontfamily *family, UINT32 index, IDWriteFont3 **font)
2292 {
2293     struct dwrite_font *object;
2294
2295     *font = NULL;
2296
2297     if (!(object = heap_alloc(sizeof(*object))))
2298         return E_OUTOFMEMORY;
2299
2300     object->IDWriteFont3_iface.lpVtbl = &dwritefontvtbl;
2301     object->refcount = 1;
2302     object->family = family;
2303     IDWriteFontFamily2_AddRef(&family->IDWriteFontFamily2_iface);
2304     object->data = family->data->fonts[index];
2305     object->style = object->data->style;
2306     addref_font_data(object->data);
2307
2308     *font = &object->IDWriteFont3_iface;
2309
2310     return S_OK;
2311 }
2312
2313 /* IDWriteFontList2 */
2314 static HRESULT WINAPI dwritefontlist_QueryInterface(IDWriteFontList2 *iface, REFIID riid, void **obj)
2315 {
2316     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
2317
2318     if (IsEqualIID(riid, &IID_IDWriteFontList2) ||
2319         IsEqualIID(riid, &IID_IDWriteFontList1) ||
2320         IsEqualIID(riid, &IID_IDWriteFontList) ||
2321         IsEqualIID(riid, &IID_IUnknown))
2322     {
2323         *obj = iface;
2324         IDWriteFontList2_AddRef(iface);
2325         return S_OK;
2326     }
2327
2328     WARN("%s not implemented.\n", debugstr_guid(riid));
2329
2330     *obj = NULL;
2331     return E_NOINTERFACE;
2332 }
2333
2334 static ULONG WINAPI dwritefontlist_AddRef(IDWriteFontList2 *iface)
2335 {
2336     struct dwrite_fontlist *fontlist = impl_from_IDWriteFontList2(iface);
2337     ULONG refcount = InterlockedIncrement(&fontlist->refcount);
2338
2339     TRACE("%p, refcount %u.\n", iface, refcount);
2340
2341     return refcount;
2342 }
2343
2344 static ULONG WINAPI dwritefontlist_Release(IDWriteFontList2 *iface)
2345 {
2346     struct dwrite_fontlist *fontlist = impl_from_IDWriteFontList2(iface);
2347     ULONG refcount = InterlockedDecrement(&fontlist->refcount);
2348
2349     TRACE("%p, refcount %u.\n", iface, refcount);
2350
2351     if (!refcount)
2352     {
2353         UINT32 i;
2354
2355         for (i = 0; i < fontlist->font_count; i++)
2356             release_font_data(fontlist->fonts[i]);
2357         IDWriteFontFamily2_Release(&fontlist->family->IDWriteFontFamily2_iface);
2358         heap_free(fontlist->fonts);
2359         heap_free(fontlist);
2360     }
2361
2362     return refcount;
2363 }
2364
2365 static HRESULT WINAPI dwritefontlist_GetFontCollection(IDWriteFontList2 *iface, IDWriteFontCollection **collection)
2366 {
2367     struct dwrite_fontlist *fontlist = impl_from_IDWriteFontList2(iface);
2368     return IDWriteFontFamily2_GetFontCollection(&fontlist->family->IDWriteFontFamily2_iface, collection);
2369 }
2370
2371 static UINT32 WINAPI dwritefontlist_GetFontCount(IDWriteFontList2 *iface)
2372 {
2373     struct dwrite_fontlist *fontlist = impl_from_IDWriteFontList2(iface);
2374
2375     TRACE("%p.\n", iface);
2376
2377     return fontlist->font_count;
2378 }
2379
2380 static HRESULT WINAPI dwritefontlist_GetFont(IDWriteFontList2 *iface, UINT32 index, IDWriteFont **font)
2381 {
2382     struct dwrite_fontlist *fontlist = impl_from_IDWriteFontList2(iface);
2383
2384     TRACE("%p, %u, %p.\n", iface, index, font);
2385
2386     *font = NULL;
2387
2388     if (fontlist->font_count == 0)
2389         return S_FALSE;
2390
2391     if (index >= fontlist->font_count)
2392         return E_INVALIDARG;
2393
2394     return create_font(fontlist->family, index, (IDWriteFont3 **)font);
2395 }
2396
2397 static DWRITE_LOCALITY WINAPI dwritefontlist1_GetFontLocality(IDWriteFontList2 *iface, UINT32 index)
2398 {
2399     FIXME("%p, %u.\n", iface, index);
2400
2401     return DWRITE_LOCALITY_LOCAL;
2402 }
2403
2404 static HRESULT fontlist_get_font(const struct dwrite_fontlist *fontlist, unsigned int index,
2405         IDWriteFont3 **font)
2406 {
2407     *font = NULL;
2408
2409     if (fontlist->font_count == 0)
2410         return S_FALSE;
2411
2412     if (index >= fontlist->font_count)
2413         return E_FAIL;
2414
2415     return create_font(fontlist->family, index, font);
2416 }
2417
2418 static HRESULT WINAPI dwritefontlist1_GetFont(IDWriteFontList2 *iface, UINT32 index, IDWriteFont3 **font)
2419 {
2420     struct dwrite_fontlist *fontlist = impl_from_IDWriteFontList2(iface);
2421
2422     TRACE("%p, %u, %p.\n", iface, index, font);
2423
2424     return fontlist_get_font(fontlist, index, font);
2425 }
2426
2427 static HRESULT WINAPI dwritefontlist1_GetFontFaceReference(IDWriteFontList2 *iface, UINT32 index,
2428     IDWriteFontFaceReference **reference)
2429 {
2430     struct dwrite_fontlist *fontlist = impl_from_IDWriteFontList2(iface);
2431     IDWriteFont3 *font;
2432     HRESULT hr;
2433
2434     TRACE("%p, %u, %p.\n", iface, index, reference);
2435
2436     *reference = NULL;
2437
2438     if (SUCCEEDED(hr = fontlist_get_font(fontlist, index, &font)))
2439     {
2440         hr = IDWriteFont3_GetFontFaceReference(font, reference);
2441         IDWriteFont3_Release(font);
2442     }
2443
2444     return hr;
2445 }
2446
2447 static HRESULT WINAPI dwritefontlist2_GetFontSet(IDWriteFontList2 *iface, IDWriteFontSet1 **fontset)
2448 {
2449     struct dwrite_fontlist *fontlist = impl_from_IDWriteFontList2(iface);
2450
2451     TRACE("%p, %p.\n", iface, fontset);
2452
2453     return fontset_create_from_font_data(fontlist->family->collection->factory, fontlist->fonts,
2454             fontlist->font_count, fontset);
2455 }
2456
2457 static const IDWriteFontList2Vtbl dwritefontlistvtbl =
2458 {
2459     dwritefontlist_QueryInterface,
2460     dwritefontlist_AddRef,
2461     dwritefontlist_Release,
2462     dwritefontlist_GetFontCollection,
2463     dwritefontlist_GetFontCount,
2464     dwritefontlist_GetFont,
2465     dwritefontlist1_GetFontLocality,
2466     dwritefontlist1_GetFont,
2467     dwritefontlist1_GetFontFaceReference,
2468     dwritefontlist2_GetFontSet,
2469 };
2470
2471 static HRESULT WINAPI dwritefontfamily_QueryInterface(IDWriteFontFamily2 *iface, REFIID riid, void **obj)
2472 {
2473     struct dwrite_fontfamily *family = impl_from_IDWriteFontFamily2(iface);
2474
2475     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
2476
2477     if (IsEqualIID(riid, &IID_IDWriteFontFamily2) ||
2478         IsEqualIID(riid, &IID_IDWriteFontFamily1) ||
2479         IsEqualIID(riid, &IID_IDWriteFontFamily) ||
2480         IsEqualIID(riid, &IID_IUnknown))
2481     {
2482         *obj = iface;
2483     }
2484     else if (IsEqualIID(riid, &IID_IDWriteFontList2) ||
2485         IsEqualIID(riid, &IID_IDWriteFontList1) ||
2486         IsEqualIID(riid, &IID_IDWriteFontList))
2487     {
2488         *obj = &family->IDWriteFontList2_iface;
2489     }
2490     else
2491     {
2492         WARN("%s not implemented.\n", debugstr_guid(riid));
2493         *obj = NULL;
2494         return E_NOINTERFACE;
2495     }
2496
2497     IUnknown_AddRef((IUnknown *)*obj);
2498     return S_OK;
2499 }
2500
2501 static ULONG WINAPI dwritefontfamily_AddRef(IDWriteFontFamily2 *iface)
2502 {
2503     struct dwrite_fontfamily *family = impl_from_IDWriteFontFamily2(iface);
2504     ULONG refcount = InterlockedIncrement(&family->refcount);
2505
2506     TRACE("%p, %u.\n", iface, refcount);
2507
2508     return refcount;
2509 }
2510
2511 static ULONG WINAPI dwritefontfamily_Release(IDWriteFontFamily2 *iface)
2512 {
2513     struct dwrite_fontfamily *family = impl_from_IDWriteFontFamily2(iface);
2514     ULONG refcount = InterlockedDecrement(&family->refcount);
2515
2516     TRACE("%p, %u.\n", iface, refcount);
2517
2518     if (!refcount)
2519     {
2520         IDWriteFontCollection3_Release(&family->collection->IDWriteFontCollection3_iface);
2521         release_fontfamily_data(family->data);
2522         heap_free(family);
2523     }
2524
2525     return refcount;
2526 }
2527
2528 static HRESULT WINAPI dwritefontfamily_GetFontCollection(IDWriteFontFamily2 *iface, IDWriteFontCollection **collection)
2529 {
2530     struct dwrite_fontfamily *family = impl_from_IDWriteFontFamily2(iface);
2531
2532     TRACE("%p, %p.\n", iface, collection);
2533
2534     *collection = (IDWriteFontCollection *)family->collection;
2535     IDWriteFontCollection_AddRef(*collection);
2536     return S_OK;
2537 }
2538
2539 static UINT32 WINAPI dwritefontfamily_GetFontCount(IDWriteFontFamily2 *iface)
2540 {
2541     struct dwrite_fontfamily *family = impl_from_IDWriteFontFamily2(iface);
2542
2543     TRACE("%p.\n", iface);
2544
2545     return family->data->count;
2546 }
2547
2548 static HRESULT WINAPI dwritefontfamily_GetFont(IDWriteFontFamily2 *iface, UINT32 index, IDWriteFont **font)
2549 {
2550     struct dwrite_fontfamily *family = impl_from_IDWriteFontFamily2(iface);
2551
2552     TRACE("%p, %u, %p.\n", iface, index, font);
2553
2554     *font = NULL;
2555
2556     if (!family->data->count)
2557         return S_FALSE;
2558
2559     if (index >= family->data->count)
2560         return E_INVALIDARG;
2561
2562     return create_font(family, index, (IDWriteFont3 **)font);
2563 }
2564
2565 static HRESULT WINAPI dwritefontfamily_GetFamilyNames(IDWriteFontFamily2 *iface, IDWriteLocalizedStrings **names)
2566 {
2567     struct dwrite_fontfamily *family = impl_from_IDWriteFontFamily2(iface);
2568
2569     TRACE("%p, %p.\n", iface, names);
2570
2571     return clone_localizedstrings(family->data->familyname, names);
2572 }
2573
2574 static BOOL is_better_font_match(const struct dwrite_font_propvec *next, const struct dwrite_font_propvec *cur,
2575     const struct dwrite_font_propvec *req)
2576 {
2577     FLOAT cur_to_req = get_font_prop_vec_distance(cur, req);
2578     FLOAT next_to_req = get_font_prop_vec_distance(next, req);
2579     FLOAT cur_req_prod, next_req_prod;
2580
2581     if (next_to_req < cur_to_req)
2582         return TRUE;
2583
2584     if (next_to_req > cur_to_req)
2585         return FALSE;
2586
2587     cur_req_prod = get_font_prop_vec_dotproduct(cur, req);
2588     next_req_prod = get_font_prop_vec_dotproduct(next, req);
2589
2590     if (next_req_prod > cur_req_prod)
2591         return TRUE;
2592
2593     if (next_req_prod < cur_req_prod)
2594         return FALSE;
2595
2596     if (next->stretch > cur->stretch)
2597         return TRUE;
2598     if (next->stretch < cur->stretch)
2599         return FALSE;
2600
2601     if (next->style > cur->style)
2602         return TRUE;
2603     if (next->style < cur->style)
2604         return FALSE;
2605
2606     if (next->weight > cur->weight)
2607         return TRUE;
2608     if (next->weight < cur->weight)
2609         return FALSE;
2610
2611     /* full match, no reason to prefer new variant */
2612     return FALSE;
2613 }
2614
2615 static HRESULT WINAPI dwritefontfamily_GetFirstMatchingFont(IDWriteFontFamily2 *iface, DWRITE_FONT_WEIGHT weight,
2616         DWRITE_FONT_STRETCH stretch, DWRITE_FONT_STYLE style, IDWriteFont **font)
2617 {
2618     struct dwrite_fontfamily *family = impl_from_IDWriteFontFamily2(iface);
2619     struct dwrite_font_propvec req;
2620     size_t i, match;
2621
2622     TRACE("%p, %d, %d, %d, %p.\n", iface, weight, stretch, style, font);
2623
2624     if (!family->data->count)
2625     {
2626         *font = NULL;
2627         return DWRITE_E_NOFONT;
2628     }
2629
2630     init_font_prop_vec(weight, stretch, style, &req);
2631     match = 0;
2632
2633     for (i = 1; i < family->data->count; ++i)
2634     {
2635         if (is_better_font_match(&family->data->fonts[i]->propvec, &family->data->fonts[match]->propvec, &req))
2636             match = i;
2637     }
2638
2639     return create_font(family, match, (IDWriteFont3 **)font);
2640 }
2641
2642 typedef BOOL (*matching_filter_func)(const struct dwrite_font_data*);
2643
2644 static BOOL is_font_acceptable_for_normal(const struct dwrite_font_data *font)
2645 {
2646     return font->style == DWRITE_FONT_STYLE_NORMAL || font->style == DWRITE_FONT_STYLE_ITALIC;
2647 }
2648
2649 static BOOL is_font_acceptable_for_oblique_italic(const struct dwrite_font_data *font)
2650 {
2651     return font->style == DWRITE_FONT_STYLE_OBLIQUE || font->style == DWRITE_FONT_STYLE_ITALIC;
2652 }
2653
2654 static void matchingfonts_sort(struct dwrite_fontlist *fonts, const struct dwrite_font_propvec *req)
2655 {
2656     UINT32 b = fonts->font_count - 1, j, t;
2657
2658     while (1) {
2659         t = b;
2660
2661         for (j = 0; j < b; j++) {
2662             if (is_better_font_match(&fonts->fonts[j+1]->propvec, &fonts->fonts[j]->propvec, req)) {
2663                 struct dwrite_font_data *s = fonts->fonts[j];
2664                 fonts->fonts[j] = fonts->fonts[j+1];
2665                 fonts->fonts[j+1] = s;
2666                 t = j;
2667             }
2668         }
2669
2670         if (t == b)
2671             break;
2672         b = t;
2673     };
2674 }
2675
2676 static HRESULT WINAPI dwritefontfamily_GetMatchingFonts(IDWriteFontFamily2 *iface, DWRITE_FONT_WEIGHT weight,
2677         DWRITE_FONT_STRETCH stretch, DWRITE_FONT_STYLE style, IDWriteFontList **ret)
2678 {
2679     struct dwrite_fontfamily *family = impl_from_IDWriteFontFamily2(iface);
2680     matching_filter_func func = NULL;
2681     struct dwrite_font_propvec req;
2682     struct dwrite_fontlist *fonts;
2683     size_t i;
2684
2685     TRACE("%p, %d, %d, %d, %p.\n", iface, weight, stretch, style, ret);
2686
2687     *ret = NULL;
2688
2689     fonts = heap_alloc(sizeof(*fonts));
2690     if (!fonts)
2691         return E_OUTOFMEMORY;
2692
2693     /* Allocate as many as family has, not all of them will be necessary used. */
2694     fonts->fonts = heap_calloc(family->data->count, sizeof(*fonts->fonts));
2695     if (!fonts->fonts) {
2696         heap_free(fonts);
2697         return E_OUTOFMEMORY;
2698     }
2699
2700     fonts->IDWriteFontList2_iface.lpVtbl = &dwritefontlistvtbl;
2701     fonts->refcount = 1;
2702     fonts->family = family;
2703     IDWriteFontFamily2_AddRef(&fonts->family->IDWriteFontFamily2_iface);
2704     fonts->font_count = 0;
2705
2706     /* Normal style accepts Normal or Italic, Oblique and Italic - both Oblique and Italic styles */
2707     if (style == DWRITE_FONT_STYLE_NORMAL) {
2708         if (family->data->has_normal_face || family->data->has_italic_face)
2709             func = is_font_acceptable_for_normal;
2710     }
2711     else /* requested oblique or italic */ {
2712         if (family->data->has_oblique_face || family->data->has_italic_face)
2713             func = is_font_acceptable_for_oblique_italic;
2714     }
2715
2716     for (i = 0; i < family->data->count; ++i)
2717     {
2718         if (!func || func(family->data->fonts[i]))
2719         {
2720             fonts->fonts[fonts->font_count++] = addref_font_data(family->data->fonts[i]);
2721         }
2722     }
2723
2724     /* now potential matches are sorted using same criteria GetFirstMatchingFont uses */
2725     init_font_prop_vec(weight, stretch, style, &req);
2726     matchingfonts_sort(fonts, &req);
2727
2728     *ret = (IDWriteFontList *)&fonts->IDWriteFontList2_iface;
2729     return S_OK;
2730 }
2731
2732 static DWRITE_LOCALITY WINAPI dwritefontfamily1_GetFontLocality(IDWriteFontFamily2 *iface, UINT32 index)
2733 {
2734     FIXME("%p, %u.\n", iface, index);
2735
2736     return DWRITE_LOCALITY_LOCAL;
2737 }
2738
2739 static HRESULT WINAPI dwritefontfamily1_GetFont(IDWriteFontFamily2 *iface, UINT32 index, IDWriteFont3 **font)
2740 {
2741     struct dwrite_fontfamily *family = impl_from_IDWriteFontFamily2(iface);
2742
2743     TRACE("%p, %u, %p.\n", iface, index, font);
2744
2745     *font = NULL;
2746
2747     if (!family->data->count)
2748         return S_FALSE;
2749
2750     if (index >= family->data->count)
2751         return E_FAIL;
2752
2753     return create_font(family, index, font);
2754 }
2755
2756 static HRESULT WINAPI dwritefontfamily1_GetFontFaceReference(IDWriteFontFamily2 *iface, UINT32 index,
2757         IDWriteFontFaceReference **reference)
2758 {
2759     struct dwrite_fontfamily *family = impl_from_IDWriteFontFamily2(iface);
2760     const struct dwrite_font_data *font;
2761
2762     TRACE("%p, %u, %p.\n", iface, index, reference);
2763
2764     *reference = NULL;
2765
2766     if (index >= family->data->count)
2767         return E_FAIL;
2768
2769     font = family->data->fonts[index];
2770     return IDWriteFactory5_CreateFontFaceReference_((IDWriteFactory5 *)family->collection->factory,
2771             font->file, font->face_index, font->simulations, reference);
2772 }
2773
2774 static HRESULT WINAPI dwritefontfamily2_GetMatchingFonts(IDWriteFontFamily2 *iface,
2775         DWRITE_FONT_AXIS_VALUE const *axis_values, UINT32 num_values, IDWriteFontList2 **fontlist)
2776 {
2777     FIXME("%p, %p, %u, %p.\n", iface, axis_values, num_values, fontlist);
2778
2779     return E_NOTIMPL;
2780 }
2781
2782 static HRESULT WINAPI dwritefontfamily2_GetFontSet(IDWriteFontFamily2 *iface, IDWriteFontSet1 **fontset)
2783 {
2784     struct dwrite_fontfamily *family = impl_from_IDWriteFontFamily2(iface);
2785
2786     TRACE("%p, %p.\n", iface, fontset);
2787
2788     return fontset_create_from_font_data(family->collection->factory, family->data->fonts,
2789             family->data->count, fontset);
2790 }
2791
2792 static const IDWriteFontFamily2Vtbl fontfamilyvtbl =
2793 {
2794     dwritefontfamily_QueryInterface,
2795     dwritefontfamily_AddRef,
2796     dwritefontfamily_Release,
2797     dwritefontfamily_GetFontCollection,
2798     dwritefontfamily_GetFontCount,
2799     dwritefontfamily_GetFont,
2800     dwritefontfamily_GetFamilyNames,
2801     dwritefontfamily_GetFirstMatchingFont,
2802     dwritefontfamily_GetMatchingFonts,
2803     dwritefontfamily1_GetFontLocality,
2804     dwritefontfamily1_GetFont,
2805     dwritefontfamily1_GetFontFaceReference,
2806     dwritefontfamily2_GetMatchingFonts,
2807     dwritefontfamily2_GetFontSet,
2808 };
2809
2810 static HRESULT WINAPI dwritefontfamilylist_QueryInterface(IDWriteFontList2 *iface, REFIID riid, void **obj)
2811 {
2812     struct dwrite_fontfamily *family = impl_family_from_IDWriteFontList2(iface);
2813     return dwritefontfamily_QueryInterface(&family->IDWriteFontFamily2_iface, riid, obj);
2814 }
2815
2816 static ULONG WINAPI dwritefontfamilylist_AddRef(IDWriteFontList2 *iface)
2817 {
2818     struct dwrite_fontfamily *family = impl_family_from_IDWriteFontList2(iface);
2819     return dwritefontfamily_AddRef(&family->IDWriteFontFamily2_iface);
2820 }
2821
2822 static ULONG WINAPI dwritefontfamilylist_Release(IDWriteFontList2 *iface)
2823 {
2824     struct dwrite_fontfamily *family = impl_family_from_IDWriteFontList2(iface);
2825     return dwritefontfamily_Release(&family->IDWriteFontFamily2_iface);
2826 }
2827
2828 static HRESULT WINAPI dwritefontfamilylist_GetFontCollection(IDWriteFontList2 *iface,
2829         IDWriteFontCollection **collection)
2830 {
2831     struct dwrite_fontfamily *family = impl_family_from_IDWriteFontList2(iface);
2832     return dwritefontfamily_GetFontCollection(&family->IDWriteFontFamily2_iface, collection);
2833 }
2834
2835 static UINT32 WINAPI dwritefontfamilylist_GetFontCount(IDWriteFontList2 *iface)
2836 {
2837     struct dwrite_fontfamily *family = impl_family_from_IDWriteFontList2(iface);
2838     return dwritefontfamily_GetFontCount(&family->IDWriteFontFamily2_iface);
2839 }
2840
2841 static HRESULT WINAPI dwritefontfamilylist_GetFont(IDWriteFontList2 *iface, UINT32 index, IDWriteFont **font)
2842 {
2843     struct dwrite_fontfamily *family = impl_family_from_IDWriteFontList2(iface);
2844     return dwritefontfamily_GetFont(&family->IDWriteFontFamily2_iface, index, font);
2845 }
2846
2847 static DWRITE_LOCALITY WINAPI dwritefontfamilylist1_GetFontLocality(IDWriteFontList2 *iface, UINT32 index)
2848 {
2849     struct dwrite_fontfamily *family = impl_family_from_IDWriteFontList2(iface);
2850     return dwritefontfamily1_GetFontLocality(&family->IDWriteFontFamily2_iface, index);
2851 }
2852
2853 static HRESULT WINAPI dwritefontfamilylist1_GetFont(IDWriteFontList2 *iface, UINT32 index, IDWriteFont3 **font)
2854 {
2855     struct dwrite_fontfamily *family = impl_family_from_IDWriteFontList2(iface);
2856     return dwritefontfamily1_GetFont(&family->IDWriteFontFamily2_iface, index, font);
2857 }
2858
2859 static HRESULT WINAPI dwritefontfamilylist1_GetFontFaceReference(IDWriteFontList2 *iface, UINT32 index,
2860         IDWriteFontFaceReference **reference)
2861 {
2862     struct dwrite_fontfamily *family = impl_family_from_IDWriteFontList2(iface);
2863     return dwritefontfamily1_GetFontFaceReference(&family->IDWriteFontFamily2_iface, index, reference);
2864 }
2865
2866 static HRESULT WINAPI dwritefontfamilylist2_GetFontSet(IDWriteFontList2 *iface, IDWriteFontSet1 **fontset)
2867 {
2868     struct dwrite_fontfamily *family = impl_family_from_IDWriteFontList2(iface);
2869
2870     TRACE("%p, %p.\n", iface, fontset);
2871
2872     return fontset_create_from_font_data(family->collection->factory, family->data->fonts,
2873             family->data->count, fontset);
2874 }
2875
2876 static const IDWriteFontList2Vtbl fontfamilylistvtbl =
2877 {
2878     dwritefontfamilylist_QueryInterface,
2879     dwritefontfamilylist_AddRef,
2880     dwritefontfamilylist_Release,
2881     dwritefontfamilylist_GetFontCollection,
2882     dwritefontfamilylist_GetFontCount,
2883     dwritefontfamilylist_GetFont,
2884     dwritefontfamilylist1_GetFontLocality,
2885     dwritefontfamilylist1_GetFont,
2886     dwritefontfamilylist1_GetFontFaceReference,
2887     dwritefontfamilylist2_GetFontSet,
2888 };
2889
2890 static HRESULT create_fontfamily(struct dwrite_fontcollection *collection, UINT32 index,
2891         struct dwrite_fontfamily **family)
2892 {
2893     struct dwrite_fontfamily *object;
2894
2895     *family = NULL;
2896
2897     object = heap_alloc(sizeof(*object));
2898     if (!object)
2899         return E_OUTOFMEMORY;
2900
2901     object->IDWriteFontFamily2_iface.lpVtbl = &fontfamilyvtbl;
2902     object->IDWriteFontList2_iface.lpVtbl = &fontfamilylistvtbl;
2903     object->refcount = 1;
2904     object->collection = collection;
2905     IDWriteFontCollection3_AddRef(&collection->IDWriteFontCollection3_iface);
2906     object->data = collection->family_data[index];
2907     InterlockedIncrement(&object->data->refcount);
2908
2909     *family = object;
2910
2911     return S_OK;
2912 }
2913
2914 BOOL is_system_collection(IDWriteFontCollection *collection)
2915 {
2916     void *obj;
2917     return IDWriteFontCollection_QueryInterface(collection, &IID_issystemcollection, &obj) == S_OK;
2918 }
2919
2920 static HRESULT WINAPI dwritesystemfontcollection_QueryInterface(IDWriteFontCollection3 *iface, REFIID riid, void **obj)
2921 {
2922     struct dwrite_fontcollection *collection = impl_from_IDWriteFontCollection3(iface);
2923
2924     TRACE("%p, %s, %p.\n", collection, debugstr_guid(riid), obj);
2925
2926     if (IsEqualIID(riid, &IID_IDWriteFontCollection3) ||
2927         IsEqualIID(riid, &IID_IDWriteFontCollection2) ||
2928         IsEqualIID(riid, &IID_IDWriteFontCollection1) ||
2929         IsEqualIID(riid, &IID_IDWriteFontCollection) ||
2930         IsEqualIID(riid, &IID_IUnknown))
2931     {
2932         *obj = iface;
2933         IDWriteFontCollection3_AddRef(iface);
2934         return S_OK;
2935     }
2936
2937     *obj = NULL;
2938
2939     if (IsEqualIID(riid, &IID_issystemcollection))
2940         return S_OK;
2941
2942     WARN("%s not implemented.\n", debugstr_guid(riid));
2943
2944     return E_NOINTERFACE;
2945 }
2946
2947 static HRESULT WINAPI dwritefontcollection_QueryInterface(IDWriteFontCollection3 *iface, REFIID riid, void **obj)
2948 {
2949     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
2950
2951     if (IsEqualIID(riid, &IID_IDWriteFontCollection3) ||
2952         IsEqualIID(riid, &IID_IDWriteFontCollection2) ||
2953         IsEqualIID(riid, &IID_IDWriteFontCollection1) ||
2954         IsEqualIID(riid, &IID_IDWriteFontCollection) ||
2955         IsEqualIID(riid, &IID_IUnknown))
2956     {
2957         *obj = iface;
2958         IDWriteFontCollection3_AddRef(iface);
2959         return S_OK;
2960     }
2961
2962     WARN("%s not implemented.\n", debugstr_guid(riid));
2963
2964     *obj = NULL;
2965
2966     return E_NOINTERFACE;
2967 }
2968
2969 static ULONG WINAPI dwritefontcollection_AddRef(IDWriteFontCollection3 *iface)
2970 {
2971     struct dwrite_fontcollection *collection = impl_from_IDWriteFontCollection3(iface);
2972     ULONG refcount = InterlockedIncrement(&collection->refcount);
2973
2974     TRACE("%p, refcount %d.\n", collection, refcount);
2975
2976     return refcount;
2977 }
2978
2979 static ULONG WINAPI dwritefontcollection_Release(IDWriteFontCollection3 *iface)
2980 {
2981     struct dwrite_fontcollection *collection = impl_from_IDWriteFontCollection3(iface);
2982     ULONG refcount = InterlockedDecrement(&collection->refcount);
2983     size_t i;
2984
2985     TRACE("%p, refcount %d.\n", iface, refcount);
2986
2987     if (!refcount)
2988     {
2989         factory_detach_fontcollection(collection->factory, iface);
2990         for (i = 0; i < collection->count; ++i)
2991             release_fontfamily_data(collection->family_data[i]);
2992         heap_free(collection->family_data);
2993         heap_free(collection);
2994     }
2995
2996     return refcount;
2997 }
2998
2999 static UINT32 WINAPI dwritefontcollection_GetFontFamilyCount(IDWriteFontCollection3 *iface)
3000 {
3001     struct dwrite_fontcollection *collection = impl_from_IDWriteFontCollection3(iface);
3002
3003     TRACE("%p.\n", iface);
3004
3005     return collection->count;
3006 }
3007
3008 static HRESULT WINAPI dwritefontcollection_GetFontFamily(IDWriteFontCollection3 *iface, UINT32 index,
3009         IDWriteFontFamily **ret)
3010 {
3011     struct dwrite_fontcollection *collection = impl_from_IDWriteFontCollection3(iface);
3012     struct dwrite_fontfamily *family;
3013     HRESULT hr;
3014
3015     TRACE("%p, %u, %p.\n", iface, index, ret);
3016
3017     *ret = NULL;
3018
3019     if (index >= collection->count)
3020         return E_FAIL;
3021
3022     if (SUCCEEDED(hr = create_fontfamily(collection, index, &family)))
3023         *ret = (IDWriteFontFamily *)&family->IDWriteFontFamily2_iface;
3024
3025     return hr;
3026 }
3027
3028 static UINT32 collection_find_family(struct dwrite_fontcollection *collection, const WCHAR *name)
3029 {
3030     size_t i;
3031
3032     for (i = 0; i < collection->count; ++i)
3033     {
3034         IDWriteLocalizedStrings *family_name = collection->family_data[i]->familyname;
3035         UINT32 j, count = IDWriteLocalizedStrings_GetCount(family_name);
3036         HRESULT hr;
3037
3038         for (j = 0; j < count; j++)
3039         {
3040             WCHAR buffer[255];
3041             hr = IDWriteLocalizedStrings_GetString(family_name, j, buffer, ARRAY_SIZE(buffer));
3042             if (SUCCEEDED(hr) && !wcsicmp(buffer, name))
3043                 return i;
3044         }
3045     }
3046
3047     return ~0u;
3048 }
3049
3050 static HRESULT WINAPI dwritefontcollection_FindFamilyName(IDWriteFontCollection3 *iface, const WCHAR *name,
3051         UINT32 *index, BOOL *exists)
3052 {
3053     struct dwrite_fontcollection *collection = impl_from_IDWriteFontCollection3(iface);
3054
3055     TRACE("%p, %s, %p, %p.\n", iface, debugstr_w(name), index, exists);
3056
3057     *index = collection_find_family(collection, name);
3058     *exists = *index != ~0u;
3059     return S_OK;
3060 }
3061
3062 static HRESULT WINAPI dwritefontcollection_GetFontFromFontFace(IDWriteFontCollection3 *iface, IDWriteFontFace *face,
3063         IDWriteFont **font)
3064 {
3065     struct dwrite_fontcollection *collection = impl_from_IDWriteFontCollection3(iface);
3066     struct dwrite_fontfamily *family;
3067     BOOL found_font = FALSE;
3068     IDWriteFontFile *file;
3069     UINT32 face_index, count;
3070     size_t i, j;
3071     HRESULT hr;
3072
3073     TRACE("%p, %p, %p.\n", iface, face, font);
3074
3075     *font = NULL;
3076
3077     if (!face)
3078         return E_INVALIDARG;
3079
3080     count = 1;
3081     hr = IDWriteFontFace_GetFiles(face, &count, &file);
3082     if (FAILED(hr))
3083         return hr;
3084     face_index = IDWriteFontFace_GetIndex(face);
3085
3086     found_font = FALSE;
3087     for (i = 0; i < collection->count; ++i)
3088     {
3089         struct dwrite_fontfamily_data *family_data = collection->family_data[i];
3090
3091         for (j = 0; j < family_data->count; ++j)
3092         {
3093             struct dwrite_font_data *font_data = family_data->fonts[j];
3094
3095             if (face_index == font_data->face_index && is_same_fontfile(file, font_data->file)) {
3096                 found_font = TRUE;
3097                 break;
3098             }
3099         }
3100
3101         if (found_font)
3102             break;
3103     }
3104     IDWriteFontFile_Release(file);
3105
3106     if (!found_font)
3107         return DWRITE_E_NOFONT;
3108
3109     hr = create_fontfamily(collection, i, &family);
3110     if (FAILED(hr))
3111         return hr;
3112
3113     hr = create_font(family, j, (IDWriteFont3 **)font);
3114     IDWriteFontFamily2_Release(&family->IDWriteFontFamily2_iface);
3115     return hr;
3116 }
3117
3118 static HRESULT WINAPI dwritefontcollection1_GetFontSet(IDWriteFontCollection3 *iface, IDWriteFontSet **fontset)
3119 {
3120     FIXME("%p, %p.\n", iface, fontset);
3121
3122     return E_NOTIMPL;
3123 }
3124
3125 static HRESULT WINAPI dwritefontcollection1_GetFontFamily(IDWriteFontCollection3 *iface, UINT32 index,
3126         IDWriteFontFamily1 **ret)
3127 {
3128     struct dwrite_fontcollection *collection = impl_from_IDWriteFontCollection3(iface);
3129     struct dwrite_fontfamily *family;
3130     HRESULT hr;
3131
3132     TRACE("%p, %u, %p.\n", iface, index, ret);
3133
3134     *ret = NULL;
3135
3136     if (index >= collection->count)
3137         return E_FAIL;
3138
3139     if (SUCCEEDED(hr = create_fontfamily(collection, index, &family)))
3140         *ret = (IDWriteFontFamily1 *)&family->IDWriteFontFamily2_iface;
3141
3142     return hr;
3143 }
3144
3145 static HRESULT WINAPI dwritefontcollection2_GetFontFamily(IDWriteFontCollection3 *iface,
3146         UINT32 index, IDWriteFontFamily2 **ret)
3147 {
3148     struct dwrite_fontcollection *collection = impl_from_IDWriteFontCollection3(iface);
3149     struct dwrite_fontfamily *family;
3150     HRESULT hr;
3151
3152     TRACE("%p, %u, %p.\n", iface, index, ret);
3153
3154     *ret = NULL;
3155
3156     if (index >= collection->count)
3157         return E_FAIL;
3158
3159     if (SUCCEEDED(hr = create_fontfamily(collection, index, &family)))
3160         *ret = &family->IDWriteFontFamily2_iface;
3161
3162     return hr;
3163 }
3164
3165 static HRESULT WINAPI dwritefontcollection2_GetMatchingFonts(IDWriteFontCollection3 *iface,
3166         const WCHAR *familyname, DWRITE_FONT_AXIS_VALUE const *axis_values, UINT32 num_values,
3167         IDWriteFontList2 **fontlist)
3168 {
3169     FIXME("%p, %s, %p, %u, %p.\n", iface, debugstr_w(familyname), axis_values, num_values, fontlist);
3170
3171     return E_NOTIMPL;
3172 }
3173
3174 static DWRITE_FONT_FAMILY_MODEL WINAPI dwritefontcollection2_GetFontFamilyModel(IDWriteFontCollection3 *iface)
3175 {
3176     FIXME("%p.\n", iface);
3177
3178     return DWRITE_FONT_FAMILY_MODEL_WEIGHT_STRETCH_STYLE;
3179 }
3180
3181 static HRESULT WINAPI dwritefontcollection2_GetFontSet(IDWriteFontCollection3 *iface, IDWriteFontSet1 **fontset)
3182 {
3183     FIXME("%p, %p.\n", iface, fontset);
3184
3185     return E_NOTIMPL;
3186 }
3187
3188 static HANDLE WINAPI dwritefontcollection3_GetExpirationEvent(IDWriteFontCollection3 *iface)
3189 {
3190     FIXME("%p.\n", iface);
3191
3192     return NULL;
3193 }
3194
3195 static const IDWriteFontCollection3Vtbl fontcollectionvtbl =
3196 {
3197     dwritefontcollection_QueryInterface,
3198     dwritefontcollection_AddRef,
3199     dwritefontcollection_Release,
3200     dwritefontcollection_GetFontFamilyCount,
3201     dwritefontcollection_GetFontFamily,
3202     dwritefontcollection_FindFamilyName,
3203     dwritefontcollection_GetFontFromFontFace,
3204     dwritefontcollection1_GetFontSet,
3205     dwritefontcollection1_GetFontFamily,
3206     dwritefontcollection2_GetFontFamily,
3207     dwritefontcollection2_GetMatchingFonts,
3208     dwritefontcollection2_GetFontFamilyModel,
3209     dwritefontcollection2_GetFontSet,
3210     dwritefontcollection3_GetExpirationEvent,
3211 };
3212
3213 static const IDWriteFontCollection3Vtbl systemfontcollectionvtbl =
3214 {
3215     dwritesystemfontcollection_QueryInterface,
3216     dwritefontcollection_AddRef,
3217     dwritefontcollection_Release,
3218     dwritefontcollection_GetFontFamilyCount,
3219     dwritefontcollection_GetFontFamily,
3220     dwritefontcollection_FindFamilyName,
3221     dwritefontcollection_GetFontFromFontFace,
3222     dwritefontcollection1_GetFontSet,
3223     dwritefontcollection1_GetFontFamily,
3224     dwritefontcollection2_GetFontFamily,
3225     dwritefontcollection2_GetMatchingFonts,
3226     dwritefontcollection2_GetFontFamilyModel,
3227     dwritefontcollection2_GetFontSet,
3228     dwritefontcollection3_GetExpirationEvent,
3229 };
3230
3231 static HRESULT fontfamily_add_font(struct dwrite_fontfamily_data *family_data, struct dwrite_font_data *font_data)
3232 {
3233     if (!dwrite_array_reserve((void **)&family_data->fonts, &family_data->size, family_data->count + 1,
3234             sizeof(*family_data->fonts)))
3235     {
3236         return E_OUTOFMEMORY;
3237     }
3238
3239     family_data->fonts[family_data->count++] = font_data;
3240     if (font_data->style == DWRITE_FONT_STYLE_NORMAL)
3241         family_data->has_normal_face = 1;
3242     else if (font_data->style == DWRITE_FONT_STYLE_OBLIQUE)
3243         family_data->has_oblique_face = 1;
3244     else
3245         family_data->has_italic_face = 1;
3246     return S_OK;
3247 }
3248
3249 static HRESULT fontcollection_add_family(struct dwrite_fontcollection *collection,
3250         struct dwrite_fontfamily_data *family)
3251 {
3252     if (!dwrite_array_reserve((void **)&collection->family_data, &collection->size, collection->count + 1,
3253             sizeof(*collection->family_data)))
3254     {
3255         return E_OUTOFMEMORY;
3256     }
3257
3258     collection->family_data[collection->count++] = family;
3259     return S_OK;
3260 }
3261
3262 static HRESULT init_font_collection(struct dwrite_fontcollection *collection, BOOL is_system)
3263 {
3264     collection->IDWriteFontCollection3_iface.lpVtbl = is_system ? &systemfontcollectionvtbl : &fontcollectionvtbl;
3265     collection->refcount = 1;
3266     collection->count = 0;
3267     collection->size = 0;
3268     collection->family_data = NULL;
3269
3270     return S_OK;
3271 }
3272
3273 HRESULT get_filestream_from_file(IDWriteFontFile *file, IDWriteFontFileStream **stream)
3274 {
3275     IDWriteFontFileLoader *loader;
3276     const void *key;
3277     UINT32 key_size;
3278     HRESULT hr;
3279
3280     *stream = NULL;
3281
3282     hr = IDWriteFontFile_GetReferenceKey(file, &key, &key_size);
3283     if (FAILED(hr))
3284         return hr;
3285
3286     hr = IDWriteFontFile_GetLoader(file, &loader);
3287     if (FAILED(hr))
3288         return hr;
3289
3290     hr = IDWriteFontFileLoader_CreateStreamFromKey(loader, key, key_size, stream);
3291     IDWriteFontFileLoader_Release(loader);
3292     if (FAILED(hr))
3293         return hr;
3294
3295     return hr;
3296 }
3297
3298 static void fontstrings_get_en_string(IDWriteLocalizedStrings *strings, WCHAR *buffer, UINT32 size)
3299 {
3300     BOOL exists = FALSE;
3301     UINT32 index;
3302     HRESULT hr;
3303
3304     buffer[0] = 0;
3305     hr = IDWriteLocalizedStrings_FindLocaleName(strings, L"en-us", &index, &exists);
3306     if (FAILED(hr) || !exists)
3307         return;
3308
3309     IDWriteLocalizedStrings_GetString(strings, index, buffer, size);
3310 }
3311
3312 static int trim_spaces(WCHAR *in, WCHAR *ret)
3313 {
3314     int len;
3315
3316     while (iswspace(*in))
3317         in++;
3318
3319     ret[0] = 0;
3320     if (!(len = wcslen(in)))
3321         return 0;
3322
3323     while (iswspace(in[len-1]))
3324         len--;
3325
3326     memcpy(ret, in, len*sizeof(WCHAR));
3327     ret[len] = 0;
3328
3329     return len;
3330 }
3331
3332 struct name_token {
3333     struct list entry;
3334     const WCHAR *ptr;
3335     INT len;     /* token length */
3336     INT fulllen; /* full length including following separators */
3337 };
3338
3339 static inline BOOL is_name_separator_char(WCHAR ch)
3340 {
3341     return ch == ' ' || ch == '.' || ch == '-' || ch == '_';
3342 }
3343
3344 struct name_pattern {
3345     const WCHAR *part1; /* NULL indicates end of list */
3346     const WCHAR *part2; /* optional, if not NULL should point to non-empty string */
3347 };
3348
3349 static BOOL match_pattern_list(struct list *tokens, const struct name_pattern *patterns, struct name_token *match)
3350 {
3351     const struct name_pattern *pattern;
3352     struct name_token *token;
3353     int i = 0;
3354
3355     while ((pattern = &patterns[i++])->part1)
3356     {
3357         int len_part1 = wcslen(pattern->part1);
3358         int len_part2 = pattern->part2 ? wcslen(pattern->part2) : 0;
3359
3360         LIST_FOR_EACH_ENTRY(token, tokens, struct name_token, entry) {
3361             if (len_part2 == 0) {
3362                 /* simple case with single part pattern */
3363                 if (token->len != len_part1)
3364                     continue;
3365
3366                 if (!wcsnicmp(token->ptr, pattern->part1, len_part1))
3367                 {
3368                     if (match) *match = *token;
3369                     list_remove(&token->entry);
3370                     heap_free(token);
3371                     return TRUE;
3372                 }
3373             }
3374             else {
3375                 struct name_token *next_token;
3376                 struct list *next_entry;
3377
3378                 /* pattern parts are stored in reading order, tokens list is reversed */
3379                 if (token->len < len_part2)
3380                     continue;
3381
3382                 /* it's possible to have combined string as a token, like ExtraCondensed */
3383                 if (token->len == len_part1 + len_part2)
3384                 {
3385                     if (wcsnicmp(token->ptr, pattern->part1, len_part1))
3386                         continue;
3387
3388                     if (wcsnicmp(&token->ptr[len_part1], pattern->part2, len_part2))
3389                         continue;
3390
3391                     /* combined string match */
3392                     if (match) *match = *token;
3393                     list_remove(&token->entry);
3394                     heap_free(token);
3395                     return TRUE;
3396                 }
3397
3398                 /* now it's only possible to have two tokens matched to respective pattern parts */
3399                 if (token->len != len_part2)
3400                     continue;
3401
3402                 next_entry = list_next(tokens, &token->entry);
3403                 if (next_entry) {
3404                     next_token = LIST_ENTRY(next_entry, struct name_token, entry);
3405                     if (next_token->len != len_part1)
3406                         continue;
3407
3408                     if (wcsnicmp(token->ptr, pattern->part2, len_part2))
3409                         continue;
3410
3411                     if (wcsnicmp(next_token->ptr, pattern->part1, len_part1))
3412                         continue;
3413
3414                     /* both parts matched, remove tokens */
3415                     if (match) {
3416                         match->ptr = next_token->ptr;
3417                         match->len = (token->ptr - next_token->ptr) + token->len;
3418                     }
3419                     list_remove(&token->entry);
3420                     list_remove(&next_token->entry);
3421                     heap_free(next_token);
3422                     heap_free(token);
3423                     return TRUE;
3424                 }
3425             }
3426         }
3427     }
3428
3429     if (match) {
3430         match->ptr = NULL;
3431         match->len = 0;
3432     }
3433     return FALSE;
3434 }
3435
3436 static DWRITE_FONT_STYLE font_extract_style(struct list *tokens, DWRITE_FONT_STYLE style, struct name_token *match)
3437 {
3438     static const struct name_pattern italic_patterns[] =
3439     {
3440         { L"ita" },
3441         { L"ital" },
3442         { L"italic" },
3443         { L"cursive" },
3444         { L"kursiv" },
3445         { NULL }
3446     };
3447
3448     static const struct name_pattern oblique_patterns[] =
3449     {
3450         { L"inclined" },
3451         { L"oblique" },
3452         { L"backslanted" },
3453         { L"backslant" },
3454         { L"slanted" },
3455         { NULL }
3456     };
3457
3458     /* italic patterns first */
3459     if (match_pattern_list(tokens, italic_patterns, match))
3460         return DWRITE_FONT_STYLE_ITALIC;
3461
3462     /* oblique patterns */
3463     if (match_pattern_list(tokens, oblique_patterns, match))
3464         return DWRITE_FONT_STYLE_OBLIQUE;
3465
3466     return style;
3467 }
3468
3469 static DWRITE_FONT_STRETCH font_extract_stretch(struct list *tokens, DWRITE_FONT_STRETCH stretch,
3470     struct name_token *match)
3471 {
3472     static const struct name_pattern ultracondensed_patterns[] =
3473     {
3474         { L"extra", L"compressed" },
3475         { L"ext", L"compressed" },
3476         { L"ultra", L"compressed" },
3477         { L"ultra", L"condensed" },
3478         { L"ultra", L"cond" },
3479         { NULL }
3480     };
3481
3482     static const struct name_pattern extracondensed_patterns[] =
3483     {
3484         { L"compressed" },
3485         { L"extra", L"condensed" },
3486         { L"ext", L"condensed" },
3487         { L"extra", L"cond" },
3488         { L"ext", L"cond" },
3489         { NULL }
3490     };
3491
3492     static const struct name_pattern semicondensed_patterns[] =
3493     {
3494         { L"narrow" },
3495         { L"compact" },
3496         { L"semi", L"condensed" },
3497         { L"semi", L"cond" },
3498         { NULL }
3499     };
3500
3501     static const struct name_pattern semiexpanded_patterns[] =
3502     {
3503         { L"wide" },
3504         { L"semi", L"expanded" },
3505         { L"semi", L"extended" },
3506         { NULL }
3507     };
3508
3509     static const struct name_pattern extraexpanded_patterns[] =
3510     {
3511         { L"extra", L"expanded" },
3512         { L"ext", L"expanded" },
3513         { L"extra", L"extended" },
3514         { L"ext", L"extended" },
3515         { NULL }
3516     };
3517
3518     static const struct name_pattern ultraexpanded_patterns[] =
3519     {
3520         { L"ultra", L"expanded" },
3521         { L"ultra", L"extended" },
3522         { NULL }
3523     };
3524
3525     static const struct name_pattern condensed_patterns[] =
3526     {
3527         { L"condensed" },
3528         { L"cond" },
3529         { NULL }
3530     };
3531
3532     static const struct name_pattern expanded_patterns[] =
3533     {
3534         { L"expanded" },
3535         { L"extended" },
3536         { NULL }
3537     };
3538
3539     if (match_pattern_list(tokens, ultracondensed_patterns, match))
3540         return DWRITE_FONT_STRETCH_ULTRA_CONDENSED;
3541
3542     if (match_pattern_list(tokens, extracondensed_patterns, match))
3543         return DWRITE_FONT_STRETCH_EXTRA_CONDENSED;
3544
3545     if (match_pattern_list(tokens, semicondensed_patterns, match))
3546         return DWRITE_FONT_STRETCH_SEMI_CONDENSED;
3547
3548     if (match_pattern_list(tokens, semiexpanded_patterns, match))
3549         return DWRITE_FONT_STRETCH_SEMI_EXPANDED;
3550
3551     if (match_pattern_list(tokens, extraexpanded_patterns, match))
3552         return DWRITE_FONT_STRETCH_EXTRA_EXPANDED;
3553
3554     if (match_pattern_list(tokens, ultraexpanded_patterns, match))
3555         return DWRITE_FONT_STRETCH_ULTRA_EXPANDED;
3556
3557     if (match_pattern_list(tokens, condensed_patterns, match))
3558         return DWRITE_FONT_STRETCH_CONDENSED;
3559
3560     if (match_pattern_list(tokens, expanded_patterns, match))
3561         return DWRITE_FONT_STRETCH_EXPANDED;
3562
3563     return stretch;
3564 }
3565
3566 static DWRITE_FONT_WEIGHT font_extract_weight(struct list *tokens, DWRITE_FONT_WEIGHT weight,
3567     struct name_token *match)
3568 {
3569     static const struct name_pattern thin_patterns[] =
3570     {
3571         { L"extra", L"thin" },
3572         { L"ext", L"thin" },
3573         { L"ultra", L"thin" },
3574         { NULL }
3575     };
3576
3577     static const struct name_pattern extralight_patterns[] =
3578     {
3579         { L"extra", L"light" },
3580         { L"ext", L"light" },
3581         { L"ultra", L"light" },
3582         { NULL }
3583     };
3584
3585     static const struct name_pattern semilight_patterns[] =
3586     {
3587         { L"semi", L"light" },
3588         { NULL }
3589     };
3590
3591     static const struct name_pattern demibold_patterns[] =
3592     {
3593         { L"semi", L"bold" },
3594         { L"demi", L"bold" },
3595         { NULL }
3596     };
3597
3598     static const struct name_pattern extrabold_patterns[] =
3599     {
3600         { L"extra", L"bold" },
3601         { L"ext", L"bold" },
3602         { L"ultra", L"bold" },
3603         { NULL }
3604     };
3605
3606     static const struct name_pattern extrablack_patterns[] =
3607     {
3608         { L"extra", L"black" },
3609         { L"ext", L"black" },
3610         { L"ultra", L"black" },
3611         { NULL }
3612     };
3613
3614     static const struct name_pattern bold_patterns[] =
3615     {
3616         { L"bold" },
3617         { NULL }
3618     };
3619
3620     static const struct name_pattern thin2_patterns[] =
3621     {
3622         { L"thin" },
3623         { NULL }
3624     };
3625
3626     static const struct name_pattern light_patterns[] =
3627     {
3628         { L"light" },
3629         { NULL }
3630     };
3631
3632     static const struct name_pattern medium_patterns[] =
3633     {
3634         { L"medium" },
3635         { NULL }
3636     };
3637
3638     static const struct name_pattern black_patterns[] =
3639     {
3640         { L"black" },
3641         { L"heavy" },
3642         { L"nord" },
3643         { NULL }
3644     };
3645
3646     static const struct name_pattern demibold2_patterns[] =
3647     {
3648         { L"demi" },
3649         { NULL }
3650     };
3651
3652     static const struct name_pattern extrabold2_patterns[] =
3653     {
3654         { L"ultra" },
3655         { NULL }
3656     };
3657
3658     /* FIXME: allow optional 'face' suffix, separated or not. It's removed together with
3659        matching pattern. */
3660
3661     if (match_pattern_list(tokens, thin_patterns, match))
3662         return DWRITE_FONT_WEIGHT_THIN;
3663
3664     if (match_pattern_list(tokens, extralight_patterns, match))
3665         return DWRITE_FONT_WEIGHT_EXTRA_LIGHT;
3666
3667     if (match_pattern_list(tokens, semilight_patterns, match))
3668         return DWRITE_FONT_WEIGHT_SEMI_LIGHT;
3669
3670     if (match_pattern_list(tokens, demibold_patterns, match))
3671         return DWRITE_FONT_WEIGHT_DEMI_BOLD;
3672
3673     if (match_pattern_list(tokens, extrabold_patterns, match))
3674         return DWRITE_FONT_WEIGHT_EXTRA_BOLD;
3675
3676     if (match_pattern_list(tokens, extrablack_patterns, match))
3677         return DWRITE_FONT_WEIGHT_EXTRA_BLACK;
3678
3679     if (match_pattern_list(tokens, bold_patterns, match))
3680         return DWRITE_FONT_WEIGHT_BOLD;
3681
3682     if (match_pattern_list(tokens, thin2_patterns, match))
3683         return DWRITE_FONT_WEIGHT_THIN;
3684
3685     if (match_pattern_list(tokens, light_patterns, match))
3686         return DWRITE_FONT_WEIGHT_LIGHT;
3687
3688     if (match_pattern_list(tokens, medium_patterns, match))
3689         return DWRITE_FONT_WEIGHT_MEDIUM;
3690
3691     if (match_pattern_list(tokens, black_patterns, match))
3692         return DWRITE_FONT_WEIGHT_BLACK;
3693
3694     if (match_pattern_list(tokens, black_patterns, match))
3695         return DWRITE_FONT_WEIGHT_BLACK;
3696
3697     if (match_pattern_list(tokens, demibold2_patterns, match))
3698         return DWRITE_FONT_WEIGHT_DEMI_BOLD;
3699
3700     if (match_pattern_list(tokens, extrabold2_patterns, match))
3701         return DWRITE_FONT_WEIGHT_EXTRA_BOLD;
3702
3703     /* FIXME: use abbreviated names to extract weight */
3704
3705     return weight;
3706 }
3707
3708 struct knownweight_entry
3709 {
3710     const WCHAR *nameW;
3711     DWRITE_FONT_WEIGHT weight;
3712 };
3713
3714 static int __cdecl compare_knownweights(const void *a, const void* b)
3715 {
3716     DWRITE_FONT_WEIGHT target = *(DWRITE_FONT_WEIGHT*)a;
3717     const struct knownweight_entry *entry = (struct knownweight_entry*)b;
3718     int ret = 0;
3719
3720     if (target > entry->weight)
3721         ret = 1;
3722     else if (target < entry->weight)
3723         ret = -1;
3724
3725     return ret;
3726 }
3727
3728 static BOOL is_known_weight_value(DWRITE_FONT_WEIGHT weight, WCHAR *nameW)
3729 {
3730     static const struct knownweight_entry knownweights[] =
3731     {
3732         { L"Thin",        DWRITE_FONT_WEIGHT_THIN },
3733         { L"Extra Light", DWRITE_FONT_WEIGHT_EXTRA_LIGHT },
3734         { L"Light",       DWRITE_FONT_WEIGHT_LIGHT },
3735         { L"Semi Light",  DWRITE_FONT_WEIGHT_SEMI_LIGHT },
3736         { L"Medium",      DWRITE_FONT_WEIGHT_MEDIUM },
3737         { L"Demi Bold",   DWRITE_FONT_WEIGHT_DEMI_BOLD },
3738         { L"Bold",        DWRITE_FONT_WEIGHT_BOLD },
3739         { L"Extra Bold",  DWRITE_FONT_WEIGHT_EXTRA_BOLD },
3740         { L"Black",       DWRITE_FONT_WEIGHT_BLACK },
3741         { L"Extra Black", DWRITE_FONT_WEIGHT_EXTRA_BLACK }
3742     };
3743     const struct knownweight_entry *ptr;
3744
3745     ptr = bsearch(&weight, knownweights, ARRAY_SIZE(knownweights), sizeof(*knownweights),
3746         compare_knownweights);
3747     if (!ptr) {
3748         nameW[0] = 0;
3749         return FALSE;
3750     }
3751
3752     wcscpy(nameW, ptr->nameW);
3753     return TRUE;
3754 }
3755
3756 static inline void font_name_token_to_str(const struct name_token *name, WCHAR *strW)
3757 {
3758     memcpy(strW, name->ptr, name->len * sizeof(WCHAR));
3759     strW[name->len] = 0;
3760 }
3761
3762 /* Modifies facenameW string, and returns pointer to regular term that was removed */
3763 static const WCHAR *facename_remove_regular_term(WCHAR *facenameW, INT len)
3764 {
3765     static const WCHAR *regular_patterns[] =
3766     {
3767         L"Book",
3768         L"Normal",
3769         L"Regular",
3770         L"Roman",
3771         L"Upright",
3772         NULL
3773     };
3774
3775     const WCHAR *regular_ptr = NULL, *ptr;
3776     int i = 0;
3777
3778     if (len == -1)
3779         len = wcslen(facenameW);
3780
3781     /* remove rightmost regular variant from face name */
3782     while (!regular_ptr && (ptr = regular_patterns[i++]))
3783     {
3784         int pattern_len = wcslen(ptr);
3785         WCHAR *src;
3786
3787         if (pattern_len > len)
3788             continue;
3789
3790         src = facenameW + len - pattern_len;
3791         while (src >= facenameW)
3792         {
3793             if (!wcsnicmp(src, ptr, pattern_len))
3794             {
3795                 memmove(src, src + pattern_len, (len - pattern_len - (src - facenameW) + 1)*sizeof(WCHAR));
3796                 len = wcslen(facenameW);
3797                 regular_ptr = ptr;
3798                 break;
3799             }
3800             else
3801                 src--;
3802         }
3803     }
3804
3805     return regular_ptr;
3806 }
3807
3808 static void fontname_tokenize(struct list *tokens, const WCHAR *nameW)
3809 {
3810     const WCHAR *ptr;
3811
3812     list_init(tokens);
3813     ptr = nameW;
3814
3815     while (*ptr) {
3816         struct name_token *token = heap_alloc(sizeof(*token));
3817         token->ptr = ptr;
3818         token->len = 0;
3819         token->fulllen = 0;
3820
3821         while (*ptr && !is_name_separator_char(*ptr)) {
3822             token->len++;
3823             token->fulllen++;
3824             ptr++;
3825         }
3826
3827         /* skip separators */
3828         while (is_name_separator_char(*ptr)) {
3829             token->fulllen++;
3830             ptr++;
3831         }
3832
3833         list_add_head(tokens, &token->entry);
3834     }
3835 }
3836
3837 static void fontname_tokens_to_str(struct list *tokens, WCHAR *nameW)
3838 {
3839     struct name_token *token, *token2;
3840     LIST_FOR_EACH_ENTRY_SAFE_REV(token, token2, tokens, struct name_token, entry) {
3841         int len;
3842
3843         list_remove(&token->entry);
3844
3845         /* don't include last separator */
3846         len = list_empty(tokens) ? token->len : token->fulllen;
3847         memcpy(nameW, token->ptr, len * sizeof(WCHAR));
3848         nameW += len;
3849
3850         heap_free(token);
3851     }
3852     *nameW = 0;
3853 }
3854
3855 static BOOL font_apply_differentiation_rules(struct dwrite_font_data *font, WCHAR *familyW, WCHAR *faceW)
3856 {
3857     struct name_token stretch_name, weight_name, style_name;
3858     WCHAR familynameW[255], facenameW[255], finalW[255];
3859     WCHAR weightW[32], stretchW[32], styleW[32];
3860     const WCHAR *regular_ptr = NULL;
3861     DWRITE_FONT_STRETCH stretch;
3862     DWRITE_FONT_WEIGHT weight;
3863     struct list tokens;
3864     int len;
3865
3866     /* remove leading and trailing spaces from family and face name */
3867     trim_spaces(familyW, familynameW);
3868     len = trim_spaces(faceW, facenameW);
3869
3870     /* remove rightmost regular variant from face name */
3871     regular_ptr = facename_remove_regular_term(facenameW, len);
3872
3873     /* append face name to family name, FIXME check if face name is a substring of family name */
3874     if (*facenameW)
3875     {
3876         wcscat(familynameW, L" ");
3877         wcscat(familynameW, facenameW);
3878     }
3879
3880     /* tokenize with " .-_" */
3881     fontname_tokenize(&tokens, familynameW);
3882
3883     /* extract and resolve style */
3884     font->style = font_extract_style(&tokens, font->style, &style_name);
3885
3886     /* extract stretch */
3887     stretch = font_extract_stretch(&tokens, font->stretch, &stretch_name);
3888
3889     /* extract weight */
3890     weight = font_extract_weight(&tokens, font->weight, &weight_name);
3891
3892     /* resolve weight */
3893     if (weight != font->weight)
3894     {
3895         if (!(weight < DWRITE_FONT_WEIGHT_NORMAL && font->weight < DWRITE_FONT_WEIGHT_NORMAL) &&
3896             !(weight > DWRITE_FONT_WEIGHT_MEDIUM && font->weight > DWRITE_FONT_WEIGHT_MEDIUM) &&
3897             !((weight == DWRITE_FONT_WEIGHT_NORMAL && font->weight == DWRITE_FONT_WEIGHT_MEDIUM) ||
3898               (weight == DWRITE_FONT_WEIGHT_MEDIUM && font->weight == DWRITE_FONT_WEIGHT_NORMAL)) &&
3899             !(abs((int)weight - (int)font->weight) <= 150 &&
3900               font->weight != DWRITE_FONT_WEIGHT_NORMAL &&
3901               font->weight != DWRITE_FONT_WEIGHT_MEDIUM &&
3902               font->weight != DWRITE_FONT_WEIGHT_BOLD))
3903         {
3904             font->weight = weight;
3905         }
3906     }
3907
3908     /* Resolve stretch - extracted stretch can't be normal, it will override specified stretch if
3909        it's leaning in opposite direction from normal comparing to specified stretch or if specified
3910        stretch itself is normal (extracted stretch is never normal). */
3911     if (stretch != font->stretch) {
3912         if ((font->stretch == DWRITE_FONT_STRETCH_NORMAL) ||
3913             (font->stretch < DWRITE_FONT_STRETCH_NORMAL && stretch > DWRITE_FONT_STRETCH_NORMAL) ||
3914             (font->stretch > DWRITE_FONT_STRETCH_NORMAL && stretch < DWRITE_FONT_STRETCH_NORMAL)) {
3915
3916             font->stretch = stretch;
3917         }
3918     }
3919
3920     /* FIXME: cleanup face name from possible 2-3 digit prefixes */
3921
3922     /* get final combined string from what's left in token list, list is released */
3923     fontname_tokens_to_str(&tokens, finalW);
3924
3925     if (!wcscmp(familyW, finalW))
3926         return FALSE;
3927
3928     /* construct face name */
3929     wcscpy(familyW, finalW);
3930
3931     /* resolved weight name */
3932     if (weight_name.ptr)
3933         font_name_token_to_str(&weight_name, weightW);
3934     /* ignore normal weight */
3935     else if (font->weight == DWRITE_FONT_WEIGHT_NORMAL)
3936         weightW[0] = 0;
3937     /* for known weight values use appropriate names */
3938     else if (is_known_weight_value(font->weight, weightW)) {
3939     }
3940     /* use Wnnn format as a fallback in case weight is not one of known values */
3941     else
3942         swprintf(weightW, ARRAY_SIZE(weightW), L"W%d", font->weight);
3943
3944     /* resolved stretch name */
3945     if (stretch_name.ptr)
3946         font_name_token_to_str(&stretch_name, stretchW);
3947     /* ignore normal stretch */
3948     else if (font->stretch == DWRITE_FONT_STRETCH_NORMAL)
3949         stretchW[0] = 0;
3950     /* use predefined stretch names */
3951     else
3952     {
3953         static const WCHAR *stretchnamesW[] =
3954         {
3955             NULL, /* DWRITE_FONT_STRETCH_UNDEFINED */
3956             L"Ultra Condensed",
3957             L"Extra Condensed",
3958             L"Condensed",
3959             L"Semi Condensed",
3960             NULL, /* DWRITE_FONT_STRETCH_NORMAL */
3961             L"Semi Expanded",
3962             L"Expanded",
3963             L"Extra Expanded",
3964             L"Ultra Expanded"
3965         };
3966         wcscpy(stretchW, stretchnamesW[font->stretch]);
3967     }
3968
3969     /* resolved style name */
3970     if (style_name.ptr)
3971         font_name_token_to_str(&style_name, styleW);
3972     else if (font->style == DWRITE_FONT_STYLE_NORMAL)
3973         styleW[0] = 0;
3974     /* use predefined names */
3975     else
3976         wcscpy(styleW, font->style == DWRITE_FONT_STYLE_ITALIC ? L"Italic" : L"Oblique");
3977
3978     /* use Regular match if it was found initially */
3979     if (!*weightW && !*stretchW && !*styleW)
3980         wcscpy(faceW, regular_ptr ? regular_ptr : L"Regular");
3981     else
3982     {
3983         faceW[0] = 0;
3984
3985         if (*stretchW) wcscpy(faceW, stretchW);
3986
3987         if (*weightW)
3988         {
3989             if (*faceW) wcscat(faceW, L" ");
3990             wcscat(faceW, weightW);
3991         }
3992
3993         if (*styleW)
3994         {
3995             if (*faceW) wcscat(faceW, L" ");
3996             wcscat(faceW, styleW);
3997         }
3998     }
3999
4000     TRACE("resolved family %s, face %s\n", debugstr_w(familyW), debugstr_w(faceW));
4001     return TRUE;
4002 }
4003
4004 static HRESULT init_font_data(const struct fontface_desc *desc, struct dwrite_font_data **ret)
4005 {
4006     static const float width_axis_values[] =
4007     {
4008         0.0f, /* DWRITE_FONT_STRETCH_UNDEFINED */
4009         50.0f, /* DWRITE_FONT_STRETCH_ULTRA_CONDENSED */
4010         62.5f, /* DWRITE_FONT_STRETCH_EXTRA_CONDENSED */
4011         75.0f, /* DWRITE_FONT_STRETCH_CONDENSED */
4012         87.5f, /* DWRITE_FONT_STRETCH_SEMI_CONDENSED */
4013         100.0f, /* DWRITE_FONT_STRETCH_NORMAL */
4014         112.5f, /* DWRITE_FONT_STRETCH_SEMI_EXPANDED */
4015         125.0f, /* DWRITE_FONT_STRETCH_EXPANDED */
4016         150.0f, /* DWRITE_FONT_STRETCH_EXTRA_EXPANDED */
4017         200.0f, /* DWRITE_FONT_STRETCH_ULTRA_EXPANDED */
4018     };
4019
4020     struct file_stream_desc stream_desc;
4021     struct dwrite_font_props props;
4022     struct dwrite_font_data *data;
4023     WCHAR familyW[255], faceW[255];
4024     HRESULT hr;
4025
4026     *ret = NULL;
4027
4028     data = heap_alloc_zero(sizeof(*data));
4029     if (!data)
4030         return E_OUTOFMEMORY;
4031
4032     data->refcount = 1;
4033     data->file = desc->file;
4034     data->face_index = desc->index;
4035     data->face_type = desc->face_type;
4036     IDWriteFontFile_AddRef(data->file);
4037
4038     stream_desc.stream = desc->stream;
4039     stream_desc.face_type = desc->face_type;
4040     stream_desc.face_index = desc->index;
4041     opentype_get_font_properties(&stream_desc, &props);
4042     opentype_get_font_metrics(&stream_desc, &data->metrics, NULL);
4043     opentype_get_font_facename(&stream_desc, props.lf.lfFaceName, &data->names);
4044
4045     /* get family name from font file */
4046     hr = opentype_get_font_familyname(&stream_desc, &data->family_names);
4047     if (FAILED(hr)) {
4048         WARN("unable to get family name from font\n");
4049         release_font_data(data);
4050         return hr;
4051     }
4052
4053     data->style = props.style;
4054     data->stretch = props.stretch;
4055     data->weight = props.weight;
4056     data->panose = props.panose;
4057     data->fontsig = props.fontsig;
4058     data->lf = props.lf;
4059     data->flags = props.flags;
4060
4061     fontstrings_get_en_string(data->family_names, familyW, ARRAY_SIZE(familyW));
4062     fontstrings_get_en_string(data->names, faceW, ARRAY_SIZE(faceW));
4063     if (font_apply_differentiation_rules(data, familyW, faceW)) {
4064         set_en_localizedstring(data->family_names, familyW);
4065         set_en_localizedstring(data->names, faceW);
4066     }
4067
4068     init_font_prop_vec(data->weight, data->stretch, data->style, &data->propvec);
4069
4070     data->axis[0].axisTag = DWRITE_FONT_AXIS_TAG_WEIGHT;
4071     data->axis[0].value = props.weight;
4072     data->axis[1].axisTag = DWRITE_FONT_AXIS_TAG_WIDTH;
4073     data->axis[1].value = width_axis_values[props.stretch];
4074     data->axis[2].axisTag = DWRITE_FONT_AXIS_TAG_ITALIC;
4075     data->axis[2].value = data->style == DWRITE_FONT_STYLE_ITALIC ? 1.0f : 0.0f;
4076
4077     *ret = data;
4078     return S_OK;
4079 }
4080
4081 static HRESULT init_font_data_from_font(const struct dwrite_font_data *src, DWRITE_FONT_SIMULATIONS simulations,
4082         const WCHAR *facenameW, struct dwrite_font_data **ret)
4083 {
4084     struct dwrite_font_data *data;
4085
4086     *ret = NULL;
4087
4088     data = heap_alloc_zero(sizeof(*data));
4089     if (!data)
4090         return E_OUTOFMEMORY;
4091
4092     *data = *src;
4093     data->refcount = 1;
4094     data->simulations |= simulations;
4095     if (simulations & DWRITE_FONT_SIMULATIONS_BOLD)
4096         data->weight = DWRITE_FONT_WEIGHT_BOLD;
4097     if (simulations & DWRITE_FONT_SIMULATIONS_OBLIQUE)
4098         data->style = DWRITE_FONT_STYLE_OBLIQUE;
4099     memset(data->info_strings, 0, sizeof(data->info_strings));
4100     data->names = NULL;
4101     IDWriteFontFile_AddRef(data->file);
4102     IDWriteLocalizedStrings_AddRef(data->family_names);
4103
4104     create_localizedstrings(&data->names);
4105     add_localizedstring(data->names, L"en-us", facenameW);
4106
4107     init_font_prop_vec(data->weight, data->stretch, data->style, &data->propvec);
4108
4109     *ret = data;
4110     return S_OK;
4111 };
4112
4113 static HRESULT init_fontfamily_data(IDWriteLocalizedStrings *familyname, struct dwrite_fontfamily_data **ret)
4114 {
4115     struct dwrite_fontfamily_data *data;
4116
4117     data = heap_alloc_zero(sizeof(*data));
4118     if (!data)
4119         return E_OUTOFMEMORY;
4120
4121     data->refcount = 1;
4122     data->familyname = familyname;
4123     IDWriteLocalizedStrings_AddRef(familyname);
4124
4125     *ret = data;
4126
4127     return S_OK;
4128 }
4129
4130 static void fontfamily_add_bold_simulated_face(struct dwrite_fontfamily_data *family)
4131 {
4132     size_t i, j, heaviest;
4133
4134     for (i = 0; i < family->count; ++i)
4135     {
4136         DWRITE_FONT_WEIGHT weight = family->fonts[i]->weight;
4137         heaviest = i;
4138
4139         if (family->fonts[i]->bold_sim_tested)
4140             continue;
4141
4142         family->fonts[i]->bold_sim_tested = 1;
4143         for (j = i; j < family->count; ++j)
4144         {
4145             if (family->fonts[j]->bold_sim_tested)
4146                 continue;
4147
4148             if ((family->fonts[i]->style == family->fonts[j]->style) &&
4149                 (family->fonts[i]->stretch == family->fonts[j]->stretch)) {
4150                 if (family->fonts[j]->weight > weight) {
4151                     weight = family->fonts[j]->weight;
4152                     heaviest = j;
4153                 }
4154                 family->fonts[j]->bold_sim_tested = 1;
4155             }
4156         }
4157
4158         if (weight >= DWRITE_FONT_WEIGHT_SEMI_LIGHT && weight <= 550)
4159         {
4160             static const struct name_pattern weightsim_patterns[] =
4161             {
4162                 { L"extra", L"light" },
4163                 { L"ext", L"light" },
4164                 { L"ultra", L"light" },
4165                 { L"semi", L"light" },
4166                 { L"semi", L"bold" },
4167                 { L"demi", L"bold" },
4168                 { L"bold" },
4169                 { L"thin" },
4170                 { L"light" },
4171                 { L"medium" },
4172                 { L"demi" },
4173                 { NULL }
4174             };
4175
4176             WCHAR facenameW[255], initialW[255];
4177             struct dwrite_font_data *boldface;
4178             struct list tokens;
4179
4180             /* add Bold simulation based on heaviest face data */
4181
4182             /* Simulated face name should only contain Bold as weight term,
4183                so remove existing regular and weight terms. */
4184             fontstrings_get_en_string(family->fonts[heaviest]->names, initialW, ARRAY_SIZE(initialW));
4185             facename_remove_regular_term(initialW, -1);
4186
4187             /* remove current weight pattern */
4188             fontname_tokenize(&tokens, initialW);
4189             match_pattern_list(&tokens, weightsim_patterns, NULL);
4190             fontname_tokens_to_str(&tokens, facenameW);
4191
4192             /* Bold suffix for new name */
4193             if (*facenameW) wcscat(facenameW, L" ");
4194             wcscat(facenameW, L"Bold");
4195
4196             if (init_font_data_from_font(family->fonts[heaviest], DWRITE_FONT_SIMULATIONS_BOLD, facenameW, &boldface) == S_OK) {
4197                 boldface->bold_sim_tested = 1;
4198                 boldface->lf.lfWeight += (FW_BOLD - FW_REGULAR) / 2 + 1;
4199                 fontfamily_add_font(family, boldface);
4200             }
4201         }
4202     }
4203 }
4204
4205 static void fontfamily_add_oblique_simulated_face(struct dwrite_fontfamily_data *family)
4206 {
4207     size_t i, j;
4208
4209     for (i = 0; i < family->count; ++i)
4210     {
4211         UINT32 regular = ~0u, oblique = ~0u;
4212         struct dwrite_font_data *obliqueface;
4213         WCHAR facenameW[255];
4214
4215         if (family->fonts[i]->oblique_sim_tested)
4216             continue;
4217
4218         family->fonts[i]->oblique_sim_tested = 1;
4219         if (family->fonts[i]->style == DWRITE_FONT_STYLE_NORMAL)
4220             regular = i;
4221         else if (family->fonts[i]->style == DWRITE_FONT_STYLE_OBLIQUE)
4222             oblique = i;
4223
4224         /* find regular style with same weight/stretch values */
4225         for (j = i; j < family->count; ++j)
4226         {
4227             if (family->fonts[j]->oblique_sim_tested)
4228                 continue;
4229
4230             if ((family->fonts[i]->weight == family->fonts[j]->weight) &&
4231                 (family->fonts[i]->stretch == family->fonts[j]->stretch)) {
4232
4233                 family->fonts[j]->oblique_sim_tested = 1;
4234                 if (regular == ~0 && family->fonts[j]->style == DWRITE_FONT_STYLE_NORMAL)
4235                     regular = j;
4236
4237                 if (oblique == ~0 && family->fonts[j]->style == DWRITE_FONT_STYLE_OBLIQUE)
4238                     oblique = j;
4239             }
4240
4241             if (regular != ~0u && oblique != ~0u)
4242                 break;
4243         }
4244
4245         /* no regular variant for this weight/stretch pair, nothing to base simulated face on */
4246         if (regular == ~0u)
4247             continue;
4248
4249         /* regular face exists, and corresponding oblique is present as well, nothing to do */
4250         if (oblique != ~0u)
4251             continue;
4252
4253         /* add oblique simulation based on this regular face */
4254
4255         /* remove regular term if any, append 'Oblique' */
4256         fontstrings_get_en_string(family->fonts[regular]->names, facenameW, ARRAY_SIZE(facenameW));
4257         facename_remove_regular_term(facenameW, -1);
4258
4259         if (*facenameW) wcscat(facenameW, L" ");
4260         wcscat(facenameW, L"Oblique");
4261
4262         if (init_font_data_from_font(family->fonts[regular], DWRITE_FONT_SIMULATIONS_OBLIQUE, facenameW, &obliqueface) == S_OK) {
4263             obliqueface->oblique_sim_tested = 1;
4264             obliqueface->lf.lfItalic = 1;
4265             fontfamily_add_font(family, obliqueface);
4266         }
4267     }
4268 }
4269
4270 static BOOL fontcollection_add_replacement(struct dwrite_fontcollection *collection, const WCHAR *target_name,
4271     const WCHAR *replacement_name)
4272 {
4273     UINT32 i = collection_find_family(collection, replacement_name);
4274     struct dwrite_fontfamily_data *target;
4275     IDWriteLocalizedStrings *strings;
4276     HRESULT hr;
4277
4278     /* replacement does not exist */
4279     if (i == ~0u)
4280         return FALSE;
4281
4282     hr = create_localizedstrings(&strings);
4283     if (FAILED(hr))
4284         return FALSE;
4285
4286     /* add a new family with target name, reuse font data from replacement */
4287     add_localizedstring(strings, L"en-us", target_name);
4288     hr = init_fontfamily_data(strings, &target);
4289     if (hr == S_OK) {
4290         struct dwrite_fontfamily_data *replacement = collection->family_data[i];
4291         WCHAR nameW[255];
4292
4293         for (i = 0; i < replacement->count; ++i)
4294         {
4295             fontfamily_add_font(target, replacement->fonts[i]);
4296             addref_font_data(replacement->fonts[i]);
4297         }
4298
4299         fontcollection_add_family(collection, target);
4300         fontstrings_get_en_string(replacement->familyname, nameW, ARRAY_SIZE(nameW));
4301         TRACE("replacement %s -> %s\n", debugstr_w(target_name), debugstr_w(nameW));
4302     }
4303     IDWriteLocalizedStrings_Release(strings);
4304     return TRUE;
4305 }
4306
4307 /* Add family mappings from HKCU\Software\Wine\Fonts\Replacements. This only affects
4308    system font collections. */
4309 static void fontcollection_add_replacements(struct dwrite_fontcollection *collection)
4310 {
4311     DWORD max_namelen, max_datalen, i = 0, type, datalen, namelen;
4312     WCHAR *name;
4313     void *data;
4314     HKEY hkey;
4315
4316     if (RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Fonts\\Replacements", &hkey))
4317         return;
4318
4319     if (RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &max_namelen, &max_datalen, NULL, NULL)) {
4320         RegCloseKey(hkey);
4321         return;
4322     }
4323
4324     max_namelen++; /* returned value doesn't include room for '\0' */
4325     name = heap_alloc(max_namelen * sizeof(WCHAR));
4326     data = heap_alloc(max_datalen);
4327
4328     datalen = max_datalen;
4329     namelen = max_namelen;
4330     while (RegEnumValueW(hkey, i++, name, &namelen, NULL, &type, data, &datalen) == ERROR_SUCCESS) {
4331         if (collection_find_family(collection, name) == ~0u) {
4332             if (type == REG_MULTI_SZ) {
4333                 WCHAR *replacement = data;
4334                 while (*replacement) {
4335                     if (fontcollection_add_replacement(collection, name, replacement))
4336                         break;
4337                     replacement += wcslen(replacement) + 1;
4338                 }
4339             }
4340             else if (type == REG_SZ)
4341                 fontcollection_add_replacement(collection, name, data);
4342         }
4343         else
4344             TRACE("%s is available, won't be replaced.\n", debugstr_w(name));
4345
4346         datalen = max_datalen;
4347         namelen = max_namelen;
4348     }
4349
4350     heap_free(data);
4351     heap_free(name);
4352     RegCloseKey(hkey);
4353 }
4354
4355 HRESULT create_font_collection(IDWriteFactory7 *factory, IDWriteFontFileEnumerator *enumerator, BOOL is_system,
4356     IDWriteFontCollection3 **ret)
4357 {
4358     struct fontfile_enum {
4359         struct list entry;
4360         IDWriteFontFile *file;
4361     };
4362     struct fontfile_enum *fileenum, *fileenum2;
4363     struct dwrite_fontcollection *collection;
4364     struct list scannedfiles;
4365     BOOL current = FALSE;
4366     HRESULT hr = S_OK;
4367     size_t i;
4368
4369     *ret = NULL;
4370
4371     collection = heap_alloc(sizeof(struct dwrite_fontcollection));
4372     if (!collection) return E_OUTOFMEMORY;
4373
4374     hr = init_font_collection(collection, is_system);
4375     if (FAILED(hr)) {
4376         heap_free(collection);
4377         return hr;
4378     }
4379
4380     *ret = &collection->IDWriteFontCollection3_iface;
4381
4382     TRACE("building font collection:\n");
4383
4384     list_init(&scannedfiles);
4385     while (hr == S_OK) {
4386         DWRITE_FONT_FACE_TYPE face_type;
4387         DWRITE_FONT_FILE_TYPE file_type;
4388         BOOL supported, same = FALSE;
4389         IDWriteFontFileStream *stream;
4390         IDWriteFontFile *file;
4391         UINT32 face_count;
4392
4393         current = FALSE;
4394         hr = IDWriteFontFileEnumerator_MoveNext(enumerator, &current);
4395         if (FAILED(hr) || !current)
4396             break;
4397
4398         hr = IDWriteFontFileEnumerator_GetCurrentFontFile(enumerator, &file);
4399         if (FAILED(hr))
4400             break;
4401
4402         /* check if we've scanned this file already */
4403         LIST_FOR_EACH_ENTRY(fileenum, &scannedfiles, struct fontfile_enum, entry) {
4404             if ((same = is_same_fontfile(fileenum->file, file)))
4405                 break;
4406         }
4407
4408         if (same) {
4409             IDWriteFontFile_Release(file);
4410             continue;
4411         }
4412
4413         if (FAILED(get_filestream_from_file(file, &stream))) {
4414             IDWriteFontFile_Release(file);
4415             continue;
4416         }
4417
4418         /* Unsupported formats are skipped. */
4419         hr = opentype_analyze_font(stream, &supported, &file_type, &face_type, &face_count);
4420         if (FAILED(hr) || !supported || face_count == 0) {
4421             TRACE("Unsupported font (%p, 0x%08x, %d, %u)\n", file, hr, supported, face_count);
4422             IDWriteFontFileStream_Release(stream);
4423             IDWriteFontFile_Release(file);
4424             hr = S_OK;
4425             continue;
4426         }
4427
4428         /* add to scanned list */
4429         fileenum = heap_alloc(sizeof(*fileenum));
4430         fileenum->file = file;
4431         list_add_tail(&scannedfiles, &fileenum->entry);
4432
4433         for (i = 0; i < face_count; ++i)
4434         {
4435             struct dwrite_font_data *font_data;
4436             struct fontface_desc desc;
4437             WCHAR familyW[255];
4438             UINT32 index;
4439
4440             desc.factory = factory;
4441             desc.face_type = face_type;
4442             desc.file = file;
4443             desc.stream = stream;
4444             desc.index = i;
4445             desc.simulations = DWRITE_FONT_SIMULATIONS_NONE;
4446             desc.font_data = NULL;
4447
4448             /* Allocate an initialize new font data structure. */
4449             hr = init_font_data(&desc, &font_data);
4450             if (FAILED(hr))
4451             {
4452                 /* move to next one */
4453                 hr = S_OK;
4454                 continue;
4455             }
4456
4457             fontstrings_get_en_string(font_data->family_names, familyW, ARRAY_SIZE(familyW));
4458
4459             /* ignore dot named faces */
4460             if (familyW[0] == '.')
4461             {
4462                 WARN("Ignoring face %s\n", debugstr_w(familyW));
4463                 release_font_data(font_data);
4464                 continue;
4465             }
4466
4467             index = collection_find_family(collection, familyW);
4468             if (index != ~0u)
4469                 hr = fontfamily_add_font(collection->family_data[index], font_data);
4470             else {
4471                 struct dwrite_fontfamily_data *family_data;
4472
4473                 /* create and init new family */
4474                 hr = init_fontfamily_data(font_data->family_names, &family_data);
4475                 if (hr == S_OK) {
4476                     /* add font to family, family - to collection */
4477                     hr = fontfamily_add_font(family_data, font_data);
4478                     if (hr == S_OK)
4479                         hr = fontcollection_add_family(collection, family_data);
4480
4481                     if (FAILED(hr))
4482                         release_fontfamily_data(family_data);
4483                 }
4484             }
4485
4486             if (FAILED(hr))
4487                 break;
4488         }
4489
4490         IDWriteFontFileStream_Release(stream);
4491     }
4492
4493     LIST_FOR_EACH_ENTRY_SAFE(fileenum, fileenum2, &scannedfiles, struct fontfile_enum, entry) {
4494         IDWriteFontFile_Release(fileenum->file);
4495         list_remove(&fileenum->entry);
4496         heap_free(fileenum);
4497     }
4498
4499     for (i = 0; i < collection->count; ++i)
4500     {
4501         fontfamily_add_bold_simulated_face(collection->family_data[i]);
4502         fontfamily_add_oblique_simulated_face(collection->family_data[i]);
4503     }
4504
4505     if (is_system)
4506         fontcollection_add_replacements(collection);
4507
4508     collection->factory = factory;
4509     IDWriteFactory7_AddRef(factory);
4510
4511     return hr;
4512 }
4513
4514 struct system_fontfile_enumerator
4515 {
4516     IDWriteFontFileEnumerator IDWriteFontFileEnumerator_iface;
4517     LONG refcount;
4518
4519     IDWriteFactory7 *factory;
4520     HKEY hkey;
4521     int index;
4522
4523     WCHAR *filename;
4524     DWORD filename_size;
4525 };
4526
4527 static inline struct system_fontfile_enumerator *impl_from_IDWriteFontFileEnumerator(IDWriteFontFileEnumerator* iface)
4528 {
4529     return CONTAINING_RECORD(iface, struct system_fontfile_enumerator, IDWriteFontFileEnumerator_iface);
4530 }
4531
4532 static HRESULT WINAPI systemfontfileenumerator_QueryInterface(IDWriteFontFileEnumerator *iface, REFIID riid, void **obj)
4533 {
4534     if (IsEqualIID(riid, &IID_IDWriteFontFileEnumerator) || IsEqualIID(riid, &IID_IUnknown)) {
4535         IDWriteFontFileEnumerator_AddRef(iface);
4536         *obj = iface;
4537         return S_OK;
4538     }
4539
4540     WARN("%s not implemented.\n", debugstr_guid(riid));
4541
4542     *obj = NULL;
4543
4544     return E_NOINTERFACE;
4545 }
4546
4547 static ULONG WINAPI systemfontfileenumerator_AddRef(IDWriteFontFileEnumerator *iface)
4548 {
4549     struct system_fontfile_enumerator *enumerator = impl_from_IDWriteFontFileEnumerator(iface);
4550     return InterlockedIncrement(&enumerator->refcount);
4551 }
4552
4553 static ULONG WINAPI systemfontfileenumerator_Release(IDWriteFontFileEnumerator *iface)
4554 {
4555     struct system_fontfile_enumerator *enumerator = impl_from_IDWriteFontFileEnumerator(iface);
4556     ULONG refcount = InterlockedDecrement(&enumerator->refcount);
4557
4558     if (!refcount)
4559     {
4560         IDWriteFactory7_Release(enumerator->factory);
4561         RegCloseKey(enumerator->hkey);
4562         heap_free(enumerator->filename);
4563         heap_free(enumerator);
4564     }
4565
4566     return refcount;
4567 }
4568
4569 static HRESULT create_local_file_reference(IDWriteFactory7 *factory, const WCHAR *filename, IDWriteFontFile **file)
4570 {
4571     HRESULT hr;
4572
4573     /* Fonts installed in 'Fonts' system dir don't get full path in registry font files cache */
4574     if (!wcschr(filename, '\\'))
4575     {
4576         WCHAR fullpathW[MAX_PATH];
4577
4578         GetWindowsDirectoryW(fullpathW, ARRAY_SIZE(fullpathW));
4579         wcscat(fullpathW, L"\\fonts\\");
4580         wcscat(fullpathW, filename);
4581
4582         hr = IDWriteFactory7_CreateFontFileReference(factory, fullpathW, NULL, file);
4583     }
4584     else
4585         hr = IDWriteFactory7_CreateFontFileReference(factory, filename, NULL, file);
4586
4587     return hr;
4588 }
4589
4590 static HRESULT WINAPI systemfontfileenumerator_GetCurrentFontFile(IDWriteFontFileEnumerator *iface, IDWriteFontFile **file)
4591 {
4592     struct system_fontfile_enumerator *enumerator = impl_from_IDWriteFontFileEnumerator(iface);
4593
4594     *file = NULL;
4595
4596     if (enumerator->index < 0 || !enumerator->filename || !*enumerator->filename)
4597         return E_FAIL;
4598
4599     return create_local_file_reference(enumerator->factory, enumerator->filename, file);
4600 }
4601
4602 static HRESULT WINAPI systemfontfileenumerator_MoveNext(IDWriteFontFileEnumerator *iface, BOOL *current)
4603 {
4604     struct system_fontfile_enumerator *enumerator = impl_from_IDWriteFontFileEnumerator(iface);
4605     WCHAR name_buf[256], *name = name_buf;
4606     DWORD name_count, max_name_count = ARRAY_SIZE(name_buf), type, data_size;
4607     HRESULT hr = S_OK;
4608     LONG r;
4609
4610     *current = FALSE;
4611     enumerator->index++;
4612
4613     /* iterate until we find next string value */
4614     for (;;) {
4615         do {
4616             name_count = max_name_count;
4617             data_size = enumerator->filename_size - sizeof(*enumerator->filename);
4618
4619             r = RegEnumValueW(enumerator->hkey, enumerator->index, name, &name_count,
4620                               NULL, &type, (BYTE *)enumerator->filename, &data_size);
4621             if (r == ERROR_MORE_DATA) {
4622                 if (name_count >= max_name_count) {
4623                     if (name != name_buf) heap_free(name);
4624                     max_name_count *= 2;
4625                     name = heap_alloc(max_name_count * sizeof(*name));
4626                     if (!name) return E_OUTOFMEMORY;
4627                 }
4628                 if (data_size > enumerator->filename_size - sizeof(*enumerator->filename)) {
4629                     heap_free(enumerator->filename);
4630                     enumerator->filename_size = max(data_size + sizeof(*enumerator->filename), enumerator->filename_size * 2);
4631                     enumerator->filename = heap_alloc(enumerator->filename_size);
4632                     if (!enumerator->filename) {
4633                         hr = E_OUTOFMEMORY;
4634                         goto err;
4635                     }
4636                 }
4637             }
4638         } while (r == ERROR_MORE_DATA);
4639
4640         if (r != ERROR_SUCCESS) {
4641             enumerator->filename[0] = 0;
4642             break;
4643         }
4644         enumerator->filename[data_size / sizeof(*enumerator->filename)] = 0;
4645         if (type == REG_SZ && *name != '@') {
4646             *current = TRUE;
4647             break;
4648         }
4649         enumerator->index++;
4650     }
4651     TRACE("index = %d, current = %d\n", enumerator->index, *current);
4652
4653 err:
4654     if (name != name_buf) heap_free(name);
4655     return hr;
4656 }
4657
4658 static const IDWriteFontFileEnumeratorVtbl systemfontfileenumeratorvtbl =
4659 {
4660     systemfontfileenumerator_QueryInterface,
4661     systemfontfileenumerator_AddRef,
4662     systemfontfileenumerator_Release,
4663     systemfontfileenumerator_MoveNext,
4664     systemfontfileenumerator_GetCurrentFontFile
4665 };
4666
4667 static HRESULT create_system_fontfile_enumerator(IDWriteFactory7 *factory, IDWriteFontFileEnumerator **ret)
4668 {
4669     struct system_fontfile_enumerator *enumerator;
4670
4671     *ret = NULL;
4672
4673     enumerator = heap_alloc(sizeof(*enumerator));
4674     if (!enumerator)
4675         return E_OUTOFMEMORY;
4676
4677     enumerator->IDWriteFontFileEnumerator_iface.lpVtbl = &systemfontfileenumeratorvtbl;
4678     enumerator->refcount = 1;
4679     enumerator->factory = factory;
4680     enumerator->index = -1;
4681     enumerator->filename_size = MAX_PATH * sizeof(*enumerator->filename);
4682     enumerator->filename = heap_alloc(enumerator->filename_size);
4683     if (!enumerator->filename) {
4684         heap_free(enumerator);
4685         return E_OUTOFMEMORY;
4686     }
4687
4688     IDWriteFactory7_AddRef(factory);
4689
4690     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts", 0,
4691             GENERIC_READ, &enumerator->hkey))
4692     {
4693         ERR("failed to open fonts list key\n");
4694         IDWriteFactory7_Release(factory);
4695         heap_free(enumerator->filename);
4696         heap_free(enumerator);
4697         return E_FAIL;
4698     }
4699
4700     *ret = &enumerator->IDWriteFontFileEnumerator_iface;
4701
4702     return S_OK;
4703 }
4704
4705 HRESULT get_system_fontcollection(IDWriteFactory7 *factory, IDWriteFontCollection1 **collection)
4706 {
4707     IDWriteFontFileEnumerator *enumerator;
4708     HRESULT hr;
4709
4710     *collection = NULL;
4711
4712     hr = create_system_fontfile_enumerator(factory, &enumerator);
4713     if (FAILED(hr))
4714         return hr;
4715
4716     TRACE("building system font collection for factory %p\n", factory);
4717     hr = create_font_collection(factory, enumerator, TRUE, (IDWriteFontCollection3 **)collection);
4718     IDWriteFontFileEnumerator_Release(enumerator);
4719     return hr;
4720 }
4721
4722 static HRESULT eudc_collection_add_family(IDWriteFactory7 *factory, struct dwrite_fontcollection *collection,
4723     const WCHAR *keynameW, const WCHAR *pathW)
4724 {
4725     struct dwrite_fontfamily_data *family_data;
4726     IDWriteLocalizedStrings *names;
4727     DWRITE_FONT_FACE_TYPE face_type;
4728     DWRITE_FONT_FILE_TYPE file_type;
4729     IDWriteFontFileStream *stream;
4730     IDWriteFontFile *file;
4731     UINT32 face_count, i;
4732     BOOL supported;
4733     HRESULT hr;
4734
4735     /* create font file from this path */
4736     hr = create_local_file_reference(factory, pathW, &file);
4737     if (FAILED(hr))
4738         return S_FALSE;
4739
4740     if (FAILED(get_filestream_from_file(file, &stream))) {
4741         IDWriteFontFile_Release(file);
4742         return S_FALSE;
4743     }
4744
4745     /* Unsupported formats are skipped. */
4746     hr = opentype_analyze_font(stream, &supported, &file_type, &face_type, &face_count);
4747     if (FAILED(hr) || !supported || face_count == 0) {
4748         TRACE("Unsupported font (%p, 0x%08x, %d, %u)\n", file, hr, supported, face_count);
4749         IDWriteFontFileStream_Release(stream);
4750         IDWriteFontFile_Release(file);
4751         return S_FALSE;
4752     }
4753
4754     /* create and init new family */
4755
4756     /* Family names are added for non-specific locale, represented with empty string.
4757        Default family appears with empty family name. */
4758     create_localizedstrings(&names);
4759     if (!wcsicmp(keynameW, L"SystemDefaultEUDCFont"))
4760         add_localizedstring(names, L"", L"");
4761     else
4762         add_localizedstring(names, L"", keynameW);
4763
4764     hr = init_fontfamily_data(names, &family_data);
4765     IDWriteLocalizedStrings_Release(names);
4766     if (hr != S_OK) {
4767         IDWriteFontFile_Release(file);
4768         return hr;
4769     }
4770
4771     /* fill with faces */
4772     for (i = 0; i < face_count; i++) {
4773         struct dwrite_font_data *font_data;
4774         struct fontface_desc desc;
4775
4776         /* Allocate new font data structure. */
4777         desc.factory = factory;
4778         desc.face_type = face_type;
4779         desc.index = i;
4780         desc.file = file;
4781         desc.stream = stream;
4782         desc.simulations = DWRITE_FONT_SIMULATIONS_NONE;
4783         desc.font_data = NULL;
4784
4785         hr = init_font_data(&desc, &font_data);
4786         if (FAILED(hr))
4787             continue;
4788
4789         /* add font to family */
4790         hr = fontfamily_add_font(family_data, font_data);
4791         if (hr != S_OK)
4792             release_font_data(font_data);
4793     }
4794
4795     /* add family to collection */
4796     hr = fontcollection_add_family(collection, family_data);
4797     if (FAILED(hr))
4798         release_fontfamily_data(family_data);
4799     IDWriteFontFileStream_Release(stream);
4800     IDWriteFontFile_Release(file);
4801
4802     return hr;
4803 }
4804
4805 HRESULT get_eudc_fontcollection(IDWriteFactory7 *factory, IDWriteFontCollection3 **ret)
4806 {
4807     struct dwrite_fontcollection *collection;
4808     WCHAR eudckeypathW[16];
4809     HKEY eudckey;
4810     DWORD index;
4811     BOOL exists;
4812     LONG retval;
4813     HRESULT hr;
4814     size_t i;
4815
4816     TRACE("building EUDC font collection for factory %p, ACP %u\n", factory, GetACP());
4817
4818     *ret = NULL;
4819
4820     collection = heap_alloc(sizeof(struct dwrite_fontcollection));
4821     if (!collection) return E_OUTOFMEMORY;
4822
4823     hr = init_font_collection(collection, FALSE);
4824     if (FAILED(hr)) {
4825         heap_free(collection);
4826         return hr;
4827     }
4828
4829     *ret = &collection->IDWriteFontCollection3_iface;
4830     collection->factory = factory;
4831     IDWriteFactory7_AddRef(factory);
4832
4833     /* return empty collection if EUDC fonts are not configured */
4834     swprintf(eudckeypathW, ARRAY_SIZE(eudckeypathW), L"EUDC\\%u", GetACP());
4835     if (RegOpenKeyExW(HKEY_CURRENT_USER, eudckeypathW, 0, GENERIC_READ, &eudckey))
4836         return S_OK;
4837
4838     retval = ERROR_SUCCESS;
4839     index = 0;
4840     while (retval != ERROR_NO_MORE_ITEMS) {
4841         WCHAR keynameW[64], pathW[MAX_PATH];
4842         DWORD type, path_len, name_len;
4843
4844         path_len = ARRAY_SIZE(pathW);
4845         name_len = ARRAY_SIZE(keynameW);
4846         retval = RegEnumValueW(eudckey, index++, keynameW, &name_len, NULL, &type, (BYTE*)pathW, &path_len);
4847         if (retval || type != REG_SZ)
4848             continue;
4849
4850         hr = eudc_collection_add_family(factory, collection, keynameW, pathW);
4851         if (hr != S_OK)
4852             WARN("failed to add family %s, path %s\n", debugstr_w(keynameW), debugstr_w(pathW));
4853     }
4854     RegCloseKey(eudckey);
4855
4856     /* try to add global default if not defined for specific codepage */
4857     exists = FALSE;
4858     hr = IDWriteFontCollection3_FindFamilyName(&collection->IDWriteFontCollection3_iface, L"",
4859         &index, &exists);
4860     if (FAILED(hr) || !exists)
4861     {
4862         hr = eudc_collection_add_family(factory, collection, L"", L"EUDC.TTE");
4863         if (hr != S_OK)
4864             WARN("failed to add global default EUDC font, 0x%08x\n", hr);
4865     }
4866
4867     /* EUDC collection offers simulated faces too */
4868     for (i = 0; i < collection->count; ++i)
4869     {
4870         fontfamily_add_bold_simulated_face(collection->family_data[i]);
4871         fontfamily_add_oblique_simulated_face(collection->family_data[i]);
4872     }
4873
4874     return S_OK;
4875 }
4876
4877 static HRESULT WINAPI dwritefontfile_QueryInterface(IDWriteFontFile *iface, REFIID riid, void **obj)
4878 {
4879     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
4880
4881     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDWriteFontFile))
4882     {
4883         *obj = iface;
4884         IDWriteFontFile_AddRef(iface);
4885         return S_OK;
4886     }
4887
4888     WARN("%s not implemented.\n", debugstr_guid(riid));
4889
4890     *obj = NULL;
4891     return E_NOINTERFACE;
4892 }
4893
4894 static ULONG WINAPI dwritefontfile_AddRef(IDWriteFontFile *iface)
4895 {
4896     struct dwrite_fontfile *file = impl_from_IDWriteFontFile(iface);
4897     ULONG refcount = InterlockedIncrement(&file->refcount);
4898
4899     TRACE("%p, refcount %d.\n", iface, refcount);
4900
4901     return refcount;
4902 }
4903
4904 static ULONG WINAPI dwritefontfile_Release(IDWriteFontFile *iface)
4905 {
4906     struct dwrite_fontfile *file = impl_from_IDWriteFontFile(iface);
4907     ULONG refcount = InterlockedDecrement(&file->refcount);
4908
4909     TRACE("%p, refcount %d.\n", iface, refcount);
4910
4911     if (!refcount)
4912     {
4913         IDWriteFontFileLoader_Release(file->loader);
4914         if (file->stream)
4915             IDWriteFontFileStream_Release(file->stream);
4916         heap_free(file->reference_key);
4917         heap_free(file);
4918     }
4919
4920     return refcount;
4921 }
4922
4923 static HRESULT WINAPI dwritefontfile_GetReferenceKey(IDWriteFontFile *iface, const void **key, UINT32 *key_size)
4924 {
4925     struct dwrite_fontfile *file = impl_from_IDWriteFontFile(iface);
4926
4927     TRACE("%p, %p, %p.\n", iface, key, key_size);
4928
4929     *key = file->reference_key;
4930     *key_size = file->key_size;
4931
4932     return S_OK;
4933 }
4934
4935 static HRESULT WINAPI dwritefontfile_GetLoader(IDWriteFontFile *iface, IDWriteFontFileLoader **loader)
4936 {
4937     struct dwrite_fontfile *file = impl_from_IDWriteFontFile(iface);
4938
4939     TRACE("%p, %p.\n", iface, loader);
4940
4941     *loader = file->loader;
4942     IDWriteFontFileLoader_AddRef(*loader);
4943
4944     return S_OK;
4945 }
4946
4947 static HRESULT WINAPI dwritefontfile_Analyze(IDWriteFontFile *iface, BOOL *is_supported, DWRITE_FONT_FILE_TYPE *file_type,
4948     DWRITE_FONT_FACE_TYPE *face_type, UINT32 *face_count)
4949 {
4950     struct dwrite_fontfile *file = impl_from_IDWriteFontFile(iface);
4951     IDWriteFontFileStream *stream;
4952     HRESULT hr;
4953
4954     TRACE("%p, %p, %p, %p, %p.\n", iface, is_supported, file_type, face_type, face_count);
4955
4956     *is_supported = FALSE;
4957     *file_type = DWRITE_FONT_FILE_TYPE_UNKNOWN;
4958     if (face_type)
4959         *face_type = DWRITE_FONT_FACE_TYPE_UNKNOWN;
4960     *face_count = 0;
4961
4962     hr = IDWriteFontFileLoader_CreateStreamFromKey(file->loader, file->reference_key, file->key_size, &stream);
4963     if (FAILED(hr))
4964         return hr;
4965
4966     hr = opentype_analyze_font(stream, is_supported, file_type, face_type, face_count);
4967
4968     /* TODO: Further Analysis */
4969     IDWriteFontFileStream_Release(stream);
4970     return S_OK;
4971 }
4972
4973 static const IDWriteFontFileVtbl dwritefontfilevtbl =
4974 {
4975     dwritefontfile_QueryInterface,
4976     dwritefontfile_AddRef,
4977     dwritefontfile_Release,
4978     dwritefontfile_GetReferenceKey,
4979     dwritefontfile_GetLoader,
4980     dwritefontfile_Analyze,
4981 };
4982
4983 HRESULT create_font_file(IDWriteFontFileLoader *loader, const void *reference_key, UINT32 key_size,
4984         IDWriteFontFile **ret)
4985 {
4986     struct dwrite_fontfile *file;
4987     void *key;
4988
4989     *ret = NULL;
4990
4991     file = heap_alloc(sizeof(*file));
4992     key = heap_alloc(key_size);
4993     if (!file || !key) {
4994         heap_free(file);
4995         heap_free(key);
4996         return E_OUTOFMEMORY;
4997     }
4998
4999     file->IDWriteFontFile_iface.lpVtbl = &dwritefontfilevtbl;
5000     file->refcount = 1;
5001     IDWriteFontFileLoader_AddRef(loader);
5002     file->loader = loader;
5003     file->stream = NULL;
5004     file->reference_key = key;
5005     memcpy(file->reference_key, reference_key, key_size);
5006     file->key_size = key_size;
5007
5008     *ret = &file->IDWriteFontFile_iface;
5009
5010     return S_OK;
5011 }
5012
5013 HRESULT create_fontface(const struct fontface_desc *desc, struct list *cached_list, IDWriteFontFace5 **ret)
5014 {
5015     struct file_stream_desc stream_desc;
5016     struct dwrite_font_data *font_data;
5017     struct dwrite_fontface *fontface;
5018     HRESULT hr;
5019     int i;
5020
5021     *ret = NULL;
5022
5023     fontface = heap_alloc_zero(sizeof(struct dwrite_fontface));
5024     if (!fontface)
5025         return E_OUTOFMEMORY;
5026
5027     fontface->IDWriteFontFace5_iface.lpVtbl = &dwritefontfacevtbl;
5028     fontface->IDWriteFontFaceReference_iface.lpVtbl = &dwritefontface_reference_vtbl;
5029     fontface->refcount = 1;
5030     fontface->type = desc->face_type;
5031     fontface->vdmx.exists = TRUE;
5032     fontface->gasp.exists = TRUE;
5033     fontface->cpal.exists = TRUE;
5034     fontface->colr.exists = TRUE;
5035     fontface->kern.exists = TRUE;
5036     fontface->index = desc->index;
5037     fontface->simulations = desc->simulations;
5038     fontface->factory = desc->factory;
5039     IDWriteFactory7_AddRef(fontface->factory);
5040     fontface->file = desc->file;
5041     IDWriteFontFile_AddRef(fontface->file);
5042     fontface->stream = desc->stream;
5043     IDWriteFontFileStream_AddRef(fontface->stream);
5044
5045     stream_desc.stream = fontface->stream;
5046     stream_desc.face_type = desc->face_type;
5047     stream_desc.face_index = desc->index;
5048     opentype_get_font_metrics(&stream_desc, &fontface->metrics, &fontface->caret);
5049     opentype_get_font_typo_metrics(&stream_desc, &fontface->typo_metrics.ascent, &fontface->typo_metrics.descent);
5050     if (desc->simulations & DWRITE_FONT_SIMULATIONS_OBLIQUE) {
5051         /* TODO: test what happens if caret is already slanted */
5052         if (fontface->caret.slopeRise == 1) {
5053             fontface->caret.slopeRise = fontface->metrics.designUnitsPerEm;
5054             fontface->caret.slopeRun = fontface->caret.slopeRise / 3;
5055         }
5056     }
5057     fontface->glyph_image_formats = opentype_get_glyph_image_formats(&fontface->IDWriteFontFace5_iface);
5058
5059     /* Font properties are reused from font object when 'normal' face creation path is used:
5060        collection -> family -> matching font -> fontface.
5061
5062        If face is created directly from factory we have to go through properties resolution.
5063     */
5064     if (desc->font_data)
5065     {
5066         font_data = addref_font_data(desc->font_data);
5067     }
5068     else
5069     {
5070         hr = init_font_data(desc, &font_data);
5071         if (FAILED(hr))
5072         {
5073             IDWriteFontFace5_Release(&fontface->IDWriteFontFace5_iface);
5074             return hr;
5075         }
5076     }
5077
5078     fontface->weight = font_data->weight;
5079     fontface->style = font_data->style;
5080     fontface->stretch = font_data->stretch;
5081     fontface->panose = font_data->panose;
5082     fontface->fontsig = font_data->fontsig;
5083     fontface->lf = font_data->lf;
5084     fontface->flags |= font_data->flags & (FONT_IS_SYMBOL | FONT_IS_MONOSPACED | FONT_IS_COLORED);
5085     fontface->names = font_data->names;
5086     if (fontface->names)
5087         IDWriteLocalizedStrings_AddRef(fontface->names);
5088     fontface->family_names = font_data->family_names;
5089     if (fontface->family_names)
5090         IDWriteLocalizedStrings_AddRef(fontface->family_names);
5091     memcpy(fontface->info_strings, font_data->info_strings, sizeof(fontface->info_strings));
5092     for (i = 0; i < ARRAY_SIZE(fontface->info_strings); ++i)
5093     {
5094         if (fontface->info_strings[i])
5095             IDWriteLocalizedStrings_AddRef(fontface->info_strings[i]);
5096     }
5097     fontface->cmap.stream = fontface->stream;
5098     IDWriteFontFileStream_AddRef(fontface->cmap.stream);
5099     release_font_data(font_data);
5100
5101     fontface->cached = factory_cache_fontface(fontface->factory, cached_list, &fontface->IDWriteFontFace5_iface);
5102
5103     *ret = &fontface->IDWriteFontFace5_iface;
5104
5105     return S_OK;
5106 }
5107
5108 /* IDWriteLocalFontFileLoader and its required IDWriteFontFileStream */
5109 struct local_refkey
5110 {
5111     FILETIME writetime;
5112     WCHAR name[1];
5113 };
5114
5115 struct local_cached_stream
5116 {
5117     struct list entry;
5118     IDWriteFontFileStream *stream;
5119     struct local_refkey *key;
5120     UINT32 key_size;
5121 };
5122
5123 struct dwrite_localfontfilestream
5124 {
5125     IDWriteFontFileStream IDWriteFontFileStream_iface;
5126     LONG refcount;
5127
5128     struct local_cached_stream *entry;
5129     const void *file_ptr;
5130     UINT64 size;
5131 };
5132
5133 struct dwrite_localfontfileloader
5134 {
5135     IDWriteLocalFontFileLoader IDWriteLocalFontFileLoader_iface;
5136     LONG refcount;
5137
5138     struct list streams;
5139     CRITICAL_SECTION cs;
5140 };
5141
5142 static struct dwrite_localfontfileloader local_fontfile_loader;
5143
5144 struct dwrite_inmemory_stream_data
5145 {
5146     LONG refcount;
5147     IUnknown *owner;
5148     void *data;
5149     UINT32 size;
5150 };
5151
5152 struct dwrite_inmemory_filestream
5153 {
5154     IDWriteFontFileStream IDWriteFontFileStream_iface;
5155     LONG refcount;
5156
5157     struct dwrite_inmemory_stream_data *data;
5158 };
5159
5160 struct dwrite_inmemory_fileloader
5161 {
5162     IDWriteInMemoryFontFileLoader IDWriteInMemoryFontFileLoader_iface;
5163     LONG refcount;
5164
5165     struct dwrite_inmemory_stream_data **streams;
5166     size_t size;
5167     size_t count;
5168 };
5169
5170 static inline struct dwrite_localfontfileloader *impl_from_IDWriteLocalFontFileLoader(IDWriteLocalFontFileLoader *iface)
5171 {
5172     return CONTAINING_RECORD(iface, struct dwrite_localfontfileloader, IDWriteLocalFontFileLoader_iface);
5173 }
5174
5175 static inline struct dwrite_localfontfilestream *impl_from_IDWriteFontFileStream(IDWriteFontFileStream *iface)
5176 {
5177     return CONTAINING_RECORD(iface, struct dwrite_localfontfilestream, IDWriteFontFileStream_iface);
5178 }
5179
5180 static inline struct dwrite_inmemory_fileloader *impl_from_IDWriteInMemoryFontFileLoader(IDWriteInMemoryFontFileLoader *iface)
5181 {
5182     return CONTAINING_RECORD(iface, struct dwrite_inmemory_fileloader, IDWriteInMemoryFontFileLoader_iface);
5183 }
5184
5185 static inline struct dwrite_inmemory_filestream *inmemory_impl_from_IDWriteFontFileStream(IDWriteFontFileStream *iface)
5186 {
5187     return CONTAINING_RECORD(iface, struct dwrite_inmemory_filestream, IDWriteFontFileStream_iface);
5188 }
5189
5190 static void release_inmemory_stream(struct dwrite_inmemory_stream_data *stream)
5191 {
5192     if (InterlockedDecrement(&stream->refcount) == 0)
5193     {
5194         if (stream->owner)
5195             IUnknown_Release(stream->owner);
5196         else
5197             heap_free(stream->data);
5198         heap_free(stream);
5199     }
5200 }
5201
5202 static HRESULT WINAPI localfontfilestream_QueryInterface(IDWriteFontFileStream *iface, REFIID riid, void **obj)
5203 {
5204     struct dwrite_localfontfilestream *stream = impl_from_IDWriteFontFileStream(iface);
5205
5206     TRACE_(dwrite_file)("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
5207
5208     if (IsEqualIID(riid, &IID_IDWriteFontFileStream) ||
5209         IsEqualIID(riid, &IID_IUnknown))
5210     {
5211         *obj = iface;
5212         if (InterlockedIncrement(&stream->refcount) == 1)
5213         {
5214             InterlockedDecrement(&stream->refcount);
5215             *obj = NULL;
5216             return E_FAIL;
5217         }
5218         return S_OK;
5219     }
5220
5221     WARN("%s not implemented.\n", debugstr_guid(riid));
5222
5223     *obj = NULL;
5224     return E_NOINTERFACE;
5225 }
5226
5227 static ULONG WINAPI localfontfilestream_AddRef(IDWriteFontFileStream *iface)
5228 {
5229     struct dwrite_localfontfilestream *stream = impl_from_IDWriteFontFileStream(iface);
5230     ULONG refcount = InterlockedIncrement(&stream->refcount);
5231
5232     TRACE_(dwrite_file)("%p, refcount %d.\n", iface, refcount);
5233
5234     return refcount;
5235 }
5236
5237 static inline void release_cached_stream(struct local_cached_stream *stream)
5238 {
5239     list_remove(&stream->entry);
5240     heap_free(stream->key);
5241     heap_free(stream);
5242 }
5243
5244 static ULONG WINAPI localfontfilestream_Release(IDWriteFontFileStream *iface)
5245 {
5246     struct dwrite_localfontfilestream *stream = impl_from_IDWriteFontFileStream(iface);
5247     ULONG refcount = InterlockedDecrement(&stream->refcount);
5248
5249     TRACE_(dwrite_file)("%p, refcount %d.\n", iface, refcount);
5250
5251     if (!refcount)
5252     {
5253         UnmapViewOfFile(stream->file_ptr);
5254
5255         EnterCriticalSection(&local_fontfile_loader.cs);
5256         release_cached_stream(stream->entry);
5257         LeaveCriticalSection(&local_fontfile_loader.cs);
5258
5259         heap_free(stream);
5260     }
5261
5262     return refcount;
5263 }
5264
5265 static HRESULT WINAPI localfontfilestream_ReadFileFragment(IDWriteFontFileStream *iface, void const **fragment_start,
5266     UINT64 offset, UINT64 fragment_size, void **fragment_context)
5267 {
5268     struct dwrite_localfontfilestream *stream = impl_from_IDWriteFontFileStream(iface);
5269
5270     TRACE_(dwrite_file)("%p, %p, 0x%s, 0x%s, %p.\n", iface, fragment_start,
5271           wine_dbgstr_longlong(offset), wine_dbgstr_longlong(fragment_size), fragment_context);
5272
5273     *fragment_context = NULL;
5274
5275     if ((offset >= stream->size - 1) || (fragment_size > stream->size - offset))
5276     {
5277         *fragment_start = NULL;
5278         return E_FAIL;
5279     }
5280
5281     *fragment_start = (char *)stream->file_ptr + offset;
5282     return S_OK;
5283 }
5284
5285 static void WINAPI localfontfilestream_ReleaseFileFragment(IDWriteFontFileStream *iface, void *fragment_context)
5286 {
5287     TRACE_(dwrite_file)("%p, %p.\n", iface, fragment_context);
5288 }
5289
5290 static HRESULT WINAPI localfontfilestream_GetFileSize(IDWriteFontFileStream *iface, UINT64 *size)
5291 {
5292     struct dwrite_localfontfilestream *stream = impl_from_IDWriteFontFileStream(iface);
5293
5294     TRACE_(dwrite_file)("%p, %p.\n", iface, size);
5295
5296     *size = stream->size;
5297     return S_OK;
5298 }
5299
5300 static HRESULT WINAPI localfontfilestream_GetLastWriteTime(IDWriteFontFileStream *iface, UINT64 *last_writetime)
5301 {
5302     struct dwrite_localfontfilestream *stream = impl_from_IDWriteFontFileStream(iface);
5303     ULARGE_INTEGER li;
5304
5305     TRACE_(dwrite_file)("%p, %p.\n", iface, last_writetime);
5306
5307     li.u.LowPart = stream->entry->key->writetime.dwLowDateTime;
5308     li.u.HighPart = stream->entry->key->writetime.dwHighDateTime;
5309     *last_writetime = li.QuadPart;
5310
5311     return S_OK;
5312 }
5313
5314 static const IDWriteFontFileStreamVtbl localfontfilestreamvtbl =
5315 {
5316     localfontfilestream_QueryInterface,
5317     localfontfilestream_AddRef,
5318     localfontfilestream_Release,
5319     localfontfilestream_ReadFileFragment,
5320     localfontfilestream_ReleaseFileFragment,
5321     localfontfilestream_GetFileSize,
5322     localfontfilestream_GetLastWriteTime
5323 };
5324
5325 static HRESULT create_localfontfilestream(const void *file_ptr, UINT64 size, struct local_cached_stream *entry,
5326         IDWriteFontFileStream **ret)
5327 {
5328     struct dwrite_localfontfilestream *object;
5329
5330     *ret = NULL;
5331
5332     if (!(object = heap_alloc(sizeof(*object))))
5333         return E_OUTOFMEMORY;
5334
5335     object->IDWriteFontFileStream_iface.lpVtbl = &localfontfilestreamvtbl;
5336     object->refcount = 1;
5337
5338     object->file_ptr = file_ptr;
5339     object->size = size;
5340     object->entry = entry;
5341
5342     *ret = &object->IDWriteFontFileStream_iface;
5343
5344     return S_OK;
5345 }
5346
5347 static HRESULT WINAPI localfontfileloader_QueryInterface(IDWriteLocalFontFileLoader *iface, REFIID riid, void **obj)
5348 {
5349     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
5350
5351     if (IsEqualIID(riid, &IID_IDWriteLocalFontFileLoader) ||
5352         IsEqualIID(riid, &IID_IDWriteFontFileLoader) ||
5353         IsEqualIID(riid, &IID_IUnknown))
5354     {
5355         *obj = iface;
5356         IDWriteLocalFontFileLoader_AddRef(iface);
5357         return S_OK;
5358     }
5359
5360     WARN("%s not implemented.\n", debugstr_guid(riid));
5361
5362     *obj = NULL;
5363     return E_NOINTERFACE;
5364 }
5365
5366 static ULONG WINAPI localfontfileloader_AddRef(IDWriteLocalFontFileLoader *iface)
5367 {
5368     struct dwrite_localfontfileloader *loader = impl_from_IDWriteLocalFontFileLoader(iface);
5369     ULONG refcount = InterlockedIncrement(&loader->refcount);
5370
5371     TRACE("%p, refcount %d.\n", iface, refcount);
5372
5373     return refcount;
5374 }
5375
5376 static ULONG WINAPI localfontfileloader_Release(IDWriteLocalFontFileLoader *iface)
5377 {
5378     struct dwrite_localfontfileloader *loader = impl_from_IDWriteLocalFontFileLoader(iface);
5379     ULONG refcount = InterlockedDecrement(&loader->refcount);
5380
5381     TRACE("%p, refcount %d.\n", iface, refcount);
5382
5383     return refcount;
5384 }
5385
5386 static HRESULT create_local_cached_stream(const void *key, UINT32 key_size, struct local_cached_stream **ret)
5387 {
5388     const struct local_refkey *refkey = key;
5389     struct local_cached_stream *stream;
5390     IDWriteFontFileStream *filestream;
5391     HANDLE file, mapping;
5392     LARGE_INTEGER size;
5393     void *file_ptr;
5394     HRESULT hr = S_OK;
5395
5396     *ret = NULL;
5397
5398     file = CreateFileW(refkey->name, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE,
5399             NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
5400     if (file == INVALID_HANDLE_VALUE) {
5401         WARN_(dwrite_file)("Failed to open the file %s, error %d.\n", debugstr_w(refkey->name), GetLastError());
5402         return E_FAIL;
5403     }
5404
5405     GetFileSizeEx(file, &size);
5406     mapping = CreateFileMappingW(file, NULL, PAGE_READONLY, 0, 0, NULL);
5407     CloseHandle(file);
5408     if (!mapping)
5409         return E_FAIL;
5410
5411     file_ptr = MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
5412     CloseHandle(mapping);
5413     if (!file_ptr) {
5414         ERR("mapping failed, file size %s, error %d\n", wine_dbgstr_longlong(size.QuadPart), GetLastError());
5415         return E_FAIL;
5416     }
5417
5418     stream = heap_alloc(sizeof(*stream));
5419     if (!stream) {
5420         UnmapViewOfFile(file_ptr);
5421         return E_OUTOFMEMORY;
5422     }
5423
5424     stream->key = heap_alloc(key_size);
5425     if (!stream->key) {
5426         UnmapViewOfFile(file_ptr);
5427         heap_free(stream);
5428         return E_OUTOFMEMORY;
5429     }
5430
5431     stream->key_size = key_size;
5432     memcpy(stream->key, key, key_size);
5433
5434     hr = create_localfontfilestream(file_ptr, size.QuadPart, stream, &filestream);
5435     if (FAILED(hr)) {
5436         UnmapViewOfFile(file_ptr);
5437         heap_free(stream->key);
5438         heap_free(stream);
5439         return hr;
5440     }
5441
5442     stream->stream = filestream;
5443
5444     *ret = stream;
5445
5446     return S_OK;
5447 }
5448
5449 static HRESULT WINAPI localfontfileloader_CreateStreamFromKey(IDWriteLocalFontFileLoader *iface, const void *key,
5450         UINT32 key_size, IDWriteFontFileStream **ret)
5451 {
5452     struct dwrite_localfontfileloader *loader = impl_from_IDWriteLocalFontFileLoader(iface);
5453     struct local_cached_stream *stream;
5454     HRESULT hr = S_OK;
5455
5456     TRACE("%p, %p, %u, %p.\n", iface, key, key_size, ret);
5457
5458     EnterCriticalSection(&loader->cs);
5459
5460     *ret = NULL;
5461
5462     /* search cache first */
5463     LIST_FOR_EACH_ENTRY(stream, &loader->streams, struct local_cached_stream, entry)
5464     {
5465         if (key_size == stream->key_size && !memcmp(stream->key, key, key_size)) {
5466             IDWriteFontFileStream_QueryInterface(stream->stream, &IID_IDWriteFontFileStream, (void **)ret);
5467             break;
5468         }
5469     }
5470
5471     if (*ret == NULL && (hr = create_local_cached_stream(key, key_size, &stream)) == S_OK)
5472     {
5473         list_add_head(&loader->streams, &stream->entry);
5474         *ret = stream->stream;
5475     }
5476
5477     LeaveCriticalSection(&loader->cs);
5478
5479     return hr;
5480 }
5481
5482 static HRESULT WINAPI localfontfileloader_GetFilePathLengthFromKey(IDWriteLocalFontFileLoader *iface, void const *key,
5483         UINT32 key_size, UINT32 *length)
5484 {
5485     const struct local_refkey *refkey = key;
5486
5487     TRACE("%p, %p, %u, %p.\n", iface, key, key_size, length);
5488
5489     *length = wcslen(refkey->name);
5490     return S_OK;
5491 }
5492
5493 static HRESULT WINAPI localfontfileloader_GetFilePathFromKey(IDWriteLocalFontFileLoader *iface, void const *key,
5494         UINT32 key_size, WCHAR *path, UINT32 length)
5495 {
5496     const struct local_refkey *refkey = key;
5497
5498     TRACE("%p, %p, %u, %p, %u.\n", iface, key, key_size, path, length);
5499
5500     if (length < wcslen(refkey->name))
5501         return E_INVALIDARG;
5502
5503     wcscpy(path, refkey->name);
5504     return S_OK;
5505 }
5506
5507 static HRESULT WINAPI localfontfileloader_GetLastWriteTimeFromKey(IDWriteLocalFontFileLoader *iface, void const *key,
5508         UINT32 key_size, FILETIME *writetime)
5509 {
5510     const struct local_refkey *refkey = key;
5511
5512     TRACE("%p, %p, %u, %p.\n", iface, key, key_size, writetime);
5513
5514     *writetime = refkey->writetime;
5515     return S_OK;
5516 }
5517
5518 static const IDWriteLocalFontFileLoaderVtbl localfontfileloadervtbl =
5519 {
5520     localfontfileloader_QueryInterface,
5521     localfontfileloader_AddRef,
5522     localfontfileloader_Release,
5523     localfontfileloader_CreateStreamFromKey,
5524     localfontfileloader_GetFilePathLengthFromKey,
5525     localfontfileloader_GetFilePathFromKey,
5526     localfontfileloader_GetLastWriteTimeFromKey
5527 };
5528
5529 void init_local_fontfile_loader(void)
5530 {
5531     local_fontfile_loader.IDWriteLocalFontFileLoader_iface.lpVtbl = &localfontfileloadervtbl;
5532     local_fontfile_loader.refcount = 1;
5533     list_init(&local_fontfile_loader.streams);
5534     InitializeCriticalSection(&local_fontfile_loader.cs);
5535     local_fontfile_loader.cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": localfileloader.lock");
5536 }
5537
5538 IDWriteFontFileLoader *get_local_fontfile_loader(void)
5539 {
5540     return (IDWriteFontFileLoader *)&local_fontfile_loader.IDWriteLocalFontFileLoader_iface;
5541 }
5542
5543 HRESULT get_local_refkey(const WCHAR *path, const FILETIME *writetime, void **key, UINT32 *size)
5544 {
5545     struct local_refkey *refkey;
5546
5547     if (!path)
5548         return E_INVALIDARG;
5549
5550     *size = FIELD_OFFSET(struct local_refkey, name) + (wcslen(path)+1)*sizeof(WCHAR);
5551     *key = NULL;
5552
5553     refkey = heap_alloc(*size);
5554     if (!refkey)
5555         return E_OUTOFMEMORY;
5556
5557     if (writetime)
5558         refkey->writetime = *writetime;
5559     else {
5560         WIN32_FILE_ATTRIBUTE_DATA info;
5561
5562         if (GetFileAttributesExW(path, GetFileExInfoStandard, &info))
5563             refkey->writetime = info.ftLastWriteTime;
5564         else
5565             memset(&refkey->writetime, 0, sizeof(refkey->writetime));
5566     }
5567     wcscpy(refkey->name, path);
5568
5569     *key = refkey;
5570
5571     return S_OK;
5572 }
5573
5574 static HRESULT WINAPI glyphrunanalysis_QueryInterface(IDWriteGlyphRunAnalysis *iface, REFIID riid, void **ppv)
5575 {
5576     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), ppv);
5577
5578     if (IsEqualIID(riid, &IID_IDWriteGlyphRunAnalysis) ||
5579         IsEqualIID(riid, &IID_IUnknown))
5580     {
5581         *ppv = iface;
5582         IDWriteGlyphRunAnalysis_AddRef(iface);
5583         return S_OK;
5584     }
5585
5586     WARN("%s not implemented.\n", debugstr_guid(riid));
5587
5588     *ppv = NULL;
5589     return E_NOINTERFACE;
5590 }
5591
5592 static ULONG WINAPI glyphrunanalysis_AddRef(IDWriteGlyphRunAnalysis *iface)
5593 {
5594     struct dwrite_glyphrunanalysis *analysis = impl_from_IDWriteGlyphRunAnalysis(iface);
5595     ULONG refcount = InterlockedIncrement(&analysis->refcount);
5596
5597     TRACE("%p, refcount %d.\n", iface, refcount);
5598
5599     return refcount;
5600 }
5601
5602 static ULONG WINAPI glyphrunanalysis_Release(IDWriteGlyphRunAnalysis *iface)
5603 {
5604     struct dwrite_glyphrunanalysis *analysis = impl_from_IDWriteGlyphRunAnalysis(iface);
5605     ULONG refcount = InterlockedDecrement(&analysis->refcount);
5606
5607     TRACE("%p, refcount %d.\n", iface, refcount);
5608
5609     if (!refcount)
5610     {
5611         if (analysis->run.fontFace)
5612             IDWriteFontFace_Release(analysis->run.fontFace);
5613         heap_free(analysis->glyphs);
5614         heap_free(analysis->origins);
5615         heap_free(analysis->bitmap);
5616         heap_free(analysis);
5617     }
5618
5619     return refcount;
5620 }
5621
5622 static BOOL is_natural_rendering_mode(DWRITE_RENDERING_MODE1 mode)
5623 {
5624     switch (mode)
5625     {
5626     case DWRITE_RENDERING_MODE1_NATURAL:
5627     case DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC:
5628     case DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC_DOWNSAMPLED:
5629         return TRUE;
5630     default:
5631         return FALSE;
5632     }
5633 }
5634
5635 static UINT32 get_glyph_bitmap_pitch(DWRITE_RENDERING_MODE1 rendering_mode, INT width)
5636 {
5637     return rendering_mode == DWRITE_RENDERING_MODE1_ALIASED ? ((width + 31) >> 5) << 2 : (width + 3) / 4 * 4;
5638 }
5639
5640 static void glyphrunanalysis_get_texturebounds(struct dwrite_glyphrunanalysis *analysis, RECT *bounds)
5641 {
5642     struct dwrite_glyphbitmap glyph_bitmap;
5643     IDWriteFontFace4 *fontface;
5644     HRESULT hr;
5645     UINT32 i;
5646
5647     if (analysis->flags & RUNANALYSIS_BOUNDS_READY) {
5648         *bounds = analysis->bounds;
5649         return;
5650     }
5651
5652     if (analysis->run.isSideways)
5653         FIXME("sideways runs are not supported.\n");
5654
5655     hr = IDWriteFontFace_QueryInterface(analysis->run.fontFace, &IID_IDWriteFontFace4, (void **)&fontface);
5656     if (FAILED(hr))
5657         WARN("failed to get IDWriteFontFace4, 0x%08x\n", hr);
5658
5659     memset(&glyph_bitmap, 0, sizeof(glyph_bitmap));
5660     glyph_bitmap.key = fontface;
5661     glyph_bitmap.simulations = IDWriteFontFace4_GetSimulations(fontface);
5662     glyph_bitmap.emsize = analysis->run.fontEmSize;
5663     glyph_bitmap.nohint = is_natural_rendering_mode(analysis->rendering_mode);
5664     if (analysis->flags & RUNANALYSIS_USE_TRANSFORM)
5665         glyph_bitmap.m = &analysis->m;
5666
5667     for (i = 0; i < analysis->run.glyphCount; i++) {
5668         RECT *bbox = &glyph_bitmap.bbox;
5669         UINT32 bitmap_size;
5670
5671         glyph_bitmap.glyph = analysis->run.glyphIndices[i];
5672         font_funcs->get_glyph_bbox(&glyph_bitmap);
5673
5674         bitmap_size = get_glyph_bitmap_pitch(analysis->rendering_mode, bbox->right - bbox->left) *
5675             (bbox->bottom - bbox->top);
5676         if (bitmap_size > analysis->max_glyph_bitmap_size)
5677             analysis->max_glyph_bitmap_size = bitmap_size;
5678
5679         OffsetRect(bbox, analysis->origins[i].x, analysis->origins[i].y);
5680         UnionRect(&analysis->bounds, &analysis->bounds, bbox);
5681     }
5682
5683     IDWriteFontFace4_Release(fontface);
5684
5685     analysis->flags |= RUNANALYSIS_BOUNDS_READY;
5686     *bounds = analysis->bounds;
5687 }
5688
5689 static HRESULT WINAPI glyphrunanalysis_GetAlphaTextureBounds(IDWriteGlyphRunAnalysis *iface,
5690         DWRITE_TEXTURE_TYPE type, RECT *bounds)
5691 {
5692     struct dwrite_glyphrunanalysis *analysis = impl_from_IDWriteGlyphRunAnalysis(iface);
5693
5694     TRACE("%p, %d, %p.\n", iface, type, bounds);
5695
5696     if ((UINT32)type > DWRITE_TEXTURE_CLEARTYPE_3x1) {
5697         SetRectEmpty(bounds);
5698         return E_INVALIDARG;
5699     }
5700
5701     if (type != analysis->texture_type)
5702     {
5703         SetRectEmpty(bounds);
5704         return S_OK;
5705     }
5706
5707     glyphrunanalysis_get_texturebounds(analysis, bounds);
5708     return S_OK;
5709 }
5710
5711 static inline BYTE *get_pixel_ptr(BYTE *ptr, DWRITE_TEXTURE_TYPE type, const RECT *runbounds, const RECT *bounds)
5712 {
5713     if (type == DWRITE_TEXTURE_CLEARTYPE_3x1)
5714         return ptr + (runbounds->top - bounds->top) * (bounds->right - bounds->left) * 3 +
5715             (runbounds->left - bounds->left) * 3;
5716     else
5717         return ptr + (runbounds->top - bounds->top) * (bounds->right - bounds->left) +
5718             runbounds->left - bounds->left;
5719 }
5720
5721 static HRESULT glyphrunanalysis_render(struct dwrite_glyphrunanalysis *analysis)
5722 {
5723     static const BYTE masks[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
5724     struct dwrite_glyphbitmap glyph_bitmap;
5725     IDWriteFontFace4 *fontface;
5726     D2D_POINT_2F origin;
5727     UINT32 i, size;
5728     HRESULT hr;
5729     RECT *bbox;
5730
5731     hr = IDWriteFontFace_QueryInterface(analysis->run.fontFace, &IID_IDWriteFontFace4, (void **)&fontface);
5732     if (FAILED(hr)) {
5733         WARN("failed to get IDWriteFontFace4, 0x%08x\n", hr);
5734         return hr;
5735     }
5736
5737     size = (analysis->bounds.right - analysis->bounds.left)*(analysis->bounds.bottom - analysis->bounds.top);
5738     if (analysis->texture_type == DWRITE_TEXTURE_CLEARTYPE_3x1)
5739         size *= 3;
5740     if (!(analysis->bitmap = heap_alloc_zero(size))) {
5741         WARN("Failed to allocate run bitmap, %s, type %s.\n", wine_dbgstr_rect(&analysis->bounds),
5742                 analysis->texture_type == DWRITE_TEXTURE_CLEARTYPE_3x1 ? "3x1" : "1x1");
5743         IDWriteFontFace4_Release(fontface);
5744         return E_OUTOFMEMORY;
5745     }
5746
5747     origin.x = origin.y = 0.0f;
5748
5749     memset(&glyph_bitmap, 0, sizeof(glyph_bitmap));
5750     glyph_bitmap.key = fontface;
5751     glyph_bitmap.simulations = IDWriteFontFace4_GetSimulations(fontface);
5752     glyph_bitmap.emsize = analysis->run.fontEmSize;
5753     glyph_bitmap.nohint = is_natural_rendering_mode(analysis->rendering_mode);
5754     glyph_bitmap.aliased = analysis->rendering_mode == DWRITE_RENDERING_MODE1_ALIASED;
5755     if (analysis->flags & RUNANALYSIS_USE_TRANSFORM)
5756         glyph_bitmap.m = &analysis->m;
5757     if (!(glyph_bitmap.buf = heap_alloc(analysis->max_glyph_bitmap_size))) {
5758         IDWriteFontFace4_Release(fontface);
5759         return E_OUTOFMEMORY;
5760     }
5761
5762     bbox = &glyph_bitmap.bbox;
5763
5764     for (i = 0; i < analysis->run.glyphCount; i++) {
5765         BYTE *src = glyph_bitmap.buf, *dst;
5766         int x, y, width, height;
5767         BOOL is_1bpp;
5768
5769         glyph_bitmap.glyph = analysis->run.glyphIndices[i];
5770         font_funcs->get_glyph_bbox(&glyph_bitmap);
5771
5772         if (IsRectEmpty(bbox))
5773             continue;
5774
5775         width = bbox->right - bbox->left;
5776         height = bbox->bottom - bbox->top;
5777
5778         glyph_bitmap.pitch = get_glyph_bitmap_pitch(analysis->rendering_mode, width);
5779         memset(src, 0, height * glyph_bitmap.pitch);
5780         is_1bpp = font_funcs->get_glyph_bitmap(&glyph_bitmap);
5781
5782         OffsetRect(bbox, analysis->origins[i].x, analysis->origins[i].y);
5783
5784         /* blit to analysis bitmap */
5785         dst = get_pixel_ptr(analysis->bitmap, analysis->texture_type, bbox, &analysis->bounds);
5786
5787         if (is_1bpp) {
5788             /* convert 1bpp to 8bpp/24bpp */
5789             if (analysis->texture_type == DWRITE_TEXTURE_CLEARTYPE_3x1) {
5790                 for (y = 0; y < height; y++) {
5791                     for (x = 0; x < width; x++)
5792                         if (src[x / 8] & masks[x % 8])
5793                             dst[3*x] = dst[3*x+1] = dst[3*x+2] = DWRITE_ALPHA_MAX;
5794                     src += glyph_bitmap.pitch;
5795                     dst += (analysis->bounds.right - analysis->bounds.left) * 3;
5796                 }
5797             }
5798             else {
5799                 for (y = 0; y < height; y++) {
5800                     for (x = 0; x < width; x++)
5801                         if (src[x / 8] & masks[x % 8])
5802                             dst[x] = DWRITE_ALPHA_MAX;
5803                     src += glyph_bitmap.pitch;
5804                     dst += analysis->bounds.right - analysis->bounds.left;
5805                 }
5806             }
5807         }
5808         else {
5809             if (analysis->texture_type == DWRITE_TEXTURE_CLEARTYPE_3x1) {
5810                 for (y = 0; y < height; y++) {
5811                     for (x = 0; x < width; x++)
5812                         dst[3*x] = dst[3*x+1] = dst[3*x+2] = src[x] | dst[3*x];
5813                     src += glyph_bitmap.pitch;
5814                     dst += (analysis->bounds.right - analysis->bounds.left) * 3;
5815                 }
5816             }
5817             else {
5818                 for (y = 0; y < height; y++) {
5819                     for (x = 0; x < width; x++)
5820                         dst[x] |= src[x];
5821                     src += glyph_bitmap.pitch;
5822                     dst += analysis->bounds.right - analysis->bounds.left;
5823                 }
5824             }
5825         }
5826     }
5827     heap_free(glyph_bitmap.buf);
5828
5829     IDWriteFontFace4_Release(fontface);
5830
5831     analysis->flags |= RUNANALYSIS_BITMAP_READY;
5832
5833     /* we don't need this anymore */
5834     heap_free(analysis->glyphs);
5835     heap_free(analysis->origins);
5836     IDWriteFontFace_Release(analysis->run.fontFace);
5837
5838     analysis->glyphs = NULL;
5839     analysis->origins = NULL;
5840     analysis->run.glyphIndices = NULL;
5841     analysis->run.fontFace = NULL;
5842
5843     return S_OK;
5844 }
5845
5846 static HRESULT WINAPI glyphrunanalysis_CreateAlphaTexture(IDWriteGlyphRunAnalysis *iface, DWRITE_TEXTURE_TYPE type,
5847     RECT const *bounds, BYTE *bitmap, UINT32 size)
5848 {
5849     struct dwrite_glyphrunanalysis *analysis = impl_from_IDWriteGlyphRunAnalysis(iface);
5850     UINT32 required;
5851     RECT runbounds;
5852
5853     TRACE("%p, %d, %s, %p, %u.\n", iface, type, wine_dbgstr_rect(bounds), bitmap, size);
5854
5855     if (!bounds || !bitmap || (UINT32)type > DWRITE_TEXTURE_CLEARTYPE_3x1)
5856         return E_INVALIDARG;
5857
5858     /* make sure buffer is large enough for requested texture type */
5859     required = (bounds->right - bounds->left) * (bounds->bottom - bounds->top);
5860     if (analysis->texture_type == DWRITE_TEXTURE_CLEARTYPE_3x1)
5861         required *= 3;
5862
5863     if (size < required)
5864         return E_NOT_SUFFICIENT_BUFFER;
5865
5866     /* validate requested texture type */
5867     if (analysis->texture_type != type)
5868         return DWRITE_E_UNSUPPORTEDOPERATION;
5869
5870     memset(bitmap, 0, size);
5871     glyphrunanalysis_get_texturebounds(analysis, &runbounds);
5872     if (IntersectRect(&runbounds, &runbounds, bounds))
5873     {
5874         int pixel_size = type == DWRITE_TEXTURE_CLEARTYPE_3x1 ? 3 : 1;
5875         int src_width = (analysis->bounds.right - analysis->bounds.left) * pixel_size;
5876         int dst_width = (bounds->right - bounds->left) * pixel_size;
5877         int draw_width = (runbounds.right - runbounds.left) * pixel_size;
5878         BYTE *src, *dst;
5879         int y;
5880
5881         if (!(analysis->flags & RUNANALYSIS_BITMAP_READY))
5882         {
5883             HRESULT hr;
5884
5885             if (FAILED(hr = glyphrunanalysis_render(analysis)))
5886                 return hr;
5887         }
5888
5889         src = get_pixel_ptr(analysis->bitmap, type, &runbounds, &analysis->bounds);
5890         dst = get_pixel_ptr(bitmap, type, &runbounds, bounds);
5891
5892         for (y = 0; y < runbounds.bottom - runbounds.top; y++) {
5893             memcpy(dst, src, draw_width);
5894             src += src_width;
5895             dst += dst_width;
5896         }
5897     }
5898
5899     return S_OK;
5900 }
5901
5902 static HRESULT WINAPI glyphrunanalysis_GetAlphaBlendParams(IDWriteGlyphRunAnalysis *iface, IDWriteRenderingParams *params,
5903     FLOAT *gamma, FLOAT *contrast, FLOAT *cleartypelevel)
5904 {
5905     struct dwrite_glyphrunanalysis *analysis = impl_from_IDWriteGlyphRunAnalysis(iface);
5906
5907     TRACE("%p, %p, %p, %p, %p.\n", iface, params, gamma, contrast, cleartypelevel);
5908
5909     if (!params)
5910         return E_INVALIDARG;
5911
5912     switch (analysis->rendering_mode)
5913     {
5914     case DWRITE_RENDERING_MODE1_GDI_CLASSIC:
5915     case DWRITE_RENDERING_MODE1_GDI_NATURAL:
5916     {
5917         UINT value = 0;
5918         SystemParametersInfoW(SPI_GETFONTSMOOTHINGCONTRAST, 0, &value, 0);
5919         *gamma = (FLOAT)value / 1000.0f;
5920         *contrast = 0.0f;
5921         *cleartypelevel = 1.0f;
5922         break;
5923     }
5924     case DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC_DOWNSAMPLED:
5925         WARN("NATURAL_SYMMETRIC_DOWNSAMPLED mode is ignored.\n");
5926         /* fallthrough */
5927     case DWRITE_RENDERING_MODE1_ALIASED:
5928     case DWRITE_RENDERING_MODE1_NATURAL:
5929     case DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC:
5930         *gamma = IDWriteRenderingParams_GetGamma(params);
5931         *contrast = IDWriteRenderingParams_GetEnhancedContrast(params);
5932         *cleartypelevel = IDWriteRenderingParams_GetClearTypeLevel(params);
5933         break;
5934     default:
5935         ;
5936     }
5937
5938     return S_OK;
5939 }
5940
5941 static const IDWriteGlyphRunAnalysisVtbl glyphrunanalysisvtbl =
5942 {
5943     glyphrunanalysis_QueryInterface,
5944     glyphrunanalysis_AddRef,
5945     glyphrunanalysis_Release,
5946     glyphrunanalysis_GetAlphaTextureBounds,
5947     glyphrunanalysis_CreateAlphaTexture,
5948     glyphrunanalysis_GetAlphaBlendParams
5949 };
5950
5951 static inline void transform_point(D2D_POINT_2F *point, const DWRITE_MATRIX *m)
5952 {
5953     D2D_POINT_2F ret;
5954     ret.x = point->x * m->m11 + point->y * m->m21 + m->dx;
5955     ret.y = point->x * m->m12 + point->y * m->m22 + m->dy;
5956     *point = ret;
5957 }
5958
5959 float fontface_get_scaled_design_advance(struct dwrite_fontface *fontface, DWRITE_MEASURING_MODE measuring_mode,
5960         float emsize, float ppdip, const DWRITE_MATRIX *transform, UINT16 glyph, BOOL is_sideways)
5961 {
5962     unsigned int upem = fontface->metrics.designUnitsPerEm;
5963     int advance;
5964
5965     if (is_sideways)
5966         FIXME("Sideways mode is not supported.\n");
5967
5968     advance = fontface_get_design_advance(fontface, measuring_mode, emsize, ppdip, transform, glyph, is_sideways);
5969
5970     switch (measuring_mode)
5971     {
5972         case DWRITE_MEASURING_MODE_NATURAL:
5973             return (float)advance * emsize / (float)upem;
5974         case DWRITE_MEASURING_MODE_GDI_NATURAL:
5975         case DWRITE_MEASURING_MODE_GDI_CLASSIC:
5976             return ppdip > 0.0f ? floorf(advance * emsize * ppdip / upem + 0.5f) / ppdip : 0.0f;
5977         default:
5978             WARN("Unknown measuring mode %u.\n", measuring_mode);
5979             return 0.0f;
5980     }
5981 }
5982
5983 HRESULT create_glyphrunanalysis(const struct glyphrunanalysis_desc *desc, IDWriteGlyphRunAnalysis **ret)
5984 {
5985     struct dwrite_glyphrunanalysis *analysis;
5986     unsigned int i;
5987
5988     *ret = NULL;
5989
5990     /* Check rendering, antialiasing, measuring, and grid fitting modes. */
5991     if ((UINT32)desc->rendering_mode >= DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC_DOWNSAMPLED ||
5992             desc->rendering_mode == DWRITE_RENDERING_MODE1_OUTLINE ||
5993             desc->rendering_mode == DWRITE_RENDERING_MODE1_DEFAULT)
5994         return E_INVALIDARG;
5995
5996     if ((UINT32)desc->aa_mode > DWRITE_TEXT_ANTIALIAS_MODE_GRAYSCALE)
5997         return E_INVALIDARG;
5998
5999     if ((UINT32)desc->gridfit_mode > DWRITE_GRID_FIT_MODE_ENABLED)
6000         return E_INVALIDARG;
6001
6002     if ((UINT32)desc->measuring_mode > DWRITE_MEASURING_MODE_GDI_NATURAL)
6003         return E_INVALIDARG;
6004
6005     analysis = heap_alloc_zero(sizeof(*analysis));
6006     if (!analysis)
6007         return E_OUTOFMEMORY;
6008
6009     analysis->IDWriteGlyphRunAnalysis_iface.lpVtbl = &glyphrunanalysisvtbl;
6010     analysis->refcount = 1;
6011     analysis->rendering_mode = desc->rendering_mode;
6012
6013     if (desc->rendering_mode == DWRITE_RENDERING_MODE1_ALIASED
6014             || desc->aa_mode == DWRITE_TEXT_ANTIALIAS_MODE_GRAYSCALE)
6015         analysis->texture_type = DWRITE_TEXTURE_ALIASED_1x1;
6016     else
6017         analysis->texture_type = DWRITE_TEXTURE_CLEARTYPE_3x1;
6018
6019     analysis->run = *desc->run;
6020     IDWriteFontFace_AddRef(analysis->run.fontFace);
6021     analysis->glyphs = heap_calloc(desc->run->glyphCount, sizeof(*analysis->glyphs));
6022     analysis->origins = heap_calloc(desc->run->glyphCount, sizeof(*analysis->origins));
6023
6024     if (!analysis->glyphs || !analysis->origins) {
6025         heap_free(analysis->glyphs);
6026         heap_free(analysis->origins);
6027
6028         analysis->glyphs = NULL;
6029         analysis->origins = NULL;
6030
6031         IDWriteGlyphRunAnalysis_Release(&analysis->IDWriteGlyphRunAnalysis_iface);
6032         return E_OUTOFMEMORY;
6033     }
6034
6035     /* check if transform is usable */
6036     if (desc->transform && memcmp(desc->transform, &identity, sizeof(*desc->transform))) {
6037         analysis->m = *desc->transform;
6038         analysis->flags |= RUNANALYSIS_USE_TRANSFORM;
6039     }
6040
6041     analysis->run.glyphIndices = analysis->glyphs;
6042     memcpy(analysis->glyphs, desc->run->glyphIndices, desc->run->glyphCount*sizeof(*desc->run->glyphIndices));
6043
6044     compute_glyph_origins(desc->run, desc->measuring_mode, desc->origin, desc->transform, analysis->origins);
6045     if (analysis->flags & RUNANALYSIS_USE_TRANSFORM)
6046     {
6047         for (i = 0; i < desc->run->glyphCount; ++i)
6048             transform_point(&analysis->origins[i], &analysis->m);
6049     }
6050
6051     *ret = &analysis->IDWriteGlyphRunAnalysis_iface;
6052     return S_OK;
6053 }
6054
6055 /* IDWriteColorGlyphRunEnumerator1 */
6056 static HRESULT WINAPI colorglyphenum_QueryInterface(IDWriteColorGlyphRunEnumerator1 *iface, REFIID riid, void **ppv)
6057 {
6058     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), ppv);
6059
6060     if (IsEqualIID(riid, &IID_IDWriteColorGlyphRunEnumerator1) ||
6061         IsEqualIID(riid, &IID_IDWriteColorGlyphRunEnumerator) ||
6062         IsEqualIID(riid, &IID_IUnknown))
6063     {
6064         *ppv = iface;
6065         IDWriteColorGlyphRunEnumerator1_AddRef(iface);
6066         return S_OK;
6067     }
6068
6069     WARN("%s not implemented.\n", debugstr_guid(riid));
6070
6071     *ppv = NULL;
6072     return E_NOINTERFACE;
6073 }
6074
6075 static ULONG WINAPI colorglyphenum_AddRef(IDWriteColorGlyphRunEnumerator1 *iface)
6076 {
6077     struct dwrite_colorglyphenum *glyphenum = impl_from_IDWriteColorGlyphRunEnumerator1(iface);
6078     ULONG refcount = InterlockedIncrement(&glyphenum->refcount);
6079
6080     TRACE("%p, refcount %u.\n", iface, refcount);
6081
6082     return refcount;
6083 }
6084
6085 static ULONG WINAPI colorglyphenum_Release(IDWriteColorGlyphRunEnumerator1 *iface)
6086 {
6087     struct dwrite_colorglyphenum *glyphenum = impl_from_IDWriteColorGlyphRunEnumerator1(iface);
6088     ULONG refcount = InterlockedDecrement(&glyphenum->refcount);
6089
6090     TRACE("%p, refcount %u.\n", iface, refcount);
6091
6092     if (!refcount)
6093     {
6094         heap_free(glyphenum->advances);
6095         heap_free(glyphenum->color_advances);
6096         heap_free(glyphenum->offsets);
6097         heap_free(glyphenum->color_offsets);
6098         heap_free(glyphenum->glyphindices);
6099         heap_free(glyphenum->glyphs);
6100         if (glyphenum->colr.context)
6101             IDWriteFontFace5_ReleaseFontTable(glyphenum->fontface, glyphenum->colr.context);
6102         IDWriteFontFace5_Release(glyphenum->fontface);
6103         heap_free(glyphenum);
6104     }
6105
6106     return refcount;
6107 }
6108
6109 static FLOAT get_glyph_origin(const struct dwrite_colorglyphenum *glyphenum, UINT32 g)
6110 {
6111     BOOL is_rtl = glyphenum->run.bidiLevel & 1;
6112     FLOAT origin = 0.0f;
6113
6114     if (g == 0)
6115         return 0.0f;
6116
6117     while (g--)
6118         origin += is_rtl ? -glyphenum->advances[g] : glyphenum->advances[g];
6119     return origin;
6120 }
6121
6122 static BOOL colorglyphenum_build_color_run(struct dwrite_colorglyphenum *glyphenum)
6123 {
6124     DWRITE_COLOR_GLYPH_RUN1 *colorrun = &glyphenum->colorrun;
6125     FLOAT advance_adj = 0.0f;
6126     BOOL got_palette_index;
6127     UINT32 g;
6128
6129     /* start with regular glyphs */
6130     if (glyphenum->current_layer == 0 && glyphenum->has_regular_glyphs) {
6131         UINT32 first_glyph = 0;
6132
6133         for (g = 0; g < glyphenum->run.glyphCount; g++) {
6134             if (glyphenum->glyphs[g].num_layers == 0) {
6135                 glyphenum->glyphindices[g] = glyphenum->glyphs[g].glyph;
6136                 first_glyph = min(first_glyph, g);
6137             }
6138             else
6139                 glyphenum->glyphindices[g] = 1;
6140             glyphenum->color_advances[g] = glyphenum->advances[g];
6141             if (glyphenum->color_offsets)
6142                 glyphenum->color_offsets[g] = glyphenum->offsets[g];
6143         }
6144
6145         colorrun->baselineOriginX = glyphenum->origin_x + get_glyph_origin(glyphenum, first_glyph);
6146         colorrun->baselineOriginY = glyphenum->origin_y;
6147         colorrun->glyphRun.glyphCount = glyphenum->run.glyphCount;
6148         colorrun->paletteIndex = 0xffff;
6149         memset(&colorrun->runColor, 0, sizeof(colorrun->runColor));
6150         glyphenum->has_regular_glyphs = FALSE;
6151         return TRUE;
6152     }
6153     else {
6154         colorrun->glyphRun.glyphCount = 0;
6155         got_palette_index = FALSE;
6156     }
6157
6158     advance_adj = 0.0f;
6159     for (g = 0; g < glyphenum->run.glyphCount; g++) {
6160
6161         glyphenum->glyphindices[g] = 1;
6162
6163         /* all glyph layers were returned */
6164         if (glyphenum->glyphs[g].layer == glyphenum->glyphs[g].num_layers) {
6165             advance_adj += glyphenum->advances[g];
6166             continue;
6167         }
6168
6169         if (glyphenum->current_layer == glyphenum->glyphs[g].layer && (!got_palette_index || colorrun->paletteIndex == glyphenum->glyphs[g].palette_index)) {
6170             UINT32 index = colorrun->glyphRun.glyphCount;
6171             if (!got_palette_index) {
6172                 colorrun->paletteIndex = glyphenum->glyphs[g].palette_index;
6173                 /* use foreground color or request one from the font */
6174                 memset(&colorrun->runColor, 0, sizeof(colorrun->runColor));
6175                 if (colorrun->paletteIndex != 0xffff)
6176                 {
6177                     HRESULT hr = IDWriteFontFace5_GetPaletteEntries(glyphenum->fontface, glyphenum->palette,
6178                             colorrun->paletteIndex, 1, &colorrun->runColor);
6179                     if (FAILED(hr))
6180                         WARN("failed to get palette entry, fontface %p, palette %u, index %u, 0x%08x\n", glyphenum->fontface,
6181                             glyphenum->palette, colorrun->paletteIndex, hr);
6182                 }
6183                 /* found a glyph position new color run starts from, origin is "original origin + distance to this glyph" */
6184                 colorrun->baselineOriginX = glyphenum->origin_x + get_glyph_origin(glyphenum, g);
6185                 colorrun->baselineOriginY = glyphenum->origin_y;
6186                 glyphenum->color_advances[index] = glyphenum->advances[g];
6187                 got_palette_index = TRUE;
6188             }
6189
6190             glyphenum->glyphindices[index] = glyphenum->glyphs[g].glyph;
6191             /* offsets are relative to glyph origin, nothing to fix up */
6192             if (glyphenum->color_offsets)
6193                 glyphenum->color_offsets[index] = glyphenum->offsets[g];
6194             opentype_colr_next_glyph(&glyphenum->colr, glyphenum->glyphs + g);
6195             if (index)
6196                 glyphenum->color_advances[index-1] += advance_adj;
6197             colorrun->glyphRun.glyphCount++;
6198             advance_adj = 0.0f;
6199         }
6200         else
6201             advance_adj += glyphenum->advances[g];
6202     }
6203
6204     /* reset last advance */
6205     if (colorrun->glyphRun.glyphCount)
6206         glyphenum->color_advances[colorrun->glyphRun.glyphCount-1] = 0.0f;
6207
6208     return colorrun->glyphRun.glyphCount > 0;
6209 }
6210
6211 static HRESULT WINAPI colorglyphenum_MoveNext(IDWriteColorGlyphRunEnumerator1 *iface, BOOL *has_run)
6212 {
6213     struct dwrite_colorglyphenum *glyphenum = impl_from_IDWriteColorGlyphRunEnumerator1(iface);
6214
6215     TRACE("%p, %p.\n", iface, has_run);
6216
6217     *has_run = FALSE;
6218
6219     glyphenum->colorrun.glyphRun.glyphCount = 0;
6220     while (glyphenum->current_layer < glyphenum->max_layer_num)
6221     {
6222         if (colorglyphenum_build_color_run(glyphenum))
6223             break;
6224         else
6225             glyphenum->current_layer++;
6226     }
6227
6228     *has_run = glyphenum->colorrun.glyphRun.glyphCount > 0;
6229
6230     return S_OK;
6231 }
6232
6233 static HRESULT colorglyphenum_get_current_run(const struct dwrite_colorglyphenum *glyphenum,
6234         DWRITE_COLOR_GLYPH_RUN1 const **run)
6235 {
6236     if (glyphenum->colorrun.glyphRun.glyphCount == 0)
6237     {
6238         *run = NULL;
6239         return E_NOT_VALID_STATE;
6240     }
6241
6242     *run = &glyphenum->colorrun;
6243     return S_OK;
6244 }
6245
6246 static HRESULT WINAPI colorglyphenum_GetCurrentRun(IDWriteColorGlyphRunEnumerator1 *iface,
6247         DWRITE_COLOR_GLYPH_RUN const **run)
6248 {
6249     struct dwrite_colorglyphenum *glyphenum = impl_from_IDWriteColorGlyphRunEnumerator1(iface);
6250
6251     TRACE("%p, %p.\n", iface, run);
6252
6253     return colorglyphenum_get_current_run(glyphenum, (DWRITE_COLOR_GLYPH_RUN1 const **)run);
6254 }
6255
6256 static HRESULT WINAPI colorglyphenum1_GetCurrentRun(IDWriteColorGlyphRunEnumerator1 *iface,
6257         DWRITE_COLOR_GLYPH_RUN1 const **run)
6258 {
6259     struct dwrite_colorglyphenum *glyphenum = impl_from_IDWriteColorGlyphRunEnumerator1(iface);
6260
6261     TRACE("%p, %p.\n", iface, run);
6262
6263     return colorglyphenum_get_current_run(glyphenum, run);
6264 }
6265
6266 static const IDWriteColorGlyphRunEnumerator1Vtbl colorglyphenumvtbl =
6267 {
6268     colorglyphenum_QueryInterface,
6269     colorglyphenum_AddRef,
6270     colorglyphenum_Release,
6271     colorglyphenum_MoveNext,
6272     colorglyphenum_GetCurrentRun,
6273     colorglyphenum1_GetCurrentRun,
6274 };
6275
6276 HRESULT create_colorglyphenum(float originX, float originY, const DWRITE_GLYPH_RUN *run,
6277         const DWRITE_GLYPH_RUN_DESCRIPTION *rundescr, DWRITE_MEASURING_MODE measuring_mode,
6278         const DWRITE_MATRIX *transform, unsigned int palette, IDWriteColorGlyphRunEnumerator **ret)
6279 {
6280     struct dwrite_colorglyphenum *colorglyphenum;
6281     BOOL colorfont, has_colored_glyph;
6282     struct dwrite_fontface *fontface;
6283     unsigned int i;
6284
6285     *ret = NULL;
6286
6287     fontface = unsafe_impl_from_IDWriteFontFace(run->fontFace);
6288
6289     colorfont = IDWriteFontFace5_IsColorFont(&fontface->IDWriteFontFace5_iface) &&
6290             IDWriteFontFace5_GetColorPaletteCount(&fontface->IDWriteFontFace5_iface) > palette;
6291     if (!colorfont)
6292         return DWRITE_E_NOCOLOR;
6293
6294     colorglyphenum = heap_alloc_zero(sizeof(*colorglyphenum));
6295     if (!colorglyphenum)
6296         return E_OUTOFMEMORY;
6297
6298     colorglyphenum->IDWriteColorGlyphRunEnumerator1_iface.lpVtbl = &colorglyphenumvtbl;
6299     colorglyphenum->refcount = 1;
6300     colorglyphenum->origin_x = originX;
6301     colorglyphenum->origin_y = originY;
6302     colorglyphenum->fontface = &fontface->IDWriteFontFace5_iface;
6303     IDWriteFontFace5_AddRef(colorglyphenum->fontface);
6304     colorglyphenum->glyphs = NULL;
6305     colorglyphenum->run = *run;
6306     colorglyphenum->run.glyphIndices = NULL;
6307     colorglyphenum->run.glyphAdvances = NULL;
6308     colorglyphenum->run.glyphOffsets = NULL;
6309     colorglyphenum->palette = palette;
6310     memset(&colorglyphenum->colr, 0, sizeof(colorglyphenum->colr));
6311     colorglyphenum->colr.exists = TRUE;
6312     get_fontface_table(&fontface->IDWriteFontFace5_iface, MS_COLR_TAG, &colorglyphenum->colr);
6313     colorglyphenum->current_layer = 0;
6314     colorglyphenum->max_layer_num = 0;
6315
6316     colorglyphenum->glyphs = heap_alloc_zero(run->glyphCount * sizeof(*colorglyphenum->glyphs));
6317
6318     has_colored_glyph = FALSE;
6319     colorglyphenum->has_regular_glyphs = FALSE;
6320     for (i = 0; i < run->glyphCount; i++) {
6321         if (opentype_get_colr_glyph(&colorglyphenum->colr, run->glyphIndices[i], colorglyphenum->glyphs + i) == S_OK) {
6322             colorglyphenum->max_layer_num = max(colorglyphenum->max_layer_num, colorglyphenum->glyphs[i].num_layers);
6323             has_colored_glyph = TRUE;
6324         }
6325         if (colorglyphenum->glyphs[i].num_layers == 0)
6326             colorglyphenum->has_regular_glyphs = TRUE;
6327     }
6328
6329     /* It's acceptable to have a subset of glyphs mapped to color layers, for regular runs client
6330        is supposed to proceed normally, like if font had no color info at all. */
6331     if (!has_colored_glyph) {
6332         IDWriteColorGlyphRunEnumerator1_Release(&colorglyphenum->IDWriteColorGlyphRunEnumerator1_iface);
6333         return DWRITE_E_NOCOLOR;
6334     }
6335
6336     colorglyphenum->advances = heap_calloc(run->glyphCount, sizeof(*colorglyphenum->advances));
6337     colorglyphenum->color_advances = heap_calloc(run->glyphCount, sizeof(*colorglyphenum->color_advances));
6338     colorglyphenum->glyphindices = heap_calloc(run->glyphCount, sizeof(*colorglyphenum->glyphindices));
6339     if (run->glyphOffsets) {
6340         colorglyphenum->offsets = heap_calloc(run->glyphCount, sizeof(*colorglyphenum->offsets));
6341         colorglyphenum->color_offsets = heap_calloc(run->glyphCount, sizeof(*colorglyphenum->color_offsets));
6342         memcpy(colorglyphenum->offsets, run->glyphOffsets, run->glyphCount * sizeof(*run->glyphOffsets));
6343     }
6344
6345     colorglyphenum->colorrun.glyphRun.fontFace = run->fontFace;
6346     colorglyphenum->colorrun.glyphRun.fontEmSize = run->fontEmSize;
6347     colorglyphenum->colorrun.glyphRun.glyphIndices = colorglyphenum->glyphindices;
6348     colorglyphenum->colorrun.glyphRun.glyphAdvances = colorglyphenum->color_advances;
6349     colorglyphenum->colorrun.glyphRun.glyphOffsets = colorglyphenum->color_offsets;
6350     colorglyphenum->colorrun.glyphRunDescription = NULL; /* FIXME */
6351     colorglyphenum->colorrun.measuringMode = measuring_mode;
6352     colorglyphenum->colorrun.glyphImageFormat = DWRITE_GLYPH_IMAGE_FORMATS_NONE; /* FIXME */
6353
6354     if (run->glyphAdvances)
6355         memcpy(colorglyphenum->advances, run->glyphAdvances, run->glyphCount * sizeof(FLOAT));
6356     else
6357     {
6358         for (i = 0; i < run->glyphCount; ++i)
6359             colorglyphenum->advances[i] = fontface_get_scaled_design_advance(fontface, measuring_mode,
6360                     run->fontEmSize, 1.0f, transform, run->glyphIndices[i], run->isSideways);
6361     }
6362
6363     *ret = (IDWriteColorGlyphRunEnumerator *)&colorglyphenum->IDWriteColorGlyphRunEnumerator1_iface;
6364
6365     return S_OK;
6366 }
6367
6368 /* IDWriteFontFaceReference */
6369 static HRESULT WINAPI fontfacereference_QueryInterface(IDWriteFontFaceReference1 *iface, REFIID riid, void **obj)
6370 {
6371     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
6372
6373     if (IsEqualIID(riid, &IID_IDWriteFontFaceReference1) ||
6374             IsEqualIID(riid, &IID_IDWriteFontFaceReference) ||
6375             IsEqualIID(riid, &IID_IUnknown))
6376     {
6377         *obj = iface;
6378         IDWriteFontFaceReference1_AddRef(iface);
6379         return S_OK;
6380     }
6381
6382     WARN("%s not implemented.\n", debugstr_guid(riid));
6383
6384     *obj = NULL;
6385
6386     return E_NOINTERFACE;
6387 }
6388
6389 static ULONG WINAPI fontfacereference_AddRef(IDWriteFontFaceReference1 *iface)
6390 {
6391     struct dwrite_fontfacereference *reference = impl_from_IDWriteFontFaceReference1(iface);
6392     ULONG refcount = InterlockedIncrement(&reference->refcount);
6393
6394     TRACE("%p, refcount %u.\n", iface, refcount);
6395
6396     return refcount;
6397 }
6398
6399 static ULONG WINAPI fontfacereference_Release(IDWriteFontFaceReference1 *iface)
6400 {
6401     struct dwrite_fontfacereference *reference = impl_from_IDWriteFontFaceReference1(iface);
6402     ULONG refcount = InterlockedDecrement(&reference->refcount);
6403
6404     TRACE("%p, refcount %u.\n", iface, refcount);
6405
6406     if (!refcount)
6407     {
6408         IDWriteFontFile_Release(reference->file);
6409         IDWriteFactory7_Release(reference->factory);
6410         heap_free(reference->axis_values);
6411         heap_free(reference);
6412     }
6413
6414     return refcount;
6415 }
6416
6417 static HRESULT WINAPI fontfacereference_CreateFontFace(IDWriteFontFaceReference1 *iface, IDWriteFontFace3 **fontface)
6418 {
6419     struct dwrite_fontfacereference *reference = impl_from_IDWriteFontFaceReference1(iface);
6420
6421     TRACE("%p, %p.\n", iface, fontface);
6422
6423     return IDWriteFontFaceReference1_CreateFontFaceWithSimulations(iface, reference->simulations, fontface);
6424 }
6425
6426 static HRESULT WINAPI fontfacereference_CreateFontFaceWithSimulations(IDWriteFontFaceReference1 *iface,
6427     DWRITE_FONT_SIMULATIONS simulations, IDWriteFontFace3 **ret)
6428 {
6429     struct dwrite_fontfacereference *reference = impl_from_IDWriteFontFaceReference1(iface);
6430     DWRITE_FONT_FILE_TYPE file_type;
6431     DWRITE_FONT_FACE_TYPE face_type;
6432     IDWriteFontFace *fontface;
6433     BOOL is_supported;
6434     UINT32 face_num;
6435     HRESULT hr;
6436
6437     TRACE("%p, %#x, %p.\n", iface, simulations, ret);
6438
6439     hr = IDWriteFontFile_Analyze(reference->file, &is_supported, &file_type, &face_type, &face_num);
6440     if (FAILED(hr))
6441         return hr;
6442
6443     hr = IDWriteFactory7_CreateFontFace(reference->factory, face_type, 1, &reference->file, reference->index,
6444             simulations, &fontface);
6445     if (SUCCEEDED(hr))
6446     {
6447         hr = IDWriteFontFace_QueryInterface(fontface, &IID_IDWriteFontFace3, (void **)ret);
6448         IDWriteFontFace_Release(fontface);
6449     }
6450
6451     return hr;
6452 }
6453
6454 static BOOL WINAPI fontfacereference_Equals(IDWriteFontFaceReference1 *iface, IDWriteFontFaceReference *ref)
6455 {
6456     struct dwrite_fontfacereference *reference = impl_from_IDWriteFontFaceReference1(iface);
6457     struct dwrite_fontfacereference *other = unsafe_impl_from_IDWriteFontFaceReference(ref);
6458     BOOL ret;
6459
6460     TRACE("%p, %p.\n", iface, ref);
6461
6462     ret = is_same_fontfile(reference->file, other->file) && reference->index == other->index &&
6463             reference->simulations == other->simulations;
6464     if (reference->axis_values_count)
6465     {
6466         ret &= reference->axis_values_count == other->axis_values_count &&
6467                 !memcmp(reference->axis_values, other->axis_values, reference->axis_values_count * sizeof(*reference->axis_values));
6468     }
6469
6470     return ret;
6471 }
6472
6473 static UINT32 WINAPI fontfacereference_GetFontFaceIndex(IDWriteFontFaceReference1 *iface)
6474 {
6475     struct dwrite_fontfacereference *reference = impl_from_IDWriteFontFaceReference1(iface);
6476
6477     TRACE("%p.\n", iface);
6478
6479     return reference->index;
6480 }
6481
6482 static DWRITE_FONT_SIMULATIONS WINAPI fontfacereference_GetSimulations(IDWriteFontFaceReference1 *iface)
6483 {
6484     struct dwrite_fontfacereference *reference = impl_from_IDWriteFontFaceReference1(iface);
6485
6486     TRACE("%p.\n", iface);
6487
6488     return reference->simulations;
6489 }
6490
6491 static HRESULT WINAPI fontfacereference_GetFontFile(IDWriteFontFaceReference1 *iface, IDWriteFontFile **file)
6492 {
6493     struct dwrite_fontfacereference *reference = impl_from_IDWriteFontFaceReference1(iface);
6494     IDWriteFontFileLoader *loader;
6495     const void *key;
6496     UINT32 key_size;
6497     HRESULT hr;
6498
6499     TRACE("%p, %p.\n", iface, file);
6500
6501     hr = IDWriteFontFile_GetReferenceKey(reference->file, &key, &key_size);
6502     if (FAILED(hr))
6503         return hr;
6504
6505     hr = IDWriteFontFile_GetLoader(reference->file, &loader);
6506     if (FAILED(hr))
6507         return hr;
6508
6509     hr = IDWriteFactory7_CreateCustomFontFileReference(reference->factory, key, key_size, loader, file);
6510     IDWriteFontFileLoader_Release(loader);
6511
6512     return hr;
6513 }
6514
6515 static UINT64 WINAPI fontfacereference_GetLocalFileSize(IDWriteFontFaceReference1 *iface)
6516 {
6517     FIXME("%p.\n", iface);
6518
6519     return 0;
6520 }
6521
6522 static UINT64 WINAPI fontfacereference_GetFileSize(IDWriteFontFaceReference1 *iface)
6523 {
6524     FIXME("%p.\n", iface);
6525
6526     return 0;
6527 }
6528
6529 static HRESULT WINAPI fontfacereference_GetFileTime(IDWriteFontFaceReference1 *iface, FILETIME *writetime)
6530 {
6531     FIXME("%p, %p.\n", iface, writetime);
6532
6533     return E_NOTIMPL;
6534 }
6535
6536 static DWRITE_LOCALITY WINAPI fontfacereference_GetLocality(IDWriteFontFaceReference1 *iface)
6537 {
6538     FIXME("%p.\n", iface);
6539
6540     return DWRITE_LOCALITY_LOCAL;
6541 }
6542
6543 static HRESULT WINAPI fontfacereference_EnqueueFontDownloadRequest(IDWriteFontFaceReference1 *iface)
6544 {
6545     FIXME("%p.\n", iface);
6546
6547     return E_NOTIMPL;
6548 }
6549
6550 static HRESULT WINAPI fontfacereference_EnqueueCharacterDownloadRequest(IDWriteFontFaceReference1 *iface,
6551         WCHAR const *chars, UINT32 count)
6552 {
6553     FIXME("%p, %s, %u.\n", iface, debugstr_wn(chars, count), count);
6554
6555     return E_NOTIMPL;
6556 }
6557
6558 static HRESULT WINAPI fontfacereference_EnqueueGlyphDownloadRequest(IDWriteFontFaceReference1 *iface,
6559         UINT16 const *glyphs, UINT32 count)
6560 {
6561     FIXME("%p, %p, %u.\n", iface, glyphs, count);
6562
6563     return E_NOTIMPL;
6564 }
6565
6566 static HRESULT WINAPI fontfacereference_EnqueueFileFragmentDownloadRequest(IDWriteFontFaceReference1 *iface,
6567         UINT64 offset, UINT64 size)
6568 {
6569     FIXME("%p, 0x%s, 0x%s.\n", iface, wine_dbgstr_longlong(offset), wine_dbgstr_longlong(size));
6570
6571     return E_NOTIMPL;
6572 }
6573
6574 static HRESULT WINAPI fontfacereference1_CreateFontFace(IDWriteFontFaceReference1 *iface, IDWriteFontFace5 **fontface)
6575 {
6576     struct dwrite_fontfacereference *reference = impl_from_IDWriteFontFaceReference1(iface);
6577     IDWriteFontFace3 *fontface3;
6578     HRESULT hr;
6579
6580     TRACE("%p, %p.\n", iface, fontface);
6581
6582     /* FIXME: created instance should likely respect given axis. */
6583     if (SUCCEEDED(hr = IDWriteFontFaceReference1_CreateFontFaceWithSimulations(iface, reference->simulations,
6584             &fontface3)))
6585     {
6586         hr = IDWriteFontFace3_QueryInterface(fontface3, &IID_IDWriteFontFace5, (void **)fontface);
6587         IDWriteFontFace3_Release(fontface3);
6588     }
6589
6590     return hr;
6591 }
6592
6593 static UINT32 WINAPI fontfacereference1_GetFontAxisValueCount(IDWriteFontFaceReference1 *iface)
6594 {
6595     struct dwrite_fontfacereference *reference = impl_from_IDWriteFontFaceReference1(iface);
6596
6597     TRACE("%p.\n", iface);
6598
6599     return reference->axis_values_count;
6600 }
6601
6602 static HRESULT WINAPI fontfacereference1_GetFontAxisValues(IDWriteFontFaceReference1 *iface,
6603         DWRITE_FONT_AXIS_VALUE *axis_values, UINT32 value_count)
6604 {
6605     struct dwrite_fontfacereference *reference = impl_from_IDWriteFontFaceReference1(iface);
6606
6607     TRACE("%p, %p, %u.\n", iface, axis_values, value_count);
6608
6609     if (value_count < reference->axis_values_count)
6610         return E_NOT_SUFFICIENT_BUFFER;
6611
6612     memcpy(axis_values, reference->axis_values, value_count * sizeof(*axis_values));
6613
6614     return S_OK;
6615 }
6616
6617 static const IDWriteFontFaceReference1Vtbl fontfacereferencevtbl =
6618 {
6619     fontfacereference_QueryInterface,
6620     fontfacereference_AddRef,
6621     fontfacereference_Release,
6622     fontfacereference_CreateFontFace,
6623     fontfacereference_CreateFontFaceWithSimulations,
6624     fontfacereference_Equals,
6625     fontfacereference_GetFontFaceIndex,
6626     fontfacereference_GetSimulations,
6627     fontfacereference_GetFontFile,
6628     fontfacereference_GetLocalFileSize,
6629     fontfacereference_GetFileSize,
6630     fontfacereference_GetFileTime,
6631     fontfacereference_GetLocality,
6632     fontfacereference_EnqueueFontDownloadRequest,
6633     fontfacereference_EnqueueCharacterDownloadRequest,
6634     fontfacereference_EnqueueGlyphDownloadRequest,
6635     fontfacereference_EnqueueFileFragmentDownloadRequest,
6636     fontfacereference1_CreateFontFace,
6637     fontfacereference1_GetFontAxisValueCount,
6638     fontfacereference1_GetFontAxisValues,
6639 };
6640
6641 HRESULT create_fontfacereference(IDWriteFactory7 *factory, IDWriteFontFile *file, UINT32 index,
6642         DWRITE_FONT_SIMULATIONS simulations, DWRITE_FONT_AXIS_VALUE const *axis_values, UINT32 axis_values_count,
6643         IDWriteFontFaceReference1 **ret)
6644 {
6645     struct dwrite_fontfacereference *object;
6646
6647     *ret = NULL;
6648
6649     if (!is_simulation_valid(simulations))
6650         return E_INVALIDARG;
6651
6652     object = heap_alloc_zero(sizeof(*object));
6653     if (!object)
6654         return E_OUTOFMEMORY;
6655
6656     object->IDWriteFontFaceReference1_iface.lpVtbl = &fontfacereferencevtbl;
6657     object->refcount = 1;
6658
6659     object->factory = factory;
6660     IDWriteFactory7_AddRef(object->factory);
6661     object->file = file;
6662     IDWriteFontFile_AddRef(object->file);
6663     object->index = index;
6664     object->simulations = simulations;
6665     if (axis_values_count)
6666     {
6667         if (!(object->axis_values = heap_alloc(axis_values_count * sizeof(*axis_values))))
6668         {
6669             IDWriteFontFaceReference1_Release(&object->IDWriteFontFaceReference1_iface);
6670             return E_OUTOFMEMORY;
6671         }
6672         memcpy(object->axis_values, axis_values, axis_values_count * sizeof(*axis_values));
6673         object->axis_values_count = axis_values_count;
6674     }
6675
6676     *ret = &object->IDWriteFontFaceReference1_iface;
6677
6678     return S_OK;
6679 }
6680
6681 static HRESULT WINAPI inmemoryfilestream_QueryInterface(IDWriteFontFileStream *iface, REFIID riid, void **obj)
6682 {
6683     TRACE_(dwrite_file)("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
6684
6685     if (IsEqualIID(riid, &IID_IDWriteFontFileStream) || IsEqualIID(riid, &IID_IUnknown)) {
6686         *obj = iface;
6687         IDWriteFontFileStream_AddRef(iface);
6688         return S_OK;
6689     }
6690
6691     *obj = NULL;
6692
6693     WARN("%s not implemented.\n", debugstr_guid(riid));
6694     return E_NOINTERFACE;
6695 }
6696
6697 static ULONG WINAPI inmemoryfilestream_AddRef(IDWriteFontFileStream *iface)
6698 {
6699     struct dwrite_inmemory_filestream *stream = inmemory_impl_from_IDWriteFontFileStream(iface);
6700     ULONG refcount = InterlockedIncrement(&stream->refcount);
6701
6702     TRACE_(dwrite_file)("%p, refcount %u.\n", iface, refcount);
6703
6704     return refcount;
6705 }
6706
6707 static ULONG WINAPI inmemoryfilestream_Release(IDWriteFontFileStream *iface)
6708 {
6709     struct dwrite_inmemory_filestream *stream = inmemory_impl_from_IDWriteFontFileStream(iface);
6710     ULONG refcount = InterlockedDecrement(&stream->refcount);
6711
6712     TRACE_(dwrite_file)("%p, refcount %u.\n", iface, refcount);
6713
6714     if (!refcount)
6715     {
6716         release_inmemory_stream(stream->data);
6717         heap_free(stream);
6718     }
6719
6720     return refcount;
6721 }
6722
6723 static HRESULT WINAPI inmemoryfilestream_ReadFileFragment(IDWriteFontFileStream *iface, void const **fragment_start,
6724         UINT64 offset, UINT64 fragment_size, void **fragment_context)
6725 {
6726     struct dwrite_inmemory_filestream *stream = inmemory_impl_from_IDWriteFontFileStream(iface);
6727
6728     TRACE_(dwrite_file)("%p, %p, 0x%s, 0x%s, %p.\n", iface, fragment_start,
6729           wine_dbgstr_longlong(offset), wine_dbgstr_longlong(fragment_size), fragment_context);
6730
6731     *fragment_context = NULL;
6732
6733     if ((offset >= stream->data->size - 1) || (fragment_size > stream->data->size - offset)) {
6734         *fragment_start = NULL;
6735         return E_FAIL;
6736     }
6737
6738     *fragment_start = (char *)stream->data->data + offset;
6739     return S_OK;
6740 }
6741
6742 static void WINAPI inmemoryfilestream_ReleaseFileFragment(IDWriteFontFileStream *iface, void *fragment_context)
6743 {
6744     TRACE_(dwrite_file)("%p, %p.\n", iface, fragment_context);
6745 }
6746
6747 static HRESULT WINAPI inmemoryfilestream_GetFileSize(IDWriteFontFileStream *iface, UINT64 *size)
6748 {
6749     struct dwrite_inmemory_filestream *stream = inmemory_impl_from_IDWriteFontFileStream(iface);
6750
6751     TRACE_(dwrite_file)("%p, %p.\n", iface, size);
6752
6753     *size = stream->data->size;
6754
6755     return S_OK;
6756 }
6757
6758 static HRESULT WINAPI inmemoryfilestream_GetLastWriteTime(IDWriteFontFileStream *iface, UINT64 *last_writetime)
6759 {
6760     TRACE_(dwrite_file)("%p, %p.\n", iface, last_writetime);
6761
6762     *last_writetime = 0;
6763
6764     return E_NOTIMPL;
6765 }
6766
6767 static const IDWriteFontFileStreamVtbl inmemoryfilestreamvtbl = {
6768     inmemoryfilestream_QueryInterface,
6769     inmemoryfilestream_AddRef,
6770     inmemoryfilestream_Release,
6771     inmemoryfilestream_ReadFileFragment,
6772     inmemoryfilestream_ReleaseFileFragment,
6773     inmemoryfilestream_GetFileSize,
6774     inmemoryfilestream_GetLastWriteTime,
6775 };
6776
6777 static HRESULT WINAPI inmemoryfontfileloader_QueryInterface(IDWriteInMemoryFontFileLoader *iface,
6778         REFIID riid, void **obj)
6779 {
6780     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
6781
6782     if (IsEqualIID(riid, &IID_IDWriteInMemoryFontFileLoader) ||
6783         IsEqualIID(riid, &IID_IDWriteFontFileLoader) ||
6784         IsEqualIID(riid, &IID_IUnknown))
6785     {
6786         *obj = iface;
6787         IDWriteInMemoryFontFileLoader_AddRef(iface);
6788         return S_OK;
6789     }
6790
6791     WARN("%s not implemented.\n", debugstr_guid(riid));
6792
6793     *obj = NULL;
6794
6795     return E_NOINTERFACE;
6796 }
6797
6798 static ULONG WINAPI inmemoryfontfileloader_AddRef(IDWriteInMemoryFontFileLoader *iface)
6799 {
6800     struct dwrite_inmemory_fileloader *loader = impl_from_IDWriteInMemoryFontFileLoader(iface);
6801     ULONG refcount = InterlockedIncrement(&loader->refcount);
6802
6803     TRACE("%p, refcount %u.\n", iface, refcount);
6804
6805     return refcount;
6806 }
6807
6808 static ULONG WINAPI inmemoryfontfileloader_Release(IDWriteInMemoryFontFileLoader *iface)
6809 {
6810     struct dwrite_inmemory_fileloader *loader = impl_from_IDWriteInMemoryFontFileLoader(iface);
6811     ULONG refcount = InterlockedDecrement(&loader->refcount);
6812     size_t i;
6813
6814     TRACE("%p, refcount %u.\n", iface, refcount);
6815
6816     if (!refcount)
6817     {
6818         for (i = 0; i < loader->count; ++i)
6819             release_inmemory_stream(loader->streams[i]);
6820         heap_free(loader->streams);
6821         heap_free(loader);
6822     }
6823
6824     return refcount;
6825 }
6826
6827 static HRESULT WINAPI inmemoryfontfileloader_CreateStreamFromKey(IDWriteInMemoryFontFileLoader *iface,
6828         void const *key, UINT32 key_size, IDWriteFontFileStream **ret)
6829 {
6830     struct dwrite_inmemory_fileloader *loader = impl_from_IDWriteInMemoryFontFileLoader(iface);
6831     struct dwrite_inmemory_filestream *stream;
6832     DWORD index;
6833
6834     TRACE("%p, %p, %u, %p.\n", iface, key, key_size, ret);
6835
6836     *ret = NULL;
6837
6838     if (key_size != sizeof(DWORD))
6839         return E_INVALIDARG;
6840
6841     index = *(DWORD *)key;
6842
6843     if (index >= loader->count)
6844         return E_INVALIDARG;
6845
6846     if (!(stream = heap_alloc(sizeof(*stream))))
6847         return E_OUTOFMEMORY;
6848
6849     stream->IDWriteFontFileStream_iface.lpVtbl = &inmemoryfilestreamvtbl;
6850     stream->refcount = 1;
6851     stream->data = loader->streams[index];
6852     InterlockedIncrement(&stream->data->refcount);
6853
6854     *ret = &stream->IDWriteFontFileStream_iface;
6855
6856     return S_OK;
6857 }
6858
6859 static HRESULT WINAPI inmemoryfontfileloader_CreateInMemoryFontFileReference(IDWriteInMemoryFontFileLoader *iface,
6860         IDWriteFactory *factory, void const *data, UINT32 data_size, IUnknown *owner, IDWriteFontFile **fontfile)
6861 {
6862     struct dwrite_inmemory_fileloader *loader = impl_from_IDWriteInMemoryFontFileLoader(iface);
6863     struct dwrite_inmemory_stream_data *stream;
6864     DWORD key;
6865
6866     TRACE("%p, %p, %p, %u, %p, %p.\n", iface, factory, data, data_size, owner, fontfile);
6867
6868     *fontfile = NULL;
6869
6870     if (!dwrite_array_reserve((void **)&loader->streams, &loader->size, loader->count + 1, sizeof(*loader->streams)))
6871         return E_OUTOFMEMORY;
6872
6873     if (!(stream = heap_alloc(sizeof(*stream))))
6874         return E_OUTOFMEMORY;
6875
6876     stream->refcount = 1;
6877     stream->size = data_size;
6878     stream->owner = owner;
6879     if (stream->owner) {
6880         IUnknown_AddRef(stream->owner);
6881         stream->data = (void *)data;
6882     }
6883     else {
6884         if (!(stream->data = heap_alloc(data_size))) {
6885             heap_free(stream);
6886             return E_OUTOFMEMORY;
6887         }
6888         memcpy(stream->data, data, data_size);
6889     }
6890
6891     key = loader->count;
6892     loader->streams[loader->count++] = stream;
6893
6894     return IDWriteFactory_CreateCustomFontFileReference(factory, &key, sizeof(key),
6895             (IDWriteFontFileLoader *)&loader->IDWriteInMemoryFontFileLoader_iface, fontfile);
6896 }
6897
6898 static UINT32 WINAPI inmemoryfontfileloader_GetFileCount(IDWriteInMemoryFontFileLoader *iface)
6899 {
6900     struct dwrite_inmemory_fileloader *loader = impl_from_IDWriteInMemoryFontFileLoader(iface);
6901
6902     TRACE("%p.\n", iface);
6903
6904     return loader->count;
6905 }
6906
6907 static const IDWriteInMemoryFontFileLoaderVtbl inmemoryfontfileloadervtbl =
6908 {
6909     inmemoryfontfileloader_QueryInterface,
6910     inmemoryfontfileloader_AddRef,
6911     inmemoryfontfileloader_Release,
6912     inmemoryfontfileloader_CreateStreamFromKey,
6913     inmemoryfontfileloader_CreateInMemoryFontFileReference,
6914     inmemoryfontfileloader_GetFileCount,
6915 };
6916
6917 HRESULT create_inmemory_fileloader(IDWriteInMemoryFontFileLoader **ret)
6918 {
6919     struct dwrite_inmemory_fileloader *loader;
6920
6921     *ret = NULL;
6922
6923     loader = heap_alloc_zero(sizeof(*loader));
6924     if (!loader)
6925         return E_OUTOFMEMORY;
6926
6927     loader->IDWriteInMemoryFontFileLoader_iface.lpVtbl = &inmemoryfontfileloadervtbl;
6928     loader->refcount = 1;
6929
6930     *ret = &loader->IDWriteInMemoryFontFileLoader_iface;
6931
6932     return S_OK;
6933 }
6934
6935 static HRESULT WINAPI dwritefontresource_QueryInterface(IDWriteFontResource *iface, REFIID riid, void **obj)
6936 {
6937     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
6938
6939     if (IsEqualIID(riid, &IID_IDWriteFontResource) ||
6940             IsEqualIID(riid, &IID_IUnknown))
6941     {
6942         *obj = iface;
6943         IDWriteFontResource_AddRef(iface);
6944         return S_OK;
6945     }
6946
6947     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
6948
6949     return E_NOINTERFACE;
6950 }
6951
6952 static ULONG WINAPI dwritefontresource_AddRef(IDWriteFontResource *iface)
6953 {
6954     struct dwrite_fontresource *resource = impl_from_IDWriteFontResource(iface);
6955     ULONG refcount = InterlockedIncrement(&resource->refcount);
6956
6957     TRACE("%p, refcount %u.\n", iface, refcount);
6958
6959     return refcount;
6960 }
6961
6962 static ULONG WINAPI dwritefontresource_Release(IDWriteFontResource *iface)
6963 {
6964     struct dwrite_fontresource *resource = impl_from_IDWriteFontResource(iface);
6965     ULONG refcount = InterlockedDecrement(&resource->refcount);
6966
6967     TRACE("%p, refcount %u.\n", iface, refcount);
6968
6969     if (!refcount)
6970     {
6971         IDWriteFactory7_Release(resource->factory);
6972         IDWriteFontFile_Release(resource->file);
6973         heap_free(resource);
6974     }
6975
6976     return refcount;
6977 }
6978
6979 static HRESULT WINAPI dwritefontresource_GetFontFile(IDWriteFontResource *iface, IDWriteFontFile **fontfile)
6980 {
6981     struct dwrite_fontresource *resource = impl_from_IDWriteFontResource(iface);
6982
6983     TRACE("%p, %p.\n", iface, fontfile);
6984
6985     *fontfile = resource->file;
6986     IDWriteFontFile_AddRef(*fontfile);
6987
6988     return S_OK;
6989 }
6990
6991 static UINT32 WINAPI dwritefontresource_GetFontFaceIndex(IDWriteFontResource *iface)
6992 {
6993     struct dwrite_fontresource *resource = impl_from_IDWriteFontResource(iface);
6994
6995     TRACE("%p.\n", iface);
6996
6997     return resource->face_index;
6998 }
6999
7000 static UINT32 WINAPI dwritefontresource_GetFontAxisCount(IDWriteFontResource *iface)
7001 {
7002     FIXME("%p.\n", iface);
7003
7004     return 0;
7005 }
7006
7007 static HRESULT WINAPI dwritefontresource_GetDefaultFontAxisValues(IDWriteFontResource *iface,
7008         DWRITE_FONT_AXIS_VALUE const *values, UINT32 num_values)
7009 {
7010     FIXME("%p, %p, %u.\n", iface, values, num_values);
7011
7012     return E_NOTIMPL;
7013 }
7014
7015 static HRESULT WINAPI dwritefontresource_GetFontAxisRanges(IDWriteFontResource *iface,
7016         DWRITE_FONT_AXIS_RANGE const *ranges, UINT32 num_ranges)
7017 {
7018     FIXME("%p, %p, %u.\n", iface, ranges, num_ranges);
7019
7020     return E_NOTIMPL;
7021 }
7022
7023 static DWRITE_FONT_AXIS_ATTRIBUTES WINAPI dwritefontresource_GetFontAxisAttributes(IDWriteFontResource *iface,
7024         UINT32 axis)
7025 {
7026     FIXME("%p, %u.\n", iface, axis);
7027
7028     return DWRITE_FONT_AXIS_ATTRIBUTES_NONE;
7029 }
7030
7031 static HRESULT WINAPI dwritefontresource_GetAxisNames(IDWriteFontResource *iface, UINT32 axis,
7032         IDWriteLocalizedStrings **names)
7033 {
7034     FIXME("%p, %u, %p.\n", iface, axis, names);
7035
7036     return E_NOTIMPL;
7037 }
7038
7039 static UINT32 WINAPI dwritefontresource_GetAxisValueNameCount(IDWriteFontResource *iface, UINT32 axis)
7040 {
7041     FIXME("%p, %u.\n", iface, axis);
7042
7043     return 0;
7044 }
7045
7046 static HRESULT WINAPI dwritefontresource_GetAxisValueNames(IDWriteFontResource *iface, UINT32 axis,
7047         UINT32 axis_value, DWRITE_FONT_AXIS_RANGE *axis_range, IDWriteLocalizedStrings **names)
7048 {
7049     FIXME("%p, %u, %u, %p, %p.\n", iface, axis, axis_value, axis_range, names);
7050
7051     return E_NOTIMPL;
7052 }
7053
7054 static BOOL WINAPI dwritefontresource_HasVariations(IDWriteFontResource *iface)
7055 {
7056     FIXME("%p.\n", iface);
7057
7058     return FALSE;
7059 }
7060
7061 static HRESULT WINAPI dwritefontresource_CreateFontFace(IDWriteFontResource *iface,
7062         DWRITE_FONT_SIMULATIONS simulations, DWRITE_FONT_AXIS_VALUE const *axis_values, UINT32 num_values,
7063         IDWriteFontFace5 **fontface)
7064 {
7065     struct dwrite_fontresource *resource = impl_from_IDWriteFontResource(iface);
7066     IDWriteFontFaceReference1 *reference;
7067     HRESULT hr;
7068
7069     TRACE("%p, %#x, %p, %u, %p.\n", iface, simulations, axis_values, num_values, fontface);
7070
7071     hr = IDWriteFactory7_CreateFontFaceReference(resource->factory, resource->file, resource->face_index,
7072             simulations, axis_values, num_values, &reference);
7073     if (SUCCEEDED(hr))
7074     {
7075         hr = IDWriteFontFaceReference1_CreateFontFace(reference, fontface);
7076         IDWriteFontFaceReference1_Release(reference);
7077     }
7078
7079     return hr;
7080 }
7081
7082 static HRESULT WINAPI dwritefontresource_CreateFontFaceReference(IDWriteFontResource *iface,
7083         DWRITE_FONT_SIMULATIONS simulations, DWRITE_FONT_AXIS_VALUE const *axis_values, UINT32 num_values,
7084         IDWriteFontFaceReference1 **reference)
7085 {
7086     struct dwrite_fontresource *resource = impl_from_IDWriteFontResource(iface);
7087
7088     TRACE("%p, %#x, %p, %u, %p.\n", iface, simulations, axis_values, num_values, reference);
7089
7090     return IDWriteFactory7_CreateFontFaceReference(resource->factory, resource->file, resource->face_index,
7091             simulations, axis_values, num_values, reference);
7092 }
7093
7094 static const IDWriteFontResourceVtbl fontresourcevtbl =
7095 {
7096     dwritefontresource_QueryInterface,
7097     dwritefontresource_AddRef,
7098     dwritefontresource_Release,
7099     dwritefontresource_GetFontFile,
7100     dwritefontresource_GetFontFaceIndex,
7101     dwritefontresource_GetFontAxisCount,
7102     dwritefontresource_GetDefaultFontAxisValues,
7103     dwritefontresource_GetFontAxisRanges,
7104     dwritefontresource_GetFontAxisAttributes,
7105     dwritefontresource_GetAxisNames,
7106     dwritefontresource_GetAxisValueNameCount,
7107     dwritefontresource_GetAxisValueNames,
7108     dwritefontresource_HasVariations,
7109     dwritefontresource_CreateFontFace,
7110     dwritefontresource_CreateFontFaceReference,
7111 };
7112
7113 HRESULT create_font_resource(IDWriteFactory7 *factory, IDWriteFontFile *file, UINT32 face_index,
7114         IDWriteFontResource **ret)
7115 {
7116     struct dwrite_fontresource *resource;
7117
7118     *ret = NULL;
7119
7120     resource = heap_alloc_zero(sizeof(*resource));
7121     if (!resource)
7122         return E_OUTOFMEMORY;
7123
7124     resource->IDWriteFontResource_iface.lpVtbl = &fontresourcevtbl;
7125     resource->refcount = 1;
7126     resource->face_index = face_index;
7127     resource->file = file;
7128     IDWriteFontFile_AddRef(resource->file);
7129     resource->factory = factory;
7130     IDWriteFactory7_AddRef(resource->factory);
7131
7132     *ret = &resource->IDWriteFontResource_iface;
7133
7134     return S_OK;
7135 }
7136
7137 static HRESULT WINAPI dwritefontset_QueryInterface(IDWriteFontSet3 *iface, REFIID riid, void **obj)
7138 {
7139     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
7140
7141     if (IsEqualIID(riid, &IID_IDWriteFontSet3) ||
7142             IsEqualIID(riid, &IID_IDWriteFontSet2) ||
7143             IsEqualIID(riid, &IID_IDWriteFontSet1) ||
7144             IsEqualIID(riid, &IID_IDWriteFontSet))
7145     {
7146         *obj = iface;
7147         IDWriteFontSet3_AddRef(iface);
7148         return S_OK;
7149     }
7150
7151     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
7152     *obj = NULL;
7153     return E_NOINTERFACE;
7154 }
7155
7156 static ULONG WINAPI dwritefontset_AddRef(IDWriteFontSet3 *iface)
7157 {
7158     struct dwrite_fontset *set = impl_from_IDWriteFontSet3(iface);
7159     ULONG refcount = InterlockedIncrement(&set->refcount);
7160
7161     TRACE("%p, refcount %u.\n", iface, refcount);
7162
7163     return refcount;
7164 }
7165
7166 #define MISSING_SET_PROP ((void *)0x1)
7167
7168 static void release_fontset_entry(struct dwrite_fontset_entry *entry)
7169 {
7170     unsigned int i;
7171
7172     if (InterlockedDecrement(&entry->refcount) > 0)
7173         return;
7174     IDWriteFontFile_Release(entry->file);
7175     for (i = 0; i < ARRAY_SIZE(entry->props); ++i)
7176     {
7177         if (entry->props[i] && entry->props[i] != MISSING_SET_PROP)
7178             IDWriteLocalizedStrings_Release(entry->props[i]);
7179     }
7180     heap_free(entry);
7181 }
7182
7183 static struct dwrite_fontset_entry * addref_fontset_entry(struct dwrite_fontset_entry *entry)
7184 {
7185     InterlockedIncrement(&entry->refcount);
7186     return entry;
7187 }
7188
7189 static IDWriteLocalizedStrings * fontset_entry_get_property(struct dwrite_fontset_entry *entry,
7190         DWRITE_FONT_PROPERTY_ID property)
7191 {
7192     struct file_stream_desc stream_desc = { 0 };
7193     IDWriteLocalizedStrings *value;
7194
7195     assert(property > DWRITE_FONT_PROPERTY_ID_NONE && property <= DWRITE_FONT_PROPERTY_ID_TYPOGRAPHIC_FACE_NAME);
7196
7197     if (entry->props[property] == MISSING_SET_PROP)
7198         return NULL;
7199
7200     if ((value = entry->props[property]))
7201     {
7202         IDWriteLocalizedStrings_AddRef(value);
7203         return value;
7204     }
7205
7206     get_filestream_from_file(entry->file, &stream_desc.stream);
7207     stream_desc.face_type = entry->face_type;
7208     stream_desc.face_index = entry->face_index;
7209
7210     if (property == DWRITE_FONT_PROPERTY_ID_FULL_NAME)
7211         opentype_get_font_info_strings(&stream_desc, DWRITE_INFORMATIONAL_STRING_FULL_NAME, &value);
7212     else if (property == DWRITE_FONT_PROPERTY_ID_POSTSCRIPT_NAME)
7213         opentype_get_font_info_strings(&stream_desc, DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_NAME, &value);
7214     else if (property == DWRITE_FONT_PROPERTY_ID_DESIGN_SCRIPT_LANGUAGE_TAG)
7215         opentype_get_font_info_strings(&stream_desc, DWRITE_INFORMATIONAL_STRING_DESIGN_SCRIPT_LANGUAGE_TAG, &value);
7216     else if (property == DWRITE_FONT_PROPERTY_ID_SUPPORTED_SCRIPT_LANGUAGE_TAG)
7217         opentype_get_font_info_strings(&stream_desc, DWRITE_INFORMATIONAL_STRING_SUPPORTED_SCRIPT_LANGUAGE_TAG, &value);
7218     else
7219         WARN("Unsupported property %u.\n", property);
7220
7221     if (stream_desc.stream)
7222         IDWriteFontFileStream_Release(stream_desc.stream);
7223
7224     if (value)
7225     {
7226         entry->props[property] = value;
7227         IDWriteLocalizedStrings_AddRef(value);
7228     }
7229     else
7230         entry->props[property] = MISSING_SET_PROP;
7231
7232     return value;
7233 }
7234
7235 static void init_fontset(struct dwrite_fontset *object, IDWriteFactory7 *factory,
7236        struct dwrite_fontset_entry **entries, unsigned int count);
7237
7238 static ULONG WINAPI dwritefontset_Release(IDWriteFontSet3 *iface)
7239 {
7240     struct dwrite_fontset *set = impl_from_IDWriteFontSet3(iface);
7241     ULONG refcount = InterlockedDecrement(&set->refcount);
7242     unsigned int i;
7243
7244     TRACE("%p, refcount %u.\n", iface, refcount);
7245
7246     if (!refcount)
7247     {
7248         IDWriteFactory7_Release(set->factory);
7249         for (i = 0; i < set->count; ++i)
7250             release_fontset_entry(set->entries[i]);
7251         heap_free(set->entries);
7252         heap_free(set);
7253     }
7254
7255     return refcount;
7256 }
7257
7258 static UINT32 WINAPI dwritefontset_GetFontCount(IDWriteFontSet3 *iface)
7259 {
7260     struct dwrite_fontset *set = impl_from_IDWriteFontSet3(iface);
7261
7262     TRACE("%p.\n", iface);
7263
7264     return set->count;
7265 }
7266
7267 static HRESULT WINAPI dwritefontset_GetFontFaceReference(IDWriteFontSet3 *iface, UINT32 index,
7268         IDWriteFontFaceReference **reference)
7269 {
7270     struct dwrite_fontset *set = impl_from_IDWriteFontSet3(iface);
7271
7272     TRACE("%p, %u, %p.\n", iface, index, reference);
7273
7274     *reference = NULL;
7275
7276     if (index >= set->count)
7277         return E_INVALIDARG;
7278
7279     return IDWriteFactory7_CreateFontFaceReference_(set->factory, set->entries[index]->file,
7280             set->entries[index]->face_index, set->entries[index]->simulations, reference);
7281 }
7282
7283 static HRESULT WINAPI dwritefontset_FindFontFaceReference(IDWriteFontSet3 *iface,
7284         IDWriteFontFaceReference *reference, UINT32 *index, BOOL *exists)
7285 {
7286     FIXME("%p, %p, %p, %p.\n", iface, reference, index, exists);
7287
7288     return E_NOTIMPL;
7289 }
7290
7291 static HRESULT WINAPI dwritefontset_FindFontFace(IDWriteFontSet3 *iface, IDWriteFontFace *fontface,
7292         UINT32 *index, BOOL *exists)
7293 {
7294     FIXME("%p, %p, %p, %p.\n", iface, fontface, index, exists);
7295
7296     return E_NOTIMPL;
7297 }
7298
7299 static HRESULT WINAPI dwritefontset_GetPropertyValues__(IDWriteFontSet3 *iface, DWRITE_FONT_PROPERTY_ID id,
7300         IDWriteStringList **values)
7301 {
7302     FIXME("%p, %d, %p.\n", iface, id, values);
7303
7304     return E_NOTIMPL;
7305 }
7306
7307 static HRESULT WINAPI dwritefontset_GetPropertyValues_(IDWriteFontSet3 *iface, DWRITE_FONT_PROPERTY_ID id,
7308         WCHAR const *preferred_locales, IDWriteStringList **values)
7309 {
7310     FIXME("%p, %d, %s, %p.\n", iface, id, debugstr_w(preferred_locales), values);
7311
7312     return E_NOTIMPL;
7313 }
7314
7315 static HRESULT WINAPI dwritefontset_GetPropertyValues(IDWriteFontSet3 *iface, UINT32 index, DWRITE_FONT_PROPERTY_ID id,
7316         BOOL *exists, IDWriteLocalizedStrings **values)
7317 {
7318     struct dwrite_fontset *set = impl_from_IDWriteFontSet3(iface);
7319
7320     TRACE("%p, %u, %d, %p, %p.\n", iface, index, id, exists, values);
7321
7322     if (!(id > DWRITE_FONT_PROPERTY_ID_NONE && id <= DWRITE_FONT_PROPERTY_ID_TYPOGRAPHIC_FACE_NAME) ||
7323             index >= set->count)
7324     {
7325         *values = NULL;
7326         *exists = FALSE;
7327         return E_INVALIDARG;
7328     }
7329
7330     *values = fontset_entry_get_property(set->entries[index], id);
7331     *exists = !!*values;
7332
7333     return S_OK;
7334 }
7335
7336 static HRESULT WINAPI dwritefontset_GetPropertyOccurrenceCount(IDWriteFontSet3 *iface, DWRITE_FONT_PROPERTY const *property,
7337         UINT32 *count)
7338 {
7339     FIXME("%p, %p, %p.\n", iface, property, count);
7340
7341     return E_NOTIMPL;
7342 }
7343
7344 static BOOL fontset_entry_is_matching(struct dwrite_fontset_entry *entry, DWRITE_FONT_PROPERTY const *props,
7345         unsigned int count)
7346 {
7347     IDWriteLocalizedStrings *value;
7348     unsigned int i;
7349     BOOL ret;
7350
7351     for (i = 0; i < count; ++i)
7352     {
7353         switch (props[i].propertyId)
7354         {
7355             case DWRITE_FONT_PROPERTY_ID_POSTSCRIPT_NAME:
7356             case DWRITE_FONT_PROPERTY_ID_FULL_NAME:
7357             case DWRITE_FONT_PROPERTY_ID_DESIGN_SCRIPT_LANGUAGE_TAG:
7358             case DWRITE_FONT_PROPERTY_ID_SUPPORTED_SCRIPT_LANGUAGE_TAG:
7359                 if (!(value = fontset_entry_get_property(entry, props[i].propertyId)))
7360                     return FALSE;
7361
7362                 ret = localizedstrings_contains(value, props[i].propertyValue);
7363                 IDWriteLocalizedStrings_Release(value);
7364                 if (!ret) return FALSE;
7365                 break;
7366             case DWRITE_FONT_PROPERTY_ID_WEIGHT_STRETCH_STYLE_FAMILY_NAME:
7367             case DWRITE_FONT_PROPERTY_ID_TYPOGRAPHIC_FAMILY_NAME:
7368             case DWRITE_FONT_PROPERTY_ID_WEIGHT_STRETCH_STYLE_FACE_NAME:
7369             case DWRITE_FONT_PROPERTY_ID_WIN32_FAMILY_NAME:
7370             case DWRITE_FONT_PROPERTY_ID_SEMANTIC_TAG:
7371             case DWRITE_FONT_PROPERTY_ID_WEIGHT:
7372             case DWRITE_FONT_PROPERTY_ID_STRETCH:
7373             case DWRITE_FONT_PROPERTY_ID_STYLE:
7374             case DWRITE_FONT_PROPERTY_ID_TYPOGRAPHIC_FACE_NAME:
7375                 FIXME("Unsupported property %d.\n", props[i].propertyId);
7376                 /* fallthrough */
7377             default:
7378                 return FALSE;
7379         }
7380     }
7381
7382     return TRUE;
7383 }
7384
7385 static HRESULT WINAPI dwritefontset_GetMatchingFonts_(IDWriteFontSet3 *iface, WCHAR const *family, DWRITE_FONT_WEIGHT weight,
7386         DWRITE_FONT_STRETCH stretch,  DWRITE_FONT_STYLE style, IDWriteFontSet **fontset)
7387 {
7388     FIXME("%p, %s, %d, %d, %d, %p.\n", iface, debugstr_w(family), weight, stretch, style, fontset);
7389
7390     return E_NOTIMPL;
7391 }
7392
7393 static HRESULT WINAPI dwritefontset_GetMatchingFonts(IDWriteFontSet3 *iface, DWRITE_FONT_PROPERTY const *props, UINT32 count,
7394         IDWriteFontSet **filtered_set)
7395 {
7396     struct dwrite_fontset *set = impl_from_IDWriteFontSet3(iface);
7397     struct dwrite_fontset_entry **entries;
7398     unsigned int i, matched_count = 0;
7399     struct dwrite_fontset *object;
7400
7401     TRACE("%p, %p, %u, %p.\n", iface, props, count, filtered_set);
7402
7403     if (!props && count)
7404         return E_INVALIDARG;
7405
7406     if (!(object = heap_alloc_zero(sizeof(*object))))
7407         return E_OUTOFMEMORY;
7408
7409     if (!(entries = heap_calloc(set->count, sizeof(*entries))))
7410     {
7411         heap_free(object);
7412         return E_OUTOFMEMORY;
7413     }
7414
7415     for (i = 0; i < set->count; ++i)
7416     {
7417         if (fontset_entry_is_matching(set->entries[i], props, count))
7418         {
7419             entries[matched_count++] = addref_fontset_entry(set->entries[i]);
7420         }
7421     }
7422
7423     if (!matched_count)
7424     {
7425         heap_free(entries);
7426         entries = NULL;
7427     }
7428
7429     init_fontset(object, set->factory, entries, matched_count);
7430
7431     *filtered_set = (IDWriteFontSet *)&object->IDWriteFontSet3_iface;
7432
7433     return S_OK;
7434 }
7435
7436 static HRESULT WINAPI dwritefontset1_GetMatchingFonts(IDWriteFontSet3 *iface, DWRITE_FONT_PROPERTY const *property,
7437         DWRITE_FONT_AXIS_VALUE const *axis_values, UINT32 num_values, IDWriteFontSet1 **fontset)
7438 {
7439     FIXME("%p, %p, %p, %u, %p.\n", iface, property, axis_values, num_values, fontset);
7440
7441     return E_NOTIMPL;
7442 }
7443
7444 static HRESULT WINAPI dwritefontset1_GetFirstFontResources(IDWriteFontSet3 *iface, IDWriteFontSet1 **fontset)
7445 {
7446     FIXME("%p, %p.\n", iface, fontset);
7447
7448     return E_NOTIMPL;
7449 }
7450
7451 static HRESULT WINAPI dwritefontset1_GetFilteredFonts__(IDWriteFontSet3 *iface, UINT32 const *indices,
7452         UINT32 num_indices, IDWriteFontSet1 **fontset)
7453 {
7454     FIXME("%p, %p, %u, %p.\n", iface, indices, num_indices, fontset);
7455
7456     return E_NOTIMPL;
7457 }
7458
7459 static HRESULT WINAPI dwritefontset1_GetFilteredFonts_(IDWriteFontSet3 *iface, DWRITE_FONT_AXIS_RANGE const *axis_ranges,
7460         UINT32 num_ranges, BOOL select_any_range, IDWriteFontSet1 **fontset)
7461 {
7462     FIXME("%p, %p, %u, %d, %p.\n", iface, axis_ranges, num_ranges, select_any_range, fontset);
7463
7464     return E_NOTIMPL;
7465 }
7466
7467 static HRESULT WINAPI dwritefontset1_GetFilteredFonts(IDWriteFontSet3 *iface, DWRITE_FONT_PROPERTY const *props,
7468         UINT32 num_properties, BOOL select_any_property, IDWriteFontSet1 **fontset)
7469 {
7470     FIXME("%p, %p, %u, %d, %p.\n", iface, props, num_properties, select_any_property, fontset);
7471
7472     return E_NOTIMPL;
7473 }
7474
7475 static HRESULT WINAPI dwritefontset1_GetFilteredFontIndices_(IDWriteFontSet3 *iface, DWRITE_FONT_AXIS_RANGE const *ranges,
7476         UINT32 num_ranges, BOOL select_any_range, UINT32 *indices, UINT32 num_indices, UINT32 *actual_num_indices)
7477 {
7478     FIXME("%p, %p, %u, %d, %p, %u, %p.\n", iface, ranges, num_ranges, select_any_range, indices, num_indices, actual_num_indices);
7479
7480     return E_NOTIMPL;
7481 }
7482
7483 static HRESULT WINAPI dwritefontset1_GetFilteredFontIndices(IDWriteFontSet3 *iface, DWRITE_FONT_PROPERTY const *props,
7484         UINT32 num_properties, BOOL select_any_range, UINT32 *indices, UINT32 num_indices, UINT32 *actual_num_indices)
7485 {
7486     FIXME("%p, %p, %u, %d, %p, %u, %p.\n", iface, props, num_properties, select_any_range, indices,
7487             num_indices, actual_num_indices);
7488
7489     return E_NOTIMPL;
7490 }
7491
7492 static HRESULT WINAPI dwritefontset1_GetFontAxisRanges_(IDWriteFontSet3 *iface, UINT32 font_index,
7493         DWRITE_FONT_AXIS_RANGE *axis_ranges, UINT32 num_ranges, UINT32 *actual_num_ranges)
7494 {
7495     FIXME("%p, %u, %p, %u, %p.\n", iface, font_index, axis_ranges, num_ranges, actual_num_ranges);
7496
7497     return E_NOTIMPL;
7498 }
7499
7500 static HRESULT WINAPI dwritefontset1_GetFontAxisRanges(IDWriteFontSet3 *iface, DWRITE_FONT_AXIS_RANGE *axis_ranges,
7501         UINT32 num_ranges, UINT32 *actual_num_ranges)
7502 {
7503     FIXME("%p, %p, %u, %p.\n", iface, axis_ranges, num_ranges, actual_num_ranges);
7504
7505     return E_NOTIMPL;
7506 }
7507
7508 static HRESULT WINAPI dwritefontset1_GetFontFaceReference(IDWriteFontSet3 *iface, UINT32 index,
7509         IDWriteFontFaceReference1 **reference)
7510 {
7511     FIXME("%p, %u, %p.\n", iface, index, reference);
7512
7513     return E_NOTIMPL;
7514 }
7515
7516 static HRESULT WINAPI dwritefontset1_CreateFontResource(IDWriteFontSet3 *iface, UINT32 index, IDWriteFontResource **resource)
7517 {
7518     struct dwrite_fontset *set = impl_from_IDWriteFontSet3(iface);
7519
7520     TRACE("%p, %u, %p.\n", iface, index, resource);
7521
7522     *resource = NULL;
7523
7524     if (index >= set->count)
7525         return E_INVALIDARG;
7526
7527     return IDWriteFactory7_CreateFontResource(set->factory, set->entries[index]->file,
7528             set->entries[index]->face_index, resource);
7529 }
7530
7531 static HRESULT WINAPI dwritefontset1_CreateFontFace(IDWriteFontSet3 *iface, UINT32 index, IDWriteFontFace5 **fontface)
7532 {
7533     FIXME("%p, %u, %p.\n", iface, index, fontface);
7534
7535     return E_NOTIMPL;
7536 }
7537
7538 static DWRITE_LOCALITY WINAPI dwritefontset1_GetFontLocality(IDWriteFontSet3 *iface, UINT32 index)
7539 {
7540     FIXME("%p, %u.\n", iface, index);
7541
7542     return DWRITE_LOCALITY_LOCAL;
7543 }
7544
7545 static HANDLE WINAPI dwritefontset2_GetExpirationEvent(IDWriteFontSet3 *iface)
7546 {
7547     FIXME("%p.\n", iface);
7548
7549     return NULL;
7550 }
7551
7552 static DWRITE_FONT_SOURCE_TYPE WINAPI dwritefontset3_GetFontSourceType(IDWriteFontSet3 *iface, UINT32 index)
7553 {
7554     FIXME("%p, %u.\n", iface, index);
7555
7556     return DWRITE_FONT_SOURCE_TYPE_UNKNOWN;
7557 }
7558
7559 static UINT32 WINAPI dwritefontset3_GetFontSourceNameLength(IDWriteFontSet3 *iface, UINT32 index)
7560 {
7561     FIXME("%p, %u.\n", iface, index);
7562
7563     return 0;
7564 }
7565
7566 static HRESULT WINAPI dwritefontset3_GetFontSourceName(IDWriteFontSet3 *iface, UINT32 index, WCHAR *buffer, UINT32 buffer_size)
7567 {
7568     FIXME("%p, %u, %p, %u.\n", iface, index, buffer, buffer_size);
7569
7570     return E_NOTIMPL;
7571 }
7572
7573 static const IDWriteFontSet3Vtbl fontsetvtbl =
7574 {
7575     dwritefontset_QueryInterface,
7576     dwritefontset_AddRef,
7577     dwritefontset_Release,
7578     dwritefontset_GetFontCount,
7579     dwritefontset_GetFontFaceReference,
7580     dwritefontset_FindFontFaceReference,
7581     dwritefontset_FindFontFace,
7582     dwritefontset_GetPropertyValues__,
7583     dwritefontset_GetPropertyValues_,
7584     dwritefontset_GetPropertyValues,
7585     dwritefontset_GetPropertyOccurrenceCount,
7586     dwritefontset_GetMatchingFonts_,
7587     dwritefontset_GetMatchingFonts,
7588     dwritefontset1_GetMatchingFonts,
7589     dwritefontset1_GetFirstFontResources,
7590     dwritefontset1_GetFilteredFonts__,
7591     dwritefontset1_GetFilteredFonts_,
7592     dwritefontset1_GetFilteredFonts,
7593     dwritefontset1_GetFilteredFontIndices_,
7594     dwritefontset1_GetFilteredFontIndices,
7595     dwritefontset1_GetFontAxisRanges_,
7596     dwritefontset1_GetFontAxisRanges,
7597     dwritefontset1_GetFontFaceReference,
7598     dwritefontset1_CreateFontResource,
7599     dwritefontset1_CreateFontFace,
7600     dwritefontset1_GetFontLocality,
7601     dwritefontset2_GetExpirationEvent,
7602     dwritefontset3_GetFontSourceType,
7603     dwritefontset3_GetFontSourceNameLength,
7604     dwritefontset3_GetFontSourceName,
7605 };
7606
7607 static HRESULT fontset_create_entry(IDWriteFontFile *file, DWRITE_FONT_FACE_TYPE face_type,
7608         unsigned int face_index, unsigned int simulations, struct dwrite_fontset_entry **ret)
7609 {
7610     struct dwrite_fontset_entry *entry;
7611
7612     if (!(entry = heap_alloc_zero(sizeof(*entry))))
7613         return E_OUTOFMEMORY;
7614
7615     entry->refcount = 1;
7616     entry->file = file;
7617     IDWriteFontFile_AddRef(entry->file);
7618     entry->face_type = face_type;
7619     entry->face_index = face_index;
7620     entry->simulations = simulations;
7621
7622     *ret = entry;
7623
7624     return S_OK;
7625 }
7626
7627 static void init_fontset(struct dwrite_fontset *object, IDWriteFactory7 *factory,
7628         struct dwrite_fontset_entry **entries, unsigned int count)
7629 {
7630     object->IDWriteFontSet3_iface.lpVtbl = &fontsetvtbl;
7631     object->refcount = 1;
7632     object->factory = factory;
7633     IDWriteFactory7_AddRef(object->factory);
7634     object->entries = entries;
7635     object->count = count;
7636 }
7637
7638 static HRESULT fontset_create_from_font_data(IDWriteFactory7 *factory, struct dwrite_font_data **fonts,
7639         unsigned int count, IDWriteFontSet1 **ret)
7640 {
7641     struct dwrite_fontset_entry **entries = NULL;
7642     struct dwrite_fontset *object;
7643     unsigned int i;
7644
7645     if (!(object = heap_alloc_zero(sizeof(*object))))
7646         return E_OUTOFMEMORY;
7647
7648     if (count)
7649     {
7650         entries = heap_calloc(count, sizeof(*entries));
7651
7652         /* FIXME: set available properties too */
7653
7654         for (i = 0; i < count; ++i)
7655         {
7656             fontset_create_entry(fonts[i]->file, fonts[i]->face_type, fonts[i]->face_index,
7657                     fonts[i]->simulations, &entries[i]);
7658         }
7659     }
7660     init_fontset(object, factory, entries, count);
7661
7662     *ret = (IDWriteFontSet1 *)&object->IDWriteFontSet3_iface;
7663
7664     return S_OK;
7665 }
7666
7667 static HRESULT fontset_builder_create_fontset(IDWriteFactory7 *factory, struct dwrite_fontset_entry **src_entries,
7668         unsigned int count, IDWriteFontSet **ret)
7669 {
7670     struct dwrite_fontset_entry **entries = NULL;
7671     struct dwrite_fontset *object;
7672     unsigned int i;
7673
7674     if (!(object = heap_alloc_zero(sizeof(*object))))
7675         return E_OUTOFMEMORY;
7676
7677     if (count)
7678     {
7679         entries = heap_calloc(count, sizeof(*entries));
7680
7681         for (i = 0; i < count; ++i)
7682             entries[i] = addref_fontset_entry(src_entries[i]);
7683     }
7684     init_fontset(object, factory, entries, count);
7685
7686     *ret = (IDWriteFontSet *)&object->IDWriteFontSet3_iface;
7687
7688     return S_OK;
7689 }
7690
7691 static HRESULT WINAPI dwritefontsetbuilder_QueryInterface(IDWriteFontSetBuilder2 *iface,
7692         REFIID riid, void **obj)
7693 {
7694     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
7695
7696     if (IsEqualIID(riid, &IID_IDWriteFontSetBuilder2) ||
7697             IsEqualIID(riid, &IID_IDWriteFontSetBuilder1) ||
7698             IsEqualIID(riid, &IID_IDWriteFontSetBuilder) ||
7699             IsEqualIID(riid, &IID_IUnknown))
7700     {
7701         *obj = iface;
7702         IDWriteFontSetBuilder2_AddRef(iface);
7703         return S_OK;
7704     }
7705
7706     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
7707     *obj = NULL;
7708     return E_NOINTERFACE;
7709 }
7710
7711 static ULONG WINAPI dwritefontsetbuilder_AddRef(IDWriteFontSetBuilder2 *iface)
7712 {
7713     struct dwrite_fontset_builder *builder = impl_from_IDWriteFontSetBuilder2(iface);
7714     ULONG refcount = InterlockedIncrement(&builder->refcount);
7715
7716     TRACE("%p, refcount %u.\n", iface, refcount);
7717
7718     return refcount;
7719 }
7720
7721 static ULONG WINAPI dwritefontsetbuilder_Release(IDWriteFontSetBuilder2 *iface)
7722 {
7723     struct dwrite_fontset_builder *builder = impl_from_IDWriteFontSetBuilder2(iface);
7724     ULONG refcount = InterlockedDecrement(&builder->refcount);
7725     unsigned int i;
7726
7727     TRACE("%p, refcount %u.\n", iface, refcount);
7728
7729     if (!refcount)
7730     {
7731         IDWriteFactory7_Release(builder->factory);
7732         for (i = 0; i < builder->count; ++i)
7733             release_fontset_entry(builder->entries[i]);
7734         heap_free(builder->entries);
7735         heap_free(builder);
7736     }
7737
7738     return refcount;
7739 }
7740
7741 static HRESULT fontset_builder_add_entry(struct dwrite_fontset_builder *builder, IDWriteFontFile *file,
7742         DWRITE_FONT_FACE_TYPE face_type, unsigned int face_index, unsigned int simulations)
7743 {
7744     struct dwrite_fontset_entry *entry;
7745     HRESULT hr;
7746
7747     if (!dwrite_array_reserve((void **)&builder->entries, &builder->capacity, builder->count + 1,
7748             sizeof(*builder->entries)))
7749     {
7750         return E_OUTOFMEMORY;
7751     }
7752
7753     if (FAILED(hr = fontset_create_entry(file, face_type, face_index, simulations, &entry)))
7754         return hr;
7755
7756     builder->entries[builder->count++] = entry;
7757
7758     return S_OK;
7759 }
7760
7761 static HRESULT fontset_builder_add_file(struct dwrite_fontset_builder *builder, IDWriteFontFile *file)
7762 {
7763     DWRITE_FONT_FILE_TYPE filetype;
7764     DWRITE_FONT_FACE_TYPE facetype;
7765     unsigned int i, face_count;
7766     BOOL supported = FALSE;
7767     HRESULT hr;
7768
7769     if (FAILED(hr = IDWriteFontFile_Analyze(file, &supported, &filetype, &facetype, &face_count)))
7770         return hr;
7771
7772     if (!supported)
7773         return DWRITE_E_FILEFORMAT;
7774
7775     for (i = 0; i < face_count; ++i)
7776     {
7777         if (FAILED(hr = fontset_builder_add_entry(builder, file, facetype, i, DWRITE_FONT_SIMULATIONS_NONE)))
7778             break;
7779     }
7780
7781     return hr;
7782 }
7783
7784 static HRESULT WINAPI dwritefontsetbuilder_AddFontFaceReference_(IDWriteFontSetBuilder2 *iface,
7785         IDWriteFontFaceReference *ref, DWRITE_FONT_PROPERTY const *props, UINT32 prop_count)
7786 {
7787     FIXME("%p, %p, %p, %u.\n", iface, ref, props, prop_count);
7788
7789     return E_NOTIMPL;
7790 }
7791
7792 static HRESULT WINAPI dwritefontsetbuilder_AddFontFaceReference(IDWriteFontSetBuilder2 *iface,
7793         IDWriteFontFaceReference *ref)
7794 {
7795     struct dwrite_fontset_builder *builder = impl_from_IDWriteFontSetBuilder2(iface);
7796     unsigned int face_count, face_index, simulations;
7797     DWRITE_FONT_FILE_TYPE file_type;
7798     DWRITE_FONT_FACE_TYPE face_type;
7799     IDWriteFontFile *file;
7800     BOOL supported;
7801     HRESULT hr;
7802
7803     TRACE("%p, %p.\n", iface, ref);
7804
7805     if (FAILED(hr = IDWriteFontFaceReference_GetFontFile(ref, &file))) return hr;
7806     if (FAILED(hr = IDWriteFontFile_Analyze(file, &supported, &file_type, &face_type, &face_count)))
7807         goto done;
7808
7809     if (!supported)
7810     {
7811         hr = DWRITE_E_FILEFORMAT;
7812         goto done;
7813     }
7814
7815     face_index = IDWriteFontFaceReference_GetFontFaceIndex(ref);
7816     simulations = IDWriteFontFaceReference_GetSimulations(ref);
7817     hr = fontset_builder_add_entry(builder, file, face_type, face_index, simulations);
7818
7819 done:
7820     IDWriteFontFile_Release(file);
7821
7822     return hr;
7823 }
7824
7825 static HRESULT WINAPI dwritefontsetbuilder_AddFontSet(IDWriteFontSetBuilder2 *iface, IDWriteFontSet *fontset)
7826 {
7827     FIXME("%p, %p.\n", iface, fontset);
7828
7829     return E_NOTIMPL;
7830 }
7831
7832 static HRESULT WINAPI dwritefontsetbuilder_CreateFontSet(IDWriteFontSetBuilder2 *iface, IDWriteFontSet **fontset)
7833 {
7834     struct dwrite_fontset_builder *builder = impl_from_IDWriteFontSetBuilder2(iface);
7835
7836     TRACE("%p, %p.\n", iface, fontset);
7837
7838     return fontset_builder_create_fontset(builder->factory, builder->entries, builder->count, fontset);
7839 }
7840
7841 static HRESULT WINAPI dwritefontsetbuilder1_AddFontFile(IDWriteFontSetBuilder2 *iface, IDWriteFontFile *file)
7842 {
7843     struct dwrite_fontset_builder *builder = impl_from_IDWriteFontSetBuilder2(iface);
7844
7845     TRACE("%p, %p.\n", iface, file);
7846
7847     return fontset_builder_add_file(builder, file);
7848 }
7849
7850 static HRESULT WINAPI dwritefontsetbuilder2_AddFont(IDWriteFontSetBuilder2 *iface, IDWriteFontFile *file,
7851         unsigned int face_index, DWRITE_FONT_SIMULATIONS simulations, const DWRITE_FONT_AXIS_VALUE *axis_values,
7852         unsigned int num_values, const DWRITE_FONT_AXIS_RANGE *axis_ranges, unsigned int num_ranges,
7853         const DWRITE_FONT_PROPERTY *props, unsigned int num_properties)
7854 {
7855     FIXME("%p, %p, %u, %#x, %p, %u, %p, %u, %p, %u.\n", iface, file, face_index, simulations, axis_values, num_values,
7856             axis_ranges, num_ranges, props, num_properties);
7857
7858     return E_NOTIMPL;
7859 }
7860
7861 static HRESULT WINAPI dwritefontsetbuilder2_AddFontFile(IDWriteFontSetBuilder2 *iface, const WCHAR *filepath)
7862 {
7863     struct dwrite_fontset_builder *builder = impl_from_IDWriteFontSetBuilder2(iface);
7864     IDWriteFontFile *file;
7865     HRESULT hr;
7866
7867     TRACE("%p, %s.\n", iface, debugstr_w(filepath));
7868
7869     if (FAILED(hr = IDWriteFactory7_CreateFontFileReference(builder->factory, filepath, NULL, &file)))
7870         return hr;
7871
7872     hr = fontset_builder_add_file(builder, file);
7873     IDWriteFontFile_Release(file);
7874     return hr;
7875 }
7876
7877 static const IDWriteFontSetBuilder2Vtbl fontsetbuildervtbl =
7878 {
7879     dwritefontsetbuilder_QueryInterface,
7880     dwritefontsetbuilder_AddRef,
7881     dwritefontsetbuilder_Release,
7882     dwritefontsetbuilder_AddFontFaceReference_,
7883     dwritefontsetbuilder_AddFontFaceReference,
7884     dwritefontsetbuilder_AddFontSet,
7885     dwritefontsetbuilder_CreateFontSet,
7886     dwritefontsetbuilder1_AddFontFile,
7887     dwritefontsetbuilder2_AddFont,
7888     dwritefontsetbuilder2_AddFontFile,
7889 };
7890
7891 HRESULT create_fontset_builder(IDWriteFactory7 *factory, IDWriteFontSetBuilder2 **ret)
7892 {
7893     struct dwrite_fontset_builder *builder;
7894
7895     *ret = NULL;
7896
7897     if (!(builder = heap_alloc_zero(sizeof(*builder))))
7898         return E_OUTOFMEMORY;
7899
7900     builder->IDWriteFontSetBuilder2_iface.lpVtbl = &fontsetbuildervtbl;
7901     builder->refcount = 1;
7902     builder->factory = factory;
7903     IDWriteFactory7_AddRef(builder->factory);
7904
7905     *ret = &builder->IDWriteFontSetBuilder2_iface;
7906
7907     return S_OK;
7908 }
7909
7910 struct font_data_context
7911 {
7912     IDWriteFontFileStream *stream;
7913     void *context;
7914 };
7915
7916 static int CDECL get_font_data_cb(void *key, const void **data_ptr, UINT64 *data_size,
7917         unsigned int *index, struct font_data_context **ret_context)
7918 {
7919     IDWriteFontFace *fontface = key;
7920     struct font_data_context *context;
7921     IDWriteFontFileStream *stream;
7922     IDWriteFontFile *file;
7923     unsigned int count;
7924     void *data_context;
7925     HRESULT hr;
7926
7927     *ret_context = NULL;
7928
7929     count = 1;
7930     if (FAILED(IDWriteFontFace_GetFiles(fontface, &count, &file))) return 1;
7931
7932     hr = get_filestream_from_file(file, &stream);
7933     IDWriteFontFile_Release(file);
7934     if (FAILED(hr)) return 1;
7935
7936     hr = IDWriteFontFileStream_GetFileSize(stream, data_size);
7937     if (FAILED(hr))
7938     {
7939         IDWriteFontFileStream_Release(stream);
7940         return 1;
7941     }
7942
7943     hr = IDWriteFontFileStream_ReadFileFragment(stream, data_ptr, 0, *data_size, &data_context);
7944     if (FAILED(hr))
7945     {
7946         IDWriteFontFileStream_Release(stream);
7947         return 1;
7948     }
7949
7950     if (!(context = heap_alloc(sizeof(*context))))
7951     {
7952         IDWriteFontFileStream_Release(stream);
7953         return 1;
7954     }
7955
7956     context->stream = stream;
7957     context->context = data_context;
7958
7959     *ret_context = context;
7960     *index = IDWriteFontFace_GetIndex(fontface);
7961
7962     return 0;
7963 }
7964
7965 static void CDECL release_font_data_cb(struct font_data_context *context)
7966 {
7967     if (!context) return;
7968     IDWriteFontFileStream_ReleaseFileFragment(context->stream, context->context);
7969     IDWriteFontFileStream_Release(context->stream);
7970     heap_free(context);
7971 }
7972
7973 struct font_callback_funcs callback_funcs =
7974 {
7975     get_font_data_cb,
7976     release_font_data_cb,
7977 };
7978
7979 void init_font_backend(void)
7980 {
7981     __wine_init_unix_lib(dwrite_module, DLL_PROCESS_ATTACH, &callback_funcs, &font_funcs);
7982 }
7983
7984 void release_font_backend(void)
7985 {
7986     __wine_init_unix_lib(dwrite_module, DLL_PROCESS_DETACH, &callback_funcs, NULL);
7987 }