dlls/gdiplus/metafile.c

   1 /*
   2  * Copyright (C) 2011 Vincent Povirk for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #include <math.h>
  21 #include <assert.h>
  22
  23 #define NONAMELESSUNION
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wingdi.h"
  28 #include "wine/unicode.h"
  29
  30 #define COBJMACROS
  31 #include "objbase.h"
  32 #include "ocidl.h"
  33 #include "olectl.h"
  34 #include "ole2.h"
  35
  36 #include "winreg.h"
  37 #include "shlwapi.h"
  38
  39 #include "gdiplus.h"
  40 #include "gdiplus_private.h"
  41 #include "wine/debug.h"
  42 #include "wine/list.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  45
  46 typedef struct EmfPlusARGB
  47 {
  48     BYTE Blue;
  49     BYTE Green;
  50     BYTE Red;
  51     BYTE Alpha;
  52 } EmfPlusARGB;
  53
  54 typedef struct EmfPlusRecordHeader
  55 {
  56     WORD Type;
  57     WORD Flags;
  58     DWORD Size;
  59     DWORD DataSize;
  60 } EmfPlusRecordHeader;
  61
  62 typedef struct EmfPlusHeader
  63 {
  64     EmfPlusRecordHeader Header;
  65     DWORD Version;
  66     DWORD EmfPlusFlags;
  67     DWORD LogicalDpiX;
  68     DWORD LogicalDpiY;
  69 } EmfPlusHeader;
  70
  71 typedef struct EmfPlusClear
  72 {
  73     EmfPlusRecordHeader Header;
  74     DWORD Color;
  75 } EmfPlusClear;
  76
  77 typedef struct EmfPlusFillRects
  78 {
  79     EmfPlusRecordHeader Header;
  80     DWORD BrushID;
  81     DWORD Count;
  82 } EmfPlusFillRects;
  83
  84 typedef struct EmfPlusSetClipRect
  85 {
  86     EmfPlusRecordHeader Header;
  87     GpRectF ClipRect;
  88 } EmfPlusSetClipRect;
  89
  90 typedef struct EmfPlusSetPageTransform
  91 {
  92     EmfPlusRecordHeader Header;
  93     REAL PageScale;
  94 } EmfPlusSetPageTransform;
  95
  96 typedef struct EmfPlusRect
  97 {
  98     SHORT X;
  99     SHORT Y;
 100     SHORT Width;
 101     SHORT Height;
 102 } EmfPlusRect;
 103
 104 typedef struct EmfPlusSetWorldTransform
 105 {
 106     EmfPlusRecordHeader Header;
 107     REAL MatrixData[6];
 108 } EmfPlusSetWorldTransform;
 109
 110 typedef struct EmfPlusScaleWorldTransform
 111 {
 112     EmfPlusRecordHeader Header;
 113     REAL Sx;
 114     REAL Sy;
 115 } EmfPlusScaleWorldTransform;
 116
 117 typedef struct EmfPlusMultiplyWorldTransform
 118 {
 119     EmfPlusRecordHeader Header;
 120     REAL MatrixData[6];
 121 } EmfPlusMultiplyWorldTransform;
 122
 123 typedef struct EmfPlusRotateWorldTransform
 124 {
 125     EmfPlusRecordHeader Header;
 126     REAL Angle;
 127 } EmfPlusRotateWorldTransform;
 128
 129 typedef struct EmfPlusTranslateWorldTransform
 130 {
 131     EmfPlusRecordHeader Header;
 132     REAL dx;
 133     REAL dy;
 134 } EmfPlusTranslateWorldTransform;
 135
 136 typedef struct EmfPlusBeginContainer
 137 {
 138     EmfPlusRecordHeader Header;
 139     GpRectF DestRect;
 140     GpRectF SrcRect;
 141     DWORD StackIndex;
 142 } EmfPlusBeginContainer;
 143
 144 typedef struct EmfPlusContainerRecord
 145 {
 146     EmfPlusRecordHeader Header;
 147     DWORD StackIndex;
 148 } EmfPlusContainerRecord;
 149
 150 enum container_type
 151 {
 152     BEGIN_CONTAINER,
 153     SAVE_GRAPHICS
 154 };
 155
 156 typedef struct container
 157 {
 158     struct list entry;
 159     DWORD id;
 160     enum container_type type;
 161     GraphicsContainer state;
 162     GpMatrix world_transform;
 163     GpUnit page_unit;
 164     REAL page_scale;
 165     GpRegion *clip;
 166 } container;
 167
 168 enum PenDataFlags
 169 {
 170     PenDataTransform        = 0x0001,
 171     PenDataStartCap         = 0x0002,
 172     PenDataEndCap           = 0x0004,
 173     PenDataJoin             = 0x0008,
 174     PenDataMiterLimit       = 0x0010,
 175     PenDataLineStyle        = 0x0020,
 176     PenDataDashedLineCap    = 0x0040,
 177     PenDataDashedLineOffset = 0x0080,
 178     PenDataDashedLine       = 0x0100,
 179     PenDataNonCenter        = 0x0200,
 180     PenDataCompoundLine     = 0x0400,
 181     PenDataCustomStartCap   = 0x0800,
 182     PenDataCustomEndCap     = 0x1000
 183 };
 184
 185 typedef struct EmfPlusTransformMatrix
 186 {
 187     REAL TransformMatrix[6];
 188 } EmfPlusTransformMatrix;
 189
 190 enum LineStyle
 191 {
 192     LineStyleSolid,
 193     LineStyleDash,
 194     LineStyleDot,
 195     LineStyleDashDot,
 196     LineStyleDashDotDot,
 197     LineStyleCustom
 198 };
 199
 200 typedef struct EmfPlusPenData
 201 {
 202     DWORD PenDataFlags;
 203     DWORD PenUnit;
 204     REAL PenWidth;
 205     BYTE OptionalData[1];
 206 } EmfPlusPenData;
 207
 208 typedef struct EmfPlusSolidBrushData
 209 {
 210     EmfPlusARGB SolidColor;
 211 } EmfPlusSolidBrushData;
 212
 213 typedef struct EmfPlusBrush
 214 {
 215     DWORD Version;
 216     DWORD Type;
 217     union {
 218         EmfPlusSolidBrushData solid;
 219     } BrushData;
 220 } EmfPlusBrush;
 221
 222 typedef struct EmfPlusPen
 223 {
 224     DWORD Version;
 225     DWORD Type;
 226     /* EmfPlusPenData */
 227     /* EmfPlusBrush */
 228     BYTE data[1];
 229 } EmfPlusPen;
 230
 231 typedef struct EmfPlusPath
 232 {
 233     DWORD Version;
 234     DWORD PathPointCount;
 235     DWORD PathPointFlags;
 236     /* PathPoints[] */
 237     /* PathPointTypes[] */
 238     /* AlignmentPadding */
 239     BYTE data[1];
 240 } EmfPlusPath;
 241
 242 typedef enum
 243 {
 244     BitmapDataTypePixel,
 245     BitmapDataTypeCompressed,
 246 } BitmapDataType;
 247
 248 typedef struct EmfPlusBitmap
 249 {
 250     DWORD Width;
 251     DWORD Height;
 252     DWORD Stride;
 253     DWORD PixelFormat;
 254     DWORD Type;
 255     BYTE BitmapData[1];
 256 } EmfPlusBitmap;
 257
 258 typedef struct EmfPlusMetafile
 259 {
 260     DWORD Type;
 261     DWORD MetafileDataSize;
 262     BYTE MetafileData[1];
 263 } EmfPlusMetafile;
 264
 265 typedef enum ImageDataType
 266 {
 267     ImageDataTypeUnknown,
 268     ImageDataTypeBitmap,
 269     ImageDataTypeMetafile,
 270 } ImageDataType;
 271
 272 typedef struct EmfPlusImage
 273 {
 274     DWORD Version;
 275     ImageDataType Type;
 276     union
 277     {
 278         EmfPlusBitmap bitmap;
 279         EmfPlusMetafile metafile;
 280     } ImageData;
 281 } EmfPlusImage;
 282
 283 typedef struct EmfPlusImageAttributes
 284 {
 285     DWORD Version;
 286     DWORD Reserved1;
 287     DWORD WrapMode;
 288     EmfPlusARGB ClampColor;
 289     DWORD ObjectClamp;
 290     DWORD Reserved2;
 291 } EmfPlusImageAttributes;
 292
 293 typedef enum ObjectType
 294 {
 295     ObjectTypeInvalid,
 296     ObjectTypeBrush,
 297     ObjectTypePen,
 298     ObjectTypePath,
 299     ObjectTypeRegion,
 300     ObjectTypeImage,
 301     ObjectTypeFont,
 302     ObjectTypeStringFormat,
 303     ObjectTypeImageAttributes,
 304     ObjectTypeCustomLineCap,
 305 } ObjectType;
 306
 307 typedef struct EmfPlusObject
 308 {
 309     EmfPlusRecordHeader Header;
 310     union
 311     {
 312         EmfPlusBrush brush;
 313         EmfPlusPen pen;
 314         EmfPlusPath path;
 315         EmfPlusImage image;
 316         EmfPlusImageAttributes image_attributes;
 317     } ObjectData;
 318 } EmfPlusObject;
 319
 320 typedef struct EmfPlusRectF
 321 {
 322     float X;
 323     float Y;
 324     float Width;
 325     float Height;
 326 } EmfPlusRectF;
 327
 328 typedef struct EmfPlusPointF
 329 {
 330     float X;
 331     float Y;
 332 } EmfPlusPointF;
 333
 334 typedef struct EmfPlusDrawImagePoints
 335 {
 336     EmfPlusRecordHeader Header;
 337     DWORD ImageAttributesID;
 338     DWORD SrcUnit;
 339     EmfPlusRectF SrcRect;
 340     DWORD count;
 341     union
 342     {
 343         /*EmfPlusPointR pointR;
 344         EmfPlusPoint point;*/
 345         EmfPlusPointF pointF;
 346     } PointData[3];
 347 } EmfPlusDrawImagePoints;
 348
 349 typedef struct EmfPlusDrawPath
 350 {
 351     EmfPlusRecordHeader Header;
 352     DWORD PenId;
 353 } EmfPlusDrawPath;
 354
 355 typedef struct EmfPlusFillPath
 356 {
 357     EmfPlusRecordHeader Header;
 358     union
 359     {
 360         DWORD BrushId;
 361         EmfPlusARGB Color;
 362     } data;
 363 } EmfPlusFillPath;
 364
 365 static DWORD METAFILE_AddObjectId(GpMetafile *metafile)
 366 {
 367     return (metafile->next_object_id++) % 64;
 368 }
 369
 370 static GpStatus METAFILE_AllocateRecord(GpMetafile *metafile, DWORD size, void **result)
 371 {
 372     DWORD size_needed;
 373     EmfPlusRecordHeader *record;
 374
 375     if (!metafile->comment_data_size)
 376     {
 377         DWORD data_size = max(256, size * 2 + 4);
 378         metafile->comment_data = heap_alloc_zero(data_size);
 379
 380         if (!metafile->comment_data)
 381             return OutOfMemory;
 382
 383         memcpy(metafile->comment_data, "EMF+", 4);
 384
 385         metafile->comment_data_size = data_size;
 386         metafile->comment_data_length = 4;
 387     }
 388
 389     size_needed = size + metafile->comment_data_length;
 390
 391     if (size_needed > metafile->comment_data_size)
 392     {
 393         DWORD data_size = size_needed * 2;
 394         BYTE *new_data = heap_alloc_zero(data_size);
 395
 396         if (!new_data)
 397             return OutOfMemory;
 398
 399         memcpy(new_data, metafile->comment_data, metafile->comment_data_length);
 400
 401         metafile->comment_data_size = data_size;
 402         heap_free(metafile->comment_data);
 403         metafile->comment_data = new_data;
 404     }
 405
 406     *result = metafile->comment_data + metafile->comment_data_length;
 407     metafile->comment_data_length += size;
 408
 409     record = (EmfPlusRecordHeader*)*result;
 410     record->Size = size;
 411     record->DataSize = size - sizeof(EmfPlusRecordHeader);
 412
 413     return Ok;
 414 }
 415
 416 static void METAFILE_RemoveLastRecord(GpMetafile *metafile, EmfPlusRecordHeader *record)
 417 {
 418     assert(metafile->comment_data + metafile->comment_data_length == (BYTE*)record + record->Size);
 419     metafile->comment_data_length -=  record->Size;
 420 }
 421
 422 static void METAFILE_WriteRecords(GpMetafile *metafile)
 423 {
 424     if (metafile->comment_data_length > 4)
 425     {
 426         GdiComment(metafile->record_dc, metafile->comment_data_length, metafile->comment_data);
 427         metafile->comment_data_length = 4;
 428     }
 429 }
 430
 431 static GpStatus METAFILE_WriteHeader(GpMetafile *metafile, HDC hdc)
 432 {
 433     GpStatus stat;
 434
 435     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 436     {
 437         EmfPlusHeader *header;
 438
 439         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusHeader), (void**)&header);
 440         if (stat != Ok)
 441             return stat;
 442
 443         header->Header.Type = EmfPlusRecordTypeHeader;
 444
 445         if (metafile->metafile_type == MetafileTypeEmfPlusDual)
 446             header->Header.Flags = 1;
 447         else
 448             header->Header.Flags = 0;
 449
 450         header->Version = VERSION_MAGIC2;
 451
 452         if (GetDeviceCaps(hdc, TECHNOLOGY) == DT_RASDISPLAY)
 453             header->EmfPlusFlags = 1;
 454         else
 455             header->EmfPlusFlags = 0;
 456
 457         header->LogicalDpiX = GetDeviceCaps(hdc, LOGPIXELSX);
 458         header->LogicalDpiY = GetDeviceCaps(hdc, LOGPIXELSY);
 459
 460         METAFILE_WriteRecords(metafile);
 461     }
 462
 463     return Ok;
 464 }
 465
 466 static GpStatus METAFILE_WriteEndOfFile(GpMetafile *metafile)
 467 {
 468     GpStatus stat;
 469
 470     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 471     {
 472         EmfPlusRecordHeader *record;
 473
 474         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusRecordHeader), (void**)&record);
 475         if (stat != Ok)
 476             return stat;
 477
 478         record->Type = EmfPlusRecordTypeEndOfFile;
 479         record->Flags = 0;
 480
 481         METAFILE_WriteRecords(metafile);
 482     }
 483
 484     return Ok;
 485 }
 486
 487 GpStatus WINGDIPAPI GdipRecordMetafile(HDC hdc, EmfType type, GDIPCONST GpRectF *frameRect,
 488                                        MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
 489 {
 490     HDC record_dc;
 491     REAL dpix, dpiy;
 492     REAL framerect_factor_x, framerect_factor_y;
 493     RECT rc, *lprc;
 494     GpStatus stat;
 495
 496     TRACE("(%p %d %p %d %p %p)\n", hdc, type, frameRect, frameUnit, desc, metafile);
 497
 498     if (!hdc || type < EmfTypeEmfOnly || type > EmfTypeEmfPlusDual || !metafile)
 499         return InvalidParameter;
 500
 501     dpix = (REAL)GetDeviceCaps(hdc, HORZRES) / GetDeviceCaps(hdc, HORZSIZE) * 25.4;
 502     dpiy = (REAL)GetDeviceCaps(hdc, VERTRES) / GetDeviceCaps(hdc, VERTSIZE) * 25.4;
 503
 504     if (frameRect)
 505     {
 506         switch (frameUnit)
 507         {
 508         case MetafileFrameUnitPixel:
 509             framerect_factor_x = 2540.0 / dpix;
 510             framerect_factor_y = 2540.0 / dpiy;
 511             break;
 512         case MetafileFrameUnitPoint:
 513             framerect_factor_x = framerect_factor_y = 2540.0 / 72.0;
 514             break;
 515         case MetafileFrameUnitInch:
 516             framerect_factor_x = framerect_factor_y = 2540.0;
 517             break;
 518         case MetafileFrameUnitDocument:
 519             framerect_factor_x = framerect_factor_y = 2540.0 / 300.0;
 520             break;
 521         case MetafileFrameUnitMillimeter:
 522             framerect_factor_x = framerect_factor_y = 100.0;
 523             break;
 524         case MetafileFrameUnitGdi:
 525             framerect_factor_x = framerect_factor_y = 1.0;
 526             break;
 527         default:
 528             return InvalidParameter;
 529         }
 530
 531         rc.left = framerect_factor_x * frameRect->X;
 532         rc.top = framerect_factor_y * frameRect->Y;
 533         rc.right = rc.left + framerect_factor_x * frameRect->Width;
 534         rc.bottom = rc.top + framerect_factor_y * frameRect->Height;
 535
 536         lprc = &rc;
 537     }
 538     else
 539         lprc = NULL;
 540
 541     record_dc = CreateEnhMetaFileW(hdc, NULL, lprc, desc);
 542
 543     if (!record_dc)
 544         return GenericError;
 545
 546     *metafile = heap_alloc_zero(sizeof(GpMetafile));
 547     if(!*metafile)
 548     {
 549         DeleteEnhMetaFile(CloseEnhMetaFile(record_dc));
 550         return OutOfMemory;
 551     }
 552
 553     (*metafile)->image.type = ImageTypeMetafile;
 554     (*metafile)->image.flags   = ImageFlagsNone;
 555     (*metafile)->image.palette = NULL;
 556     (*metafile)->image.xres = dpix;
 557     (*metafile)->image.yres = dpiy;
 558     (*metafile)->bounds.X = (*metafile)->bounds.Y = 0.0;
 559     (*metafile)->bounds.Width = (*metafile)->bounds.Height = 1.0;
 560     (*metafile)->unit = UnitPixel;
 561     (*metafile)->metafile_type = type;
 562     (*metafile)->record_dc = record_dc;
 563     (*metafile)->comment_data = NULL;
 564     (*metafile)->comment_data_size = 0;
 565     (*metafile)->comment_data_length = 0;
 566     (*metafile)->hemf = NULL;
 567     list_init(&(*metafile)->containers);
 568
 569     if (!frameRect)
 570     {
 571         (*metafile)->auto_frame = TRUE;
 572         (*metafile)->auto_frame_min.X = 0;
 573         (*metafile)->auto_frame_min.Y = 0;
 574         (*metafile)->auto_frame_max.X = -1;
 575         (*metafile)->auto_frame_max.Y = -1;
 576     }
 577
 578     stat = METAFILE_WriteHeader(*metafile, hdc);
 579
 580     if (stat != Ok)
 581     {
 582         DeleteEnhMetaFile(CloseEnhMetaFile(record_dc));
 583         heap_free(*metafile);
 584         *metafile = NULL;
 585         return OutOfMemory;
 586     }
 587
 588     return stat;
 589 }
 590
 591 /*****************************************************************************
 592  * GdipRecordMetafileI [GDIPLUS.@]
 593  */
 594 GpStatus WINGDIPAPI GdipRecordMetafileI(HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
 595                                         MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
 596 {
 597     GpRectF frameRectF, *pFrameRectF;
 598
 599     TRACE("(%p %d %p %d %p %p)\n", hdc, type, frameRect, frameUnit, desc, metafile);
 600
 601     if (frameRect)
 602     {
 603         frameRectF.X = frameRect->X;
 604         frameRectF.Y = frameRect->Y;
 605         frameRectF.Width = frameRect->Width;
 606         frameRectF.Height = frameRect->Height;
 607         pFrameRectF = &frameRectF;
 608     }
 609     else
 610         pFrameRectF = NULL;
 611
 612     return GdipRecordMetafile(hdc, type, pFrameRectF, frameUnit, desc, metafile);
 613 }
 614
 615 GpStatus WINGDIPAPI GdipRecordMetafileStream(IStream *stream, HDC hdc, EmfType type, GDIPCONST GpRectF *frameRect,
 616                                         MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
 617 {
 618     GpStatus stat;
 619
 620     TRACE("(%p %p %d %p %d %p %p)\n", stream, hdc, type, frameRect, frameUnit, desc, metafile);
 621
 622     if (!stream)
 623         return InvalidParameter;
 624
 625     stat = GdipRecordMetafile(hdc, type, frameRect, frameUnit, desc, metafile);
 626
 627     if (stat == Ok)
 628     {
 629         (*metafile)->record_stream = stream;
 630         IStream_AddRef(stream);
 631     }
 632
 633     return stat;
 634 }
 635
 636 static void METAFILE_AdjustFrame(GpMetafile* metafile, const GpPointF *points,
 637     UINT num_points)
 638 {
 639     int i;
 640
 641     if (!metafile->auto_frame || !num_points)
 642         return;
 643
 644     if (metafile->auto_frame_max.X < metafile->auto_frame_min.X)
 645         metafile->auto_frame_max = metafile->auto_frame_min = points[0];
 646
 647     for (i=0; i<num_points; i++)
 648     {
 649         if (points[i].X < metafile->auto_frame_min.X)
 650             metafile->auto_frame_min.X = points[i].X;
 651         if (points[i].X > metafile->auto_frame_max.X)
 652             metafile->auto_frame_max.X = points[i].X;
 653         if (points[i].Y < metafile->auto_frame_min.Y)
 654             metafile->auto_frame_min.Y = points[i].Y;
 655         if (points[i].Y > metafile->auto_frame_max.Y)
 656             metafile->auto_frame_max.Y = points[i].Y;
 657     }
 658 }
 659
 660 GpStatus METAFILE_GetGraphicsContext(GpMetafile* metafile, GpGraphics **result)
 661 {
 662     GpStatus stat;
 663
 664     if (!metafile->record_dc || metafile->record_graphics)
 665         return InvalidParameter;
 666
 667     stat = graphics_from_image((GpImage*)metafile, &metafile->record_graphics);
 668
 669     if (stat == Ok)
 670     {
 671         *result = metafile->record_graphics;
 672         metafile->record_graphics->xres = 96.0;
 673         metafile->record_graphics->yres = 96.0;
 674     }
 675
 676     return stat;
 677 }
 678
 679 GpStatus METAFILE_GetDC(GpMetafile* metafile, HDC *hdc)
 680 {
 681     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 682     {
 683         EmfPlusRecordHeader *record;
 684         GpStatus stat;
 685
 686         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusRecordHeader), (void**)&record);
 687         if (stat != Ok)
 688             return stat;
 689
 690         record->Type = EmfPlusRecordTypeGetDC;
 691         record->Flags = 0;
 692
 693         METAFILE_WriteRecords(metafile);
 694     }
 695
 696     *hdc = metafile->record_dc;
 697
 698     return Ok;
 699 }
 700
 701 GpStatus METAFILE_GraphicsClear(GpMetafile* metafile, ARGB color)
 702 {
 703     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 704     {
 705         EmfPlusClear *record;
 706         GpStatus stat;
 707
 708         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusClear), (void**)&record);
 709         if (stat != Ok)
 710             return stat;
 711
 712         record->Header.Type = EmfPlusRecordTypeClear;
 713         record->Header.Flags = 0;
 714         record->Color = color;
 715
 716         METAFILE_WriteRecords(metafile);
 717     }
 718
 719     return Ok;
 720 }
 721
 722 static BOOL is_integer_rect(const GpRectF *rect)
 723 {
 724     SHORT x, y, width, height;
 725     x = rect->X;
 726     y = rect->Y;
 727     width = rect->Width;
 728     height = rect->Height;
 729     if (rect->X != (REAL)x || rect->Y != (REAL)y ||
 730         rect->Width != (REAL)width || rect->Height != (REAL)height)
 731         return FALSE;
 732     return TRUE;
 733 }
 734
 735 GpStatus METAFILE_FillRectangles(GpMetafile* metafile, GpBrush* brush,
 736     GDIPCONST GpRectF* rects, INT count)
 737 {
 738     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 739     {
 740         EmfPlusFillRects *record;
 741         GpStatus stat;
 742         BOOL integer_rects = TRUE;
 743         int i;
 744         DWORD brushid;
 745         int flags = 0;
 746
 747         if (brush->bt == BrushTypeSolidColor)
 748         {
 749             flags |= 0x8000;
 750             brushid = ((GpSolidFill*)brush)->color;
 751         }
 752         else
 753         {
 754             FIXME("brush serialization not implemented\n");
 755             return NotImplemented;
 756         }
 757
 758         for (i=0; i<count; i++)
 759         {
 760             if (!is_integer_rect(&rects[i]))
 761             {
 762                 integer_rects = FALSE;
 763                 break;
 764             }
 765         }
 766
 767         if (integer_rects)
 768             flags |= 0x4000;
 769
 770         stat = METAFILE_AllocateRecord(metafile,
 771             sizeof(EmfPlusFillRects) + count * (integer_rects ? sizeof(EmfPlusRect) : sizeof(GpRectF)),
 772             (void**)&record);
 773         if (stat != Ok)
 774             return stat;
 775
 776         record->Header.Type = EmfPlusRecordTypeFillRects;
 777         record->Header.Flags = flags;
 778         record->BrushID = brushid;
 779         record->Count = count;
 780
 781         if (integer_rects)
 782         {
 783             EmfPlusRect *record_rects = (EmfPlusRect*)(record+1);
 784             for (i=0; i<count; i++)
 785             {
 786                 record_rects[i].X = (SHORT)rects[i].X;
 787                 record_rects[i].Y = (SHORT)rects[i].Y;
 788                 record_rects[i].Width = (SHORT)rects[i].Width;
 789                 record_rects[i].Height = (SHORT)rects[i].Height;
 790             }
 791         }
 792         else
 793             memcpy(record+1, rects, sizeof(GpRectF) * count);
 794
 795         METAFILE_WriteRecords(metafile);
 796     }
 797
 798     if (metafile->auto_frame)
 799     {
 800         GpPointF corners[4];
 801         int i;
 802
 803         for (i=0; i<count; i++)
 804         {
 805             corners[0].X = rects[i].X;
 806             corners[0].Y = rects[i].Y;
 807             corners[1].X = rects[i].X + rects[i].Width;
 808             corners[1].Y = rects[i].Y;
 809             corners[2].X = rects[i].X;
 810             corners[2].Y = rects[i].Y + rects[i].Height;
 811             corners[3].X = rects[i].X + rects[i].Width;
 812             corners[3].Y = rects[i].Y + rects[i].Height;
 813
 814             GdipTransformPoints(metafile->record_graphics, CoordinateSpaceDevice,
 815                 CoordinateSpaceWorld, corners, 4);
 816
 817             METAFILE_AdjustFrame(metafile, corners, 4);
 818         }
 819     }
 820
 821     return Ok;
 822 }
 823
 824 GpStatus METAFILE_SetClipRect(GpMetafile* metafile, REAL x, REAL y, REAL width, REAL height, CombineMode mode)
 825 {
 826     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 827     {
 828         EmfPlusSetClipRect *record;
 829         GpStatus stat;
 830
 831         stat = METAFILE_AllocateRecord(metafile,
 832             sizeof(EmfPlusSetClipRect),
 833             (void**)&record);
 834         if (stat != Ok)
 835             return stat;
 836
 837         record->Header.Type = EmfPlusRecordTypeSetClipRect;
 838         record->Header.Flags = (mode & 0xf) << 8;
 839         record->ClipRect.X = x;
 840         record->ClipRect.Y = y;
 841         record->ClipRect.Width = width;
 842         record->ClipRect.Height = height;
 843
 844         METAFILE_WriteRecords(metafile);
 845     }
 846
 847     return Ok;
 848 }
 849
 850 GpStatus METAFILE_SetPageTransform(GpMetafile* metafile, GpUnit unit, REAL scale)
 851 {
 852     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 853     {
 854         EmfPlusSetPageTransform *record;
 855         GpStatus stat;
 856
 857         stat = METAFILE_AllocateRecord(metafile,
 858             sizeof(EmfPlusSetPageTransform),
 859             (void**)&record);
 860         if (stat != Ok)
 861             return stat;
 862
 863         record->Header.Type = EmfPlusRecordTypeSetPageTransform;
 864         record->Header.Flags = unit;
 865         record->PageScale = scale;
 866
 867         METAFILE_WriteRecords(metafile);
 868     }
 869
 870     return Ok;
 871 }
 872
 873 GpStatus METAFILE_SetWorldTransform(GpMetafile* metafile, GDIPCONST GpMatrix* transform)
 874 {
 875     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 876     {
 877         EmfPlusSetWorldTransform *record;
 878         GpStatus stat;
 879
 880         stat = METAFILE_AllocateRecord(metafile,
 881             sizeof(EmfPlusSetWorldTransform),
 882             (void**)&record);
 883         if (stat != Ok)
 884             return stat;
 885
 886         record->Header.Type = EmfPlusRecordTypeSetWorldTransform;
 887         record->Header.Flags = 0;
 888         memcpy(record->MatrixData, transform->matrix, sizeof(record->MatrixData));
 889
 890         METAFILE_WriteRecords(metafile);
 891     }
 892
 893     return Ok;
 894 }
 895
 896 GpStatus METAFILE_ScaleWorldTransform(GpMetafile* metafile, REAL sx, REAL sy, MatrixOrder order)
 897 {
 898     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 899     {
 900         EmfPlusScaleWorldTransform *record;
 901         GpStatus stat;
 902
 903         stat = METAFILE_AllocateRecord(metafile,
 904             sizeof(EmfPlusScaleWorldTransform),
 905             (void**)&record);
 906         if (stat != Ok)
 907             return stat;
 908
 909         record->Header.Type = EmfPlusRecordTypeScaleWorldTransform;
 910         record->Header.Flags = (order == MatrixOrderAppend ? 0x2000 : 0);
 911         record->Sx = sx;
 912         record->Sy = sy;
 913
 914         METAFILE_WriteRecords(metafile);
 915     }
 916
 917     return Ok;
 918 }
 919
 920 GpStatus METAFILE_MultiplyWorldTransform(GpMetafile* metafile, GDIPCONST GpMatrix* matrix, MatrixOrder order)
 921 {
 922     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 923     {
 924         EmfPlusMultiplyWorldTransform *record;
 925         GpStatus stat;
 926
 927         stat = METAFILE_AllocateRecord(metafile,
 928             sizeof(EmfPlusMultiplyWorldTransform),
 929             (void**)&record);
 930         if (stat != Ok)
 931             return stat;
 932
 933         record->Header.Type = EmfPlusRecordTypeMultiplyWorldTransform;
 934         record->Header.Flags = (order == MatrixOrderAppend ? 0x2000 : 0);
 935         memcpy(record->MatrixData, matrix->matrix, sizeof(record->MatrixData));
 936
 937         METAFILE_WriteRecords(metafile);
 938     }
 939
 940     return Ok;
 941 }
 942
 943 GpStatus METAFILE_RotateWorldTransform(GpMetafile* metafile, REAL angle, MatrixOrder order)
 944 {
 945     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 946     {
 947         EmfPlusRotateWorldTransform *record;
 948         GpStatus stat;
 949
 950         stat = METAFILE_AllocateRecord(metafile,
 951             sizeof(EmfPlusRotateWorldTransform),
 952             (void**)&record);
 953         if (stat != Ok)
 954             return stat;
 955
 956         record->Header.Type = EmfPlusRecordTypeRotateWorldTransform;
 957         record->Header.Flags = (order == MatrixOrderAppend ? 0x2000 : 0);
 958         record->Angle = angle;
 959
 960         METAFILE_WriteRecords(metafile);
 961     }
 962
 963     return Ok;
 964 }
 965
 966 GpStatus METAFILE_TranslateWorldTransform(GpMetafile* metafile, REAL dx, REAL dy, MatrixOrder order)
 967 {
 968     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 969     {
 970         EmfPlusTranslateWorldTransform *record;
 971         GpStatus stat;
 972
 973         stat = METAFILE_AllocateRecord(metafile,
 974             sizeof(EmfPlusTranslateWorldTransform),
 975             (void**)&record);
 976         if (stat != Ok)
 977             return stat;
 978
 979         record->Header.Type = EmfPlusRecordTypeTranslateWorldTransform;
 980         record->Header.Flags = (order == MatrixOrderAppend ? 0x2000 : 0);
 981         record->dx = dx;
 982         record->dy = dy;
 983
 984         METAFILE_WriteRecords(metafile);
 985     }
 986
 987     return Ok;
 988 }
 989
 990 GpStatus METAFILE_ResetWorldTransform(GpMetafile* metafile)
 991 {
 992     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 993     {
 994         EmfPlusRecordHeader *record;
 995         GpStatus stat;
 996
 997         stat = METAFILE_AllocateRecord(metafile,
 998             sizeof(EmfPlusRecordHeader),
 999             (void**)&record);
1000         if (stat != Ok)
1001             return stat;
1002
1003         record->Type = EmfPlusRecordTypeResetWorldTransform;
1004         record->Flags = 0;
1005
1006         METAFILE_WriteRecords(metafile);
1007     }
1008
1009     return Ok;
1010 }
1011
1012 GpStatus METAFILE_BeginContainer(GpMetafile* metafile, GDIPCONST GpRectF *dstrect,
1013     GDIPCONST GpRectF *srcrect, GpUnit unit, DWORD StackIndex)
1014 {
1015     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1016     {
1017         EmfPlusBeginContainer *record;
1018         GpStatus stat;
1019
1020         stat = METAFILE_AllocateRecord(metafile, sizeof(*record), (void**)&record);
1021         if (stat != Ok)
1022             return stat;
1023
1024         record->Header.Type = EmfPlusRecordTypeBeginContainer;
1025         record->Header.Flags = unit & 0xff;
1026         record->DestRect = *dstrect;
1027         record->SrcRect = *srcrect;
1028         record->StackIndex = StackIndex;
1029
1030         METAFILE_WriteRecords(metafile);
1031     }
1032
1033     return Ok;
1034 }
1035
1036 GpStatus METAFILE_BeginContainerNoParams(GpMetafile* metafile, DWORD StackIndex)
1037 {
1038     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1039     {
1040         EmfPlusContainerRecord *record;
1041         GpStatus stat;
1042
1043         stat = METAFILE_AllocateRecord(metafile,
1044             sizeof(EmfPlusContainerRecord),
1045             (void**)&record);
1046         if (stat != Ok)
1047             return stat;
1048
1049         record->Header.Type = EmfPlusRecordTypeBeginContainerNoParams;
1050         record->Header.Flags = 0;
1051         record->StackIndex = StackIndex;
1052
1053         METAFILE_WriteRecords(metafile);
1054     }
1055
1056     return Ok;
1057 }
1058
1059 GpStatus METAFILE_EndContainer(GpMetafile* metafile, DWORD StackIndex)
1060 {
1061     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1062     {
1063         EmfPlusContainerRecord *record;
1064         GpStatus stat;
1065
1066         stat = METAFILE_AllocateRecord(metafile,
1067             sizeof(EmfPlusContainerRecord),
1068             (void**)&record);
1069         if (stat != Ok)
1070             return stat;
1071
1072         record->Header.Type = EmfPlusRecordTypeEndContainer;
1073         record->Header.Flags = 0;
1074         record->StackIndex = StackIndex;
1075
1076         METAFILE_WriteRecords(metafile);
1077     }
1078
1079     return Ok;
1080 }
1081
1082 GpStatus METAFILE_SaveGraphics(GpMetafile* metafile, DWORD StackIndex)
1083 {
1084     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1085     {
1086         EmfPlusContainerRecord *record;
1087         GpStatus stat;
1088
1089         stat = METAFILE_AllocateRecord(metafile,
1090             sizeof(EmfPlusContainerRecord),
1091             (void**)&record);
1092         if (stat != Ok)
1093             return stat;
1094
1095         record->Header.Type = EmfPlusRecordTypeSave;
1096         record->Header.Flags = 0;
1097         record->StackIndex = StackIndex;
1098
1099         METAFILE_WriteRecords(metafile);
1100     }
1101
1102     return Ok;
1103 }
1104
1105 GpStatus METAFILE_RestoreGraphics(GpMetafile* metafile, DWORD StackIndex)
1106 {
1107     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1108     {
1109         EmfPlusContainerRecord *record;
1110         GpStatus stat;
1111
1112         stat = METAFILE_AllocateRecord(metafile,
1113             sizeof(EmfPlusContainerRecord),
1114             (void**)&record);
1115         if (stat != Ok)
1116             return stat;
1117
1118         record->Header.Type = EmfPlusRecordTypeRestore;
1119         record->Header.Flags = 0;
1120         record->StackIndex = StackIndex;
1121
1122         METAFILE_WriteRecords(metafile);
1123     }
1124
1125     return Ok;
1126 }
1127
1128 GpStatus METAFILE_ReleaseDC(GpMetafile* metafile, HDC hdc)
1129 {
1130     if (hdc != metafile->record_dc)
1131         return InvalidParameter;
1132
1133     return Ok;
1134 }
1135
1136 GpStatus METAFILE_GraphicsDeleted(GpMetafile* metafile)
1137 {
1138     GpStatus stat;
1139
1140     stat = METAFILE_WriteEndOfFile(metafile);
1141     metafile->record_graphics = NULL;
1142
1143     metafile->hemf = CloseEnhMetaFile(metafile->record_dc);
1144     metafile->record_dc = NULL;
1145
1146     heap_free(metafile->comment_data);
1147     metafile->comment_data = NULL;
1148     metafile->comment_data_size = 0;
1149
1150     if (stat == Ok)
1151     {
1152         MetafileHeader header;
1153
1154         stat = GdipGetMetafileHeaderFromEmf(metafile->hemf, &header);
1155         if (stat == Ok && metafile->auto_frame &&
1156             metafile->auto_frame_max.X >= metafile->auto_frame_min.X)
1157         {
1158             RECTL bounds_rc, gdi_bounds_rc;
1159             REAL x_scale = 2540.0 / header.DpiX;
1160             REAL y_scale = 2540.0 / header.DpiY;
1161             BYTE* buffer;
1162             UINT buffer_size;
1163
1164             bounds_rc.left = floorf(metafile->auto_frame_min.X * x_scale);
1165             bounds_rc.top = floorf(metafile->auto_frame_min.Y * y_scale);
1166             bounds_rc.right = ceilf(metafile->auto_frame_max.X * x_scale);
1167             bounds_rc.bottom = ceilf(metafile->auto_frame_max.Y * y_scale);
1168
1169             gdi_bounds_rc = header.u.EmfHeader.rclBounds;
1170             if (gdi_bounds_rc.right > gdi_bounds_rc.left && gdi_bounds_rc.bottom > gdi_bounds_rc.top)
1171             {
1172                 bounds_rc.left = min(bounds_rc.left, gdi_bounds_rc.left);
1173                 bounds_rc.top = min(bounds_rc.top, gdi_bounds_rc.top);
1174                 bounds_rc.right = max(bounds_rc.right, gdi_bounds_rc.right);
1175                 bounds_rc.bottom = max(bounds_rc.bottom, gdi_bounds_rc.bottom);
1176             }
1177
1178             buffer_size = GetEnhMetaFileBits(metafile->hemf, 0, NULL);
1179             buffer = heap_alloc(buffer_size);
1180             if (buffer)
1181             {
1182                 HENHMETAFILE new_hemf;
1183
1184                 GetEnhMetaFileBits(metafile->hemf, buffer_size, buffer);
1185
1186                 ((ENHMETAHEADER*)buffer)->rclFrame = bounds_rc;
1187
1188                 new_hemf = SetEnhMetaFileBits(buffer_size, buffer);
1189
1190                 if (new_hemf)
1191                 {
1192                     DeleteEnhMetaFile(metafile->hemf);
1193                     metafile->hemf = new_hemf;
1194                 }
1195                 else
1196                     stat = OutOfMemory;
1197
1198                 heap_free(buffer);
1199             }
1200             else
1201                 stat = OutOfMemory;
1202
1203             if (stat == Ok)
1204                 stat = GdipGetMetafileHeaderFromEmf(metafile->hemf, &header);
1205         }
1206         if (stat == Ok)
1207         {
1208             metafile->bounds.X = header.X;
1209             metafile->bounds.Y = header.Y;
1210             metafile->bounds.Width = header.Width;
1211             metafile->bounds.Height = header.Height;
1212         }
1213     }
1214
1215     if (stat == Ok && metafile->record_stream)
1216     {
1217         BYTE *buffer;
1218         UINT buffer_size;
1219
1220         buffer_size = GetEnhMetaFileBits(metafile->hemf, 0, NULL);
1221
1222         buffer = heap_alloc(buffer_size);
1223         if (buffer)
1224         {
1225             HRESULT hr;
1226
1227             GetEnhMetaFileBits(metafile->hemf, buffer_size, buffer);
1228
1229             hr = IStream_Write(metafile->record_stream, buffer, buffer_size, NULL);
1230
1231             if (FAILED(hr))
1232                 stat = hresult_to_status(hr);
1233
1234             heap_free(buffer);
1235         }
1236         else
1237             stat = OutOfMemory;
1238     }
1239
1240     if (metafile->record_stream)
1241     {
1242         IStream_Release(metafile->record_stream);
1243         metafile->record_stream = NULL;
1244     }
1245
1246     return stat;
1247 }
1248
1249 GpStatus WINGDIPAPI GdipGetHemfFromMetafile(GpMetafile *metafile, HENHMETAFILE *hEmf)
1250 {
1251     TRACE("(%p,%p)\n", metafile, hEmf);
1252
1253     if (!metafile || !hEmf || !metafile->hemf)
1254         return InvalidParameter;
1255
1256     *hEmf = metafile->hemf;
1257     metafile->hemf = NULL;
1258
1259     return Ok;
1260 }
1261
1262 static void METAFILE_GetFinalGdiTransform(const GpMetafile *metafile, XFORM *result)
1263 {
1264     const GpRectF *rect;
1265     const GpPointF *pt;
1266
1267     /* This transforms metafile device space to output points. */
1268     rect = &metafile->src_rect;
1269     pt = metafile->playback_points;
1270     result->eM11 = (pt[1].X - pt[0].X) / rect->Width;
1271     result->eM21 = (pt[2].X - pt[0].X) / rect->Height;
1272     result->eDx = pt[0].X - result->eM11 * rect->X - result->eM21 * rect->Y;
1273     result->eM12 = (pt[1].Y - pt[0].Y) / rect->Width;
1274     result->eM22 = (pt[2].Y - pt[0].Y) / rect->Height;
1275     result->eDy = pt[0].Y - result->eM12 * rect->X - result->eM22 * rect->Y;
1276 }
1277
1278 static GpStatus METAFILE_PlaybackUpdateGdiTransform(GpMetafile *metafile)
1279 {
1280     XFORM combined, final;
1281
1282     METAFILE_GetFinalGdiTransform(metafile, &final);
1283
1284     CombineTransform(&combined, &metafile->gdiworldtransform, &final);
1285
1286     SetGraphicsMode(metafile->playback_dc, GM_ADVANCED);
1287     SetWorldTransform(metafile->playback_dc, &combined);
1288
1289     return Ok;
1290 }
1291
1292 static GpStatus METAFILE_PlaybackGetDC(GpMetafile *metafile)
1293 {
1294     GpStatus stat = Ok;
1295
1296     stat = GdipGetDC(metafile->playback_graphics, &metafile->playback_dc);
1297
1298     if (stat == Ok)
1299     {
1300         static const XFORM identity = {1, 0, 0, 1, 0, 0};
1301
1302         metafile->gdiworldtransform = identity;
1303         METAFILE_PlaybackUpdateGdiTransform(metafile);
1304     }
1305
1306     return stat;
1307 }
1308
1309 static void METAFILE_PlaybackReleaseDC(GpMetafile *metafile)
1310 {
1311     if (metafile->playback_dc)
1312     {
1313         GdipReleaseDC(metafile->playback_graphics, metafile->playback_dc);
1314         metafile->playback_dc = NULL;
1315     }
1316 }
1317
1318 static GpStatus METAFILE_PlaybackUpdateClip(GpMetafile *metafile)
1319 {
1320     GpStatus stat;
1321     stat = GdipCombineRegionRegion(metafile->playback_graphics->clip, metafile->base_clip, CombineModeReplace);
1322     if (stat == Ok)
1323         stat = GdipCombineRegionRegion(metafile->playback_graphics->clip, metafile->clip, CombineModeIntersect);
1324     return stat;
1325 }
1326
1327 static GpStatus METAFILE_PlaybackUpdateWorldTransform(GpMetafile *metafile)
1328 {
1329     GpMatrix *real_transform;
1330     GpStatus stat;
1331
1332     stat = GdipCreateMatrix3(&metafile->src_rect, metafile->playback_points, &real_transform);
1333
1334     if (stat == Ok)
1335     {
1336         REAL scale = units_to_pixels(1.0, metafile->page_unit, 96.0);
1337
1338         if (metafile->page_unit != UnitDisplay)
1339             scale *= metafile->page_scale;
1340
1341         stat = GdipScaleMatrix(real_transform, scale, scale, MatrixOrderPrepend);
1342
1343         if (stat == Ok)
1344             stat = GdipMultiplyMatrix(real_transform, metafile->world_transform, MatrixOrderPrepend);
1345
1346         if (stat == Ok)
1347             stat = GdipSetWorldTransform(metafile->playback_graphics, real_transform);
1348
1349         GdipDeleteMatrix(real_transform);
1350     }
1351
1352     return stat;
1353 }
1354
1355 GpStatus WINGDIPAPI GdipPlayMetafileRecord(GDIPCONST GpMetafile *metafile,
1356     EmfPlusRecordType recordType, UINT flags, UINT dataSize, GDIPCONST BYTE *data)
1357 {
1358     GpStatus stat;
1359     GpMetafile *real_metafile = (GpMetafile*)metafile;
1360
1361     TRACE("(%p,%x,%x,%d,%p)\n", metafile, recordType, flags, dataSize, data);
1362
1363     if (!metafile || (dataSize && !data) || !metafile->playback_graphics)
1364         return InvalidParameter;
1365
1366     if (recordType >= 1 && recordType <= 0x7a)
1367     {
1368         /* regular EMF record */
1369         if (metafile->playback_dc)
1370         {
1371             ENHMETARECORD *record;
1372
1373             switch (recordType)
1374             {
1375             case EMR_SETMAPMODE:
1376             case EMR_SAVEDC:
1377             case EMR_RESTOREDC:
1378             case EMR_SETWINDOWORGEX:
1379             case EMR_SETWINDOWEXTEX:
1380             case EMR_SETVIEWPORTORGEX:
1381             case EMR_SETVIEWPORTEXTEX:
1382             case EMR_SCALEVIEWPORTEXTEX:
1383             case EMR_SCALEWINDOWEXTEX:
1384             case EMR_MODIFYWORLDTRANSFORM:
1385                 FIXME("not implemented for record type %x\n", recordType);
1386                 break;
1387             case EMR_SETWORLDTRANSFORM:
1388             {
1389                 const XFORM* xform = (void*)data;
1390                 real_metafile->gdiworldtransform = *xform;
1391                 METAFILE_PlaybackUpdateGdiTransform(real_metafile);
1392                 break;
1393             }
1394             case EMR_EXTSELECTCLIPRGN:
1395             {
1396                 DWORD rgndatasize = *(DWORD*)data;
1397                 DWORD mode = *(DWORD*)(data + 4);
1398                 const RGNDATA *rgndata = (const RGNDATA*)(data + 8);
1399                 HRGN hrgn = NULL;
1400
1401                 if (dataSize > 8)
1402                 {
1403                     XFORM final;
1404
1405                     METAFILE_GetFinalGdiTransform(metafile, &final);
1406
1407                     hrgn = ExtCreateRegion(&final, rgndatasize, rgndata);
1408                 }
1409
1410                 ExtSelectClipRgn(metafile->playback_dc, hrgn, mode);
1411
1412                 DeleteObject(hrgn);
1413
1414                 return Ok;
1415             }
1416             default:
1417                 break;
1418             }
1419
1420             record = heap_alloc_zero(dataSize + 8);
1421
1422             if (record)
1423             {
1424                 record->iType = recordType;
1425                 record->nSize = dataSize + 8;
1426                 memcpy(record->dParm, data, dataSize);
1427
1428                 PlayEnhMetaFileRecord(metafile->playback_dc, metafile->handle_table,
1429                     record, metafile->handle_count);
1430
1431                 heap_free(record);
1432             }
1433             else
1434                 return OutOfMemory;
1435         }
1436     }
1437     else
1438     {
1439         EmfPlusRecordHeader *header = (EmfPlusRecordHeader*)(data)-1;
1440
1441         METAFILE_PlaybackReleaseDC((GpMetafile*)metafile);
1442
1443         switch(recordType)
1444         {
1445         case EmfPlusRecordTypeHeader:
1446         case EmfPlusRecordTypeEndOfFile:
1447             break;
1448         case EmfPlusRecordTypeGetDC:
1449             METAFILE_PlaybackGetDC((GpMetafile*)metafile);
1450             break;
1451         case EmfPlusRecordTypeClear:
1452         {
1453             EmfPlusClear *record = (EmfPlusClear*)header;
1454
1455             return GdipGraphicsClear(metafile->playback_graphics, record->Color);
1456         }
1457         case EmfPlusRecordTypeFillRects:
1458         {
1459             EmfPlusFillRects *record = (EmfPlusFillRects*)header;
1460             GpBrush *brush, *temp_brush=NULL;
1461             GpRectF *rects, *temp_rects=NULL;
1462
1463             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects))
1464                 return InvalidParameter;
1465
1466             if (flags & 0x4000)
1467             {
1468                 if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects) + sizeof(EmfPlusRect) * record->Count)
1469                     return InvalidParameter;
1470             }
1471             else
1472             {
1473                 if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects) + sizeof(GpRectF) * record->Count)
1474                     return InvalidParameter;
1475             }
1476
1477             if (flags & 0x8000)
1478             {
1479                 stat = GdipCreateSolidFill((ARGB)record->BrushID, (GpSolidFill**)&temp_brush);
1480                 brush = temp_brush;
1481             }
1482             else
1483             {
1484                 FIXME("brush deserialization not implemented\n");
1485                 return NotImplemented;
1486             }
1487
1488             if (stat == Ok)
1489             {
1490                 if (flags & 0x4000)
1491                 {
1492                     EmfPlusRect *int_rects = (EmfPlusRect*)(record+1);
1493                     int i;
1494
1495                     rects = temp_rects = heap_alloc_zero(sizeof(GpRectF) * record->Count);
1496                     if (rects)
1497                     {
1498                         for (i=0; i<record->Count; i++)
1499                         {
1500                             rects[i].X = int_rects[i].X;
1501                             rects[i].Y = int_rects[i].Y;
1502                             rects[i].Width = int_rects[i].Width;
1503                             rects[i].Height = int_rects[i].Height;
1504                         }
1505                     }
1506                     else
1507                         stat = OutOfMemory;
1508                 }
1509                 else
1510                     rects = (GpRectF*)(record+1);
1511             }
1512
1513             if (stat == Ok)
1514             {
1515                 stat = GdipFillRectangles(metafile->playback_graphics, brush, rects, record->Count);
1516             }
1517
1518             GdipDeleteBrush(temp_brush);
1519             heap_free(temp_rects);
1520
1521             return stat;
1522         }
1523         case EmfPlusRecordTypeSetClipRect:
1524         {
1525             EmfPlusSetClipRect *record = (EmfPlusSetClipRect*)header;
1526             CombineMode mode = (CombineMode)((flags >> 8) & 0xf);
1527             GpRegion *region;
1528             GpMatrix world_to_device;
1529
1530             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(*record))
1531                 return InvalidParameter;
1532
1533             stat = GdipCreateRegionRect(&record->ClipRect, &region);
1534
1535             if (stat == Ok)
1536             {
1537                 get_graphics_transform(real_metafile->playback_graphics,
1538                     CoordinateSpaceDevice, CoordinateSpaceWorld, &world_to_device);
1539
1540                 GdipTransformRegion(region, &world_to_device);
1541
1542                 GdipCombineRegionRegion(real_metafile->clip, region, mode);
1543
1544                 GdipDeleteRegion(region);
1545             }
1546
1547             return METAFILE_PlaybackUpdateClip(real_metafile);
1548         }
1549         case EmfPlusRecordTypeSetPageTransform:
1550         {
1551             EmfPlusSetPageTransform *record = (EmfPlusSetPageTransform*)header;
1552             GpUnit unit = (GpUnit)flags;
1553
1554             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusSetPageTransform))
1555                 return InvalidParameter;
1556
1557             real_metafile->page_unit = unit;
1558             real_metafile->page_scale = record->PageScale;
1559
1560             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
1561         }
1562         case EmfPlusRecordTypeSetWorldTransform:
1563         {
1564             EmfPlusSetWorldTransform *record = (EmfPlusSetWorldTransform*)header;
1565
1566             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusSetWorldTransform))
1567                 return InvalidParameter;
1568
1569             memcpy(real_metafile->world_transform->matrix, record->MatrixData, sizeof(record->MatrixData));
1570
1571             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
1572         }
1573         case EmfPlusRecordTypeScaleWorldTransform:
1574         {
1575             EmfPlusScaleWorldTransform *record = (EmfPlusScaleWorldTransform*)header;
1576             MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
1577
1578             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusScaleWorldTransform))
1579                 return InvalidParameter;
1580
1581             GdipScaleMatrix(real_metafile->world_transform, record->Sx, record->Sy, order);
1582
1583             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
1584         }
1585         case EmfPlusRecordTypeMultiplyWorldTransform:
1586         {
1587             EmfPlusMultiplyWorldTransform *record = (EmfPlusMultiplyWorldTransform*)header;
1588             MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
1589             GpMatrix matrix;
1590
1591             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusMultiplyWorldTransform))
1592                 return InvalidParameter;
1593
1594             memcpy(matrix.matrix, record->MatrixData, sizeof(matrix.matrix));
1595
1596             GdipMultiplyMatrix(real_metafile->world_transform, &matrix, order);
1597
1598             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
1599         }
1600         case EmfPlusRecordTypeRotateWorldTransform:
1601         {
1602             EmfPlusRotateWorldTransform *record = (EmfPlusRotateWorldTransform*)header;
1603             MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
1604
1605             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusRotateWorldTransform))
1606                 return InvalidParameter;
1607
1608             GdipRotateMatrix(real_metafile->world_transform, record->Angle, order);
1609
1610             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
1611         }
1612         case EmfPlusRecordTypeTranslateWorldTransform:
1613         {
1614             EmfPlusTranslateWorldTransform *record = (EmfPlusTranslateWorldTransform*)header;
1615             MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
1616
1617             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusTranslateWorldTransform))
1618                 return InvalidParameter;
1619
1620             GdipTranslateMatrix(real_metafile->world_transform, record->dx, record->dy, order);
1621
1622             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
1623         }
1624         case EmfPlusRecordTypeResetWorldTransform:
1625         {
1626             GdipSetMatrixElements(real_metafile->world_transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
1627
1628             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
1629         }
1630         case EmfPlusRecordTypeBeginContainer:
1631         {
1632             EmfPlusBeginContainer *record = (EmfPlusBeginContainer*)header;
1633             container* cont;
1634             GpUnit unit;
1635             REAL scale_x, scale_y;
1636             GpRectF scaled_srcrect;
1637             GpMatrix transform;
1638
1639             cont = heap_alloc_zero(sizeof(*cont));
1640             if (!cont)
1641                 return OutOfMemory;
1642
1643             stat = GdipCloneRegion(metafile->clip, &cont->clip);
1644             if (stat != Ok)
1645             {
1646                 heap_free(cont);
1647                 return stat;
1648             }
1649
1650             stat = GdipBeginContainer2(metafile->playback_graphics, &cont->state);
1651
1652             if (stat != Ok)
1653             {
1654                 GdipDeleteRegion(cont->clip);
1655                 heap_free(cont);
1656                 return stat;
1657             }
1658
1659             cont->id = record->StackIndex;
1660             cont->type = BEGIN_CONTAINER;
1661             cont->world_transform = *metafile->world_transform;
1662             cont->page_unit = metafile->page_unit;
1663             cont->page_scale = metafile->page_scale;
1664             list_add_head(&real_metafile->containers, &cont->entry);
1665
1666             unit = record->Header.Flags & 0xff;
1667
1668             scale_x = units_to_pixels(1.0, unit, metafile->image.xres);
1669             scale_y = units_to_pixels(1.0, unit, metafile->image.yres);
1670
1671             scaled_srcrect.X = scale_x * record->SrcRect.X;
1672             scaled_srcrect.Y = scale_y * record->SrcRect.Y;
1673             scaled_srcrect.Width = scale_x * record->SrcRect.Width;
1674             scaled_srcrect.Height = scale_y * record->SrcRect.Height;
1675
1676             transform.matrix[0] = record->DestRect.Width / scaled_srcrect.Width;
1677             transform.matrix[1] = 0.0;
1678             transform.matrix[2] = 0.0;
1679             transform.matrix[3] = record->DestRect.Height / scaled_srcrect.Height;
1680             transform.matrix[4] = record->DestRect.X - scaled_srcrect.X;
1681             transform.matrix[5] = record->DestRect.Y - scaled_srcrect.Y;
1682
1683             GdipMultiplyMatrix(real_metafile->world_transform, &transform, MatrixOrderPrepend);
1684
1685             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
1686         }
1687         case EmfPlusRecordTypeBeginContainerNoParams:
1688         case EmfPlusRecordTypeSave:
1689         {
1690             EmfPlusContainerRecord *record = (EmfPlusContainerRecord*)header;
1691             container* cont;
1692
1693             cont = heap_alloc_zero(sizeof(*cont));
1694             if (!cont)
1695                 return OutOfMemory;
1696
1697             stat = GdipCloneRegion(metafile->clip, &cont->clip);
1698             if (stat != Ok)
1699             {
1700                 heap_free(cont);
1701                 return stat;
1702             }
1703
1704             if (recordType == EmfPlusRecordTypeBeginContainerNoParams)
1705                 stat = GdipBeginContainer2(metafile->playback_graphics, &cont->state);
1706             else
1707                 stat = GdipSaveGraphics(metafile->playback_graphics, &cont->state);
1708
1709             if (stat != Ok)
1710             {
1711                 GdipDeleteRegion(cont->clip);
1712                 heap_free(cont);
1713                 return stat;
1714             }
1715
1716             cont->id = record->StackIndex;
1717             if (recordType == EmfPlusRecordTypeBeginContainerNoParams)
1718                 cont->type = BEGIN_CONTAINER;
1719             else
1720                 cont->type = SAVE_GRAPHICS;
1721             cont->world_transform = *metafile->world_transform;
1722             cont->page_unit = metafile->page_unit;
1723             cont->page_scale = metafile->page_scale;
1724             list_add_head(&real_metafile->containers, &cont->entry);
1725
1726             break;
1727         }
1728         case EmfPlusRecordTypeEndContainer:
1729         case EmfPlusRecordTypeRestore:
1730         {
1731             EmfPlusContainerRecord *record = (EmfPlusContainerRecord*)header;
1732             container* cont;
1733             enum container_type type;
1734             BOOL found=FALSE;
1735
1736             if (recordType == EmfPlusRecordTypeEndContainer)
1737                 type = BEGIN_CONTAINER;
1738             else
1739                 type = SAVE_GRAPHICS;
1740
1741             LIST_FOR_EACH_ENTRY(cont, &real_metafile->containers, container, entry)
1742             {
1743                 if (cont->id == record->StackIndex && cont->type == type)
1744                 {
1745                     found = TRUE;
1746                     break;
1747                 }
1748             }
1749
1750             if (found)
1751             {
1752                 container* cont2;
1753
1754                 /* pop any newer items on the stack */
1755                 while ((cont2 = LIST_ENTRY(list_head(&real_metafile->containers), container, entry)) != cont)
1756                 {
1757                     list_remove(&cont2->entry);
1758                     GdipDeleteRegion(cont2->clip);
1759                     heap_free(cont2);
1760                 }
1761
1762                 if (type == BEGIN_CONTAINER)
1763                     GdipEndContainer(real_metafile->playback_graphics, cont->state);
1764                 else
1765                     GdipRestoreGraphics(real_metafile->playback_graphics, cont->state);
1766
1767                 *real_metafile->world_transform = cont->world_transform;
1768                 real_metafile->page_unit = cont->page_unit;
1769                 real_metafile->page_scale = cont->page_scale;
1770                 GdipCombineRegionRegion(real_metafile->clip, cont->clip, CombineModeReplace);
1771
1772                 list_remove(&cont->entry);
1773                 GdipDeleteRegion(cont->clip);
1774                 heap_free(cont);
1775             }
1776
1777             break;
1778         }
1779         default:
1780             FIXME("Not implemented for record type %x\n", recordType);
1781             return NotImplemented;
1782         }
1783     }
1784
1785     return Ok;
1786 }
1787
1788 struct enum_metafile_data
1789 {
1790     EnumerateMetafileProc callback;
1791     void *callback_data;
1792     GpMetafile *metafile;
1793 };
1794
1795 static int CALLBACK enum_metafile_proc(HDC hDC, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR,
1796     int nObj, LPARAM lpData)
1797 {
1798     BOOL ret;
1799     struct enum_metafile_data *data = (struct enum_metafile_data*)lpData;
1800     const BYTE* pStr;
1801
1802     data->metafile->handle_table = lpHTable;
1803     data->metafile->handle_count = nObj;
1804
1805     /* First check for an EMF+ record. */
1806     if (lpEMFR->iType == EMR_GDICOMMENT)
1807     {
1808         const EMRGDICOMMENT *comment = (const EMRGDICOMMENT*)lpEMFR;
1809
1810         if (comment->cbData >= 4 && memcmp(comment->Data, "EMF+", 4) == 0)
1811         {
1812             int offset = 4;
1813
1814             while (offset + sizeof(EmfPlusRecordHeader) <= comment->cbData)
1815             {
1816                 const EmfPlusRecordHeader *record = (const EmfPlusRecordHeader*)&comment->Data[offset];
1817
1818                 if (record->DataSize)
1819                     pStr = (const BYTE*)(record+1);
1820                 else
1821                     pStr = NULL;
1822
1823                 ret = data->callback(record->Type, record->Flags, record->DataSize,
1824                     pStr, data->callback_data);
1825
1826                 if (!ret)
1827                     return 0;
1828
1829                 offset += record->Size;
1830             }
1831
1832             return 1;
1833         }
1834     }
1835
1836     if (lpEMFR->nSize != 8)
1837         pStr = (const BYTE*)lpEMFR->dParm;
1838     else
1839         pStr = NULL;
1840
1841     return data->callback(lpEMFR->iType, 0, lpEMFR->nSize-8,
1842         pStr, data->callback_data);
1843 }
1844
1845 GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPoints(GpGraphics *graphics,
1846     GDIPCONST GpMetafile *metafile, GDIPCONST GpPointF *destPoints, INT count,
1847     GDIPCONST GpRectF *srcRect, Unit srcUnit, EnumerateMetafileProc callback,
1848     VOID *callbackData, GDIPCONST GpImageAttributes *imageAttributes)
1849 {
1850     struct enum_metafile_data data;
1851     GpStatus stat;
1852     GpMetafile *real_metafile = (GpMetafile*)metafile; /* whoever made this const was joking */
1853     GraphicsContainer state;
1854     GpPath *dst_path;
1855
1856     TRACE("(%p,%p,%p,%i,%p,%i,%p,%p,%p)\n", graphics, metafile,
1857         destPoints, count, srcRect, srcUnit, callback, callbackData,
1858         imageAttributes);
1859
1860     if (!graphics || !metafile || !destPoints || count != 3 || !srcRect)
1861         return InvalidParameter;
1862
1863     if (!metafile->hemf)
1864         return InvalidParameter;
1865
1866     if (metafile->playback_graphics)
1867         return ObjectBusy;
1868
1869     TRACE("%s %i -> %s %s %s\n", debugstr_rectf(srcRect), srcUnit,
1870         debugstr_pointf(&destPoints[0]), debugstr_pointf(&destPoints[1]),
1871         debugstr_pointf(&destPoints[2]));
1872
1873     data.callback = callback;
1874     data.callback_data = callbackData;
1875     data.metafile = real_metafile;
1876
1877     real_metafile->playback_graphics = graphics;
1878     real_metafile->playback_dc = NULL;
1879     real_metafile->src_rect = *srcRect;
1880
1881     memcpy(real_metafile->playback_points, destPoints, sizeof(PointF) * 3);
1882     stat = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, real_metafile->playback_points, 3);
1883
1884     if (stat == Ok)
1885         stat = GdipBeginContainer2(graphics, &state);
1886
1887     if (stat == Ok)
1888     {
1889         stat = GdipSetPageScale(graphics, 1.0);
1890
1891         if (stat == Ok)
1892             stat = GdipSetPageUnit(graphics, UnitPixel);
1893
1894         if (stat == Ok)
1895             stat = GdipResetWorldTransform(graphics);
1896
1897         if (stat == Ok)
1898             stat = GdipCreateRegion(&real_metafile->base_clip);
1899
1900         if (stat == Ok)
1901             stat = GdipGetClip(graphics, real_metafile->base_clip);
1902
1903         if (stat == Ok)
1904             stat = GdipCreateRegion(&real_metafile->clip);
1905
1906         if (stat == Ok)
1907             stat = GdipCreatePath(FillModeAlternate, &dst_path);
1908
1909         if (stat == Ok)
1910         {
1911             GpPointF clip_points[4];
1912
1913             clip_points[0] = real_metafile->playback_points[0];
1914             clip_points[1] = real_metafile->playback_points[1];
1915             clip_points[2].X = real_metafile->playback_points[1].X + real_metafile->playback_points[2].X
1916                 - real_metafile->playback_points[0].X;
1917             clip_points[2].Y = real_metafile->playback_points[1].Y + real_metafile->playback_points[2].Y
1918                 - real_metafile->playback_points[0].Y;
1919             clip_points[3] = real_metafile->playback_points[2];
1920
1921             stat = GdipAddPathPolygon(dst_path, clip_points, 4);
1922
1923             if (stat == Ok)
1924                 stat = GdipCombineRegionPath(real_metafile->base_clip, dst_path, CombineModeIntersect);
1925
1926             GdipDeletePath(dst_path);
1927         }
1928
1929         if (stat == Ok)
1930             stat = GdipCreateMatrix(&real_metafile->world_transform);
1931
1932         if (stat == Ok)
1933         {
1934             real_metafile->page_unit = UnitDisplay;
1935             real_metafile->page_scale = 1.0;
1936             stat = METAFILE_PlaybackUpdateWorldTransform(real_metafile);
1937         }
1938
1939         if (stat == Ok)
1940         {
1941             stat = METAFILE_PlaybackUpdateClip(real_metafile);
1942         }
1943
1944         if (stat == Ok && (metafile->metafile_type == MetafileTypeEmf ||
1945             metafile->metafile_type == MetafileTypeWmfPlaceable ||
1946             metafile->metafile_type == MetafileTypeWmf))
1947             stat = METAFILE_PlaybackGetDC(real_metafile);
1948
1949         if (stat == Ok)
1950             EnumEnhMetaFile(0, metafile->hemf, enum_metafile_proc, &data, NULL);
1951
1952         METAFILE_PlaybackReleaseDC(real_metafile);
1953
1954         GdipDeleteMatrix(real_metafile->world_transform);
1955         real_metafile->world_transform = NULL;
1956
1957         GdipDeleteRegion(real_metafile->base_clip);
1958         real_metafile->base_clip = NULL;
1959
1960         GdipDeleteRegion(real_metafile->clip);
1961         real_metafile->clip = NULL;
1962
1963         while (list_head(&real_metafile->containers))
1964         {
1965             container* cont = LIST_ENTRY(list_head(&real_metafile->containers), container, entry);
1966             list_remove(&cont->entry);
1967             GdipDeleteRegion(cont->clip);
1968             heap_free(cont);
1969         }
1970
1971         GdipEndContainer(graphics, state);
1972     }
1973
1974     real_metafile->playback_graphics = NULL;
1975
1976     return stat;
1977 }
1978
1979 GpStatus WINGDIPAPI GdipEnumerateMetafileDestRect(GpGraphics *graphics,
1980     GDIPCONST GpMetafile *metafile, GDIPCONST GpRectF *dest,
1981     EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
1982 {
1983     GpPointF points[3];
1984
1985     if (!graphics || !metafile || !dest) return InvalidParameter;
1986
1987     points[0].X = points[2].X = dest->X;
1988     points[0].Y = points[1].Y = dest->Y;
1989     points[1].X = dest->X + dest->Width;
1990     points[2].Y = dest->Y + dest->Height;
1991
1992     return GdipEnumerateMetafileSrcRectDestPoints(graphics, metafile, points, 3,
1993         &metafile->bounds, metafile->unit, callback, cb_data, attrs);
1994 }
1995
1996 GpStatus WINGDIPAPI GdipEnumerateMetafileDestRectI(GpGraphics *graphics,
1997     GDIPCONST GpMetafile *metafile, GDIPCONST GpRect *dest,
1998     EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
1999 {
2000     GpRectF destf;
2001
2002     if (!graphics || !metafile || !dest) return InvalidParameter;
2003
2004     destf.X = dest->X;
2005     destf.Y = dest->Y;
2006     destf.Width = dest->Width;
2007     destf.Height = dest->Height;
2008
2009     return GdipEnumerateMetafileDestRect(graphics, metafile, &destf, callback, cb_data, attrs);
2010 }
2011
2012 GpStatus WINGDIPAPI GdipEnumerateMetafileDestPoint(GpGraphics *graphics,
2013     GDIPCONST GpMetafile *metafile, GDIPCONST GpPointF *dest,
2014     EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
2015 {
2016     GpRectF destf;
2017
2018     if (!graphics || !metafile || !dest) return InvalidParameter;
2019
2020     destf.X = dest->X;
2021     destf.Y = dest->Y;
2022     destf.Width = units_to_pixels(metafile->bounds.Width, metafile->unit, metafile->image.xres);
2023     destf.Height = units_to_pixels(metafile->bounds.Height, metafile->unit, metafile->image.yres);
2024
2025     return GdipEnumerateMetafileDestRect(graphics, metafile, &destf, callback, cb_data, attrs);
2026 }
2027
2028 GpStatus WINGDIPAPI GdipEnumerateMetafileDestPointI(GpGraphics *graphics,
2029     GDIPCONST GpMetafile *metafile, GDIPCONST GpPoint *dest,
2030     EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
2031 {
2032     GpPointF ptf;
2033
2034     if (!graphics || !metafile || !dest) return InvalidParameter;
2035
2036     ptf.X = dest->X;
2037     ptf.Y = dest->Y;
2038
2039     return GdipEnumerateMetafileDestPoint(graphics, metafile, &ptf, callback, cb_data, attrs);
2040 }
2041
2042 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
2043     MetafileHeader * header)
2044 {
2045     GpStatus status;
2046
2047     TRACE("(%p, %p)\n", metafile, header);
2048
2049     if(!metafile || !header)
2050         return InvalidParameter;
2051
2052     if (metafile->hemf)
2053     {
2054         status = GdipGetMetafileHeaderFromEmf(metafile->hemf, header);
2055         if (status != Ok) return status;
2056     }
2057     else
2058     {
2059         memset(header, 0, sizeof(*header));
2060         header->Version = VERSION_MAGIC2;
2061     }
2062
2063     header->Type = metafile->metafile_type;
2064     header->DpiX = metafile->image.xres;
2065     header->DpiY = metafile->image.yres;
2066     header->Width = gdip_round(metafile->bounds.Width);
2067     header->Height = gdip_round(metafile->bounds.Height);
2068
2069     return Ok;
2070 }
2071
2072 static int CALLBACK get_emfplus_header_proc(HDC hDC, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR,
2073     int nObj, LPARAM lpData)
2074 {
2075     EmfPlusHeader *dst_header = (EmfPlusHeader*)lpData;
2076
2077     if (lpEMFR->iType == EMR_GDICOMMENT)
2078     {
2079         const EMRGDICOMMENT *comment = (const EMRGDICOMMENT*)lpEMFR;
2080
2081         if (comment->cbData >= 4 && memcmp(comment->Data, "EMF+", 4) == 0)
2082         {
2083             const EmfPlusRecordHeader *header = (const EmfPlusRecordHeader*)&comment->Data[4];
2084
2085             if (4 + sizeof(EmfPlusHeader) <= comment->cbData &&
2086                 header->Type == EmfPlusRecordTypeHeader)
2087             {
2088                 memcpy(dst_header, header, sizeof(*dst_header));
2089             }
2090         }
2091     }
2092     else if (lpEMFR->iType == EMR_HEADER)
2093         return TRUE;
2094
2095     return FALSE;
2096 }
2097
2098 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromEmf(HENHMETAFILE hemf,
2099     MetafileHeader *header)
2100 {
2101     ENHMETAHEADER3 emfheader;
2102     EmfPlusHeader emfplusheader;
2103     MetafileType metafile_type;
2104
2105     TRACE("(%p,%p)\n", hemf, header);
2106
2107     if(!hemf || !header)
2108         return InvalidParameter;
2109
2110     if (GetEnhMetaFileHeader(hemf, sizeof(emfheader), (ENHMETAHEADER*)&emfheader) == 0)
2111         return GenericError;
2112
2113     emfplusheader.Header.Type = 0;
2114
2115     EnumEnhMetaFile(NULL, hemf, get_emfplus_header_proc, &emfplusheader, NULL);
2116
2117     if (emfplusheader.Header.Type == EmfPlusRecordTypeHeader)
2118     {
2119         if ((emfplusheader.Header.Flags & 1) == 1)
2120             metafile_type = MetafileTypeEmfPlusDual;
2121         else
2122             metafile_type = MetafileTypeEmfPlusOnly;
2123     }
2124     else
2125         metafile_type = MetafileTypeEmf;
2126
2127     header->Type = metafile_type;
2128     header->Size = emfheader.nBytes;
2129     header->DpiX = (REAL)emfheader.szlDevice.cx * 25.4 / emfheader.szlMillimeters.cx;
2130     header->DpiY = (REAL)emfheader.szlDevice.cy * 25.4 / emfheader.szlMillimeters.cy;
2131     header->X = gdip_round((REAL)emfheader.rclFrame.left / 2540.0 * header->DpiX);
2132     header->Y = gdip_round((REAL)emfheader.rclFrame.top / 2540.0 * header->DpiY);
2133     header->Width = gdip_round((REAL)(emfheader.rclFrame.right - emfheader.rclFrame.left) / 2540.0 * header->DpiX);
2134     header->Height = gdip_round((REAL)(emfheader.rclFrame.bottom - emfheader.rclFrame.top) / 2540.0 * header->DpiY);
2135     header->u.EmfHeader = emfheader;
2136
2137     if (metafile_type == MetafileTypeEmfPlusDual || metafile_type == MetafileTypeEmfPlusOnly)
2138     {
2139         header->Version = emfplusheader.Version;
2140         header->EmfPlusFlags = emfplusheader.EmfPlusFlags;
2141         header->EmfPlusHeaderSize = emfplusheader.Header.Size;
2142         header->LogicalDpiX = emfplusheader.LogicalDpiX;
2143         header->LogicalDpiY = emfplusheader.LogicalDpiY;
2144     }
2145     else
2146     {
2147         header->Version = emfheader.nVersion;
2148         header->EmfPlusFlags = 0;
2149         header->EmfPlusHeaderSize = 0;
2150         header->LogicalDpiX = 0;
2151         header->LogicalDpiY = 0;
2152     }
2153
2154     return Ok;
2155 }
2156
2157 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromWmf(HMETAFILE hwmf,
2158     GDIPCONST WmfPlaceableFileHeader *placeable, MetafileHeader *header)
2159 {
2160     GpStatus status;
2161     GpMetafile *metafile;
2162
2163     TRACE("(%p,%p,%p)\n", hwmf, placeable, header);
2164
2165     status = GdipCreateMetafileFromWmf(hwmf, FALSE, placeable, &metafile);
2166     if (status == Ok)
2167     {
2168         status = GdipGetMetafileHeaderFromMetafile(metafile, header);
2169         GdipDisposeImage(&metafile->image);
2170     }
2171     return status;
2172 }
2173
2174 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromFile(GDIPCONST WCHAR *filename,
2175     MetafileHeader *header)
2176 {
2177     GpStatus status;
2178     GpMetafile *metafile;
2179
2180     TRACE("(%s,%p)\n", debugstr_w(filename), header);
2181
2182     if (!filename || !header)
2183         return InvalidParameter;
2184
2185     status = GdipCreateMetafileFromFile(filename, &metafile);
2186     if (status == Ok)
2187     {
2188         status = GdipGetMetafileHeaderFromMetafile(metafile, header);
2189         GdipDisposeImage(&metafile->image);
2190     }
2191     return status;
2192 }
2193
2194 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromStream(IStream *stream,
2195     MetafileHeader *header)
2196 {
2197     GpStatus status;
2198     GpMetafile *metafile;
2199
2200     TRACE("(%p,%p)\n", stream, header);
2201
2202     if (!stream || !header)
2203         return InvalidParameter;
2204
2205     status = GdipCreateMetafileFromStream(stream, &metafile);
2206     if (status == Ok)
2207     {
2208         status = GdipGetMetafileHeaderFromMetafile(metafile, header);
2209         GdipDisposeImage(&metafile->image);
2210     }
2211     return status;
2212 }
2213
2214 GpStatus WINGDIPAPI GdipCreateMetafileFromEmf(HENHMETAFILE hemf, BOOL delete,
2215     GpMetafile **metafile)
2216 {
2217     GpStatus stat;
2218     MetafileHeader header;
2219
2220     TRACE("(%p,%i,%p)\n", hemf, delete, metafile);
2221
2222     if(!hemf || !metafile)
2223         return InvalidParameter;
2224
2225     stat = GdipGetMetafileHeaderFromEmf(hemf, &header);
2226     if (stat != Ok)
2227         return stat;
2228
2229     *metafile = heap_alloc_zero(sizeof(GpMetafile));
2230     if (!*metafile)
2231         return OutOfMemory;
2232
2233     (*metafile)->image.type = ImageTypeMetafile;
2234     (*metafile)->image.format = ImageFormatEMF;
2235     (*metafile)->image.frame_count = 1;
2236     (*metafile)->image.xres = header.DpiX;
2237     (*metafile)->image.yres = header.DpiY;
2238     (*metafile)->bounds.X = (REAL)header.u.EmfHeader.rclFrame.left / 2540.0 * header.DpiX;
2239     (*metafile)->bounds.Y = (REAL)header.u.EmfHeader.rclFrame.top / 2540.0 * header.DpiY;
2240     (*metafile)->bounds.Width = (REAL)(header.u.EmfHeader.rclFrame.right - header.u.EmfHeader.rclFrame.left)
2241                                 / 2540.0 * header.DpiX;
2242     (*metafile)->bounds.Height = (REAL)(header.u.EmfHeader.rclFrame.bottom - header.u.EmfHeader.rclFrame.top)
2243                                  / 2540.0 * header.DpiY;
2244     (*metafile)->unit = UnitPixel;
2245     (*metafile)->metafile_type = header.Type;
2246     (*metafile)->hemf = hemf;
2247     (*metafile)->preserve_hemf = !delete;
2248     list_init(&(*metafile)->containers);
2249
2250     TRACE("<-- %p\n", *metafile);
2251
2252     return Ok;
2253 }
2254
2255 GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE hwmf, BOOL delete,
2256     GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
2257 {
2258     UINT read;
2259     BYTE *copy;
2260     HENHMETAFILE hemf;
2261     GpStatus retval = Ok;
2262
2263     TRACE("(%p, %d, %p, %p)\n", hwmf, delete, placeable, metafile);
2264
2265     if(!hwmf || !metafile)
2266         return InvalidParameter;
2267
2268     *metafile = NULL;
2269     read = GetMetaFileBitsEx(hwmf, 0, NULL);
2270     if(!read)
2271         return GenericError;
2272     copy = heap_alloc_zero(read);
2273     GetMetaFileBitsEx(hwmf, read, copy);
2274
2275     hemf = SetWinMetaFileBits(read, copy, NULL, NULL);
2276     heap_free(copy);
2277
2278     /* FIXME: We should store and use hwmf instead of converting to hemf */
2279     retval = GdipCreateMetafileFromEmf(hemf, TRUE, metafile);
2280
2281     if (retval == Ok)
2282     {
2283         if (placeable)
2284         {
2285             (*metafile)->image.xres = (REAL)placeable->Inch;
2286             (*metafile)->image.yres = (REAL)placeable->Inch;
2287             (*metafile)->bounds.X = ((REAL)placeable->BoundingBox.Left) / ((REAL)placeable->Inch);
2288             (*metafile)->bounds.Y = ((REAL)placeable->BoundingBox.Top) / ((REAL)placeable->Inch);
2289             (*metafile)->bounds.Width = (REAL)(placeable->BoundingBox.Right -
2290                                                placeable->BoundingBox.Left);
2291             (*metafile)->bounds.Height = (REAL)(placeable->BoundingBox.Bottom -
2292                                                 placeable->BoundingBox.Top);
2293             (*metafile)->metafile_type = MetafileTypeWmfPlaceable;
2294         }
2295         else
2296             (*metafile)->metafile_type = MetafileTypeWmf;
2297         (*metafile)->image.format = ImageFormatWMF;
2298
2299         if (delete) DeleteMetaFile(hwmf);
2300     }
2301     else
2302         DeleteEnhMetaFile(hemf);
2303     return retval;
2304 }
2305
2306 GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR *file,
2307     GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
2308 {
2309     HMETAFILE hmf = GetMetaFileW(file);
2310
2311     TRACE("(%s, %p, %p)\n", debugstr_w(file), placeable, metafile);
2312
2313     if(!hmf) return InvalidParameter;
2314
2315     return GdipCreateMetafileFromWmf(hmf, TRUE, placeable, metafile);
2316 }
2317
2318 GpStatus WINGDIPAPI GdipCreateMetafileFromFile(GDIPCONST WCHAR *file,
2319     GpMetafile **metafile)
2320 {
2321     GpStatus status;
2322     IStream *stream;
2323
2324     TRACE("(%p, %p)\n", file, metafile);
2325
2326     if (!file || !metafile) return InvalidParameter;
2327
2328     *metafile = NULL;
2329
2330     status = GdipCreateStreamOnFile(file, GENERIC_READ, &stream);
2331     if (status == Ok)
2332     {
2333         status = GdipCreateMetafileFromStream(stream, metafile);
2334         IStream_Release(stream);
2335     }
2336     return status;
2337 }
2338
2339 GpStatus WINGDIPAPI GdipCreateMetafileFromStream(IStream *stream,
2340     GpMetafile **metafile)
2341 {
2342     GpStatus stat;
2343
2344     TRACE("%p %p\n", stream, metafile);
2345
2346     stat = GdipLoadImageFromStream(stream, (GpImage **)metafile);
2347     if (stat != Ok) return stat;
2348
2349     if ((*metafile)->image.type != ImageTypeMetafile)
2350     {
2351         GdipDisposeImage(&(*metafile)->image);
2352         *metafile = NULL;
2353         return GenericError;
2354     }
2355
2356     return Ok;
2357 }
2358
2359 GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit(GpMetafile *metafile,
2360     UINT limitDpi)
2361 {
2362     TRACE("(%p,%u)\n", metafile, limitDpi);
2363
2364     return Ok;
2365 }
2366
2367 GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
2368     GpMetafile* metafile, BOOL* succ, EmfType emfType,
2369     const WCHAR* description, GpMetafile** out_metafile)
2370 {
2371     static int calls;
2372
2373     TRACE("(%p,%p,%p,%u,%s,%p)\n", ref, metafile, succ, emfType,
2374         debugstr_w(description), out_metafile);
2375
2376     if(!ref || !metafile || !out_metafile || emfType < EmfTypeEmfOnly || emfType > EmfTypeEmfPlusDual)
2377         return InvalidParameter;
2378
2379     if(succ)
2380         *succ = FALSE;
2381     *out_metafile = NULL;
2382
2383     if(!(calls++))
2384         FIXME("not implemented\n");
2385
2386     return NotImplemented;
2387 }
2388
2389 GpStatus WINGDIPAPI GdipEmfToWmfBits(HENHMETAFILE hemf, UINT cbData16,
2390     LPBYTE pData16, INT iMapMode, INT eFlags)
2391 {
2392     FIXME("(%p, %d, %p, %d, %d): stub\n", hemf, cbData16, pData16, iMapMode, eFlags);
2393     return NotImplemented;
2394 }
2395
2396 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
2397                             HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
2398                             MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
2399                             GpMetafile **metafile)
2400 {
2401     FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
2402                                  frameUnit, debugstr_w(desc), metafile);
2403
2404     return NotImplemented;
2405 }
2406
2407 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
2408                             GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
2409                             GDIPCONST WCHAR *desc, GpMetafile **metafile)
2410 {
2411     FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
2412                                  frameUnit, debugstr_w(desc), metafile);
2413
2414     return NotImplemented;
2415 }
2416
2417 /*****************************************************************************
2418  * GdipConvertToEmfPlusToFile [GDIPLUS.@]
2419  */
2420
2421 GpStatus WINGDIPAPI GdipConvertToEmfPlusToFile(const GpGraphics* refGraphics,
2422                                                GpMetafile* metafile, BOOL* conversionSuccess,
2423                                                const WCHAR* filename, EmfType emfType,
2424                                                const WCHAR* description, GpMetafile** out_metafile)
2425 {
2426     FIXME("stub: %p, %p, %p, %p, %u, %p, %p\n", refGraphics, metafile, conversionSuccess, filename, emfType, description, out_metafile);
2427     return NotImplemented;
2428 }
2429
2430 static GpStatus METAFILE_CreateCompressedImageStream(GpImage *image, IStream **stream, DWORD *size)
2431 {
2432     LARGE_INTEGER zero;
2433     STATSTG statstg;
2434     GpStatus stat;
2435     HRESULT hr;
2436
2437     *size = 0;
2438
2439     hr = CreateStreamOnHGlobal(NULL, TRUE, stream);
2440     if (FAILED(hr)) return hresult_to_status(hr);
2441
2442     stat = encode_image_png(image, *stream, NULL);
2443     if (stat != Ok)
2444     {
2445         IStream_Release(*stream);
2446         return stat;
2447     }
2448
2449     hr = IStream_Stat(*stream, &statstg, 1);
2450     if (FAILED(hr))
2451     {
2452         IStream_Release(*stream);
2453         return hresult_to_status(hr);
2454     }
2455     *size = statstg.cbSize.u.LowPart;
2456
2457     zero.QuadPart = 0;
2458     hr = IStream_Seek(*stream, zero, STREAM_SEEK_SET, NULL);
2459     if (FAILED(hr))
2460     {
2461         IStream_Release(*stream);
2462         return hresult_to_status(hr);
2463     }
2464
2465     return Ok;
2466 }
2467
2468 static GpStatus METAFILE_FillEmfPlusBitmap(EmfPlusBitmap *record, IStream *stream, DWORD size)
2469 {
2470     HRESULT hr;
2471
2472     record->Width = 0;
2473     record->Height = 0;
2474     record->Stride = 0;
2475     record->PixelFormat = 0;
2476     record->Type = BitmapDataTypeCompressed;
2477
2478     hr = IStream_Read(stream, record->BitmapData, size, NULL);
2479     if (FAILED(hr)) return hresult_to_status(hr);
2480     return Ok;
2481 }
2482
2483 static GpStatus METAFILE_AddImageObject(GpMetafile *metafile, GpImage *image, DWORD *id)
2484 {
2485     EmfPlusObject *object_record;
2486     GpStatus stat;
2487     DWORD size;
2488
2489     *id = -1;
2490
2491     if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
2492         return Ok;
2493
2494     if (image->type == ImageTypeBitmap)
2495     {
2496         IStream *stream;
2497         DWORD aligned_size;
2498
2499         stat = METAFILE_CreateCompressedImageStream(image, &stream, &size);
2500         if (stat != Ok) return stat;
2501         aligned_size = (size + 3) & ~3;
2502
2503         stat = METAFILE_AllocateRecord(metafile,
2504                 FIELD_OFFSET(EmfPlusObject, ObjectData.image.ImageData.bitmap.BitmapData[aligned_size]),
2505                 (void**)&object_record);
2506         if (stat != Ok)
2507         {
2508             IStream_Release(stream);
2509             return stat;
2510         }
2511         memset(object_record->ObjectData.image.ImageData.bitmap.BitmapData + size, 0, aligned_size - size);
2512
2513         *id = METAFILE_AddObjectId(metafile);
2514         object_record->Header.Type = EmfPlusRecordTypeObject;
2515         object_record->Header.Flags = *id | ObjectTypeImage << 8;
2516         object_record->ObjectData.image.Version = VERSION_MAGIC2;
2517         object_record->ObjectData.image.Type = ImageDataTypeBitmap;
2518
2519         stat = METAFILE_FillEmfPlusBitmap(&object_record->ObjectData.image.ImageData.bitmap, stream, size);
2520         IStream_Release(stream);
2521         if (stat != Ok) METAFILE_RemoveLastRecord(metafile, &object_record->Header);
2522         return stat;
2523     }
2524     else if (image->type == ImageTypeMetafile)
2525     {
2526         HENHMETAFILE hemf = ((GpMetafile*)image)->hemf;
2527         EmfPlusMetafile *metafile_record;
2528
2529         if (!hemf) return InvalidParameter;
2530
2531         size = GetEnhMetaFileBits(hemf, 0, NULL);
2532         if (!size) return GenericError;
2533
2534         stat  = METAFILE_AllocateRecord(metafile,
2535                 FIELD_OFFSET(EmfPlusObject, ObjectData.image.ImageData.metafile.MetafileData[size]),
2536                 (void**)&object_record);
2537         if (stat != Ok) return stat;
2538
2539         *id = METAFILE_AddObjectId(metafile);
2540         object_record->Header.Type = EmfPlusRecordTypeObject;
2541         object_record->Header.Flags = *id | ObjectTypeImage << 8;
2542         object_record->ObjectData.image.Version = VERSION_MAGIC2;
2543         object_record->ObjectData.image.Type = ImageDataTypeMetafile;
2544         metafile_record = &object_record->ObjectData.image.ImageData.metafile;
2545         metafile_record->Type = ((GpMetafile*)image)->metafile_type;
2546         metafile_record->MetafileDataSize = size;
2547         if (GetEnhMetaFileBits(hemf, size, metafile_record->MetafileData) != size)
2548         {
2549             METAFILE_RemoveLastRecord(metafile, &object_record->Header);
2550             return GenericError;
2551         }
2552         return Ok;
2553     }
2554     else
2555     {
2556         FIXME("not supported image type (%d)\n", image->type);
2557         return NotImplemented;
2558     }
2559 }
2560
2561 static GpStatus METAFILE_AddImageAttributesObject(GpMetafile *metafile, const GpImageAttributes *attrs, DWORD *id)
2562 {
2563     EmfPlusObject *object_record;
2564     EmfPlusImageAttributes *attrs_record;
2565     GpStatus stat;
2566
2567     *id = -1;
2568
2569     if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
2570         return Ok;
2571
2572     if (!attrs)
2573         return Ok;
2574
2575     stat = METAFILE_AllocateRecord(metafile,
2576             FIELD_OFFSET(EmfPlusObject, ObjectData.image_attributes) + sizeof(EmfPlusImageAttributes),
2577             (void**)&object_record);
2578     if (stat != Ok) return stat;
2579
2580     *id = METAFILE_AddObjectId(metafile);
2581     object_record->Header.Type = EmfPlusRecordTypeObject;
2582     object_record->Header.Flags = *id | (ObjectTypeImageAttributes << 8);
2583     attrs_record = &object_record->ObjectData.image_attributes;
2584     attrs_record->Version = VERSION_MAGIC2;
2585     attrs_record->Reserved1 = 0;
2586     attrs_record->WrapMode = attrs->wrap;
2587     attrs_record->ClampColor.Blue = attrs->outside_color & 0xff;
2588     attrs_record->ClampColor.Green = (attrs->outside_color >> 8) & 0xff;
2589     attrs_record->ClampColor.Red = (attrs->outside_color >> 16) & 0xff;
2590     attrs_record->ClampColor.Alpha = attrs->outside_color >> 24;
2591     attrs_record->ObjectClamp = attrs->clamp;
2592     attrs_record->Reserved2 = 0;
2593     return Ok;
2594 }
2595
2596 GpStatus METAFILE_DrawImagePointsRect(GpMetafile *metafile, GpImage *image,
2597      GDIPCONST GpPointF *points, INT count, REAL srcx, REAL srcy, REAL srcwidth,
2598      REAL srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
2599      DrawImageAbort callback, VOID *callbackData)
2600 {
2601     EmfPlusDrawImagePoints *draw_image_record;
2602     DWORD image_id, attributes_id;
2603     GpStatus stat;
2604
2605     if (count != 3) return InvalidParameter;
2606
2607     if (metafile->metafile_type == MetafileTypeEmf)
2608     {
2609         FIXME("MetafileTypeEmf metafiles not supported\n");
2610         return NotImplemented;
2611     }
2612     else
2613         FIXME("semi-stub\n");
2614
2615     if (!imageAttributes)
2616     {
2617         stat = METAFILE_AddImageObject(metafile, image, &image_id);
2618     }
2619     else if (image->type == ImageTypeBitmap)
2620     {
2621         INT width = ((GpBitmap*)image)->width;
2622         INT height = ((GpBitmap*)image)->height;
2623         GpGraphics *graphics;
2624         GpBitmap *bitmap;
2625
2626         stat = GdipCreateBitmapFromScan0(width, height,
2627                 0, PixelFormat32bppARGB, NULL, &bitmap);
2628         if (stat != Ok) return stat;
2629
2630         stat = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
2631         if (stat != Ok)
2632         {
2633             GdipDisposeImage((GpImage*)bitmap);
2634             return stat;
2635         }
2636
2637         stat = GdipDrawImageRectRectI(graphics, image, 0, 0, width, height,
2638                 0, 0, width, height, UnitPixel, imageAttributes, NULL, NULL);
2639         GdipDeleteGraphics(graphics);
2640         if (stat != Ok)
2641         {
2642             GdipDisposeImage((GpImage*)bitmap);
2643             return stat;
2644         }
2645
2646         stat = METAFILE_AddImageObject(metafile, (GpImage*)bitmap, &image_id);
2647         GdipDisposeImage((GpImage*)bitmap);
2648     }
2649     else
2650     {
2651         FIXME("imageAttributes not supported (image type %d)\n", image->type);
2652         return NotImplemented;
2653     }
2654     if (stat != Ok) return stat;
2655
2656     stat = METAFILE_AddImageAttributesObject(metafile, imageAttributes, &attributes_id);
2657     if (stat != Ok) return stat;
2658
2659     stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusDrawImagePoints), (void**)&draw_image_record);
2660     if (stat != Ok) return stat;
2661     draw_image_record->Header.Type = EmfPlusRecordTypeDrawImagePoints;
2662     draw_image_record->Header.Flags = image_id;
2663     draw_image_record->ImageAttributesID = attributes_id;
2664     draw_image_record->SrcUnit = UnitPixel;
2665     draw_image_record->SrcRect.X = units_to_pixels(srcx, srcUnit, metafile->image.xres);
2666     draw_image_record->SrcRect.Y = units_to_pixels(srcy, srcUnit, metafile->image.yres);
2667     draw_image_record->SrcRect.Width = units_to_pixels(srcwidth, srcUnit, metafile->image.xres);
2668     draw_image_record->SrcRect.Height = units_to_pixels(srcheight, srcUnit, metafile->image.yres);
2669     draw_image_record->count = 3;
2670     draw_image_record->PointData[0].pointF.X = points[0].X;
2671     draw_image_record->PointData[0].pointF.Y = points[0].Y;
2672     draw_image_record->PointData[1].pointF.X = points[1].X;
2673     draw_image_record->PointData[1].pointF.Y = points[1].Y;
2674     draw_image_record->PointData[2].pointF.X = points[2].X;
2675     draw_image_record->PointData[2].pointF.Y = points[2].Y;
2676     METAFILE_WriteRecords(metafile);
2677     return Ok;
2678 }
2679
2680 GpStatus METAFILE_AddSimpleProperty(GpMetafile *metafile, SHORT prop, SHORT val)
2681 {
2682     EmfPlusRecordHeader *record;
2683     GpStatus stat;
2684
2685     if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
2686         return Ok;
2687
2688     stat = METAFILE_AllocateRecord(metafile, sizeof(*record), (void**)&record);
2689     if (stat != Ok) return stat;
2690
2691     record->Type = prop;
2692     record->Flags = val;
2693
2694     METAFILE_WriteRecords(metafile);
2695     return Ok;
2696 }
2697
2698 static GpStatus METAFILE_AddPathObject(GpMetafile *metafile, GpPath *path, DWORD *id)
2699 {
2700     EmfPlusObject *object_record;
2701     GpStatus stat;
2702     DWORD size;
2703
2704     *id = -1;
2705     if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
2706         return Ok;
2707
2708     size = write_path_data(path, NULL);
2709     stat = METAFILE_AllocateRecord(metafile,
2710             FIELD_OFFSET(EmfPlusObject, ObjectData.path) + size,
2711             (void**)&object_record);
2712     if (stat != Ok) return stat;
2713
2714     *id = METAFILE_AddObjectId(metafile);
2715     object_record->Header.Type = EmfPlusRecordTypeObject;
2716     object_record->Header.Flags = *id | ObjectTypePath << 8;
2717     write_path_data(path, &object_record->ObjectData.path);
2718     return Ok;
2719 }
2720
2721 static GpStatus METAFILE_PrepareBrushData(GpBrush *brush, DWORD *size)
2722 {
2723     if (brush->bt == BrushTypeSolidColor)
2724     {
2725         *size = FIELD_OFFSET(EmfPlusBrush, BrushData.solid) + sizeof(EmfPlusSolidBrushData);
2726         return Ok;
2727     }
2728
2729     FIXME("unsupported brush type: %d\n", brush->bt);
2730     return NotImplemented;
2731 }
2732
2733 static void METAFILE_FillBrushData(GpBrush *brush, EmfPlusBrush *data)
2734 {
2735     if (brush->bt == BrushTypeSolidColor)
2736     {
2737         GpSolidFill *solid = (GpSolidFill*)brush;
2738
2739         data->Version = VERSION_MAGIC2;
2740         data->Type = solid->brush.bt;
2741         data->BrushData.solid.SolidColor.Blue = solid->color & 0xff;
2742         data->BrushData.solid.SolidColor.Green = (solid->color >> 8) & 0xff;
2743         data->BrushData.solid.SolidColor.Red = (solid->color >> 16) & 0xff;
2744         data->BrushData.solid.SolidColor.Alpha = solid->color >> 24;
2745     }
2746 }
2747
2748 static GpStatus METAFILE_AddPenObject(GpMetafile *metafile, GpPen *pen, DWORD *id)
2749 {
2750     DWORD i, data_flags, pen_data_size, brush_size;
2751     EmfPlusObject *object_record;
2752     EmfPlusPenData *pen_data;
2753     GpStatus stat;
2754     BOOL result;
2755
2756     *id = -1;
2757     if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
2758         return Ok;
2759
2760     data_flags = 0;
2761     pen_data_size = FIELD_OFFSET(EmfPlusPenData, OptionalData);
2762
2763     GdipIsMatrixIdentity(&pen->transform, &result);
2764     if (!result)
2765     {
2766         data_flags |= PenDataTransform;
2767         pen_data_size += sizeof(EmfPlusTransformMatrix);
2768     }
2769     if (pen->startcap != LineCapFlat)
2770     {
2771         data_flags |= PenDataStartCap;
2772         pen_data_size += sizeof(DWORD);
2773     }
2774     if (pen->endcap != LineCapFlat)
2775     {
2776         data_flags |= PenDataEndCap;
2777         pen_data_size += sizeof(DWORD);
2778     }
2779     if (pen->join != LineJoinMiter)
2780     {
2781         data_flags |= PenDataJoin;
2782         pen_data_size += sizeof(DWORD);
2783     }
2784     if (pen->miterlimit != 10.0)
2785     {
2786         data_flags |= PenDataMiterLimit;
2787         pen_data_size += sizeof(REAL);
2788     }
2789     if (pen->style != GP_DEFAULT_PENSTYLE)
2790     {
2791         data_flags |= PenDataLineStyle;
2792         pen_data_size += sizeof(DWORD);
2793     }
2794     if (pen->dashcap != DashCapFlat)
2795     {
2796         data_flags |= PenDataDashedLineCap;
2797         pen_data_size += sizeof(DWORD);
2798     }
2799     data_flags |= PenDataDashedLineOffset;
2800     pen_data_size += sizeof(REAL);
2801     if (pen->numdashes)
2802     {
2803         data_flags |= PenDataDashedLine;
2804         pen_data_size += sizeof(DWORD) + pen->numdashes*sizeof(REAL);
2805     }
2806     if (pen->align != PenAlignmentCenter)
2807     {
2808         data_flags |= PenDataNonCenter;
2809         pen_data_size += sizeof(DWORD);
2810     }
2811     /* TODO: Add support for PenDataCompoundLine */
2812     if (pen->customstart)
2813     {
2814         FIXME("ignoring custom start cup\n");
2815     }
2816     if (pen->customend)
2817     {
2818         FIXME("ignoring custom end cup\n");
2819     }
2820
2821     stat = METAFILE_PrepareBrushData(pen->brush, &brush_size);
2822     if (stat != Ok) return stat;
2823
2824     stat = METAFILE_AllocateRecord(metafile,
2825             FIELD_OFFSET(EmfPlusObject, ObjectData.pen.data) + pen_data_size + brush_size,
2826             (void**)&object_record);
2827     if (stat != Ok) return stat;
2828
2829     *id = METAFILE_AddObjectId(metafile);
2830     object_record->Header.Type = EmfPlusRecordTypeObject;
2831     object_record->Header.Flags = *id | ObjectTypePen << 8;
2832     object_record->ObjectData.pen.Version = VERSION_MAGIC2;
2833     object_record->ObjectData.pen.Type = 0;
2834
2835     pen_data = (EmfPlusPenData*)object_record->ObjectData.pen.data;
2836     pen_data->PenDataFlags = data_flags;
2837     pen_data->PenUnit = pen->unit;
2838     pen_data->PenWidth = pen->width;
2839
2840     i = 0;
2841     if (data_flags & PenDataTransform)
2842     {
2843         EmfPlusTransformMatrix *m = (EmfPlusTransformMatrix*)(pen_data->OptionalData + i);
2844         memcpy(m, &pen->transform, sizeof(*m));
2845         i += sizeof(EmfPlusTransformMatrix);
2846     }
2847     if (data_flags & PenDataStartCap)
2848     {
2849         *(DWORD*)(pen_data->OptionalData + i) = pen->startcap;
2850         i += sizeof(DWORD);
2851     }
2852     if (data_flags & PenDataEndCap)
2853     {
2854         *(DWORD*)(pen_data->OptionalData + i) = pen->endcap;
2855         i += sizeof(DWORD);
2856     }
2857     if (data_flags & PenDataJoin)
2858     {
2859         *(DWORD*)(pen_data->OptionalData + i) = pen->join;
2860         i += sizeof(DWORD);
2861     }
2862     if (data_flags & PenDataMiterLimit)
2863     {
2864         *(REAL*)(pen_data->OptionalData + i) = pen->miterlimit;
2865         i += sizeof(REAL);
2866     }
2867     if (data_flags & PenDataLineStyle)
2868     {
2869         switch (pen->style & PS_STYLE_MASK)
2870         {
2871         case PS_SOLID: *(DWORD*)(pen_data->OptionalData + i) = LineStyleSolid; break;
2872         case PS_DASH: *(DWORD*)(pen_data->OptionalData + i) = LineStyleDash; break;
2873         case PS_DOT: *(DWORD*)(pen_data->OptionalData + i) = LineStyleDot; break;
2874         case PS_DASHDOT: *(DWORD*)(pen_data->OptionalData + i) = LineStyleDashDot; break;
2875         case PS_DASHDOTDOT: *(DWORD*)(pen_data->OptionalData + i) = LineStyleDashDotDot; break;
2876         default: *(DWORD*)(pen_data->OptionalData + i) = LineStyleCustom; break;
2877         }
2878         i += sizeof(DWORD);
2879     }
2880     if (data_flags & PenDataDashedLineCap)
2881     {
2882         *(DWORD*)(pen_data->OptionalData + i) = pen->dashcap;
2883         i += sizeof(DWORD);
2884     }
2885     if (data_flags & PenDataDashedLineOffset)
2886     {
2887         *(REAL*)(pen_data->OptionalData + i) = pen->offset;
2888         i += sizeof(REAL);
2889     }
2890     if (data_flags & PenDataDashedLine)
2891     {
2892         int j;
2893
2894         *(DWORD*)(pen_data->OptionalData + i) = pen->numdashes;
2895         i += sizeof(DWORD);
2896
2897         for (j=0; j<pen->numdashes; j++)
2898         {
2899             *(REAL*)(pen_data->OptionalData + i) = pen->dashes[j];
2900             i += sizeof(REAL);
2901         }
2902     }
2903     if (data_flags & PenDataNonCenter)
2904     {
2905         *(REAL*)(pen_data->OptionalData + i) = pen->align;
2906         i += sizeof(DWORD);
2907     }
2908
2909     METAFILE_FillBrushData(pen->brush,
2910             (EmfPlusBrush*)(object_record->ObjectData.pen.data + pen_data_size));
2911     return Ok;
2912 }
2913
2914 GpStatus METAFILE_DrawPath(GpMetafile *metafile, GpPen *pen, GpPath *path)
2915 {
2916     EmfPlusDrawPath *draw_path_record;
2917     DWORD path_id;
2918     DWORD pen_id;
2919     GpStatus stat;
2920
2921     if (metafile->metafile_type == MetafileTypeEmf)
2922     {
2923         FIXME("stub!\n");
2924         return NotImplemented;
2925     }
2926
2927     stat = METAFILE_AddPenObject(metafile, pen, &pen_id);
2928     if (stat != Ok) return stat;
2929
2930     stat = METAFILE_AddPathObject(metafile, path, &path_id);
2931     if (stat != Ok) return stat;
2932
2933     stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusDrawPath), (void**)&draw_path_record);
2934     if (stat != Ok) return stat;
2935     draw_path_record->Header.Type = EmfPlusRecordTypeDrawPath;
2936     draw_path_record->Header.Flags = path_id;
2937     draw_path_record->PenId = pen_id;
2938
2939     METAFILE_WriteRecords(metafile);
2940     return Ok;
2941 }
2942
2943 static GpStatus METAFILE_AddBrushObject(GpMetafile *metafile, GpBrush *brush, DWORD *id)
2944 {
2945     EmfPlusObject *object_record;
2946     GpStatus stat;
2947     DWORD size;
2948
2949     *id = -1;
2950     if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
2951         return Ok;
2952
2953     stat = METAFILE_PrepareBrushData(brush, &size);
2954     if (stat != Ok) return stat;
2955
2956     stat = METAFILE_AllocateRecord(metafile,
2957         FIELD_OFFSET(EmfPlusObject, ObjectData) + size, (void**)&object_record);
2958     if (stat != Ok) return stat;
2959
2960     *id = METAFILE_AddObjectId(metafile);
2961     object_record->Header.Type = EmfPlusRecordTypeObject;
2962     object_record->Header.Flags = *id | ObjectTypeBrush << 8;
2963     METAFILE_FillBrushData(brush, &object_record->ObjectData.brush);
2964     return Ok;
2965 }
2966
2967 GpStatus METAFILE_FillPath(GpMetafile *metafile, GpBrush *brush, GpPath *path)
2968 {
2969     EmfPlusFillPath *fill_path_record;
2970     DWORD brush_id = -1, path_id;
2971     BOOL inline_color;
2972     GpStatus stat;
2973
2974     if (metafile->metafile_type == MetafileTypeEmf)
2975     {
2976         FIXME("stub!\n");
2977         return NotImplemented;
2978     }
2979
2980     inline_color = brush->bt == BrushTypeSolidColor;
2981     if (!inline_color)
2982     {
2983         stat = METAFILE_AddBrushObject(metafile, brush, &brush_id);
2984         if (stat != Ok) return stat;
2985     }
2986
2987     stat = METAFILE_AddPathObject(metafile, path, &path_id);
2988     if (stat != Ok) return stat;
2989
2990     stat = METAFILE_AllocateRecord(metafile,
2991             sizeof(EmfPlusFillPath), (void**)&fill_path_record);
2992     if (stat != Ok) return stat;
2993     fill_path_record->Header.Type = EmfPlusRecordTypeFillPath;
2994     if (inline_color)
2995     {
2996         fill_path_record->Header.Flags = 0x8000 | path_id;
2997         fill_path_record->data.Color.Blue = ((GpSolidFill*)brush)->color & 0xff;
2998         fill_path_record->data.Color.Green = (((GpSolidFill*)brush)->color >> 8) & 0xff;
2999         fill_path_record->data.Color.Red = (((GpSolidFill*)brush)->color >> 16) & 0xff;
3000         fill_path_record->data.Color.Alpha = ((GpSolidFill*)brush)->color >> 24;
3001     }
3002     else
3003     {
3004         fill_path_record->Header.Flags = path_id;
3005         fill_path_record->data.BrushId = brush_id;
3006     }
3007
3008     METAFILE_WriteRecords(metafile);
3009     return Ok;
3010 }