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