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