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
  29 #define COBJMACROS
  30 #include "objbase.h"
  31 #include "ocidl.h"
  32 #include "olectl.h"
  33 #include "ole2.h"
  34
  35 #include "winreg.h"
  36 #include "shlwapi.h"
  37
  38 #include "gdiplus.h"
  39 #include "gdiplus_private.h"
  40 #include "wine/debug.h"
  41 #include "wine/list.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  44
  45 HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT, IWICImagingFactory**);
  46
  47 typedef ARGB EmfPlusARGB;
  48
  49 typedef struct EmfPlusRecordHeader
  50 {
  51     WORD Type;
  52     WORD Flags;
  53     DWORD Size;
  54     DWORD DataSize;
  55 } EmfPlusRecordHeader;
  56
  57 typedef struct EmfPlusHeader
  58 {
  59     EmfPlusRecordHeader Header;
  60     DWORD Version;
  61     DWORD EmfPlusFlags;
  62     DWORD LogicalDpiX;
  63     DWORD LogicalDpiY;
  64 } EmfPlusHeader;
  65
  66 typedef struct EmfPlusClear
  67 {
  68     EmfPlusRecordHeader Header;
  69     DWORD Color;
  70 } EmfPlusClear;
  71
  72 typedef struct EmfPlusFillRects
  73 {
  74     EmfPlusRecordHeader Header;
  75     DWORD BrushID;
  76     DWORD Count;
  77 } EmfPlusFillRects;
  78
  79 typedef struct EmfPlusSetClipRect
  80 {
  81     EmfPlusRecordHeader Header;
  82     GpRectF ClipRect;
  83 } EmfPlusSetClipRect;
  84
  85 typedef struct EmfPlusSetPageTransform
  86 {
  87     EmfPlusRecordHeader Header;
  88     REAL PageScale;
  89 } EmfPlusSetPageTransform;
  90
  91 typedef struct EmfPlusRect
  92 {
  93     SHORT X;
  94     SHORT Y;
  95     SHORT Width;
  96     SHORT Height;
  97 } EmfPlusRect;
  98
  99 typedef struct EmfPlusSetWorldTransform
 100 {
 101     EmfPlusRecordHeader Header;
 102     REAL MatrixData[6];
 103 } EmfPlusSetWorldTransform;
 104
 105 typedef struct EmfPlusScaleWorldTransform
 106 {
 107     EmfPlusRecordHeader Header;
 108     REAL Sx;
 109     REAL Sy;
 110 } EmfPlusScaleWorldTransform;
 111
 112 typedef struct EmfPlusMultiplyWorldTransform
 113 {
 114     EmfPlusRecordHeader Header;
 115     REAL MatrixData[6];
 116 } EmfPlusMultiplyWorldTransform;
 117
 118 typedef struct EmfPlusRotateWorldTransform
 119 {
 120     EmfPlusRecordHeader Header;
 121     REAL Angle;
 122 } EmfPlusRotateWorldTransform;
 123
 124 typedef struct EmfPlusTranslateWorldTransform
 125 {
 126     EmfPlusRecordHeader Header;
 127     REAL dx;
 128     REAL dy;
 129 } EmfPlusTranslateWorldTransform;
 130
 131 typedef struct EmfPlusBeginContainer
 132 {
 133     EmfPlusRecordHeader Header;
 134     GpRectF DestRect;
 135     GpRectF SrcRect;
 136     DWORD StackIndex;
 137 } EmfPlusBeginContainer;
 138
 139 typedef struct EmfPlusContainerRecord
 140 {
 141     EmfPlusRecordHeader Header;
 142     DWORD StackIndex;
 143 } EmfPlusContainerRecord;
 144
 145 enum container_type
 146 {
 147     BEGIN_CONTAINER,
 148     SAVE_GRAPHICS
 149 };
 150
 151 typedef struct container
 152 {
 153     struct list entry;
 154     DWORD id;
 155     enum container_type type;
 156     GraphicsContainer state;
 157     GpMatrix world_transform;
 158     GpUnit page_unit;
 159     REAL page_scale;
 160     GpRegion *clip;
 161 } container;
 162
 163 enum PenDataFlags
 164 {
 165     PenDataTransform        = 0x0001,
 166     PenDataStartCap         = 0x0002,
 167     PenDataEndCap           = 0x0004,
 168     PenDataJoin             = 0x0008,
 169     PenDataMiterLimit       = 0x0010,
 170     PenDataLineStyle        = 0x0020,
 171     PenDataDashedLineCap    = 0x0040,
 172     PenDataDashedLineOffset = 0x0080,
 173     PenDataDashedLine       = 0x0100,
 174     PenDataNonCenter        = 0x0200,
 175     PenDataCompoundLine     = 0x0400,
 176     PenDataCustomStartCap   = 0x0800,
 177     PenDataCustomEndCap     = 0x1000
 178 };
 179
 180 typedef struct EmfPlusTransformMatrix
 181 {
 182     REAL TransformMatrix[6];
 183 } EmfPlusTransformMatrix;
 184
 185 enum LineStyle
 186 {
 187     LineStyleSolid,
 188     LineStyleDash,
 189     LineStyleDot,
 190     LineStyleDashDot,
 191     LineStyleDashDotDot,
 192     LineStyleCustom
 193 };
 194
 195 typedef struct EmfPlusDashedLineData
 196 {
 197     DWORD DashedLineDataSize;
 198     BYTE data[1];
 199 } EmfPlusDashedLineData;
 200
 201 typedef struct EmfPlusCompoundLineData
 202 {
 203     DWORD CompoundLineDataSize;
 204     BYTE data[1];
 205 } EmfPlusCompoundLineData;
 206
 207 typedef struct EmfPlusCustomStartCapData
 208 {
 209     DWORD CustomStartCapSize;
 210     BYTE data[1];
 211 } EmfPlusCustomStartCapData;
 212
 213 typedef struct EmfPlusCustomEndCapData
 214 {
 215     DWORD CustomEndCapSize;
 216     BYTE data[1];
 217 } EmfPlusCustomEndCapData;
 218
 219 typedef struct EmfPlusPenData
 220 {
 221     DWORD PenDataFlags;
 222     DWORD PenUnit;
 223     REAL PenWidth;
 224     BYTE OptionalData[1];
 225 } EmfPlusPenData;
 226
 227 enum BrushDataFlags
 228 {
 229     BrushDataPath             = 1 << 0,
 230     BrushDataTransform        = 1 << 1,
 231     BrushDataPresetColors     = 1 << 2,
 232     BrushDataBlendFactorsH    = 1 << 3,
 233     BrushDataBlendFactorsV    = 1 << 4,
 234     BrushDataFocusScales      = 1 << 6,
 235     BrushDataIsGammaCorrected = 1 << 7,
 236     BrushDataDoNotTransform   = 1 << 8,
 237 };
 238
 239 typedef struct EmfPlusSolidBrushData
 240 {
 241     EmfPlusARGB SolidColor;
 242 } EmfPlusSolidBrushData;
 243
 244 typedef struct EmfPlusHatchBrushData
 245 {
 246     DWORD HatchStyle;
 247     EmfPlusARGB ForeColor;
 248     EmfPlusARGB BackColor;
 249 } EmfPlusHatchBrushData;
 250
 251 typedef struct EmfPlusTextureBrushData
 252 {
 253     DWORD BrushDataFlags;
 254     INT WrapMode;
 255     BYTE OptionalData[1];
 256 } EmfPlusTextureBrushData;
 257
 258 typedef struct EmfPlusRectF
 259 {
 260     float X;
 261     float Y;
 262     float Width;
 263     float Height;
 264 } EmfPlusRectF;
 265
 266 typedef struct EmfPlusLinearGradientBrushData
 267 {
 268     DWORD BrushDataFlags;
 269     INT WrapMode;
 270     EmfPlusRectF RectF;
 271     EmfPlusARGB StartColor;
 272     EmfPlusARGB EndColor;
 273     DWORD Reserved1;
 274     DWORD Reserved2;
 275     BYTE OptionalData[1];
 276 } EmfPlusLinearGradientBrushData;
 277
 278 typedef struct EmfPlusBrush
 279 {
 280     DWORD Version;
 281     DWORD Type;
 282     union {
 283         EmfPlusSolidBrushData solid;
 284         EmfPlusHatchBrushData hatch;
 285         EmfPlusTextureBrushData texture;
 286         EmfPlusLinearGradientBrushData lineargradient;
 287     } BrushData;
 288 } EmfPlusBrush;
 289
 290 typedef struct EmfPlusPen
 291 {
 292     DWORD Version;
 293     DWORD Type;
 294     /* EmfPlusPenData */
 295     /* EmfPlusBrush */
 296     BYTE data[1];
 297 } EmfPlusPen;
 298
 299 typedef struct EmfPlusPath
 300 {
 301     DWORD Version;
 302     DWORD PathPointCount;
 303     DWORD PathPointFlags;
 304     /* PathPoints[] */
 305     /* PathPointTypes[] */
 306     /* AlignmentPadding */
 307     BYTE data[1];
 308 } EmfPlusPath;
 309
 310 typedef struct EmfPlusRegionNodePath
 311 {
 312     DWORD RegionNodePathLength;
 313     EmfPlusPath RegionNodePath;
 314 } EmfPlusRegionNodePath;
 315
 316 typedef struct EmfPlusRegion
 317 {
 318     DWORD Version;
 319     DWORD RegionNodeCount;
 320     BYTE RegionNode[1];
 321 } EmfPlusRegion;
 322
 323 typedef struct EmfPlusPalette
 324 {
 325     DWORD PaletteStyleFlags;
 326     DWORD PaletteCount;
 327     BYTE PaletteEntries[1];
 328 } EmfPlusPalette;
 329
 330 typedef enum
 331 {
 332     BitmapDataTypePixel,
 333     BitmapDataTypeCompressed,
 334 } BitmapDataType;
 335
 336 typedef struct EmfPlusBitmap
 337 {
 338     DWORD Width;
 339     DWORD Height;
 340     DWORD Stride;
 341     DWORD PixelFormat;
 342     DWORD Type;
 343     BYTE BitmapData[1];
 344 } EmfPlusBitmap;
 345
 346 typedef struct EmfPlusMetafile
 347 {
 348     DWORD Type;
 349     DWORD MetafileDataSize;
 350     BYTE MetafileData[1];
 351 } EmfPlusMetafile;
 352
 353 typedef enum ImageDataType
 354 {
 355     ImageDataTypeUnknown,
 356     ImageDataTypeBitmap,
 357     ImageDataTypeMetafile,
 358 } ImageDataType;
 359
 360 typedef struct EmfPlusImage
 361 {
 362     DWORD Version;
 363     ImageDataType Type;
 364     union
 365     {
 366         EmfPlusBitmap bitmap;
 367         EmfPlusMetafile metafile;
 368     } ImageData;
 369 } EmfPlusImage;
 370
 371 typedef struct EmfPlusImageAttributes
 372 {
 373     DWORD Version;
 374     DWORD Reserved1;
 375     DWORD WrapMode;
 376     EmfPlusARGB ClampColor;
 377     DWORD ObjectClamp;
 378     DWORD Reserved2;
 379 } EmfPlusImageAttributes;
 380
 381 typedef struct EmfPlusFont
 382 {
 383     DWORD Version;
 384     float EmSize;
 385     DWORD SizeUnit;
 386     DWORD FontStyleFlags;
 387     DWORD Reserved;
 388     DWORD Length;
 389     WCHAR FamilyName[1];
 390 } EmfPlusFont;
 391
 392 typedef struct EmfPlusObject
 393 {
 394     EmfPlusRecordHeader Header;
 395     union
 396     {
 397         EmfPlusBrush brush;
 398         EmfPlusPen pen;
 399         EmfPlusPath path;
 400         EmfPlusRegion region;
 401         EmfPlusImage image;
 402         EmfPlusImageAttributes image_attributes;
 403         EmfPlusFont font;
 404     } ObjectData;
 405 } EmfPlusObject;
 406
 407 typedef struct EmfPlusPointR7
 408 {
 409     BYTE X;
 410     BYTE Y;
 411 } EmfPlusPointR7;
 412
 413 typedef struct EmfPlusPoint
 414 {
 415     short X;
 416     short Y;
 417 } EmfPlusPoint;
 418
 419 typedef struct EmfPlusPointF
 420 {
 421     float X;
 422     float Y;
 423 } EmfPlusPointF;
 424
 425 typedef struct EmfPlusDrawImage
 426 {
 427     EmfPlusRecordHeader Header;
 428     DWORD ImageAttributesID;
 429     DWORD SrcUnit;
 430     EmfPlusRectF SrcRect;
 431     union
 432     {
 433         EmfPlusRect rect;
 434         EmfPlusRectF rectF;
 435     } RectData;
 436 } EmfPlusDrawImage;
 437
 438 typedef struct EmfPlusDrawImagePoints
 439 {
 440     EmfPlusRecordHeader Header;
 441     DWORD ImageAttributesID;
 442     DWORD SrcUnit;
 443     EmfPlusRectF SrcRect;
 444     DWORD count;
 445     union
 446     {
 447         EmfPlusPointR7 pointsR[3];
 448         EmfPlusPoint points[3];
 449         EmfPlusPointF pointsF[3];
 450     } PointData;
 451 } EmfPlusDrawImagePoints;
 452
 453 typedef struct EmfPlusDrawPath
 454 {
 455     EmfPlusRecordHeader Header;
 456     DWORD PenId;
 457 } EmfPlusDrawPath;
 458
 459 typedef struct EmfPlusDrawArc
 460 {
 461     EmfPlusRecordHeader Header;
 462     float StartAngle;
 463     float SweepAngle;
 464     union
 465     {
 466         EmfPlusRect rect;
 467         EmfPlusRectF rectF;
 468     } RectData;
 469 } EmfPlusDrawArc;
 470
 471 typedef struct EmfPlusDrawEllipse
 472 {
 473     EmfPlusRecordHeader Header;
 474     union
 475     {
 476         EmfPlusRect rect;
 477         EmfPlusRectF rectF;
 478     } RectData;
 479 } EmfPlusDrawEllipse;
 480
 481 typedef struct EmfPlusDrawPie
 482 {
 483     EmfPlusRecordHeader Header;
 484     float StartAngle;
 485     float SweepAngle;
 486     union
 487     {
 488         EmfPlusRect rect;
 489         EmfPlusRectF rectF;
 490     } RectData;
 491 } EmfPlusDrawPie;
 492
 493 typedef struct EmfPlusDrawRects
 494 {
 495     EmfPlusRecordHeader Header;
 496     DWORD Count;
 497     union
 498     {
 499         EmfPlusRect rect[1];
 500         EmfPlusRectF rectF[1];
 501     } RectData;
 502 } EmfPlusDrawRects;
 503
 504 typedef struct EmfPlusFillPath
 505 {
 506     EmfPlusRecordHeader Header;
 507     union
 508     {
 509         DWORD BrushId;
 510         EmfPlusARGB Color;
 511     } data;
 512 } EmfPlusFillPath;
 513
 514 typedef struct EmfPlusFillClosedCurve
 515 {
 516     EmfPlusRecordHeader Header;
 517     DWORD BrushId;
 518     float Tension;
 519     DWORD Count;
 520     union
 521     {
 522         EmfPlusPointR7 pointsR[1];
 523         EmfPlusPoint points[1];
 524         EmfPlusPointF pointsF[1];
 525     } PointData;
 526 } EmfPlusFillClosedCurve;
 527
 528 typedef struct EmfPlusFillEllipse
 529 {
 530     EmfPlusRecordHeader Header;
 531     DWORD BrushId;
 532     union
 533     {
 534         EmfPlusRect rect;
 535         EmfPlusRectF rectF;
 536     } RectData;
 537 } EmfPlusFillEllipse;
 538
 539 typedef struct EmfPlusFillPie
 540 {
 541     EmfPlusRecordHeader Header;
 542     DWORD BrushId;
 543     float StartAngle;
 544     float SweepAngle;
 545     union
 546     {
 547         EmfPlusRect rect;
 548         EmfPlusRectF rectF;
 549     } RectData;
 550 } EmfPlusFillPie;
 551
 552 typedef struct EmfPlusDrawDriverString
 553 {
 554     EmfPlusRecordHeader Header;
 555     union
 556     {
 557         DWORD BrushId;
 558         ARGB Color;
 559     } brush;
 560     DWORD DriverStringOptionsFlags;
 561     DWORD MatrixPresent;
 562     DWORD GlyphCount;
 563     BYTE VariableData[1];
 564 } EmfPlusDrawDriverString;
 565
 566 typedef struct EmfPlusFillRegion
 567 {
 568     EmfPlusRecordHeader Header;
 569     union
 570     {
 571         DWORD BrushId;
 572         EmfPlusARGB Color;
 573     } data;
 574 } EmfPlusFillRegion;
 575
 576 static void metafile_free_object_table_entry(GpMetafile *metafile, BYTE id)
 577 {
 578     struct emfplus_object *object = &metafile->objtable[id];
 579
 580     switch (object->type)
 581     {
 582     case ObjectTypeInvalid:
 583         break;
 584     case ObjectTypeBrush:
 585         GdipDeleteBrush(object->u.brush);
 586         break;
 587     case ObjectTypePen:
 588         GdipDeletePen(object->u.pen);
 589         break;
 590     case ObjectTypePath:
 591         GdipDeletePath(object->u.path);
 592         break;
 593     case ObjectTypeRegion:
 594         GdipDeleteRegion(object->u.region);
 595         break;
 596     case ObjectTypeImage:
 597         GdipDisposeImage(object->u.image);
 598         break;
 599     case ObjectTypeFont:
 600         GdipDeleteFont(object->u.font);
 601         break;
 602     case ObjectTypeImageAttributes:
 603         GdipDisposeImageAttributes(object->u.image_attributes);
 604         break;
 605     default:
 606         FIXME("not implemented for object type %u.\n", object->type);
 607         return;
 608     }
 609
 610     object->type = ObjectTypeInvalid;
 611     object->u.object = NULL;
 612 }
 613
 614 void METAFILE_Free(GpMetafile *metafile)
 615 {
 616     unsigned int i;
 617
 618     heap_free(metafile->comment_data);
 619     DeleteEnhMetaFile(CloseEnhMetaFile(metafile->record_dc));
 620     if (!metafile->preserve_hemf)
 621         DeleteEnhMetaFile(metafile->hemf);
 622     if (metafile->record_graphics)
 623     {
 624         WARN("metafile closed while recording\n");
 625         /* not sure what to do here; for now just prevent the graphics from functioning or using this object */
 626         metafile->record_graphics->image = NULL;
 627         metafile->record_graphics->busy = TRUE;
 628     }
 629
 630     if (metafile->record_stream)
 631         IStream_Release(metafile->record_stream);
 632
 633     for (i = 0; i < ARRAY_SIZE(metafile->objtable); i++)
 634         metafile_free_object_table_entry(metafile, i);
 635 }
 636
 637 static DWORD METAFILE_AddObjectId(GpMetafile *metafile)
 638 {
 639     return (metafile->next_object_id++) % EmfPlusObjectTableSize;
 640 }
 641
 642 static GpStatus METAFILE_AllocateRecord(GpMetafile *metafile, DWORD size, void **result)
 643 {
 644     DWORD size_needed;
 645     EmfPlusRecordHeader *record;
 646
 647     if (!metafile->comment_data_size)
 648     {
 649         DWORD data_size = max(256, size * 2 + 4);
 650         metafile->comment_data = heap_alloc_zero(data_size);
 651
 652         if (!metafile->comment_data)
 653             return OutOfMemory;
 654
 655         memcpy(metafile->comment_data, "EMF+", 4);
 656
 657         metafile->comment_data_size = data_size;
 658         metafile->comment_data_length = 4;
 659     }
 660
 661     size_needed = size + metafile->comment_data_length;
 662
 663     if (size_needed > metafile->comment_data_size)
 664     {
 665         DWORD data_size = size_needed * 2;
 666         BYTE *new_data = heap_alloc_zero(data_size);
 667
 668         if (!new_data)
 669             return OutOfMemory;
 670
 671         memcpy(new_data, metafile->comment_data, metafile->comment_data_length);
 672
 673         metafile->comment_data_size = data_size;
 674         heap_free(metafile->comment_data);
 675         metafile->comment_data = new_data;
 676     }
 677
 678     *result = metafile->comment_data + metafile->comment_data_length;
 679     metafile->comment_data_length += size;
 680
 681     record = (EmfPlusRecordHeader*)*result;
 682     record->Size = size;
 683     record->DataSize = size - sizeof(EmfPlusRecordHeader);
 684
 685     return Ok;
 686 }
 687
 688 static void METAFILE_RemoveLastRecord(GpMetafile *metafile, EmfPlusRecordHeader *record)
 689 {
 690     assert(metafile->comment_data + metafile->comment_data_length == (BYTE*)record + record->Size);
 691     metafile->comment_data_length -=  record->Size;
 692 }
 693
 694 static void METAFILE_WriteRecords(GpMetafile *metafile)
 695 {
 696     if (metafile->comment_data_length > 4)
 697     {
 698         GdiComment(metafile->record_dc, metafile->comment_data_length, metafile->comment_data);
 699         metafile->comment_data_length = 4;
 700     }
 701 }
 702
 703 static GpStatus METAFILE_WriteHeader(GpMetafile *metafile, HDC hdc)
 704 {
 705     GpStatus stat;
 706
 707     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 708     {
 709         EmfPlusHeader *header;
 710
 711         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusHeader), (void**)&header);
 712         if (stat != Ok)
 713             return stat;
 714
 715         header->Header.Type = EmfPlusRecordTypeHeader;
 716
 717         if (metafile->metafile_type == MetafileTypeEmfPlusDual)
 718             header->Header.Flags = 1;
 719         else
 720             header->Header.Flags = 0;
 721
 722         header->Version = VERSION_MAGIC2;
 723
 724         if (GetDeviceCaps(hdc, TECHNOLOGY) == DT_RASDISPLAY)
 725             header->EmfPlusFlags = 1;
 726         else
 727             header->EmfPlusFlags = 0;
 728
 729         header->LogicalDpiX = GetDeviceCaps(hdc, LOGPIXELSX);
 730         header->LogicalDpiY = GetDeviceCaps(hdc, LOGPIXELSY);
 731
 732         METAFILE_WriteRecords(metafile);
 733     }
 734
 735     return Ok;
 736 }
 737
 738 static GpStatus METAFILE_WriteEndOfFile(GpMetafile *metafile)
 739 {
 740     GpStatus stat;
 741
 742     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 743     {
 744         EmfPlusRecordHeader *record;
 745
 746         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusRecordHeader), (void**)&record);
 747         if (stat != Ok)
 748             return stat;
 749
 750         record->Type = EmfPlusRecordTypeEndOfFile;
 751         record->Flags = 0;
 752
 753         METAFILE_WriteRecords(metafile);
 754     }
 755
 756     return Ok;
 757 }
 758
 759 GpStatus WINGDIPAPI GdipRecordMetafile(HDC hdc, EmfType type, GDIPCONST GpRectF *frameRect,
 760                                        MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
 761 {
 762     HDC record_dc;
 763     REAL dpix, dpiy;
 764     REAL framerect_factor_x, framerect_factor_y;
 765     RECT rc, *lprc;
 766     GpStatus stat;
 767
 768     TRACE("(%p %d %s %d %p %p)\n", hdc, type, debugstr_rectf(frameRect), frameUnit, desc, metafile);
 769
 770     if (!hdc || type < EmfTypeEmfOnly || type > EmfTypeEmfPlusDual || !metafile)
 771         return InvalidParameter;
 772
 773     dpix = (REAL)GetDeviceCaps(hdc, HORZRES) / GetDeviceCaps(hdc, HORZSIZE) * 25.4;
 774     dpiy = (REAL)GetDeviceCaps(hdc, VERTRES) / GetDeviceCaps(hdc, VERTSIZE) * 25.4;
 775
 776     if (frameRect)
 777     {
 778         switch (frameUnit)
 779         {
 780         case MetafileFrameUnitPixel:
 781             framerect_factor_x = 2540.0 / dpix;
 782             framerect_factor_y = 2540.0 / dpiy;
 783             break;
 784         case MetafileFrameUnitPoint:
 785             framerect_factor_x = framerect_factor_y = 2540.0 / 72.0;
 786             break;
 787         case MetafileFrameUnitInch:
 788             framerect_factor_x = framerect_factor_y = 2540.0;
 789             break;
 790         case MetafileFrameUnitDocument:
 791             framerect_factor_x = framerect_factor_y = 2540.0 / 300.0;
 792             break;
 793         case MetafileFrameUnitMillimeter:
 794             framerect_factor_x = framerect_factor_y = 100.0;
 795             break;
 796         case MetafileFrameUnitGdi:
 797             framerect_factor_x = framerect_factor_y = 1.0;
 798             break;
 799         default:
 800             return InvalidParameter;
 801         }
 802
 803         rc.left = framerect_factor_x * frameRect->X;
 804         rc.top = framerect_factor_y * frameRect->Y;
 805         rc.right = rc.left + framerect_factor_x * frameRect->Width;
 806         rc.bottom = rc.top + framerect_factor_y * frameRect->Height;
 807
 808         lprc = &rc;
 809     }
 810     else
 811         lprc = NULL;
 812
 813     record_dc = CreateEnhMetaFileW(hdc, NULL, lprc, desc);
 814
 815     if (!record_dc)
 816         return GenericError;
 817
 818     *metafile = heap_alloc_zero(sizeof(GpMetafile));
 819     if(!*metafile)
 820     {
 821         DeleteEnhMetaFile(CloseEnhMetaFile(record_dc));
 822         return OutOfMemory;
 823     }
 824
 825     (*metafile)->image.type = ImageTypeMetafile;
 826     (*metafile)->image.flags   = ImageFlagsNone;
 827     (*metafile)->image.palette = NULL;
 828     (*metafile)->image.xres = dpix;
 829     (*metafile)->image.yres = dpiy;
 830     (*metafile)->bounds.X = (*metafile)->bounds.Y = 0.0;
 831     (*metafile)->bounds.Width = (*metafile)->bounds.Height = 1.0;
 832     (*metafile)->unit = UnitPixel;
 833     (*metafile)->metafile_type = type;
 834     (*metafile)->record_dc = record_dc;
 835     (*metafile)->comment_data = NULL;
 836     (*metafile)->comment_data_size = 0;
 837     (*metafile)->comment_data_length = 0;
 838     (*metafile)->limit_dpi = 96;
 839     (*metafile)->hemf = NULL;
 840     list_init(&(*metafile)->containers);
 841
 842     if (!frameRect)
 843     {
 844         (*metafile)->auto_frame = TRUE;
 845         (*metafile)->auto_frame_min.X = 0;
 846         (*metafile)->auto_frame_min.Y = 0;
 847         (*metafile)->auto_frame_max.X = -1;
 848         (*metafile)->auto_frame_max.Y = -1;
 849     }
 850
 851     stat = METAFILE_WriteHeader(*metafile, hdc);
 852
 853     if (stat != Ok)
 854     {
 855         DeleteEnhMetaFile(CloseEnhMetaFile(record_dc));
 856         heap_free(*metafile);
 857         *metafile = NULL;
 858         return OutOfMemory;
 859     }
 860
 861     return stat;
 862 }
 863
 864 /*****************************************************************************
 865  * GdipRecordMetafileI [GDIPLUS.@]
 866  */
 867 GpStatus WINGDIPAPI GdipRecordMetafileI(HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
 868                                         MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
 869 {
 870     GpRectF frameRectF, *pFrameRectF;
 871
 872     TRACE("(%p %d %p %d %p %p)\n", hdc, type, frameRect, frameUnit, desc, metafile);
 873
 874     if (frameRect)
 875     {
 876         frameRectF.X = frameRect->X;
 877         frameRectF.Y = frameRect->Y;
 878         frameRectF.Width = frameRect->Width;
 879         frameRectF.Height = frameRect->Height;
 880         pFrameRectF = &frameRectF;
 881     }
 882     else
 883         pFrameRectF = NULL;
 884
 885     return GdipRecordMetafile(hdc, type, pFrameRectF, frameUnit, desc, metafile);
 886 }
 887
 888 GpStatus WINGDIPAPI GdipRecordMetafileStreamI(IStream *stream, HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
 889                                         MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
 890 {
 891     GpRectF frameRectF, *pFrameRectF;
 892
 893     TRACE("(%p %p %d %p %d %p %p)\n", stream, hdc, type, frameRect, frameUnit, desc, metafile);
 894
 895     if (frameRect)
 896     {
 897         frameRectF.X = frameRect->X;
 898         frameRectF.Y = frameRect->Y;
 899         frameRectF.Width = frameRect->Width;
 900         frameRectF.Height = frameRect->Height;
 901         pFrameRectF = &frameRectF;
 902     }
 903     else
 904         pFrameRectF = NULL;
 905
 906     return GdipRecordMetafileStream(stream, hdc, type, pFrameRectF, frameUnit, desc, metafile);
 907 }
 908
 909 GpStatus WINGDIPAPI GdipRecordMetafileStream(IStream *stream, HDC hdc, EmfType type, GDIPCONST GpRectF *frameRect,
 910                                         MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
 911 {
 912     GpStatus stat;
 913
 914     TRACE("(%p %p %d %s %d %p %p)\n", stream, hdc, type, debugstr_rectf(frameRect), frameUnit, desc, metafile);
 915
 916     if (!stream)
 917         return InvalidParameter;
 918
 919     stat = GdipRecordMetafile(hdc, type, frameRect, frameUnit, desc, metafile);
 920
 921     if (stat == Ok)
 922     {
 923         (*metafile)->record_stream = stream;
 924         IStream_AddRef(stream);
 925     }
 926
 927     return stat;
 928 }
 929
 930 static void METAFILE_AdjustFrame(GpMetafile* metafile, const GpPointF *points,
 931     UINT num_points)
 932 {
 933     int i;
 934
 935     if (!metafile->auto_frame || !num_points)
 936         return;
 937
 938     if (metafile->auto_frame_max.X < metafile->auto_frame_min.X)
 939         metafile->auto_frame_max = metafile->auto_frame_min = points[0];
 940
 941     for (i=0; i<num_points; i++)
 942     {
 943         if (points[i].X < metafile->auto_frame_min.X)
 944             metafile->auto_frame_min.X = points[i].X;
 945         if (points[i].X > metafile->auto_frame_max.X)
 946             metafile->auto_frame_max.X = points[i].X;
 947         if (points[i].Y < metafile->auto_frame_min.Y)
 948             metafile->auto_frame_min.Y = points[i].Y;
 949         if (points[i].Y > metafile->auto_frame_max.Y)
 950             metafile->auto_frame_max.Y = points[i].Y;
 951     }
 952 }
 953
 954 GpStatus METAFILE_GetGraphicsContext(GpMetafile* metafile, GpGraphics **result)
 955 {
 956     GpStatus stat;
 957
 958     if (!metafile->record_dc || metafile->record_graphics)
 959         return InvalidParameter;
 960
 961     stat = graphics_from_image((GpImage*)metafile, &metafile->record_graphics);
 962
 963     if (stat == Ok)
 964     {
 965         *result = metafile->record_graphics;
 966         metafile->record_graphics->xres = 96.0;
 967         metafile->record_graphics->yres = 96.0;
 968     }
 969
 970     return stat;
 971 }
 972
 973 GpStatus METAFILE_GetDC(GpMetafile* metafile, HDC *hdc)
 974 {
 975     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 976     {
 977         EmfPlusRecordHeader *record;
 978         GpStatus stat;
 979
 980         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusRecordHeader), (void**)&record);
 981         if (stat != Ok)
 982             return stat;
 983
 984         record->Type = EmfPlusRecordTypeGetDC;
 985         record->Flags = 0;
 986
 987         METAFILE_WriteRecords(metafile);
 988     }
 989
 990     *hdc = metafile->record_dc;
 991
 992     return Ok;
 993 }
 994
 995 GpStatus METAFILE_GraphicsClear(GpMetafile* metafile, ARGB color)
 996 {
 997     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 998     {
 999         EmfPlusClear *record;
1000         GpStatus stat;
1001
1002         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusClear), (void**)&record);
1003         if (stat != Ok)
1004             return stat;
1005
1006         record->Header.Type = EmfPlusRecordTypeClear;
1007         record->Header.Flags = 0;
1008         record->Color = color;
1009
1010         METAFILE_WriteRecords(metafile);
1011     }
1012
1013     return Ok;
1014 }
1015
1016 static BOOL is_integer_rect(const GpRectF *rect)
1017 {
1018     SHORT x, y, width, height;
1019     x = rect->X;
1020     y = rect->Y;
1021     width = rect->Width;
1022     height = rect->Height;
1023     if (rect->X != (REAL)x || rect->Y != (REAL)y ||
1024         rect->Width != (REAL)width || rect->Height != (REAL)height)
1025         return FALSE;
1026     return TRUE;
1027 }
1028
1029 static GpStatus METAFILE_PrepareBrushData(GDIPCONST GpBrush *brush, DWORD *size)
1030 {
1031     switch (brush->bt)
1032     {
1033     case BrushTypeSolidColor:
1034         *size = FIELD_OFFSET(EmfPlusBrush, BrushData) + sizeof(EmfPlusSolidBrushData);
1035         break;
1036     case BrushTypeHatchFill:
1037         *size = FIELD_OFFSET(EmfPlusBrush, BrushData) + sizeof(EmfPlusHatchBrushData);
1038         break;
1039     case BrushTypeLinearGradient:
1040     {
1041         BOOL ignore_xform;
1042         GpLineGradient *gradient = (GpLineGradient*)brush;
1043
1044         *size = FIELD_OFFSET(EmfPlusBrush, BrushData.lineargradient.OptionalData);
1045
1046         GdipIsMatrixIdentity(&gradient->transform, &ignore_xform);
1047         if (!ignore_xform)
1048             *size += sizeof(gradient->transform);
1049
1050         if (gradient->pblendcount > 1 && gradient->pblendcolor && gradient->pblendpos)
1051             *size += sizeof(DWORD) + gradient->pblendcount *
1052                 (sizeof(*gradient->pblendcolor) + sizeof(*gradient->pblendpos));
1053         else if (gradient->blendcount > 1 && gradient->blendfac && gradient->blendpos)
1054             *size += sizeof(DWORD) + gradient->blendcount *
1055                 (sizeof(*gradient->blendfac) + sizeof(*gradient->blendpos));
1056
1057         break;
1058     }
1059     default:
1060         FIXME("unsupported brush type: %d\n", brush->bt);
1061         return NotImplemented;
1062     }
1063
1064     return Ok;
1065 }
1066
1067 static void METAFILE_FillBrushData(GDIPCONST GpBrush *brush, EmfPlusBrush *data)
1068 {
1069     data->Version = VERSION_MAGIC2;
1070     data->Type = brush->bt;
1071
1072     switch (brush->bt)
1073     {
1074     case BrushTypeSolidColor:
1075     {
1076         GpSolidFill *solid = (GpSolidFill *)brush;
1077         data->BrushData.solid.SolidColor = solid->color;
1078         break;
1079     }
1080     case BrushTypeHatchFill:
1081     {
1082         GpHatch *hatch = (GpHatch *)brush;
1083         data->BrushData.hatch.HatchStyle = hatch->hatchstyle;
1084         data->BrushData.hatch.ForeColor = hatch->forecol;
1085         data->BrushData.hatch.BackColor = hatch->backcol;
1086         break;
1087     }
1088     case BrushTypeLinearGradient:
1089     {
1090         BYTE *cursor;
1091         BOOL ignore_xform;
1092         GpLineGradient *gradient = (GpLineGradient*)brush;
1093
1094         data->BrushData.lineargradient.BrushDataFlags = 0;
1095         data->BrushData.lineargradient.WrapMode = gradient->wrap;
1096         data->BrushData.lineargradient.RectF.X = gradient->rect.X;
1097         data->BrushData.lineargradient.RectF.Y = gradient->rect.Y;
1098         data->BrushData.lineargradient.RectF.Width = gradient->rect.Width;
1099         data->BrushData.lineargradient.RectF.Height = gradient->rect.Height;
1100         data->BrushData.lineargradient.StartColor = gradient->startcolor;
1101         data->BrushData.lineargradient.EndColor = gradient->endcolor;
1102         data->BrushData.lineargradient.Reserved1 = gradient->startcolor;
1103         data->BrushData.lineargradient.Reserved2 = gradient->endcolor;
1104
1105         if (gradient->gamma)
1106             data->BrushData.lineargradient.BrushDataFlags |= BrushDataIsGammaCorrected;
1107
1108         cursor = &data->BrushData.lineargradient.OptionalData[0];
1109
1110         GdipIsMatrixIdentity(&gradient->transform, &ignore_xform);
1111         if (!ignore_xform)
1112         {
1113             data->BrushData.lineargradient.BrushDataFlags |= BrushDataTransform;
1114             memcpy(cursor, &gradient->transform, sizeof(gradient->transform));
1115             cursor += sizeof(gradient->transform);
1116         }
1117
1118         if (gradient->pblendcount > 1 && gradient->pblendcolor && gradient->pblendpos)
1119         {
1120             const DWORD count = gradient->pblendcount;
1121
1122             data->BrushData.lineargradient.BrushDataFlags |= BrushDataPresetColors;
1123
1124             memcpy(cursor, &count, sizeof(count));
1125             cursor += sizeof(count);
1126
1127             memcpy(cursor, gradient->pblendpos, count * sizeof(*gradient->pblendpos));
1128             cursor += count * sizeof(*gradient->pblendpos);
1129
1130             memcpy(cursor, gradient->pblendcolor, count * sizeof(*gradient->pblendcolor));
1131         }
1132         else if (gradient->blendcount > 1 && gradient->blendfac && gradient->blendpos)
1133         {
1134             const DWORD count = gradient->blendcount;
1135
1136             data->BrushData.lineargradient.BrushDataFlags |= BrushDataBlendFactorsH;
1137
1138             memcpy(cursor, &count, sizeof(count));
1139             cursor += sizeof(count);
1140
1141             memcpy(cursor, gradient->blendpos, count * sizeof(*gradient->blendpos));
1142             cursor += count * sizeof(*gradient->blendpos);
1143
1144             memcpy(cursor, gradient->blendfac, count * sizeof(*gradient->blendfac));
1145         }
1146
1147         break;
1148     }
1149     default:
1150         FIXME("unsupported brush type: %d\n", brush->bt);
1151     }
1152 }
1153
1154 static GpStatus METAFILE_AddBrushObject(GpMetafile *metafile, GDIPCONST GpBrush *brush, DWORD *id)
1155 {
1156     EmfPlusObject *object_record;
1157     GpStatus stat;
1158     DWORD size;
1159
1160     *id = -1;
1161     if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
1162         return Ok;
1163
1164     stat = METAFILE_PrepareBrushData(brush, &size);
1165     if (stat != Ok) return stat;
1166
1167     stat = METAFILE_AllocateRecord(metafile,
1168         FIELD_OFFSET(EmfPlusObject, ObjectData) + size, (void**)&object_record);
1169     if (stat != Ok) return stat;
1170
1171     *id = METAFILE_AddObjectId(metafile);
1172     object_record->Header.Type = EmfPlusRecordTypeObject;
1173     object_record->Header.Flags = *id | ObjectTypeBrush << 8;
1174     METAFILE_FillBrushData(brush, &object_record->ObjectData.brush);
1175     return Ok;
1176 }
1177
1178 GpStatus METAFILE_FillRectangles(GpMetafile* metafile, GpBrush* brush,
1179     GDIPCONST GpRectF* rects, INT count)
1180 {
1181     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1182     {
1183         EmfPlusFillRects *record;
1184         GpStatus stat;
1185         BOOL integer_rects = TRUE;
1186         int i;
1187         DWORD brushid;
1188         int flags = 0;
1189
1190         if (brush->bt == BrushTypeSolidColor)
1191         {
1192             flags |= 0x8000;
1193             brushid = ((GpSolidFill*)brush)->color;
1194         }
1195         else
1196         {
1197             stat = METAFILE_AddBrushObject(metafile, brush, &brushid);
1198             if (stat != Ok)
1199                 return stat;
1200         }
1201
1202         for (i=0; i<count; i++)
1203         {
1204             if (!is_integer_rect(&rects[i]))
1205             {
1206                 integer_rects = FALSE;
1207                 break;
1208             }
1209         }
1210
1211         if (integer_rects)
1212             flags |= 0x4000;
1213
1214         stat = METAFILE_AllocateRecord(metafile,
1215             sizeof(EmfPlusFillRects) + count * (integer_rects ? sizeof(EmfPlusRect) : sizeof(GpRectF)),
1216             (void**)&record);
1217         if (stat != Ok)
1218             return stat;
1219
1220         record->Header.Type = EmfPlusRecordTypeFillRects;
1221         record->Header.Flags = flags;
1222         record->BrushID = brushid;
1223         record->Count = count;
1224
1225         if (integer_rects)
1226         {
1227             EmfPlusRect *record_rects = (EmfPlusRect*)(record+1);
1228             for (i=0; i<count; i++)
1229             {
1230                 record_rects[i].X = (SHORT)rects[i].X;
1231                 record_rects[i].Y = (SHORT)rects[i].Y;
1232                 record_rects[i].Width = (SHORT)rects[i].Width;
1233                 record_rects[i].Height = (SHORT)rects[i].Height;
1234             }
1235         }
1236         else
1237             memcpy(record+1, rects, sizeof(GpRectF) * count);
1238
1239         METAFILE_WriteRecords(metafile);
1240     }
1241
1242     if (metafile->auto_frame)
1243     {
1244         GpPointF corners[4];
1245         int i;
1246
1247         for (i=0; i<count; i++)
1248         {
1249             corners[0].X = rects[i].X;
1250             corners[0].Y = rects[i].Y;
1251             corners[1].X = rects[i].X + rects[i].Width;
1252             corners[1].Y = rects[i].Y;
1253             corners[2].X = rects[i].X;
1254             corners[2].Y = rects[i].Y + rects[i].Height;
1255             corners[3].X = rects[i].X + rects[i].Width;
1256             corners[3].Y = rects[i].Y + rects[i].Height;
1257
1258             GdipTransformPoints(metafile->record_graphics, CoordinateSpaceDevice,
1259                 CoordinateSpaceWorld, corners, 4);
1260
1261             METAFILE_AdjustFrame(metafile, corners, 4);
1262         }
1263     }
1264
1265     return Ok;
1266 }
1267
1268 GpStatus METAFILE_SetClipRect(GpMetafile* metafile, REAL x, REAL y, REAL width, REAL height, CombineMode mode)
1269 {
1270     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1271     {
1272         EmfPlusSetClipRect *record;
1273         GpStatus stat;
1274
1275         stat = METAFILE_AllocateRecord(metafile,
1276             sizeof(EmfPlusSetClipRect),
1277             (void**)&record);
1278         if (stat != Ok)
1279             return stat;
1280
1281         record->Header.Type = EmfPlusRecordTypeSetClipRect;
1282         record->Header.Flags = (mode & 0xf) << 8;
1283         record->ClipRect.X = x;
1284         record->ClipRect.Y = y;
1285         record->ClipRect.Width = width;
1286         record->ClipRect.Height = height;
1287
1288         METAFILE_WriteRecords(metafile);
1289     }
1290
1291     return Ok;
1292 }
1293
1294 static GpStatus METAFILE_AddRegionObject(GpMetafile *metafile, GpRegion *region, DWORD *id)
1295 {
1296     EmfPlusObject *object_record;
1297     DWORD size;
1298     GpStatus stat;
1299
1300     *id = -1;
1301     if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
1302         return Ok;
1303
1304     size = write_region_data(region, NULL);
1305     stat = METAFILE_AllocateRecord(metafile,
1306             FIELD_OFFSET(EmfPlusObject, ObjectData.region) + size, (void**)&object_record);
1307     if (stat != Ok) return stat;
1308
1309     *id = METAFILE_AddObjectId(metafile);
1310     object_record->Header.Type = EmfPlusRecordTypeObject;
1311     object_record->Header.Flags = *id | ObjectTypeRegion << 8;
1312     write_region_data(region, &object_record->ObjectData.region);
1313     return Ok;
1314 }
1315
1316 GpStatus METAFILE_SetClipRegion(GpMetafile* metafile, GpRegion* region, CombineMode mode)
1317 {
1318     EmfPlusRecordHeader *record;
1319     DWORD region_id;
1320     GpStatus stat;
1321
1322     if (metafile->metafile_type == MetafileTypeEmf)
1323     {
1324         FIXME("stub!\n");
1325         return NotImplemented;
1326     }
1327
1328     stat = METAFILE_AddRegionObject(metafile, region, &region_id);
1329     if (stat != Ok) return stat;
1330
1331     stat = METAFILE_AllocateRecord(metafile, sizeof(*record), (void**)&record);
1332     if (stat != Ok) return stat;
1333
1334     record->Type = EmfPlusRecordTypeSetClipRegion;
1335     record->Flags = region_id | mode << 8;
1336
1337     METAFILE_WriteRecords(metafile);
1338     return Ok;
1339 }
1340
1341 GpStatus METAFILE_SetPageTransform(GpMetafile* metafile, GpUnit unit, REAL scale)
1342 {
1343     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1344     {
1345         EmfPlusSetPageTransform *record;
1346         GpStatus stat;
1347
1348         stat = METAFILE_AllocateRecord(metafile,
1349             sizeof(EmfPlusSetPageTransform),
1350             (void**)&record);
1351         if (stat != Ok)
1352             return stat;
1353
1354         record->Header.Type = EmfPlusRecordTypeSetPageTransform;
1355         record->Header.Flags = unit;
1356         record->PageScale = scale;
1357
1358         METAFILE_WriteRecords(metafile);
1359     }
1360
1361     return Ok;
1362 }
1363
1364 GpStatus METAFILE_SetWorldTransform(GpMetafile* metafile, GDIPCONST GpMatrix* transform)
1365 {
1366     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1367     {
1368         EmfPlusSetWorldTransform *record;
1369         GpStatus stat;
1370
1371         stat = METAFILE_AllocateRecord(metafile,
1372             sizeof(EmfPlusSetWorldTransform),
1373             (void**)&record);
1374         if (stat != Ok)
1375             return stat;
1376
1377         record->Header.Type = EmfPlusRecordTypeSetWorldTransform;
1378         record->Header.Flags = 0;
1379         memcpy(record->MatrixData, transform->matrix, sizeof(record->MatrixData));
1380
1381         METAFILE_WriteRecords(metafile);
1382     }
1383
1384     return Ok;
1385 }
1386
1387 GpStatus METAFILE_ScaleWorldTransform(GpMetafile* metafile, REAL sx, REAL sy, MatrixOrder order)
1388 {
1389     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1390     {
1391         EmfPlusScaleWorldTransform *record;
1392         GpStatus stat;
1393
1394         stat = METAFILE_AllocateRecord(metafile,
1395             sizeof(EmfPlusScaleWorldTransform),
1396             (void**)&record);
1397         if (stat != Ok)
1398             return stat;
1399
1400         record->Header.Type = EmfPlusRecordTypeScaleWorldTransform;
1401         record->Header.Flags = (order == MatrixOrderAppend ? 0x2000 : 0);
1402         record->Sx = sx;
1403         record->Sy = sy;
1404
1405         METAFILE_WriteRecords(metafile);
1406     }
1407
1408     return Ok;
1409 }
1410
1411 GpStatus METAFILE_MultiplyWorldTransform(GpMetafile* metafile, GDIPCONST GpMatrix* matrix, MatrixOrder order)
1412 {
1413     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1414     {
1415         EmfPlusMultiplyWorldTransform *record;
1416         GpStatus stat;
1417
1418         stat = METAFILE_AllocateRecord(metafile,
1419             sizeof(EmfPlusMultiplyWorldTransform),
1420             (void**)&record);
1421         if (stat != Ok)
1422             return stat;
1423
1424         record->Header.Type = EmfPlusRecordTypeMultiplyWorldTransform;
1425         record->Header.Flags = (order == MatrixOrderAppend ? 0x2000 : 0);
1426         memcpy(record->MatrixData, matrix->matrix, sizeof(record->MatrixData));
1427
1428         METAFILE_WriteRecords(metafile);
1429     }
1430
1431     return Ok;
1432 }
1433
1434 GpStatus METAFILE_RotateWorldTransform(GpMetafile* metafile, REAL angle, MatrixOrder order)
1435 {
1436     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1437     {
1438         EmfPlusRotateWorldTransform *record;
1439         GpStatus stat;
1440
1441         stat = METAFILE_AllocateRecord(metafile,
1442             sizeof(EmfPlusRotateWorldTransform),
1443             (void**)&record);
1444         if (stat != Ok)
1445             return stat;
1446
1447         record->Header.Type = EmfPlusRecordTypeRotateWorldTransform;
1448         record->Header.Flags = (order == MatrixOrderAppend ? 0x2000 : 0);
1449         record->Angle = angle;
1450
1451         METAFILE_WriteRecords(metafile);
1452     }
1453
1454     return Ok;
1455 }
1456
1457 GpStatus METAFILE_TranslateWorldTransform(GpMetafile* metafile, REAL dx, REAL dy, MatrixOrder order)
1458 {
1459     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1460     {
1461         EmfPlusTranslateWorldTransform *record;
1462         GpStatus stat;
1463
1464         stat = METAFILE_AllocateRecord(metafile,
1465             sizeof(EmfPlusTranslateWorldTransform),
1466             (void**)&record);
1467         if (stat != Ok)
1468             return stat;
1469
1470         record->Header.Type = EmfPlusRecordTypeTranslateWorldTransform;
1471         record->Header.Flags = (order == MatrixOrderAppend ? 0x2000 : 0);
1472         record->dx = dx;
1473         record->dy = dy;
1474
1475         METAFILE_WriteRecords(metafile);
1476     }
1477
1478     return Ok;
1479 }
1480
1481 GpStatus METAFILE_ResetWorldTransform(GpMetafile* metafile)
1482 {
1483     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1484     {
1485         EmfPlusRecordHeader *record;
1486         GpStatus stat;
1487
1488         stat = METAFILE_AllocateRecord(metafile,
1489             sizeof(EmfPlusRecordHeader),
1490             (void**)&record);
1491         if (stat != Ok)
1492             return stat;
1493
1494         record->Type = EmfPlusRecordTypeResetWorldTransform;
1495         record->Flags = 0;
1496
1497         METAFILE_WriteRecords(metafile);
1498     }
1499
1500     return Ok;
1501 }
1502
1503 GpStatus METAFILE_BeginContainer(GpMetafile* metafile, GDIPCONST GpRectF *dstrect,
1504     GDIPCONST GpRectF *srcrect, GpUnit unit, DWORD StackIndex)
1505 {
1506     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1507     {
1508         EmfPlusBeginContainer *record;
1509         GpStatus stat;
1510
1511         stat = METAFILE_AllocateRecord(metafile, sizeof(*record), (void**)&record);
1512         if (stat != Ok)
1513             return stat;
1514
1515         record->Header.Type = EmfPlusRecordTypeBeginContainer;
1516         record->Header.Flags = unit & 0xff;
1517         record->DestRect = *dstrect;
1518         record->SrcRect = *srcrect;
1519         record->StackIndex = StackIndex;
1520
1521         METAFILE_WriteRecords(metafile);
1522     }
1523
1524     return Ok;
1525 }
1526
1527 GpStatus METAFILE_BeginContainerNoParams(GpMetafile* metafile, DWORD StackIndex)
1528 {
1529     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1530     {
1531         EmfPlusContainerRecord *record;
1532         GpStatus stat;
1533
1534         stat = METAFILE_AllocateRecord(metafile,
1535             sizeof(EmfPlusContainerRecord),
1536             (void**)&record);
1537         if (stat != Ok)
1538             return stat;
1539
1540         record->Header.Type = EmfPlusRecordTypeBeginContainerNoParams;
1541         record->Header.Flags = 0;
1542         record->StackIndex = StackIndex;
1543
1544         METAFILE_WriteRecords(metafile);
1545     }
1546
1547     return Ok;
1548 }
1549
1550 GpStatus METAFILE_EndContainer(GpMetafile* metafile, DWORD StackIndex)
1551 {
1552     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1553     {
1554         EmfPlusContainerRecord *record;
1555         GpStatus stat;
1556
1557         stat = METAFILE_AllocateRecord(metafile,
1558             sizeof(EmfPlusContainerRecord),
1559             (void**)&record);
1560         if (stat != Ok)
1561             return stat;
1562
1563         record->Header.Type = EmfPlusRecordTypeEndContainer;
1564         record->Header.Flags = 0;
1565         record->StackIndex = StackIndex;
1566
1567         METAFILE_WriteRecords(metafile);
1568     }
1569
1570     return Ok;
1571 }
1572
1573 GpStatus METAFILE_SaveGraphics(GpMetafile* metafile, DWORD StackIndex)
1574 {
1575     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1576     {
1577         EmfPlusContainerRecord *record;
1578         GpStatus stat;
1579
1580         stat = METAFILE_AllocateRecord(metafile,
1581             sizeof(EmfPlusContainerRecord),
1582             (void**)&record);
1583         if (stat != Ok)
1584             return stat;
1585
1586         record->Header.Type = EmfPlusRecordTypeSave;
1587         record->Header.Flags = 0;
1588         record->StackIndex = StackIndex;
1589
1590         METAFILE_WriteRecords(metafile);
1591     }
1592
1593     return Ok;
1594 }
1595
1596 GpStatus METAFILE_RestoreGraphics(GpMetafile* metafile, DWORD StackIndex)
1597 {
1598     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
1599     {
1600         EmfPlusContainerRecord *record;
1601         GpStatus stat;
1602
1603         stat = METAFILE_AllocateRecord(metafile,
1604             sizeof(EmfPlusContainerRecord),
1605             (void**)&record);
1606         if (stat != Ok)
1607             return stat;
1608
1609         record->Header.Type = EmfPlusRecordTypeRestore;
1610         record->Header.Flags = 0;
1611         record->StackIndex = StackIndex;
1612
1613         METAFILE_WriteRecords(metafile);
1614     }
1615
1616     return Ok;
1617 }
1618
1619 GpStatus METAFILE_ReleaseDC(GpMetafile* metafile, HDC hdc)
1620 {
1621     if (hdc != metafile->record_dc)
1622         return InvalidParameter;
1623
1624     return Ok;
1625 }
1626
1627 GpStatus METAFILE_GraphicsDeleted(GpMetafile* metafile)
1628 {
1629     GpStatus stat;
1630
1631     stat = METAFILE_WriteEndOfFile(metafile);
1632     metafile->record_graphics = NULL;
1633
1634     metafile->hemf = CloseEnhMetaFile(metafile->record_dc);
1635     metafile->record_dc = NULL;
1636
1637     heap_free(metafile->comment_data);
1638     metafile->comment_data = NULL;
1639     metafile->comment_data_size = 0;
1640
1641     if (stat == Ok)
1642     {
1643         MetafileHeader header;
1644
1645         stat = GdipGetMetafileHeaderFromEmf(metafile->hemf, &header);
1646         if (stat == Ok && metafile->auto_frame &&
1647             metafile->auto_frame_max.X >= metafile->auto_frame_min.X)
1648         {
1649             RECTL bounds_rc, gdi_bounds_rc;
1650             REAL x_scale = 2540.0 / header.DpiX;
1651             REAL y_scale = 2540.0 / header.DpiY;
1652             BYTE* buffer;
1653             UINT buffer_size;
1654
1655             bounds_rc.left = floorf(metafile->auto_frame_min.X * x_scale);
1656             bounds_rc.top = floorf(metafile->auto_frame_min.Y * y_scale);
1657             bounds_rc.right = ceilf(metafile->auto_frame_max.X * x_scale);
1658             bounds_rc.bottom = ceilf(metafile->auto_frame_max.Y * y_scale);
1659
1660             gdi_bounds_rc = header.u.EmfHeader.rclBounds;
1661             if (gdi_bounds_rc.right > gdi_bounds_rc.left && gdi_bounds_rc.bottom > gdi_bounds_rc.top)
1662             {
1663                 bounds_rc.left = min(bounds_rc.left, gdi_bounds_rc.left);
1664                 bounds_rc.top = min(bounds_rc.top, gdi_bounds_rc.top);
1665                 bounds_rc.right = max(bounds_rc.right, gdi_bounds_rc.right);
1666                 bounds_rc.bottom = max(bounds_rc.bottom, gdi_bounds_rc.bottom);
1667             }
1668
1669             buffer_size = GetEnhMetaFileBits(metafile->hemf, 0, NULL);
1670             buffer = heap_alloc(buffer_size);
1671             if (buffer)
1672             {
1673                 HENHMETAFILE new_hemf;
1674
1675                 GetEnhMetaFileBits(metafile->hemf, buffer_size, buffer);
1676
1677                 ((ENHMETAHEADER*)buffer)->rclFrame = bounds_rc;
1678
1679                 new_hemf = SetEnhMetaFileBits(buffer_size, buffer);
1680
1681                 if (new_hemf)
1682                 {
1683                     DeleteEnhMetaFile(metafile->hemf);
1684                     metafile->hemf = new_hemf;
1685                 }
1686                 else
1687                     stat = OutOfMemory;
1688
1689                 heap_free(buffer);
1690             }
1691             else
1692                 stat = OutOfMemory;
1693
1694             if (stat == Ok)
1695                 stat = GdipGetMetafileHeaderFromEmf(metafile->hemf, &header);
1696         }
1697         if (stat == Ok)
1698         {
1699             metafile->bounds.X = header.X;
1700             metafile->bounds.Y = header.Y;
1701             metafile->bounds.Width = header.Width;
1702             metafile->bounds.Height = header.Height;
1703         }
1704     }
1705
1706     if (stat == Ok && metafile->record_stream)
1707     {
1708         BYTE *buffer;
1709         UINT buffer_size;
1710
1711         buffer_size = GetEnhMetaFileBits(metafile->hemf, 0, NULL);
1712
1713         buffer = heap_alloc(buffer_size);
1714         if (buffer)
1715         {
1716             HRESULT hr;
1717
1718             GetEnhMetaFileBits(metafile->hemf, buffer_size, buffer);
1719
1720             hr = IStream_Write(metafile->record_stream, buffer, buffer_size, NULL);
1721
1722             if (FAILED(hr))
1723                 stat = hresult_to_status(hr);
1724
1725             heap_free(buffer);
1726         }
1727         else
1728             stat = OutOfMemory;
1729     }
1730
1731     if (metafile->record_stream)
1732     {
1733         IStream_Release(metafile->record_stream);
1734         metafile->record_stream = NULL;
1735     }
1736
1737     return stat;
1738 }
1739
1740 GpStatus WINGDIPAPI GdipGetHemfFromMetafile(GpMetafile *metafile, HENHMETAFILE *hEmf)
1741 {
1742     TRACE("(%p,%p)\n", metafile, hEmf);
1743
1744     if (!metafile || !hEmf || !metafile->hemf)
1745         return InvalidParameter;
1746
1747     *hEmf = metafile->hemf;
1748     metafile->hemf = NULL;
1749
1750     return Ok;
1751 }
1752
1753 static GpStatus METAFILE_PlaybackGetDC(GpMetafile *metafile)
1754 {
1755     GpStatus stat = Ok;
1756
1757     stat = GdipGetDC(metafile->playback_graphics, &metafile->playback_dc);
1758
1759     return stat;
1760 }
1761
1762 static void METAFILE_PlaybackReleaseDC(GpMetafile *metafile)
1763 {
1764     if (metafile->playback_dc)
1765     {
1766         GdipReleaseDC(metafile->playback_graphics, metafile->playback_dc);
1767         metafile->playback_dc = NULL;
1768     }
1769 }
1770
1771 static GpStatus METAFILE_PlaybackUpdateClip(GpMetafile *metafile)
1772 {
1773     GpStatus stat;
1774     stat = GdipCombineRegionRegion(metafile->playback_graphics->clip, metafile->base_clip, CombineModeReplace);
1775     if (stat == Ok)
1776         stat = GdipCombineRegionRegion(metafile->playback_graphics->clip, metafile->clip, CombineModeIntersect);
1777     return stat;
1778 }
1779
1780 static GpStatus METAFILE_PlaybackUpdateWorldTransform(GpMetafile *metafile)
1781 {
1782     GpMatrix *real_transform;
1783     GpStatus stat;
1784
1785     stat = GdipCreateMatrix3(&metafile->src_rect, metafile->playback_points, &real_transform);
1786
1787     if (stat == Ok)
1788     {
1789         REAL scale = units_to_pixels(1.0, metafile->page_unit, 96.0);
1790
1791         if (metafile->page_unit != UnitDisplay)
1792             scale *= metafile->page_scale;
1793
1794         stat = GdipScaleMatrix(real_transform, scale, scale, MatrixOrderPrepend);
1795
1796         if (stat == Ok)
1797             stat = GdipMultiplyMatrix(real_transform, metafile->world_transform, MatrixOrderPrepend);
1798
1799         if (stat == Ok)
1800             stat = GdipSetWorldTransform(metafile->playback_graphics, real_transform);
1801
1802         GdipDeleteMatrix(real_transform);
1803     }
1804
1805     return stat;
1806 }
1807
1808 static void metafile_set_object_table_entry(GpMetafile *metafile, BYTE id, BYTE type, void *object)
1809 {
1810     metafile_free_object_table_entry(metafile, id);
1811     metafile->objtable[id].type = type;
1812     metafile->objtable[id].u.object = object;
1813 }
1814
1815 static GpStatus metafile_deserialize_image(const BYTE *record_data, UINT data_size, GpImage **image)
1816 {
1817     EmfPlusImage *data = (EmfPlusImage *)record_data;
1818     GpStatus status;
1819
1820     *image = NULL;
1821
1822     if (data_size < FIELD_OFFSET(EmfPlusImage, ImageData))
1823         return InvalidParameter;
1824     data_size -= FIELD_OFFSET(EmfPlusImage, ImageData);
1825
1826     switch (data->Type)
1827     {
1828     case ImageDataTypeBitmap:
1829     {
1830         EmfPlusBitmap *bitmapdata = &data->ImageData.bitmap;
1831
1832         if (data_size <= FIELD_OFFSET(EmfPlusBitmap, BitmapData))
1833             return InvalidParameter;
1834         data_size -= FIELD_OFFSET(EmfPlusBitmap, BitmapData);
1835
1836         switch (bitmapdata->Type)
1837         {
1838         case BitmapDataTypePixel:
1839         {
1840             ColorPalette *palette;
1841             BYTE *scan0;
1842
1843             if (bitmapdata->PixelFormat & PixelFormatIndexed)
1844             {
1845                 EmfPlusPalette *palette_obj = (EmfPlusPalette *)bitmapdata->BitmapData;
1846                 UINT palette_size = FIELD_OFFSET(EmfPlusPalette, PaletteEntries);
1847
1848                 if (data_size <= palette_size)
1849                     return InvalidParameter;
1850                 palette_size += palette_obj->PaletteCount * sizeof(EmfPlusARGB);
1851
1852                 if (data_size < palette_size)
1853                     return InvalidParameter;
1854                 data_size -= palette_size;
1855
1856                 palette = (ColorPalette *)bitmapdata->BitmapData;
1857                 scan0 = (BYTE *)bitmapdata->BitmapData + palette_size;
1858             }
1859             else
1860             {
1861                 palette = NULL;
1862                 scan0 = bitmapdata->BitmapData;
1863             }
1864
1865             if (data_size < bitmapdata->Height * bitmapdata->Stride)
1866                 return InvalidParameter;
1867
1868             status = GdipCreateBitmapFromScan0(bitmapdata->Width, bitmapdata->Height, bitmapdata->Stride,
1869                 bitmapdata->PixelFormat, scan0, (GpBitmap **)image);
1870             if (status == Ok && palette)
1871             {
1872                 status = GdipSetImagePalette(*image, palette);
1873                 if (status != Ok)
1874                 {
1875                     GdipDisposeImage(*image);
1876                     *image = NULL;
1877                 }
1878             }
1879             break;
1880         }
1881         case BitmapDataTypeCompressed:
1882         {
1883             IWICImagingFactory *factory;
1884             IWICStream *stream;
1885             HRESULT hr;
1886
1887             if (WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory) != S_OK)
1888                 return GenericError;
1889
1890             hr = IWICImagingFactory_CreateStream(factory, &stream);
1891             IWICImagingFactory_Release(factory);
1892             if (hr != S_OK)
1893                 return GenericError;
1894
1895             if (IWICStream_InitializeFromMemory(stream, bitmapdata->BitmapData, data_size) == S_OK)
1896                 status = GdipCreateBitmapFromStream((IStream *)stream, (GpBitmap **)image);
1897             else
1898                 status = GenericError;
1899
1900             IWICStream_Release(stream);
1901             break;
1902         }
1903         default:
1904             WARN("Invalid bitmap type %d.\n", bitmapdata->Type);
1905             return InvalidParameter;
1906         }
1907         break;
1908     }
1909     case ImageDataTypeMetafile:
1910     {
1911         EmfPlusMetafile *metafiledata = &data->ImageData.metafile;
1912
1913         if (data_size <= FIELD_OFFSET(EmfPlusMetafile, MetafileData))
1914             return InvalidParameter;
1915         data_size -= FIELD_OFFSET(EmfPlusMetafile, MetafileData);
1916
1917         switch (metafiledata->Type) {
1918         case MetafileTypeEmf:
1919         case MetafileTypeEmfPlusOnly:
1920         case MetafileTypeEmfPlusDual:
1921         {
1922             HENHMETAFILE hemf;
1923
1924             hemf = SetEnhMetaFileBits(data_size, metafiledata->MetafileData);
1925
1926             if (!hemf)
1927                 return GenericError;
1928
1929             status = GdipCreateMetafileFromEmf(hemf, TRUE, (GpMetafile**)image);
1930
1931             if (status != Ok)
1932                 DeleteEnhMetaFile(hemf);
1933
1934             break;
1935         }
1936         default:
1937             FIXME("metafile type %d not supported.\n", metafiledata->Type);
1938             return NotImplemented;
1939         }
1940         break;
1941     }
1942     default:
1943         FIXME("image type %d not supported.\n", data->Type);
1944         return NotImplemented;
1945     }
1946
1947     return status;
1948 }
1949
1950 static GpStatus metafile_deserialize_path(const BYTE *record_data, UINT data_size, GpPath **path)
1951 {
1952     EmfPlusPath *data = (EmfPlusPath *)record_data;
1953     GpStatus status;
1954     BYTE *types;
1955     UINT size;
1956     DWORD i;
1957
1958     *path = NULL;
1959
1960     if (data_size <= FIELD_OFFSET(EmfPlusPath, data))
1961         return InvalidParameter;
1962     data_size -= FIELD_OFFSET(EmfPlusPath, data);
1963
1964     if (data->PathPointFlags & 0x800) /* R */
1965     {
1966         FIXME("RLE encoded path data is not supported.\n");
1967         return NotImplemented;
1968     }
1969     else
1970     {
1971         if (data->PathPointFlags & 0x4000) /* C */
1972             size = sizeof(EmfPlusPoint);
1973         else
1974             size = sizeof(EmfPlusPointF);
1975         size += sizeof(BYTE); /* EmfPlusPathPointType */
1976         size *= data->PathPointCount;
1977     }
1978
1979     if (data_size < size)
1980         return InvalidParameter;
1981
1982     status = GdipCreatePath(FillModeAlternate, path);
1983     if (status != Ok)
1984         return status;
1985
1986     (*path)->pathdata.Count = data->PathPointCount;
1987     (*path)->pathdata.Points = GdipAlloc(data->PathPointCount * sizeof(*(*path)->pathdata.Points));
1988     (*path)->pathdata.Types = GdipAlloc(data->PathPointCount * sizeof(*(*path)->pathdata.Types));
1989     (*path)->datalen = (*path)->pathdata.Count;
1990
1991     if (!(*path)->pathdata.Points || !(*path)->pathdata.Types)
1992     {
1993         GdipDeletePath(*path);
1994         return OutOfMemory;
1995     }
1996
1997     if (data->PathPointFlags & 0x4000) /* C */
1998     {
1999         EmfPlusPoint *points = (EmfPlusPoint *)data->data;
2000         for (i = 0; i < data->PathPointCount; i++)
2001         {
2002             (*path)->pathdata.Points[i].X = points[i].X;
2003             (*path)->pathdata.Points[i].Y = points[i].Y;
2004         }
2005         types = (BYTE *)(points + i);
2006     }
2007     else
2008     {
2009         EmfPlusPointF *points = (EmfPlusPointF *)data->data;
2010         memcpy((*path)->pathdata.Points, points, sizeof(*points) * data->PathPointCount);
2011         types = (BYTE *)(points + data->PathPointCount);
2012     }
2013
2014     memcpy((*path)->pathdata.Types, types, sizeof(*types) * data->PathPointCount);
2015
2016     return Ok;
2017 }
2018
2019 static GpStatus metafile_read_region_node(struct memory_buffer *mbuf, GpRegion *region, region_element *node, UINT *count)
2020 {
2021     const DWORD *type;
2022     GpStatus status;
2023
2024     type = buffer_read(mbuf, sizeof(*type));
2025     if (!type) return Ok;
2026
2027     node->type = *type;
2028
2029     switch (node->type)
2030     {
2031     case CombineModeReplace:
2032     case CombineModeIntersect:
2033     case CombineModeUnion:
2034     case CombineModeXor:
2035     case CombineModeExclude:
2036     case CombineModeComplement:
2037     {
2038         region_element *left, *right;
2039
2040         left = heap_alloc_zero(sizeof(*left));
2041         if (!left)
2042             return OutOfMemory;
2043
2044         right = heap_alloc_zero(sizeof(*right));
2045         if (!right)
2046         {
2047             heap_free(left);
2048             return OutOfMemory;
2049         }
2050
2051         status = metafile_read_region_node(mbuf, region, left, count);
2052         if (status == Ok)
2053         {
2054             status = metafile_read_region_node(mbuf, region, right, count);
2055             if (status == Ok)
2056             {
2057                 node->elementdata.combine.left = left;
2058                 node->elementdata.combine.right = right;
2059                 region->num_children += 2;
2060                 return Ok;
2061             }
2062         }
2063
2064         heap_free(left);
2065         heap_free(right);
2066         return status;
2067     }
2068     case RegionDataRect:
2069     {
2070         const EmfPlusRectF *rect;
2071
2072         rect = buffer_read(mbuf, sizeof(*rect));
2073         if (!rect)
2074             return InvalidParameter;
2075
2076         memcpy(&node->elementdata.rect, rect, sizeof(*rect));
2077         *count += 1;
2078         return Ok;
2079     }
2080     case RegionDataPath:
2081     {
2082         const BYTE *path_data;
2083         const UINT *data_size;
2084         GpPath *path;
2085
2086         data_size = buffer_read(mbuf, FIELD_OFFSET(EmfPlusRegionNodePath, RegionNodePath));
2087         if (!data_size)
2088             return InvalidParameter;
2089
2090         path_data = buffer_read(mbuf, *data_size);
2091         if (!path_data)
2092             return InvalidParameter;
2093
2094         status = metafile_deserialize_path(path_data, *data_size, &path);
2095         if (status == Ok)
2096         {
2097             node->elementdata.path = path;
2098             *count += 1;
2099         }
2100         return Ok;
2101     }
2102     case RegionDataEmptyRect:
2103     case RegionDataInfiniteRect:
2104         *count += 1;
2105         return Ok;
2106     default:
2107         FIXME("element type %#x is not supported\n", *type);
2108         break;
2109     }
2110
2111     return InvalidParameter;
2112 }
2113
2114 static GpStatus metafile_deserialize_region(const BYTE *record_data, UINT data_size, GpRegion **region)
2115 {
2116     struct memory_buffer mbuf;
2117     GpStatus status;
2118     UINT count;
2119
2120     *region = NULL;
2121
2122     init_memory_buffer(&mbuf, record_data, data_size);
2123
2124     if (!buffer_read(&mbuf, FIELD_OFFSET(EmfPlusRegion, RegionNode)))
2125         return InvalidParameter;
2126
2127     status = GdipCreateRegion(region);
2128     if (status != Ok)
2129         return status;
2130
2131     count = 0;
2132     status = metafile_read_region_node(&mbuf, *region, &(*region)->node, &count);
2133     if (status == Ok && !count)
2134         status = InvalidParameter;
2135
2136     if (status != Ok)
2137     {
2138         GdipDeleteRegion(*region);
2139         *region = NULL;
2140     }
2141
2142     return status;
2143 }
2144
2145 static GpStatus metafile_deserialize_brush(const BYTE *record_data, UINT data_size, GpBrush **brush)
2146 {
2147     static const UINT header_size = FIELD_OFFSET(EmfPlusBrush, BrushData);
2148     EmfPlusBrush *data = (EmfPlusBrush *)record_data;
2149     EmfPlusTransformMatrix *transform = NULL;
2150     DWORD brushflags;
2151     GpStatus status;
2152     UINT offset;
2153
2154     *brush = NULL;
2155
2156     if (data_size < header_size)
2157         return InvalidParameter;
2158
2159     switch (data->Type)
2160     {
2161     case BrushTypeSolidColor:
2162         if (data_size != header_size + sizeof(EmfPlusSolidBrushData))
2163             return InvalidParameter;
2164
2165         status = GdipCreateSolidFill(data->BrushData.solid.SolidColor, (GpSolidFill **)brush);
2166         break;
2167     case BrushTypeHatchFill:
2168         if (data_size != header_size + sizeof(EmfPlusHatchBrushData))
2169             return InvalidParameter;
2170
2171         status = GdipCreateHatchBrush(data->BrushData.hatch.HatchStyle, data->BrushData.hatch.ForeColor,
2172             data->BrushData.hatch.BackColor, (GpHatch **)brush);
2173         break;
2174     case BrushTypeTextureFill:
2175     {
2176         GpImage *image;
2177
2178         offset = header_size + FIELD_OFFSET(EmfPlusTextureBrushData, OptionalData);
2179         if (data_size <= offset)
2180             return InvalidParameter;
2181
2182         brushflags = data->BrushData.texture.BrushDataFlags;
2183         if (brushflags & BrushDataTransform)
2184         {
2185             if (data_size <= offset + sizeof(EmfPlusTransformMatrix))
2186                 return InvalidParameter;
2187             transform = (EmfPlusTransformMatrix *)(record_data + offset);
2188             offset += sizeof(EmfPlusTransformMatrix);
2189         }
2190
2191         status = metafile_deserialize_image(record_data + offset, data_size - offset, &image);
2192         if (status != Ok)
2193             return status;
2194
2195         status = GdipCreateTexture(image, data->BrushData.texture.WrapMode, (GpTexture **)brush);
2196         if (status == Ok && transform && !(brushflags & BrushDataDoNotTransform))
2197             GdipSetTextureTransform((GpTexture *)*brush, (const GpMatrix *)transform);
2198
2199         GdipDisposeImage(image);
2200         break;
2201     }
2202     case BrushTypeLinearGradient:
2203     {
2204         GpLineGradient *gradient = NULL;
2205         GpRectF rect;
2206         UINT position_count = 0;
2207
2208         offset = header_size + FIELD_OFFSET(EmfPlusLinearGradientBrushData, OptionalData);
2209         if (data_size < offset)
2210             return InvalidParameter;
2211
2212         brushflags = data->BrushData.lineargradient.BrushDataFlags;
2213         if ((brushflags & BrushDataPresetColors) && (brushflags & (BrushDataBlendFactorsH | BrushDataBlendFactorsV)))
2214             return InvalidParameter;
2215
2216         if (brushflags & BrushDataTransform)
2217         {
2218             if (data_size < offset + sizeof(EmfPlusTransformMatrix))
2219                 return InvalidParameter;
2220             transform = (EmfPlusTransformMatrix *)(record_data + offset);
2221             offset += sizeof(EmfPlusTransformMatrix);
2222         }
2223
2224         if (brushflags & (BrushDataPresetColors | BrushDataBlendFactorsH | BrushDataBlendFactorsV))
2225         {
2226             if (data_size <= offset + sizeof(DWORD)) /* Number of factors/preset colors. */
2227                 return InvalidParameter;
2228             position_count = *(DWORD *)(record_data + offset);
2229             offset += sizeof(DWORD);
2230         }
2231
2232         if (brushflags & BrushDataPresetColors)
2233         {
2234             if (data_size != offset + position_count * (sizeof(float) + sizeof(EmfPlusARGB)))
2235                 return InvalidParameter;
2236         }
2237         else if (brushflags & BrushDataBlendFactorsH)
2238         {
2239             if (data_size != offset + position_count * 2 * sizeof(float))
2240                 return InvalidParameter;
2241         }
2242
2243         rect.X = data->BrushData.lineargradient.RectF.X;
2244         rect.Y = data->BrushData.lineargradient.RectF.Y;
2245         rect.Width = data->BrushData.lineargradient.RectF.Width;
2246         rect.Height = data->BrushData.lineargradient.RectF.Height;
2247
2248         status = GdipCreateLineBrushFromRect(&rect, data->BrushData.lineargradient.StartColor,
2249             data->BrushData.lineargradient.EndColor, LinearGradientModeHorizontal,
2250             data->BrushData.lineargradient.WrapMode, &gradient);
2251         if (status == Ok)
2252         {
2253             if (transform)
2254                 status = GdipSetLineTransform(gradient, (const GpMatrix *)transform);
2255
2256             if (status == Ok)
2257             {
2258                 if (brushflags & BrushDataPresetColors)
2259                     status = GdipSetLinePresetBlend(gradient, (ARGB *)(record_data + offset +
2260                         position_count * sizeof(REAL)), (REAL *)(record_data + offset), position_count);
2261                 else if (brushflags & BrushDataBlendFactorsH)
2262                     status = GdipSetLineBlend(gradient, (REAL *)(record_data + offset + position_count * sizeof(REAL)),
2263                         (REAL *)(record_data + offset), position_count);
2264
2265                 if (brushflags & BrushDataIsGammaCorrected)
2266                     FIXME("BrushDataIsGammaCorrected is not handled.\n");
2267             }
2268         }
2269
2270         if (status == Ok)
2271             *brush = (GpBrush *)gradient;
2272         else
2273             GdipDeleteBrush((GpBrush *)gradient);
2274
2275         break;
2276     }
2277     default:
2278         FIXME("brush type %u is not supported.\n", data->Type);
2279         return NotImplemented;
2280     }
2281
2282     return status;
2283 }
2284
2285 static GpStatus metafile_get_pen_brush_data_offset(EmfPlusPen *data, UINT data_size, DWORD *ret)
2286 {
2287     EmfPlusPenData *pendata = (EmfPlusPenData *)data->data;
2288     DWORD offset = FIELD_OFFSET(EmfPlusPen, data);
2289
2290     if (data_size <= offset)
2291         return InvalidParameter;
2292
2293     offset += FIELD_OFFSET(EmfPlusPenData, OptionalData);
2294     if (data_size <= offset)
2295         return InvalidParameter;
2296
2297     if (pendata->PenDataFlags & PenDataTransform)
2298         offset += sizeof(EmfPlusTransformMatrix);
2299
2300     if (pendata->PenDataFlags & PenDataStartCap)
2301         offset += sizeof(DWORD);
2302
2303     if (pendata->PenDataFlags & PenDataEndCap)
2304         offset += sizeof(DWORD);
2305
2306     if (pendata->PenDataFlags & PenDataJoin)
2307         offset += sizeof(DWORD);
2308
2309     if (pendata->PenDataFlags & PenDataMiterLimit)
2310         offset += sizeof(REAL);
2311
2312     if (pendata->PenDataFlags & PenDataLineStyle)
2313         offset += sizeof(DWORD);
2314
2315     if (pendata->PenDataFlags & PenDataDashedLineCap)
2316         offset += sizeof(DWORD);
2317
2318     if (pendata->PenDataFlags & PenDataDashedLineOffset)
2319         offset += sizeof(REAL);
2320
2321     if (pendata->PenDataFlags & PenDataDashedLine)
2322     {
2323         EmfPlusDashedLineData *dashedline = (EmfPlusDashedLineData *)((BYTE *)data + offset);
2324
2325         offset += FIELD_OFFSET(EmfPlusDashedLineData, data);
2326         if (data_size <= offset)
2327             return InvalidParameter;
2328
2329         offset += dashedline->DashedLineDataSize * sizeof(float);
2330     }
2331
2332     if (pendata->PenDataFlags & PenDataNonCenter)
2333         offset += sizeof(DWORD);
2334
2335     if (pendata->PenDataFlags & PenDataCompoundLine)
2336     {
2337         EmfPlusCompoundLineData *compoundline = (EmfPlusCompoundLineData *)((BYTE *)data + offset);
2338
2339         offset += FIELD_OFFSET(EmfPlusCompoundLineData, data);
2340         if (data_size <= offset)
2341             return InvalidParameter;
2342
2343         offset += compoundline->CompoundLineDataSize * sizeof(float);
2344     }
2345
2346     if (pendata->PenDataFlags & PenDataCustomStartCap)
2347     {
2348         EmfPlusCustomStartCapData *startcap = (EmfPlusCustomStartCapData *)((BYTE *)data + offset);
2349
2350         offset += FIELD_OFFSET(EmfPlusCustomStartCapData, data);
2351         if (data_size <= offset)
2352             return InvalidParameter;
2353
2354         offset += startcap->CustomStartCapSize;
2355     }
2356
2357     if (pendata->PenDataFlags & PenDataCustomEndCap)
2358     {
2359         EmfPlusCustomEndCapData *endcap = (EmfPlusCustomEndCapData *)((BYTE *)data + offset);
2360
2361         offset += FIELD_OFFSET(EmfPlusCustomEndCapData, data);
2362         if (data_size <= offset)
2363             return InvalidParameter;
2364
2365         offset += endcap->CustomEndCapSize;
2366     }
2367
2368     *ret = offset;
2369     return Ok;
2370 }
2371
2372 static GpStatus METAFILE_PlaybackObject(GpMetafile *metafile, UINT flags, UINT data_size, const BYTE *record_data)
2373 {
2374     BYTE type = (flags >> 8) & 0xff;
2375     BYTE id = flags & 0xff;
2376     void *object = NULL;
2377     GpStatus status;
2378
2379     if (type > ObjectTypeMax || id >= EmfPlusObjectTableSize)
2380         return InvalidParameter;
2381
2382     switch (type)
2383     {
2384     case ObjectTypeBrush:
2385         status = metafile_deserialize_brush(record_data, data_size, (GpBrush **)&object);
2386         break;
2387     case ObjectTypePen:
2388     {
2389         EmfPlusPen *data = (EmfPlusPen *)record_data;
2390         EmfPlusPenData *pendata = (EmfPlusPenData *)data->data;
2391         GpBrush *brush;
2392         DWORD offset;
2393         GpPen *pen;
2394
2395         status = metafile_get_pen_brush_data_offset(data, data_size, &offset);
2396         if (status != Ok)
2397             return status;
2398
2399         status = metafile_deserialize_brush(record_data + offset, data_size - offset, &brush);
2400         if (status != Ok)
2401             return status;
2402
2403         status = GdipCreatePen2(brush, pendata->PenWidth, pendata->PenUnit, &pen);
2404         GdipDeleteBrush(brush);
2405         if (status != Ok)
2406             return status;
2407
2408         offset = FIELD_OFFSET(EmfPlusPenData, OptionalData);
2409
2410         if (pendata->PenDataFlags & PenDataTransform)
2411         {
2412             FIXME("PenDataTransform is not supported.\n");
2413             offset += sizeof(EmfPlusTransformMatrix);
2414         }
2415
2416         if (pendata->PenDataFlags & PenDataStartCap)
2417         {
2418             if ((status = GdipSetPenStartCap(pen, *(DWORD *)((BYTE *)pendata + offset))) != Ok)
2419                 goto penfailed;
2420             offset += sizeof(DWORD);
2421         }
2422
2423         if (pendata->PenDataFlags & PenDataEndCap)
2424         {
2425             if ((status = GdipSetPenEndCap(pen, *(DWORD *)((BYTE *)pendata + offset))) != Ok)
2426                 goto penfailed;
2427             offset += sizeof(DWORD);
2428         }
2429
2430         if (pendata->PenDataFlags & PenDataJoin)
2431         {
2432             if ((status = GdipSetPenLineJoin(pen, *(DWORD *)((BYTE *)pendata + offset))) != Ok)
2433                 goto penfailed;
2434             offset += sizeof(DWORD);
2435         }
2436
2437         if (pendata->PenDataFlags & PenDataMiterLimit)
2438         {
2439             if ((status = GdipSetPenMiterLimit(pen, *(REAL *)((BYTE *)pendata + offset))) != Ok)
2440                 goto penfailed;
2441             offset += sizeof(REAL);
2442         }
2443
2444         if (pendata->PenDataFlags & PenDataLineStyle)
2445         {
2446             if ((status = GdipSetPenDashStyle(pen, *(DWORD *)((BYTE *)pendata + offset))) != Ok)
2447                 goto penfailed;
2448             offset += sizeof(DWORD);
2449         }
2450
2451         if (pendata->PenDataFlags & PenDataDashedLineCap)
2452         {
2453             FIXME("PenDataDashedLineCap is not supported.\n");
2454             offset += sizeof(DWORD);
2455         }
2456
2457         if (pendata->PenDataFlags & PenDataDashedLineOffset)
2458         {
2459             if ((status = GdipSetPenDashOffset(pen, *(REAL *)((BYTE *)pendata + offset))) != Ok)
2460                 goto penfailed;
2461             offset += sizeof(REAL);
2462         }
2463
2464         if (pendata->PenDataFlags & PenDataDashedLine)
2465         {
2466             EmfPlusDashedLineData *dashedline = (EmfPlusDashedLineData *)((BYTE *)pendata + offset);
2467             FIXME("PenDataDashedLine is not supported.\n");
2468             offset += FIELD_OFFSET(EmfPlusDashedLineData, data) + dashedline->DashedLineDataSize * sizeof(float);
2469         }
2470
2471         if (pendata->PenDataFlags & PenDataNonCenter)
2472         {
2473             FIXME("PenDataNonCenter is not supported.\n");
2474             offset += sizeof(DWORD);
2475         }
2476
2477         if (pendata->PenDataFlags & PenDataCompoundLine)
2478         {
2479             EmfPlusCompoundLineData *compoundline = (EmfPlusCompoundLineData *)((BYTE *)pendata + offset);
2480             FIXME("PenDataCompoundLine is not supported.\n");
2481             offset += FIELD_OFFSET(EmfPlusCompoundLineData, data) + compoundline->CompoundLineDataSize * sizeof(float);
2482         }
2483
2484         if (pendata->PenDataFlags & PenDataCustomStartCap)
2485         {
2486             EmfPlusCustomStartCapData *startcap = (EmfPlusCustomStartCapData *)((BYTE *)pendata + offset);
2487             FIXME("PenDataCustomStartCap is not supported.\n");
2488             offset += FIELD_OFFSET(EmfPlusCustomStartCapData, data) + startcap->CustomStartCapSize;
2489         }
2490
2491         if (pendata->PenDataFlags & PenDataCustomEndCap)
2492         {
2493             EmfPlusCustomEndCapData *endcap = (EmfPlusCustomEndCapData *)((BYTE *)pendata + offset);
2494             FIXME("PenDataCustomEndCap is not supported.\n");
2495             offset += FIELD_OFFSET(EmfPlusCustomEndCapData, data) + endcap->CustomEndCapSize;
2496         }
2497
2498         object = pen;
2499         break;
2500
2501     penfailed:
2502         GdipDeletePen(pen);
2503         return status;
2504     }
2505     case ObjectTypePath:
2506         status = metafile_deserialize_path(record_data, data_size, (GpPath **)&object);
2507         break;
2508     case ObjectTypeRegion:
2509         status = metafile_deserialize_region(record_data, data_size, (GpRegion **)&object);
2510         break;
2511     case ObjectTypeImage:
2512         status = metafile_deserialize_image(record_data, data_size, (GpImage **)&object);
2513         break;
2514     case ObjectTypeFont:
2515     {
2516         EmfPlusFont *data = (EmfPlusFont *)record_data;
2517         GpFontFamily *family;
2518         WCHAR *familyname;
2519
2520         if (data_size <= FIELD_OFFSET(EmfPlusFont, FamilyName))
2521             return InvalidParameter;
2522         data_size -= FIELD_OFFSET(EmfPlusFont, FamilyName);
2523
2524         if (data_size < data->Length * sizeof(WCHAR))
2525             return InvalidParameter;
2526
2527         if (!(familyname = GdipAlloc((data->Length + 1) * sizeof(*familyname))))
2528             return OutOfMemory;
2529
2530         memcpy(familyname, data->FamilyName, data->Length * sizeof(*familyname));
2531         familyname[data->Length] = 0;
2532
2533         status = GdipCreateFontFamilyFromName(familyname, NULL, &family);
2534         GdipFree(familyname);
2535
2536         /* If a font family cannot be created from family name, native
2537            falls back to a sans serif font. */
2538         if (status != Ok)
2539             status = GdipGetGenericFontFamilySansSerif(&family);
2540         if (status != Ok)
2541             return status;
2542
2543         status = GdipCreateFont(family, data->EmSize, data->FontStyleFlags, data->SizeUnit, (GpFont **)&object);
2544         GdipDeleteFontFamily(family);
2545         break;
2546     }
2547     case ObjectTypeImageAttributes:
2548     {
2549         EmfPlusImageAttributes *data = (EmfPlusImageAttributes *)record_data;
2550         GpImageAttributes *attributes = NULL;
2551
2552         if (data_size != sizeof(*data))
2553             return InvalidParameter;
2554
2555         if ((status = GdipCreateImageAttributes(&attributes)) != Ok)
2556             return status;
2557
2558         status = GdipSetImageAttributesWrapMode(attributes, data->WrapMode, *(DWORD *)&data->ClampColor,
2559                 !!data->ObjectClamp);
2560         if (status == Ok)
2561             object = attributes;
2562         else
2563             GdipDisposeImageAttributes(attributes);
2564         break;
2565     }
2566     default:
2567         FIXME("not implemented for object type %d.\n", type);
2568         return NotImplemented;
2569     }
2570
2571     if (status == Ok)
2572         metafile_set_object_table_entry(metafile, id, type, object);
2573
2574     return status;
2575 }
2576
2577 static GpStatus metafile_set_clip_region(GpMetafile *metafile, GpRegion *region, CombineMode mode)
2578 {
2579     GpMatrix world_to_device;
2580
2581     get_graphics_transform(metafile->playback_graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, &world_to_device);
2582
2583     GdipTransformRegion(region, &world_to_device);
2584     GdipCombineRegionRegion(metafile->clip, region, mode);
2585
2586     return METAFILE_PlaybackUpdateClip(metafile);
2587 }
2588
2589 GpStatus WINGDIPAPI GdipPlayMetafileRecord(GDIPCONST GpMetafile *metafile,
2590     EmfPlusRecordType recordType, UINT flags, UINT dataSize, GDIPCONST BYTE *data)
2591 {
2592     GpStatus stat;
2593     GpMetafile *real_metafile = (GpMetafile*)metafile;
2594
2595     TRACE("(%p,%x,%x,%d,%p)\n", metafile, recordType, flags, dataSize, data);
2596
2597     if (!metafile || (dataSize && !data) || !metafile->playback_graphics)
2598         return InvalidParameter;
2599
2600     if (recordType >= 1 && recordType <= 0x7a)
2601     {
2602         /* regular EMF record */
2603         if (metafile->playback_dc)
2604         {
2605             ENHMETARECORD *record = heap_alloc_zero(dataSize + 8);
2606
2607             if (record)
2608             {
2609                 record->iType = recordType;
2610                 record->nSize = dataSize + 8;
2611                 memcpy(record->dParm, data, dataSize);
2612
2613                 if(PlayEnhMetaFileRecord(metafile->playback_dc, metafile->handle_table,
2614                         record, metafile->handle_count) == 0)
2615                     ERR("PlayEnhMetaFileRecord failed\n");
2616
2617                 heap_free(record);
2618             }
2619             else
2620                 return OutOfMemory;
2621         }
2622     }
2623     else
2624     {
2625         EmfPlusRecordHeader *header = (EmfPlusRecordHeader*)(data)-1;
2626
2627         METAFILE_PlaybackReleaseDC((GpMetafile*)metafile);
2628
2629         switch(recordType)
2630         {
2631         case EmfPlusRecordTypeHeader:
2632         case EmfPlusRecordTypeEndOfFile:
2633             break;
2634         case EmfPlusRecordTypeGetDC:
2635             METAFILE_PlaybackGetDC((GpMetafile*)metafile);
2636             break;
2637         case EmfPlusRecordTypeClear:
2638         {
2639             EmfPlusClear *record = (EmfPlusClear*)header;
2640
2641             if (dataSize != sizeof(record->Color))
2642                 return InvalidParameter;
2643
2644             return GdipGraphicsClear(metafile->playback_graphics, record->Color);
2645         }
2646         case EmfPlusRecordTypeFillRects:
2647         {
2648             EmfPlusFillRects *record = (EmfPlusFillRects*)header;
2649             GpBrush *brush, *temp_brush=NULL;
2650             GpRectF *rects, *temp_rects=NULL;
2651
2652             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects))
2653                 return InvalidParameter;
2654
2655             if (flags & 0x4000)
2656             {
2657                 if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects) + sizeof(EmfPlusRect) * record->Count)
2658                     return InvalidParameter;
2659             }
2660             else
2661             {
2662                 if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects) + sizeof(GpRectF) * record->Count)
2663                     return InvalidParameter;
2664             }
2665
2666             if (flags & 0x8000)
2667             {
2668                 stat = GdipCreateSolidFill(record->BrushID, (GpSolidFill **)&temp_brush);
2669                 brush = temp_brush;
2670             }
2671             else
2672             {
2673                 if (record->BrushID >= EmfPlusObjectTableSize ||
2674                         real_metafile->objtable[record->BrushID].type != ObjectTypeBrush)
2675                     return InvalidParameter;
2676
2677                 brush = real_metafile->objtable[record->BrushID].u.brush;
2678                 stat = Ok;
2679             }
2680
2681             if (stat == Ok)
2682             {
2683                 if (flags & 0x4000)
2684                 {
2685                     EmfPlusRect *int_rects = (EmfPlusRect*)(record+1);
2686                     int i;
2687
2688                     rects = temp_rects = heap_alloc_zero(sizeof(GpRectF) * record->Count);
2689                     if (rects)
2690                     {
2691                         for (i=0; i<record->Count; i++)
2692                         {
2693                             rects[i].X = int_rects[i].X;
2694                             rects[i].Y = int_rects[i].Y;
2695                             rects[i].Width = int_rects[i].Width;
2696                             rects[i].Height = int_rects[i].Height;
2697                         }
2698                     }
2699                     else
2700                         stat = OutOfMemory;
2701                 }
2702                 else
2703                     rects = (GpRectF*)(record+1);
2704             }
2705
2706             if (stat == Ok)
2707             {
2708                 stat = GdipFillRectangles(metafile->playback_graphics, brush, rects, record->Count);
2709             }
2710
2711             GdipDeleteBrush(temp_brush);
2712             heap_free(temp_rects);
2713
2714             return stat;
2715         }
2716         case EmfPlusRecordTypeSetClipRect:
2717         {
2718             EmfPlusSetClipRect *record = (EmfPlusSetClipRect*)header;
2719             CombineMode mode = (CombineMode)((flags >> 8) & 0xf);
2720             GpRegion *region;
2721
2722             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(*record))
2723                 return InvalidParameter;
2724
2725             stat = GdipCreateRegionRect(&record->ClipRect, &region);
2726
2727             if (stat == Ok)
2728             {
2729                 stat = metafile_set_clip_region(real_metafile, region, mode);
2730                 GdipDeleteRegion(region);
2731             }
2732
2733             return stat;
2734         }
2735         case EmfPlusRecordTypeSetClipRegion:
2736         {
2737             CombineMode mode = (flags >> 8) & 0xf;
2738             BYTE regionid = flags & 0xff;
2739             GpRegion *region;
2740
2741             if (dataSize != 0)
2742                 return InvalidParameter;
2743
2744             if (regionid >= EmfPlusObjectTableSize || real_metafile->objtable[regionid].type != ObjectTypeRegion)
2745                 return InvalidParameter;
2746
2747             stat = GdipCloneRegion(real_metafile->objtable[regionid].u.region, &region);
2748             if (stat == Ok)
2749             {
2750                 stat = metafile_set_clip_region(real_metafile, region, mode);
2751                 GdipDeleteRegion(region);
2752             }
2753
2754             return stat;
2755         }
2756         case EmfPlusRecordTypeSetClipPath:
2757         {
2758             CombineMode mode = (flags >> 8) & 0xf;
2759             BYTE pathid = flags & 0xff;
2760             GpRegion *region;
2761
2762             if (dataSize != 0)
2763                 return InvalidParameter;
2764
2765             if (pathid >= EmfPlusObjectTableSize || real_metafile->objtable[pathid].type != ObjectTypePath)
2766                 return InvalidParameter;
2767
2768             stat = GdipCreateRegionPath(real_metafile->objtable[pathid].u.path, &region);
2769             if (stat == Ok)
2770             {
2771                 stat = metafile_set_clip_region(real_metafile, region, mode);
2772                 GdipDeleteRegion(region);
2773             }
2774
2775             return stat;
2776         }
2777         case EmfPlusRecordTypeSetPageTransform:
2778         {
2779             EmfPlusSetPageTransform *record = (EmfPlusSetPageTransform*)header;
2780             GpUnit unit = (GpUnit)flags;
2781
2782             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusSetPageTransform))
2783                 return InvalidParameter;
2784
2785             real_metafile->page_unit = unit;
2786             real_metafile->page_scale = record->PageScale;
2787
2788             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
2789         }
2790         case EmfPlusRecordTypeSetWorldTransform:
2791         {
2792             EmfPlusSetWorldTransform *record = (EmfPlusSetWorldTransform*)header;
2793
2794             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusSetWorldTransform))
2795                 return InvalidParameter;
2796
2797             memcpy(real_metafile->world_transform->matrix, record->MatrixData, sizeof(record->MatrixData));
2798
2799             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
2800         }
2801         case EmfPlusRecordTypeScaleWorldTransform:
2802         {
2803             EmfPlusScaleWorldTransform *record = (EmfPlusScaleWorldTransform*)header;
2804             MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
2805
2806             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusScaleWorldTransform))
2807                 return InvalidParameter;
2808
2809             GdipScaleMatrix(real_metafile->world_transform, record->Sx, record->Sy, order);
2810
2811             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
2812         }
2813         case EmfPlusRecordTypeMultiplyWorldTransform:
2814         {
2815             EmfPlusMultiplyWorldTransform *record = (EmfPlusMultiplyWorldTransform*)header;
2816             MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
2817             GpMatrix matrix;
2818
2819             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusMultiplyWorldTransform))
2820                 return InvalidParameter;
2821
2822             memcpy(matrix.matrix, record->MatrixData, sizeof(matrix.matrix));
2823
2824             GdipMultiplyMatrix(real_metafile->world_transform, &matrix, order);
2825
2826             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
2827         }
2828         case EmfPlusRecordTypeRotateWorldTransform:
2829         {
2830             EmfPlusRotateWorldTransform *record = (EmfPlusRotateWorldTransform*)header;
2831             MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
2832
2833             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusRotateWorldTransform))
2834                 return InvalidParameter;
2835
2836             GdipRotateMatrix(real_metafile->world_transform, record->Angle, order);
2837
2838             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
2839         }
2840         case EmfPlusRecordTypeTranslateWorldTransform:
2841         {
2842             EmfPlusTranslateWorldTransform *record = (EmfPlusTranslateWorldTransform*)header;
2843             MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
2844
2845             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusTranslateWorldTransform))
2846                 return InvalidParameter;
2847
2848             GdipTranslateMatrix(real_metafile->world_transform, record->dx, record->dy, order);
2849
2850             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
2851         }
2852         case EmfPlusRecordTypeResetWorldTransform:
2853         {
2854             GdipSetMatrixElements(real_metafile->world_transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
2855
2856             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
2857         }
2858         case EmfPlusRecordTypeBeginContainer:
2859         {
2860             EmfPlusBeginContainer *record = (EmfPlusBeginContainer*)header;
2861             container* cont;
2862             GpUnit unit;
2863             REAL scale_x, scale_y;
2864             GpRectF scaled_srcrect;
2865             GpMatrix transform;
2866
2867             cont = heap_alloc_zero(sizeof(*cont));
2868             if (!cont)
2869                 return OutOfMemory;
2870
2871             stat = GdipCloneRegion(metafile->clip, &cont->clip);
2872             if (stat != Ok)
2873             {
2874                 heap_free(cont);
2875                 return stat;
2876             }
2877
2878             stat = GdipBeginContainer2(metafile->playback_graphics, &cont->state);
2879
2880             if (stat != Ok)
2881             {
2882                 GdipDeleteRegion(cont->clip);
2883                 heap_free(cont);
2884                 return stat;
2885             }
2886
2887             cont->id = record->StackIndex;
2888             cont->type = BEGIN_CONTAINER;
2889             cont->world_transform = *metafile->world_transform;
2890             cont->page_unit = metafile->page_unit;
2891             cont->page_scale = metafile->page_scale;
2892             list_add_head(&real_metafile->containers, &cont->entry);
2893
2894             unit = record->Header.Flags & 0xff;
2895
2896             scale_x = units_to_pixels(1.0, unit, metafile->image.xres);
2897             scale_y = units_to_pixels(1.0, unit, metafile->image.yres);
2898
2899             scaled_srcrect.X = scale_x * record->SrcRect.X;
2900             scaled_srcrect.Y = scale_y * record->SrcRect.Y;
2901             scaled_srcrect.Width = scale_x * record->SrcRect.Width;
2902             scaled_srcrect.Height = scale_y * record->SrcRect.Height;
2903
2904             transform.matrix[0] = record->DestRect.Width / scaled_srcrect.Width;
2905             transform.matrix[1] = 0.0;
2906             transform.matrix[2] = 0.0;
2907             transform.matrix[3] = record->DestRect.Height / scaled_srcrect.Height;
2908             transform.matrix[4] = record->DestRect.X - scaled_srcrect.X;
2909             transform.matrix[5] = record->DestRect.Y - scaled_srcrect.Y;
2910
2911             GdipMultiplyMatrix(real_metafile->world_transform, &transform, MatrixOrderPrepend);
2912
2913             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
2914         }
2915         case EmfPlusRecordTypeBeginContainerNoParams:
2916         case EmfPlusRecordTypeSave:
2917         {
2918             EmfPlusContainerRecord *record = (EmfPlusContainerRecord*)header;
2919             container* cont;
2920
2921             cont = heap_alloc_zero(sizeof(*cont));
2922             if (!cont)
2923                 return OutOfMemory;
2924
2925             stat = GdipCloneRegion(metafile->clip, &cont->clip);
2926             if (stat != Ok)
2927             {
2928                 heap_free(cont);
2929                 return stat;
2930             }
2931
2932             if (recordType == EmfPlusRecordTypeBeginContainerNoParams)
2933                 stat = GdipBeginContainer2(metafile->playback_graphics, &cont->state);
2934             else
2935                 stat = GdipSaveGraphics(metafile->playback_graphics, &cont->state);
2936
2937             if (stat != Ok)
2938             {
2939                 GdipDeleteRegion(cont->clip);
2940                 heap_free(cont);
2941                 return stat;
2942             }
2943
2944             cont->id = record->StackIndex;
2945             if (recordType == EmfPlusRecordTypeBeginContainerNoParams)
2946                 cont->type = BEGIN_CONTAINER;
2947             else
2948                 cont->type = SAVE_GRAPHICS;
2949             cont->world_transform = *metafile->world_transform;
2950             cont->page_unit = metafile->page_unit;
2951             cont->page_scale = metafile->page_scale;
2952             list_add_head(&real_metafile->containers, &cont->entry);
2953
2954             break;
2955         }
2956         case EmfPlusRecordTypeEndContainer:
2957         case EmfPlusRecordTypeRestore:
2958         {
2959             EmfPlusContainerRecord *record = (EmfPlusContainerRecord*)header;
2960             container* cont;
2961             enum container_type type;
2962             BOOL found=FALSE;
2963
2964             if (recordType == EmfPlusRecordTypeEndContainer)
2965                 type = BEGIN_CONTAINER;
2966             else
2967                 type = SAVE_GRAPHICS;
2968
2969             LIST_FOR_EACH_ENTRY(cont, &real_metafile->containers, container, entry)
2970             {
2971                 if (cont->id == record->StackIndex && cont->type == type)
2972                 {
2973                     found = TRUE;
2974                     break;
2975                 }
2976             }
2977
2978             if (found)
2979             {
2980                 container* cont2;
2981
2982                 /* pop any newer items on the stack */
2983                 while ((cont2 = LIST_ENTRY(list_head(&real_metafile->containers), container, entry)) != cont)
2984                 {
2985                     list_remove(&cont2->entry);
2986                     GdipDeleteRegion(cont2->clip);
2987                     heap_free(cont2);
2988                 }
2989
2990                 if (type == BEGIN_CONTAINER)
2991                     GdipEndContainer(real_metafile->playback_graphics, cont->state);
2992                 else
2993                     GdipRestoreGraphics(real_metafile->playback_graphics, cont->state);
2994
2995                 *real_metafile->world_transform = cont->world_transform;
2996                 real_metafile->page_unit = cont->page_unit;
2997                 real_metafile->page_scale = cont->page_scale;
2998                 GdipCombineRegionRegion(real_metafile->clip, cont->clip, CombineModeReplace);
2999
3000                 list_remove(&cont->entry);
3001                 GdipDeleteRegion(cont->clip);
3002                 heap_free(cont);
3003             }
3004
3005             break;
3006         }
3007         case EmfPlusRecordTypeSetPixelOffsetMode:
3008         {
3009             return GdipSetPixelOffsetMode(real_metafile->playback_graphics, flags & 0xff);
3010         }
3011         case EmfPlusRecordTypeSetCompositingQuality:
3012         {
3013             return GdipSetCompositingQuality(real_metafile->playback_graphics, flags & 0xff);
3014         }
3015         case EmfPlusRecordTypeSetInterpolationMode:
3016         {
3017             return GdipSetInterpolationMode(real_metafile->playback_graphics, flags & 0xff);
3018         }
3019         case EmfPlusRecordTypeSetTextRenderingHint:
3020         {
3021             return GdipSetTextRenderingHint(real_metafile->playback_graphics, flags & 0xff);
3022         }
3023         case EmfPlusRecordTypeSetAntiAliasMode:
3024         {
3025             return GdipSetSmoothingMode(real_metafile->playback_graphics, (flags >> 1) & 0xff);
3026         }
3027         case EmfPlusRecordTypeSetCompositingMode:
3028         {
3029             return GdipSetCompositingMode(real_metafile->playback_graphics, flags & 0xff);
3030         }
3031         case EmfPlusRecordTypeObject:
3032         {
3033             return METAFILE_PlaybackObject(real_metafile, flags, dataSize, data);
3034         }
3035         case EmfPlusRecordTypeDrawImage:
3036         {
3037             EmfPlusDrawImage *draw = (EmfPlusDrawImage *)header;
3038             BYTE image = flags & 0xff;
3039             GpPointF points[3];
3040
3041             if (image >= EmfPlusObjectTableSize || real_metafile->objtable[image].type != ObjectTypeImage)
3042                 return InvalidParameter;
3043
3044             if (dataSize != FIELD_OFFSET(EmfPlusDrawImage, RectData) - sizeof(EmfPlusRecordHeader) +
3045                     (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
3046                 return InvalidParameter;
3047
3048             if (draw->ImageAttributesID >= EmfPlusObjectTableSize ||
3049                     real_metafile->objtable[draw->ImageAttributesID].type != ObjectTypeImageAttributes)
3050                 return InvalidParameter;
3051
3052             if (flags & 0x4000) /* C */
3053             {
3054                 points[0].X = draw->RectData.rect.X;
3055                 points[0].Y = draw->RectData.rect.Y;
3056                 points[1].X = points[0].X + draw->RectData.rect.Width;
3057                 points[1].Y = points[0].Y;
3058                 points[2].X = points[1].X;
3059                 points[2].Y = points[1].Y + draw->RectData.rect.Height;
3060             }
3061             else
3062             {
3063                 points[0].X = draw->RectData.rectF.X;
3064                 points[0].Y = draw->RectData.rectF.Y;
3065                 points[1].X = points[0].X + draw->RectData.rectF.Width;
3066                 points[1].Y = points[0].Y;
3067                 points[2].X = points[1].X;
3068                 points[2].Y = points[1].Y + draw->RectData.rectF.Height;
3069             }
3070
3071             return GdipDrawImagePointsRect(real_metafile->playback_graphics, real_metafile->objtable[image].u.image,
3072                 points, 3, draw->SrcRect.X, draw->SrcRect.Y, draw->SrcRect.Width, draw->SrcRect.Height, draw->SrcUnit,
3073                 real_metafile->objtable[draw->ImageAttributesID].u.image_attributes, NULL, NULL);
3074         }
3075         case EmfPlusRecordTypeDrawImagePoints:
3076         {
3077             EmfPlusDrawImagePoints *draw = (EmfPlusDrawImagePoints *)header;
3078             static const UINT fixed_part_size = FIELD_OFFSET(EmfPlusDrawImagePoints, PointData) -
3079                 FIELD_OFFSET(EmfPlusDrawImagePoints, ImageAttributesID);
3080             BYTE image = flags & 0xff;
3081             GpPointF points[3];
3082             unsigned int i;
3083             UINT size;
3084
3085             if (image >= EmfPlusObjectTableSize || real_metafile->objtable[image].type != ObjectTypeImage)
3086                 return InvalidParameter;
3087
3088             if (dataSize <= fixed_part_size)
3089                 return InvalidParameter;
3090             dataSize -= fixed_part_size;
3091
3092             if (draw->ImageAttributesID >= EmfPlusObjectTableSize ||
3093                     real_metafile->objtable[draw->ImageAttributesID].type != ObjectTypeImageAttributes)
3094                 return InvalidParameter;
3095
3096             if (draw->count != 3)
3097                 return InvalidParameter;
3098
3099             if ((flags >> 13) & 1) /* E */
3100                 FIXME("image effects are not supported.\n");
3101
3102             if ((flags >> 11) & 1) /* P */
3103                 size = sizeof(EmfPlusPointR7) * draw->count;
3104             else if ((flags >> 14) & 1) /* C */
3105                 size = sizeof(EmfPlusPoint) * draw->count;
3106             else
3107                 size = sizeof(EmfPlusPointF) * draw->count;
3108
3109             if (dataSize != size)
3110                 return InvalidParameter;
3111
3112             if ((flags >> 11) & 1) /* P */
3113             {
3114                 points[0].X = draw->PointData.pointsR[0].X;
3115                 points[0].Y = draw->PointData.pointsR[0].Y;
3116                 for (i = 1; i < 3; i++)
3117                 {
3118                     points[i].X = points[i-1].X + draw->PointData.pointsR[i].X;
3119                     points[i].Y = points[i-1].Y + draw->PointData.pointsR[i].Y;
3120                 }
3121             }
3122             else if ((flags >> 14) & 1) /* C */
3123             {
3124                 for (i = 0; i < 3; i++)
3125                 {
3126                     points[i].X = draw->PointData.points[i].X;
3127                     points[i].Y = draw->PointData.points[i].Y;
3128                 }
3129             }
3130             else
3131                 memcpy(points, draw->PointData.pointsF, sizeof(points));
3132
3133             return GdipDrawImagePointsRect(real_metafile->playback_graphics, real_metafile->objtable[image].u.image,
3134                 points, 3, draw->SrcRect.X, draw->SrcRect.Y, draw->SrcRect.Width, draw->SrcRect.Height, draw->SrcUnit,
3135                 real_metafile->objtable[draw->ImageAttributesID].u.image_attributes, NULL, NULL);
3136         }
3137         case EmfPlusRecordTypeFillPath:
3138         {
3139             EmfPlusFillPath *fill = (EmfPlusFillPath *)header;
3140             GpSolidFill *solidfill = NULL;
3141             BYTE path = flags & 0xff;
3142             GpBrush *brush;
3143
3144             if (path >= EmfPlusObjectTableSize || real_metafile->objtable[path].type != ObjectTypePath)
3145                 return InvalidParameter;
3146
3147             if (dataSize != sizeof(fill->data.BrushId))
3148                 return InvalidParameter;
3149
3150             if (flags & 0x8000)
3151             {
3152                 stat = GdipCreateSolidFill(fill->data.Color, &solidfill);
3153                 if (stat != Ok)
3154                     return stat;
3155                 brush = (GpBrush *)solidfill;
3156             }
3157             else
3158             {
3159                 if (fill->data.BrushId >= EmfPlusObjectTableSize ||
3160                         real_metafile->objtable[fill->data.BrushId].type != ObjectTypeBrush)
3161                     return InvalidParameter;
3162
3163                 brush = real_metafile->objtable[fill->data.BrushId].u.brush;
3164             }
3165
3166             stat = GdipFillPath(real_metafile->playback_graphics, brush, real_metafile->objtable[path].u.path);
3167             GdipDeleteBrush((GpBrush *)solidfill);
3168             return stat;
3169         }
3170         case EmfPlusRecordTypeFillClosedCurve:
3171         {
3172             static const UINT fixed_part_size = FIELD_OFFSET(EmfPlusFillClosedCurve, PointData) -
3173                 sizeof(EmfPlusRecordHeader);
3174             EmfPlusFillClosedCurve *fill = (EmfPlusFillClosedCurve *)header;
3175             GpSolidFill *solidfill = NULL;
3176             GpFillMode mode;
3177             GpBrush *brush;
3178             UINT size, i;
3179
3180             if (dataSize <= fixed_part_size)
3181                 return InvalidParameter;
3182
3183             if (fill->Count == 0)
3184                 return InvalidParameter;
3185
3186             if (flags & 0x800) /* P */
3187                 size = (fixed_part_size + sizeof(EmfPlusPointR7) * fill->Count + 3) & ~3;
3188             else if (flags & 0x4000) /* C */
3189                 size = fixed_part_size + sizeof(EmfPlusPoint) * fill->Count;
3190             else
3191                 size = fixed_part_size + sizeof(EmfPlusPointF) * fill->Count;
3192
3193             if (dataSize != size)
3194                 return InvalidParameter;
3195
3196             mode = flags & 0x200 ? FillModeWinding : FillModeAlternate; /* W */
3197
3198             if (flags & 0x8000) /* S */
3199             {
3200                 stat = GdipCreateSolidFill(fill->BrushId, &solidfill);
3201                 if (stat != Ok)
3202                     return stat;
3203                 brush = (GpBrush *)solidfill;
3204             }
3205             else
3206             {
3207                 if (fill->BrushId >= EmfPlusObjectTableSize ||
3208                         real_metafile->objtable[fill->BrushId].type != ObjectTypeBrush)
3209                     return InvalidParameter;
3210
3211                 brush = real_metafile->objtable[fill->BrushId].u.brush;
3212             }
3213
3214             if (flags & (0x800 | 0x4000))
3215             {
3216                 GpPointF *points = GdipAlloc(fill->Count * sizeof(*points));
3217                 if (points)
3218                 {
3219                     if (flags & 0x800) /* P */
3220                     {
3221                         for (i = 1; i < fill->Count; i++)
3222                         {
3223                             points[i].X = points[i - 1].X + fill->PointData.pointsR[i].X;
3224                             points[i].Y = points[i - 1].Y + fill->PointData.pointsR[i].Y;
3225                         }
3226                     }
3227                     else
3228                     {
3229                         for (i = 0; i < fill->Count; i++)
3230                         {
3231                             points[i].X = fill->PointData.points[i].X;
3232                             points[i].Y = fill->PointData.points[i].Y;
3233                         }
3234                     }
3235
3236                     stat = GdipFillClosedCurve2(real_metafile->playback_graphics, brush,
3237                         points, fill->Count, fill->Tension, mode);
3238                     GdipFree(points);
3239                 }
3240                 else
3241                     stat = OutOfMemory;
3242             }
3243             else
3244                 stat = GdipFillClosedCurve2(real_metafile->playback_graphics, brush,
3245                     (const GpPointF *)fill->PointData.pointsF, fill->Count, fill->Tension, mode);
3246
3247             GdipDeleteBrush((GpBrush *)solidfill);
3248             return stat;
3249         }
3250         case EmfPlusRecordTypeFillEllipse:
3251         {
3252             EmfPlusFillEllipse *fill = (EmfPlusFillEllipse *)header;
3253             GpSolidFill *solidfill = NULL;
3254             GpBrush *brush;
3255
3256             if (dataSize <= FIELD_OFFSET(EmfPlusFillEllipse, RectData) - sizeof(EmfPlusRecordHeader))
3257                 return InvalidParameter;
3258             dataSize -= FIELD_OFFSET(EmfPlusFillEllipse, RectData) - sizeof(EmfPlusRecordHeader);
3259
3260             if (dataSize != (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
3261                 return InvalidParameter;
3262
3263             if (flags & 0x8000)
3264             {
3265                 stat = GdipCreateSolidFill(fill->BrushId, &solidfill);
3266                 if (stat != Ok)
3267                     return stat;
3268                 brush = (GpBrush *)solidfill;
3269             }
3270             else
3271             {
3272                 if (fill->BrushId >= EmfPlusObjectTableSize ||
3273                         real_metafile->objtable[fill->BrushId].type != ObjectTypeBrush)
3274                     return InvalidParameter;
3275
3276                 brush = real_metafile->objtable[fill->BrushId].u.brush;
3277             }
3278
3279             if (flags & 0x4000)
3280                 stat = GdipFillEllipseI(real_metafile->playback_graphics, brush, fill->RectData.rect.X,
3281                     fill->RectData.rect.Y, fill->RectData.rect.Width, fill->RectData.rect.Height);
3282             else
3283                 stat = GdipFillEllipse(real_metafile->playback_graphics, brush, fill->RectData.rectF.X,
3284                     fill->RectData.rectF.Y, fill->RectData.rectF.Width, fill->RectData.rectF.Height);
3285
3286             GdipDeleteBrush((GpBrush *)solidfill);
3287             return stat;
3288         }
3289         case EmfPlusRecordTypeFillPie:
3290         {
3291             EmfPlusFillPie *fill = (EmfPlusFillPie *)header;
3292             GpSolidFill *solidfill = NULL;
3293             GpBrush *brush;
3294
3295             if (dataSize <= FIELD_OFFSET(EmfPlusFillPie, RectData) - sizeof(EmfPlusRecordHeader))
3296                 return InvalidParameter;
3297             dataSize -= FIELD_OFFSET(EmfPlusFillPie, RectData) - sizeof(EmfPlusRecordHeader);
3298
3299             if (dataSize != (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
3300                 return InvalidParameter;
3301
3302             if (flags & 0x8000) /* S */
3303             {
3304                 stat = GdipCreateSolidFill(fill->BrushId, &solidfill);
3305                 if (stat != Ok)
3306                     return stat;
3307                 brush = (GpBrush *)solidfill;
3308             }
3309             else
3310             {
3311                 if (fill->BrushId >= EmfPlusObjectTableSize ||
3312                         real_metafile->objtable[fill->BrushId].type != ObjectTypeBrush)
3313                     return InvalidParameter;
3314
3315                 brush = real_metafile->objtable[fill->BrushId].u.brush;
3316             }
3317
3318             if (flags & 0x4000) /* C */
3319                 stat = GdipFillPieI(real_metafile->playback_graphics, brush, fill->RectData.rect.X,
3320                     fill->RectData.rect.Y, fill->RectData.rect.Width, fill->RectData.rect.Height,
3321                     fill->StartAngle, fill->SweepAngle);
3322             else
3323                 stat = GdipFillPie(real_metafile->playback_graphics, brush, fill->RectData.rectF.X,
3324                     fill->RectData.rectF.Y, fill->RectData.rectF.Width, fill->RectData.rectF.Height,
3325                     fill->StartAngle, fill->SweepAngle);
3326
3327             GdipDeleteBrush((GpBrush *)solidfill);
3328             return stat;
3329         }
3330         case EmfPlusRecordTypeDrawPath:
3331         {
3332             EmfPlusDrawPath *draw = (EmfPlusDrawPath *)header;
3333             BYTE path = flags & 0xff;
3334
3335             if (dataSize != sizeof(draw->PenId))
3336                 return InvalidParameter;
3337
3338             if (path >= EmfPlusObjectTableSize || draw->PenId >= EmfPlusObjectTableSize)
3339                 return InvalidParameter;
3340
3341             if (real_metafile->objtable[path].type != ObjectTypePath ||
3342                     real_metafile->objtable[draw->PenId].type != ObjectTypePen)
3343                 return InvalidParameter;
3344
3345             return GdipDrawPath(real_metafile->playback_graphics, real_metafile->objtable[draw->PenId].u.pen,
3346                 real_metafile->objtable[path].u.path);
3347         }
3348         case EmfPlusRecordTypeDrawArc:
3349         {
3350             EmfPlusDrawArc *draw = (EmfPlusDrawArc *)header;
3351             BYTE pen = flags & 0xff;
3352
3353             if (pen >= EmfPlusObjectTableSize || real_metafile->objtable[pen].type != ObjectTypePen)
3354                 return InvalidParameter;
3355
3356             if (dataSize != FIELD_OFFSET(EmfPlusDrawArc, RectData) - sizeof(EmfPlusRecordHeader) +
3357                     (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
3358                 return InvalidParameter;
3359
3360             if (flags & 0x4000) /* C */
3361                 return GdipDrawArcI(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
3362                     draw->RectData.rect.X, draw->RectData.rect.Y, draw->RectData.rect.Width,
3363                     draw->RectData.rect.Height, draw->StartAngle, draw->SweepAngle);
3364             else
3365                 return GdipDrawArc(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
3366                     draw->RectData.rectF.X, draw->RectData.rectF.Y, draw->RectData.rectF.Width,
3367                     draw->RectData.rectF.Height, draw->StartAngle, draw->SweepAngle);
3368         }
3369         case EmfPlusRecordTypeDrawEllipse:
3370         {
3371             EmfPlusDrawEllipse *draw = (EmfPlusDrawEllipse *)header;
3372             BYTE pen = flags & 0xff;
3373
3374             if (pen >= EmfPlusObjectTableSize || real_metafile->objtable[pen].type != ObjectTypePen)
3375                 return InvalidParameter;
3376
3377             if (dataSize != (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
3378                 return InvalidParameter;
3379
3380             if (flags & 0x4000) /* C */
3381                 return GdipDrawEllipseI(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
3382                     draw->RectData.rect.X, draw->RectData.rect.Y, draw->RectData.rect.Width,
3383                     draw->RectData.rect.Height);
3384             else
3385                 return GdipDrawEllipse(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
3386                     draw->RectData.rectF.X, draw->RectData.rectF.Y, draw->RectData.rectF.Width,
3387                     draw->RectData.rectF.Height);
3388         }
3389         case EmfPlusRecordTypeDrawPie:
3390         {
3391             EmfPlusDrawPie *draw = (EmfPlusDrawPie *)header;
3392             BYTE pen = flags & 0xff;
3393
3394             if (pen >= EmfPlusObjectTableSize || real_metafile->objtable[pen].type != ObjectTypePen)
3395                 return InvalidParameter;
3396
3397             if (dataSize != FIELD_OFFSET(EmfPlusDrawPie, RectData) - sizeof(EmfPlusRecordHeader) +
3398                     (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
3399                 return InvalidParameter;
3400
3401             if (flags & 0x4000) /* C */
3402                 return GdipDrawPieI(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
3403                     draw->RectData.rect.X, draw->RectData.rect.Y, draw->RectData.rect.Width,
3404                     draw->RectData.rect.Height, draw->StartAngle, draw->SweepAngle);
3405             else
3406                 return GdipDrawPie(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
3407                     draw->RectData.rectF.X, draw->RectData.rectF.Y, draw->RectData.rectF.Width,
3408                     draw->RectData.rectF.Height, draw->StartAngle, draw->SweepAngle);
3409         }
3410         case EmfPlusRecordTypeDrawRects:
3411         {
3412             EmfPlusDrawRects *draw = (EmfPlusDrawRects *)header;
3413             BYTE pen = flags & 0xff;
3414             GpRectF *rects = NULL;
3415
3416             if (pen >= EmfPlusObjectTableSize || real_metafile->objtable[pen].type != ObjectTypePen)
3417                 return InvalidParameter;
3418
3419             if (dataSize <= FIELD_OFFSET(EmfPlusDrawRects, RectData) - sizeof(EmfPlusRecordHeader))
3420                 return InvalidParameter;
3421             dataSize -= FIELD_OFFSET(EmfPlusDrawRects, RectData) - sizeof(EmfPlusRecordHeader);
3422
3423             if (dataSize != draw->Count * (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
3424                 return InvalidParameter;
3425
3426             if (flags & 0x4000)
3427             {
3428                 DWORD i;
3429
3430                 rects = GdipAlloc(draw->Count * sizeof(*rects));
3431                 if (!rects)
3432                     return OutOfMemory;
3433
3434                 for (i = 0; i < draw->Count; i++)
3435                 {
3436                     rects[i].X = draw->RectData.rect[i].X;
3437                     rects[i].Y = draw->RectData.rect[i].Y;
3438                     rects[i].Width = draw->RectData.rect[i].Width;
3439                     rects[i].Height = draw->RectData.rect[i].Height;
3440                 }
3441             }
3442
3443             stat = GdipDrawRectangles(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
3444                     rects ? rects : (GpRectF *)draw->RectData.rectF, draw->Count);
3445             GdipFree(rects);
3446             return stat;
3447         }
3448         case EmfPlusRecordTypeDrawDriverString:
3449         {
3450             GpBrush *brush;
3451             DWORD expected_size;
3452             UINT16 *text;
3453             PointF *positions;
3454             GpSolidFill *solidfill = NULL;
3455             void* alignedmem = NULL;
3456             GpMatrix *matrix = NULL;
3457             BYTE font = flags & 0xff;
3458             EmfPlusDrawDriverString *draw = (EmfPlusDrawDriverString*)header;
3459
3460             if (font >= EmfPlusObjectTableSize ||
3461                     real_metafile->objtable[font].type != ObjectTypeFont)
3462                 return InvalidParameter;
3463
3464             expected_size = FIELD_OFFSET(EmfPlusDrawDriverString, VariableData) -
3465                 sizeof(EmfPlusRecordHeader);
3466             if (dataSize < expected_size || draw->GlyphCount <= 0)
3467                 return InvalidParameter;
3468
3469             expected_size += draw->GlyphCount * (sizeof(*text) + sizeof(*positions));
3470             if (draw->MatrixPresent)
3471                 expected_size += sizeof(*matrix);
3472
3473             /* Pad expected size to DWORD alignment. */
3474             expected_size = (expected_size + 3) & ~3;
3475
3476             if (dataSize != expected_size)
3477                 return InvalidParameter;
3478
3479             if (flags & 0x8000)
3480             {
3481                 stat = GdipCreateSolidFill(draw->brush.Color, (GpSolidFill**)&solidfill);
3482
3483                 if (stat != Ok)
3484                     return InvalidParameter;
3485
3486                 brush = (GpBrush*)solidfill;
3487             }
3488             else
3489             {
3490                 if (draw->brush.BrushId >= EmfPlusObjectTableSize ||
3491                         real_metafile->objtable[draw->brush.BrushId].type != ObjectTypeBrush)
3492                     return InvalidParameter;
3493
3494                 brush = real_metafile->objtable[draw->brush.BrushId].u.brush;
3495             }
3496
3497             text = (UINT16*)&draw->VariableData[0];
3498
3499             /* If GlyphCount is odd, all subsequent fields will be 2-byte
3500                aligned rather than 4-byte aligned, which may lead to access
3501                issues. Handle this case by making our own copy of positions. */
3502             if (draw->GlyphCount % 2)
3503             {
3504                 SIZE_T alloc_size = draw->GlyphCount * sizeof(*positions);
3505
3506                 if (draw->MatrixPresent)
3507                     alloc_size += sizeof(*matrix);
3508
3509                 positions = alignedmem = heap_alloc(alloc_size);
3510                 if (!positions)
3511                 {
3512                     GdipDeleteBrush((GpBrush*)solidfill);
3513                     return OutOfMemory;
3514                 }
3515
3516                 memcpy(positions, &text[draw->GlyphCount], alloc_size);
3517             }
3518             else
3519                 positions = (PointF*)&text[draw->GlyphCount];
3520
3521             if (draw->MatrixPresent)
3522                 matrix = (GpMatrix*)&positions[draw->GlyphCount];
3523
3524             stat = GdipDrawDriverString(real_metafile->playback_graphics, text, draw->GlyphCount,
3525                     real_metafile->objtable[font].u.font, brush, positions,
3526                     draw->DriverStringOptionsFlags, matrix);
3527
3528             GdipDeleteBrush((GpBrush*)solidfill);
3529             heap_free(alignedmem);
3530
3531             return stat;
3532         }
3533         case EmfPlusRecordTypeFillRegion:
3534         {
3535             EmfPlusFillRegion * const fill = (EmfPlusFillRegion*)header;
3536             GpSolidFill *solidfill = NULL;
3537             GpBrush *brush;
3538             BYTE region = flags & 0xff;
3539
3540             if (dataSize != sizeof(EmfPlusFillRegion) - sizeof(EmfPlusRecordHeader))
3541                 return InvalidParameter;
3542
3543             if (region >= EmfPlusObjectTableSize ||
3544                     real_metafile->objtable[region].type != ObjectTypeRegion)
3545                 return InvalidParameter;
3546
3547             if (flags & 0x8000)
3548             {
3549                 stat = GdipCreateSolidFill(fill->data.Color, &solidfill);
3550                 if (stat != Ok)
3551                     return stat;
3552                 brush = (GpBrush*)solidfill;
3553             }
3554             else
3555             {
3556                 if (fill->data.BrushId >= EmfPlusObjectTableSize ||
3557                         real_metafile->objtable[fill->data.BrushId].type != ObjectTypeBrush)
3558                     return InvalidParameter;
3559
3560                 brush = real_metafile->objtable[fill->data.BrushId].u.brush;
3561             }
3562
3563             stat = GdipFillRegion(real_metafile->playback_graphics, brush,
3564                 real_metafile->objtable[region].u.region);
3565             GdipDeleteBrush((GpBrush*)solidfill);
3566
3567             return stat;
3568         }
3569         default:
3570             FIXME("Not implemented for record type %x\n", recordType);
3571             return NotImplemented;
3572         }
3573     }
3574
3575     return Ok;
3576 }
3577
3578 struct enum_metafile_data
3579 {
3580     EnumerateMetafileProc callback;
3581     void *callback_data;
3582     GpMetafile *metafile;
3583 };
3584
3585 static int CALLBACK enum_metafile_proc(HDC hDC, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR,
3586     int nObj, LPARAM lpData)
3587 {
3588     BOOL ret;
3589     struct enum_metafile_data *data = (struct enum_metafile_data*)lpData;
3590     const BYTE* pStr;
3591
3592     data->metafile->handle_table = lpHTable;
3593     data->metafile->handle_count = nObj;
3594
3595     /* First check for an EMF+ record. */
3596     if (lpEMFR->iType == EMR_GDICOMMENT)
3597     {
3598         const EMRGDICOMMENT *comment = (const EMRGDICOMMENT*)lpEMFR;
3599
3600         if (comment->cbData >= 4 && memcmp(comment->Data, "EMF+", 4) == 0)
3601         {
3602             int offset = 4;
3603
3604             while (offset + sizeof(EmfPlusRecordHeader) <= comment->cbData)
3605             {
3606                 const EmfPlusRecordHeader *record = (const EmfPlusRecordHeader*)&comment->Data[offset];
3607
3608                 if (record->DataSize)
3609                     pStr = (const BYTE*)(record+1);
3610                 else
3611                     pStr = NULL;
3612
3613                 ret = data->callback(record->Type, record->Flags, record->DataSize,
3614                     pStr, data->callback_data);
3615
3616                 if (!ret)
3617                     return 0;
3618
3619                 offset += record->Size;
3620             }
3621
3622             return 1;
3623         }
3624     }
3625
3626     if (lpEMFR->nSize != 8)
3627         pStr = (const BYTE*)lpEMFR->dParm;
3628     else
3629         pStr = NULL;
3630
3631     return data->callback(lpEMFR->iType, 0, lpEMFR->nSize-8,
3632         pStr, data->callback_data);
3633 }
3634
3635 GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPoints(GpGraphics *graphics,
3636     GDIPCONST GpMetafile *metafile, GDIPCONST GpPointF *destPoints, INT count,
3637     GDIPCONST GpRectF *srcRect, Unit srcUnit, EnumerateMetafileProc callback,
3638     VOID *callbackData, GDIPCONST GpImageAttributes *imageAttributes)
3639 {
3640     struct enum_metafile_data data;
3641     GpStatus stat;
3642     GpMetafile *real_metafile = (GpMetafile*)metafile; /* whoever made this const was joking */
3643     GraphicsContainer state;
3644     GpPath *dst_path;
3645     RECT dst_bounds;
3646
3647     TRACE("(%p,%p,%p,%i,%p,%i,%p,%p,%p)\n", graphics, metafile,
3648         destPoints, count, srcRect, srcUnit, callback, callbackData,
3649         imageAttributes);
3650
3651     if (!graphics || !metafile || !destPoints || count != 3 || !srcRect)
3652         return InvalidParameter;
3653
3654     if (!metafile->hemf)
3655         return InvalidParameter;
3656
3657     if (metafile->playback_graphics)
3658         return ObjectBusy;
3659
3660     TRACE("%s %i -> %s %s %s\n", debugstr_rectf(srcRect), srcUnit,
3661         debugstr_pointf(&destPoints[0]), debugstr_pointf(&destPoints[1]),
3662         debugstr_pointf(&destPoints[2]));
3663
3664     data.callback = callback;
3665     data.callback_data = callbackData;
3666     data.metafile = real_metafile;
3667
3668     real_metafile->playback_graphics = graphics;
3669     real_metafile->playback_dc = NULL;
3670     real_metafile->src_rect = *srcRect;
3671
3672     memcpy(real_metafile->playback_points, destPoints, sizeof(PointF) * 3);
3673     stat = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, real_metafile->playback_points, 3);
3674
3675     if (stat == Ok)
3676         stat = GdipBeginContainer2(graphics, &state);
3677
3678     if (stat == Ok)
3679     {
3680         stat = GdipSetPageScale(graphics, 1.0);
3681
3682         if (stat == Ok)
3683             stat = GdipSetPageUnit(graphics, UnitPixel);
3684
3685         if (stat == Ok)
3686             stat = GdipResetWorldTransform(graphics);
3687
3688         if (stat == Ok)
3689             stat = GdipCreateRegion(&real_metafile->base_clip);
3690
3691         if (stat == Ok)
3692             stat = GdipGetClip(graphics, real_metafile->base_clip);
3693
3694         if (stat == Ok)
3695             stat = GdipCreateRegion(&real_metafile->clip);
3696
3697         if (stat == Ok)
3698             stat = GdipCreatePath(FillModeAlternate, &dst_path);
3699
3700         if (stat == Ok)
3701         {
3702             GpPointF clip_points[4];
3703
3704             clip_points[0] = real_metafile->playback_points[0];
3705             clip_points[1] = real_metafile->playback_points[1];
3706             clip_points[2].X = real_metafile->playback_points[1].X + real_metafile->playback_points[2].X
3707                 - real_metafile->playback_points[0].X;
3708             clip_points[2].Y = real_metafile->playback_points[1].Y + real_metafile->playback_points[2].Y
3709                 - real_metafile->playback_points[0].Y;
3710             clip_points[3] = real_metafile->playback_points[2];
3711
3712             stat = GdipAddPathPolygon(dst_path, clip_points, 4);
3713
3714             if (stat == Ok)
3715                 stat = GdipCombineRegionPath(real_metafile->base_clip, dst_path, CombineModeIntersect);
3716
3717             GdipDeletePath(dst_path);
3718         }
3719
3720         if (stat == Ok)
3721             stat = GdipCreateMatrix(&real_metafile->world_transform);
3722
3723         if (stat == Ok)
3724         {
3725             real_metafile->page_unit = UnitDisplay;
3726             real_metafile->page_scale = 1.0;
3727             stat = METAFILE_PlaybackUpdateWorldTransform(real_metafile);
3728         }
3729
3730         if (stat == Ok)
3731         {
3732             stat = METAFILE_PlaybackUpdateClip(real_metafile);
3733         }
3734
3735         if (stat == Ok)
3736         {
3737             stat = METAFILE_PlaybackGetDC(real_metafile);
3738
3739             dst_bounds.left = real_metafile->playback_points[0].X;
3740             dst_bounds.right = real_metafile->playback_points[1].X;
3741             dst_bounds.top = real_metafile->playback_points[0].Y;
3742             dst_bounds.bottom = real_metafile->playback_points[2].Y;
3743         }
3744
3745         if (stat == Ok)
3746             EnumEnhMetaFile(real_metafile->playback_dc, metafile->hemf, enum_metafile_proc,
3747                 &data, &dst_bounds);
3748
3749         METAFILE_PlaybackReleaseDC(real_metafile);
3750
3751         GdipDeleteMatrix(real_metafile->world_transform);
3752         real_metafile->world_transform = NULL;
3753
3754         GdipDeleteRegion(real_metafile->base_clip);
3755         real_metafile->base_clip = NULL;
3756
3757         GdipDeleteRegion(real_metafile->clip);
3758         real_metafile->clip = NULL;
3759
3760         while (list_head(&real_metafile->containers))
3761         {
3762             container* cont = LIST_ENTRY(list_head(&real_metafile->containers), container, entry);
3763             list_remove(&cont->entry);
3764             GdipDeleteRegion(cont->clip);
3765             heap_free(cont);
3766         }
3767
3768         GdipEndContainer(graphics, state);
3769     }
3770
3771     real_metafile->playback_graphics = NULL;
3772
3773     return stat;
3774 }
3775
3776 GpStatus WINGDIPAPI GdipEnumerateMetafileDestRect(GpGraphics *graphics,
3777     GDIPCONST GpMetafile *metafile, GDIPCONST GpRectF *dest,
3778     EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
3779 {
3780     GpPointF points[3];
3781
3782     if (!graphics || !metafile || !dest) return InvalidParameter;
3783
3784     points[0].X = points[2].X = dest->X;
3785     points[0].Y = points[1].Y = dest->Y;
3786     points[1].X = dest->X + dest->Width;
3787     points[2].Y = dest->Y + dest->Height;
3788
3789     return GdipEnumerateMetafileSrcRectDestPoints(graphics, metafile, points, 3,
3790         &metafile->bounds, metafile->unit, callback, cb_data, attrs);
3791 }
3792
3793 GpStatus WINGDIPAPI GdipEnumerateMetafileDestRectI(GpGraphics *graphics,
3794     GDIPCONST GpMetafile *metafile, GDIPCONST GpRect *dest,
3795     EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
3796 {
3797     GpRectF destf;
3798
3799     if (!graphics || !metafile || !dest) return InvalidParameter;
3800
3801     destf.X = dest->X;
3802     destf.Y = dest->Y;
3803     destf.Width = dest->Width;
3804     destf.Height = dest->Height;
3805
3806     return GdipEnumerateMetafileDestRect(graphics, metafile, &destf, callback, cb_data, attrs);
3807 }
3808
3809 GpStatus WINGDIPAPI GdipEnumerateMetafileDestPoint(GpGraphics *graphics,
3810     GDIPCONST GpMetafile *metafile, GDIPCONST GpPointF *dest,
3811     EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
3812 {
3813     GpRectF destf;
3814
3815     if (!graphics || !metafile || !dest) return InvalidParameter;
3816
3817     destf.X = dest->X;
3818     destf.Y = dest->Y;
3819     destf.Width = units_to_pixels(metafile->bounds.Width, metafile->unit, metafile->image.xres);
3820     destf.Height = units_to_pixels(metafile->bounds.Height, metafile->unit, metafile->image.yres);
3821
3822     return GdipEnumerateMetafileDestRect(graphics, metafile, &destf, callback, cb_data, attrs);
3823 }
3824
3825 GpStatus WINGDIPAPI GdipEnumerateMetafileDestPointI(GpGraphics *graphics,
3826     GDIPCONST GpMetafile *metafile, GDIPCONST GpPoint *dest,
3827     EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
3828 {
3829     GpPointF ptf;
3830
3831     if (!graphics || !metafile || !dest) return InvalidParameter;
3832
3833     ptf.X = dest->X;
3834     ptf.Y = dest->Y;
3835
3836     return GdipEnumerateMetafileDestPoint(graphics, metafile, &ptf, callback, cb_data, attrs);
3837 }
3838
3839 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
3840     MetafileHeader * header)
3841 {
3842     GpStatus status;
3843
3844     TRACE("(%p, %p)\n", metafile, header);
3845
3846     if(!metafile || !header)
3847         return InvalidParameter;
3848
3849     if (metafile->hemf)
3850     {
3851         status = GdipGetMetafileHeaderFromEmf(metafile->hemf, header);
3852         if (status != Ok) return status;
3853     }
3854     else
3855     {
3856         memset(header, 0, sizeof(*header));
3857         header->Version = VERSION_MAGIC2;
3858     }
3859
3860     header->Type = metafile->metafile_type;
3861     header->DpiX = metafile->image.xres;
3862     header->DpiY = metafile->image.yres;
3863     header->Width = gdip_round(metafile->bounds.Width);
3864     header->Height = gdip_round(metafile->bounds.Height);
3865
3866     return Ok;
3867 }
3868
3869 static int CALLBACK get_emfplus_header_proc(HDC hDC, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR,
3870     int nObj, LPARAM lpData)
3871 {
3872     EmfPlusHeader *dst_header = (EmfPlusHeader*)lpData;
3873
3874     if (lpEMFR->iType == EMR_GDICOMMENT)
3875     {
3876         const EMRGDICOMMENT *comment = (const EMRGDICOMMENT*)lpEMFR;
3877
3878         if (comment->cbData >= 4 && memcmp(comment->Data, "EMF+", 4) == 0)
3879         {
3880             const EmfPlusRecordHeader *header = (const EmfPlusRecordHeader*)&comment->Data[4];
3881
3882             if (4 + sizeof(EmfPlusHeader) <= comment->cbData &&
3883                 header->Type == EmfPlusRecordTypeHeader)
3884             {
3885                 memcpy(dst_header, header, sizeof(*dst_header));
3886             }
3887         }
3888     }
3889     else if (lpEMFR->iType == EMR_HEADER)
3890         return TRUE;
3891
3892     return FALSE;
3893 }
3894
3895 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromEmf(HENHMETAFILE hemf,
3896     MetafileHeader *header)
3897 {
3898     ENHMETAHEADER3 emfheader;
3899     EmfPlusHeader emfplusheader;
3900     MetafileType metafile_type;
3901
3902     TRACE("(%p,%p)\n", hemf, header);
3903
3904     if(!hemf || !header)
3905         return InvalidParameter;
3906
3907     if (GetEnhMetaFileHeader(hemf, sizeof(emfheader), (ENHMETAHEADER*)&emfheader) == 0)
3908         return GenericError;
3909
3910     emfplusheader.Header.Type = 0;
3911
3912     EnumEnhMetaFile(NULL, hemf, get_emfplus_header_proc, &emfplusheader, NULL);
3913
3914     if (emfplusheader.Header.Type == EmfPlusRecordTypeHeader)
3915     {
3916         if ((emfplusheader.Header.Flags & 1) == 1)
3917             metafile_type = MetafileTypeEmfPlusDual;
3918         else
3919             metafile_type = MetafileTypeEmfPlusOnly;
3920     }
3921     else
3922         metafile_type = MetafileTypeEmf;
3923
3924     header->Type = metafile_type;
3925     header->Size = emfheader.nBytes;
3926     header->DpiX = (REAL)emfheader.szlDevice.cx * 25.4 / emfheader.szlMillimeters.cx;
3927     header->DpiY = (REAL)emfheader.szlDevice.cy * 25.4 / emfheader.szlMillimeters.cy;
3928     header->X = gdip_round((REAL)emfheader.rclFrame.left / 2540.0 * header->DpiX);
3929     header->Y = gdip_round((REAL)emfheader.rclFrame.top / 2540.0 * header->DpiY);
3930     header->Width = gdip_round((REAL)(emfheader.rclFrame.right - emfheader.rclFrame.left) / 2540.0 * header->DpiX);
3931     header->Height = gdip_round((REAL)(emfheader.rclFrame.bottom - emfheader.rclFrame.top) / 2540.0 * header->DpiY);
3932     header->u.EmfHeader = emfheader;
3933
3934     if (metafile_type == MetafileTypeEmfPlusDual || metafile_type == MetafileTypeEmfPlusOnly)
3935     {
3936         header->Version = emfplusheader.Version;
3937         header->EmfPlusFlags = emfplusheader.EmfPlusFlags;
3938         header->EmfPlusHeaderSize = emfplusheader.Header.Size;
3939         header->LogicalDpiX = emfplusheader.LogicalDpiX;
3940         header->LogicalDpiY = emfplusheader.LogicalDpiY;
3941     }
3942     else
3943     {
3944         header->Version = emfheader.nVersion;
3945         header->EmfPlusFlags = 0;
3946         header->EmfPlusHeaderSize = 0;
3947         header->LogicalDpiX = 0;
3948         header->LogicalDpiY = 0;
3949     }
3950
3951     return Ok;
3952 }
3953
3954 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromWmf(HMETAFILE hwmf,
3955     GDIPCONST WmfPlaceableFileHeader *placeable, MetafileHeader *header)
3956 {
3957     GpStatus status;
3958     GpMetafile *metafile;
3959
3960     TRACE("(%p,%p,%p)\n", hwmf, placeable, header);
3961
3962     status = GdipCreateMetafileFromWmf(hwmf, FALSE, placeable, &metafile);
3963     if (status == Ok)
3964     {
3965         status = GdipGetMetafileHeaderFromMetafile(metafile, header);
3966         GdipDisposeImage(&metafile->image);
3967     }
3968     return status;
3969 }
3970
3971 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromFile(GDIPCONST WCHAR *filename,
3972     MetafileHeader *header)
3973 {
3974     GpStatus status;
3975     GpMetafile *metafile;
3976
3977     TRACE("(%s,%p)\n", debugstr_w(filename), header);
3978
3979     if (!filename || !header)
3980         return InvalidParameter;
3981
3982     status = GdipCreateMetafileFromFile(filename, &metafile);
3983     if (status == Ok)
3984     {
3985         status = GdipGetMetafileHeaderFromMetafile(metafile, header);
3986         GdipDisposeImage(&metafile->image);
3987     }
3988     return status;
3989 }
3990
3991 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromStream(IStream *stream,
3992     MetafileHeader *header)
3993 {
3994     GpStatus status;
3995     GpMetafile *metafile;
3996
3997     TRACE("(%p,%p)\n", stream, header);
3998
3999     if (!stream || !header)
4000         return InvalidParameter;
4001
4002     status = GdipCreateMetafileFromStream(stream, &metafile);
4003     if (status == Ok)
4004     {
4005         status = GdipGetMetafileHeaderFromMetafile(metafile, header);
4006         GdipDisposeImage(&metafile->image);
4007     }
4008     return status;
4009 }
4010
4011 GpStatus WINGDIPAPI GdipCreateMetafileFromEmf(HENHMETAFILE hemf, BOOL delete,
4012     GpMetafile **metafile)
4013 {
4014     GpStatus stat;
4015     MetafileHeader header;
4016
4017     TRACE("(%p,%i,%p)\n", hemf, delete, metafile);
4018
4019     if(!hemf || !metafile)
4020         return InvalidParameter;
4021
4022     stat = GdipGetMetafileHeaderFromEmf(hemf, &header);
4023     if (stat != Ok)
4024         return stat;
4025
4026     *metafile = heap_alloc_zero(sizeof(GpMetafile));
4027     if (!*metafile)
4028         return OutOfMemory;
4029
4030     (*metafile)->image.type = ImageTypeMetafile;
4031     (*metafile)->image.format = ImageFormatEMF;
4032     (*metafile)->image.frame_count = 1;
4033     (*metafile)->image.xres = header.DpiX;
4034     (*metafile)->image.yres = header.DpiY;
4035     (*metafile)->bounds.X = (REAL)header.u.EmfHeader.rclFrame.left / 2540.0 * header.DpiX;
4036     (*metafile)->bounds.Y = (REAL)header.u.EmfHeader.rclFrame.top / 2540.0 * header.DpiY;
4037     (*metafile)->bounds.Width = (REAL)(header.u.EmfHeader.rclFrame.right - header.u.EmfHeader.rclFrame.left)
4038                                 / 2540.0 * header.DpiX;
4039     (*metafile)->bounds.Height = (REAL)(header.u.EmfHeader.rclFrame.bottom - header.u.EmfHeader.rclFrame.top)
4040                                  / 2540.0 * header.DpiY;
4041     (*metafile)->unit = UnitPixel;
4042     (*metafile)->metafile_type = header.Type;
4043     (*metafile)->hemf = hemf;
4044     (*metafile)->preserve_hemf = !delete;
4045     list_init(&(*metafile)->containers);
4046
4047     TRACE("<-- %p\n", *metafile);
4048
4049     return Ok;
4050 }
4051
4052 GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE hwmf, BOOL delete,
4053     GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
4054 {
4055     UINT read;
4056     BYTE *copy;
4057     HENHMETAFILE hemf;
4058     GpStatus retval = Ok;
4059
4060     TRACE("(%p, %d, %p, %p)\n", hwmf, delete, placeable, metafile);
4061
4062     if(!hwmf || !metafile)
4063         return InvalidParameter;
4064
4065     *metafile = NULL;
4066     read = GetMetaFileBitsEx(hwmf, 0, NULL);
4067     if(!read)
4068         return GenericError;
4069     copy = heap_alloc_zero(read);
4070     GetMetaFileBitsEx(hwmf, read, copy);
4071
4072     hemf = SetWinMetaFileBits(read, copy, NULL, NULL);
4073     heap_free(copy);
4074
4075     /* FIXME: We should store and use hwmf instead of converting to hemf */
4076     retval = GdipCreateMetafileFromEmf(hemf, TRUE, metafile);
4077
4078     if (retval == Ok)
4079     {
4080         if (placeable)
4081         {
4082             (*metafile)->image.xres = (REAL)placeable->Inch;
4083             (*metafile)->image.yres = (REAL)placeable->Inch;
4084             (*metafile)->bounds.X = ((REAL)placeable->BoundingBox.Left) / ((REAL)placeable->Inch);
4085             (*metafile)->bounds.Y = ((REAL)placeable->BoundingBox.Top) / ((REAL)placeable->Inch);
4086             (*metafile)->bounds.Width = (REAL)(placeable->BoundingBox.Right -
4087                                                placeable->BoundingBox.Left);
4088             (*metafile)->bounds.Height = (REAL)(placeable->BoundingBox.Bottom -
4089                                                 placeable->BoundingBox.Top);
4090             (*metafile)->metafile_type = MetafileTypeWmfPlaceable;
4091         }
4092         else
4093             (*metafile)->metafile_type = MetafileTypeWmf;
4094         (*metafile)->image.format = ImageFormatWMF;
4095
4096         if (delete) DeleteMetaFile(hwmf);
4097     }
4098     else
4099         DeleteEnhMetaFile(hemf);
4100     return retval;
4101 }
4102
4103 GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR *file,
4104     GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
4105 {
4106     HMETAFILE hmf;
4107     HENHMETAFILE emf;
4108
4109     TRACE("(%s, %p, %p)\n", debugstr_w(file), placeable, metafile);
4110
4111     hmf = GetMetaFileW(file);
4112     if(hmf)
4113         return GdipCreateMetafileFromWmf(hmf, TRUE, placeable, metafile);
4114
4115     emf = GetEnhMetaFileW(file);
4116     if(emf)
4117         return GdipCreateMetafileFromEmf(emf, TRUE, metafile);
4118
4119     return GenericError;
4120 }
4121
4122 GpStatus WINGDIPAPI GdipCreateMetafileFromFile(GDIPCONST WCHAR *file,
4123     GpMetafile **metafile)
4124 {
4125     GpStatus status;
4126     IStream *stream;
4127
4128     TRACE("(%p, %p)\n", file, metafile);
4129
4130     if (!file || !metafile) return InvalidParameter;
4131
4132     *metafile = NULL;
4133
4134     status = GdipCreateStreamOnFile(file, GENERIC_READ, &stream);
4135     if (status == Ok)
4136     {
4137         status = GdipCreateMetafileFromStream(stream, metafile);
4138         IStream_Release(stream);
4139     }
4140     return status;
4141 }
4142
4143 GpStatus WINGDIPAPI GdipCreateMetafileFromStream(IStream *stream,
4144     GpMetafile **metafile)
4145 {
4146     GpStatus stat;
4147
4148     TRACE("%p %p\n", stream, metafile);
4149
4150     stat = GdipLoadImageFromStream(stream, (GpImage **)metafile);
4151     if (stat != Ok) return stat;
4152
4153     if ((*metafile)->image.type != ImageTypeMetafile)
4154     {
4155         GdipDisposeImage(&(*metafile)->image);
4156         *metafile = NULL;
4157         return GenericError;
4158     }
4159
4160     return Ok;
4161 }
4162
4163 GpStatus WINGDIPAPI GdipGetMetafileDownLevelRasterizationLimit(GDIPCONST GpMetafile *metafile,
4164     UINT *limitDpi)
4165 {
4166     TRACE("(%p,%p)\n", metafile, limitDpi);
4167
4168     if (!metafile || !limitDpi)
4169         return InvalidParameter;
4170
4171     if (!metafile->record_dc)
4172         return WrongState;
4173
4174     *limitDpi = metafile->limit_dpi;
4175
4176     return Ok;
4177 }
4178
4179 GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit(GpMetafile *metafile,
4180     UINT limitDpi)
4181 {
4182     TRACE("(%p,%u)\n", metafile, limitDpi);
4183
4184     if (limitDpi == 0)
4185         limitDpi = 96;
4186
4187     if (!metafile || limitDpi < 10)
4188         return InvalidParameter;
4189
4190     if (!metafile->record_dc)
4191         return WrongState;
4192
4193     metafile->limit_dpi = limitDpi;
4194
4195     return Ok;
4196 }
4197
4198 GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
4199     GpMetafile* metafile, BOOL* succ, EmfType emfType,
4200     const WCHAR* description, GpMetafile** out_metafile)
4201 {
4202     static int calls;
4203
4204     TRACE("(%p,%p,%p,%u,%s,%p)\n", ref, metafile, succ, emfType,
4205         debugstr_w(description), out_metafile);
4206
4207     if(!ref || !metafile || !out_metafile || emfType < EmfTypeEmfOnly || emfType > EmfTypeEmfPlusDual)
4208         return InvalidParameter;
4209
4210     if(succ)
4211         *succ = FALSE;
4212     *out_metafile = NULL;
4213
4214     if(!(calls++))
4215         FIXME("not implemented\n");
4216
4217     return NotImplemented;
4218 }
4219
4220 GpStatus WINGDIPAPI GdipEmfToWmfBits(HENHMETAFILE hemf, UINT cbData16,
4221     LPBYTE pData16, INT iMapMode, INT eFlags)
4222 {
4223     FIXME("(%p, %d, %p, %d, %d): stub\n", hemf, cbData16, pData16, iMapMode, eFlags);
4224     return NotImplemented;
4225 }
4226
4227 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
4228                             HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
4229                             MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
4230                             GpMetafile **metafile)
4231 {
4232     FIXME("%s %p %d %s %d %s %p stub!\n", debugstr_w(fileName), hdc, type, debugstr_rectf(pFrameRect),
4233                                  frameUnit, debugstr_w(desc), metafile);
4234
4235     return NotImplemented;
4236 }
4237
4238 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
4239                             GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
4240                             GDIPCONST WCHAR *desc, GpMetafile **metafile)
4241 {
4242     FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
4243                                  frameUnit, debugstr_w(desc), metafile);
4244
4245     return NotImplemented;
4246 }
4247
4248 /*****************************************************************************
4249  * GdipConvertToEmfPlusToFile [GDIPLUS.@]
4250  */
4251
4252 GpStatus WINGDIPAPI GdipConvertToEmfPlusToFile(const GpGraphics* refGraphics,
4253                                                GpMetafile* metafile, BOOL* conversionSuccess,
4254                                                const WCHAR* filename, EmfType emfType,
4255                                                const WCHAR* description, GpMetafile** out_metafile)
4256 {
4257     FIXME("stub: %p, %p, %p, %p, %u, %p, %p\n", refGraphics, metafile, conversionSuccess, filename, emfType, description, out_metafile);
4258     return NotImplemented;
4259 }
4260
4261 static GpStatus METAFILE_CreateCompressedImageStream(GpImage *image, IStream **stream, DWORD *size)
4262 {
4263     LARGE_INTEGER zero;
4264     STATSTG statstg;
4265     GpStatus stat;
4266     HRESULT hr;
4267
4268     *size = 0;
4269
4270     hr = CreateStreamOnHGlobal(NULL, TRUE, stream);
4271     if (FAILED(hr)) return hresult_to_status(hr);
4272
4273     stat = encode_image_png(image, *stream, NULL);
4274     if (stat != Ok)
4275     {
4276         IStream_Release(*stream);
4277         return stat;
4278     }
4279
4280     hr = IStream_Stat(*stream, &statstg, 1);
4281     if (FAILED(hr))
4282     {
4283         IStream_Release(*stream);
4284         return hresult_to_status(hr);
4285     }
4286     *size = statstg.cbSize.u.LowPart;
4287
4288     zero.QuadPart = 0;
4289     hr = IStream_Seek(*stream, zero, STREAM_SEEK_SET, NULL);
4290     if (FAILED(hr))
4291     {
4292         IStream_Release(*stream);
4293         return hresult_to_status(hr);
4294     }
4295
4296     return Ok;
4297 }
4298
4299 static GpStatus METAFILE_FillEmfPlusBitmap(EmfPlusBitmap *record, IStream *stream, DWORD size)
4300 {
4301     HRESULT hr;
4302
4303     record->Width = 0;
4304     record->Height = 0;
4305     record->Stride = 0;
4306     record->PixelFormat = 0;
4307     record->Type = BitmapDataTypeCompressed;
4308
4309     hr = IStream_Read(stream, record->BitmapData, size, NULL);
4310     if (FAILED(hr)) return hresult_to_status(hr);
4311     return Ok;
4312 }
4313
4314 static GpStatus METAFILE_AddImageObject(GpMetafile *metafile, GpImage *image, DWORD *id)
4315 {
4316     EmfPlusObject *object_record;
4317     GpStatus stat;
4318     DWORD size;
4319
4320     *id = -1;
4321
4322     if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
4323         return Ok;
4324
4325     if (image->type == ImageTypeBitmap)
4326     {
4327         IStream *stream;
4328         DWORD aligned_size;
4329
4330         stat = METAFILE_CreateCompressedImageStream(image, &stream, &size);
4331         if (stat != Ok) return stat;
4332         aligned_size = (size + 3) & ~3;
4333
4334         stat = METAFILE_AllocateRecord(metafile,
4335                 FIELD_OFFSET(EmfPlusObject, ObjectData.image.ImageData.bitmap.BitmapData[aligned_size]),
4336                 (void**)&object_record);
4337         if (stat != Ok)
4338         {
4339             IStream_Release(stream);
4340             return stat;
4341         }
4342         memset(object_record->ObjectData.image.ImageData.bitmap.BitmapData + size, 0, aligned_size - size);
4343
4344         *id = METAFILE_AddObjectId(metafile);
4345         object_record->Header.Type = EmfPlusRecordTypeObject;
4346         object_record->Header.Flags = *id | ObjectTypeImage << 8;
4347         object_record->ObjectData.image.Version = VERSION_MAGIC2;
4348         object_record->ObjectData.image.Type = ImageDataTypeBitmap;
4349
4350         stat = METAFILE_FillEmfPlusBitmap(&object_record->ObjectData.image.ImageData.bitmap, stream, size);
4351         IStream_Release(stream);
4352         if (stat != Ok) METAFILE_RemoveLastRecord(metafile, &object_record->Header);
4353         return stat;
4354     }
4355     else if (image->type == ImageTypeMetafile)
4356     {
4357         HENHMETAFILE hemf = ((GpMetafile*)image)->hemf;
4358         EmfPlusMetafile *metafile_record;
4359
4360         if (!hemf) return InvalidParameter;
4361
4362         size = GetEnhMetaFileBits(hemf, 0, NULL);
4363         if (!size) return GenericError;
4364
4365         stat  = METAFILE_AllocateRecord(metafile,
4366                 FIELD_OFFSET(EmfPlusObject, ObjectData.image.ImageData.metafile.MetafileData[size]),
4367                 (void**)&object_record);
4368         if (stat != Ok) return stat;
4369
4370         *id = METAFILE_AddObjectId(metafile);
4371         object_record->Header.Type = EmfPlusRecordTypeObject;
4372         object_record->Header.Flags = *id | ObjectTypeImage << 8;
4373         object_record->ObjectData.image.Version = VERSION_MAGIC2;
4374         object_record->ObjectData.image.Type = ImageDataTypeMetafile;
4375         metafile_record = &object_record->ObjectData.image.ImageData.metafile;
4376         metafile_record->Type = ((GpMetafile*)image)->metafile_type;
4377         metafile_record->MetafileDataSize = size;
4378         if (GetEnhMetaFileBits(hemf, size, metafile_record->MetafileData) != size)
4379         {
4380             METAFILE_RemoveLastRecord(metafile, &object_record->Header);
4381             return GenericError;
4382         }
4383         return Ok;
4384     }
4385     else
4386     {
4387         FIXME("not supported image type (%d)\n", image->type);
4388         return NotImplemented;
4389     }
4390 }
4391
4392 static GpStatus METAFILE_AddImageAttributesObject(GpMetafile *metafile, const GpImageAttributes *attrs, DWORD *id)
4393 {
4394     EmfPlusObject *object_record;
4395     EmfPlusImageAttributes *attrs_record;
4396     GpStatus stat;
4397
4398     *id = -1;
4399
4400     if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
4401         return Ok;
4402
4403     if (!attrs)
4404         return Ok;
4405
4406     stat = METAFILE_AllocateRecord(metafile,
4407             FIELD_OFFSET(EmfPlusObject, ObjectData.image_attributes) + sizeof(EmfPlusImageAttributes),
4408             (void**)&object_record);
4409     if (stat != Ok) return stat;
4410
4411     *id = METAFILE_AddObjectId(metafile);
4412     object_record->Header.Type = EmfPlusRecordTypeObject;
4413     object_record->Header.Flags = *id | (ObjectTypeImageAttributes << 8);
4414     attrs_record = &object_record->ObjectData.image_attributes;
4415     attrs_record->Version = VERSION_MAGIC2;
4416     attrs_record->Reserved1 = 0;
4417     attrs_record->WrapMode = attrs->wrap;
4418     attrs_record->ClampColor = attrs->outside_color;
4419     attrs_record->ObjectClamp = attrs->clamp;
4420     attrs_record->Reserved2 = 0;
4421     return Ok;
4422 }
4423
4424 GpStatus METAFILE_DrawImagePointsRect(GpMetafile *metafile, GpImage *image,
4425      GDIPCONST GpPointF *points, INT count, REAL srcx, REAL srcy, REAL srcwidth,
4426      REAL srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
4427      DrawImageAbort callback, VOID *callbackData)
4428 {
4429     EmfPlusDrawImagePoints *draw_image_record;
4430     DWORD image_id, attributes_id;
4431     GpStatus stat;
4432
4433     if (count != 3) return InvalidParameter;
4434
4435     if (metafile->metafile_type == MetafileTypeEmf)
4436     {
4437         FIXME("MetafileTypeEmf metafiles not supported\n");
4438         return NotImplemented;
4439     }
4440     else
4441         FIXME("semi-stub\n");
4442
4443     if (!imageAttributes)
4444     {
4445         stat = METAFILE_AddImageObject(metafile, image, &image_id);
4446     }
4447     else if (image->type == ImageTypeBitmap)
4448     {
4449         INT width = ((GpBitmap*)image)->width;
4450         INT height = ((GpBitmap*)image)->height;
4451         GpGraphics *graphics;
4452         GpBitmap *bitmap;
4453
4454         stat = GdipCreateBitmapFromScan0(width, height,
4455                 0, PixelFormat32bppARGB, NULL, &bitmap);
4456         if (stat != Ok) return stat;
4457
4458         stat = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
4459         if (stat != Ok)
4460         {
4461             GdipDisposeImage((GpImage*)bitmap);
4462             return stat;
4463         }
4464
4465         stat = GdipDrawImageRectRectI(graphics, image, 0, 0, width, height,
4466                 0, 0, width, height, UnitPixel, imageAttributes, NULL, NULL);
4467         GdipDeleteGraphics(graphics);
4468         if (stat != Ok)
4469         {
4470             GdipDisposeImage((GpImage*)bitmap);
4471             return stat;
4472         }
4473
4474         stat = METAFILE_AddImageObject(metafile, (GpImage*)bitmap, &image_id);
4475         GdipDisposeImage((GpImage*)bitmap);
4476     }
4477     else
4478     {
4479         FIXME("imageAttributes not supported (image type %d)\n", image->type);
4480         return NotImplemented;
4481     }
4482     if (stat != Ok) return stat;
4483
4484     stat = METAFILE_AddImageAttributesObject(metafile, imageAttributes, &attributes_id);
4485     if (stat != Ok) return stat;
4486
4487     stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusDrawImagePoints), (void**)&draw_image_record);
4488     if (stat != Ok) return stat;
4489     draw_image_record->Header.Type = EmfPlusRecordTypeDrawImagePoints;
4490     draw_image_record->Header.Flags = image_id;
4491     draw_image_record->ImageAttributesID = attributes_id;
4492     draw_image_record->SrcUnit = UnitPixel;
4493     draw_image_record->SrcRect.X = units_to_pixels(srcx, srcUnit, metafile->image.xres);
4494     draw_image_record->SrcRect.Y = units_to_pixels(srcy, srcUnit, metafile->image.yres);
4495     draw_image_record->SrcRect.Width = units_to_pixels(srcwidth, srcUnit, metafile->image.xres);
4496     draw_image_record->SrcRect.Height = units_to_pixels(srcheight, srcUnit, metafile->image.yres);
4497     draw_image_record->count = 3;
4498     memcpy(draw_image_record->PointData.pointsF, points, 3 * sizeof(*points));
4499     METAFILE_WriteRecords(metafile);
4500     return Ok;
4501 }
4502
4503 GpStatus METAFILE_AddSimpleProperty(GpMetafile *metafile, SHORT prop, SHORT val)
4504 {
4505     EmfPlusRecordHeader *record;
4506     GpStatus stat;
4507
4508     if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
4509         return Ok;
4510
4511     stat = METAFILE_AllocateRecord(metafile, sizeof(*record), (void**)&record);
4512     if (stat != Ok) return stat;
4513
4514     record->Type = prop;
4515     record->Flags = val;
4516
4517     METAFILE_WriteRecords(metafile);
4518     return Ok;
4519 }
4520
4521 static GpStatus METAFILE_AddPathObject(GpMetafile *metafile, GpPath *path, DWORD *id)
4522 {
4523     EmfPlusObject *object_record;
4524     GpStatus stat;
4525     DWORD size;
4526
4527     *id = -1;
4528     if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
4529         return Ok;
4530
4531     size = write_path_data(path, NULL);
4532     stat = METAFILE_AllocateRecord(metafile,
4533             FIELD_OFFSET(EmfPlusObject, ObjectData.path) + size,
4534             (void**)&object_record);
4535     if (stat != Ok) return stat;
4536
4537     *id = METAFILE_AddObjectId(metafile);
4538     object_record->Header.Type = EmfPlusRecordTypeObject;
4539     object_record->Header.Flags = *id | ObjectTypePath << 8;
4540     write_path_data(path, &object_record->ObjectData.path);
4541     return Ok;
4542 }
4543
4544 static GpStatus METAFILE_AddPenObject(GpMetafile *metafile, GpPen *pen, DWORD *id)
4545 {
4546     DWORD i, data_flags, pen_data_size, brush_size;
4547     EmfPlusObject *object_record;
4548     EmfPlusPenData *pen_data;
4549     GpStatus stat;
4550     BOOL result;
4551
4552     *id = -1;
4553     if (metafile->metafile_type != MetafileTypeEmfPlusOnly && metafile->metafile_type != MetafileTypeEmfPlusDual)
4554         return Ok;
4555
4556     data_flags = 0;
4557     pen_data_size = FIELD_OFFSET(EmfPlusPenData, OptionalData);
4558
4559     GdipIsMatrixIdentity(&pen->transform, &result);
4560     if (!result)
4561     {
4562         data_flags |= PenDataTransform;
4563         pen_data_size += sizeof(EmfPlusTransformMatrix);
4564     }
4565     if (pen->startcap != LineCapFlat)
4566     {
4567         data_flags |= PenDataStartCap;
4568         pen_data_size += sizeof(DWORD);
4569     }
4570     if (pen->endcap != LineCapFlat)
4571     {
4572         data_flags |= PenDataEndCap;
4573         pen_data_size += sizeof(DWORD);
4574     }
4575     if (pen->join != LineJoinMiter)
4576     {
4577         data_flags |= PenDataJoin;
4578         pen_data_size += sizeof(DWORD);
4579     }
4580     if (pen->miterlimit != 10.0)
4581     {
4582         data_flags |= PenDataMiterLimit;
4583         pen_data_size += sizeof(REAL);
4584     }
4585     if (pen->style != GP_DEFAULT_PENSTYLE)
4586     {
4587         data_flags |= PenDataLineStyle;
4588         pen_data_size += sizeof(DWORD);
4589     }
4590     if (pen->dashcap != DashCapFlat)
4591     {
4592         data_flags |= PenDataDashedLineCap;
4593         pen_data_size += sizeof(DWORD);
4594     }
4595     data_flags |= PenDataDashedLineOffset;
4596     pen_data_size += sizeof(REAL);
4597     if (pen->numdashes)
4598     {
4599         data_flags |= PenDataDashedLine;
4600         pen_data_size += sizeof(DWORD) + pen->numdashes*sizeof(REAL);
4601     }
4602     if (pen->align != PenAlignmentCenter)
4603     {
4604         data_flags |= PenDataNonCenter;
4605         pen_data_size += sizeof(DWORD);
4606     }
4607     /* TODO: Add support for PenDataCompoundLine */
4608     if (pen->customstart)
4609     {
4610         FIXME("ignoring custom start cup\n");
4611     }
4612     if (pen->customend)
4613     {
4614         FIXME("ignoring custom end cup\n");
4615     }
4616
4617     stat = METAFILE_PrepareBrushData(pen->brush, &brush_size);
4618     if (stat != Ok) return stat;
4619
4620     stat = METAFILE_AllocateRecord(metafile,
4621             FIELD_OFFSET(EmfPlusObject, ObjectData.pen.data) + pen_data_size + brush_size,
4622             (void**)&object_record);
4623     if (stat != Ok) return stat;
4624
4625     *id = METAFILE_AddObjectId(metafile);
4626     object_record->Header.Type = EmfPlusRecordTypeObject;
4627     object_record->Header.Flags = *id | ObjectTypePen << 8;
4628     object_record->ObjectData.pen.Version = VERSION_MAGIC2;
4629     object_record->ObjectData.pen.Type = 0;
4630
4631     pen_data = (EmfPlusPenData*)object_record->ObjectData.pen.data;
4632     pen_data->PenDataFlags = data_flags;
4633     pen_data->PenUnit = pen->unit;
4634     pen_data->PenWidth = pen->width;
4635
4636     i = 0;
4637     if (data_flags & PenDataTransform)
4638     {
4639         EmfPlusTransformMatrix *m = (EmfPlusTransformMatrix*)(pen_data->OptionalData + i);
4640         memcpy(m, &pen->transform, sizeof(*m));
4641         i += sizeof(EmfPlusTransformMatrix);
4642     }
4643     if (data_flags & PenDataStartCap)
4644     {
4645         *(DWORD*)(pen_data->OptionalData + i) = pen->startcap;
4646         i += sizeof(DWORD);
4647     }
4648     if (data_flags & PenDataEndCap)
4649     {
4650         *(DWORD*)(pen_data->OptionalData + i) = pen->endcap;
4651         i += sizeof(DWORD);
4652     }
4653     if (data_flags & PenDataJoin)
4654     {
4655         *(DWORD*)(pen_data->OptionalData + i) = pen->join;
4656         i += sizeof(DWORD);
4657     }
4658     if (data_flags & PenDataMiterLimit)
4659     {
4660         *(REAL*)(pen_data->OptionalData + i) = pen->miterlimit;
4661         i += sizeof(REAL);
4662     }
4663     if (data_flags & PenDataLineStyle)
4664     {
4665         switch (pen->style & PS_STYLE_MASK)
4666         {
4667         case PS_SOLID: *(DWORD*)(pen_data->OptionalData + i) = LineStyleSolid; break;
4668         case PS_DASH: *(DWORD*)(pen_data->OptionalData + i) = LineStyleDash; break;
4669         case PS_DOT: *(DWORD*)(pen_data->OptionalData + i) = LineStyleDot; break;
4670         case PS_DASHDOT: *(DWORD*)(pen_data->OptionalData + i) = LineStyleDashDot; break;
4671         case PS_DASHDOTDOT: *(DWORD*)(pen_data->OptionalData + i) = LineStyleDashDotDot; break;
4672         default: *(DWORD*)(pen_data->OptionalData + i) = LineStyleCustom; break;
4673         }
4674         i += sizeof(DWORD);
4675     }
4676     if (data_flags & PenDataDashedLineCap)
4677     {
4678         *(DWORD*)(pen_data->OptionalData + i) = pen->dashcap;
4679         i += sizeof(DWORD);
4680     }
4681     if (data_flags & PenDataDashedLineOffset)
4682     {
4683         *(REAL*)(pen_data->OptionalData + i) = pen->offset;
4684         i += sizeof(REAL);
4685     }
4686     if (data_flags & PenDataDashedLine)
4687     {
4688         int j;
4689
4690         *(DWORD*)(pen_data->OptionalData + i) = pen->numdashes;
4691         i += sizeof(DWORD);
4692
4693         for (j=0; j<pen->numdashes; j++)
4694         {
4695             *(REAL*)(pen_data->OptionalData + i) = pen->dashes[j];
4696             i += sizeof(REAL);
4697         }
4698     }
4699     if (data_flags & PenDataNonCenter)
4700     {
4701         *(REAL*)(pen_data->OptionalData + i) = pen->align;
4702         i += sizeof(DWORD);
4703     }
4704
4705     METAFILE_FillBrushData(pen->brush,
4706             (EmfPlusBrush*)(object_record->ObjectData.pen.data + pen_data_size));
4707     return Ok;
4708 }
4709
4710 GpStatus METAFILE_DrawPath(GpMetafile *metafile, GpPen *pen, GpPath *path)
4711 {
4712     EmfPlusDrawPath *draw_path_record;
4713     DWORD path_id;
4714     DWORD pen_id;
4715     GpStatus stat;
4716
4717     if (metafile->metafile_type == MetafileTypeEmf)
4718     {
4719         FIXME("stub!\n");
4720         return NotImplemented;
4721     }
4722
4723     stat = METAFILE_AddPenObject(metafile, pen, &pen_id);
4724     if (stat != Ok) return stat;
4725
4726     stat = METAFILE_AddPathObject(metafile, path, &path_id);
4727     if (stat != Ok) return stat;
4728
4729     stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusDrawPath), (void**)&draw_path_record);
4730     if (stat != Ok) return stat;
4731     draw_path_record->Header.Type = EmfPlusRecordTypeDrawPath;
4732     draw_path_record->Header.Flags = path_id;
4733     draw_path_record->PenId = pen_id;
4734
4735     METAFILE_WriteRecords(metafile);
4736     return Ok;
4737 }
4738
4739 GpStatus METAFILE_FillPath(GpMetafile *metafile, GpBrush *brush, GpPath *path)
4740 {
4741     EmfPlusFillPath *fill_path_record;
4742     DWORD brush_id = -1, path_id;
4743     BOOL inline_color;
4744     GpStatus stat;
4745
4746     if (metafile->metafile_type == MetafileTypeEmf)
4747     {
4748         FIXME("stub!\n");
4749         return NotImplemented;
4750     }
4751
4752     inline_color = brush->bt == BrushTypeSolidColor;
4753     if (!inline_color)
4754     {
4755         stat = METAFILE_AddBrushObject(metafile, brush, &brush_id);
4756         if (stat != Ok) return stat;
4757     }
4758
4759     stat = METAFILE_AddPathObject(metafile, path, &path_id);
4760     if (stat != Ok) return stat;
4761
4762     stat = METAFILE_AllocateRecord(metafile,
4763             sizeof(EmfPlusFillPath), (void**)&fill_path_record);
4764     if (stat != Ok) return stat;
4765     fill_path_record->Header.Type = EmfPlusRecordTypeFillPath;
4766     if (inline_color)
4767     {
4768         fill_path_record->Header.Flags = 0x8000 | path_id;
4769         fill_path_record->data.Color = ((GpSolidFill *)brush)->color;
4770     }
4771     else
4772     {
4773         fill_path_record->Header.Flags = path_id;
4774         fill_path_record->data.BrushId = brush_id;
4775     }
4776
4777     METAFILE_WriteRecords(metafile);
4778     return Ok;
4779 }
4780
4781 static GpStatus METAFILE_AddFontObject(GpMetafile *metafile, GDIPCONST GpFont *font, DWORD *id)
4782 {
4783     EmfPlusObject *object_record;
4784     EmfPlusFont *font_record;
4785     GpStatus stat;
4786     INT fn_len;
4787     INT style;
4788
4789     *id = -1;
4790
4791     if (metafile->metafile_type != MetafileTypeEmfPlusOnly &&
4792             metafile->metafile_type != MetafileTypeEmfPlusDual)
4793         return Ok;
4794
4795     /* The following cast is ugly, but GdipGetFontStyle does treat
4796        its first parameter as const. */
4797     stat = GdipGetFontStyle((GpFont*)font, &style);
4798     if (stat != Ok)
4799         return stat;
4800
4801     fn_len = lstrlenW(font->family->FamilyName);
4802     stat = METAFILE_AllocateRecord(metafile,
4803         FIELD_OFFSET(EmfPlusObject, ObjectData.font.FamilyName[(fn_len + 1) & ~1]),
4804         (void**)&object_record);
4805     if (stat != Ok)
4806         return stat;
4807
4808     *id = METAFILE_AddObjectId(metafile);
4809
4810     object_record->Header.Type = EmfPlusRecordTypeObject;
4811     object_record->Header.Flags = *id | ObjectTypeFont << 8;
4812
4813     font_record = &object_record->ObjectData.font;
4814     font_record->Version = VERSION_MAGIC2;
4815     font_record->EmSize = font->emSize;
4816     font_record->SizeUnit = font->unit;
4817     font_record->FontStyleFlags = style;
4818     font_record->Reserved = 0;
4819     font_record->Length = fn_len;
4820
4821     memcpy(font_record->FamilyName, font->family->FamilyName,
4822         fn_len * sizeof(*font->family->FamilyName));
4823
4824     return Ok;
4825 }
4826
4827 GpStatus METAFILE_DrawDriverString(GpMetafile *metafile, GDIPCONST UINT16 *text, INT length,
4828     GDIPCONST GpFont *font, GDIPCONST GpStringFormat *format, GDIPCONST GpBrush *brush,
4829     GDIPCONST PointF *positions, INT flags, GDIPCONST GpMatrix *matrix)
4830 {
4831     DWORD brush_id;
4832     DWORD font_id;
4833     DWORD alloc_size;
4834     GpStatus stat;
4835     EmfPlusDrawDriverString *draw_string_record;
4836     BYTE *cursor;
4837     BOOL inline_color;
4838     BOOL include_matrix = FALSE;
4839
4840     if (length <= 0)
4841         return InvalidParameter;
4842
4843     if (metafile->metafile_type != MetafileTypeEmfPlusOnly &&
4844             metafile->metafile_type != MetafileTypeEmfPlusDual)
4845     {
4846         FIXME("metafile type not supported: %i\n", metafile->metafile_type);
4847         return NotImplemented;
4848     }
4849
4850     stat = METAFILE_AddFontObject(metafile, font, &font_id);
4851     if (stat != Ok)
4852         return stat;
4853
4854     inline_color = (brush->bt == BrushTypeSolidColor);
4855     if (!inline_color)
4856     {
4857         stat = METAFILE_AddBrushObject(metafile, brush, &brush_id);
4858         if (stat != Ok)
4859             return stat;
4860     }
4861
4862     if (matrix)
4863     {
4864         BOOL identity;
4865
4866         stat = GdipIsMatrixIdentity(matrix, &identity);
4867         if (stat != Ok)
4868            return stat;
4869
4870         include_matrix = !identity;
4871     }
4872
4873     alloc_size = FIELD_OFFSET(EmfPlusDrawDriverString, VariableData) +
4874         length * (sizeof(*text) + sizeof(*positions));
4875
4876     if (include_matrix)
4877         alloc_size += sizeof(*matrix);
4878
4879     /* Pad record to DWORD alignment. */
4880     alloc_size = (alloc_size + 3) & ~3;
4881
4882     stat = METAFILE_AllocateRecord(metafile, alloc_size, (void**)&draw_string_record);
4883     if (stat != Ok)
4884         return stat;
4885
4886     draw_string_record->Header.Type = EmfPlusRecordTypeDrawDriverString;
4887     draw_string_record->Header.Flags = font_id;
4888     draw_string_record->DriverStringOptionsFlags = flags;
4889     draw_string_record->MatrixPresent = include_matrix;
4890     draw_string_record->GlyphCount = length;
4891
4892     if (inline_color)
4893     {
4894         draw_string_record->Header.Flags |= 0x8000;
4895         draw_string_record->brush.Color = ((GpSolidFill*)brush)->color;
4896     }
4897     else
4898         draw_string_record->brush.BrushId = brush_id;
4899
4900     cursor = &draw_string_record->VariableData[0];
4901
4902     memcpy(cursor, text, length * sizeof(*text));
4903     cursor += length * sizeof(*text);
4904
4905     if (flags & DriverStringOptionsRealizedAdvance)
4906     {
4907         static BOOL fixme_written = FALSE;
4908
4909         /* Native never writes DriverStringOptionsRealizedAdvance. Instead,
4910            in the case of RealizedAdvance, each glyph position is computed
4911            and serialized.
4912
4913            While native GDI+ is capable of playing back metafiles with this
4914            flag set, it is possible that some application might rely on
4915            metafiles produced from GDI+ not setting this flag. Ideally we
4916            would also compute the position of each glyph here, serialize those
4917            values, and not set DriverStringOptionsRealizedAdvance. */
4918         if (!fixme_written)
4919         {
4920             fixme_written = TRUE;
4921             FIXME("serializing RealizedAdvance flag and single GlyphPos with padding\n");
4922         }
4923
4924         *((PointF*)cursor) = *positions;
4925     }
4926     else
4927         memcpy(cursor, positions, length * sizeof(*positions));
4928
4929     if (include_matrix)
4930     {
4931         cursor += length * sizeof(*positions);
4932         memcpy(cursor, matrix, sizeof(*matrix));
4933     }
4934
4935     METAFILE_WriteRecords(metafile);
4936
4937     return Ok;
4938 }
4939
4940 GpStatus METAFILE_FillRegion(GpMetafile* metafile, GpBrush* brush, GpRegion* region)
4941 {
4942     GpStatus stat;
4943     DWORD brush_id;
4944     DWORD region_id;
4945     EmfPlusFillRegion *fill_region_record;
4946     BOOL inline_color;
4947
4948     if (metafile->metafile_type != MetafileTypeEmfPlusOnly &&
4949             metafile->metafile_type != MetafileTypeEmfPlusDual)
4950     {
4951         FIXME("metafile type not supported: %i\n", metafile->metafile_type);
4952         return NotImplemented;
4953     }
4954
4955     inline_color = (brush->bt == BrushTypeSolidColor);
4956     if (!inline_color)
4957     {
4958         stat = METAFILE_AddBrushObject(metafile, brush, &brush_id);
4959         if (stat != Ok)
4960             return stat;
4961     }
4962
4963     stat = METAFILE_AddRegionObject(metafile, region, &region_id);
4964     if (stat != Ok)
4965         return stat;
4966
4967     stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusFillRegion),
4968         (void**)&fill_region_record);
4969     if (stat != Ok)
4970         return stat;
4971
4972     fill_region_record->Header.Type = EmfPlusRecordTypeFillRegion;
4973     fill_region_record->Header.Flags = region_id;
4974
4975     if (inline_color)
4976     {
4977         fill_region_record->Header.Flags |= 0x8000;
4978         fill_region_record->data.Color = ((GpSolidFill*)brush)->color;
4979     }
4980     else
4981         fill_region_record->data.BrushId = brush_id;
4982
4983     METAFILE_WriteRecords(metafile);
4984
4985     return Ok;
4986 }