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
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "wingdi.h"
  25 #include "wine/unicode.h"
  26
  27 #define COBJMACROS
  28 #include "objbase.h"
  29 #include "ocidl.h"
  30 #include "olectl.h"
  31 #include "ole2.h"
  32
  33 #include "winreg.h"
  34 #include "shlwapi.h"
  35
  36 #include "gdiplus.h"
  37 #include "gdiplus_private.h"
  38 #include "wine/debug.h"
  39 #include "wine/list.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  42
  43 typedef struct EmfPlusRecordHeader
  44 {
  45     WORD Type;
  46     WORD Flags;
  47     DWORD Size;
  48     DWORD DataSize;
  49 } EmfPlusRecordHeader;
  50
  51 typedef struct EmfPlusHeader
  52 {
  53     EmfPlusRecordHeader Header;
  54     DWORD Version;
  55     DWORD EmfPlusFlags;
  56     DWORD LogicalDpiX;
  57     DWORD LogicalDpiY;
  58 } EmfPlusHeader;
  59
  60 typedef struct EmfPlusFillRects
  61 {
  62     EmfPlusRecordHeader Header;
  63     DWORD BrushID;
  64     DWORD Count;
  65 } EmfPlusFillRects;
  66
  67 typedef struct EmfPlusSetPageTransform
  68 {
  69     EmfPlusRecordHeader Header;
  70     REAL PageScale;
  71 } EmfPlusSetPageTransform;
  72
  73 typedef struct EmfPlusRect
  74 {
  75     SHORT X;
  76     SHORT Y;
  77     SHORT Width;
  78     SHORT Height;
  79 } EmfPlusRect;
  80
  81 static GpStatus METAFILE_AllocateRecord(GpMetafile *metafile, DWORD size, void **result)
  82 {
  83     DWORD size_needed;
  84     EmfPlusRecordHeader *record;
  85
  86     if (!metafile->comment_data_size)
  87     {
  88         DWORD data_size = max(256, size * 2 + 4);
  89         metafile->comment_data = heap_alloc_zero(data_size);
  90
  91         if (!metafile->comment_data)
  92             return OutOfMemory;
  93
  94         memcpy(metafile->comment_data, "EMF+", 4);
  95
  96         metafile->comment_data_size = data_size;
  97         metafile->comment_data_length = 4;
  98     }
  99
 100     size_needed = size + metafile->comment_data_length;
 101
 102     if (size_needed > metafile->comment_data_size)
 103     {
 104         DWORD data_size = size_needed * 2;
 105         BYTE *new_data = heap_alloc_zero(data_size);
 106
 107         if (!new_data)
 108             return OutOfMemory;
 109
 110         memcpy(new_data, metafile->comment_data, metafile->comment_data_length);
 111
 112         metafile->comment_data_size = data_size;
 113         heap_free(metafile->comment_data);
 114         metafile->comment_data = new_data;
 115     }
 116
 117     *result = metafile->comment_data + metafile->comment_data_length;
 118     metafile->comment_data_length += size;
 119
 120     record = (EmfPlusRecordHeader*)*result;
 121     record->Size = size;
 122     record->DataSize = size - sizeof(EmfPlusRecordHeader);
 123
 124     return Ok;
 125 }
 126
 127 static void METAFILE_WriteRecords(GpMetafile *metafile)
 128 {
 129     if (metafile->comment_data_length > 4)
 130     {
 131         GdiComment(metafile->record_dc, metafile->comment_data_length, metafile->comment_data);
 132         metafile->comment_data_length = 4;
 133     }
 134 }
 135
 136 static GpStatus METAFILE_WriteHeader(GpMetafile *metafile, HDC hdc)
 137 {
 138     GpStatus stat;
 139
 140     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 141     {
 142         EmfPlusHeader *header;
 143
 144         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusHeader), (void**)&header);
 145         if (stat != Ok)
 146             return stat;
 147
 148         header->Header.Type = EmfPlusRecordTypeHeader;
 149
 150         if (metafile->metafile_type == MetafileTypeEmfPlusDual)
 151             header->Header.Flags = 1;
 152         else
 153             header->Header.Flags = 0;
 154
 155         header->Version = 0xDBC01002;
 156
 157         if (GetDeviceCaps(hdc, TECHNOLOGY) == DT_RASDISPLAY)
 158             header->EmfPlusFlags = 1;
 159         else
 160             header->EmfPlusFlags = 0;
 161
 162         header->LogicalDpiX = GetDeviceCaps(hdc, LOGPIXELSX);
 163         header->LogicalDpiY = GetDeviceCaps(hdc, LOGPIXELSY);
 164
 165         METAFILE_WriteRecords(metafile);
 166     }
 167
 168     return Ok;
 169 }
 170
 171 static GpStatus METAFILE_WriteEndOfFile(GpMetafile *metafile)
 172 {
 173     GpStatus stat;
 174
 175     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 176     {
 177         EmfPlusRecordHeader *record;
 178
 179         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusRecordHeader), (void**)&record);
 180         if (stat != Ok)
 181             return stat;
 182
 183         record->Type = EmfPlusRecordTypeEndOfFile;
 184         record->Flags = 0;
 185
 186         METAFILE_WriteRecords(metafile);
 187     }
 188
 189     return Ok;
 190 }
 191
 192 GpStatus WINGDIPAPI GdipRecordMetafile(HDC hdc, EmfType type, GDIPCONST GpRectF *frameRect,
 193                                        MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
 194 {
 195     HDC record_dc;
 196     REAL dpix, dpiy;
 197     REAL framerect_factor_x, framerect_factor_y;
 198     RECT rc;
 199     GpStatus stat;
 200
 201     TRACE("(%p %d %p %d %p %p)\n", hdc, type, frameRect, frameUnit, desc, metafile);
 202
 203     if (!hdc || type < EmfTypeEmfOnly || type > EmfTypeEmfPlusDual || !metafile)
 204         return InvalidParameter;
 205
 206     if (!frameRect)
 207     {
 208         FIXME("not implemented for NULL rect\n");
 209         return NotImplemented;
 210     }
 211
 212     dpix = (REAL)GetDeviceCaps(hdc, HORZRES) / GetDeviceCaps(hdc, HORZSIZE) * 25.4;
 213     dpiy = (REAL)GetDeviceCaps(hdc, VERTRES) / GetDeviceCaps(hdc, VERTSIZE) * 25.4;
 214
 215     switch (frameUnit)
 216     {
 217     case MetafileFrameUnitPixel:
 218         framerect_factor_x = 2540.0 / dpix;
 219         framerect_factor_y = 2540.0 / dpiy;
 220         break;
 221     case MetafileFrameUnitPoint:
 222         framerect_factor_x = framerect_factor_y = 2540.0 / 72.0;
 223         break;
 224     case MetafileFrameUnitInch:
 225         framerect_factor_x = framerect_factor_y = 2540.0;
 226         break;
 227     case MetafileFrameUnitDocument:
 228         framerect_factor_x = framerect_factor_y = 2540.0 / 300.0;
 229         break;
 230     case MetafileFrameUnitMillimeter:
 231         framerect_factor_x = framerect_factor_y = 100.0;
 232         break;
 233     case MetafileFrameUnitGdi:
 234         framerect_factor_x = framerect_factor_y = 1.0;
 235         break;
 236     default:
 237         return InvalidParameter;
 238     }
 239
 240     rc.left = framerect_factor_x * frameRect->X;
 241     rc.top = framerect_factor_y * frameRect->Y;
 242     rc.right = rc.left + framerect_factor_x * frameRect->Width;
 243     rc.bottom = rc.top + framerect_factor_y * frameRect->Height;
 244
 245     record_dc = CreateEnhMetaFileW(hdc, NULL, &rc, desc);
 246
 247     if (!record_dc)
 248         return GenericError;
 249
 250     *metafile = heap_alloc_zero(sizeof(GpMetafile));
 251     if(!*metafile)
 252     {
 253         DeleteEnhMetaFile(CloseEnhMetaFile(record_dc));
 254         return OutOfMemory;
 255     }
 256
 257     (*metafile)->image.type = ImageTypeMetafile;
 258     (*metafile)->image.picture = NULL;
 259     (*metafile)->image.flags   = ImageFlagsNone;
 260     (*metafile)->image.palette = NULL;
 261     (*metafile)->image.xres = dpix;
 262     (*metafile)->image.yres = dpiy;
 263     (*metafile)->bounds = *frameRect;
 264     (*metafile)->unit = frameUnit;
 265     (*metafile)->metafile_type = type;
 266     (*metafile)->record_dc = record_dc;
 267     (*metafile)->comment_data = NULL;
 268     (*metafile)->comment_data_size = 0;
 269     (*metafile)->comment_data_length = 0;
 270     (*metafile)->hemf = NULL;
 271
 272     stat = METAFILE_WriteHeader(*metafile, hdc);
 273
 274     if (stat != Ok)
 275     {
 276         DeleteEnhMetaFile(CloseEnhMetaFile(record_dc));
 277         heap_free(*metafile);
 278         *metafile = NULL;
 279         return OutOfMemory;
 280     }
 281
 282     return stat;
 283 }
 284
 285 /*****************************************************************************
 286  * GdipRecordMetafileI [GDIPLUS.@]
 287  */
 288 GpStatus WINGDIPAPI GdipRecordMetafileI(HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
 289                                         MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
 290 {
 291     GpRectF frameRectF, *pFrameRectF;
 292
 293     TRACE("(%p %d %p %d %p %p)\n", hdc, type, frameRect, frameUnit, desc, metafile);
 294
 295     if (frameRect)
 296     {
 297         frameRectF.X = frameRect->X;
 298         frameRectF.Y = frameRect->Y;
 299         frameRectF.Width = frameRect->Width;
 300         frameRectF.Height = frameRect->Height;
 301         pFrameRectF = &frameRectF;
 302     }
 303     else
 304         pFrameRectF = NULL;
 305
 306     return GdipRecordMetafile(hdc, type, pFrameRectF, frameUnit, desc, metafile);
 307 }
 308
 309 GpStatus METAFILE_GetGraphicsContext(GpMetafile* metafile, GpGraphics **result)
 310 {
 311     GpStatus stat;
 312
 313     if (!metafile->record_dc || metafile->record_graphics)
 314         return InvalidParameter;
 315
 316     stat = graphics_from_image((GpImage*)metafile, &metafile->record_graphics);
 317
 318     if (stat == Ok)
 319     {
 320         *result = metafile->record_graphics;
 321         metafile->record_graphics->xres = 96.0;
 322         metafile->record_graphics->yres = 96.0;
 323     }
 324
 325     return stat;
 326 }
 327
 328 GpStatus METAFILE_GetDC(GpMetafile* metafile, HDC *hdc)
 329 {
 330     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 331     {
 332         EmfPlusRecordHeader *record;
 333         GpStatus stat;
 334
 335         stat = METAFILE_AllocateRecord(metafile, sizeof(EmfPlusRecordHeader), (void**)&record);
 336         if (stat != Ok)
 337             return stat;
 338
 339         record->Type = EmfPlusRecordTypeGetDC;
 340         record->Flags = 0;
 341
 342         METAFILE_WriteRecords(metafile);
 343     }
 344
 345     *hdc = metafile->record_dc;
 346
 347     return Ok;
 348 }
 349
 350 static BOOL is_integer_rect(const GpRectF *rect)
 351 {
 352     SHORT x, y, width, height;
 353     x = rect->X;
 354     y = rect->Y;
 355     width = rect->Width;
 356     height = rect->Height;
 357     if (rect->X != (REAL)x || rect->Y != (REAL)y ||
 358         rect->Width != (REAL)width || rect->Height != (REAL)height)
 359         return FALSE;
 360     return TRUE;
 361 }
 362
 363 GpStatus METAFILE_FillRectangles(GpMetafile* metafile, GpBrush* brush,
 364     GDIPCONST GpRectF* rects, INT count)
 365 {
 366     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 367     {
 368         EmfPlusFillRects *record;
 369         GpStatus stat;
 370         BOOL integer_rects = TRUE;
 371         int i;
 372         DWORD brushid;
 373         int flags = 0;
 374
 375         if (brush->bt == BrushTypeSolidColor)
 376         {
 377             flags |= 0x8000;
 378             brushid = ((GpSolidFill*)brush)->color;
 379         }
 380         else
 381         {
 382             FIXME("brush serialization not implemented\n");
 383             return NotImplemented;
 384         }
 385
 386         for (i=0; i<count; i++)
 387         {
 388             if (!is_integer_rect(&rects[i]))
 389             {
 390                 integer_rects = FALSE;
 391                 break;
 392             }
 393         }
 394
 395         if (integer_rects)
 396             flags |= 0x4000;
 397
 398         stat = METAFILE_AllocateRecord(metafile,
 399             sizeof(EmfPlusFillRects) + count * (integer_rects ? sizeof(EmfPlusRect) : sizeof(GpRectF)),
 400             (void**)&record);
 401         if (stat != Ok)
 402             return stat;
 403
 404         record->Header.Type = EmfPlusRecordTypeFillRects;
 405         record->Header.Flags = flags;
 406         record->BrushID = brushid;
 407         record->Count = count;
 408
 409         if (integer_rects)
 410         {
 411             EmfPlusRect *record_rects = (EmfPlusRect*)(record+1);
 412             for (i=0; i<count; i++)
 413             {
 414                 record_rects[i].X = (SHORT)rects[i].X;
 415                 record_rects[i].Y = (SHORT)rects[i].Y;
 416                 record_rects[i].Width = (SHORT)rects[i].Width;
 417                 record_rects[i].Height = (SHORT)rects[i].Height;
 418             }
 419         }
 420         else
 421             memcpy(record+1, rects, sizeof(GpRectF) * count);
 422
 423         METAFILE_WriteRecords(metafile);
 424     }
 425
 426     return Ok;
 427 }
 428
 429 GpStatus METAFILE_SetPageTransform(GpMetafile* metafile, GpUnit unit, REAL scale)
 430 {
 431     if (metafile->metafile_type == MetafileTypeEmfPlusOnly || metafile->metafile_type == MetafileTypeEmfPlusDual)
 432     {
 433         EmfPlusSetPageTransform *record;
 434         GpStatus stat;
 435
 436         stat = METAFILE_AllocateRecord(metafile,
 437             sizeof(EmfPlusSetPageTransform),
 438             (void**)&record);
 439         if (stat != Ok)
 440             return stat;
 441
 442         record->Header.Type = EmfPlusRecordTypeSetPageTransform;
 443         record->Header.Flags = unit;
 444         record->PageScale = scale;
 445
 446         METAFILE_WriteRecords(metafile);
 447     }
 448
 449     return Ok;
 450 }
 451
 452 GpStatus METAFILE_ReleaseDC(GpMetafile* metafile, HDC hdc)
 453 {
 454     if (hdc != metafile->record_dc)
 455         return InvalidParameter;
 456
 457     return Ok;
 458 }
 459
 460 GpStatus METAFILE_GraphicsDeleted(GpMetafile* metafile)
 461 {
 462     GpStatus stat;
 463
 464     stat = METAFILE_WriteEndOfFile(metafile);
 465     metafile->record_graphics = NULL;
 466
 467     metafile->hemf = CloseEnhMetaFile(metafile->record_dc);
 468     metafile->record_dc = NULL;
 469
 470     heap_free(metafile->comment_data);
 471     metafile->comment_data = NULL;
 472     metafile->comment_data_size = 0;
 473
 474     return stat;
 475 }
 476
 477 GpStatus WINGDIPAPI GdipGetHemfFromMetafile(GpMetafile *metafile, HENHMETAFILE *hEmf)
 478 {
 479     TRACE("(%p,%p)\n", metafile, hEmf);
 480
 481     if (!metafile || !hEmf || !metafile->hemf)
 482         return InvalidParameter;
 483
 484     *hEmf = metafile->hemf;
 485     metafile->hemf = NULL;
 486
 487     return Ok;
 488 }
 489
 490 static GpStatus METAFILE_PlaybackGetDC(GpMetafile *metafile)
 491 {
 492     GpStatus stat = Ok;
 493
 494     stat = GdipGetDC(metafile->playback_graphics, &metafile->playback_dc);
 495
 496     if (stat == Ok)
 497     {
 498         /* The result of GdipGetDC always expects device co-ordinates, but the
 499          * device co-ordinates of the source metafile do not correspond to
 500          * device co-ordinates of the destination. Therefore, we set up the DC
 501          * so that the metafile's bounds map to the destination points where we
 502          * are drawing this metafile. */
 503         SetMapMode(metafile->playback_dc, MM_ANISOTROPIC);
 504
 505         SetWindowOrgEx(metafile->playback_dc, metafile->bounds.X, metafile->bounds.Y, NULL);
 506         SetWindowExtEx(metafile->playback_dc, metafile->bounds.Width, metafile->bounds.Height, NULL);
 507
 508         SetViewportOrgEx(metafile->playback_dc, metafile->playback_points[0].X, metafile->playback_points[0].Y, NULL);
 509         SetViewportExtEx(metafile->playback_dc,
 510             metafile->playback_points[1].X - metafile->playback_points[0].X,
 511             metafile->playback_points[2].Y - metafile->playback_points[0].Y, NULL);
 512     }
 513
 514     return stat;
 515 }
 516
 517 static void METAFILE_PlaybackReleaseDC(GpMetafile *metafile)
 518 {
 519     if (metafile->playback_dc)
 520     {
 521         GdipReleaseDC(metafile->playback_graphics, metafile->playback_dc);
 522         metafile->playback_dc = NULL;
 523     }
 524 }
 525
 526 static GpStatus METAFILE_PlaybackUpdateWorldTransform(GpMetafile *metafile)
 527 {
 528     GpMatrix *real_transform;
 529     GpStatus stat;
 530
 531     stat = GdipCreateMatrix3(&metafile->src_rect, metafile->playback_points, &real_transform);
 532
 533     if (stat == Ok)
 534     {
 535         REAL scale = units_to_pixels(1.0, metafile->page_unit, 96.0);
 536
 537         if (metafile->page_unit != UnitDisplay)
 538             scale *= metafile->page_scale;
 539
 540         stat = GdipScaleMatrix(real_transform, scale, scale, MatrixOrderPrepend);
 541
 542         if (stat == Ok)
 543             stat = GdipMultiplyMatrix(real_transform, metafile->world_transform, MatrixOrderPrepend);
 544
 545         if (stat == Ok)
 546             stat = GdipSetWorldTransform(metafile->playback_graphics, real_transform);
 547
 548         GdipDeleteMatrix(real_transform);
 549     }
 550
 551     return stat;
 552 }
 553
 554 GpStatus WINGDIPAPI GdipPlayMetafileRecord(GDIPCONST GpMetafile *metafile,
 555     EmfPlusRecordType recordType, UINT flags, UINT dataSize, GDIPCONST BYTE *data)
 556 {
 557     GpStatus stat;
 558     GpMetafile *real_metafile = (GpMetafile*)metafile;
 559
 560     TRACE("(%p,%x,%x,%d,%p)\n", metafile, recordType, flags, dataSize, data);
 561
 562     if (!metafile || (dataSize && !data) || !metafile->playback_graphics)
 563         return InvalidParameter;
 564
 565     if (recordType >= 1 && recordType <= 0x7a)
 566     {
 567         /* regular EMF record */
 568         if (metafile->playback_dc)
 569         {
 570             ENHMETARECORD *record;
 571
 572             record = heap_alloc_zero(dataSize + 8);
 573
 574             if (record)
 575             {
 576                 record->iType = recordType;
 577                 record->nSize = dataSize + 8;
 578                 memcpy(record->dParm, data, dataSize);
 579
 580                 PlayEnhMetaFileRecord(metafile->playback_dc, metafile->handle_table,
 581                     record, metafile->handle_count);
 582
 583                 heap_free(record);
 584             }
 585             else
 586                 return OutOfMemory;
 587         }
 588     }
 589     else
 590     {
 591         EmfPlusRecordHeader *header = (EmfPlusRecordHeader*)(data)-1;
 592
 593         METAFILE_PlaybackReleaseDC((GpMetafile*)metafile);
 594
 595         switch(recordType)
 596         {
 597         case EmfPlusRecordTypeHeader:
 598         case EmfPlusRecordTypeEndOfFile:
 599             break;
 600         case EmfPlusRecordTypeGetDC:
 601             METAFILE_PlaybackGetDC((GpMetafile*)metafile);
 602             break;
 603         case EmfPlusRecordTypeFillRects:
 604         {
 605             EmfPlusFillRects *record = (EmfPlusFillRects*)header;
 606             GpBrush *brush, *temp_brush=NULL;
 607             GpRectF *rects, *temp_rects=NULL;
 608
 609             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects))
 610                 return InvalidParameter;
 611
 612             if (flags & 0x4000)
 613             {
 614                 if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects) + sizeof(EmfPlusRect) * record->Count)
 615                     return InvalidParameter;
 616             }
 617             else
 618             {
 619                 if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects) + sizeof(GpRectF) * record->Count)
 620                     return InvalidParameter;
 621             }
 622
 623             if (flags & 0x8000)
 624             {
 625                 stat = GdipCreateSolidFill((ARGB)record->BrushID, (GpSolidFill**)&temp_brush);
 626                 brush = temp_brush;
 627             }
 628             else
 629             {
 630                 FIXME("brush deserialization not implemented\n");
 631                 return NotImplemented;
 632             }
 633
 634             if (stat == Ok)
 635             {
 636                 if (flags & 0x4000)
 637                 {
 638                     EmfPlusRect *int_rects = (EmfPlusRect*)(record+1);
 639                     int i;
 640
 641                     rects = temp_rects = heap_alloc_zero(sizeof(GpRectF) * record->Count);
 642                     if (rects)
 643                     {
 644                         for (i=0; i<record->Count; i++)
 645                         {
 646                             rects[i].X = int_rects[i].X;
 647                             rects[i].Y = int_rects[i].Y;
 648                             rects[i].Width = int_rects[i].Width;
 649                             rects[i].Height = int_rects[i].Height;
 650                         }
 651                     }
 652                     else
 653                         stat = OutOfMemory;
 654                 }
 655                 else
 656                     rects = (GpRectF*)(record+1);
 657             }
 658
 659             if (stat == Ok)
 660             {
 661                 stat = GdipFillRectangles(metafile->playback_graphics, brush, rects, record->Count);
 662             }
 663
 664             GdipDeleteBrush(temp_brush);
 665             heap_free(temp_rects);
 666
 667             return stat;
 668         }
 669         case EmfPlusRecordTypeSetPageTransform:
 670         {
 671             EmfPlusSetPageTransform *record = (EmfPlusSetPageTransform*)header;
 672             GpUnit unit = (GpUnit)flags;
 673
 674             if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusSetPageTransform))
 675                 return InvalidParameter;
 676
 677             real_metafile->page_unit = unit;
 678             real_metafile->page_scale = record->PageScale;
 679
 680             return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
 681         }
 682         default:
 683             FIXME("Not implemented for record type %x\n", recordType);
 684             return NotImplemented;
 685         }
 686     }
 687
 688     return Ok;
 689 }
 690
 691 struct enum_metafile_data
 692 {
 693     EnumerateMetafileProc callback;
 694     void *callback_data;
 695     GpMetafile *metafile;
 696 };
 697
 698 static int CALLBACK enum_metafile_proc(HDC hDC, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR,
 699     int nObj, LPARAM lpData)
 700 {
 701     BOOL ret;
 702     struct enum_metafile_data *data = (struct enum_metafile_data*)lpData;
 703     const BYTE* pStr;
 704
 705     data->metafile->handle_table = lpHTable;
 706     data->metafile->handle_count = nObj;
 707
 708     /* First check for an EMF+ record. */
 709     if (lpEMFR->iType == EMR_GDICOMMENT)
 710     {
 711         const EMRGDICOMMENT *comment = (const EMRGDICOMMENT*)lpEMFR;
 712
 713         if (comment->cbData >= 4 && memcmp(comment->Data, "EMF+", 4) == 0)
 714         {
 715             int offset = 4;
 716
 717             while (offset + sizeof(EmfPlusRecordHeader) <= comment->cbData)
 718             {
 719                 const EmfPlusRecordHeader *record = (const EmfPlusRecordHeader*)&comment->Data[offset];
 720
 721                 if (record->DataSize)
 722                     pStr = (const BYTE*)(record+1);
 723                 else
 724                     pStr = NULL;
 725
 726                 ret = data->callback(record->Type, record->Flags, record->DataSize,
 727                     pStr, data->callback_data);
 728
 729                 if (!ret)
 730                     return 0;
 731
 732                 offset += record->Size;
 733             }
 734
 735             return 1;
 736         }
 737     }
 738
 739     if (lpEMFR->nSize != 8)
 740         pStr = (const BYTE*)lpEMFR->dParm;
 741     else
 742         pStr = NULL;
 743
 744     return data->callback(lpEMFR->iType, 0, lpEMFR->nSize-8,
 745         pStr, data->callback_data);
 746 }
 747
 748 GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPoints(GpGraphics *graphics,
 749     GDIPCONST GpMetafile *metafile, GDIPCONST GpPointF *destPoints, INT count,
 750     GDIPCONST GpRectF *srcRect, Unit srcUnit, EnumerateMetafileProc callback,
 751     VOID *callbackData, GDIPCONST GpImageAttributes *imageAttributes)
 752 {
 753     struct enum_metafile_data data;
 754     GpStatus stat;
 755     GpMetafile *real_metafile = (GpMetafile*)metafile; /* whoever made this const was joking */
 756     GraphicsContainer state;
 757
 758     TRACE("(%p,%p,%p,%i,%p,%i,%p,%p,%p)\n", graphics, metafile,
 759         destPoints, count, srcRect, srcUnit, callback, callbackData,
 760         imageAttributes);
 761
 762     if (!graphics || !metafile || !destPoints || count != 3 || !srcRect)
 763         return InvalidParameter;
 764
 765     if (!metafile->hemf)
 766         return InvalidParameter;
 767
 768     if (metafile->playback_graphics)
 769         return ObjectBusy;
 770
 771     TRACE("%s %i -> %s %s %s\n", debugstr_rectf(srcRect), srcUnit,
 772         debugstr_pointf(&destPoints[0]), debugstr_pointf(&destPoints[1]),
 773         debugstr_pointf(&destPoints[2]));
 774
 775     data.callback = callback;
 776     data.callback_data = callbackData;
 777     data.metafile = real_metafile;
 778
 779     real_metafile->playback_graphics = graphics;
 780     real_metafile->playback_dc = NULL;
 781     real_metafile->src_rect = *srcRect;
 782
 783     memcpy(real_metafile->playback_points, destPoints, sizeof(PointF) * 3);
 784     stat = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, real_metafile->playback_points, 3);
 785
 786     if (stat == Ok)
 787         stat = GdipBeginContainer2(graphics, &state);
 788
 789     if (stat == Ok)
 790     {
 791         stat = GdipSetPageScale(graphics, 1.0);
 792
 793         if (stat == Ok)
 794             stat = GdipSetPageUnit(graphics, UnitPixel);
 795
 796         if (stat == Ok)
 797             stat = GdipCreateMatrix(&real_metafile->world_transform);
 798
 799         if (stat == Ok)
 800         {
 801             real_metafile->page_unit = UnitDisplay;
 802             real_metafile->page_scale = 1.0;
 803             stat = METAFILE_PlaybackUpdateWorldTransform(real_metafile);
 804         }
 805
 806         if (stat == Ok && (metafile->metafile_type == MetafileTypeEmf ||
 807             metafile->metafile_type == MetafileTypeWmfPlaceable ||
 808             metafile->metafile_type == MetafileTypeWmf))
 809             stat = METAFILE_PlaybackGetDC(real_metafile);
 810
 811         if (stat == Ok)
 812             EnumEnhMetaFile(0, metafile->hemf, enum_metafile_proc, &data, NULL);
 813
 814         METAFILE_PlaybackReleaseDC(real_metafile);
 815
 816         GdipDeleteMatrix(real_metafile->world_transform);
 817         real_metafile->world_transform = NULL;
 818
 819         GdipEndContainer(graphics, state);
 820     }
 821
 822     real_metafile->playback_graphics = NULL;
 823
 824     return stat;
 825 }
 826
 827 GpStatus WINGDIPAPI GdipEnumerateMetafileDestRect(GpGraphics *graphics,
 828     GDIPCONST GpMetafile *metafile, GDIPCONST GpRectF *dest,
 829     EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
 830 {
 831     GpPointF points[3];
 832
 833     if (!graphics || !metafile || !dest) return InvalidParameter;
 834
 835     points[0].X = points[2].X = dest->X;
 836     points[0].Y = points[1].Y = dest->Y;
 837     points[1].X = dest->X + dest->Width;
 838     points[2].Y = dest->Y + dest->Height;
 839
 840     return GdipEnumerateMetafileSrcRectDestPoints(graphics, metafile, points, 3,
 841         &metafile->bounds, metafile->unit, callback, cb_data, attrs);
 842 }
 843
 844 GpStatus WINGDIPAPI GdipEnumerateMetafileDestRectI(GpGraphics *graphics,
 845     GDIPCONST GpMetafile *metafile, GDIPCONST GpRect *dest,
 846     EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
 847 {
 848     GpRectF destf;
 849
 850     if (!graphics || !metafile || !dest) return InvalidParameter;
 851
 852     destf.X = dest->X;
 853     destf.Y = dest->Y;
 854     destf.Width = dest->Width;
 855     destf.Height = dest->Height;
 856
 857     return GdipEnumerateMetafileDestRect(graphics, metafile, &destf, callback, cb_data, attrs);
 858 }
 859
 860 GpStatus WINGDIPAPI GdipEnumerateMetafileDestPoint(GpGraphics *graphics,
 861     GDIPCONST GpMetafile *metafile, GDIPCONST GpPointF *dest,
 862     EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
 863 {
 864     GpRectF destf;
 865
 866     if (!graphics || !metafile || !dest) return InvalidParameter;
 867
 868     destf.X = dest->X;
 869     destf.Y = dest->Y;
 870     destf.Width = units_to_pixels(metafile->bounds.Width, metafile->unit, metafile->image.xres);
 871     destf.Height = units_to_pixels(metafile->bounds.Height, metafile->unit, metafile->image.yres);
 872
 873     return GdipEnumerateMetafileDestRect(graphics, metafile, &destf, callback, cb_data, attrs);
 874 }
 875
 876 GpStatus WINGDIPAPI GdipEnumerateMetafileDestPointI(GpGraphics *graphics,
 877     GDIPCONST GpMetafile *metafile, GDIPCONST GpPoint *dest,
 878     EnumerateMetafileProc callback, VOID *cb_data, GDIPCONST GpImageAttributes *attrs)
 879 {
 880     GpPointF ptf;
 881
 882     if (!graphics || !metafile || !dest) return InvalidParameter;
 883
 884     ptf.X = dest->X;
 885     ptf.Y = dest->Y;
 886
 887     return GdipEnumerateMetafileDestPoint(graphics, metafile, &ptf, callback, cb_data, attrs);
 888 }
 889
 890 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
 891     MetafileHeader * header)
 892 {
 893     static int calls;
 894
 895     TRACE("(%p, %p)\n", metafile, header);
 896
 897     if(!metafile || !header)
 898         return InvalidParameter;
 899
 900     if(!(calls++))
 901         FIXME("not implemented\n");
 902
 903     memset(header, 0, sizeof(MetafileHeader));
 904
 905     return Ok;
 906 }
 907
 908 static int CALLBACK get_emfplus_header_proc(HDC hDC, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR,
 909     int nObj, LPARAM lpData)
 910 {
 911     EmfPlusHeader *dst_header = (EmfPlusHeader*)lpData;
 912
 913     if (lpEMFR->iType == EMR_GDICOMMENT)
 914     {
 915         const EMRGDICOMMENT *comment = (const EMRGDICOMMENT*)lpEMFR;
 916
 917         if (comment->cbData >= 4 && memcmp(comment->Data, "EMF+", 4) == 0)
 918         {
 919             const EmfPlusRecordHeader *header = (const EmfPlusRecordHeader*)&comment->Data[4];
 920
 921             if (4 + sizeof(EmfPlusHeader) <= comment->cbData &&
 922                 header->Type == EmfPlusRecordTypeHeader)
 923             {
 924                 memcpy(dst_header, header, sizeof(*dst_header));
 925             }
 926         }
 927     }
 928     else if (lpEMFR->iType == EMR_HEADER)
 929         return TRUE;
 930
 931     return FALSE;
 932 }
 933
 934 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromEmf(HENHMETAFILE hemf,
 935     MetafileHeader *header)
 936 {
 937     ENHMETAHEADER3 emfheader;
 938     EmfPlusHeader emfplusheader;
 939     MetafileType metafile_type;
 940
 941     TRACE("(%p,%p)\n", hemf, header);
 942
 943     if(!hemf || !header)
 944         return InvalidParameter;
 945
 946     if (GetEnhMetaFileHeader(hemf, sizeof(emfheader), (ENHMETAHEADER*)&emfheader) == 0)
 947         return GenericError;
 948
 949     emfplusheader.Header.Type = 0;
 950
 951     EnumEnhMetaFile(NULL, hemf, get_emfplus_header_proc, &emfplusheader, NULL);
 952
 953     if (emfplusheader.Header.Type == EmfPlusRecordTypeHeader)
 954     {
 955         if ((emfplusheader.Header.Flags & 1) == 1)
 956             metafile_type = MetafileTypeEmfPlusDual;
 957         else
 958             metafile_type = MetafileTypeEmfPlusOnly;
 959     }
 960     else
 961         metafile_type = MetafileTypeEmf;
 962
 963     header->Type = metafile_type;
 964     header->Size = emfheader.nBytes;
 965     header->DpiX = (REAL)emfheader.szlDevice.cx * 25.4 / emfheader.szlMillimeters.cx;
 966     header->DpiY = (REAL)emfheader.szlDevice.cy * 25.4 / emfheader.szlMillimeters.cy;
 967     header->X = gdip_round((REAL)emfheader.rclFrame.left / 2540.0 * header->DpiX);
 968     header->Y = gdip_round((REAL)emfheader.rclFrame.top / 2540.0 * header->DpiY);
 969     header->Width = gdip_round((REAL)(emfheader.rclFrame.right - emfheader.rclFrame.left) / 2540.0 * header->DpiX);
 970     header->Height = gdip_round((REAL)(emfheader.rclFrame.bottom - emfheader.rclFrame.top) / 2540.0 * header->DpiY);
 971     header->EmfHeader = emfheader;
 972
 973     if (metafile_type == MetafileTypeEmfPlusDual || metafile_type == MetafileTypeEmfPlusOnly)
 974     {
 975         header->Version = emfplusheader.Version;
 976         header->EmfPlusFlags = emfplusheader.EmfPlusFlags;
 977         header->EmfPlusHeaderSize = emfplusheader.Header.Size;
 978         header->LogicalDpiX = emfplusheader.LogicalDpiX;
 979         header->LogicalDpiY = emfplusheader.LogicalDpiY;
 980     }
 981     else
 982     {
 983         header->Version = emfheader.nVersion;
 984         header->EmfPlusFlags = 0;
 985         header->EmfPlusHeaderSize = 0;
 986         header->LogicalDpiX = 0;
 987         header->LogicalDpiY = 0;
 988     }
 989
 990     return Ok;
 991 }
 992
 993 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromFile(GDIPCONST WCHAR *filename,
 994     MetafileHeader *header)
 995 {
 996     static int calls;
 997
 998     TRACE("(%s,%p)\n", debugstr_w(filename), header);
 999
1000     if(!filename || !header)
1001         return InvalidParameter;
1002
1003     if(!(calls++))
1004         FIXME("not implemented\n");
1005
1006     memset(header, 0, sizeof(MetafileHeader));
1007
1008     return Ok;
1009 }
1010
1011 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromStream(IStream *stream,
1012     MetafileHeader *header)
1013 {
1014     static int calls;
1015
1016     TRACE("(%p,%p)\n", stream, header);
1017
1018     if(!stream || !header)
1019         return InvalidParameter;
1020
1021     if(!(calls++))
1022         FIXME("not implemented\n");
1023
1024     memset(header, 0, sizeof(MetafileHeader));
1025
1026     return Ok;
1027 }
1028
1029 GpStatus WINGDIPAPI GdipCreateMetafileFromEmf(HENHMETAFILE hemf, BOOL delete,
1030     GpMetafile **metafile)
1031 {
1032     GpStatus stat;
1033     MetafileHeader header;
1034
1035     TRACE("(%p,%i,%p)\n", hemf, delete, metafile);
1036
1037     if(!hemf || !metafile)
1038         return InvalidParameter;
1039
1040     stat = GdipGetMetafileHeaderFromEmf(hemf, &header);
1041     if (stat != Ok)
1042         return stat;
1043
1044     *metafile = heap_alloc_zero(sizeof(GpMetafile));
1045     if (!*metafile)
1046         return OutOfMemory;
1047
1048     (*metafile)->image.type = ImageTypeMetafile;
1049     (*metafile)->image.format = ImageFormatEMF;
1050     (*metafile)->image.frame_count = 1;
1051     (*metafile)->image.xres = header.DpiX;
1052     (*metafile)->image.yres = header.DpiY;
1053     (*metafile)->bounds.X = (REAL)header.EmfHeader.rclFrame.left / 2540.0 * header.DpiX;
1054     (*metafile)->bounds.Y = (REAL)header.EmfHeader.rclFrame.top / 2540.0 * header.DpiY;
1055     (*metafile)->bounds.Width = (REAL)(header.EmfHeader.rclFrame.right - header.EmfHeader.rclFrame.left)
1056                                 / 2540.0 * header.DpiX;
1057     (*metafile)->bounds.Height = (REAL)(header.EmfHeader.rclFrame.bottom - header.EmfHeader.rclFrame.top)
1058                                  / 2540.0 * header.DpiY;
1059     (*metafile)->unit = UnitPixel;
1060     (*metafile)->metafile_type = header.Type;
1061     (*metafile)->hemf = hemf;
1062     (*metafile)->preserve_hemf = !delete;
1063
1064     TRACE("<-- %p\n", *metafile);
1065
1066     return Ok;
1067 }
1068
1069 GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE hwmf, BOOL delete,
1070     GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
1071 {
1072     UINT read;
1073     BYTE *copy;
1074     HENHMETAFILE hemf;
1075     GpStatus retval = Ok;
1076
1077     TRACE("(%p, %d, %p, %p)\n", hwmf, delete, placeable, metafile);
1078
1079     if(!hwmf || !metafile)
1080         return InvalidParameter;
1081
1082     *metafile = NULL;
1083     read = GetMetaFileBitsEx(hwmf, 0, NULL);
1084     if(!read)
1085         return GenericError;
1086     copy = heap_alloc_zero(read);
1087     GetMetaFileBitsEx(hwmf, read, copy);
1088
1089     hemf = SetWinMetaFileBits(read, copy, NULL, NULL);
1090     heap_free(copy);
1091
1092     /* FIXME: We should store and use hwmf instead of converting to hemf */
1093     retval = GdipCreateMetafileFromEmf(hemf, TRUE, metafile);
1094
1095     if (retval == Ok)
1096     {
1097         if (placeable)
1098         {
1099             (*metafile)->image.xres = (REAL)placeable->Inch;
1100             (*metafile)->image.yres = (REAL)placeable->Inch;
1101             (*metafile)->bounds.X = ((REAL)placeable->BoundingBox.Left) / ((REAL)placeable->Inch);
1102             (*metafile)->bounds.Y = ((REAL)placeable->BoundingBox.Top) / ((REAL)placeable->Inch);
1103             (*metafile)->bounds.Width = (REAL)(placeable->BoundingBox.Right -
1104                                                placeable->BoundingBox.Left);
1105             (*metafile)->bounds.Height = (REAL)(placeable->BoundingBox.Bottom -
1106                                                 placeable->BoundingBox.Top);
1107             (*metafile)->metafile_type = MetafileTypeWmfPlaceable;
1108         }
1109         else
1110             (*metafile)->metafile_type = MetafileTypeWmf;
1111         (*metafile)->image.format = ImageFormatWMF;
1112
1113         if (delete) DeleteMetaFile(hwmf);
1114     }
1115     else
1116         DeleteEnhMetaFile(hemf);
1117     return retval;
1118 }
1119
1120 GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR *file,
1121     GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
1122 {
1123     HMETAFILE hmf = GetMetaFileW(file);
1124
1125     TRACE("(%s, %p, %p)\n", debugstr_w(file), placeable, metafile);
1126
1127     if(!hmf) return InvalidParameter;
1128
1129     return GdipCreateMetafileFromWmf(hmf, TRUE, placeable, metafile);
1130 }
1131
1132 GpStatus WINGDIPAPI GdipCreateMetafileFromFile(GDIPCONST WCHAR *file,
1133     GpMetafile **metafile)
1134 {
1135     FIXME("(%p, %p): stub\n", file, metafile);
1136     return NotImplemented;
1137 }
1138
1139 GpStatus WINGDIPAPI GdipCreateMetafileFromStream(IStream *stream,
1140     GpMetafile **metafile)
1141 {
1142     FIXME("(%p, %p): stub\n", stream, metafile);
1143     return NotImplemented;
1144 }
1145
1146 GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit(GpMetafile *metafile,
1147     UINT limitDpi)
1148 {
1149     TRACE("(%p,%u)\n", metafile, limitDpi);
1150
1151     return Ok;
1152 }
1153
1154 GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
1155     GpMetafile* metafile, BOOL* succ, EmfType emfType,
1156     const WCHAR* description, GpMetafile** out_metafile)
1157 {
1158     static int calls;
1159
1160     TRACE("(%p,%p,%p,%u,%s,%p)\n", ref, metafile, succ, emfType,
1161         debugstr_w(description), out_metafile);
1162
1163     if(!ref || !metafile || !out_metafile || emfType < EmfTypeEmfOnly || emfType > EmfTypeEmfPlusDual)
1164         return InvalidParameter;
1165
1166     if(succ)
1167         *succ = FALSE;
1168     *out_metafile = NULL;
1169
1170     if(!(calls++))
1171         FIXME("not implemented\n");
1172
1173     return NotImplemented;
1174 }
1175
1176 GpStatus WINGDIPAPI GdipEmfToWmfBits(HENHMETAFILE hemf, UINT cbData16,
1177     LPBYTE pData16, INT iMapMode, INT eFlags)
1178 {
1179     FIXME("(%p, %d, %p, %d, %d): stub\n", hemf, cbData16, pData16, iMapMode, eFlags);
1180     return NotImplemented;
1181 }
1182
1183 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
1184                             HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
1185                             MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
1186                             GpMetafile **metafile)
1187 {
1188     FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
1189                                  frameUnit, debugstr_w(desc), metafile);
1190
1191     return NotImplemented;
1192 }
1193
1194 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
1195                             GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
1196                             GDIPCONST WCHAR *desc, GpMetafile **metafile)
1197 {
1198     FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
1199                                  frameUnit, debugstr_w(desc), metafile);
1200
1201     return NotImplemented;
1202 }
1203
1204 /*****************************************************************************
1205  * GdipConvertToEmfPlusToFile [GDIPLUS.@]
1206  */
1207
1208 GpStatus WINGDIPAPI GdipConvertToEmfPlusToFile(const GpGraphics* refGraphics,
1209                                                GpMetafile* metafile, BOOL* conversionSuccess,
1210                                                const WCHAR* filename, EmfType emfType,
1211                                                const WCHAR* description, GpMetafile** out_metafile)
1212 {
1213     FIXME("stub: %p, %p, %p, %p, %u, %p, %p\n", refGraphics, metafile, conversionSuccess, filename, emfType, description, out_metafile);
1214     return NotImplemented;
1215 }