rostests/winetests/gdiplus/font.c

   1 /*
   2  * Unit test suite for fonts
   3  *
   4  * Copyright (C) 2007 Google (Evan Stade)
   5  * Copyright (C) 2012 Dmitry Timoshkov
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <math.h>
  23
  24 #define WIN32_NO_STATUS
  25 #define _INC_WINDOWS
  26 #define COM_NO_WINDOWS_H
  27
  28 //#include "windows.h"
  29 #include <wine/test.h>
  30 #include <wingdi.h>
  31 #include <winnls.h>
  32 #include <objbase.h>
  33 #include <gdiplus.h>
  34
  35 #define expect(expected, got) ok(got == expected, "Expected %d, got %d\n", expected, got)
  36 #define expect_(expected, got, precision) ok(abs((expected) - (got)) <= (precision), "Expected %d, got %d\n", (expected), (got))
  37 #define expectf_(expected, got, precision) ok(fabs((expected) - (got)) <= (precision), "Expected %f, got %f\n", (expected), (got))
  38 #define expectf(expected, got) expectf_((expected), (got), 0.001)
  39
  40 static const WCHAR nonexistent[] = {'T','h','i','s','F','o','n','t','s','h','o','u','l','d','N','o','t','E','x','i','s','t','\0'};
  41 static const WCHAR MSSansSerif[] = {'M','S',' ','S','a','n','s',' ','S','e','r','i','f','\0'};
  42 static const WCHAR MicrosoftSansSerif[] = {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f','\0'};
  43 static const WCHAR TimesNewRoman[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'};
  44 static const WCHAR CourierNew[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
  45 static const WCHAR Tahoma[] = {'T','a','h','o','m','a',0};
  46 static const WCHAR LiberationSerif[] = {'L','i','b','e','r','a','t','i','o','n',' ','S','e','r','i','f',0};
  47
  48 static void set_rect_empty(RectF *rc)
  49 {
  50     rc->X = 0.0;
  51     rc->Y = 0.0;
  52     rc->Width = 0.0;
  53     rc->Height = 0.0;
  54 }
  55
  56 static void test_createfont(void)
  57 {
  58     GpFontFamily* fontfamily = NULL, *fontfamily2;
  59     GpFont* font = NULL;
  60     GpStatus stat;
  61     Unit unit;
  62     UINT i;
  63     REAL size;
  64     WCHAR familyname[LF_FACESIZE];
  65
  66     stat = GdipCreateFontFamilyFromName(nonexistent, NULL, &fontfamily);
  67     expect (FontFamilyNotFound, stat);
  68     stat = GdipDeleteFont(font);
  69     expect (InvalidParameter, stat);
  70     stat = GdipCreateFontFamilyFromName(Tahoma, NULL, &fontfamily);
  71     expect (Ok, stat);
  72     stat = GdipCreateFont(fontfamily, 12, FontStyleRegular, UnitPoint, &font);
  73     expect (Ok, stat);
  74     stat = GdipGetFontUnit (font, &unit);
  75     expect (Ok, stat);
  76     expect (UnitPoint, unit);
  77
  78     stat = GdipGetFamily(font, &fontfamily2);
  79     expect(Ok, stat);
  80     stat = GdipGetFamilyName(fontfamily2, familyname, 0);
  81     expect(Ok, stat);
  82     ok (lstrcmpiW(Tahoma, familyname) == 0, "Expected Tahoma, got %s\n",
  83             wine_dbgstr_w(familyname));
  84     stat = GdipDeleteFontFamily(fontfamily2);
  85     expect(Ok, stat);
  86
  87     /* Test to see if returned size is based on unit (its not) */
  88     GdipGetFontSize(font, &size);
  89     ok (size == 12, "Expected 12, got %f\n", size);
  90     GdipDeleteFont(font);
  91
  92     /* Make sure everything is converted correctly for all Units */
  93     for (i = UnitWorld; i <=UnitMillimeter; i++)
  94     {
  95         if (i == UnitDisplay) continue; /* Crashes WindowsXP, wtf? */
  96         GdipCreateFont(fontfamily, 24, FontStyleRegular, i, &font);
  97         GdipGetFontSize (font, &size);
  98         ok (size == 24, "Expected 24, got %f (with unit: %d)\n", size, i);
  99         GdipGetFontUnit (font, &unit);
 100         expect (i, unit);
 101         GdipDeleteFont(font);
 102     }
 103
 104     GdipDeleteFontFamily(fontfamily);
 105 }
 106
 107 #if CORE_6660_IS_FIXED
 108 static void test_logfont(void)
 109 {
 110     LOGFONTA lfa, lfa2;
 111     GpFont *font;
 112     GpFontFamily *family;
 113     GpStatus stat;
 114     GpGraphics *graphics;
 115     HDC hdc = GetDC(0);
 116     INT style;
 117     REAL rval;
 118     UINT16 em_height, line_spacing;
 119     Unit unit;
 120
 121     GdipCreateFromHDC(hdc, &graphics);
 122
 123     memset(&lfa, 0, sizeof(LOGFONTA));
 124     memset(&lfa2, 0xff, sizeof(LOGFONTA));
 125     lstrcpyA(lfa.lfFaceName, "Tahoma");
 126
 127     stat = GdipCreateFontFromLogfontA(hdc, &lfa, &font);
 128     expect(Ok, stat);
 129     stat = GdipGetLogFontA(font, graphics, &lfa2);
 130     expect(Ok, stat);
 131
 132     ok(lfa2.lfHeight < 0, "Expected negative height\n");
 133     expect(0, lfa2.lfWidth);
 134     expect(0, lfa2.lfEscapement);
 135     expect(0, lfa2.lfOrientation);
 136     ok((lfa2.lfWeight >= 100) && (lfa2.lfWeight <= 900), "Expected weight to be set\n");
 137     expect(0, lfa2.lfItalic);
 138     expect(0, lfa2.lfUnderline);
 139     expect(0, lfa2.lfStrikeOut);
 140     ok(lfa2.lfCharSet == GetTextCharset(hdc) || lfa2.lfCharSet == ANSI_CHARSET,
 141         "Expected %x or %x, got %x\n", GetTextCharset(hdc), ANSI_CHARSET, lfa2.lfCharSet);
 142     expect(0, lfa2.lfOutPrecision);
 143     expect(0, lfa2.lfClipPrecision);
 144     expect(0, lfa2.lfQuality);
 145     expect(0, lfa2.lfPitchAndFamily);
 146
 147     GdipDeleteFont(font);
 148
 149     memset(&lfa, 0, sizeof(LOGFONTA));
 150     lfa.lfHeight = 25;
 151     lfa.lfWidth = 25;
 152     lfa.lfEscapement = lfa.lfOrientation = 50;
 153     lfa.lfItalic = lfa.lfUnderline = lfa.lfStrikeOut = TRUE;
 154
 155     memset(&lfa2, 0xff, sizeof(LOGFONTA));
 156     lstrcpyA(lfa.lfFaceName, "Tahoma");
 157
 158     stat = GdipCreateFontFromLogfontA(hdc, &lfa, &font);
 159     expect(Ok, stat);
 160     stat = GdipGetLogFontA(font, graphics, &lfa2);
 161     expect(Ok, stat);
 162
 163     ok(lfa2.lfHeight < 0, "Expected negative height\n");
 164     expect(0, lfa2.lfWidth);
 165     expect(0, lfa2.lfEscapement);
 166     expect(0, lfa2.lfOrientation);
 167     ok((lfa2.lfWeight >= 100) && (lfa2.lfWeight <= 900), "Expected weight to be set\n");
 168     expect(TRUE, lfa2.lfItalic);
 169     expect(TRUE, lfa2.lfUnderline);
 170     expect(TRUE, lfa2.lfStrikeOut);
 171     ok(lfa2.lfCharSet == GetTextCharset(hdc) || lfa2.lfCharSet == ANSI_CHARSET,
 172         "Expected %x or %x, got %x\n", GetTextCharset(hdc), ANSI_CHARSET, lfa2.lfCharSet);
 173     expect(0, lfa2.lfOutPrecision);
 174     expect(0, lfa2.lfClipPrecision);
 175     expect(0, lfa2.lfQuality);
 176     expect(0, lfa2.lfPitchAndFamily);
 177
 178     stat = GdipGetFontStyle(font, &style);
 179     expect(Ok, stat);
 180     ok (style == (FontStyleItalic | FontStyleUnderline | FontStyleStrikeout),
 181             "Expected , got %d\n", style);
 182
 183     stat = GdipGetFontUnit(font, &unit);
 184     expect(Ok, stat);
 185     expect(UnitWorld, unit);
 186
 187     stat = GdipGetFontHeight(font, graphics, &rval);
 188     expect(Ok, stat);
 189     expectf(25.347656, rval);
 190     stat = GdipGetFontSize(font, &rval);
 191     expect(Ok, stat);
 192     expectf(21.0, rval);
 193
 194     stat = GdipGetFamily(font, &family);
 195     expect(Ok, stat);
 196     stat = GdipGetEmHeight(family, FontStyleRegular, &em_height);
 197     expect(Ok, stat);
 198     expect(2048, em_height);
 199     stat = GdipGetLineSpacing(family, FontStyleRegular, &line_spacing);
 200     expect(Ok, stat);
 201     expect(2472, line_spacing);
 202     GdipDeleteFontFamily(family);
 203
 204     GdipDeleteFont(font);
 205
 206     memset(&lfa, 0, sizeof(lfa));
 207     lfa.lfHeight = -25;
 208     lstrcpyA(lfa.lfFaceName, "Tahoma");
 209     stat = GdipCreateFontFromLogfontA(hdc, &lfa, &font);
 210     expect(Ok, stat);
 211     memset(&lfa2, 0xff, sizeof(lfa2));
 212     stat = GdipGetLogFontA(font, graphics, &lfa2);
 213     expect(Ok, stat);
 214     expect(lfa.lfHeight, lfa2.lfHeight);
 215
 216     stat = GdipGetFontUnit(font, &unit);
 217     expect(Ok, stat);
 218     expect(UnitWorld, unit);
 219
 220     stat = GdipGetFontHeight(font, graphics, &rval);
 221     expect(Ok, stat);
 222     expectf(30.175781, rval);
 223     stat = GdipGetFontSize(font, &rval);
 224     expect(Ok, stat);
 225     expectf(25.0, rval);
 226
 227     stat = GdipGetFamily(font, &family);
 228     expect(Ok, stat);
 229     stat = GdipGetEmHeight(family, FontStyleRegular, &em_height);
 230     expect(Ok, stat);
 231     expect(2048, em_height);
 232     stat = GdipGetLineSpacing(family, FontStyleRegular, &line_spacing);
 233     expect(Ok, stat);
 234     expect(2472, line_spacing);
 235     GdipDeleteFontFamily(family);
 236
 237     GdipDeleteFont(font);
 238
 239     GdipDeleteGraphics(graphics);
 240     ReleaseDC(0, hdc);
 241 }
 242
 243 static void test_fontfamily (void)
 244 {
 245     GpFontFamily *family, *clonedFontFamily;
 246     WCHAR itsName[LF_FACESIZE];
 247     GpStatus stat;
 248
 249     /* FontFamily cannot be NULL */
 250     stat = GdipCreateFontFamilyFromName (Tahoma , NULL, NULL);
 251     expect (InvalidParameter, stat);
 252
 253     /* FontFamily must be able to actually find the family.
 254      * If it can't, any subsequent calls should fail.
 255      */
 256     stat = GdipCreateFontFamilyFromName (nonexistent, NULL, &family);
 257     expect (FontFamilyNotFound, stat);
 258
 259     /* Bitmap fonts are not found */
 260     stat = GdipCreateFontFamilyFromName (MSSansSerif, NULL, &family);
 261     expect (FontFamilyNotFound, stat);
 262     if(stat == Ok) GdipDeleteFontFamily(family);
 263
 264     stat = GdipCreateFontFamilyFromName (Tahoma, NULL, &family);
 265     expect (Ok, stat);
 266
 267     stat = GdipGetFamilyName (family, itsName, LANG_NEUTRAL);
 268     expect (Ok, stat);
 269     expect (0, lstrcmpiW(itsName, Tahoma));
 270
 271     if (0)
 272     {
 273         /* Crashes on Windows XP SP2, Vista, and so Wine as well */
 274         stat = GdipGetFamilyName (family, NULL, LANG_NEUTRAL);
 275         expect (Ok, stat);
 276     }
 277
 278     /* Make sure we don't read old data */
 279     ZeroMemory (itsName, sizeof(itsName));
 280     stat = GdipCloneFontFamily(family, &clonedFontFamily);
 281     expect (Ok, stat);
 282     GdipDeleteFontFamily(family);
 283     stat = GdipGetFamilyName(clonedFontFamily, itsName, LANG_NEUTRAL);
 284     expect(Ok, stat);
 285     expect(0, lstrcmpiW(itsName, Tahoma));
 286
 287     GdipDeleteFontFamily(clonedFontFamily);
 288 }
 289 #endif // CORE_6660_IS_FIXED
 290
 291 static void test_fontfamily_properties (void)
 292 {
 293     GpFontFamily* FontFamily = NULL;
 294     GpStatus stat;
 295     UINT16 result = 0;
 296
 297     stat = GdipCreateFontFamilyFromName(Tahoma, NULL, &FontFamily);
 298     expect(Ok, stat);
 299
 300     stat = GdipGetLineSpacing(FontFamily, FontStyleRegular, &result);
 301     expect(Ok, stat);
 302     ok (result == 2472, "Expected 2472, got %d\n", result);
 303     result = 0;
 304     stat = GdipGetEmHeight(FontFamily, FontStyleRegular, &result);
 305     expect(Ok, stat);
 306     ok(result == 2048, "Expected 2048, got %d\n", result);
 307     result = 0;
 308     stat = GdipGetCellAscent(FontFamily, FontStyleRegular, &result);
 309     expect(Ok, stat);
 310     ok(result == 2049, "Expected 2049, got %d\n", result);
 311     result = 0;
 312     stat = GdipGetCellDescent(FontFamily, FontStyleRegular, &result);
 313     expect(Ok, stat);
 314     ok(result == 423, "Expected 423, got %d\n", result);
 315     GdipDeleteFontFamily(FontFamily);
 316
 317     stat = GdipCreateFontFamilyFromName(TimesNewRoman, NULL, &FontFamily);
 318     if(stat == FontFamilyNotFound)
 319         skip("Times New Roman not installed\n");
 320     else
 321     {
 322         result = 0;
 323         stat = GdipGetLineSpacing(FontFamily, FontStyleRegular, &result);
 324         expect(Ok, stat);
 325         ok(result == 2355, "Expected 2355, got %d\n", result);
 326         result = 0;
 327         stat = GdipGetEmHeight(FontFamily, FontStyleRegular, &result);
 328         expect(Ok, stat);
 329         ok(result == 2048, "Expected 2048, got %d\n", result);
 330         result = 0;
 331         stat = GdipGetCellAscent(FontFamily, FontStyleRegular, &result);
 332         expect(Ok, stat);
 333         ok(result == 1825, "Expected 1825, got %d\n", result);
 334         result = 0;
 335         stat = GdipGetCellDescent(FontFamily, FontStyleRegular, &result);
 336         expect(Ok, stat);
 337         ok(result == 443, "Expected 443 got %d\n", result);
 338         GdipDeleteFontFamily(FontFamily);
 339     }
 340 }
 341
 342 static void check_family(const char* context, GpFontFamily *family, WCHAR *name)
 343 {
 344     GpStatus stat;
 345     GpFont* font;
 346
 347     *name = 0;
 348     stat = GdipGetFamilyName(family, name, LANG_NEUTRAL);
 349     ok(stat == Ok, "could not get the %s family name: %.8x\n", context, stat);
 350
 351     stat = GdipCreateFont(family, 12, FontStyleRegular, UnitPixel, &font);
 352     ok(stat == Ok, "could not create a font for the %s family: %.8x\n", context, stat);
 353     if (stat == Ok)
 354     {
 355         stat = GdipDeleteFont(font);
 356         ok(stat == Ok, "could not delete the %s family font: %.8x\n", context, stat);
 357     }
 358
 359     stat = GdipDeleteFontFamily(family);
 360     ok(stat == Ok, "could not delete the %s family: %.8x\n", context, stat);
 361 }
 362
 363 static void test_getgenerics (void)
 364 {
 365     GpStatus stat;
 366     GpFontFamily *family;
 367     WCHAR sansname[LF_FACESIZE], serifname[LF_FACESIZE], mononame[LF_FACESIZE];
 368     int missingfonts = 0;
 369
 370     stat = GdipGetGenericFontFamilySansSerif(&family);
 371     expect (Ok, stat);
 372     if (stat == FontFamilyNotFound)
 373         missingfonts = 1;
 374     else
 375         check_family("Sans Serif", family, sansname);
 376
 377     stat = GdipGetGenericFontFamilySerif(&family);
 378     expect (Ok, stat);
 379     if (stat == FontFamilyNotFound)
 380         missingfonts = 1;
 381     else
 382         check_family("Serif", family, serifname);
 383
 384     stat = GdipGetGenericFontFamilyMonospace(&family);
 385     expect (Ok, stat);
 386     if (stat == FontFamilyNotFound)
 387         missingfonts = 1;
 388     else
 389         check_family("Monospace", family, mononame);
 390
 391     if (missingfonts && strcmp(winetest_platform, "wine") == 0)
 392         trace("You may need to install either the Microsoft Web Fonts or the Liberation Fonts\n");
 393
 394     /* Check that the family names are all different */
 395     ok(lstrcmpiW(sansname, serifname) != 0, "Sans Serif and Serif families should be different: %s\n", wine_dbgstr_w(sansname));
 396     ok(lstrcmpiW(sansname, mononame) != 0, "Sans Serif and Monospace families should be different: %s\n", wine_dbgstr_w(sansname));
 397     ok(lstrcmpiW(serifname, mononame) != 0, "Serif and Monospace families should be different: %s\n", wine_dbgstr_w(serifname));
 398 }
 399
 400 static void test_installedfonts (void)
 401 {
 402     GpStatus stat;
 403     GpFontCollection* collection=NULL;
 404
 405     stat = GdipNewInstalledFontCollection(NULL);
 406     expect (InvalidParameter, stat);
 407
 408     stat = GdipNewInstalledFontCollection(&collection);
 409     expect (Ok, stat);
 410     ok (collection != NULL, "got NULL font collection\n");
 411 }
 412
 413 static void test_heightgivendpi(void)
 414 {
 415     GpStatus stat;
 416     GpFont* font = NULL;
 417     GpFontFamily* fontfamily = NULL;
 418     REAL height;
 419     Unit unit;
 420
 421     stat = GdipCreateFontFamilyFromName(Tahoma, NULL, &fontfamily);
 422     expect(Ok, stat);
 423
 424     stat = GdipCreateFont(fontfamily, 30, FontStyleRegular, UnitPixel, &font);
 425     expect(Ok, stat);
 426
 427     stat = GdipGetFontHeightGivenDPI(NULL, 96, &height);
 428     expect(InvalidParameter, stat);
 429
 430     stat = GdipGetFontHeightGivenDPI(font, 96, NULL);
 431     expect(InvalidParameter, stat);
 432
 433     stat = GdipGetFontHeightGivenDPI(font, 96, &height);
 434     expect(Ok, stat);
 435     expectf(36.210938, height);
 436     GdipDeleteFont(font);
 437
 438     height = 12345;
 439     stat = GdipCreateFont(fontfamily, 30, FontStyleRegular, UnitWorld, &font);
 440     expect(Ok, stat);
 441
 442     stat = GdipGetFontUnit(font, &unit);
 443     expect(Ok, stat);
 444     expect(UnitWorld, unit);
 445
 446     stat = GdipGetFontHeightGivenDPI(font, 96, &height);
 447     expect(Ok, stat);
 448     expectf(36.210938, height);
 449     GdipDeleteFont(font);
 450
 451     height = 12345;
 452     stat = GdipCreateFont(fontfamily, 30, FontStyleRegular, UnitPoint, &font);
 453     expect(Ok, stat);
 454     stat = GdipGetFontHeightGivenDPI(font, 96, &height);
 455     expect(Ok, stat);
 456     expectf(48.281250, height);
 457     GdipDeleteFont(font);
 458
 459     height = 12345;
 460     stat = GdipCreateFont(fontfamily, 30, FontStyleRegular, UnitInch, &font);
 461     expect(Ok, stat);
 462
 463     stat = GdipGetFontUnit(font, &unit);
 464     expect(Ok, stat);
 465     expect(UnitInch, unit);
 466
 467     stat = GdipGetFontHeightGivenDPI(font, 96, &height);
 468     expect(Ok, stat);
 469     expectf(3476.250000, height);
 470     GdipDeleteFont(font);
 471
 472     height = 12345;
 473     stat = GdipCreateFont(fontfamily, 30, FontStyleRegular, UnitDocument, &font);
 474     expect(Ok, stat);
 475
 476     stat = GdipGetFontUnit(font, &unit);
 477     expect(Ok, stat);
 478     expect(UnitDocument, unit);
 479
 480     stat = GdipGetFontHeightGivenDPI(font, 96, &height);
 481     expect(Ok, stat);
 482     expectf(11.587500, height);
 483     GdipDeleteFont(font);
 484
 485     height = 12345;
 486     stat = GdipCreateFont(fontfamily, 30, FontStyleRegular, UnitMillimeter, &font);
 487     expect(Ok, stat);
 488
 489     stat = GdipGetFontUnit(font, &unit);
 490     expect(Ok, stat);
 491     expect(UnitMillimeter, unit);
 492
 493     stat = GdipGetFontHeightGivenDPI(font, 96, &height);
 494     expect(Ok, stat);
 495     expectf(136.860245, height);
 496     GdipDeleteFont(font);
 497
 498     GdipDeleteFontFamily(fontfamily);
 499 }
 500
 501 #if CORE_6660_IS_FIXED
 502 static int CALLBACK font_enum_proc(const LOGFONTW *lfe, const TEXTMETRICW *ntme,
 503                                    DWORD type, LPARAM lparam)
 504 {
 505     NEWTEXTMETRICW *ntm = (NEWTEXTMETRICW *)lparam;
 506
 507     if (type != TRUETYPE_FONTTYPE) return 1;
 508
 509     *ntm = *(NEWTEXTMETRICW *)ntme;
 510     return 0;
 511 }
 512
 513 struct font_metrics
 514 {
 515     UINT16 em_height, line_spacing, ascent, descent;
 516     REAL font_height, font_size;
 517     INT lfHeight;
 518 };
 519
 520 static void gdi_get_font_metrics(LOGFONTW *lf, struct font_metrics *fm)
 521 {
 522     HDC hdc;
 523     HFONT hfont;
 524     NEWTEXTMETRICW ntm;
 525     OUTLINETEXTMETRICW otm;
 526     int ret;
 527
 528     hdc = CreateCompatibleDC(0);
 529
 530     /* it's the only way to get extended NEWTEXTMETRIC fields */
 531     ret = EnumFontFamiliesExW(hdc, lf, font_enum_proc, (LPARAM)&ntm, 0);
 532     ok(!ret, "EnumFontFamiliesExW failed to find %s\n", wine_dbgstr_w(lf->lfFaceName));
 533
 534     hfont = CreateFontIndirectW(lf);
 535     SelectObject(hdc, hfont);
 536
 537     otm.otmSize = sizeof(otm);
 538     ret = GetOutlineTextMetricsW(hdc, otm.otmSize, &otm);
 539     ok(ret, "GetOutlineTextMetrics failed\n");
 540
 541     DeleteDC(hdc);
 542     DeleteObject(hfont);
 543
 544     fm->lfHeight = -otm.otmTextMetrics.tmAscent;
 545     fm->line_spacing = ntm.ntmCellHeight;
 546     fm->font_size = (REAL)otm.otmTextMetrics.tmAscent;
 547     fm->font_height = (REAL)fm->line_spacing * fm->font_size / (REAL)ntm.ntmSizeEM;
 548     fm->em_height = ntm.ntmSizeEM;
 549     fm->ascent = ntm.ntmSizeEM;
 550     fm->descent = ntm.ntmCellHeight - ntm.ntmSizeEM;
 551 }
 552
 553 static void gdip_get_font_metrics(GpFont *font, struct font_metrics *fm)
 554 {
 555     INT style;
 556     GpFontFamily *family;
 557     GpStatus stat;
 558
 559     stat = GdipGetFontStyle(font, &style);
 560     expect(Ok, stat);
 561
 562     stat = GdipGetFontHeight(font, NULL, &fm->font_height);
 563     expect(Ok, stat);
 564     stat = GdipGetFontSize(font, &fm->font_size);
 565     expect(Ok, stat);
 566
 567     fm->lfHeight = (INT)(fm->font_size * -1.0);
 568
 569     stat = GdipGetFamily(font, &family);
 570     expect(Ok, stat);
 571
 572     stat = GdipGetEmHeight(family, style, &fm->em_height);
 573     expect(Ok, stat);
 574     stat = GdipGetLineSpacing(family, style, &fm->line_spacing);
 575     expect(Ok, stat);
 576     stat = GdipGetCellAscent(family, style, &fm->ascent);
 577     expect(Ok, stat);
 578     stat = GdipGetCellDescent(family, style, &fm->descent);
 579     expect(Ok, stat);
 580
 581     GdipDeleteFontFamily(family);
 582 }
 583
 584 static void cmp_font_metrics(struct font_metrics *fm1, struct font_metrics *fm2, int line)
 585 {
 586     ok_(__FILE__, line)(fm1->lfHeight == fm2->lfHeight, "lfHeight %d != %d\n", fm1->lfHeight, fm2->lfHeight);
 587     ok_(__FILE__, line)(fm1->em_height == fm2->em_height, "em_height %u != %u\n", fm1->em_height, fm2->em_height);
 588     ok_(__FILE__, line)(fm1->line_spacing == fm2->line_spacing, "line_spacing %u != %u\n", fm1->line_spacing, fm2->line_spacing);
 589     ok_(__FILE__, line)(abs(fm1->ascent - fm2->ascent) <= 1, "ascent %u != %u\n", fm1->ascent, fm2->ascent);
 590     ok_(__FILE__, line)(abs(fm1->descent - fm2->descent) <= 1, "descent %u != %u\n", fm1->descent, fm2->descent);
 591     ok(fm1->font_height > 0.0, "fm1->font_height should be positive, got %f\n", fm1->font_height);
 592     ok(fm2->font_height > 0.0, "fm2->font_height should be positive, got %f\n", fm2->font_height);
 593     ok_(__FILE__, line)(fm1->font_height == fm2->font_height, "font_height %f != %f\n", fm1->font_height, fm2->font_height);
 594     ok(fm1->font_size > 0.0, "fm1->font_size should be positive, got %f\n", fm1->font_size);
 595     ok(fm2->font_size > 0.0, "fm2->font_size should be positive, got %f\n", fm2->font_size);
 596     ok_(__FILE__, line)(fm1->font_size == fm2->font_size, "font_size %f != %f\n", fm1->font_size, fm2->font_size);
 597 }
 598
 599 static void test_font_metrics(void)
 600 {
 601     LOGFONTW lf;
 602     GpFont *font;
 603     GpFontFamily *family;
 604     GpGraphics *graphics;
 605     GpStatus stat;
 606     Unit unit;
 607     struct font_metrics fm_gdi, fm_gdip;
 608     HDC hdc;
 609
 610     hdc = CreateCompatibleDC(0);
 611     stat = GdipCreateFromHDC(hdc, &graphics);
 612     expect(Ok, stat);
 613
 614     memset(&lf, 0, sizeof(lf));
 615
 616     /* Tahoma,-13 */
 617     lstrcpyW(lf.lfFaceName, Tahoma);
 618     lf.lfHeight = -13;
 619     stat = GdipCreateFontFromLogfontW(hdc, &lf, &font);
 620     expect(Ok, stat);
 621
 622     stat = GdipGetFontUnit(font, &unit);
 623     expect(Ok, stat);
 624     expect(UnitWorld, unit);
 625
 626     gdip_get_font_metrics(font, &fm_gdip);
 627     trace("gdiplus:\n");
 628     trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
 629           wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
 630           fm_gdip.em_height, fm_gdip.line_spacing, fm_gdip.ascent, fm_gdip.descent,
 631           fm_gdip.font_height, fm_gdip.font_size);
 632
 633     gdi_get_font_metrics(&lf, &fm_gdi);
 634     trace("gdi:\n");
 635     trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
 636           wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
 637           fm_gdi.em_height, fm_gdi.line_spacing, fm_gdi.ascent, fm_gdi.descent,
 638           fm_gdi.font_height, fm_gdi.font_size);
 639
 640     cmp_font_metrics(&fm_gdip, &fm_gdi, __LINE__);
 641
 642     stat = GdipGetLogFontW(font, graphics, &lf);
 643     expect(Ok, stat);
 644     ok(lf.lfHeight < 0, "lf.lfHeight should be negative, got %d\n", lf.lfHeight);
 645     gdi_get_font_metrics(&lf, &fm_gdi);
 646     trace("gdi:\n");
 647     trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
 648           wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
 649           fm_gdi.em_height, fm_gdi.line_spacing, fm_gdi.ascent, fm_gdi.descent,
 650           fm_gdi.font_height, fm_gdi.font_size);
 651     ok((REAL)lf.lfHeight * -1.0 == fm_gdi.font_size, "expected %f, got %f\n", (REAL)lf.lfHeight * -1.0, fm_gdi.font_size);
 652
 653     cmp_font_metrics(&fm_gdip, &fm_gdi, __LINE__);
 654
 655     GdipDeleteFont(font);
 656
 657     /* Tahoma,13 */
 658     lstrcpyW(lf.lfFaceName, Tahoma);
 659     lf.lfHeight = 13;
 660     stat = GdipCreateFontFromLogfontW(hdc, &lf, &font);
 661     expect(Ok, stat);
 662
 663     stat = GdipGetFontUnit(font, &unit);
 664     expect(Ok, stat);
 665     expect(UnitWorld, unit);
 666
 667     gdip_get_font_metrics(font, &fm_gdip);
 668     trace("gdiplus:\n");
 669     trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
 670           wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
 671           fm_gdip.em_height, fm_gdip.line_spacing, fm_gdip.ascent, fm_gdip.descent,
 672           fm_gdip.font_height, fm_gdip.font_size);
 673
 674     gdi_get_font_metrics(&lf, &fm_gdi);
 675     trace("gdi:\n");
 676     trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
 677           wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
 678           fm_gdi.em_height, fm_gdi.line_spacing, fm_gdi.ascent, fm_gdi.descent,
 679           fm_gdi.font_height, fm_gdi.font_size);
 680
 681     cmp_font_metrics(&fm_gdip, &fm_gdi, __LINE__);
 682
 683     stat = GdipGetLogFontW(font, graphics, &lf);
 684     expect(Ok, stat);
 685     ok(lf.lfHeight < 0, "lf.lfHeight should be negative, got %d\n", lf.lfHeight);
 686     gdi_get_font_metrics(&lf, &fm_gdi);
 687     trace("gdi:\n");
 688     trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
 689           wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
 690           fm_gdi.em_height, fm_gdi.line_spacing, fm_gdi.ascent, fm_gdi.descent,
 691           fm_gdi.font_height, fm_gdi.font_size);
 692     ok((REAL)lf.lfHeight * -1.0 == fm_gdi.font_size, "expected %f, got %f\n", (REAL)lf.lfHeight * -1.0, fm_gdi.font_size);
 693
 694     cmp_font_metrics(&fm_gdip, &fm_gdi, __LINE__);
 695
 696     GdipDeleteFont(font);
 697
 698     stat = GdipCreateFontFamilyFromName(Tahoma, NULL, &family);
 699     expect(Ok, stat);
 700
 701     /* Tahoma,13 */
 702     stat = GdipCreateFont(family, 13.0, FontStyleRegular, UnitPixel, &font);
 703     expect(Ok, stat);
 704
 705     gdip_get_font_metrics(font, &fm_gdip);
 706     trace("gdiplus:\n");
 707     trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
 708           wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
 709           fm_gdip.em_height, fm_gdip.line_spacing, fm_gdip.ascent, fm_gdip.descent,
 710           fm_gdip.font_height, fm_gdip.font_size);
 711
 712     stat = GdipGetLogFontW(font, graphics, &lf);
 713     expect(Ok, stat);
 714     ok(lf.lfHeight < 0, "lf.lfHeight should be negative, got %d\n", lf.lfHeight);
 715     gdi_get_font_metrics(&lf, &fm_gdi);
 716     trace("gdi:\n");
 717     trace("%s,%d: EmHeight %u, LineSpacing %u, CellAscent %u, CellDescent %u, FontHeight %f, FontSize %f\n",
 718           wine_dbgstr_w(lf.lfFaceName), lf.lfHeight,
 719           fm_gdi.em_height, fm_gdi.line_spacing, fm_gdi.ascent, fm_gdi.descent,
 720           fm_gdi.font_height, fm_gdi.font_size);
 721     ok((REAL)lf.lfHeight * -1.0 == fm_gdi.font_size, "expected %f, got %f\n", (REAL)lf.lfHeight * -1.0, fm_gdi.font_size);
 722
 723     cmp_font_metrics(&fm_gdip, &fm_gdi, __LINE__);
 724
 725     stat = GdipGetLogFontW(font, NULL, &lf);
 726     expect(InvalidParameter, stat);
 727
 728     GdipDeleteFont(font);
 729
 730     stat = GdipCreateFont(family, -13.0, FontStyleRegular, UnitPixel, &font);
 731     expect(InvalidParameter, stat);
 732
 733     GdipDeleteFontFamily(family);
 734
 735     GdipDeleteGraphics(graphics);
 736     DeleteDC(hdc);
 737 }
 738 #endif // CORE_6660_IS_FIXED
 739
 740 static void test_font_substitution(void)
 741 {
 742     WCHAR ms_shell_dlg[LF_FACESIZE];
 743     HDC hdc;
 744     HFONT hfont;
 745     LOGFONTA lf;
 746     GpStatus status;
 747     GpGraphics *graphics;
 748     GpFont *font;
 749     GpFontFamily *family;
 750     int ret;
 751
 752     hdc = CreateCompatibleDC(0);
 753     status = GdipCreateFromHDC(hdc, &graphics);
 754     expect(Ok, status);
 755
 756     hfont = GetStockObject(DEFAULT_GUI_FONT);
 757     ok(hfont != 0, "GetStockObject(DEFAULT_GUI_FONT) failed\n");
 758
 759     memset(&lf, 0xfe, sizeof(lf));
 760     ret = GetObjectA(hfont, sizeof(lf), &lf);
 761     ok(ret == sizeof(lf), "GetObject failed\n");
 762     ok(!lstrcmpA(lf.lfFaceName, "MS Shell Dlg"), "wrong face name %s\n", lf.lfFaceName);
 763     MultiByteToWideChar(CP_ACP, 0, lf.lfFaceName, -1, ms_shell_dlg, LF_FACESIZE);
 764
 765     status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
 766     expect(Ok, status);
 767     memset(&lf, 0xfe, sizeof(lf));
 768     status = GdipGetLogFontA(font, graphics, &lf);
 769     expect(Ok, status);
 770     ok(!lstrcmpA(lf.lfFaceName, "Microsoft Sans Serif") ||
 771        !lstrcmpA(lf.lfFaceName, "Tahoma"), "wrong face name %s\n", lf.lfFaceName);
 772     GdipDeleteFont(font);
 773
 774     status = GdipCreateFontFamilyFromName(ms_shell_dlg, NULL, &family);
 775     expect(Ok, status);
 776     status = GdipCreateFont(family, 12, FontStyleRegular, UnitPoint, &font);
 777     expect(Ok, status);
 778     memset(&lf, 0xfe, sizeof(lf));
 779     status = GdipGetLogFontA(font, graphics, &lf);
 780     expect(Ok, status);
 781     ok(!lstrcmpA(lf.lfFaceName, "Microsoft Sans Serif") ||
 782        !lstrcmpA(lf.lfFaceName, "Tahoma"), "wrong face name %s\n", lf.lfFaceName);
 783     GdipDeleteFont(font);
 784     GdipDeleteFontFamily(family);
 785
 786     status = GdipCreateFontFamilyFromName(nonexistent, NULL, &family);
 787     ok(status == FontFamilyNotFound, "expected FontFamilyNotFound, got %d\n", status);
 788
 789     lstrcpyA(lf.lfFaceName, "ThisFontShouldNotExist");
 790     status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
 791     expect(Ok, status);
 792     memset(&lf, 0xfe, sizeof(lf));
 793     status = GdipGetLogFontA(font, graphics, &lf);
 794     expect(Ok, status);
 795     ok(!lstrcmpA(lf.lfFaceName, "Arial"), "wrong face name %s\n", lf.lfFaceName);
 796     GdipDeleteFont(font);
 797
 798     /* empty FaceName */
 799     lf.lfFaceName[0] = 0;
 800     status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
 801     expect(Ok, status);
 802     memset(&lf, 0xfe, sizeof(lf));
 803     status = GdipGetLogFontA(font, graphics, &lf);
 804     expect(Ok, status);
 805     ok(!lstrcmpA(lf.lfFaceName, "Arial"), "wrong face name %s\n", lf.lfFaceName);
 806     GdipDeleteFont(font);
 807
 808     /* zeroing out lfWeight and lfCharSet leads to font creation failure */
 809     lf.lfWeight = 0;
 810     lf.lfCharSet = 0;
 811     lstrcpyA(lf.lfFaceName, "ThisFontShouldNotExist");
 812     status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
 813 todo_wine
 814     ok(status == NotTrueTypeFont || broken(status == FileNotFound), /* before XP */
 815        "expected NotTrueTypeFont, got %d\n", status);
 816
 817     /* empty FaceName */
 818     lf.lfFaceName[0] = 0;
 819     status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
 820 todo_wine
 821     ok(status == NotTrueTypeFont || broken(status == FileNotFound), /* before XP */
 822        "expected NotTrueTypeFont, got %d\n", status);
 823
 824     GdipDeleteGraphics(graphics);
 825     DeleteDC(hdc);
 826 }
 827
 828 static void test_font_transform(void)
 829 {
 830     static const WCHAR string[] = { 'A',0 };
 831     GpStatus status;
 832     HDC hdc;
 833     LOGFONTA lf;
 834     GpFont *font;
 835     GpGraphics *graphics;
 836     GpMatrix *matrix;
 837     GpStringFormat *format, *typographic;
 838     PointF pos[1] = { { 0,0 } };
 839     REAL height, margin_y;
 840     RectF bounds, rect;
 841
 842     hdc = CreateCompatibleDC(0);
 843     status = GdipCreateFromHDC(hdc, &graphics);
 844     expect(Ok, status);
 845
 846     status = GdipSetPageUnit(graphics, UnitPixel);
 847     expect(Ok, status);
 848
 849     status = GdipCreateStringFormat(0, LANG_NEUTRAL, &format);
 850     expect(Ok, status);
 851     status = GdipStringFormatGetGenericTypographic(&typographic);
 852     expect(Ok, status);
 853
 854     memset(&lf, 0, sizeof(lf));
 855     lstrcpyA(lf.lfFaceName, "Tahoma");
 856     lf.lfHeight = -100;
 857     lf.lfWidth = 100;
 858     status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
 859     expect(Ok, status);
 860
 861     margin_y = 100.0 / 8.0;
 862
 863     /* identity matrix */
 864     status = GdipCreateMatrix(&matrix);
 865     expect(Ok, status);
 866     status = GdipSetWorldTransform(graphics, matrix);
 867     expect(Ok, status);
 868     status = GdipGetLogFontA(font, graphics, &lf);
 869     expect(Ok, status);
 870     expect(-100, lf.lfHeight);
 871     expect(0, lf.lfWidth);
 872     expect(0, lf.lfEscapement);
 873     expect(0, lf.lfOrientation);
 874     status = GdipGetFontHeight(font, graphics, &height);
 875     expect(Ok, status);
 876     expectf(120.703125, height);
 877     set_rect_empty(&rect);
 878     set_rect_empty(&bounds);
 879     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, NULL, NULL);
 880     expect(Ok, status);
 881     expectf(0.0, bounds.X);
 882     expectf(0.0, bounds.Y);
 883 todo_wine
 884     expectf(height + margin_y, bounds.Height);
 885     set_rect_empty(&rect);
 886     set_rect_empty(&bounds);
 887     status = GdipMeasureString(graphics, string, -1, font, &rect, typographic, &bounds, NULL, NULL);
 888     expect(Ok, status);
 889     expectf(0.0, bounds.X);
 890     expectf(0.0, bounds.Y);
 891     expectf_(height, bounds.Height, 1.0);
 892     set_rect_empty(&bounds);
 893     status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
 894                                      DriverStringOptionsCmapLookup, NULL, &bounds);
 895     expect(Ok, status);
 896     expectf(0.0, bounds.X);
 897     expectf_(-100.0, bounds.Y, 0.05);
 898     expectf_(height, bounds.Height, 0.5);
 899     set_rect_empty(&bounds);
 900     status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
 901                                      DriverStringOptionsCmapLookup, matrix, &bounds);
 902     expect(Ok, status);
 903     expectf(0.0, bounds.X);
 904     expectf_(-100.0, bounds.Y, 0.05);
 905     expectf_(height, bounds.Height, 0.5);
 906
 907     /* scale matrix */
 908     status = GdipScaleMatrix(matrix, 2.0, 3.0, MatrixOrderAppend);
 909     expect(Ok, status);
 910     status = GdipSetWorldTransform(graphics, matrix);
 911     expect(Ok, status);
 912     status = GdipGetLogFontA(font, graphics, &lf);
 913     expect(Ok, status);
 914     expect(-300, lf.lfHeight);
 915     expect(0, lf.lfWidth);
 916     expect(0, lf.lfEscapement);
 917     expect(0, lf.lfOrientation);
 918     status = GdipGetFontHeight(font, graphics, &height);
 919     expect(Ok, status);
 920     expectf(120.703125, height);
 921     set_rect_empty(&rect);
 922     set_rect_empty(&bounds);
 923     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, NULL, NULL);
 924     expect(Ok, status);
 925     expectf(0.0, bounds.X);
 926     expectf(0.0, bounds.Y);
 927 todo_wine
 928     expectf(height + margin_y, bounds.Height);
 929     set_rect_empty(&rect);
 930     set_rect_empty(&bounds);
 931     status = GdipMeasureString(graphics, string, -1, font, &rect, typographic, &bounds, NULL, NULL);
 932     expect(Ok, status);
 933     expectf(0.0, bounds.X);
 934     expectf(0.0, bounds.Y);
 935     expectf_(height, bounds.Height, 0.05);
 936     set_rect_empty(&bounds);
 937     status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
 938                                      DriverStringOptionsCmapLookup, NULL, &bounds);
 939     expect(Ok, status);
 940     expectf(0.0, bounds.X);
 941     expectf_(-100.0, bounds.Y, 0.05);
 942     expectf_(height, bounds.Height, 0.2);
 943     set_rect_empty(&bounds);
 944     status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
 945                                      DriverStringOptionsCmapLookup, matrix, &bounds);
 946     expect(Ok, status);
 947     expectf(0.0, bounds.X);
 948 todo_wine
 949     expectf_(-300.0, bounds.Y, 0.15);
 950 todo_wine
 951     expectf(height * 3.0, bounds.Height);
 952
 953     /* scale + ratate matrix */
 954     status = GdipRotateMatrix(matrix, 45.0, MatrixOrderAppend);
 955     expect(Ok, status);
 956     status = GdipSetWorldTransform(graphics, matrix);
 957     expect(Ok, status);
 958     status = GdipGetLogFontA(font, graphics, &lf);
 959     expect(Ok, status);
 960     expect(-300, lf.lfHeight);
 961     expect(0, lf.lfWidth);
 962     expect_(3151, lf.lfEscapement, 1);
 963     expect_(3151, lf.lfOrientation, 1);
 964     status = GdipGetFontHeight(font, graphics, &height);
 965     expect(Ok, status);
 966     expectf(120.703125, height);
 967     set_rect_empty(&rect);
 968     set_rect_empty(&bounds);
 969     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, NULL, NULL);
 970     expect(Ok, status);
 971     expectf(0.0, bounds.X);
 972     expectf(0.0, bounds.Y);
 973 todo_wine
 974     expectf(height + margin_y, bounds.Height);
 975     set_rect_empty(&rect);
 976     set_rect_empty(&bounds);
 977     status = GdipMeasureString(graphics, string, -1, font, &rect, typographic, &bounds, NULL, NULL);
 978     expect(Ok, status);
 979     expectf(0.0, bounds.X);
 980     expectf(0.0, bounds.Y);
 981     expectf_(height, bounds.Height, 0.05);
 982     set_rect_empty(&bounds);
 983     status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
 984                                      DriverStringOptionsCmapLookup, NULL, &bounds);
 985     expect(Ok, status);
 986     expectf(0.0, bounds.X);
 987     expectf_(-100.0, bounds.Y, 0.05);
 988     expectf_(height, bounds.Height, 0.2);
 989     set_rect_empty(&bounds);
 990     status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
 991                                      DriverStringOptionsCmapLookup, matrix, &bounds);
 992     expect(Ok, status);
 993 todo_wine
 994     expectf_(-43.814377, bounds.X, 0.05);
 995 todo_wine
 996     expectf_(-212.235611, bounds.Y, 0.05);
 997 todo_wine
 998     expectf_(340.847534, bounds.Height, 0.05);
 999
