dlls/gdiplus/tests/metafile.c

   1 /*
   2  * Unit test suite for metafiles
   3  *
   4  * Copyright (C) 2011 Vincent Povirk 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 #include <math.h>
  22
  23 #include "objbase.h"
  24 #include "gdiplus.h"
  25 #include "wine/test.h"
  26
  27 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
  28 #define expectf_(expected, got, precision) ok(fabs((expected) - (got)) <= (precision), "Expected %f, got %f\n", (expected), (got))
  29 #define expectf(expected, got) expectf_((expected), (got), 0.001)
  30
  31 static BOOL save_metafiles;
  32 static BOOL load_metafiles;
  33
  34 typedef struct emfplus_record
  35 {
  36     BOOL  todo;
  37     ULONG record_type;
  38     BOOL  playback_todo;
  39 } emfplus_record;
  40
  41 typedef struct emfplus_check_state
  42 {
  43     const char *desc;
  44     int count;
  45     const struct emfplus_record *expected;
  46     GpMetafile *metafile;
  47 } emfplus_check_state;
  48
  49 static void check_record(int count, const char *desc, const struct emfplus_record *expected, const struct emfplus_record *actual)
  50 {
  51     todo_wine_if (expected->todo)
  52         ok(expected->record_type == actual->record_type,
  53             "%s.%i: Expected record type 0x%x, got 0x%x\n", desc, count,
  54             expected->record_type, actual->record_type);
  55 }
  56
  57 typedef struct EmfPlusRecordHeader
  58 {
  59     WORD Type;
  60     WORD Flags;
  61     DWORD Size;
  62     DWORD DataSize;
  63 } EmfPlusRecordHeader;
  64
  65 static int CALLBACK enum_emf_proc(HDC hDC, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR,
  66     int nObj, LPARAM lpData)
  67 {
  68     emfplus_check_state *state = (emfplus_check_state*)lpData;
  69     emfplus_record actual;
  70
  71     if (lpEMFR->iType == EMR_GDICOMMENT)
  72     {
  73         const EMRGDICOMMENT *comment = (const EMRGDICOMMENT*)lpEMFR;
  74
  75         if (comment->cbData >= 4 && memcmp(comment->Data, "EMF+", 4) == 0)
  76         {
  77             int offset = 4;
  78
  79             while (offset + sizeof(EmfPlusRecordHeader) <= comment->cbData)
  80             {
  81                 const EmfPlusRecordHeader *record = (const EmfPlusRecordHeader*)&comment->Data[offset];
  82
  83                 ok(record->Size == record->DataSize + sizeof(EmfPlusRecordHeader),
  84                     "%s: EMF+ record datasize %u and size %u mismatch\n", state->desc, record->DataSize, record->Size);
  85
  86                 ok(offset + record->DataSize <= comment->cbData,
  87                     "%s: EMF+ record truncated\n", state->desc);
  88
  89                 if (offset + record->DataSize > comment->cbData)
  90                     return 0;
  91
  92                 if (state->expected[state->count].record_type)
  93                 {
  94                     actual.todo = FALSE;
  95                     actual.record_type = record->Type;
  96
  97                     check_record(state->count, state->desc, &state->expected[state->count], &actual);
  98
  99                     state->count++;
 100                 }
 101                 else
 102                 {
 103                     ok(0, "%s: Unexpected EMF+ 0x%x record\n", state->desc, record->Type);
 104                 }
 105
 106                 offset += record->Size;
 107             }
 108
 109             ok(offset == comment->cbData, "%s: truncated EMF+ record data?\n", state->desc);
 110
 111             return 1;
 112         }
 113     }
 114
 115     if (state->expected[state->count].record_type)
 116     {
 117         actual.todo = FALSE;
 118         actual.record_type = lpEMFR->iType;
 119
 120         check_record(state->count, state->desc, &state->expected[state->count], &actual);
 121
 122         state->count++;
 123     }
 124     else
 125     {
 126         ok(0, "%s: Unexpected EMF 0x%x record\n", state->desc, lpEMFR->iType);
 127     }
 128
 129     return 1;
 130 }
 131
 132 static void check_emfplus(HENHMETAFILE hemf, const emfplus_record *expected, const char *desc)
 133 {
 134     emfplus_check_state state;
 135
 136     state.desc = desc;
 137     state.count = 0;
 138     state.expected = expected;
 139
 140     EnumEnhMetaFile(0, hemf, enum_emf_proc, &state, NULL);
 141
 142     todo_wine_if (expected[state.count].todo)
 143         ok(expected[state.count].record_type == 0, "%s: Got %i records, expecting more\n", desc, state.count);
 144 }
 145
 146 static BOOL CALLBACK enum_metafile_proc(EmfPlusRecordType record_type, unsigned int flags,
 147     unsigned int dataSize, const unsigned char *pStr, void *userdata)
 148 {
 149     emfplus_check_state *state = (emfplus_check_state*)userdata;
 150     emfplus_record actual;
 151
 152     actual.todo = FALSE;
 153     actual.record_type = record_type;
 154
 155     if (dataSize == 0)
 156         ok(pStr == NULL, "non-NULL pStr\n");
 157
 158     if (state->expected[state->count].record_type)
 159     {
 160         check_record(state->count, state->desc, &state->expected[state->count], &actual);
 161
 162         state->count++;
 163     }
 164     else
 165     {
 166         ok(0, "%s: Unexpected EMF 0x%x record\n", state->desc, record_type);
 167     }
 168
 169     return TRUE;
 170 }
 171
 172 static void check_metafile(GpMetafile *metafile, const emfplus_record *expected, const char *desc,
 173     const GpPointF *dst_points, const GpRectF *src_rect, Unit src_unit)
 174 {
 175     GpStatus stat;
 176     HDC hdc;
 177     GpGraphics *graphics;
 178     emfplus_check_state state;
 179
 180     state.desc = desc;
 181     state.count = 0;
 182     state.expected = expected;
 183     state.metafile = metafile;
 184
 185     hdc = CreateCompatibleDC(0);
 186
 187     stat = GdipCreateFromHDC(hdc, &graphics);
 188     expect(Ok, stat);
 189
 190     stat = GdipEnumerateMetafileSrcRectDestPoints(graphics, metafile, dst_points,
 191         3, src_rect, src_unit, enum_metafile_proc, &state, NULL);
 192     expect(Ok, stat);
 193
 194     todo_wine_if (expected[state.count].todo)
 195         ok(expected[state.count].record_type == 0, "%s: Got %i records, expecting more\n", desc, state.count);
 196
 197     GdipDeleteGraphics(graphics);
 198
 199     DeleteDC(hdc);
 200 }
 201
 202 static BOOL CALLBACK play_metafile_proc(EmfPlusRecordType record_type, unsigned int flags,
 203     unsigned int dataSize, const unsigned char *pStr, void *userdata)
 204 {
 205     emfplus_check_state *state = (emfplus_check_state*)userdata;
 206     GpStatus stat;
 207
 208     stat = GdipPlayMetafileRecord(state->metafile, record_type, flags, dataSize, pStr);
 209
 210     if (state->expected[state->count].record_type)
 211     {
 212         todo_wine_if (state->expected[state->count].playback_todo)
 213             ok(stat == Ok, "%s.%i: GdipPlayMetafileRecord failed with stat %i\n", state->desc, state->count, stat);
 214         state->count++;
 215     }
 216     else
 217     {
 218         todo_wine_if (state->expected[state->count].playback_todo)
 219             ok(0, "%s: too many records\n", state->desc);
 220
 221         return FALSE;
 222     }
 223
 224     return TRUE;
 225 }
 226
 227 static void play_metafile(GpMetafile *metafile, GpGraphics *graphics, const emfplus_record *expected,
 228     const char *desc, const GpPointF *dst_points, const GpRectF *src_rect, Unit src_unit)
 229 {
 230     GpStatus stat;
 231     emfplus_check_state state;
 232
 233     state.desc = desc;
 234     state.count = 0;
 235     state.expected = expected;
 236     state.metafile = metafile;
 237
 238     stat = GdipEnumerateMetafileSrcRectDestPoints(graphics, metafile, dst_points,
 239         3, src_rect, src_unit, play_metafile_proc, &state, NULL);
 240     expect(Ok, stat);
 241 }
 242
 243 /* When 'save' or 'load' is specified on the command line, save or
 244  * load the specified filename. */
 245 static void sync_metafile(GpMetafile **metafile, const char *filename)
 246 {
 247     GpStatus stat;
 248     if (save_metafiles)
 249     {
 250         GpMetafile *clone;
 251         HENHMETAFILE hemf;
 252
 253         stat = GdipCloneImage((GpImage*)*metafile, (GpImage**)&clone);
 254         expect(Ok, stat);
 255
 256         stat = GdipGetHemfFromMetafile(clone, &hemf);
 257         expect(Ok, stat);
 258
 259         DeleteEnhMetaFile(CopyEnhMetaFileA(hemf, filename));
 260
 261         DeleteEnhMetaFile(hemf);
 262
 263         stat = GdipDisposeImage((GpImage*)clone);
 264         expect(Ok, stat);
 265     }
 266     else if (load_metafiles)
 267     {
 268         HENHMETAFILE hemf;
 269
 270         stat = GdipDisposeImage((GpImage*)*metafile);
 271         expect(Ok, stat);
 272         *metafile = NULL;
 273
 274         hemf = GetEnhMetaFileA(filename);
 275         ok(hemf != NULL, "%s could not be opened\n", filename);
 276
 277         stat = GdipCreateMetafileFromEmf(hemf, TRUE, metafile);
 278         expect(Ok, stat);
 279     }
 280 }
 281
 282 static const emfplus_record empty_records[] = {
 283     {0, EMR_HEADER},
 284     {0, EmfPlusRecordTypeHeader},
 285     {0, EmfPlusRecordTypeEndOfFile},
 286     {0, EMR_EOF},
 287     {0}
 288 };
 289
 290 static void test_empty(void)
 291 {
 292     GpStatus stat;
 293     GpMetafile *metafile;
 294     GpGraphics *graphics;
 295     HDC hdc;
 296     GpRectF bounds;
 297     GpUnit unit;
 298     REAL xres, yres;
 299     HENHMETAFILE hemf, dummy;
 300     MetafileHeader header;
 301     static const GpRectF frame = {0.0, 0.0, 100.0, 100.0};
 302     static const GpPointF dst_points[3] = {{0.0,0.0},{100.0,0.0},{0.0,100.0}};
 303     static const WCHAR description[] = {'w','i','n','e','t','e','s','t',0};
 304
 305     hdc = CreateCompatibleDC(0);
 306
 307     stat = GdipRecordMetafile(NULL, EmfTypeEmfPlusOnly, &frame, MetafileFrameUnitPixel, description, &metafile);
 308     expect(InvalidParameter, stat);
 309
 310     stat = GdipRecordMetafile(hdc, MetafileTypeInvalid, &frame, MetafileFrameUnitPixel, description, &metafile);
 311     expect(InvalidParameter, stat);
 312
 313     stat = GdipRecordMetafile(hdc, MetafileTypeWmf, &frame, MetafileFrameUnitPixel, description, &metafile);
 314     expect(InvalidParameter, stat);
 315
 316     stat = GdipRecordMetafile(hdc, MetafileTypeWmfPlaceable, &frame, MetafileFrameUnitPixel, description, &metafile);
 317     expect(InvalidParameter, stat);
 318
 319     stat = GdipRecordMetafile(hdc, MetafileTypeEmfPlusDual+1, &frame, MetafileFrameUnitPixel, description, &metafile);
 320     expect(InvalidParameter, stat);
 321
 322     stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, &frame, MetafileFrameUnitPixel, description, NULL);
 323     expect(InvalidParameter, stat);
 324
 325     stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, &frame, MetafileFrameUnitPixel, description, &metafile);
 326     expect(Ok, stat);
 327
 328     DeleteDC(hdc);
 329
 330     if (stat != Ok)
 331         return;
 332
 333     stat = GdipGetHemfFromMetafile(metafile, &hemf);
 334     expect(InvalidParameter, stat);
 335
 336     stat = GdipGetImageGraphicsContext((GpImage*)metafile, &graphics);
 337     expect(Ok, stat);
 338
 339     stat = GdipGetHemfFromMetafile(metafile, &hemf);
 340     expect(InvalidParameter, stat);
 341
 342     stat = GdipDeleteGraphics(graphics);
 343     expect(Ok, stat);
 344
 345     check_metafile(metafile, empty_records, "empty metafile", dst_points, &frame, UnitPixel);
 346
 347     sync_metafile(&metafile, "empty.emf");
 348
 349     stat = GdipGetImageBounds((GpImage*)metafile, &bounds, &unit);
 350     expect(Ok, stat);
 351     expectf(0.0, bounds.X);
 352     expectf(0.0, bounds.Y);
 353     expectf_(100.0, bounds.Width, 0.05);
 354     expectf_(100.0, bounds.Height, 0.05);
 355     expect(UnitPixel, unit);
 356
 357     stat = GdipGetImageHorizontalResolution((GpImage*)metafile, &xres);
 358     expect(Ok, stat);
 359
 360     stat = GdipGetImageVerticalResolution((GpImage*)metafile, &yres);
 361     expect(Ok, stat);
 362
 363     stat = GdipGetHemfFromMetafile(metafile, &hemf);
 364     expect(Ok, stat);
 365
 366     stat = GdipGetHemfFromMetafile(metafile, &dummy);
 367     expect(InvalidParameter, stat);
 368
 369     stat = GdipDisposeImage((GpImage*)metafile);
 370     expect(Ok, stat);
 371
 372     check_emfplus(hemf, empty_records, "empty emf");
 373
 374     memset(&header, 0xaa, sizeof(header));
 375     stat = GdipGetMetafileHeaderFromEmf(hemf, &header);
 376     expect(Ok, stat);
 377     expect(MetafileTypeEmfPlusOnly, header.Type);
 378     expect(U(header).EmfHeader.nBytes, header.Size);
 379     ok(header.Version == 0xdbc01001 || header.Version == 0xdbc01002, "Unexpected version %x\n", header.Version);
 380     expect(1, header.EmfPlusFlags); /* reference device was display, not printer */
 381     expectf(xres, header.DpiX);
 382     expectf(xres, U(header).EmfHeader.szlDevice.cx / (REAL)U(header).EmfHeader.szlMillimeters.cx * 25.4);
 383     expectf(yres, header.DpiY);
 384     expectf(yres, U(header).EmfHeader.szlDevice.cy / (REAL)U(header).EmfHeader.szlMillimeters.cy * 25.4);
 385     expect(0, header.X);
 386     expect(0, header.Y);
 387     expect(100, header.Width);
 388     expect(100, header.Height);
 389     expect(28, header.EmfPlusHeaderSize);
 390     expect(96, header.LogicalDpiX);
 391     expect(96, header.LogicalDpiX);
 392     expect(EMR_HEADER, U(header).EmfHeader.iType);
 393     expect(0, U(header).EmfHeader.rclBounds.left);
 394     expect(0, U(header).EmfHeader.rclBounds.top);
 395     expect(-1, U(header).EmfHeader.rclBounds.right);
 396     expect(-1, U(header).EmfHeader.rclBounds.bottom);
 397     expect(0, U(header).EmfHeader.rclFrame.left);
 398     expect(0, U(header).EmfHeader.rclFrame.top);
 399     expectf_(100.0, U(header).EmfHeader.rclFrame.right * xres / 2540.0, 2.0);
 400     expectf_(100.0, U(header).EmfHeader.rclFrame.bottom * yres / 2540.0, 2.0);
 401
 402     stat = GdipCreateMetafileFromEmf(hemf, TRUE, &metafile);
 403     expect(Ok, stat);
 404
 405     stat = GdipGetImageBounds((GpImage*)metafile, &bounds, &unit);
 406     expect(Ok, stat);
 407     expectf(0.0, bounds.X);
 408     expectf(0.0, bounds.Y);
 409     expectf_(100.0, bounds.Width, 0.05);
 410     expectf_(100.0, bounds.Height, 0.05);
 411     expect(UnitPixel, unit);
 412
 413     stat = GdipGetImageHorizontalResolution((GpImage*)metafile, &xres);
 414     expect(Ok, stat);
 415     expectf(header.DpiX, xres);
 416
 417     stat = GdipGetImageVerticalResolution((GpImage*)metafile, &yres);
 418     expect(Ok, stat);
 419     expectf(header.DpiY, yres);
 420
 421     stat = GdipDisposeImage((GpImage*)metafile);
 422     expect(Ok, stat);
 423 }
 424
 425 static const emfplus_record getdc_records[] = {
 426     {0, EMR_HEADER},
 427     {0, EmfPlusRecordTypeHeader},
 428     {0, EmfPlusRecordTypeGetDC},
 429     {0, EMR_CREATEBRUSHINDIRECT},
 430     {0, EMR_SELECTOBJECT},
 431     {0, EMR_RECTANGLE},
 432     {0, EMR_SELECTOBJECT},
 433     {0, EMR_DELETEOBJECT},
 434     {0, EmfPlusRecordTypeEndOfFile},
 435     {0, EMR_EOF},
 436     {0}
 437 };
 438
 439 static void test_getdc(void)
 440 {
 441     GpStatus stat;
 442     GpMetafile *metafile;
 443     GpGraphics *graphics;
 444     HDC hdc, metafile_dc;
 445     HENHMETAFILE hemf;
 446     BOOL ret;
 447     static const GpRectF frame = {0.0, 0.0, 100.0, 100.0};
 448     static const GpPointF dst_points[3] = {{0.0,0.0},{100.0,0.0},{0.0,100.0}};
 449     static const GpPointF dst_points_half[3] = {{0.0,0.0},{50.0,0.0},{0.0,50.0}};
 450     static const WCHAR description[] = {'w','i','n','e','t','e','s','t',0};
 451     HBRUSH hbrush, holdbrush;
 452     GpBitmap *bitmap;
 453     ARGB color;
 454
 455     hdc = CreateCompatibleDC(0);
 456
 457     stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, &frame, MetafileFrameUnitPixel, description, &metafile);
 458     expect(Ok, stat);
 459
 460     DeleteDC(hdc);
 461
 462     if (stat != Ok)
 463         return;
 464
 465     stat = GdipGetHemfFromMetafile(metafile, &hemf);
 466     expect(InvalidParameter, stat);
 467
 468     stat = GdipGetImageGraphicsContext((GpImage*)metafile, &graphics);
 469     expect(Ok, stat);
 470
 471     stat = GdipGetDC(graphics, &metafile_dc);
 472     expect(Ok, stat);
 473
 474     if (stat != Ok)
 475     {
 476         GdipDeleteGraphics(graphics);
 477         GdipDisposeImage((GpImage*)metafile);
 478         return;
 479     }
 480
 481     hbrush = CreateSolidBrush(0xff0000);
 482
 483     holdbrush = SelectObject(metafile_dc, hbrush);
 484
 485     Rectangle(metafile_dc, 25, 25, 75, 75);
 486
 487     SelectObject(metafile_dc, holdbrush);
 488
 489     DeleteObject(hbrush);
 490
 491     stat = GdipReleaseDC(graphics, metafile_dc);
 492     expect(Ok, stat);
 493
 494     stat = GdipDeleteGraphics(graphics);
 495     expect(Ok, stat);
 496
 497     check_metafile(metafile, getdc_records, "getdc metafile", dst_points, &frame, UnitPixel);
 498
 499     sync_metafile(&metafile, "getdc.emf");
 500
 501     stat = GdipCreateBitmapFromScan0(100, 100, 0, PixelFormat32bppARGB, NULL, &bitmap);
 502     expect(Ok, stat);
 503
 504     stat = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
 505     expect(Ok, stat);
 506
 507     play_metafile(metafile, graphics, getdc_records, "getdc playback", dst_points, &frame, UnitPixel);
 508
 509     stat = GdipBitmapGetPixel(bitmap, 15, 15, &color);
 510     expect(Ok, stat);
 511     expect(0, color);
 512
 513     stat = GdipBitmapGetPixel(bitmap, 50, 50, &color);
 514     expect(Ok, stat);
 515     expect(0xff0000ff, color);
 516
 517     stat = GdipBitmapSetPixel(bitmap, 50, 50, 0);
 518     expect(Ok, stat);
 519
 520     play_metafile(metafile, graphics, getdc_records, "getdc playback", dst_points_half, &frame, UnitPixel);
 521
 522     stat = GdipBitmapGetPixel(bitmap, 15, 15, &color);
 523     expect(Ok, stat);
 524     expect(0xff0000ff, color);
 525
 526     stat = GdipBitmapGetPixel(bitmap, 50, 50, &color);
 527     expect(Ok, stat);
 528     expect(0, color);
 529
 530     stat = GdipBitmapSetPixel(bitmap, 15, 15, 0);
 531     expect(Ok, stat);
 532
 533     stat = GdipDrawImagePointsRect(graphics, (GpImage*)metafile, dst_points, 3,
 534         0.0, 0.0, 100.0, 100.0, UnitPixel, NULL, NULL, NULL);
 535     expect(Ok, stat);
 536
 537     stat = GdipBitmapGetPixel(bitmap, 15, 15, &color);
 538     expect(Ok, stat);
 539     expect(0, color);
 540
 541     stat = GdipBitmapGetPixel(bitmap, 50, 50, &color);
 542     expect(Ok, stat);
 543     expect(0xff0000ff, color);
 544
 545     stat = GdipDeleteGraphics(graphics);
 546     expect(Ok, stat);
 547
 548     stat = GdipDisposeImage((GpImage*)bitmap);
 549     expect(Ok, stat);
 550
 551     stat = GdipGetHemfFromMetafile(metafile, &hemf);
 552     expect(Ok, stat);
 553
 554     stat = GdipDisposeImage((GpImage*)metafile);
 555     expect(Ok, stat);
 556
 557     check_emfplus(hemf, getdc_records, "getdc emf");
 558
 559     ret = DeleteEnhMetaFile(hemf);
 560     ok(ret != 0, "Failed to delete enhmetafile %p\n", hemf);
 561 }
 562
 563 static const emfplus_record emfonly_records[] = {
 564     {0, EMR_HEADER},
 565     {0, EMR_CREATEBRUSHINDIRECT},
 566     {0, EMR_SELECTOBJECT},
 567     {0, EMR_RECTANGLE},
 568     {0, EMR_SELECTOBJECT},
 569     {0, EMR_DELETEOBJECT},
 570     {0, EMR_EOF},
 571     {0}
 572 };
 573
 574 static void test_emfonly(void)
 575 {
 576     GpStatus stat;
 577     GpMetafile *metafile;
 578     GpImage *clone;
 579     GpGraphics *graphics;
 580     HDC hdc, metafile_dc;
 581     GpRectF bounds;
 582     GpUnit unit;
 583     REAL xres, yres;
 584     HENHMETAFILE hemf;
 585     MetafileHeader header;
 586     static const GpRectF frame = {0.0, 0.0, 100.0, 100.0};
 587     static const GpPointF dst_points[3] = {{0.0,0.0},{100.0,0.0},{0.0,100.0}};
 588     static const WCHAR description[] = {'w','i','n','e','t','e','s','t',0};
 589     HBRUSH hbrush, holdbrush;
 590     GpBitmap *bitmap;
 591     ARGB color;
 592
 593     hdc = CreateCompatibleDC(0);
 594
 595     stat = GdipRecordMetafile(hdc, EmfTypeEmfOnly, &frame, MetafileFrameUnitPixel, description, &metafile);
 596     expect(Ok, stat);
 597
 598     DeleteDC(hdc);
 599
 600     if (stat != Ok)
 601         return;
 602
 603     stat = GdipGetHemfFromMetafile(metafile, &hemf);
 604     expect(InvalidParameter, stat);
 605
 606     stat = GdipGetImageGraphicsContext((GpImage*)metafile, &graphics);
 607     expect(Ok, stat);
 608
 609     stat = GdipGetDC(graphics, &metafile_dc);
 610     expect(Ok, stat);
 611
 612     if (stat != Ok)
 613     {
 614         GdipDeleteGraphics(graphics);
 615         GdipDisposeImage((GpImage*)metafile);
 616         return;
 617     }
 618
 619     hbrush = CreateSolidBrush(0xff0000);
 620
 621     holdbrush = SelectObject(metafile_dc, hbrush);
 622
 623     Rectangle(metafile_dc, 25, 25, 75, 75);
 624
 625     SelectObject(metafile_dc, holdbrush);
 626
 627     DeleteObject(hbrush);
 628
 629     stat = GdipReleaseDC(graphics, metafile_dc);
 630     expect(Ok, stat);
 631
 632     stat = GdipDeleteGraphics(graphics);
 633     expect(Ok, stat);
 634
 635     check_metafile(metafile, emfonly_records, "emfonly metafile", dst_points, &frame, UnitPixel);
 636
 637     sync_metafile(&metafile, "emfonly.emf");
 638
 639     stat = GdipGetImageBounds((GpImage*)metafile, &bounds, &unit);
 640     expect(Ok, stat);
 641     expectf(0.0, bounds.X);
 642     expectf(0.0, bounds.Y);
 643     expectf_(100.0, bounds.Width, 0.05);
 644     expectf_(100.0, bounds.Height, 0.05);
 645     expect(UnitPixel, unit);
 646
 647     stat = GdipGetImageHorizontalResolution((GpImage*)metafile, &xres);
 648     expect(Ok, stat);
 649
 650     stat = GdipGetImageVerticalResolution((GpImage*)metafile, &yres);
 651     expect(Ok, stat);
 652
 653     stat = GdipCreateBitmapFromScan0(100, 100, 0, PixelFormat32bppARGB, NULL, &bitmap);
 654     expect(Ok, stat);
 655
 656     stat = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
 657     expect(Ok, stat);
 658
 659     play_metafile(metafile, graphics, emfonly_records, "emfonly playback", dst_points, &frame, UnitPixel);
 660
 661     stat = GdipBitmapGetPixel(bitmap, 15, 15, &color);
 662     expect(Ok, stat);
 663     expect(0, color);
 664
 665     stat = GdipBitmapGetPixel(bitmap, 50, 50, &color);
 666     expect(Ok, stat);
 667     expect(0xff0000ff, color);
 668
 669     stat = GdipBitmapSetPixel(bitmap, 50, 50, 0);
 670     expect(Ok, stat);
 671
 672     stat = GdipDrawImagePointsRect(graphics, (GpImage*)metafile, dst_points, 3,
 673         0.0, 0.0, 100.0, 100.0, UnitPixel, NULL, NULL, NULL);
 674     expect(Ok, stat);
 675
 676     stat = GdipBitmapGetPixel(bitmap, 15, 15, &color);
 677     expect(Ok, stat);
 678     expect(0, color);
 679
 680     stat = GdipBitmapGetPixel(bitmap, 50, 50, &color);
 681     expect(Ok, stat);
 682     expect(0xff0000ff, color);
 683
 684     stat = GdipCloneImage((GpImage*)metafile, &clone);
 685     expect(Ok, stat);
 686
 687     if (stat == Ok)
 688     {
 689         stat = GdipBitmapSetPixel(bitmap, 50, 50, 0);
 690         expect(Ok, stat);
 691
 692         stat = GdipDrawImagePointsRect(graphics, clone, dst_points, 3,
 693             0.0, 0.0, 100.0, 100.0, UnitPixel, NULL, NULL, NULL);
 694         expect(Ok, stat);
 695
 696         stat = GdipBitmapGetPixel(bitmap, 15, 15, &color);
 697         expect(Ok, stat);
 698         expect(0, color);
 699
 700         stat = GdipBitmapGetPixel(bitmap, 50, 50, &color);
 701         expect(Ok, stat);
 702         expect(0xff0000ff, color);
 703
 704         GdipDisposeImage(clone);
 705     }
 706
 707     stat = GdipDeleteGraphics(graphics);
 708     expect(Ok, stat);
 709
 710     stat = GdipDisposeImage((GpImage*)bitmap);
 711     expect(Ok, stat);
 712
 713     stat = GdipGetHemfFromMetafile(metafile, &hemf);
 714     expect(Ok, stat);
 715
 716     stat = GdipDisposeImage((GpImage*)metafile);
 717     expect(Ok, stat);
 718
 719     check_emfplus(hemf, emfonly_records, "emfonly emf");
 720
 721     memset(&header, 0xaa, sizeof(header));
 722     stat = GdipGetMetafileHeaderFromEmf(hemf, &header);
 723     expect(Ok, stat);
 724     expect(MetafileTypeEmf, header.Type);
 725     expect(U(header).EmfHeader.nBytes, header.Size);
 726     expect(0x10000, header.Version);
 727     expect(0, header.EmfPlusFlags);
 728     expectf(xres, header.DpiX);
 729     expectf(xres, U(header).EmfHeader.szlDevice.cx / (REAL)U(header).EmfHeader.szlMillimeters.cx * 25.4);
 730     expectf(yres, header.DpiY);
 731     expectf(yres, U(header).EmfHeader.szlDevice.cy / (REAL)U(header).EmfHeader.szlMillimeters.cy * 25.4);
 732     expect(0, header.X);
 733     expect(0, header.Y);
 734     expect(100, header.Width);
 735     expect(100, header.Height);
 736     expect(0, header.EmfPlusHeaderSize);
 737     expect(0, header.LogicalDpiX);
 738     expect(0, header.LogicalDpiX);
 739     expect(EMR_HEADER, U(header).EmfHeader.iType);
 740     expect(25, U(header).EmfHeader.rclBounds.left);
 741     expect(25, U(header).EmfHeader.rclBounds.top);
 742     expect(74, U(header).EmfHeader.rclBounds.right);
 743     expect(74, U(header).EmfHeader.rclBounds.bottom);
 744     expect(0, U(header).EmfHeader.rclFrame.left);
 745     expect(0, U(header).EmfHeader.rclFrame.top);
 746     expectf_(100.0, U(header).EmfHeader.rclFrame.right * xres / 2540.0, 2.0);
 747     expectf_(100.0, U(header).EmfHeader.rclFrame.bottom * yres / 2540.0, 2.0);
 748
 749     stat = GdipCreateMetafileFromEmf(hemf, TRUE, &metafile);
 750     expect(Ok, stat);
 751
 752     stat = GdipGetImageBounds((GpImage*)metafile, &bounds, &unit);
 753     expect(Ok, stat);
 754     expectf(0.0, bounds.X);
 755     expectf(0.0, bounds.Y);
 756     expectf_(100.0, bounds.Width, 0.05);
 757     expectf_(100.0, bounds.Height, 0.05);
 758     expect(UnitPixel, unit);
 759
 760     stat = GdipGetImageHorizontalResolution((GpImage*)metafile, &xres);
 761     expect(Ok, stat);
 762     expectf(header.DpiX, xres);
 763
 764     stat = GdipGetImageVerticalResolution((GpImage*)metafile, &yres);
 765     expect(Ok, stat);
 766     expectf(header.DpiY, yres);
 767
 768     stat = GdipDisposeImage((GpImage*)metafile);
 769     expect(Ok, stat);
 770 }
 771
 772 static const emfplus_record fillrect_records[] = {
 773     {0, EMR_HEADER},
 774     {0, EmfPlusRecordTypeHeader},
 775     {0, EmfPlusRecordTypeFillRects},
 776     {0, EmfPlusRecordTypeEndOfFile},
 777     {0, EMR_EOF},
 778     {0}
 779 };
 780
 781 static void test_fillrect(void)
 782 {
 783     GpStatus stat;
 784     GpMetafile *metafile;
 785     GpGraphics *graphics;
 786     HDC hdc;
 787     HENHMETAFILE hemf;
 788     static const GpRectF frame = {0.0, 0.0, 100.0, 100.0};
 789     static const GpPointF dst_points[3] = {{0.0,0.0},{100.0,0.0},{0.0,100.0}};
 790     static const GpPointF dst_points_half[3] = {{0.0,0.0},{50.0,0.0},{0.0,50.0}};
 791     static const WCHAR description[] = {'w','i','n','e','t','e','s','t',0};
 792     GpBitmap *bitmap;
 793     ARGB color;
 794     GpBrush *brush;
 795
 796     hdc = CreateCompatibleDC(0);
 797
 798     stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, &frame, MetafileFrameUnitPixel, description, &metafile);
 799     expect(Ok, stat);
 800
 801     DeleteDC(hdc);
 802
 803     if (stat != Ok)
 804         return;
 805
 806     stat = GdipGetHemfFromMetafile(metafile, &hemf);
 807     expect(InvalidParameter, stat);
 808
 809     stat = GdipGetImageGraphicsContext((GpImage*)metafile, &graphics);
 810     expect(Ok, stat);
 811
 812     stat = GdipCreateSolidFill((ARGB)0xff0000ff, (GpSolidFill**)&brush);
 813     expect(Ok, stat);
 814
 815     stat = GdipFillRectangleI(graphics, brush, 25, 25, 75, 75);
 816     expect(Ok, stat);
 817
 818     stat = GdipDeleteBrush(brush);
 819     expect(Ok, stat);
 820
 821     stat = GdipDeleteGraphics(graphics);
 822     expect(Ok, stat);
 823
 824     check_metafile(metafile, fillrect_records, "fillrect metafile", dst_points, &frame, UnitPixel);
 825
 826     sync_metafile(&metafile, "fillrect.emf");
 827
 828     stat = GdipCreateBitmapFromScan0(100, 100, 0, PixelFormat32bppARGB, NULL, &bitmap);
 829     expect(Ok, stat);
 830
 831     stat = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
 832     expect(Ok, stat);
 833
 834     play_metafile(metafile, graphics, fillrect_records, "fillrect playback", dst_points, &frame, UnitPixel);
 835
 836     stat = GdipBitmapGetPixel(bitmap, 15, 15, &color);
 837     expect(Ok, stat);
 838     expect(0, color);
 839
 840     stat = GdipBitmapGetPixel(bitmap, 50, 50, &color);
 841     expect(Ok, stat);
 842     expect(0xff0000ff, color);
 843
 844     stat = GdipBitmapSetPixel(bitmap, 50, 50, 0);
 845     expect(Ok, stat);
 846
 847     play_metafile(metafile, graphics, fillrect_records, "fillrect playback", dst_points_half, &frame, UnitPixel);
 848
 849     stat = GdipBitmapGetPixel(bitmap, 15, 15, &color);
 850     expect(Ok, stat);
 851     expect(0xff0000ff, color);
 852
 853     stat = GdipBitmapGetPixel(bitmap, 50, 50, &color);
 854     expect(Ok, stat);
 855     expect(0, color);
 856
 857     stat = GdipBitmapSetPixel(bitmap, 15, 15, 0);
 858     expect(Ok, stat);
 859
 860     stat = GdipDrawImagePointsRect(graphics, (GpImage*)metafile, dst_points, 3,
 861         0.0, 0.0, 100.0, 100.0, UnitPixel, NULL, NULL, NULL);
 862     expect(Ok, stat);
 863
 864     stat = GdipBitmapGetPixel(bitmap, 15, 15, &color);
 865     expect(Ok, stat);
 866     expect(0, color);
 867
 868     stat = GdipBitmapGetPixel(bitmap, 50, 50, &color);
 869     expect(Ok, stat);
 870     expect(0xff0000ff, color);
 871
 872     stat = GdipDeleteGraphics(graphics);
 873     expect(Ok, stat);
 874
 875     stat = GdipDisposeImage((GpImage*)bitmap);
 876     expect(Ok, stat);
 877
 878     stat = GdipDisposeImage((GpImage*)metafile);
 879     expect(Ok, stat);
 880 }
 881
 882 static const emfplus_record clear_emf_records[] = {
 883     {0, EMR_HEADER},
 884     {0, EmfPlusRecordTypeHeader},
 885     {0, EmfPlusRecordTypeClear},
 886     {1, EMR_SAVEDC},
 887     {1, EMR_SETICMMODE},
 888     {1, EMR_BITBLT},
 889     {1, EMR_RESTOREDC},
 890     {0, EmfPlusRecordTypeEndOfFile},
 891     {0, EMR_EOF},
 892     {0}
 893 };
 894
 895 static void test_clear(void)
 896 {
 897     GpStatus stat;
 898     GpMetafile *metafile;
 899     GpGraphics *graphics;
 900     HDC hdc;
 901     HENHMETAFILE hemf;
 902     static const GpRectF frame = {0.0, 0.0, 100.0, 100.0};
 903     static const GpPointF dst_points[3] = {{10.0,10.0},{20.0,10.0},{10.0,20.0}};
 904     static const WCHAR description[] = {'w','i','n','e','t','e','s','t',0};
 905     GpBitmap *bitmap;
 906     ARGB color;
 907
 908     hdc = CreateCompatibleDC(0);
 909
 910     stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, &frame, MetafileFrameUnitPixel, description, &metafile);
 911     expect(Ok, stat);
 912
 913     DeleteDC(hdc);
 914
 915     if (stat != Ok)
 916         return;
 917
 918     stat = GdipGetHemfFromMetafile(metafile, &hemf);
 919     expect(InvalidParameter, stat);
 920
 921     stat = GdipGetImageGraphicsContext((GpImage*)metafile, &graphics);
 922     expect(Ok, stat);
 923
 924     stat = GdipGraphicsClear(graphics, 0xffffff00);
 925     expect(Ok, stat);
 926
 927     stat = GdipDeleteGraphics(graphics);
 928     expect(Ok, stat);
 929
 930     sync_metafile(&metafile, "clear.emf");
 931
 932     stat = GdipCreateBitmapFromScan0(30, 30, 0, PixelFormat32bppRGB, NULL, &bitmap);
 933     expect(Ok, stat);
 934
 935     stat = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
 936     expect(Ok, stat);
 937
 938     stat = GdipDrawImagePointsRect(graphics, (GpImage*)metafile, dst_points, 3,
 939         0.0, 0.0, 100.0, 100.0, UnitPixel, NULL, NULL, NULL);
 940     expect(Ok, stat);
 941
 942     stat = GdipBitmapGetPixel(bitmap, 5, 5, &color);
 943     expect(Ok, stat);
 944     expect(0xff000000, color);
 945
 946     stat = GdipBitmapGetPixel(bitmap, 15, 15, &color);
 947     expect(Ok, stat);
 948     expect(0xffffff00, color);
 949
 950     stat = GdipBitmapGetPixel(bitmap, 25, 25, &color);
 951     expect(Ok, stat);
 952     expect(0xff000000, color);
 953
 954     stat = GdipDeleteGraphics(graphics);
 955     expect(Ok, stat);
 956
 957     stat = GdipDisposeImage((GpImage*)bitmap);
 958     expect(Ok, stat);
 959
 960     stat = GdipGetHemfFromMetafile(metafile, &hemf);
 961     expect(Ok, stat);
 962
 963     stat = GdipDisposeImage((GpImage*)metafile);
 964     expect(Ok, stat);
 965
 966     check_emfplus(hemf, clear_emf_records, "clear emf");
 967
 968     DeleteEnhMetaFile(hemf);
 969 }
 970
 971 static void test_nullframerect(void) {
 972     GpStatus stat;
 973     GpMetafile *metafile;
 974     GpGraphics *graphics;
 975     HDC hdc, metafile_dc;
 976     static const WCHAR description[] = {'w','i','n','e','t','e','s','t',0};
 977     GpBrush *brush;
 978     HBRUSH hbrush, holdbrush;
 979     GpRectF bounds;
 980     GpUnit unit;
 981
 982     hdc = CreateCompatibleDC(0);
 983
 984     stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, NULL, MetafileFrameUnitPixel, description, &metafile);
 985     expect(Ok, stat);
 986
 987     DeleteDC(hdc);
 988
 989     if (stat != Ok)
 990         return;
 991
 992     stat = GdipGetImageBounds((GpImage*)metafile, &bounds, &unit);
 993     expect(Ok, stat);
 994     expect(UnitPixel, unit);
 995     expectf(0.0, bounds.X);
 996     expectf(0.0, bounds.Y);
 997     ok(bounds.Width == 1.0 || broken(bounds.Width == 0.0) /* xp sp1 */,
 998         "expected 1.0, got %f\n", bounds.Width);
 999     ok(bounds.Height == 1.0 || broken(bounds.Height == 0.0) /* xp sp1 */,
1000         "expected 1.0, got %f\n", bounds.Height);
1001
1002     stat = GdipGetImageGraphicsContext((GpImage*)metafile, &graphics);
1003     expect(Ok, stat);
1004
1005     stat = GdipCreateSolidFill((ARGB)0xff0000ff, (GpSolidFill**)&brush);
1006     expect(Ok, stat);
1007
1008     stat = GdipFillRectangleI(graphics, brush, 25, 25, 75, 75);
1009     expect(Ok, stat);
1010
1011     stat = GdipDeleteBrush(brush);
1012     expect(Ok, stat);
1013
1014     stat = GdipGetImageBounds((GpImage*)metafile, &bounds, &unit);
1015     expect(Ok, stat);
1016     expect(UnitPixel, unit);
1017     expectf(0.0, bounds.X);
1018     expectf(0.0, bounds.Y);
1019     ok(bounds.Width == 1.0 || broken(bounds.Width == 0.0) /* xp sp1 */,
1020         "expected 1.0, got %f\n", bounds.Width);
1021     ok(bounds.Height == 1.0 || broken(bounds.Height == 0.0) /* xp sp1 */,
1022         "expected 1.0, got %f\n", bounds.Height);
1023
1024     stat = GdipDeleteGraphics(graphics);
1025     expect(Ok, stat);
1026
1027     stat = GdipGetImageBounds((GpImage*)metafile, &bounds, &unit);
1028     expect(Ok, stat);
1029     expect(UnitPixel, unit);
1030     expectf_(25.0, bounds.X, 0.05);
1031     expectf_(25.0, bounds.Y, 0.05);
1032     expectf_(75.0, bounds.Width, 0.05);
1033     expectf_(75.0, bounds.Height, 0.05);
1034
1035     stat = GdipDisposeImage((GpImage*)metafile);
1036     expect(Ok, stat);
1037
1038     hdc = CreateCompatibleDC(0);
1039
1040     stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, NULL, MetafileFrameUnitMillimeter, description, &metafile);
1041     expect(Ok, stat);
1042
1043     DeleteDC(hdc);
1044
1045     stat = GdipGetImageGraphicsContext((GpImage*)metafile, &graphics);
1046     expect(Ok, stat);
1047
1048     stat = GdipGetDC(graphics, &metafile_dc);
1049     expect(Ok, stat);
1050
1051     if (stat != Ok)
1052     {
1053         GdipDeleteGraphics(graphics);
1054         GdipDisposeImage((GpImage*)metafile);
1055         return;
1056     }
1057
1058     hbrush = CreateSolidBrush(0xff0000);
1059
1060     holdbrush = SelectObject(metafile_dc, hbrush);
1061
1062     Rectangle(metafile_dc, 25, 25, 75, 75);
1063
1064     SelectObject(metafile_dc, holdbrush);
1065
1066     DeleteObject(hbrush);
1067
1068     stat = GdipReleaseDC(graphics, metafile_dc);
1069     expect(Ok, stat);
1070
1071     stat = GdipDeleteGraphics(graphics);
1072     expect(Ok, stat);
1073
1074     stat = GdipGetImageBounds((GpImage*)metafile, &bounds, &unit);
1075     expect(Ok, stat);
1076     expect(UnitPixel, unit);
1077     expectf_(25.0, bounds.X, 0.05);
1078     expectf_(25.0, bounds.Y, 0.05);
1079     todo_wine expectf_(50.0, bounds.Width, 0.05);
1080     todo_wine expectf_(50.0, bounds.Height, 0.05);
1081
1082     stat = GdipDisposeImage((GpImage*)metafile);
1083     expect(Ok, stat);
1084 }
1085
1086 static const emfplus_record pagetransform_records[] = {
1087     {0, EMR_HEADER},
1088     {0, EmfPlusRecordTypeHeader},
1089     {0, EmfPlusRecordTypeFillRects},
1090     {0, EmfPlusRecordTypeSetPageTransform},
1091     {0, EmfPlusRecordTypeFillRects},
1092     {0, EmfPlusRecordTypeSetPageTransform},
1093     {0, EmfPlusRecordTypeFillRects},
1094     {0, EmfPlusRecordTypeSetPageTransform},
1095     {0, EmfPlusRecordTypeFillRects},
1096     {0, EmfPlusRecordTypeSetPageTransform},
1097     {0, EmfPlusRecordTypeFillRects},
1098     {0, EmfPlusRecordTypeEndOfFile},
1099     {0, EMR_EOF},
1100     {0}
1101 };
1102
1103 static void test_pagetransform(void)
1104 {
1105     GpStatus stat;
1106     GpMetafile *metafile;
1107     GpGraphics *graphics;
1108     HDC hdc;
1109     static const GpRectF frame = {0.0, 0.0, 5.0, 5.0};
1110     static const GpPointF dst_points[3] = {{0.0,0.0},{100.0,0.0},{0.0,100.0}};
1111     static const WCHAR description[] = {'w','i','n','e','t','e','s','t',0};
1112     GpBitmap *bitmap;
1113     ARGB color;
1114     GpBrush *brush;
1115     GpUnit unit;
1116     REAL scale, dpix, dpiy;
1117     UINT width, height;
1118
1119     hdc = CreateCompatibleDC(0);
1120
1121     stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, &frame, MetafileFrameUnitInch, description, &metafile);
1122     expect(Ok, stat);
1123
1124     DeleteDC(hdc);
1125
1126     if (stat != Ok)
1127         return;
1128
1129     stat = GdipGetImageHorizontalResolution((GpImage*)metafile, &dpix);
1130     todo_wine expect(InvalidParameter, stat);
1131
1132     stat = GdipGetImageVerticalResolution((GpImage*)metafile, &dpiy);
1133     todo_wine expect(InvalidParameter, stat);
1134
1135     stat = GdipGetImageWidth((GpImage*)metafile, &width);
1136     todo_wine expect(InvalidParameter, stat);
1137
1138     stat = GdipGetImageHeight((GpImage*)metafile, &height);
1139     todo_wine expect(InvalidParameter, stat);
1140
1141     stat = GdipGetImageGraphicsContext((GpImage*)metafile, &graphics);
1142     expect(Ok, stat);
1143
1144     /* initial scale */
1145     stat = GdipGetPageUnit(graphics, &unit);
1146     expect(Ok, stat);
1147     expect(UnitDisplay, unit);
1148
1149     stat = GdipGetPageScale(graphics, &scale);
1150     expect(Ok, stat);
1151     expectf(1.0, scale);
1152
1153     stat = GdipGetDpiX(graphics, &dpix);
1154     expect(Ok, stat);
1155     expectf(96.0, dpix);
1156
1157     stat = GdipGetDpiY(graphics, &dpiy);
1158     expect(Ok, stat);
1159     expectf(96.0, dpiy);
1160
1161     stat = GdipCreateSolidFill((ARGB)0xff0000ff, (GpSolidFill**)&brush);
1162     expect(Ok, stat);
1163
1164     stat = GdipFillRectangleI(graphics, brush, 1, 2, 1, 1);
1165     expect(Ok, stat);
1166
1167     stat = GdipDeleteBrush(brush);
1168     expect(Ok, stat);
1169
1170     /* page unit = pixels */
1171     stat = GdipSetPageUnit(graphics, UnitPixel);
1172     expect(Ok, stat);
1173
1174     stat = GdipGetPageUnit(graphics, &unit);
1175     expect(Ok, stat);
1176     expect(UnitPixel, unit);
1177
1178     stat = GdipCreateSolidFill((ARGB)0xff00ff00, (GpSolidFill**)&brush);
1179     expect(Ok, stat);
1180
1181     stat = GdipFillRectangleI(graphics, brush, 0, 1, 1, 1);
1182     expect(Ok, stat);
1183
1184     stat = GdipDeleteBrush(brush);
1185     expect(Ok, stat);
1186
1187     /* page scale = 3, unit = pixels */
1188     stat = GdipSetPageScale(graphics, 3.0);
1189     expect(Ok, stat);
1190
1191     stat = GdipGetPageScale(graphics, &scale);
1192     expect(Ok, stat);
1193     expectf(3.0, scale);
1194
1195     stat = GdipCreateSolidFill((ARGB)0xff00ffff, (GpSolidFill**)&brush);
1196     expect(Ok, stat);
1197
1198     stat = GdipFillRectangleI(graphics, brush, 0, 1, 2, 2);
1199     expect(Ok, stat);
1200
1201     stat = GdipDeleteBrush(brush);
1202     expect(Ok, stat);
1203
1204     /* page scale = 3, unit = inches */
1205     stat = GdipSetPageUnit(graphics, UnitInch);
1206     expect(Ok, stat);
1207
1208     stat = GdipGetPageUnit(graphics, &unit);
1209     expect(Ok, stat);
1210     expect(UnitInch, unit);
1211
1212     stat = GdipCreateSolidFill((ARGB)0xffff0000, (GpSolidFill**)&brush);
1213     expect(Ok, stat);
1214
1215     stat = GdipFillRectangle(graphics, brush, 1.0/96.0, 0, 1, 1);
1216     expect(Ok, stat);
1217
1218     stat = GdipDeleteBrush(brush);
1219     expect(Ok, stat);
1220
1221     /* page scale = 3, unit = display */
1222     stat = GdipSetPageUnit(graphics, UnitDisplay);
1223     expect(Ok, stat);
1224
1225     stat = GdipGetPageUnit(graphics, &unit);
1226     expect(Ok, stat);
1227     expect(UnitDisplay, unit);
1228
1229     stat = GdipCreateSolidFill((ARGB)0xffff00ff, (GpSolidFill**)&brush);
1230     expect(Ok, stat);
1231
1232     stat = GdipFillRectangle(graphics, brush, 3, 3, 2, 2);
1233     expect(Ok, stat);
1234
1235     stat = GdipDeleteBrush(brush);
1236     expect(Ok, stat);
1237
1238     stat = GdipDeleteGraphics(graphics);
1239     expect(Ok, stat);
1240
1241     check_metafile(metafile, pagetransform_records, "pagetransform metafile", dst_points, &frame, UnitPixel);
1242
1243     sync_metafile(&metafile, "pagetransform.emf");
1244
1245     stat = GdipCreateBitmapFromScan0(100, 100, 0, PixelFormat32bppARGB, NULL, &bitmap);
1246     expect(Ok, stat);
1247
1248     stat = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
1249     expect(Ok, stat);
1250
1251     play_metafile(metafile, graphics, pagetransform_records, "pagetransform playback", dst_points, &frame, UnitPixel);
1252
1253     stat = GdipBitmapGetPixel(bitmap, 50, 50, &color);
1254     expect(Ok, stat);
1255     expect(0, color);
1256
1257     stat = GdipBitmapGetPixel(bitmap, 30, 50, &color);
1258     expect(Ok, stat);
1259     expect(0xff0000ff, color);
1260
1261     stat = GdipBitmapGetPixel(bitmap, 10, 30, &color);
1262     expect(Ok, stat);
1263     expect(0xff00ff00, color);
1264
1265     stat = GdipBitmapGetPixel(bitmap, 20, 80, &color);
1266     expect(Ok, stat);
1267     expect(0xff00ffff, color);
1268
1269     stat = GdipBitmapGetPixel(bitmap, 80, 20, &color);
1270     expect(Ok, stat);
1271     expect(0xffff0000, color);
1272
1273     stat = GdipBitmapGetPixel(bitmap, 80, 80, &color);
1274     expect(Ok, stat);
1275     expect(0xffff00ff, color);
1276
1277     stat = GdipDeleteGraphics(graphics);
1278     expect(Ok, stat);
1279
1280     stat = GdipDisposeImage((GpImage*)bitmap);
1281     expect(Ok, stat);
1282
1283     stat = GdipDisposeImage((GpImage*)metafile);
1284     expect(Ok, stat);
1285 }
1286
1287 static const emfplus_record worldtransform_records[] = {
1288     {0, EMR_HEADER},
1289     {0, EmfPlusRecordTypeHeader},
1290     {0, EmfPlusRecordTypeFillRects},
1291     {0, EmfPlusRecordTypeScaleWorldTransform},
1292     {0, EmfPlusRecordTypeFillRects},
1293     {0, EmfPlusRecordTypeResetWorldTransform},
1294     {0, EmfPlusRecordTypeFillRects},
1295     {0, EmfPlusRecordTypeMultiplyWorldTransform},
1296     {0, EmfPlusRecordTypeFillRects},
1297     {0, EmfPlusRecordTypeRotateWorldTransform},
1298     {0, EmfPlusRecordTypeFillRects},
1299     {0, EmfPlusRecordTypeEndOfFile},
1300     {0, EMR_EOF},
1301     {0}
1302 };
1303
1304 static void test_worldtransform(void)
1305 {
1306     GpStatus stat;
1307     GpMetafile *metafile;
1308     GpGraphics *graphics;
1309     HDC hdc;
1310     static const GpRectF frame = {0.0, 0.0, 5.0, 5.0};
1311     static const GpPointF dst_points[3] = {{0.0,0.0},{100.0,0.0},{0.0,100.0}};
1312     static const WCHAR description[] = {'w','i','n','e','t','e','s','t',0};
1313     GpBitmap *bitmap;
1314     ARGB color;
1315     GpBrush *brush;
1316     GpMatrix *transform;
1317     BOOL identity;
1318     REAL elements[6];
1319
1320     hdc = CreateCompatibleDC(0);
1321
1322     stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, &frame, MetafileFrameUnitPixel, description, &metafile);
1323     expect(Ok, stat);
1324
1325     DeleteDC(hdc);
1326
1327     if (stat != Ok)
1328         return;
1329
1330     stat = GdipCreateMatrix(&transform);
1331     expect(Ok, stat);
1332
1333     stat = GdipGetImageGraphicsContext((GpImage*)metafile, &graphics);
1334     expect(Ok, stat);
1335
1336     /* initial transform */
1337     stat = GdipGetWorldTransform(graphics, transform);
1338     expect(Ok, stat);
1339
1340     stat = GdipIsMatrixIdentity(transform, &identity);
1341     expect(Ok, stat);
1342     expect(TRUE, identity);
1343
1344     stat = GdipCreateSolidFill((ARGB)0xff0000ff, (GpSolidFill**)&brush);
1345     expect(Ok, stat);
1346
1347     stat = GdipFillRectangleI(graphics, brush, 0, 0, 1, 1);
1348     expect(Ok, stat);
1349
1350     stat = GdipDeleteBrush(brush);
1351     expect(Ok, stat);
1352
1353     /* scale transform */
1354     stat = GdipScaleWorldTransform(graphics, 2.0, 4.0, MatrixOrderPrepend);
1355     expect(Ok, stat);
1356
1357     stat = GdipGetWorldTransform(graphics, transform);
1358     expect(Ok, stat);
1359
1360     stat = GdipGetMatrixElements(transform, elements);
1361     expect(Ok, stat);
1362     expectf(2.0, elements[0]);
1363     expectf(0.0, elements[1]);
1364     expectf(0.0, elements[2]);
1365     expectf(4.0, elements[3]);
1366     expectf(0.0, elements[4]);
1367     expectf(0.0, elements[5]);
1368
1369     stat = GdipCreateSolidFill((ARGB)0xff00ff00, (GpSolidFill**)&brush);
1370     expect(Ok, stat);
1371
1372     stat = GdipFillRectangle(graphics, brush, 0.5, 0.5, 0.5, 0.25);
1373     expect(Ok, stat);
1374
1375     stat = GdipDeleteBrush(brush);
1376     expect(Ok, stat);
1377
1378     /* reset transform */
1379     stat = GdipResetWorldTransform(graphics);
1380     expect(Ok, stat);
1381
1382     stat = GdipGetWorldTransform(graphics, transform);
1383     expect(Ok, stat);
1384
1385     stat = GdipIsMatrixIdentity(transform, &identity);
1386     expect(Ok, stat);
1387     expect(TRUE, identity);
1388
1389     stat = GdipCreateSolidFill((ARGB)0xff00ffff, (GpSolidFill**)&brush);
1390     expect(Ok, stat);
1391
1392     stat = GdipFillRectangle(graphics, brush, 1.0, 0.0, 1.0, 1.0);
1393     expect(Ok, stat);
1394
1395     stat = GdipDeleteBrush(brush);
1396     expect(Ok, stat);
1397
1398     /* multiply transform */
1399     stat = GdipSetMatrixElements(transform, 2.0, 0.0, 0.0, 1.0, 0.0, 0.0);
1400     expect(Ok, stat);
1401
1402     stat = GdipMultiplyWorldTransform(graphics, transform, MatrixOrderPrepend);
1403     expect(Ok, stat);
1404
1405     stat = GdipGetWorldTransform(graphics, transform);
1406     expect(Ok, stat);
1407
1408     stat = GdipGetMatrixElements(transform, elements);
1409     expect(Ok, stat);
1410     expectf(2.0, elements[0]);
1411     expectf(0.0, elements[1]);
1412     expectf(0.0, elements[2]);
1413     expectf(1.0, elements[3]);
1414     expectf(0.0, elements[4]);
1415     expectf(0.0, elements[5]);
1416
1417     stat = GdipCreateSolidFill((ARGB)0xffff0000, (GpSolidFill**)&brush);
1418     expect(Ok, stat);
1419
1420     stat = GdipFillRectangle(graphics, brush, 1.0, 1.0, 0.5, 1.0);
1421     expect(Ok, stat);
1422
1423     stat = GdipDeleteBrush(brush);
1424     expect(Ok, stat);
1425
1426     /* rotate transform */
1427     stat = GdipRotateWorldTransform(graphics, 90.0, MatrixOrderAppend);
1428     expect(Ok, stat);
1429
1430     stat = GdipGetWorldTransform(graphics, transform);
1431     expect(Ok, stat);
1432
1433     stat = GdipGetMatrixElements(transform, elements);
1434     expect(Ok, stat);
1435     expectf(0.0, elements[0]);
1436     expectf(2.0, elements[1]);
1437     expectf(-1.0, elements[2]);
1438     expectf(0.0, elements[3]);
1439     expectf(0.0, elements[4]);
1440     expectf(0.0, elements[5]);
1441
1442     stat = GdipCreateSolidFill((ARGB)0xffff00ff, (GpSolidFill**)&brush);
1443     expect(Ok, stat);
1444
1445     stat = GdipFillRectangle(graphics, brush, 1.0, -1.0, 0.5, 1.0);
1446     expect(Ok, stat);
1447
1448     stat = GdipDeleteBrush(brush);
1449     expect(Ok, stat);
1450
1451     stat = GdipDeleteMatrix(transform);
1452     expect(Ok, stat);
1453
1454     stat = GdipDeleteGraphics(graphics);
1455     expect(Ok, stat);
1456
1457     check_metafile(metafile, worldtransform_records, "worldtransform metafile", dst_points, &frame, UnitPixel);
1458
1459     sync_metafile(&metafile, "worldtransform.emf");
1460
1461     stat = GdipCreateBitmapFromScan0(100, 100, 0, PixelFormat32bppARGB, NULL, &bitmap);
1462     expect(Ok, stat);
1463
1464     stat = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
1465     expect(Ok, stat);
1466
1467     play_metafile(metafile, graphics, worldtransform_records, "worldtransform playback", dst_points, &frame, UnitPixel);
1468
1469     stat = GdipBitmapGetPixel(bitmap, 80, 80, &color);
1470     expect(Ok, stat);
1471     expect(0, color);
1472
1473     stat = GdipBitmapGetPixel(bitmap, 10, 10, &color);
1474     expect(Ok, stat);
1475     expect(0xff0000ff, color);
1476
1477     stat = GdipBitmapGetPixel(bitmap, 30, 50, &color);
1478     expect(Ok, stat);
1479     expect(0xff00ff00, color);
1480
1481     stat = GdipBitmapGetPixel(bitmap, 30, 10, &color);
1482     expect(Ok, stat);
1483     expect(0xff00ffff, color);
1484
1485     stat = GdipBitmapGetPixel(bitmap, 50, 30, &color);
1486     expect(Ok, stat);
1487     expect(0xffff0000, color);
1488
1489     stat = GdipBitmapGetPixel(bitmap, 10, 50, &color);
1490     expect(Ok, stat);
1491     expect(0xffff00ff, color);
1492
1493     stat = GdipDeleteGraphics(graphics);
1494     expect(Ok, stat);
1495
1496     stat = GdipDisposeImage((GpImage*)bitmap);
1497     expect(Ok, stat);
1498
1499     stat = GdipDisposeImage((GpImage*)metafile);
1500     expect(Ok, stat);
1501 }
1502
1503 static void test_converttoemfplus(void)
1504 {
1505     GpStatus (WINAPI *pGdipConvertToEmfPlus)( const GpGraphics *graphics, GpMetafile *metafile, BOOL *succ,
1506               EmfType emfType, const WCHAR *description, GpMetafile **outmetafile);
1507     static const GpRectF frame = {0.0, 0.0, 100.0, 100.0};
1508     static const WCHAR description[] = {'w','i','n','e','t','e','s','t',0};
1509     GpStatus stat;
1510     GpMetafile *metafile, *metafile2 = NULL, *emhmeta;
1511     GpGraphics *graphics;
1512     HDC hdc;
1513     BOOL succ;
1514     HMODULE mod = GetModuleHandleA("gdiplus.dll");
1515
1516     pGdipConvertToEmfPlus = (void*)GetProcAddress( mod, "GdipConvertToEmfPlus");
1517     if(!pGdipConvertToEmfPlus)
1518     {
1519         /* GdipConvertToEmfPlus was introduced in Windows Vista. */
1520         win_skip("GDIPlus version 1.1 not available\n");
1521         return;
1522     }
1523
1524     hdc = CreateCompatibleDC(0);
1525
1526     stat = GdipRecordMetafile(hdc, MetafileTypeEmf, &frame, MetafileFrameUnitPixel, description, &metafile);
1527     expect(Ok, stat);
1528
1529     stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, &frame, MetafileFrameUnitPixel, description, &emhmeta);
1530     expect(Ok, stat);
1531
1532     DeleteDC(hdc);
1533
1534     if (stat != Ok)
1535         return;
1536
1537     stat = GdipGetImageGraphicsContext((GpImage*)metafile, &graphics);
1538     expect(Ok, stat);
1539
1540     /* Invalid Parameters */
1541     stat = pGdipConvertToEmfPlus(NULL, metafile, &succ, EmfTypeEmfPlusOnly, description, &metafile2);
1542     expect(InvalidParameter, stat);
1543
1544     stat = pGdipConvertToEmfPlus(graphics, NULL, &succ, EmfTypeEmfPlusOnly, description, &metafile2);
1545     expect(InvalidParameter, stat);
1546
1547     stat = pGdipConvertToEmfPlus(graphics, metafile, &succ, EmfTypeEmfPlusOnly, description, NULL);
1548     expect(InvalidParameter, stat);
1549
1550     stat = pGdipConvertToEmfPlus(graphics, metafile, NULL, MetafileTypeInvalid, NULL, &metafile2);
1551     expect(InvalidParameter, stat);
1552
1553     stat = pGdipConvertToEmfPlus(graphics, metafile, NULL, MetafileTypeEmfPlusDual+1, NULL, &metafile2);
1554     expect(InvalidParameter, stat);
1555
1556     /* If we are already an Enhanced Metafile then the conversion fails. */
1557     stat = pGdipConvertToEmfPlus(graphics, emhmeta, NULL, EmfTypeEmfPlusOnly, NULL, &metafile2);
1558     todo_wine expect(InvalidParameter, stat);
1559
1560     stat = pGdipConvertToEmfPlus(graphics, metafile, NULL, EmfTypeEmfPlusOnly, NULL, &metafile2);
1561     todo_wine expect(Ok, stat);
1562     if(metafile2)
1563         GdipDisposeImage((GpImage*)metafile2);
1564
1565     succ = FALSE;
1566     stat = pGdipConvertToEmfPlus(graphics, metafile, &succ, EmfTypeEmfPlusOnly, NULL, &metafile2);
1567     todo_wine expect(Ok, stat);
1568     if(metafile2)
1569         GdipDisposeImage((GpImage*)metafile2);
1570
1571     stat = GdipDeleteGraphics(graphics);
1572     expect(Ok, stat);
1573
1574     stat = GdipDisposeImage((GpImage*)metafile);
1575     expect(Ok, stat);
1576
1577     stat = GdipDisposeImage((GpImage*)emhmeta);
1578     expect(Ok, stat);
1579 }
1580
1581 static void test_frameunit(void)
1582 {
1583     GpStatus stat;
1584     GpMetafile *metafile;
1585     GpGraphics *graphics;
1586     HDC hdc;
1587     static const GpRectF frame = {0.0, 0.0, 5.0, 5.0};
1588     static const WCHAR description[] = {'w','i','n','e','t','e','s','t',0};
1589     GpUnit unit;
1590     REAL dpix, dpiy;
1591     GpRectF bounds;
1592
1593     hdc = CreateCompatibleDC(0);
1594
1595     stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, &frame, MetafileFrameUnitInch, description, &metafile);
1596     expect(Ok, stat);
1597
1598     DeleteDC(hdc);
1599
1600     if (stat != Ok)
1601         return;
1602
1603     stat = GdipGetImageBounds((GpImage*)metafile, &bounds, &unit);
1604     expect(Ok, stat);
1605     expect(UnitPixel, unit);
1606     expectf(0.0, bounds.X);
1607     expectf(0.0, bounds.Y);
1608     ok(bounds.Width == 1.0 || broken(bounds.Width == 0.0) /* xp sp1 */,
1609         "expected 1.0, got %f\n", bounds.Width);
1610     ok(bounds.Height == 1.0 || broken(bounds.Height == 0.0) /* xp sp1 */,
1611         "expected 1.0, got %f\n", bounds.Height);
1612
1613     stat = GdipGetImageGraphicsContext((GpImage*)metafile, &graphics);
1614     expect(Ok, stat);
1615
1616     stat = GdipGetImageBounds((GpImage*)metafile, &bounds, &unit);
1617     expect(Ok, stat);
1618     expect(UnitPixel, unit);
1619     expectf(0.0, bounds.X);
1620     expectf(0.0, bounds.Y);
1621     ok(bounds.Width == 1.0 || broken(bounds.Width == 0.0) /* xp sp1 */,
1622         "expected 1.0, got %f\n", bounds.Width);
1623     ok(bounds.Height == 1.0 || broken(bounds.Height == 0.0) /* xp sp1 */,
1624         "expected 1.0, got %f\n", bounds.Height);
1625
1626     stat = GdipDeleteGraphics(graphics);
1627     expect(Ok, stat);
1628
1629     stat = GdipGetImageHorizontalResolution((GpImage*)metafile, &dpix);
1630     expect(Ok, stat);
1631
1632     stat = GdipGetImageVerticalResolution((GpImage*)metafile, &dpiy);
1633     expect(Ok, stat);
1634
1635     stat = GdipGetImageBounds((GpImage*)metafile, &bounds, &unit);
1636     expect(Ok, stat);
1637     expect(UnitPixel, unit);
1638     expectf(0.0, bounds.X);
1639     expectf(0.0, bounds.Y);
1640     expectf_(5.0 * dpix, bounds.Width, 1.0);
1641     expectf_(5.0 * dpiy, bounds.Height, 1.0);
1642
1643     stat = GdipDisposeImage((GpImage*)metafile);
1644     expect(Ok, stat);
1645 }
1646
1647 START_TEST(metafile)
1648 {
1649     struct GdiplusStartupInput gdiplusStartupInput;
1650     ULONG_PTR gdiplusToken;
1651     int myARGC;
1652     char **myARGV;
1653
1654     gdiplusStartupInput.GdiplusVersion              = 1;
1655     gdiplusStartupInput.DebugEventCallback          = NULL;
1656     gdiplusStartupInput.SuppressBackgroundThread    = 0;
1657     gdiplusStartupInput.SuppressExternalCodecs      = 0;
1658
1659     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
1660
1661     myARGC = winetest_get_mainargs( &myARGV );
1662
1663     if (myARGC >= 3)
1664     {
1665         if (!strcmp(myARGV[2], "save"))
1666             save_metafiles = TRUE;
1667         else if (!strcmp(myARGV[2], "load"))
1668             load_metafiles = TRUE;
1669     }
1670
1671     test_empty();
1672     test_getdc();
1673     test_emfonly();
1674     test_fillrect();
1675     test_clear();
1676     test_nullframerect();
1677     test_pagetransform();
1678     test_worldtransform();
1679     test_converttoemfplus();
1680     test_frameunit();
1681
1682     GdiplusShutdown(gdiplusToken);
1683 }