dlls/dwrite/tests/font.c

   1 /*
   2  *    Font related tests
   3  *
   4  * Copyright 2012, 2014 Nikolay Sivov for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include "windows.h"
  24 #include "dwrite_1.h"
  25
  26 #include "wine/test.h"
  27
  28 #define EXPECT_HR(hr,hr_exp) \
  29     ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)
  30
  31 #define EXPECT_REF(obj,ref) _expect_ref((IUnknown*)obj, ref, __LINE__)
  32 static void _expect_ref(IUnknown* obj, ULONG ref, int line)
  33 {
  34     ULONG rc;
  35     IUnknown_AddRef(obj);
  36     rc = IUnknown_Release(obj);
  37     ok_(__FILE__,line)(rc == ref, "expected refcount %d, got %d\n", ref, rc);
  38 }
  39
  40 static inline void *heap_alloc(size_t len)
  41 {
  42     return HeapAlloc(GetProcessHeap(), 0, len);
  43 }
  44
  45 static inline BOOL heap_free(void *mem)
  46 {
  47     return HeapFree(GetProcessHeap(), 0, mem);
  48 }
  49
  50 static IDWriteFactory *factory;
  51
  52 static const WCHAR tahomaW[] = {'T','a','h','o','m','a',0};
  53 static const WCHAR blahW[]  = {'B','l','a','h','!',0};
  54
  55 /* Here is a functional custom font set of interfaces */
  56 struct test_fontdatastream
  57 {
  58     IDWriteFontFileStream IDWriteFontFileStream_iface;
  59     LONG ref;
  60
  61     LPVOID data;
  62     DWORD size;
  63 };
  64
  65 static inline struct test_fontdatastream *impl_from_IDWriteFontFileStream(IDWriteFontFileStream* iface)
  66 {
  67     return CONTAINING_RECORD(iface, struct test_fontdatastream, IDWriteFontFileStream_iface);
  68 }
  69
  70 static HRESULT WINAPI fontdatastream_QueryInterface(IDWriteFontFileStream *iface, REFIID riid, void **obj)
  71 {
  72     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDWriteFontFileStream))
  73     {
  74         *obj = iface;
  75         IDWriteFontFileStream_AddRef(iface);
  76         return S_OK;
  77     }
  78     *obj = NULL;
  79     return E_NOINTERFACE;
  80 }
  81
  82 static ULONG WINAPI fontdatastream_AddRef(IDWriteFontFileStream *iface)
  83 {
  84     struct test_fontdatastream *This = impl_from_IDWriteFontFileStream(iface);
  85     ULONG ref = InterlockedIncrement(&This->ref);
  86     return ref;
  87 }
  88
  89 static ULONG WINAPI fontdatastream_Release(IDWriteFontFileStream *iface)
  90 {
  91     struct test_fontdatastream *This = impl_from_IDWriteFontFileStream(iface);
  92     ULONG ref = InterlockedDecrement(&This->ref);
  93     if (ref == 0)
  94         HeapFree(GetProcessHeap(), 0, This);
  95     return ref;
  96 }
  97
  98 static HRESULT WINAPI fontdatastream_ReadFileFragment(IDWriteFontFileStream *iface, void const **fragment_start, UINT64 offset, UINT64 fragment_size, void **fragment_context)
  99 {
 100     struct test_fontdatastream *This = impl_from_IDWriteFontFileStream(iface);
 101     *fragment_context = NULL;
 102     if (offset+fragment_size > This->size)
 103     {
 104         *fragment_start = NULL;
 105         return E_FAIL;
 106     }
 107     else
 108     {
 109         *fragment_start = (BYTE*)This->data + offset;
 110         return S_OK;
 111     }
 112 }
 113
 114 static void WINAPI fontdatastream_ReleaseFileFragment(IDWriteFontFileStream *iface, void *fragment_context)
 115 {
 116     /* Do Nothing */
 117 }
 118
 119 static HRESULT WINAPI fontdatastream_GetFileSize(IDWriteFontFileStream *iface, UINT64 *size)
 120 {
 121     struct test_fontdatastream *This = impl_from_IDWriteFontFileStream(iface);
 122     *size = This->size;
 123     return S_OK;
 124 }
 125
 126 static HRESULT WINAPI fontdatastream_GetLastWriteTime(IDWriteFontFileStream *iface, UINT64 *last_writetime)
 127 {
 128     return E_NOTIMPL;
 129 }
 130
 131 static const IDWriteFontFileStreamVtbl fontdatastreamvtbl =
 132 {
 133     fontdatastream_QueryInterface,
 134     fontdatastream_AddRef,
 135     fontdatastream_Release,
 136     fontdatastream_ReadFileFragment,
 137     fontdatastream_ReleaseFileFragment,
 138     fontdatastream_GetFileSize,
 139     fontdatastream_GetLastWriteTime
 140 };
 141
 142 static HRESULT create_fontdatastream(LPVOID data, UINT size, IDWriteFontFileStream** iface)
 143 {
 144     struct test_fontdatastream *This = HeapAlloc(GetProcessHeap(), 0, sizeof(struct test_fontdatastream));
 145     if (!This)
 146         return E_OUTOFMEMORY;
 147
 148     This->data = data;
 149     This->size = size;
 150     This->ref = 1;
 151     This->IDWriteFontFileStream_iface.lpVtbl = &fontdatastreamvtbl;
 152
 153     *iface = &This->IDWriteFontFileStream_iface;
 154     return S_OK;
 155 }
 156
 157 static HRESULT WINAPI resourcefontfileloader_QueryInterface(IDWriteFontFileLoader *iface, REFIID riid, void **obj)
 158 {
 159     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDWriteFontFileLoader))
 160     {
 161         *obj = iface;
 162         return S_OK;
 163     }
 164     *obj = NULL;
 165     return E_NOINTERFACE;
 166 }
 167
 168 static ULONG WINAPI resourcefontfileloader_AddRef(IDWriteFontFileLoader *iface)
 169 {
 170     return 2;
 171 }
 172
 173 static ULONG WINAPI resourcefontfileloader_Release(IDWriteFontFileLoader *iface)
 174 {
 175     return 1;
 176 }
 177
 178 static HRESULT WINAPI resourcefontfileloader_CreateStreamFromKey(IDWriteFontFileLoader *iface, const void *fontFileReferenceKey, UINT32 fontFileReferenceKeySize, IDWriteFontFileStream **fontFileStream)
 179 {
 180     LPVOID data;
 181     DWORD size;
 182     HGLOBAL mem;
 183
 184     mem = LoadResource(GetModuleHandleA(NULL), *(HRSRC*)fontFileReferenceKey);
 185     ok(mem != NULL, "Failed to lock font resource\n");
 186     if (mem)
 187     {
 188         size = SizeofResource(GetModuleHandleA(NULL), *(HRSRC*)fontFileReferenceKey);
 189         data = LockResource(mem);
 190         return create_fontdatastream(data, size, fontFileStream);
 191     }
 192     return E_FAIL;
 193 }
 194
 195 static const struct IDWriteFontFileLoaderVtbl resourcefontfileloadervtbl = {
 196     resourcefontfileloader_QueryInterface,
 197     resourcefontfileloader_AddRef,
 198     resourcefontfileloader_Release,
 199     resourcefontfileloader_CreateStreamFromKey
 200 };
 201
 202 static IDWriteFontFileLoader rloader = { &resourcefontfileloadervtbl };
 203
 204 static void test_CreateFontFromLOGFONT(void)
 205 {
 206     static const WCHAR tahomaspW[] = {'T','a','h','o','m','a',' ',0};
 207     IDWriteGdiInterop *interop;
 208     DWRITE_FONT_WEIGHT weight;
 209     DWRITE_FONT_STYLE style;
 210     IDWriteFont *font;
 211     LOGFONTW logfont;
 212     LONG weights[][2] = {
 213         {FW_NORMAL, DWRITE_FONT_WEIGHT_NORMAL},
 214         {FW_BOLD, DWRITE_FONT_WEIGHT_BOLD},
 215         {  0, DWRITE_FONT_WEIGHT_NORMAL},
 216         { 50, DWRITE_FONT_WEIGHT_NORMAL},
 217         {150, DWRITE_FONT_WEIGHT_NORMAL},
 218         {250, DWRITE_FONT_WEIGHT_NORMAL},
 219         {350, DWRITE_FONT_WEIGHT_NORMAL},
 220         {450, DWRITE_FONT_WEIGHT_NORMAL},
 221         {650, DWRITE_FONT_WEIGHT_BOLD},
 222         {750, DWRITE_FONT_WEIGHT_BOLD},
 223         {850, DWRITE_FONT_WEIGHT_BOLD},
 224         {950, DWRITE_FONT_WEIGHT_BOLD},
 225         {960, DWRITE_FONT_WEIGHT_BOLD},
 226     };
 227     OUTLINETEXTMETRICW otm;
 228     HRESULT hr;
 229     BOOL ret;
 230     HDC hdc;
 231     HFONT hfont;
 232     BOOL exists;
 233     int i;
 234     UINT r;
 235
 236     hr = IDWriteFactory_GetGdiInterop(factory, &interop);
 237     EXPECT_HR(hr, S_OK);
 238
 239 if (0)
 240     /* null out parameter crashes this call */
 241     hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, NULL, NULL);
 242
 243     hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, NULL, &font);
 244     EXPECT_HR(hr, E_INVALIDARG);
 245
 246     memset(&logfont, 0, sizeof(logfont));
 247     logfont.lfHeight = 12;
 248     logfont.lfWidth  = 12;
 249     logfont.lfWeight = FW_NORMAL;
 250     logfont.lfItalic = 1;
 251     lstrcpyW(logfont.lfFaceName, tahomaW);
 252
 253     hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, &logfont, &font);
 254     EXPECT_HR(hr, S_OK);
 255
 256     hfont = CreateFontIndirectW(&logfont);
 257     hdc = CreateCompatibleDC(0);
 258     SelectObject(hdc, hfont);
 259
 260     otm.otmSize = sizeof(otm);
 261     r = GetOutlineTextMetricsW(hdc, otm.otmSize, &otm);
 262     ok(r, "got %d\n", r);
 263     DeleteDC(hdc);
 264     DeleteObject(hfont);
 265
 266     exists = TRUE;
 267     hr = IDWriteFont_HasCharacter(font, 0xd800, &exists);
 268     ok(hr == S_OK, "got 0x%08x\n", hr);
 269     ok(exists == FALSE, "got %d\n", exists);
 270
 271     exists = FALSE;
 272     hr = IDWriteFont_HasCharacter(font, 0x20, &exists);
 273     ok(hr == S_OK, "got 0x%08x\n", hr);
 274     ok(exists == TRUE, "got %d\n", exists);
 275
 276     /* now check properties */
 277     weight = IDWriteFont_GetWeight(font);
 278     ok(weight == DWRITE_FONT_WEIGHT_NORMAL, "got %d\n", weight);
 279
 280     style = IDWriteFont_GetStyle(font);
 281 todo_wine {
 282     ok(style == DWRITE_FONT_STYLE_OBLIQUE, "got %d\n", style);
 283     ok(otm.otmfsSelection == 1, "got 0x%08x\n", otm.otmfsSelection);
 284 }
 285     ret = IDWriteFont_IsSymbolFont(font);
 286     ok(!ret, "got %d\n", ret);
 287
 288     IDWriteFont_Release(font);
 289
 290     /* weight values */
 291     for (i = 0; i < sizeof(weights)/(2*sizeof(LONG)); i++)
 292     {
 293         memset(&logfont, 0, sizeof(logfont));
 294         logfont.lfHeight = 12;
 295         logfont.lfWidth  = 12;
 296         logfont.lfWeight = weights[i][0];
 297         lstrcpyW(logfont.lfFaceName, tahomaW);
 298
 299         hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, &logfont, &font);
 300         EXPECT_HR(hr, S_OK);
 301
 302         weight = IDWriteFont_GetWeight(font);
 303         ok(weight == weights[i][1],
 304             "%d: got %d, expected %d\n", i, weight, weights[i][1]);
 305         IDWriteFont_Release(font);
 306     }
 307
 308     /* weight not from enum */
 309     memset(&logfont, 0, sizeof(logfont));
 310     logfont.lfHeight = 12;
 311     logfont.lfWidth  = 12;
 312     logfont.lfWeight = 550;
 313     lstrcpyW(logfont.lfFaceName, tahomaW);
 314
 315     font = NULL;
 316     hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, &logfont, &font);
 317     ok(hr == S_OK, "got 0x%08x\n", hr);
 318
 319     weight = IDWriteFont_GetWeight(font);
 320     ok(weight == DWRITE_FONT_WEIGHT_NORMAL || broken(weight == DWRITE_FONT_WEIGHT_BOLD) /* win7 w/o SP */,
 321         "got %d\n", weight);
 322     IDWriteFont_Release(font);
 323
 324     /* empty or nonexistent face name */
 325     memset(&logfont, 0, sizeof(logfont));
 326     logfont.lfHeight = 12;
 327     logfont.lfWidth  = 12;
 328     logfont.lfWeight = FW_NORMAL;
 329     lstrcpyW(logfont.lfFaceName, blahW);
 330
 331     font = (void*)0xdeadbeef;
 332     hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, &logfont, &font);
 333     ok(hr == DWRITE_E_NOFONT, "got 0x%08x\n", hr);
 334     ok(font == NULL, "got %p\n", font);
 335
 336     /* Try with name 'Tahoma ' */
 337     memset(&logfont, 0, sizeof(logfont));
 338     logfont.lfHeight = 12;
 339     logfont.lfWidth  = 12;
 340     logfont.lfWeight = FW_NORMAL;
 341     lstrcpyW(logfont.lfFaceName, tahomaspW);
 342
 343     font = (void*)0xdeadbeef;
 344     hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, &logfont, &font);
 345     ok(hr == DWRITE_E_NOFONT, "got 0x%08x\n", hr);
 346     ok(font == NULL, "got %p\n", font);
 347
 348     /* empty string as a facename */
 349     memset(&logfont, 0, sizeof(logfont));
 350     logfont.lfHeight = 12;
 351     logfont.lfWidth  = 12;
 352     logfont.lfWeight = FW_NORMAL;
 353
 354     font = (void*)0xdeadbeef;
 355     hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, &logfont, &font);
 356     ok(hr == DWRITE_E_NOFONT, "got 0x%08x\n", hr);
 357     ok(font == NULL, "got %p\n", font);
 358
 359     IDWriteGdiInterop_Release(interop);
 360 }
 361
 362 static void test_CreateBitmapRenderTarget(void)
 363 {
 364     IDWriteBitmapRenderTarget *target, *target2;
 365     IDWriteGdiInterop *interop;
 366     HBITMAP hbm, hbm2;
 367     DWRITE_MATRIX m;
 368     DIBSECTION ds;
 369     HRESULT hr;
 370     SIZE size;
 371     HDC hdc;
 372     int ret;
 373
 374     hr = IDWriteFactory_GetGdiInterop(factory, &interop);
 375     EXPECT_HR(hr, S_OK);
 376
 377     target = NULL;
 378     hr = IDWriteGdiInterop_CreateBitmapRenderTarget(interop, NULL, 0, 0, &target);
 379     EXPECT_HR(hr, S_OK);
 380
 381 if (0) /* crashes on native */
 382     hr = IDWriteBitmapRenderTarget_GetSize(target, NULL);
 383
 384     size.cx = size.cy = -1;
 385     hr = IDWriteBitmapRenderTarget_GetSize(target, &size);
 386     EXPECT_HR(hr, S_OK);
 387     ok(size.cx == 0, "got %d\n", size.cx);
 388     ok(size.cy == 0, "got %d\n", size.cy);
 389
 390     target2 = NULL;
 391     hr = IDWriteGdiInterop_CreateBitmapRenderTarget(interop, NULL, 0, 0, &target2);
 392     EXPECT_HR(hr, S_OK);
 393     ok(target != target2, "got %p, %p\n", target2, target);
 394     IDWriteBitmapRenderTarget_Release(target2);
 395
 396     hdc = IDWriteBitmapRenderTarget_GetMemoryDC(target);
 397     ok(hdc != NULL, "got %p\n", hdc);
 398
 399     hbm = GetCurrentObject(hdc, OBJ_BITMAP);
 400     ok(hbm != NULL, "got %p\n", hbm);
 401
 402     /* check DIB properties */
 403     ret = GetObjectW(hbm, sizeof(ds), &ds);
 404     ok(ret == sizeof(BITMAP), "got %d\n", ret);
 405     ok(ds.dsBm.bmWidth == 1, "got %d\n", ds.dsBm.bmWidth);
 406     ok(ds.dsBm.bmHeight == 1, "got %d\n", ds.dsBm.bmHeight);
 407     ok(ds.dsBm.bmPlanes == 1, "got %d\n", ds.dsBm.bmPlanes);
 408     ok(ds.dsBm.bmBitsPixel == 1, "got %d\n", ds.dsBm.bmBitsPixel);
 409     ok(!ds.dsBm.bmBits, "got %p\n", ds.dsBm.bmBits);
 410
 411     IDWriteBitmapRenderTarget_Release(target);
 412
 413     hbm = GetCurrentObject(hdc, OBJ_BITMAP);
 414     ok(!hbm, "got %p\n", hbm);
 415
 416     target = NULL;
 417     hr = IDWriteGdiInterop_CreateBitmapRenderTarget(interop, NULL, 10, 5, &target);
 418     EXPECT_HR(hr, S_OK);
 419
 420     hdc = IDWriteBitmapRenderTarget_GetMemoryDC(target);
 421     ok(hdc != NULL, "got %p\n", hdc);
 422
 423     hbm = GetCurrentObject(hdc, OBJ_BITMAP);
 424     ok(hbm != NULL, "got %p\n", hbm);
 425
 426     /* check DIB properties */
 427     ret = GetObjectW(hbm, sizeof(ds), &ds);
 428     ok(ret == sizeof(ds), "got %d\n", ret);
 429     ok(ds.dsBm.bmWidth == 10, "got %d\n", ds.dsBm.bmWidth);
 430     ok(ds.dsBm.bmHeight == 5, "got %d\n", ds.dsBm.bmHeight);
 431     ok(ds.dsBm.bmPlanes == 1, "got %d\n", ds.dsBm.bmPlanes);
 432     ok(ds.dsBm.bmBitsPixel == 32, "got %d\n", ds.dsBm.bmBitsPixel);
 433     ok(ds.dsBm.bmBits != NULL, "got %p\n", ds.dsBm.bmBits);
 434
 435     size.cx = size.cy = -1;
 436     hr = IDWriteBitmapRenderTarget_GetSize(target, &size);
 437     EXPECT_HR(hr, S_OK);
 438     ok(size.cx == 10, "got %d\n", size.cx);
 439     ok(size.cy == 5, "got %d\n", size.cy);
 440
 441     /* resize to same size */
 442     hr = IDWriteBitmapRenderTarget_Resize(target, 10, 5);
 443     ok(hr == S_OK, "got 0x%08x\n", hr);
 444
 445     hbm2 = GetCurrentObject(hdc, OBJ_BITMAP);
 446     ok(hbm2 == hbm, "got %p, %p\n", hbm2, hbm);
 447
 448     /* shrink */
 449     hr = IDWriteBitmapRenderTarget_Resize(target, 5, 5);
 450     ok(hr == S_OK, "got 0x%08x\n", hr);
 451
 452     hbm2 = GetCurrentObject(hdc, OBJ_BITMAP);
 453     ok(hbm2 != hbm, "got %p, %p\n", hbm2, hbm);
 454
 455     hr = IDWriteBitmapRenderTarget_Resize(target, 20, 5);
 456     ok(hr == S_OK, "got 0x%08x\n", hr);
 457
 458     hbm2 = GetCurrentObject(hdc, OBJ_BITMAP);
 459     ok(hbm2 != hbm, "got %p, %p\n", hbm2, hbm);
 460
 461     hr = IDWriteBitmapRenderTarget_Resize(target, 1, 5);
 462     ok(hr == S_OK, "got 0x%08x\n", hr);
 463
 464     hbm2 = GetCurrentObject(hdc, OBJ_BITMAP);
 465     ok(hbm2 != hbm, "got %p, %p\n", hbm2, hbm);
 466
 467     ret = GetObjectW(hbm2, sizeof(ds), &ds);
 468     ok(ret == sizeof(ds), "got %d\n", ret);
 469     ok(ds.dsBm.bmWidth == 1, "got %d\n", ds.dsBm.bmWidth);
 470     ok(ds.dsBm.bmHeight == 5, "got %d\n", ds.dsBm.bmHeight);
 471     ok(ds.dsBm.bmPlanes == 1, "got %d\n", ds.dsBm.bmPlanes);
 472     ok(ds.dsBm.bmBitsPixel == 32, "got %d\n", ds.dsBm.bmBitsPixel);
 473     ok(ds.dsBm.bmBits != NULL, "got %p\n", ds.dsBm.bmBits);
 474
 475     /* empty rectangle */
 476     hr = IDWriteBitmapRenderTarget_Resize(target, 0, 5);
 477     ok(hr == S_OK, "got 0x%08x\n", hr);
 478
 479     hbm2 = GetCurrentObject(hdc, OBJ_BITMAP);
 480     ok(hbm2 != hbm, "got %p, %p\n", hbm2, hbm);
 481
 482     ret = GetObjectW(hbm2, sizeof(ds), &ds);
 483     ok(ret == sizeof(BITMAP), "got %d\n", ret);
 484     ok(ds.dsBm.bmWidth == 1, "got %d\n", ds.dsBm.bmWidth);
 485     ok(ds.dsBm.bmHeight == 1, "got %d\n", ds.dsBm.bmHeight);
 486     ok(ds.dsBm.bmPlanes == 1, "got %d\n", ds.dsBm.bmPlanes);
 487     ok(ds.dsBm.bmBitsPixel == 1, "got %d\n", ds.dsBm.bmBitsPixel);
 488     ok(!ds.dsBm.bmBits, "got %p\n", ds.dsBm.bmBits);
 489
 490     /* transform tests */
 491 if (0) /* crashes on native */
 492     hr = IDWriteBitmapRenderTarget_GetCurrentTransform(target, NULL);
 493
 494     memset(&m, 0xcc, sizeof(m));
 495     hr = IDWriteBitmapRenderTarget_GetCurrentTransform(target, &m);
 496     ok(hr == S_OK, "got 0x%08x\n", hr);
 497     ok(m.m11 == 1.0 && m.m22 == 1.0 && m.m12 == 0.0 && m.m21 == 0.0, "got %.1f,%.1f,%.1f,%.1f\n", m.m11, m.m22, m.m12, m.m21);
 498     ok(m.dx == 0.0 && m.dy == 0.0, "got %.1f,%.1f\n", m.dx, m.dy);
 499
 500     IDWriteBitmapRenderTarget_Release(target);
 501     IDWriteGdiInterop_Release(interop);
 502 }
 503
 504 static void test_GetFontFamily(void)
 505 {
 506     IDWriteFontCollection *collection, *collection2;
 507     IDWriteFontCollection *syscoll;
 508     IDWriteFontFamily *family, *family2;
 509     IDWriteGdiInterop *interop;
 510     IDWriteFont *font, *font2;
 511     LOGFONTW logfont;
 512     HRESULT hr;
 513
 514     hr = IDWriteFactory_GetGdiInterop(factory, &interop);
 515     EXPECT_HR(hr, S_OK);
 516
 517     hr = IDWriteFactory_GetSystemFontCollection(factory, &syscoll, FALSE);
 518     ok(hr == S_OK, "got 0x%08x\n", hr);
 519
 520     memset(&logfont, 0, sizeof(logfont));
 521     logfont.lfHeight = 12;
 522     logfont.lfWidth  = 12;
 523     logfont.lfWeight = FW_NORMAL;
 524     logfont.lfItalic = 1;
 525     lstrcpyW(logfont.lfFaceName, tahomaW);
 526
 527     hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, &logfont, &font);
 528     ok(hr == S_OK, "got 0x%08x\n", hr);
 529
 530     hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, &logfont, &font2);
 531     ok(hr == S_OK, "got 0x%08x\n", hr);
 532     ok(font2 != font, "got %p, %p\n", font2, font);
 533
 534 if (0) /* crashes on native */
 535     hr = IDWriteFont_GetFontFamily(font, NULL);
 536
 537     EXPECT_REF(font, 1);
 538     hr = IDWriteFont_GetFontFamily(font, &family);
 539     EXPECT_HR(hr, S_OK);
 540     EXPECT_REF(font, 1);
 541     EXPECT_REF(family, 2);
 542
 543     hr = IDWriteFont_GetFontFamily(font, &family2);
 544     EXPECT_HR(hr, S_OK);
 545     ok(family2 == family, "got %p, previous %p\n", family2, family);
 546     EXPECT_REF(font, 1);
 547     EXPECT_REF(family, 3);
 548     IDWriteFontFamily_Release(family2);
 549
 550     hr = IDWriteFont_QueryInterface(font, &IID_IDWriteFontFamily, (void**)&family2);
 551     EXPECT_HR(hr, E_NOINTERFACE);
 552     ok(family2 == NULL, "got %p\n", family2);
 553
 554     hr = IDWriteFont_GetFontFamily(font2, &family2);
 555     ok(hr == S_OK, "got 0x%08x\n", hr);
 556     ok(family2 != family, "got %p, %p\n", family2, family);
 557
 558     collection = NULL;
 559     hr = IDWriteFontFamily_GetFontCollection(family, &collection);
 560 todo_wine
 561     ok(hr == S_OK, "got 0x%08x\n", hr);
 562
 563     collection2 = NULL;
 564     hr = IDWriteFontFamily_GetFontCollection(family2, &collection2);
 565 todo_wine
 566     ok(hr == S_OK, "got 0x%08x\n", hr);
 567     ok(collection == collection2, "got %p, %p\n", collection, collection2);
 568 todo_wine
 569     ok(collection == syscoll, "got %p, %p\n", collection, syscoll);
 570
 571     IDWriteFontCollection_Release(syscoll);
 572 if (collection2)
 573     IDWriteFontCollection_Release(collection2);
 574 if (collection)
 575     IDWriteFontCollection_Release(collection);
 576     IDWriteFontFamily_Release(family2);
 577     IDWriteFontFamily_Release(family);
 578     IDWriteFont_Release(font);
 579     IDWriteFont_Release(font2);
 580     IDWriteGdiInterop_Release(interop);
 581 }
 582
 583 static void test_GetFamilyNames(void)
 584 {
 585     IDWriteFontFamily *family;
 586     IDWriteLocalizedStrings *names, *names2;
 587     IDWriteGdiInterop *interop;
 588     IDWriteFont *font;
 589     LOGFONTW logfont;
 590     WCHAR buffer[100];
 591     HRESULT hr;
 592     UINT32 len;
 593
 594     hr = IDWriteFactory_GetGdiInterop(factory, &interop);
 595     EXPECT_HR(hr, S_OK);
 596
 597     memset(&logfont, 0, sizeof(logfont));
 598     logfont.lfHeight = 12;
 599     logfont.lfWidth  = 12;
 600     logfont.lfWeight = FW_NORMAL;
 601     logfont.lfItalic = 1;
 602     lstrcpyW(logfont.lfFaceName, tahomaW);
 603
 604     hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, &logfont, &font);
 605     EXPECT_HR(hr, S_OK);
 606
 607     hr = IDWriteFont_GetFontFamily(font, &family);
 608     EXPECT_HR(hr, S_OK);
 609
 610 if (0) /* crashes on native */
 611     hr = IDWriteFontFamily_GetFamilyNames(family, NULL);
 612
 613     hr = IDWriteFontFamily_GetFamilyNames(family, &names);
 614     ok(hr == S_OK, "got 0x%08x\n", hr);
 615     EXPECT_REF(names, 1);
 616
 617     hr = IDWriteFontFamily_GetFamilyNames(family, &names2);
 618     ok(hr == S_OK, "got 0x%08x\n", hr);
 619     EXPECT_REF(names2, 1);
 620     ok(names != names2, "got %p, was %p\n", names2, names);
 621
 622     IDWriteLocalizedStrings_Release(names2);
 623
 624     /* GetStringLength */
 625 if (0) /* crashes on native */
 626     hr = IDWriteLocalizedStrings_GetStringLength(names, 0, NULL);
 627
 628     len = 100;
 629     hr = IDWriteLocalizedStrings_GetStringLength(names, 10, &len);
 630     ok(hr == E_FAIL, "got 0x%08x\n", hr);
 631     ok(len == (UINT32)-1, "got %u\n", len);
 632
 633     len = 0;
 634     hr = IDWriteLocalizedStrings_GetStringLength(names, 0, &len);
 635     ok(hr == S_OK, "got 0x%08x\n", hr);
 636     ok(len > 0, "got %u\n", len);
 637
 638     /* GetString */
 639     hr = IDWriteLocalizedStrings_GetString(names, 0, NULL, 0);
 640     ok(hr == E_NOT_SUFFICIENT_BUFFER, "got 0x%08x\n", hr);
 641
 642     hr = IDWriteLocalizedStrings_GetString(names, 10, NULL, 0);
 643     ok(hr == E_FAIL, "got 0x%08x\n", hr);
 644
 645 if (0)
 646     hr = IDWriteLocalizedStrings_GetString(names, 0, NULL, 100);
 647
 648     buffer[0] = 1;
 649     hr = IDWriteLocalizedStrings_GetString(names, 10, buffer, 100);
 650     ok(hr == E_FAIL, "got 0x%08x\n", hr);
 651     ok(buffer[0] == 0, "got %x\n", buffer[0]);
 652
 653     buffer[0] = 1;
 654     hr = IDWriteLocalizedStrings_GetString(names, 0, buffer, len-1);
 655     ok(hr == E_NOT_SUFFICIENT_BUFFER, "got 0x%08x\n", hr);
 656     ok(buffer[0] == 0, "got %x\n", buffer[0]);
 657
 658     buffer[0] = 1;
 659     hr = IDWriteLocalizedStrings_GetString(names, 0, buffer, len);
 660     ok(hr == E_NOT_SUFFICIENT_BUFFER, "got 0x%08x\n", hr);
 661     ok(buffer[0] == 0, "got %x\n", buffer[0]);
 662
 663     buffer[0] = 0;
 664     hr = IDWriteLocalizedStrings_GetString(names, 0, buffer, len+1);
 665     ok(hr == S_OK, "got 0x%08x\n", hr);
 666     ok(buffer[0] != 0, "got %x\n", buffer[0]);
 667
 668     IDWriteLocalizedStrings_Release(names);
 669
 670     IDWriteFontFamily_Release(family);
 671     IDWriteFont_Release(font);
 672     IDWriteGdiInterop_Release(interop);
 673 }
 674
 675 static void test_CreateFontFace(void)
 676 {
 677     IDWriteFontFace *fontface, *fontface2;
 678     IDWriteGdiInterop *interop;
 679     IDWriteFont *font;
 680     LOGFONTW logfont;
 681     HRESULT hr;
 682
 683     hr = IDWriteFactory_GetGdiInterop(factory, &interop);
 684     EXPECT_HR(hr, S_OK);
 685
 686     memset(&logfont, 0, sizeof(logfont));
 687     logfont.lfHeight = 12;
 688     logfont.lfWidth  = 12;
 689     logfont.lfWeight = FW_NORMAL;
 690     logfont.lfItalic = 1;
 691     lstrcpyW(logfont.lfFaceName, tahomaW);
 692
 693     hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, &logfont, &font);
 694     ok(hr == S_OK, "got 0x%08x\n", hr);
 695
 696     hr = IDWriteFont_QueryInterface(font, &IID_IDWriteFontFace, (void**)&fontface);
 697     ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);
 698
 699 if (0) /* crashes on native */
 700     hr = IDWriteFont_CreateFontFace(font, NULL);
 701
 702     hr = IDWriteFont_CreateFontFace(font, &fontface);
 703     ok(hr == S_OK, "got 0x%08x\n", hr);
 704
 705     hr = IDWriteFont_CreateFontFace(font, &fontface2);
 706     ok(hr == S_OK, "got 0x%08x\n", hr);
 707     ok(fontface == fontface2, "got %p, was %p\n", fontface2, fontface);
 708     /* the fontface refcount is increased here */
 709     IDWriteFontFace_Release(fontface);
 710     IDWriteFont_Release(font);
 711
 712     hr = IDWriteFontFace_QueryInterface(fontface, &IID_IDWriteFont, (void**)&font);
 713     ok(hr == E_NOINTERFACE || broken(hr == E_NOTIMPL), "got 0x%08x\n", hr);
 714
 715     IDWriteFontFace_Release(fontface);
 716     IDWriteGdiInterop_Release(interop);
 717 }
 718
 719 static void test_GetMetrics(void)
 720 {
 721     IDWriteGdiInterop *interop;
 722     DWRITE_FONT_METRICS metrics;
 723     OUTLINETEXTMETRICW otm;
 724     IDWriteFont *font;
 725     LOGFONTW logfont;
 726     HRESULT hr;
 727     HDC hdc;
 728     HFONT hfont;
 729     int ret;
 730
 731     hr = IDWriteFactory_GetGdiInterop(factory, &interop);
 732     EXPECT_HR(hr, S_OK);
 733
 734     memset(&logfont, 0, sizeof(logfont));
 735     logfont.lfHeight = 12;
 736     logfont.lfWidth  = 12;
 737     logfont.lfWeight = FW_NORMAL;
 738     logfont.lfItalic = 1;
 739     lstrcpyW(logfont.lfFaceName, tahomaW);
 740
 741     hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, &logfont, &font);
 742     ok(hr == S_OK, "got 0x%08x\n", hr);
 743
 744     hfont = CreateFontIndirectW(&logfont);
 745     hdc = CreateCompatibleDC(0);
 746     SelectObject(hdc, hfont);
 747
 748     otm.otmSize = sizeof(otm);
 749     ret = GetOutlineTextMetricsW(hdc, otm.otmSize, &otm);
 750     ok(ret, "got %d\n", ret);
 751     DeleteDC(hdc);
 752     DeleteObject(hfont);
 753
 754 if (0) /* crashes on native */
 755     IDWriteFont_GetMetrics(font, NULL);
 756
 757     memset(&metrics, 0, sizeof(metrics));
 758     IDWriteFont_GetMetrics(font, &metrics);
 759
 760     ok(metrics.designUnitsPerEm != 0, "designUnitsPerEm %u\n", metrics.designUnitsPerEm);
 761     ok(metrics.ascent != 0, "ascent %u\n", metrics.ascent);
 762     ok(metrics.descent != 0, "descent %u\n", metrics.descent);
 763 todo_wine
 764     ok(metrics.lineGap == 0, "lineGap %d\n", metrics.lineGap);
 765     ok(metrics.capHeight, "capHeight %u\n", metrics.capHeight);
 766     ok(metrics.xHeight != 0, "xHeight %u\n", metrics.xHeight);
 767     ok(metrics.underlinePosition < 0, "underlinePosition %d\n", metrics.underlinePosition);
 768     ok(metrics.underlineThickness != 0, "underlineThickness %u\n", metrics.underlineThickness);
 769     ok(metrics.strikethroughPosition > 0, "strikethroughPosition %d\n", metrics.strikethroughPosition);
 770     ok(metrics.strikethroughThickness != 0, "strikethroughThickness %u\n", metrics.strikethroughThickness);
 771
 772     IDWriteFont_Release(font);
 773     IDWriteGdiInterop_Release(interop);
 774 }
 775
 776 static void test_system_fontcollection(void)
 777 {
 778     IDWriteFontCollection *collection, *coll2;
 779     IDWriteFontFamily *family;
 780     IDWriteFactory *factory2;
 781     HRESULT hr;
 782     UINT32 i;
 783     BOOL ret;
 784
 785     hr = IDWriteFactory_GetSystemFontCollection(factory, &collection, FALSE);
 786     ok(hr == S_OK, "got 0x%08x\n", hr);
 787
 788     hr = IDWriteFactory_GetSystemFontCollection(factory, &coll2, FALSE);
 789     ok(hr == S_OK, "got 0x%08x\n", hr);
 790     ok(coll2 == collection, "got %p, was %p\n", coll2, collection);
 791     IDWriteFontCollection_Release(coll2);
 792
 793     hr = IDWriteFactory_GetSystemFontCollection(factory, &coll2, TRUE);
 794     ok(hr == S_OK, "got 0x%08x\n", hr);
 795     ok(coll2 == collection, "got %p, was %p\n", coll2, collection);
 796     IDWriteFontCollection_Release(coll2);
 797
 798     hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_ISOLATED, &IID_IDWriteFactory, (IUnknown**)&factory2);
 799     ok(hr == S_OK, "got 0x%08x\n", hr);
 800     hr = IDWriteFactory_GetSystemFontCollection(factory2, &coll2, FALSE);
 801     ok(hr == S_OK, "got 0x%08x\n", hr);
 802     ok(coll2 != collection, "got %p, was %p\n", coll2, collection);
 803     IDWriteFontCollection_Release(coll2);
 804     IDWriteFactory_Release(factory2);
 805
 806     i = IDWriteFontCollection_GetFontFamilyCount(collection);
 807     ok(i, "got %u\n", i);
 808
 809     /* invalid index */
 810     family = (void*)0xdeadbeef;
 811     hr = IDWriteFontCollection_GetFontFamily(collection, i, &family);
 812     ok(hr == E_FAIL, "got 0x%08x\n", hr);
 813     ok(family == NULL, "got %p\n", family);
 814
 815     ret = FALSE;
 816     i = (UINT32)-1;
 817     hr = IDWriteFontCollection_FindFamilyName(collection, tahomaW, &i, &ret);
 818     ok(hr == S_OK, "got 0x%08x\n", hr);
 819     ok(ret, "got %d\n", ret);
 820     ok(i != (UINT32)-1, "got %u\n", i);
 821
 822     ret = TRUE;
 823     i = 0;
 824     hr = IDWriteFontCollection_FindFamilyName(collection, blahW, &i, &ret);
 825     ok(hr == S_OK, "got 0x%08x\n", hr);
 826     ok(!ret, "got %d\n", ret);
 827     ok(i == (UINT32)-1, "got %u\n", i);
 828
 829     IDWriteFontCollection_Release(collection);
 830 }
 831
 832 static void test_ConvertFontFaceToLOGFONT(void)
 833 {
 834     IDWriteGdiInterop *interop;
 835     IDWriteFontFace *fontface;
 836     IDWriteFont *font;
 837     LOGFONTW logfont;
 838     HRESULT hr;
 839
 840     hr = IDWriteFactory_GetGdiInterop(factory, &interop);
 841     ok(hr == S_OK, "got 0x%08x\n", hr);
 842
 843     memset(&logfont, 0, sizeof(logfont));
 844     logfont.lfHeight = 12;
 845     logfont.lfWidth  = 12;
 846     logfont.lfEscapement = 100;
 847     logfont.lfWeight = FW_NORMAL;
 848     logfont.lfItalic = 1;
 849     logfont.lfUnderline = 1;
 850     logfont.lfStrikeOut = 1;
 851
 852     lstrcpyW(logfont.lfFaceName, tahomaW);
 853
 854     hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop, &logfont, &font);
 855     ok(hr == S_OK, "got 0x%08x\n", hr);
 856
 857     hr = IDWriteFont_CreateFontFace(font, &fontface);
 858     ok(hr == S_OK, "got 0x%08x\n", hr);
 859     IDWriteFont_Release(font);
 860
 861 if (0) /* crashes on native */
 862 {
 863     hr = IDWriteGdiInterop_ConvertFontFaceToLOGFONT(interop, NULL, NULL);
 864     hr = IDWriteGdiInterop_ConvertFontFaceToLOGFONT(interop, fontface, NULL);
 865 }
 866
 867     memset(&logfont, 0xa, sizeof(logfont));
 868     logfont.lfFaceName[0] = 0;
 869
 870     hr = IDWriteGdiInterop_ConvertFontFaceToLOGFONT(interop, fontface, &logfont);
 871     ok(hr == S_OK, "got 0x%08x\n", hr);
 872     ok(logfont.lfHeight == 0, "got %d\n", logfont.lfHeight);
 873     ok(logfont.lfWidth == 0, "got %d\n", logfont.lfWidth);
 874     ok(logfont.lfWeight == FW_NORMAL, "got %d\n", logfont.lfWeight);
 875     ok(logfont.lfEscapement == 0, "got %d\n", logfont.lfEscapement);
 876     ok(logfont.lfItalic == 1, "got %d\n", logfont.lfItalic);
 877     ok(logfont.lfUnderline == 0, "got %d\n", logfont.lfUnderline);
 878     ok(logfont.lfStrikeOut == 0, "got %d\n", logfont.lfStrikeOut);
 879     ok(!lstrcmpW(logfont.lfFaceName, tahomaW), "got %s\n", wine_dbgstr_w(logfont.lfFaceName));
 880
 881     IDWriteGdiInterop_Release(interop);
 882     IDWriteFontFace_Release(fontface);
 883 }
 884
 885 static HRESULT WINAPI fontcollectionloader_QueryInterface(IDWriteFontCollectionLoader *iface, REFIID riid, void **obj)
 886 {
 887     *obj = iface;
 888     return S_OK;
 889 }
 890
 891 static ULONG WINAPI fontcollectionloader_AddRef(IDWriteFontCollectionLoader *iface)
 892 {
 893     return 2;
 894 }
 895
 896 static ULONG WINAPI fontcollectionloader_Release(IDWriteFontCollectionLoader *iface)
 897 {
 898     return 1;
 899 }
 900
 901 static HRESULT WINAPI fontcollectionloader_CreateEnumeratorFromKey(IDWriteFontCollectionLoader *iface, IDWriteFactory * factory, const void * collectionKey, UINT32  collectionKeySize, IDWriteFontFileEnumerator ** fontFileEnumerator)
 902 {
 903     return S_OK;
 904 }
 905
 906 static const struct IDWriteFontCollectionLoaderVtbl dwritefontcollectionloadervtbl = {
 907     fontcollectionloader_QueryInterface,
 908     fontcollectionloader_AddRef,
 909     fontcollectionloader_Release,
 910     fontcollectionloader_CreateEnumeratorFromKey
 911 };
 912
 913 static void test_CustomFontCollection(void)
 914 {
 915     IDWriteFontCollectionLoader collection = { &dwritefontcollectionloadervtbl };
 916     IDWriteFontCollectionLoader collection2 = { &dwritefontcollectionloadervtbl };
 917     HRESULT hr;
 918
 919     hr = IDWriteFactory_RegisterFontCollectionLoader(factory, NULL);
 920     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 921
 922     hr = IDWriteFactory_UnregisterFontCollectionLoader(factory, NULL);
 923     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 924
 925     hr = IDWriteFactory_RegisterFontCollectionLoader(factory, &collection);
 926     ok(hr == S_OK, "got 0x%08x\n", hr);
 927     hr = IDWriteFactory_RegisterFontCollectionLoader(factory, &collection2);
 928     ok(hr == S_OK, "got 0x%08x\n", hr);
 929     hr = IDWriteFactory_RegisterFontCollectionLoader(factory, &collection);
 930     ok(hr == DWRITE_E_ALREADYREGISTERED, "got 0x%08x\n", hr);
 931
 932     hr = IDWriteFactory_UnregisterFontCollectionLoader(factory, &collection);
 933     ok(hr == S_OK, "got 0x%08x\n", hr);
 934     hr = IDWriteFactory_UnregisterFontCollectionLoader(factory, &collection);
 935     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 936     hr = IDWriteFactory_UnregisterFontCollectionLoader(factory, &collection2);
 937     ok(hr == S_OK, "got 0x%08x\n", hr);
 938 }
 939
 940 static HRESULT WINAPI fontfileloader_QueryInterface(IDWriteFontFileLoader *iface, REFIID riid, void **obj)
 941 {
 942     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDWriteFontFileLoader))
 943     {
 944         *obj = iface;
 945         IDWriteFontFileLoader_AddRef(iface);
 946         return S_OK;
 947     }
 948
 949     *obj = NULL;
 950     return E_NOINTERFACE;
 951 }
 952
 953 static ULONG WINAPI fontfileloader_AddRef(IDWriteFontFileLoader *iface)
 954 {
 955     return 2;
 956 }
 957
 958 static ULONG WINAPI fontfileloader_Release(IDWriteFontFileLoader *iface)
 959 {
 960     return 1;
 961 }
 962
 963 static HRESULT WINAPI fontfileloader_CreateStreamFromKey(IDWriteFontFileLoader *iface, const void *fontFileReferenceKey, UINT32 fontFileReferenceKeySize, IDWriteFontFileStream **fontFileStream)
 964 {
 965     return 0x8faecafe;
 966 }
 967
 968 static const struct IDWriteFontFileLoaderVtbl dwritefontfileloadervtbl = {
 969     fontfileloader_QueryInterface,
 970     fontfileloader_AddRef,
 971     fontfileloader_Release,
 972     fontfileloader_CreateStreamFromKey
 973 };
 974
 975 static void test_FontLoader(void)
 976 {
 977     IDWriteFontFileLoader floader = { &dwritefontfileloadervtbl };
 978     IDWriteFontFileLoader floader2 = { &dwritefontfileloadervtbl };
 979     IDWriteFontFileLoader floader3 = { &dwritefontfileloadervtbl };
 980     IDWriteFontFile *ffile = NULL;
 981     BOOL support = 1;
 982     DWRITE_FONT_FILE_TYPE type = 1;
 983     DWRITE_FONT_FACE_TYPE face = 1;
 984     UINT32 count = 1;
 985     IDWriteFontFace *fface = NULL;
 986     HRESULT hr;
 987     HRSRC font;
 988     UINT32 codePoints[1] = {0xa8};
 989     UINT16 indices[1];
 990
 991     hr = IDWriteFactory_RegisterFontFileLoader(factory, NULL);
 992     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 993     hr = IDWriteFactory_RegisterFontFileLoader(factory, &floader);
 994     ok(hr == S_OK, "got 0x%08x\n", hr);
 995     hr = IDWriteFactory_RegisterFontFileLoader(factory, &floader2);
 996     ok(hr == S_OK, "got 0x%08x\n", hr);
 997     hr = IDWriteFactory_RegisterFontFileLoader(factory, &floader);
 998     ok(hr == DWRITE_E_ALREADYREGISTERED, "got 0x%08x\n", hr);
 999     hr = IDWriteFactory_RegisterFontFileLoader(factory, &rloader);
1000     ok(hr == S_OK, "got 0x%08x\n", hr);
1001
1002     hr = IDWriteFactory_CreateCustomFontFileReference(factory, "test", 4, &floader, &ffile);
1003     ok(hr == S_OK, "got 0x%08x\n", hr);
1004     if (SUCCEEDED(hr))
1005         IDWriteFontFile_Release(ffile);
1006
1007     hr = IDWriteFactory_CreateCustomFontFileReference(factory, "test", 4, &floader3, &ffile);
1008     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1009     if (SUCCEEDED(hr))
1010         IDWriteFontFile_Release(ffile);
1011
1012     hr = IDWriteFactory_CreateCustomFontFileReference(factory, "test", 4, NULL, &ffile);
1013     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1014     if (SUCCEEDED(hr))
1015         IDWriteFontFile_Release(ffile);
1016
1017     hr = IDWriteFactory_CreateCustomFontFileReference(factory, "test", 4, &floader, &ffile);
1018     ok(hr == S_OK, "got 0x%08x\n", hr);
1019     IDWriteFontFile_Analyze(ffile, &support, &type, &face, &count);
1020     ok(hr == S_OK, "got 0x%08x\n", hr);
1021     ok(support == FALSE, "got %i\n", support);
1022     ok(type == DWRITE_FONT_FILE_TYPE_UNKNOWN, "got %i\n", type);
1023     ok(face == DWRITE_FONT_FACE_TYPE_UNKNOWN, "got %i\n", face);
1024     ok(count == 0, "got %i\n", count);
1025
1026     hr = IDWriteFactory_CreateFontFace(factory, DWRITE_FONT_FACE_TYPE_CFF, 1, &ffile, 0, 0, &fface);
1027     ok(hr == 0x8faecafe, "got 0x%08x\n", hr);
1028     IDWriteFontFile_Release(ffile);
1029
1030     font = FindResourceA(GetModuleHandleA(NULL), (LPCSTR)MAKEINTRESOURCE(1), (LPCSTR)RT_RCDATA);
1031     ok(font != NULL, "Failed to find font resource\n");
1032     if (font)
1033     {
1034         hr = IDWriteFactory_CreateCustomFontFileReference(factory, &font, sizeof(HRSRC), &rloader, &ffile);
1035         ok(hr == S_OK, "got 0x%08x\n", hr);
1036
1037         hr = IDWriteFontFile_Analyze(ffile, &support, &type, &face, &count);
1038         ok(hr == S_OK, "got 0x%08x\n", hr);
1039         ok(support == TRUE, "got %i\n", support);
1040         ok(type == DWRITE_FONT_FILE_TYPE_TRUETYPE, "got %i\n", type);
1041         ok(face == DWRITE_FONT_FACE_TYPE_TRUETYPE, "got %i\n", face);
1042         ok(count == 1, "got %i\n", count);
1043
1044         /* invalid index */
1045         hr = IDWriteFactory_CreateFontFace(factory, face, 1, &ffile, 1, DWRITE_FONT_SIMULATIONS_NONE, &fface);
1046         ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1047
1048         hr = IDWriteFactory_CreateFontFace(factory, face, 1, &ffile, 0, DWRITE_FONT_SIMULATIONS_NONE, &fface);
1049         ok(hr == S_OK, "got 0x%08x\n", hr);
1050         hr = IDWriteFontFace_GetGlyphIndices(fface, codePoints, 1, indices);
1051         ok(hr == S_OK, "got 0x%08x\n", hr);
1052         ok(indices[0] == 6, "got index %i\n",indices[0]);
1053         IDWriteFontFace_Release(fface);
1054         IDWriteFontFile_Release(ffile);
1055     }
1056
1057     hr = IDWriteFactory_UnregisterFontFileLoader(factory, &floader);
1058     ok(hr == S_OK, "got 0x%08x\n", hr);
1059     hr = IDWriteFactory_UnregisterFontFileLoader(factory, &floader);
1060     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1061     hr = IDWriteFactory_UnregisterFontFileLoader(factory, &floader2);
1062     ok(hr == S_OK, "got 0x%08x\n", hr);
1063     hr = IDWriteFactory_UnregisterFontFileLoader(factory, &rloader);
1064     ok(hr == S_OK, "got 0x%08x\n", hr);
1065 }
1066
1067 static void test_CreateFontFileReference(void)
1068 {
1069     DWORD written;
1070     HANDLE file;
1071     HRSRC res;
1072     void *ptr;
1073     HRESULT hr;
1074     WCHAR font_name[] = {'w','i','n','e','_','t','e','s','t','_','f','o','n','t','.','t','t','f',0};
1075     IDWriteFontFile *ffile = NULL;
1076     BOOL support = 1;
1077     DWRITE_FONT_FILE_TYPE type = 1;
1078     DWRITE_FONT_FACE_TYPE face = 1;
1079     UINT32 count = 1;
1080     IDWriteFontFace *fface = NULL;
1081
1082     file = CreateFileW(font_name, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
1083     ok( file != INVALID_HANDLE_VALUE, "file creation failed\n" );
1084     if (file == INVALID_HANDLE_VALUE) return;
1085
1086     res = FindResourceA(GetModuleHandleA(NULL), (LPCSTR)MAKEINTRESOURCE(1), (LPCSTR)RT_RCDATA);
1087     ok( res != 0, "couldn't find resource\n" );
1088     ptr = LockResource( LoadResource( GetModuleHandleA(NULL), res ));
1089     WriteFile( file, ptr, SizeofResource( GetModuleHandleA(NULL), res ), &written, NULL );
1090     ok( written == SizeofResource( GetModuleHandleA(NULL), res ), "couldn't write resource\n" );
1091     CloseHandle( file );
1092
1093     hr = IDWriteFactory_CreateFontFileReference(factory, font_name, NULL, &ffile);
1094     ok(hr == S_OK, "got 0x%08x\n",hr);
1095
1096     IDWriteFontFile_Analyze(ffile, &support, &type, &face, &count);
1097     ok(hr == S_OK, "got 0x%08x\n", hr);
1098     ok(support == TRUE, "got %i\n", support);
1099     ok(type == DWRITE_FONT_FILE_TYPE_TRUETYPE, "got %i\n", type);
1100     ok(face == DWRITE_FONT_FACE_TYPE_TRUETYPE, "got %i\n", face);
1101     ok(count == 1, "got %i\n", count);
1102
1103     hr = IDWriteFactory_CreateFontFace(factory, face, 1, &ffile, 0, 0, &fface);
1104     ok(hr == S_OK, "got 0x%08x\n",hr);
1105
1106     IDWriteFontFace_Release(fface);
1107     IDWriteFontFile_Release(ffile);
1108
1109     DeleteFileW(font_name);
1110 }
1111
1112 static void test_shared_isolated(void)
1113 {
1114     IDWriteFactory *isolated, *isolated2;
1115     IDWriteFactory *shared, *shared2;
1116     HRESULT hr;
1117
1118     /* invalid type */
1119     shared = NULL;
1120     hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED+1, &IID_IDWriteFactory, (IUnknown**)&shared);
1121     ok(hr == S_OK, "got 0x%08x\n", hr);
1122     ok(shared != NULL, "got %p\n", shared);
1123     IDWriteFactory_Release(shared);
1124
1125     hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, &IID_IDWriteFactory, (IUnknown**)&shared);
1126     ok(hr == S_OK, "got 0x%08x\n", hr);
1127
1128     hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, &IID_IDWriteFactory, (IUnknown**)&shared2);
1129     ok(hr == S_OK, "got 0x%08x\n", hr);
1130     ok(shared == shared2, "got %p, and %p\n", shared, shared2);
1131
1132     IDWriteFactory_Release(shared);
1133     IDWriteFactory_Release(shared2);
1134
1135     /* we got 2 references, released 2 - still same pointer is returned */
1136     hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, &IID_IDWriteFactory, (IUnknown**)&shared2);
1137     ok(hr == S_OK, "got 0x%08x\n", hr);
1138     ok(shared == shared2, "got %p, and %p\n", shared, shared2);
1139     IDWriteFactory_Release(shared2);
1140
1141     hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_ISOLATED, &IID_IDWriteFactory, (IUnknown**)&isolated);
1142     ok(hr == S_OK, "got 0x%08x\n", hr);
1143
1144     hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_ISOLATED, &IID_IDWriteFactory, (IUnknown**)&isolated2);
1145     ok(hr == S_OK, "got 0x%08x\n", hr);
1146     ok(isolated != isolated2, "got %p, and %p\n", isolated, isolated2);
1147     IDWriteFactory_Release(isolated2);
1148
1149     hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED+1, &IID_IDWriteFactory, (IUnknown**)&isolated2);
1150     ok(hr == S_OK, "got 0x%08x\n", hr);
1151     ok(shared != isolated2, "got %p, and %p\n", shared, isolated2);
1152
1153     IDWriteFactory_Release(isolated);
1154     IDWriteFactory_Release(isolated2);
1155 }
1156
1157 static void test_GetUnicodeRanges(void)
1158 {
1159     DWRITE_UNICODE_RANGE *ranges, r;
1160     IDWriteFontFile *ffile = NULL;
1161     IDWriteFontFace1 *fontface1;
1162     IDWriteFontFace *fontface;
1163     UINT32 count;
1164     HRESULT hr;
1165     HRSRC font;
1166
1167     hr = IDWriteFactory_RegisterFontFileLoader(factory, &rloader);
1168     ok(hr == S_OK, "got 0x%08x\n", hr);
1169
1170     font = FindResourceA(GetModuleHandleA(NULL), (LPCSTR)MAKEINTRESOURCE(1), (LPCSTR)RT_RCDATA);
1171     ok(font != NULL, "Failed to find font resource\n");
1172
1173     hr = IDWriteFactory_CreateCustomFontFileReference(factory, &font, sizeof(HRSRC), &rloader, &ffile);
1174     ok(hr == S_OK, "got 0x%08x\n", hr);
1175
1176     hr = IDWriteFactory_CreateFontFace(factory, DWRITE_FONT_FACE_TYPE_TRUETYPE, 1, &ffile, 0, DWRITE_FONT_SIMULATIONS_NONE, &fontface);
1177     ok(hr == S_OK, "got 0x%08x\n", hr);
1178     IDWriteFontFile_Release(ffile);
1179
1180     hr = IDWriteFontFace_QueryInterface(fontface, &IID_IDWriteFontFace1, (void**)&fontface1);
1181     IDWriteFontFace_Release(fontface);
1182     if (hr != S_OK) {
1183         win_skip("GetUnicodeRanges() is not supported.\n");
1184         return;
1185     }
1186
1187     count = 0;
1188     hr = IDWriteFontFace1_GetUnicodeRanges(fontface1, 0, NULL, &count);
1189     ok(hr == E_NOT_SUFFICIENT_BUFFER, "got 0x%08x\n", hr);
1190     ok(count > 0, "got %u\n", count);
1191
1192     count = 1;
1193     hr = IDWriteFontFace1_GetUnicodeRanges(fontface1, 1, NULL, &count);
1194     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1195     ok(count == 0, "got %u\n", count);
1196
1197     count = 0;
1198     hr = IDWriteFontFace1_GetUnicodeRanges(fontface1, 1, &r, &count);
1199     ok(hr == E_NOT_SUFFICIENT_BUFFER, "got 0x%08x\n", hr);
1200     ok(count > 1, "got %u\n", count);
1201
1202     ranges = heap_alloc(count*sizeof(DWRITE_UNICODE_RANGE));
1203     hr = IDWriteFontFace1_GetUnicodeRanges(fontface1, count, ranges, &count);
1204     ok(hr == S_OK, "got 0x%08x\n", hr);
1205
1206     ranges[0].first = ranges[0].last = 0;
1207     hr = IDWriteFontFace1_GetUnicodeRanges(fontface1, 1, ranges, &count);
1208     ok(hr == E_NOT_SUFFICIENT_BUFFER, "got 0x%08x\n", hr);
1209     ok(ranges[0].first != 0 && ranges[0].last != 0, "got 0x%x-0x%0x\n", ranges[0].first, ranges[0].last);
1210
1211     heap_free(ranges);
1212
1213     hr = IDWriteFactory_UnregisterFontFileLoader(factory, &rloader);
1214     ok(hr == S_OK, "got 0x%08x\n", hr);
1215
1216     IDWriteFontFace1_Release(fontface1);
1217 }
1218
1219 static void test_GetFontFromFontFace(void)
1220 {
1221     IDWriteFontFace *fontface, *fontface2;
1222     IDWriteFontCollection *collection;
1223     IDWriteFont *font, *font2, *font3;
1224     IDWriteFontFamily *family;
1225     HRESULT hr;
1226
1227     hr = IDWriteFactory_GetSystemFontCollection(factory, &collection, FALSE);
1228     ok(hr == S_OK, "got 0x%08x\n", hr);
1229
1230     hr = IDWriteFontCollection_GetFontFamily(collection, 0, &family);
1231     ok(hr == S_OK, "got 0x%08x\n", hr);
1232
1233     hr = IDWriteFontFamily_GetFirstMatchingFont(family, DWRITE_FONT_WEIGHT_NORMAL,
1234         DWRITE_FONT_STRETCH_NORMAL, DWRITE_FONT_STYLE_NORMAL, &font);
1235     ok(hr == S_OK, "got 0x%08x\n", hr);
1236
1237     hr = IDWriteFont_CreateFontFace(font, &fontface);
1238     ok(hr == S_OK, "got 0x%08x\n", hr);
1239
1240     font2 = NULL;
1241     hr = IDWriteFontCollection_GetFontFromFontFace(collection, fontface, &font2);
1242 todo_wine
1243     ok(hr == S_OK, "got 0x%08x\n", hr);
1244     ok(font2 != font, "got %p, %p\n", font2, font);
1245
1246     font3 = NULL;
1247     hr = IDWriteFontCollection_GetFontFromFontFace(collection, fontface, &font3);
1248 todo_wine {
1249     ok(hr == S_OK, "got 0x%08x\n", hr);
1250     ok(font3 != font && font3 != font2, "got %p, %p, %p\n", font3, font2, font);
1251 }
1252
1253 if (font2) {
1254     hr = IDWriteFont_CreateFontFace(font2, &fontface2);
1255     ok(hr == S_OK, "got 0x%08x\n", hr);
1256     ok(fontface2 == fontface, "got %p, %p\n", fontface2, fontface);
1257     IDWriteFontFace_Release(fontface2);
1258 }
1259
1260 if (font3) {
1261     hr = IDWriteFont_CreateFontFace(font3, &fontface2);
1262     ok(hr == S_OK, "got 0x%08x\n", hr);
1263     ok(fontface2 == fontface, "got %p, %p\n", fontface2, fontface);
1264     IDWriteFontFace_Release(fontface2);
1265 }
1266
1267 if (font)
1268     IDWriteFont_Release(font);
1269 if (font2)
1270     IDWriteFont_Release(font2);
1271 if (font3)
1272     IDWriteFont_Release(font3);
1273     IDWriteFontFace_Release(fontface);
1274     IDWriteFontFamily_Release(family);
1275     IDWriteFontCollection_Release(collection);
1276 }
1277
1278 static void test_GetFirstMatchingFont(void)
1279 {
1280     IDWriteFontCollection *collection;
1281     IDWriteFont *font, *font2;
1282     IDWriteFontFamily *family;
1283     HRESULT hr;
1284
1285     hr = IDWriteFactory_GetSystemFontCollection(factory, &collection, FALSE);
1286     ok(hr == S_OK, "got 0x%08x\n", hr);
1287
1288     hr = IDWriteFontCollection_GetFontFamily(collection, 0, &family);
1289     ok(hr == S_OK, "got 0x%08x\n", hr);
1290
1291     hr = IDWriteFontFamily_GetFirstMatchingFont(family, DWRITE_FONT_WEIGHT_NORMAL,
1292         DWRITE_FONT_STRETCH_NORMAL, DWRITE_FONT_STYLE_NORMAL, &font);
1293     ok(hr == S_OK, "got 0x%08x\n", hr);
1294
1295     hr = IDWriteFontFamily_GetFirstMatchingFont(family, DWRITE_FONT_WEIGHT_NORMAL,
1296         DWRITE_FONT_STRETCH_NORMAL, DWRITE_FONT_STYLE_NORMAL, &font2);
1297     ok(hr == S_OK, "got 0x%08x\n", hr);
1298     ok(font != font2, "got %p, %p\n", font, font2);
1299
1300     IDWriteFont_Release(font);
1301     IDWriteFont_Release(font2);
1302     IDWriteFontFamily_Release(family);
1303     IDWriteFontCollection_Release(collection);
1304 }
1305
1306 static void test_GetInformationalStrings(void)
1307 {
1308     IDWriteLocalizedStrings *strings, *strings2;
1309     IDWriteFontCollection *collection;
1310     IDWriteFontFamily *family;
1311     IDWriteFont *font;
1312     BOOL exists;
1313     HRESULT hr;
1314
1315     hr = IDWriteFactory_GetSystemFontCollection(factory, &collection, FALSE);
1316     ok(hr == S_OK, "got 0x%08x\n", hr);
1317
1318     hr = IDWriteFontCollection_GetFontFamily(collection, 0, &family);
1319     ok(hr == S_OK, "got 0x%08x\n", hr);
1320
1321     hr = IDWriteFontFamily_GetFirstMatchingFont(family, DWRITE_FONT_WEIGHT_NORMAL,
1322         DWRITE_FONT_STRETCH_NORMAL, DWRITE_FONT_STYLE_NORMAL, &font);
1323     ok(hr == S_OK, "got 0x%08x\n", hr);
1324
1325     exists = TRUE;
1326     strings = (void*)0xdeadbeef;
1327     hr = IDWriteFont_GetInformationalStrings(font, DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_CID_NAME+1, &strings, &exists);
1328 todo_wine {
1329     ok(hr == S_OK, "got 0x%08x\n", hr);
1330     ok(exists == FALSE, "got %d\n", exists);
1331     ok(strings == NULL, "got %p\n", strings);
1332 }
1333     exists = FALSE;
1334     strings = NULL;
1335     hr = IDWriteFont_GetInformationalStrings(font, DWRITE_INFORMATIONAL_STRING_WIN32_FAMILY_NAMES, &strings, &exists);
1336 todo_wine {
1337     ok(hr == S_OK, "got 0x%08x\n", hr);
1338     ok(exists == TRUE, "got %d\n", exists);
1339 }
1340
1341     exists = TRUE;
1342     strings = NULL;
1343     hr = IDWriteFont_GetInformationalStrings(font, DWRITE_INFORMATIONAL_STRING_NONE, &strings, &exists);
1344 todo_wine {
1345     ok(hr == S_OK, "got 0x%08x\n", hr);
1346     ok(exists == FALSE, "got %d\n", exists);
1347 }
1348
1349     /* strings instance is not reused */
1350     strings2 = NULL;
1351     hr = IDWriteFont_GetInformationalStrings(font, DWRITE_INFORMATIONAL_STRING_WIN32_FAMILY_NAMES, &strings2, &exists);
1352 todo_wine {
1353     ok(hr == S_OK, "got 0x%08x\n", hr);
1354     ok(strings2 != strings, "got %p, %p\n", strings2, strings);
1355 }
1356
1357 if (strings)
1358     IDWriteLocalizedStrings_Release(strings);
1359 if (strings2)
1360     IDWriteLocalizedStrings_Release(strings2);
1361     IDWriteFont_Release(font);
1362     IDWriteFontFamily_Release(family);
1363     IDWriteFontCollection_Release(collection);
1364 }
1365
1366 static void test_GetGdiInterop(void)
1367 {
1368     IDWriteGdiInterop *interop, *interop2;
1369     IDWriteFactory *factory2;
1370     IDWriteFont *font;
1371     LOGFONTW logfont;
1372     HRESULT hr;
1373
1374     interop = NULL;
1375     hr = IDWriteFactory_GetGdiInterop(factory, &interop);
1376     ok(hr == S_OK, "got 0x%08x\n", hr);
1377
1378     interop2 = NULL;
1379     hr = IDWriteFactory_GetGdiInterop(factory, &interop2);
1380     ok(hr == S_OK, "got 0x%08x\n", hr);
1381     ok(interop == interop2, "got %p, %p\n", interop, interop2);
1382     IDWriteGdiInterop_Release(interop2);
1383
1384     hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_ISOLATED, &IID_IDWriteFactory, (IUnknown**)&factory2);
1385     ok(hr == S_OK, "got 0x%08x\n", hr);
1386
1387     /* each factory gets its own interop */
1388     interop2 = NULL;
1389     hr = IDWriteFactory_GetGdiInterop(factory2, &interop2);
1390     ok(hr == S_OK, "got 0x%08x\n", hr);
1391     ok(interop != interop2, "got %p, %p\n", interop, interop2);
1392
1393     /* release factory - interop still works */
1394     IDWriteFactory_Release(factory2);
1395
1396     memset(&logfont, 0, sizeof(logfont));
1397     logfont.lfHeight = 12;
1398     logfont.lfWidth  = 12;
1399     logfont.lfWeight = FW_NORMAL;
1400     logfont.lfItalic = 1;
1401     lstrcpyW(logfont.lfFaceName, tahomaW);
1402
1403     hr = IDWriteGdiInterop_CreateFontFromLOGFONT(interop2, &logfont, &font);
1404     ok(hr == S_OK, "got 0x%08x\n", hr);
1405
1406     IDWriteGdiInterop_Release(interop2);
1407     IDWriteGdiInterop_Release(interop);
1408 }
1409
1410 static void test_CreateFontFaceFromHdc(void)
1411 {
1412     IDWriteGdiInterop *interop;
1413     IDWriteFontFace *fontface;
1414     HFONT hfont, oldhfont;
1415     LOGFONTW logfont;
1416     HRESULT hr;
1417     HDC hdc;
1418
1419     interop = NULL;
1420     hr = IDWriteFactory_GetGdiInterop(factory, &interop);
1421     ok(hr == S_OK, "got 0x%08x\n", hr);
1422
1423     hr = IDWriteGdiInterop_CreateFontFaceFromHdc(interop, NULL, &fontface);
1424     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1425
1426     memset(&logfont, 0, sizeof(logfont));
1427     logfont.lfHeight = 12;
1428     logfont.lfWidth  = 12;
1429     logfont.lfWeight = FW_NORMAL;
1430     logfont.lfItalic = 1;
1431     lstrcpyW(logfont.lfFaceName, tahomaW);
1432
1433     hfont = CreateFontIndirectW(&logfont);
1434     hdc = CreateCompatibleDC(0);
1435     oldhfont = SelectObject(hdc, hfont);
1436
1437     fontface = NULL;
1438     hr = IDWriteGdiInterop_CreateFontFaceFromHdc(interop, hdc, &fontface);
1439     ok(hr == S_OK, "got 0x%08x\n", hr);
1440     IDWriteFontFace_Release(fontface);
1441     DeleteObject(SelectObject(hdc, oldhfont));
1442     DeleteDC(hdc);
1443
1444     IDWriteGdiInterop_Release(interop);
1445 }
1446
1447 START_TEST(font)
1448 {
1449     HRESULT hr;
1450
1451     hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_ISOLATED, &IID_IDWriteFactory, (IUnknown**)&factory);
1452     ok(hr == S_OK, "got 0x%08x\n", hr);
1453     if (hr != S_OK)
1454     {
1455         win_skip("failed to create factory\n");
1456         return;
1457     }
1458
1459     test_CreateFontFromLOGFONT();
1460     test_CreateBitmapRenderTarget();
1461     test_GetFontFamily();
1462     test_GetFamilyNames();
1463     test_CreateFontFace();
1464     test_GetMetrics();
1465     test_system_fontcollection();
1466     test_ConvertFontFaceToLOGFONT();
1467     test_CustomFontCollection();
1468     test_FontLoader();
1469     test_CreateFontFileReference();
1470     test_shared_isolated();
1471     test_GetUnicodeRanges();
1472     test_GetFontFromFontFace();
1473     test_GetFirstMatchingFont();
1474     test_GetInformationalStrings();
1475     test_GetGdiInterop();
1476     test_CreateFontFaceFromHdc();
1477
1478     IDWriteFactory_Release(factory);
1479 }