1000     /* scale + ratate + shear matrix */
1001     status = GdipShearMatrix(matrix, 4.0, 5.0, MatrixOrderAppend);
1002     expect(Ok, status);
1003     status = GdipSetWorldTransform(graphics, matrix);
1004     expect(Ok, status);
1005     status = GdipGetLogFontA(font, graphics, &lf);
1006     expect(Ok, status);
1007 todo_wine
1008     expect(1032, lf.lfHeight);
1009     expect(0, lf.lfWidth);
1010     expect_(3099, lf.lfEscapement, 1);
1011     expect_(3099, lf.lfOrientation, 1);
1012     status = GdipGetFontHeight(font, graphics, &height);
1013     expect(Ok, status);
1014     expectf(120.703125, height);
1015     set_rect_empty(&rect);
1016     set_rect_empty(&bounds);
1017     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, NULL, NULL);
1018     expect(Ok, status);
1019     expectf(0.0, bounds.X);
1020     expectf(0.0, bounds.Y);
1021 todo_wine
1022     expectf(height + margin_y, bounds.Height);
1023     set_rect_empty(&rect);
1024     set_rect_empty(&bounds);
1025     status = GdipMeasureString(graphics, string, -1, font, &rect, typographic, &bounds, NULL, NULL);
1026     expect(Ok, status);
1027     expectf(0.0, bounds.X);
1028     expectf(0.0, bounds.Y);
1029     expectf_(height, bounds.Height, 0.2);
1030     set_rect_empty(&bounds);
1031     status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
1032                                      DriverStringOptionsCmapLookup, NULL, &bounds);
1033     expect(Ok, status);
1034     expectf(0.0, bounds.X);
1035     expectf_(-100.0, bounds.Y, 0.2);
1036     expectf_(height, bounds.Height, 0.2);
1037     set_rect_empty(&bounds);
1038     status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
1039                                      DriverStringOptionsCmapLookup, matrix, &bounds);
1040     expect(Ok, status);
1041 todo_wine
1042     expectf_(-636.706848, bounds.X, 0.05);
1043 todo_wine
1044     expectf_(-175.257523, bounds.Y, 0.05);
1045 todo_wine
1046     expectf_(1532.984985, bounds.Height, 0.05);
1047
1048     /* scale + ratate + shear + translate matrix */
1049     status = GdipTranslateMatrix(matrix, 10.0, 20.0, MatrixOrderAppend);
1050     expect(Ok, status);
1051     status = GdipSetWorldTransform(graphics, matrix);
1052     expect(Ok, status);
1053     status = GdipGetLogFontA(font, graphics, &lf);
1054     expect(Ok, status);
1055 todo_wine
1056     expect(1032, lf.lfHeight);
1057     expect(0, lf.lfWidth);
1058     expect_(3099, lf.lfEscapement, 1);
1059     expect_(3099, lf.lfOrientation, 1);
1060     status = GdipGetFontHeight(font, graphics, &height);
1061     expect(Ok, status);
1062     expectf(120.703125, height);
1063     set_rect_empty(&rect);
1064     set_rect_empty(&bounds);
1065     status = GdipMeasureString(graphics, string, -1, font, &rect, format, &bounds, NULL, NULL);
1066     expect(Ok, status);
1067     expectf(0.0, bounds.X);
1068     expectf(0.0, bounds.Y);
1069 todo_wine
1070     expectf(height + margin_y, bounds.Height);
1071     set_rect_empty(&rect);
1072     set_rect_empty(&bounds);
1073     status = GdipMeasureString(graphics, string, -1, font, &rect, typographic, &bounds, NULL, NULL);
1074     expect(Ok, status);
1075     expectf(0.0, bounds.X);
1076     expectf(0.0, bounds.Y);
1077     expectf_(height, bounds.Height, 0.1);
1078     set_rect_empty(&bounds);
1079     status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
1080                                      DriverStringOptionsCmapLookup, NULL, &bounds);
1081     expect(Ok, status);
1082     expectf(0.0, bounds.X);
1083     expectf_(-100.0, bounds.Y, 0.2);
1084     expectf_(height, bounds.Height, 0.2);
1085     set_rect_empty(&bounds);
1086     status = GdipMeasureDriverString(graphics, (const UINT16 *)string, -1, font, pos,
1087                                      DriverStringOptionsCmapLookup, matrix, &bounds);
1088     expect(Ok, status);
1089 todo_wine
1090     expectf_(-626.706848, bounds.X, 0.05);
1091 todo_wine
1092     expectf_(-155.257523, bounds.Y, 0.05);
1093 todo_wine
1094     expectf_(1532.984985, bounds.Height, 0.05);
1095
1096     GdipDeleteMatrix(matrix);
1097     GdipDeleteFont(font);
1098     GdipDeleteGraphics(graphics);
1099     GdipDeleteStringFormat(typographic);
1100     GdipDeleteStringFormat(format);
1101     DeleteDC(hdc);
1102 }
1103
1104 START_TEST(font)
1105 {
1106     struct GdiplusStartupInput gdiplusStartupInput;
1107     ULONG_PTR gdiplusToken;
1108
1109     gdiplusStartupInput.GdiplusVersion              = 1;
1110     gdiplusStartupInput.DebugEventCallback          = NULL;
1111     gdiplusStartupInput.SuppressBackgroundThread    = 0;
1112     gdiplusStartupInput.SuppressExternalCodecs      = 0;
1113
1114     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
1115
1116     test_font_transform();
1117     test_font_substitution();
1118 #if CORE_6660_IS_FIXED
1119     test_font_metrics();
1120 #endif
1121     test_createfont();
1122 #if CORE_6660_IS_FIXED
1123     test_logfont();
1124     test_fontfamily();
1125 #endif
1126     test_fontfamily_properties();
1127     test_getgenerics();
1128     test_installedfonts();
1129     test_heightgivendpi();
1130
1131     GdiplusShutdown(gdiplusToken);
1132 }