2 * Copyright (C) 2011 Vincent Povirk for CodeWeavers
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.
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.
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
19 #include "gdiplus_private.h"
24 typedef struct EmfPlusARGB
32 typedef struct EmfPlusRecordHeader
38 } EmfPlusRecordHeader
;
40 typedef struct EmfPlusHeader
42 EmfPlusRecordHeader Header
;
49 typedef struct EmfPlusClear
51 EmfPlusRecordHeader Header
;
55 typedef struct EmfPlusFillRects
57 EmfPlusRecordHeader Header
;
62 typedef struct EmfPlusSetClipRect
64 EmfPlusRecordHeader Header
;
68 typedef struct EmfPlusSetPageTransform
70 EmfPlusRecordHeader Header
;
72 } EmfPlusSetPageTransform
;
74 typedef struct EmfPlusRect
82 typedef struct EmfPlusSetWorldTransform
84 EmfPlusRecordHeader Header
;
86 } EmfPlusSetWorldTransform
;
88 typedef struct EmfPlusScaleWorldTransform
90 EmfPlusRecordHeader Header
;
93 } EmfPlusScaleWorldTransform
;
95 typedef struct EmfPlusMultiplyWorldTransform
97 EmfPlusRecordHeader Header
;
99 } EmfPlusMultiplyWorldTransform
;
101 typedef struct EmfPlusRotateWorldTransform
103 EmfPlusRecordHeader Header
;
105 } EmfPlusRotateWorldTransform
;
107 typedef struct EmfPlusTranslateWorldTransform
109 EmfPlusRecordHeader Header
;
112 } EmfPlusTranslateWorldTransform
;
114 typedef struct EmfPlusBeginContainer
116 EmfPlusRecordHeader Header
;
120 } EmfPlusBeginContainer
;
122 typedef struct EmfPlusContainerRecord
124 EmfPlusRecordHeader Header
;
126 } EmfPlusContainerRecord
;
134 typedef struct container
138 enum container_type type
;
139 GraphicsContainer state
;
140 GpMatrix world_transform
;
148 PenDataTransform
= 0x0001,
149 PenDataStartCap
= 0x0002,
150 PenDataEndCap
= 0x0004,
151 PenDataJoin
= 0x0008,
152 PenDataMiterLimit
= 0x0010,
153 PenDataLineStyle
= 0x0020,
154 PenDataDashedLineCap
= 0x0040,
155 PenDataDashedLineOffset
= 0x0080,
156 PenDataDashedLine
= 0x0100,
157 PenDataNonCenter
= 0x0200,
158 PenDataCompoundLine
= 0x0400,
159 PenDataCustomStartCap
= 0x0800,
160 PenDataCustomEndCap
= 0x1000
163 typedef struct EmfPlusTransformMatrix
165 REAL TransformMatrix
[6];
166 } EmfPlusTransformMatrix
;
178 typedef struct EmfPlusPenData
183 BYTE OptionalData
[1];
186 typedef struct EmfPlusSolidBrushData
188 EmfPlusARGB SolidColor
;
189 } EmfPlusSolidBrushData
;
191 typedef struct EmfPlusBrush
196 EmfPlusSolidBrushData solid
;
200 typedef struct EmfPlusPen
209 typedef struct EmfPlusPath
212 DWORD PathPointCount
;
213 DWORD PathPointFlags
;
215 /* PathPointTypes[] */
216 /* AlignmentPadding */
220 typedef struct EmfPlusRegion
223 DWORD RegionNodeCount
;
230 BitmapDataTypeCompressed
,
233 typedef struct EmfPlusBitmap
243 typedef struct EmfPlusMetafile
246 DWORD MetafileDataSize
;
247 BYTE MetafileData
[1];
250 typedef enum ImageDataType
252 ImageDataTypeUnknown
,
254 ImageDataTypeMetafile
,
257 typedef struct EmfPlusImage
263 EmfPlusBitmap bitmap
;
264 EmfPlusMetafile metafile
;
268 typedef struct EmfPlusImageAttributes
273 EmfPlusARGB ClampColor
;
276 } EmfPlusImageAttributes
;
278 typedef enum ObjectType
287 ObjectTypeStringFormat
,
288 ObjectTypeImageAttributes
,
289 ObjectTypeCustomLineCap
,
292 typedef struct EmfPlusObject
294 EmfPlusRecordHeader Header
;
300 EmfPlusRegion region
;
302 EmfPlusImageAttributes image_attributes
;
306 typedef struct EmfPlusRectF
314 typedef struct EmfPlusPointF
320 typedef struct EmfPlusDrawImagePoints
322 EmfPlusRecordHeader Header
;
323 DWORD ImageAttributesID
;
325 EmfPlusRectF SrcRect
;
329 /*EmfPlusPointR pointR;
330 EmfPlusPoint point;*/
331 EmfPlusPointF pointF
;
333 } EmfPlusDrawImagePoints
;
335 typedef struct EmfPlusDrawPath
337 EmfPlusRecordHeader Header
;
341 typedef struct EmfPlusFillPath
343 EmfPlusRecordHeader Header
;
351 static DWORD
METAFILE_AddObjectId(GpMetafile
*metafile
)
353 return (metafile
->next_object_id
++) % 64;
356 static GpStatus
METAFILE_AllocateRecord(GpMetafile
*metafile
, DWORD size
, void **result
)
359 EmfPlusRecordHeader
*record
;
361 if (!metafile
->comment_data_size
)
363 DWORD data_size
= max(256, size
* 2 + 4);
364 metafile
->comment_data
= heap_alloc_zero(data_size
);
366 if (!metafile
->comment_data
)
369 memcpy(metafile
->comment_data
, "EMF+", 4);
371 metafile
->comment_data_size
= data_size
;
372 metafile
->comment_data_length
= 4;
375 size_needed
= size
+ metafile
->comment_data_length
;
377 if (size_needed
> metafile
->comment_data_size
)
379 DWORD data_size
= size_needed
* 2;
380 BYTE
*new_data
= heap_alloc_zero(data_size
);
385 memcpy(new_data
, metafile
->comment_data
, metafile
->comment_data_length
);
387 metafile
->comment_data_size
= data_size
;
388 heap_free(metafile
->comment_data
);
389 metafile
->comment_data
= new_data
;
392 *result
= metafile
->comment_data
+ metafile
->comment_data_length
;
393 metafile
->comment_data_length
+= size
;
395 record
= (EmfPlusRecordHeader
*)*result
;
397 record
->DataSize
= size
- sizeof(EmfPlusRecordHeader
);
402 static void METAFILE_RemoveLastRecord(GpMetafile
*metafile
, EmfPlusRecordHeader
*record
)
404 assert(metafile
->comment_data
+ metafile
->comment_data_length
== (BYTE
*)record
+ record
->Size
);
405 metafile
->comment_data_length
-= record
->Size
;
408 static void METAFILE_WriteRecords(GpMetafile
*metafile
)
410 if (metafile
->comment_data_length
> 4)
412 GdiComment(metafile
->record_dc
, metafile
->comment_data_length
, metafile
->comment_data
);
413 metafile
->comment_data_length
= 4;
417 static GpStatus
METAFILE_WriteHeader(GpMetafile
*metafile
, HDC hdc
)
421 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
423 EmfPlusHeader
*header
;
425 stat
= METAFILE_AllocateRecord(metafile
, sizeof(EmfPlusHeader
), (void**)&header
);
429 header
->Header
.Type
= EmfPlusRecordTypeHeader
;
431 if (metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
432 header
->Header
.Flags
= 1;
434 header
->Header
.Flags
= 0;
436 header
->Version
= VERSION_MAGIC2
;
438 if (GetDeviceCaps(hdc
, TECHNOLOGY
) == DT_RASDISPLAY
)
439 header
->EmfPlusFlags
= 1;
441 header
->EmfPlusFlags
= 0;
443 header
->LogicalDpiX
= GetDeviceCaps(hdc
, LOGPIXELSX
);
444 header
->LogicalDpiY
= GetDeviceCaps(hdc
, LOGPIXELSY
);
446 METAFILE_WriteRecords(metafile
);
452 static GpStatus
METAFILE_WriteEndOfFile(GpMetafile
*metafile
)
456 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
458 EmfPlusRecordHeader
*record
;
460 stat
= METAFILE_AllocateRecord(metafile
, sizeof(EmfPlusRecordHeader
), (void**)&record
);
464 record
->Type
= EmfPlusRecordTypeEndOfFile
;
467 METAFILE_WriteRecords(metafile
);
473 GpStatus WINGDIPAPI
GdipRecordMetafile(HDC hdc
, EmfType type
, GDIPCONST GpRectF
*frameRect
,
474 MetafileFrameUnit frameUnit
, GDIPCONST WCHAR
*desc
, GpMetafile
**metafile
)
478 REAL framerect_factor_x
, framerect_factor_y
;
482 TRACE("(%p %d %p %d %p %p)\n", hdc
, type
, frameRect
, frameUnit
, desc
, metafile
);
484 if (!hdc
|| type
< EmfTypeEmfOnly
|| type
> EmfTypeEmfPlusDual
|| !metafile
)
485 return InvalidParameter
;
487 dpix
= (REAL
)GetDeviceCaps(hdc
, HORZRES
) / GetDeviceCaps(hdc
, HORZSIZE
) * 25.4;
488 dpiy
= (REAL
)GetDeviceCaps(hdc
, VERTRES
) / GetDeviceCaps(hdc
, VERTSIZE
) * 25.4;
494 case MetafileFrameUnitPixel
:
495 framerect_factor_x
= 2540.0 / dpix
;
496 framerect_factor_y
= 2540.0 / dpiy
;
498 case MetafileFrameUnitPoint
:
499 framerect_factor_x
= framerect_factor_y
= 2540.0 / 72.0;
501 case MetafileFrameUnitInch
:
502 framerect_factor_x
= framerect_factor_y
= 2540.0;
504 case MetafileFrameUnitDocument
:
505 framerect_factor_x
= framerect_factor_y
= 2540.0 / 300.0;
507 case MetafileFrameUnitMillimeter
:
508 framerect_factor_x
= framerect_factor_y
= 100.0;
510 case MetafileFrameUnitGdi
:
511 framerect_factor_x
= framerect_factor_y
= 1.0;
514 return InvalidParameter
;
517 rc
.left
= framerect_factor_x
* frameRect
->X
;
518 rc
.top
= framerect_factor_y
* frameRect
->Y
;
519 rc
.right
= rc
.left
+ framerect_factor_x
* frameRect
->Width
;
520 rc
.bottom
= rc
.top
+ framerect_factor_y
* frameRect
->Height
;
527 record_dc
= CreateEnhMetaFileW(hdc
, NULL
, lprc
, desc
);
532 *metafile
= heap_alloc_zero(sizeof(GpMetafile
));
535 DeleteEnhMetaFile(CloseEnhMetaFile(record_dc
));
539 (*metafile
)->image
.type
= ImageTypeMetafile
;
540 (*metafile
)->image
.flags
= ImageFlagsNone
;
541 (*metafile
)->image
.palette
= NULL
;
542 (*metafile
)->image
.xres
= dpix
;
543 (*metafile
)->image
.yres
= dpiy
;
544 (*metafile
)->bounds
.X
= (*metafile
)->bounds
.Y
= 0.0;
545 (*metafile
)->bounds
.Width
= (*metafile
)->bounds
.Height
= 1.0;
546 (*metafile
)->unit
= UnitPixel
;
547 (*metafile
)->metafile_type
= type
;
548 (*metafile
)->record_dc
= record_dc
;
549 (*metafile
)->comment_data
= NULL
;
550 (*metafile
)->comment_data_size
= 0;
551 (*metafile
)->comment_data_length
= 0;
552 (*metafile
)->hemf
= NULL
;
553 list_init(&(*metafile
)->containers
);
557 (*metafile
)->auto_frame
= TRUE
;
558 (*metafile
)->auto_frame_min
.X
= 0;
559 (*metafile
)->auto_frame_min
.Y
= 0;
560 (*metafile
)->auto_frame_max
.X
= -1;
561 (*metafile
)->auto_frame_max
.Y
= -1;
564 stat
= METAFILE_WriteHeader(*metafile
, hdc
);
568 DeleteEnhMetaFile(CloseEnhMetaFile(record_dc
));
569 heap_free(*metafile
);
577 /*****************************************************************************
578 * GdipRecordMetafileI [GDIPLUS.@]
580 GpStatus WINGDIPAPI
GdipRecordMetafileI(HDC hdc
, EmfType type
, GDIPCONST GpRect
*frameRect
,
581 MetafileFrameUnit frameUnit
, GDIPCONST WCHAR
*desc
, GpMetafile
**metafile
)
583 GpRectF frameRectF
, *pFrameRectF
;
585 TRACE("(%p %d %p %d %p %p)\n", hdc
, type
, frameRect
, frameUnit
, desc
, metafile
);
589 frameRectF
.X
= frameRect
->X
;
590 frameRectF
.Y
= frameRect
->Y
;
591 frameRectF
.Width
= frameRect
->Width
;
592 frameRectF
.Height
= frameRect
->Height
;
593 pFrameRectF
= &frameRectF
;
598 return GdipRecordMetafile(hdc
, type
, pFrameRectF
, frameUnit
, desc
, metafile
);
601 GpStatus WINGDIPAPI
GdipRecordMetafileStream(IStream
*stream
, HDC hdc
, EmfType type
, GDIPCONST GpRectF
*frameRect
,
602 MetafileFrameUnit frameUnit
, GDIPCONST WCHAR
*desc
, GpMetafile
**metafile
)
606 TRACE("(%p %p %d %p %d %p %p)\n", stream
, hdc
, type
, frameRect
, frameUnit
, desc
, metafile
);
609 return InvalidParameter
;
611 stat
= GdipRecordMetafile(hdc
, type
, frameRect
, frameUnit
, desc
, metafile
);
615 (*metafile
)->record_stream
= stream
;
616 IStream_AddRef(stream
);
622 static void METAFILE_AdjustFrame(GpMetafile
* metafile
, const GpPointF
*points
,
627 if (!metafile
->auto_frame
|| !num_points
)
630 if (metafile
->auto_frame_max
.X
< metafile
->auto_frame_min
.X
)
631 metafile
->auto_frame_max
= metafile
->auto_frame_min
= points
[0];
633 for (i
=0; i
<num_points
; i
++)
635 if (points
[i
].X
< metafile
->auto_frame_min
.X
)
636 metafile
->auto_frame_min
.X
= points
[i
].X
;
637 if (points
[i
].X
> metafile
->auto_frame_max
.X
)
638 metafile
->auto_frame_max
.X
= points
[i
].X
;
639 if (points
[i
].Y
< metafile
->auto_frame_min
.Y
)
640 metafile
->auto_frame_min
.Y
= points
[i
].Y
;
641 if (points
[i
].Y
> metafile
->auto_frame_max
.Y
)
642 metafile
->auto_frame_max
.Y
= points
[i
].Y
;
646 GpStatus
METAFILE_GetGraphicsContext(GpMetafile
* metafile
, GpGraphics
**result
)
650 if (!metafile
->record_dc
|| metafile
->record_graphics
)
651 return InvalidParameter
;
653 stat
= graphics_from_image((GpImage
*)metafile
, &metafile
->record_graphics
);
657 *result
= metafile
->record_graphics
;
658 metafile
->record_graphics
->xres
= 96.0;
659 metafile
->record_graphics
->yres
= 96.0;
665 GpStatus
METAFILE_GetDC(GpMetafile
* metafile
, HDC
*hdc
)
667 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
669 EmfPlusRecordHeader
*record
;
672 stat
= METAFILE_AllocateRecord(metafile
, sizeof(EmfPlusRecordHeader
), (void**)&record
);
676 record
->Type
= EmfPlusRecordTypeGetDC
;
679 METAFILE_WriteRecords(metafile
);
682 *hdc
= metafile
->record_dc
;
687 GpStatus
METAFILE_GraphicsClear(GpMetafile
* metafile
, ARGB color
)
689 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
691 EmfPlusClear
*record
;
694 stat
= METAFILE_AllocateRecord(metafile
, sizeof(EmfPlusClear
), (void**)&record
);
698 record
->Header
.Type
= EmfPlusRecordTypeClear
;
699 record
->Header
.Flags
= 0;
700 record
->Color
= color
;
702 METAFILE_WriteRecords(metafile
);
708 static BOOL
is_integer_rect(const GpRectF
*rect
)
710 SHORT x
, y
, width
, height
;
714 height
= rect
->Height
;
715 if (rect
->X
!= (REAL
)x
|| rect
->Y
!= (REAL
)y
||
716 rect
->Width
!= (REAL
)width
|| rect
->Height
!= (REAL
)height
)
721 GpStatus
METAFILE_FillRectangles(GpMetafile
* metafile
, GpBrush
* brush
,
722 GDIPCONST GpRectF
* rects
, INT count
)
724 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
726 EmfPlusFillRects
*record
;
728 BOOL integer_rects
= TRUE
;
733 if (brush
->bt
== BrushTypeSolidColor
)
736 brushid
= ((GpSolidFill
*)brush
)->color
;
740 FIXME("brush serialization not implemented\n");
741 return NotImplemented
;
744 for (i
=0; i
<count
; i
++)
746 if (!is_integer_rect(&rects
[i
]))
748 integer_rects
= FALSE
;
756 stat
= METAFILE_AllocateRecord(metafile
,
757 sizeof(EmfPlusFillRects
) + count
* (integer_rects
? sizeof(EmfPlusRect
) : sizeof(GpRectF
)),
762 record
->Header
.Type
= EmfPlusRecordTypeFillRects
;
763 record
->Header
.Flags
= flags
;
764 record
->BrushID
= brushid
;
765 record
->Count
= count
;
769 EmfPlusRect
*record_rects
= (EmfPlusRect
*)(record
+1);
770 for (i
=0; i
<count
; i
++)
772 record_rects
[i
].X
= (SHORT
)rects
[i
].X
;
773 record_rects
[i
].Y
= (SHORT
)rects
[i
].Y
;
774 record_rects
[i
].Width
= (SHORT
)rects
[i
].Width
;
775 record_rects
[i
].Height
= (SHORT
)rects
[i
].Height
;
779 memcpy(record
+1, rects
, sizeof(GpRectF
) * count
);
781 METAFILE_WriteRecords(metafile
);
784 if (metafile
->auto_frame
)
789 for (i
=0; i
<count
; i
++)
791 corners
[0].X
= rects
[i
].X
;
792 corners
[0].Y
= rects
[i
].Y
;
793 corners
[1].X
= rects
[i
].X
+ rects
[i
].Width
;
794 corners
[1].Y
= rects
[i
].Y
;
795 corners
[2].X
= rects
[i
].X
;
796 corners
[2].Y
= rects
[i
].Y
+ rects
[i
].Height
;
797 corners
[3].X
= rects
[i
].X
+ rects
[i
].Width
;
798 corners
[3].Y
= rects
[i
].Y
+ rects
[i
].Height
;
800 GdipTransformPoints(metafile
->record_graphics
, CoordinateSpaceDevice
,
801 CoordinateSpaceWorld
, corners
, 4);
803 METAFILE_AdjustFrame(metafile
, corners
, 4);
810 GpStatus
METAFILE_SetClipRect(GpMetafile
* metafile
, REAL x
, REAL y
, REAL width
, REAL height
, CombineMode mode
)
812 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
814 EmfPlusSetClipRect
*record
;
817 stat
= METAFILE_AllocateRecord(metafile
,
818 sizeof(EmfPlusSetClipRect
),
823 record
->Header
.Type
= EmfPlusRecordTypeSetClipRect
;
824 record
->Header
.Flags
= (mode
& 0xf) << 8;
825 record
->ClipRect
.X
= x
;
826 record
->ClipRect
.Y
= y
;
827 record
->ClipRect
.Width
= width
;
828 record
->ClipRect
.Height
= height
;
830 METAFILE_WriteRecords(metafile
);
836 static GpStatus
METAFILE_AddRegionObject(GpMetafile
*metafile
, GpRegion
*region
, DWORD
*id
)
838 EmfPlusObject
*object_record
;
843 if (metafile
->metafile_type
!= MetafileTypeEmfPlusOnly
&& metafile
->metafile_type
!= MetafileTypeEmfPlusDual
)
846 size
= write_region_data(region
, NULL
);
847 stat
= METAFILE_AllocateRecord(metafile
,
848 FIELD_OFFSET(EmfPlusObject
, ObjectData
.region
) + size
, (void**)&object_record
);
849 if (stat
!= Ok
) return stat
;
851 *id
= METAFILE_AddObjectId(metafile
);
852 object_record
->Header
.Type
= EmfPlusRecordTypeObject
;
853 object_record
->Header
.Flags
= *id
| ObjectTypeRegion
<< 8;
854 write_region_data(region
, &object_record
->ObjectData
.region
);
858 GpStatus
METAFILE_SetClipRegion(GpMetafile
* metafile
, GpRegion
* region
, CombineMode mode
)
860 EmfPlusRecordHeader
*record
;
864 if (metafile
->metafile_type
== MetafileTypeEmf
)
867 return NotImplemented
;
870 stat
= METAFILE_AddRegionObject(metafile
, region
, ®ion_id
);
871 if (stat
!= Ok
) return stat
;
873 stat
= METAFILE_AllocateRecord(metafile
, sizeof(*record
), (void**)&record
);
874 if (stat
!= Ok
) return stat
;
876 record
->Type
= EmfPlusRecordTypeSetClipRegion
;
877 record
->Flags
= region_id
| mode
<< 8;
879 METAFILE_WriteRecords(metafile
);
883 GpStatus
METAFILE_SetPageTransform(GpMetafile
* metafile
, GpUnit unit
, REAL scale
)
885 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
887 EmfPlusSetPageTransform
*record
;
890 stat
= METAFILE_AllocateRecord(metafile
,
891 sizeof(EmfPlusSetPageTransform
),
896 record
->Header
.Type
= EmfPlusRecordTypeSetPageTransform
;
897 record
->Header
.Flags
= unit
;
898 record
->PageScale
= scale
;
900 METAFILE_WriteRecords(metafile
);
906 GpStatus
METAFILE_SetWorldTransform(GpMetafile
* metafile
, GDIPCONST GpMatrix
* transform
)
908 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
910 EmfPlusSetWorldTransform
*record
;
913 stat
= METAFILE_AllocateRecord(metafile
,
914 sizeof(EmfPlusSetWorldTransform
),
919 record
->Header
.Type
= EmfPlusRecordTypeSetWorldTransform
;
920 record
->Header
.Flags
= 0;
921 memcpy(record
->MatrixData
, transform
->matrix
, sizeof(record
->MatrixData
));
923 METAFILE_WriteRecords(metafile
);
929 GpStatus
METAFILE_ScaleWorldTransform(GpMetafile
* metafile
, REAL sx
, REAL sy
, MatrixOrder order
)
931 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
933 EmfPlusScaleWorldTransform
*record
;
936 stat
= METAFILE_AllocateRecord(metafile
,
937 sizeof(EmfPlusScaleWorldTransform
),
942 record
->Header
.Type
= EmfPlusRecordTypeScaleWorldTransform
;
943 record
->Header
.Flags
= (order
== MatrixOrderAppend
? 0x2000 : 0);
947 METAFILE_WriteRecords(metafile
);
953 GpStatus
METAFILE_MultiplyWorldTransform(GpMetafile
* metafile
, GDIPCONST GpMatrix
* matrix
, MatrixOrder order
)
955 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
957 EmfPlusMultiplyWorldTransform
*record
;
960 stat
= METAFILE_AllocateRecord(metafile
,
961 sizeof(EmfPlusMultiplyWorldTransform
),
966 record
->Header
.Type
= EmfPlusRecordTypeMultiplyWorldTransform
;
967 record
->Header
.Flags
= (order
== MatrixOrderAppend
? 0x2000 : 0);
968 memcpy(record
->MatrixData
, matrix
->matrix
, sizeof(record
->MatrixData
));
970 METAFILE_WriteRecords(metafile
);
976 GpStatus
METAFILE_RotateWorldTransform(GpMetafile
* metafile
, REAL angle
, MatrixOrder order
)
978 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
980 EmfPlusRotateWorldTransform
*record
;
983 stat
= METAFILE_AllocateRecord(metafile
,
984 sizeof(EmfPlusRotateWorldTransform
),
989 record
->Header
.Type
= EmfPlusRecordTypeRotateWorldTransform
;
990 record
->Header
.Flags
= (order
== MatrixOrderAppend
? 0x2000 : 0);
991 record
->Angle
= angle
;
993 METAFILE_WriteRecords(metafile
);
999 GpStatus
METAFILE_TranslateWorldTransform(GpMetafile
* metafile
, REAL dx
, REAL dy
, MatrixOrder order
)
1001 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
1003 EmfPlusTranslateWorldTransform
*record
;
1006 stat
= METAFILE_AllocateRecord(metafile
,
1007 sizeof(EmfPlusTranslateWorldTransform
),
1012 record
->Header
.Type
= EmfPlusRecordTypeTranslateWorldTransform
;
1013 record
->Header
.Flags
= (order
== MatrixOrderAppend
? 0x2000 : 0);
1017 METAFILE_WriteRecords(metafile
);
1023 GpStatus
METAFILE_ResetWorldTransform(GpMetafile
* metafile
)
1025 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
1027 EmfPlusRecordHeader
*record
;
1030 stat
= METAFILE_AllocateRecord(metafile
,
1031 sizeof(EmfPlusRecordHeader
),
1036 record
->Type
= EmfPlusRecordTypeResetWorldTransform
;
1039 METAFILE_WriteRecords(metafile
);
1045 GpStatus
METAFILE_BeginContainer(GpMetafile
* metafile
, GDIPCONST GpRectF
*dstrect
,
1046 GDIPCONST GpRectF
*srcrect
, GpUnit unit
, DWORD StackIndex
)
1048 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
1050 EmfPlusBeginContainer
*record
;
1053 stat
= METAFILE_AllocateRecord(metafile
, sizeof(*record
), (void**)&record
);
1057 record
->Header
.Type
= EmfPlusRecordTypeBeginContainer
;
1058 record
->Header
.Flags
= unit
& 0xff;
1059 record
->DestRect
= *dstrect
;
1060 record
->SrcRect
= *srcrect
;
1061 record
->StackIndex
= StackIndex
;
1063 METAFILE_WriteRecords(metafile
);
1069 GpStatus
METAFILE_BeginContainerNoParams(GpMetafile
* metafile
, DWORD StackIndex
)
1071 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
1073 EmfPlusContainerRecord
*record
;
1076 stat
= METAFILE_AllocateRecord(metafile
,
1077 sizeof(EmfPlusContainerRecord
),
1082 record
->Header
.Type
= EmfPlusRecordTypeBeginContainerNoParams
;
1083 record
->Header
.Flags
= 0;
1084 record
->StackIndex
= StackIndex
;
1086 METAFILE_WriteRecords(metafile
);
1092 GpStatus
METAFILE_EndContainer(GpMetafile
* metafile
, DWORD StackIndex
)
1094 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
1096 EmfPlusContainerRecord
*record
;
1099 stat
= METAFILE_AllocateRecord(metafile
,
1100 sizeof(EmfPlusContainerRecord
),
1105 record
->Header
.Type
= EmfPlusRecordTypeEndContainer
;
1106 record
->Header
.Flags
= 0;
1107 record
->StackIndex
= StackIndex
;
1109 METAFILE_WriteRecords(metafile
);
1115 GpStatus
METAFILE_SaveGraphics(GpMetafile
* metafile
, DWORD StackIndex
)
1117 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
1119 EmfPlusContainerRecord
*record
;
1122 stat
= METAFILE_AllocateRecord(metafile
,
1123 sizeof(EmfPlusContainerRecord
),
1128 record
->Header
.Type
= EmfPlusRecordTypeSave
;
1129 record
->Header
.Flags
= 0;
1130 record
->StackIndex
= StackIndex
;
1132 METAFILE_WriteRecords(metafile
);
1138 GpStatus
METAFILE_RestoreGraphics(GpMetafile
* metafile
, DWORD StackIndex
)
1140 if (metafile
->metafile_type
== MetafileTypeEmfPlusOnly
|| metafile
->metafile_type
== MetafileTypeEmfPlusDual
)
1142 EmfPlusContainerRecord
*record
;
1145 stat
= METAFILE_AllocateRecord(metafile
,
1146 sizeof(EmfPlusContainerRecord
),
1151 record
->Header
.Type
= EmfPlusRecordTypeRestore
;
1152 record
->Header
.Flags
= 0;
1153 record
->StackIndex
= StackIndex
;
1155 METAFILE_WriteRecords(metafile
);
1161 GpStatus
METAFILE_ReleaseDC(GpMetafile
* metafile
, HDC hdc
)
1163 if (hdc
!= metafile
->record_dc
)
1164 return InvalidParameter
;
1169 GpStatus
METAFILE_GraphicsDeleted(GpMetafile
* metafile
)
1173 stat
= METAFILE_WriteEndOfFile(metafile
);
1174 metafile
->record_graphics
= NULL
;
1176 metafile
->hemf
= CloseEnhMetaFile(metafile
->record_dc
);
1177 metafile
->record_dc
= NULL
;
1179 heap_free(metafile
->comment_data
);
1180 metafile
->comment_data
= NULL
;
1181 metafile
->comment_data_size
= 0;
1185 MetafileHeader header
;
1187 stat
= GdipGetMetafileHeaderFromEmf(metafile
->hemf
, &header
);
1188 if (stat
== Ok
&& metafile
->auto_frame
&&
1189 metafile
->auto_frame_max
.X
>= metafile
->auto_frame_min
.X
)
1191 RECTL bounds_rc
, gdi_bounds_rc
;
1192 REAL x_scale
= 2540.0 / header
.DpiX
;
1193 REAL y_scale
= 2540.0 / header
.DpiY
;
1197 bounds_rc
.left
= floorf(metafile
->auto_frame_min
.X
* x_scale
);
1198 bounds_rc
.top
= floorf(metafile
->auto_frame_min
.Y
* y_scale
);
1199 bounds_rc
.right
= ceilf(metafile
->auto_frame_max
.X
* x_scale
);
1200 bounds_rc
.bottom
= ceilf(metafile
->auto_frame_max
.Y
* y_scale
);
1202 gdi_bounds_rc
= header
.u
.EmfHeader
.rclBounds
;
1203 if (gdi_bounds_rc
.right
> gdi_bounds_rc
.left
&& gdi_bounds_rc
.bottom
> gdi_bounds_rc
.top
)
1205 bounds_rc
.left
= min(bounds_rc
.left
, gdi_bounds_rc
.left
);
1206 bounds_rc
.top
= min(bounds_rc
.top
, gdi_bounds_rc
.top
);
1207 bounds_rc
.right
= max(bounds_rc
.right
, gdi_bounds_rc
.right
);
1208 bounds_rc
.bottom
= max(bounds_rc
.bottom
, gdi_bounds_rc
.bottom
);
1211 buffer_size
= GetEnhMetaFileBits(metafile
->hemf
, 0, NULL
);
1212 buffer
= heap_alloc(buffer_size
);
1215 HENHMETAFILE new_hemf
;
1217 GetEnhMetaFileBits(metafile
->hemf
, buffer_size
, buffer
);
1219 ((ENHMETAHEADER
*)buffer
)->rclFrame
= bounds_rc
;
1221 new_hemf
= SetEnhMetaFileBits(buffer_size
, buffer
);
1225 DeleteEnhMetaFile(metafile
->hemf
);
1226 metafile
->hemf
= new_hemf
;
1237 stat
= GdipGetMetafileHeaderFromEmf(metafile
->hemf
, &header
);
1241 metafile
->bounds
.X
= header
.X
;
1242 metafile
->bounds
.Y
= header
.Y
;
1243 metafile
->bounds
.Width
= header
.Width
;
1244 metafile
->bounds
.Height
= header
.Height
;
1248 if (stat
== Ok
&& metafile
->record_stream
)
1253 buffer_size
= GetEnhMetaFileBits(metafile
->hemf
, 0, NULL
);
1255 buffer
= heap_alloc(buffer_size
);
1260 GetEnhMetaFileBits(metafile
->hemf
, buffer_size
, buffer
);
1262 hr
= IStream_Write(metafile
->record_stream
, buffer
, buffer_size
, NULL
);
1265 stat
= hresult_to_status(hr
);
1273 if (metafile
->record_stream
)
1275 IStream_Release(metafile
->record_stream
);
1276 metafile
->record_stream
= NULL
;
1282 GpStatus WINGDIPAPI
GdipGetHemfFromMetafile(GpMetafile
*metafile
, HENHMETAFILE
*hEmf
)
1284 TRACE("(%p,%p)\n", metafile
, hEmf
);
1286 if (!metafile
|| !hEmf
|| !metafile
->hemf
)
1287 return InvalidParameter
;
1289 *hEmf
= metafile
->hemf
;
1290 metafile
->hemf
= NULL
;
1295 static void METAFILE_GetFinalGdiTransform(const GpMetafile
*metafile
, XFORM
*result
)
1297 const GpRectF
*rect
;
1300 /* This transforms metafile device space to output points. */
1301 rect
= &metafile
->src_rect
;
1302 pt
= metafile
->playback_points
;
1303 result
->eM11
= (pt
[1].X
- pt
[0].X
) / rect
->Width
;
1304 result
->eM21
= (pt
[2].X
- pt
[0].X
) / rect
->Height
;
1305 result
->eDx
= pt
[0].X
- result
->eM11
* rect
->X
- result
->eM21
* rect
->Y
;
1306 result
->eM12
= (pt
[1].Y
- pt
[0].Y
) / rect
->Width
;
1307 result
->eM22
= (pt
[2].Y
- pt
[0].Y
) / rect
->Height
;
1308 result
->eDy
= pt
[0].Y
- result
->eM12
* rect
->X
- result
->eM22
* rect
->Y
;
1311 static GpStatus
METAFILE_PlaybackUpdateGdiTransform(GpMetafile
*metafile
)
1313 XFORM combined
, final
;
1315 METAFILE_GetFinalGdiTransform(metafile
, &final
);
1317 CombineTransform(&combined
, &metafile
->gdiworldtransform
, &final
);
1319 SetGraphicsMode(metafile
->playback_dc
, GM_ADVANCED
);
1320 SetWorldTransform(metafile
->playback_dc
, &combined
);
1325 static GpStatus
METAFILE_PlaybackGetDC(GpMetafile
*metafile
)
1329 stat
= GdipGetDC(metafile
->playback_graphics
, &metafile
->playback_dc
);
1333 static const XFORM identity
= {1, 0, 0, 1, 0, 0};
1335 metafile
->gdiworldtransform
= identity
;
1336 METAFILE_PlaybackUpdateGdiTransform(metafile
);
1342 static void METAFILE_PlaybackReleaseDC(GpMetafile
*metafile
)
1344 if (metafile
->playback_dc
)
1346 GdipReleaseDC(metafile
->playback_graphics
, metafile
->playback_dc
);
1347 metafile
->playback_dc
= NULL
;
1351 static GpStatus
METAFILE_PlaybackUpdateClip(GpMetafile
*metafile
)
1354 stat
= GdipCombineRegionRegion(metafile
->playback_graphics
->clip
, metafile
->base_clip
, CombineModeReplace
);
1356 stat
= GdipCombineRegionRegion(metafile
->playback_graphics
->clip
, metafile
->clip
, CombineModeIntersect
);
1360 static GpStatus
METAFILE_PlaybackUpdateWorldTransform(GpMetafile
*metafile
)
1362 GpMatrix
*real_transform
;
1365 stat
= GdipCreateMatrix3(&metafile
->src_rect
, metafile
->playback_points
, &real_transform
);
1369 REAL scale
= units_to_pixels(1.0, metafile
->page_unit
, 96.0);
1371 if (metafile
->page_unit
!= UnitDisplay
)
1372 scale
*= metafile
->page_scale
;
1374 stat
= GdipScaleMatrix(real_transform
, scale
, scale
, MatrixOrderPrepend
);
1377 stat
= GdipMultiplyMatrix(real_transform
, metafile
->world_transform
, MatrixOrderPrepend
);
1380 stat
= GdipSetWorldTransform(metafile
->playback_graphics
, real_transform
);
1382 GdipDeleteMatrix(real_transform
);
1388 GpStatus WINGDIPAPI
GdipPlayMetafileRecord(GDIPCONST GpMetafile
*metafile
,
1389 EmfPlusRecordType recordType
, UINT flags
, UINT dataSize
, GDIPCONST BYTE
*data
)
1392 GpMetafile
*real_metafile
= (GpMetafile
*)metafile
;
1394 TRACE("(%p,%x,%x,%d,%p)\n", metafile
, recordType
, flags
, dataSize
, data
);
1396 if (!metafile
|| (dataSize
&& !data
) || !metafile
->playback_graphics
)
1397 return InvalidParameter
;
1399 if (recordType
>= 1 && recordType
<= 0x7a)
1401 /* regular EMF record */
1402 if (metafile
->playback_dc
)
1406 case EMR_SETMAPMODE
:
1409 case EMR_SETWINDOWORGEX
:
1410 case EMR_SETWINDOWEXTEX
:
1411 case EMR_SETVIEWPORTORGEX
:
1412 case EMR_SETVIEWPORTEXTEX
:
1413 case EMR_SCALEVIEWPORTEXTEX
:
1414 case EMR_SCALEWINDOWEXTEX
:
1415 case EMR_MODIFYWORLDTRANSFORM
:
1416 FIXME("not implemented for record type %x\n", recordType
);
1418 case EMR_SETWORLDTRANSFORM
:
1420 const XFORM
* xform
= (void*)data
;
1421 real_metafile
->gdiworldtransform
= *xform
;
1422 METAFILE_PlaybackUpdateGdiTransform(real_metafile
);
1425 case EMR_EXTSELECTCLIPRGN
:
1427 DWORD rgndatasize
= *(DWORD
*)data
;
1428 DWORD mode
= *(DWORD
*)(data
+ 4);
1429 const RGNDATA
*rgndata
= (const RGNDATA
*)(data
+ 8);
1436 METAFILE_GetFinalGdiTransform(metafile
, &final
);
1438 hrgn
= ExtCreateRegion(&final
, rgndatasize
, rgndata
);
1441 ExtSelectClipRgn(metafile
->playback_dc
, hrgn
, mode
);
1449 ENHMETARECORD
*record
= heap_alloc_zero(dataSize
+ 8);
1453 record
->iType
= recordType
;
1454 record
->nSize
= dataSize
+ 8;
1455 memcpy(record
->dParm
, data
, dataSize
);
1457 if(PlayEnhMetaFileRecord(metafile
->playback_dc
, metafile
->handle_table
,
1458 record
, metafile
->handle_count
) == 0)
1459 ERR("PlayEnhMetaFileRecord failed\n");
1473 EmfPlusRecordHeader
*header
= (EmfPlusRecordHeader
*)(data
)-1;
1475 METAFILE_PlaybackReleaseDC((GpMetafile
*)metafile
);
1479 case EmfPlusRecordTypeHeader
:
1480 case EmfPlusRecordTypeEndOfFile
:
1482 case EmfPlusRecordTypeGetDC
:
1483 METAFILE_PlaybackGetDC((GpMetafile
*)metafile
);
1485 case EmfPlusRecordTypeClear
:
1487 EmfPlusClear
*record
= (EmfPlusClear
*)header
;
1489 return GdipGraphicsClear(metafile
->playback_graphics
, record
->Color
);
1491 case EmfPlusRecordTypeFillRects
:
1493 EmfPlusFillRects
*record
= (EmfPlusFillRects
*)header
;
1494 GpBrush
*brush
, *temp_brush
=NULL
;
1495 GpRectF
*rects
, *temp_rects
=NULL
;
1497 if (dataSize
+ sizeof(EmfPlusRecordHeader
) < sizeof(EmfPlusFillRects
))
1498 return InvalidParameter
;
1502 if (dataSize
+ sizeof(EmfPlusRecordHeader
) < sizeof(EmfPlusFillRects
) + sizeof(EmfPlusRect
) * record
->Count
)
1503 return InvalidParameter
;
1507 if (dataSize
+ sizeof(EmfPlusRecordHeader
) < sizeof(EmfPlusFillRects
) + sizeof(GpRectF
) * record
->Count
)
1508 return InvalidParameter
;
1513 stat
= GdipCreateSolidFill((ARGB
)record
->BrushID
, (GpSolidFill
**)&temp_brush
);
1518 FIXME("brush deserialization not implemented\n");
1519 return NotImplemented
;
1526 EmfPlusRect
*int_rects
= (EmfPlusRect
*)(record
+1);
1529 rects
= temp_rects
= heap_alloc_zero(sizeof(GpRectF
) * record
->Count
);
1532 for (i
=0; i
<record
->Count
; i
++)
1534 rects
[i
].X
= int_rects
[i
].X
;
1535 rects
[i
].Y
= int_rects
[i
].Y
;
1536 rects
[i
].Width
= int_rects
[i
].Width
;
1537 rects
[i
].Height
= int_rects
[i
].Height
;
1544 rects
= (GpRectF
*)(record
+1);
1549 stat
= GdipFillRectangles(metafile
->playback_graphics
, brush
, rects
, record
->Count
);
1552 GdipDeleteBrush(temp_brush
);
1553 heap_free(temp_rects
);
1557 case EmfPlusRecordTypeSetClipRect
:
1559 EmfPlusSetClipRect
*record
= (EmfPlusSetClipRect
*)header
;
1560 CombineMode mode
= (CombineMode
)((flags
>> 8) & 0xf);
1562 GpMatrix world_to_device
;
1564 if (dataSize
+ sizeof(EmfPlusRecordHeader
) < sizeof(*record
))
1565 return InvalidParameter
;
1567 stat
= GdipCreateRegionRect(&record
->ClipRect
, ®ion
);
1571 get_graphics_transform(real_metafile
->playback_graphics
,
1572 CoordinateSpaceDevice
, CoordinateSpaceWorld
, &world_to_device
);
1574 GdipTransformRegion(region
, &world_to_device
);
1576 GdipCombineRegionRegion(real_metafile
->clip
, region
, mode
);
1578 GdipDeleteRegion(region
);
1581 return METAFILE_PlaybackUpdateClip(real_metafile
);
1583 case EmfPlusRecordTypeSetPageTransform
:
1585 EmfPlusSetPageTransform
*record
= (EmfPlusSetPageTransform
*)header
;
1586 GpUnit unit
= (GpUnit
)flags
;
1588 if (dataSize
+ sizeof(EmfPlusRecordHeader
) < sizeof(EmfPlusSetPageTransform
))
1589 return InvalidParameter
;
1591 real_metafile
->page_unit
= unit
;
1592 real_metafile
->page_scale
= record
->PageScale
;
1594 return METAFILE_PlaybackUpdateWorldTransform(real_metafile
);
1596 case EmfPlusRecordTypeSetWorldTransform
:
1598 EmfPlusSetWorldTransform
*record
= (EmfPlusSetWorldTransform
*)header
;
1600 if (dataSize
+ sizeof(EmfPlusRecordHeader
) < sizeof(EmfPlusSetWorldTransform
))
1601 return InvalidParameter
;
1603 memcpy(real_metafile
->world_transform
->matrix
, record
->MatrixData
, sizeof(record
->MatrixData
));
1605 return METAFILE_PlaybackUpdateWorldTransform(real_metafile
);
1607 case EmfPlusRecordTypeScaleWorldTransform
:
1609 EmfPlusScaleWorldTransform
*record
= (EmfPlusScaleWorldTransform
*)header
;
1610 MatrixOrder order
= (flags
& 0x2000) ? MatrixOrderAppend
: MatrixOrderPrepend
;
1612 if (dataSize
+ sizeof(EmfPlusRecordHeader
) < sizeof(EmfPlusScaleWorldTransform
))
1613 return InvalidParameter
;
1615 GdipScaleMatrix(real_metafile
->world_transform
, record
->Sx
, record
->Sy
, order
);
1617 return METAFILE_PlaybackUpdateWorldTransform(real_metafile
);
1619 case EmfPlusRecordTypeMultiplyWorldTransform
:
1621 EmfPlusMultiplyWorldTransform
*record
= (EmfPlusMultiplyWorldTransform
*)header
;
1622 MatrixOrder order
= (flags
& 0x2000) ? MatrixOrderAppend
: MatrixOrderPrepend
;
1625 if (dataSize
+ sizeof(EmfPlusRecordHeader
) < sizeof(EmfPlusMultiplyWorldTransform
))
1626 return InvalidParameter
;
1628 memcpy(matrix
.matrix
, record
->MatrixData
, sizeof(matrix
.matrix
));
1630 GdipMultiplyMatrix(real_metafile
->world_transform
, &matrix
, order
);
1632 return METAFILE_PlaybackUpdateWorldTransform(real_metafile
);
1634 case EmfPlusRecordTypeRotateWorldTransform
:
1636 EmfPlusRotateWorldTransform
*record
= (EmfPlusRotateWorldTransform
*)header
;
1637 MatrixOrder order
= (flags
& 0x2000) ? MatrixOrderAppend
: MatrixOrderPrepend
;
1639 if (dataSize
+ sizeof(EmfPlusRecordHeader
) < sizeof(EmfPlusRotateWorldTransform
))
1640 return InvalidParameter
;
1642 GdipRotateMatrix(real_metafile
->world_transform
, record
->Angle
, order
);
1644 return METAFILE_PlaybackUpdateWorldTransform(real_metafile
);
1646 case EmfPlusRecordTypeTranslateWorldTransform
:
1648 EmfPlusTranslateWorldTransform
*record
= (EmfPlusTranslateWorldTransform
*)header
;
1649 MatrixOrder order
= (flags
& 0x2000) ? MatrixOrderAppend
: MatrixOrderPrepend
;
1651 if (dataSize
+ sizeof(EmfPlusRecordHeader
) < sizeof(EmfPlusTranslateWorldTransform
))
1652 return InvalidParameter
;
1654 GdipTranslateMatrix(real_metafile
->world_transform
, record
->dx
, record
->dy
, order
);
1656 return METAFILE_PlaybackUpdateWorldTransform(real_metafile
);
1658 case EmfPlusRecordTypeResetWorldTransform
:
1660 GdipSetMatrixElements(real_metafile
->world_transform
, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
1662 return METAFILE_PlaybackUpdateWorldTransform(real_metafile
);
1664 case EmfPlusRecordTypeBeginContainer
:
1666 EmfPlusBeginContainer
*record
= (EmfPlusBeginContainer
*)header
;
1669 REAL scale_x
, scale_y
;
1670 GpRectF scaled_srcrect
;
1673 cont
= heap_alloc_zero(sizeof(*cont
));
1677 stat
= GdipCloneRegion(metafile
->clip
, &cont
->clip
);
1684 stat
= GdipBeginContainer2(metafile
->playback_graphics
, &cont
->state
);
1688 GdipDeleteRegion(cont
->clip
);
1693 cont
->id
= record
->StackIndex
;
1694 cont
->type
= BEGIN_CONTAINER
;
1695 cont
->world_transform
= *metafile
->world_transform
;
1696 cont
->page_unit
= metafile
->page_unit
;
1697 cont
->page_scale
= metafile
->page_scale
;
1698 list_add_head(&real_metafile
->containers
, &cont
->entry
);
1700 unit
= record
->Header
.Flags
& 0xff;
1702 scale_x
= units_to_pixels(1.0, unit
, metafile
->image
.xres
);
1703 scale_y
= units_to_pixels(1.0, unit
, metafile
->image
.yres
);
1705 scaled_srcrect
.X
= scale_x
* record
->SrcRect
.X
;
1706 scaled_srcrect
.Y
= scale_y
* record
->SrcRect
.Y
;
1707 scaled_srcrect
.Width
= scale_x
* record
->SrcRect
.Width
;
1708 scaled_srcrect
.Height
= scale_y
* record
->SrcRect
.Height
;
1710 transform
.matrix
[0] = record
->DestRect
.Width
/ scaled_srcrect
.Width
;
1711 transform
.matrix
[1] = 0.0;
1712 transform
.matrix
[2] = 0.0;
1713 transform
.matrix
[3] = record
->DestRect
.Height
/ scaled_srcrect
.Height
;
1714 transform
.matrix
[4] = record
->DestRect
.X
- scaled_srcrect
.X
;
1715 transform
.matrix
[5] = record
->DestRect
.Y
- scaled_srcrect
.Y
;
1717 GdipMultiplyMatrix(real_metafile
->world_transform
, &transform
, MatrixOrderPrepend
);
1719 return METAFILE_PlaybackUpdateWorldTransform(real_metafile
);
1721 case EmfPlusRecordTypeBeginContainerNoParams
:
1722 case EmfPlusRecordTypeSave
:
1724 EmfPlusContainerRecord
*record
= (EmfPlusContainerRecord
*)header
;
1727 cont
= heap_alloc_zero(sizeof(*cont
));
1731 stat
= GdipCloneRegion(metafile
->clip
, &cont
->clip
);
1738 if (recordType
== EmfPlusRecordTypeBeginContainerNoParams
)
1739 stat
= GdipBeginContainer2(metafile
->playback_graphics
, &cont
->state
);
1741 stat
= GdipSaveGraphics(metafile
->playback_graphics
, &cont
->state
);
1745 GdipDeleteRegion(cont
->clip
);
1750 cont
->id
= record
->StackIndex
;
1751 if (recordType
== EmfPlusRecordTypeBeginContainerNoParams
)
1752 cont
->type
= BEGIN_CONTAINER
;
1754 cont
->type
= SAVE_GRAPHICS
;
1755 cont
->world_transform
= *metafile
->world_transform
;
1756 cont
->page_unit
= metafile
->page_unit
;
1757 cont
->page_scale
= metafile
->page_scale
;
1758 list_add_head(&real_metafile
->containers
, &cont
->entry
);
1762 case EmfPlusRecordTypeEndContainer
:
1763 case EmfPlusRecordTypeRestore
:
1765 EmfPlusContainerRecord
*record
= (EmfPlusContainerRecord
*)header
;
1767 enum container_type type
;
1770 if (recordType
== EmfPlusRecordTypeEndContainer
)
1771 type
= BEGIN_CONTAINER
;
1773 type
= SAVE_GRAPHICS
;
1775 LIST_FOR_EACH_ENTRY(cont
, &real_metafile
->containers
, container
, entry
)
1777 if (cont
->id
== record
->StackIndex
&& cont
->type
== type
)
1788 /* pop any newer items on the stack */
1789 while ((cont2
= LIST_ENTRY(list_head(&real_metafile
->containers
), container
, entry
)) != cont
)
1791 list_remove(&cont2
->entry
);
1792 GdipDeleteRegion(cont2
->clip
);
1796 if (type
== BEGIN_CONTAINER
)
1797 GdipEndContainer(real_metafile
->playback_graphics
, cont
->state
);
1799 GdipRestoreGraphics(real_metafile
->playback_graphics
, cont
->state
);
1801 *real_metafile
->world_transform
= cont
->world_transform
;
1802 real_metafile
->page_unit
= cont
->page_unit
;
1803 real_metafile
->page_scale
= cont
->page_scale
;
1804 GdipCombineRegionRegion(real_metafile
->clip
, cont
->clip
, CombineModeReplace
);
1806 list_remove(&cont
->entry
);
1807 GdipDeleteRegion(cont
->clip
);
1814 FIXME("Not implemented for record type %x\n", recordType
);
1815 return NotImplemented
;
1822 struct enum_metafile_data
1824 EnumerateMetafileProc callback
;
1825 void *callback_data
;
1826 GpMetafile
*metafile
;
1829 static int CALLBACK
enum_metafile_proc(HDC hDC
, HANDLETABLE
*lpHTable
, const ENHMETARECORD
*lpEMFR
,
1830 int nObj
, LPARAM lpData
)
1833 struct enum_metafile_data
*data
= (struct enum_metafile_data
*)lpData
;
1836 data
->metafile
->handle_table
= lpHTable
;
1837 data
->metafile
->handle_count
= nObj
;
1839 /* First check for an EMF+ record. */
1840 if (lpEMFR
->iType
== EMR_GDICOMMENT
)
1842 const EMRGDICOMMENT
*comment
= (const EMRGDICOMMENT
*)lpEMFR
;
1844 if (comment
->cbData
>= 4 && memcmp(comment
->Data
, "EMF+", 4) == 0)
1848 while (offset
+ sizeof(EmfPlusRecordHeader
) <= comment
->cbData
)
1850 const EmfPlusRecordHeader
*record
= (const EmfPlusRecordHeader
*)&comment
->Data
[offset
];
1852 if (record
->DataSize
)
1853 pStr
= (const BYTE
*)(record
+1);
1857 ret
= data
->callback(record
->Type
, record
->Flags
, record
->DataSize
,
1858 pStr
, data
->callback_data
);
1863 offset
+= record
->Size
;
1870 if (lpEMFR
->nSize
!= 8)
1871 pStr
= (const BYTE
*)lpEMFR
->dParm
;
1875 return data
->callback(lpEMFR
->iType
, 0, lpEMFR
->nSize
-8,
1876 pStr
, data
->callback_data
);
1879 GpStatus WINGDIPAPI
GdipEnumerateMetafileSrcRectDestPoints(GpGraphics
*graphics
,
1880 GDIPCONST GpMetafile
*metafile
, GDIPCONST GpPointF
*destPoints
, INT count
,
1881 GDIPCONST GpRectF
*srcRect
, Unit srcUnit
, EnumerateMetafileProc callback
,
1882 VOID
*callbackData
, GDIPCONST GpImageAttributes
*imageAttributes
)
1884 struct enum_metafile_data data
;
1886 GpMetafile
*real_metafile
= (GpMetafile
*)metafile
; /* whoever made this const was joking */
1887 GraphicsContainer state
;
1890 TRACE("(%p,%p,%p,%i,%p,%i,%p,%p,%p)\n", graphics
, metafile
,
1891 destPoints
, count
, srcRect
, srcUnit
, callback
, callbackData
,
1894 if (!graphics
|| !metafile
|| !destPoints
|| count
!= 3 || !srcRect
)
1895 return InvalidParameter
;
1897 if (!metafile
->hemf
)
1898 return InvalidParameter
;
1900 if (metafile
->playback_graphics
)
1903 TRACE("%s %i -> %s %s %s\n", debugstr_rectf(srcRect
), srcUnit
,
1904 debugstr_pointf(&destPoints
[0]), debugstr_pointf(&destPoints
[1]),
1905 debugstr_pointf(&destPoints
[2]));
1907 data
.callback
= callback
;
1908 data
.callback_data
= callbackData
;
1909 data
.metafile
= real_metafile
;
1911 real_metafile
->playback_graphics
= graphics
;
1912 real_metafile
->playback_dc
= NULL
;
1913 real_metafile
->src_rect
= *srcRect
;
1915 memcpy(real_metafile
->playback_points
, destPoints
, sizeof(PointF
) * 3);
1916 stat
= GdipTransformPoints(graphics
, CoordinateSpaceDevice
, CoordinateSpaceWorld
, real_metafile
->playback_points
, 3);
1919 stat
= GdipBeginContainer2(graphics
, &state
);
1923 stat
= GdipSetPageScale(graphics
, 1.0);
1926 stat
= GdipSetPageUnit(graphics
, UnitPixel
);
1929 stat
= GdipResetWorldTransform(graphics
);
1932 stat
= GdipCreateRegion(&real_metafile
->base_clip
);
1935 stat
= GdipGetClip(graphics
, real_metafile
->base_clip
);
1938 stat
= GdipCreateRegion(&real_metafile
->clip
);
1941 stat
= GdipCreatePath(FillModeAlternate
, &dst_path
);
1945 GpPointF clip_points
[4];
1947 clip_points
[0] = real_metafile
->playback_points
[0];
1948 clip_points
[1] = real_metafile
->playback_points
[1];
1949 clip_points
[2].X
= real_metafile
->playback_points
[1].X
+ real_metafile
->playback_points
[2].X
1950 - real_metafile
->playback_points
[0].X
;
1951 clip_points
[2].Y
= real_metafile
->playback_points
[1].Y
+ real_metafile
->playback_points
[2].Y
1952 - real_metafile
->playback_points
[0].Y
;
1953 clip_points
[3] = real_metafile
->playback_points
[2];
1955 stat
= GdipAddPathPolygon(dst_path
, clip_points
, 4);
1958 stat
= GdipCombineRegionPath(real_metafile
->base_clip
, dst_path
, CombineModeIntersect
);
1960 GdipDeletePath(dst_path
);
1964 stat
= GdipCreateMatrix(&real_metafile
->world_transform
);
1968 real_metafile
->page_unit
= UnitDisplay
;
1969 real_metafile
->page_scale
= 1.0;
1970 stat
= METAFILE_PlaybackUpdateWorldTransform(real_metafile
);
1975 stat
= METAFILE_PlaybackUpdateClip(real_metafile
);
1978 if (stat
== Ok
&& (metafile
->metafile_type
== MetafileTypeEmf
||
1979 metafile
->metafile_type
== MetafileTypeWmfPlaceable
||
1980 metafile
->metafile_type
== MetafileTypeWmf
))
1981 stat
= METAFILE_PlaybackGetDC(real_metafile
);
1984 EnumEnhMetaFile(0, metafile
->hemf
, enum_metafile_proc
, &data
, NULL
);
1986 METAFILE_PlaybackReleaseDC(real_metafile
);
1988 GdipDeleteMatrix(real_metafile
->world_transform
);
1989 real_metafile
->world_transform
= NULL
;
1991 GdipDeleteRegion(real_metafile
->base_clip
);
1992 real_metafile
->base_clip
= NULL
;
1994 GdipDeleteRegion(real_metafile
->clip
);
1995 real_metafile
->clip
= NULL
;
1997 while (list_head(&real_metafile
->containers
))
1999 container
* cont
= LIST_ENTRY(list_head(&real_metafile
->containers
), container
, entry
);
2000 list_remove(&cont
->entry
);
2001 GdipDeleteRegion(cont
->clip
);
2005 GdipEndContainer(graphics
, state
);
2008 real_metafile
->playback_graphics
= NULL
;
2013 GpStatus WINGDIPAPI
GdipEnumerateMetafileDestRect(GpGraphics
*graphics
,
2014 GDIPCONST GpMetafile
*metafile
, GDIPCONST GpRectF
*dest
,
2015 EnumerateMetafileProc callback
, VOID
*cb_data
, GDIPCONST GpImageAttributes
*attrs
)
2019 if (!graphics
|| !metafile
|| !dest
) return InvalidParameter
;
2021 points
[0].X
= points
[2].X
= dest
->X
;
2022 points
[0].Y
= points
[1].Y
= dest
->Y
;
2023 points
[1].X
= dest
->X
+ dest
->Width
;
2024 points
[2].Y
= dest
->Y
+ dest
->Height
;
2026 return GdipEnumerateMetafileSrcRectDestPoints(graphics
, metafile
, points
, 3,
2027 &metafile
->bounds
, metafile
->unit
, callback
, cb_data
, attrs
);
2030 GpStatus WINGDIPAPI
GdipEnumerateMetafileDestRectI(GpGraphics
*graphics
,
2031 GDIPCONST GpMetafile
*metafile
, GDIPCONST GpRect
*dest
,
2032 EnumerateMetafileProc callback
, VOID
*cb_data
, GDIPCONST GpImageAttributes
*attrs
)
2036 if (!graphics
|| !metafile
|| !dest
) return InvalidParameter
;
2040 destf
.Width
= dest
->Width
;
2041 destf
.Height
= dest
->Height
;
2043 return GdipEnumerateMetafileDestRect(graphics
, metafile
, &destf
, callback
, cb_data
, attrs
);
2046 GpStatus WINGDIPAPI
GdipEnumerateMetafileDestPoint(GpGraphics
*graphics
,
2047 GDIPCONST GpMetafile
*metafile
, GDIPCONST GpPointF
*dest
,
2048 EnumerateMetafileProc callback
, VOID
*cb_data
, GDIPCONST GpImageAttributes
*attrs
)
2052 if (!graphics
|| !metafile
|| !dest
) return InvalidParameter
;
2056 destf
.Width
= units_to_pixels(metafile
->bounds
.Width
, metafile
->unit
, metafile
->image
.xres
);
2057 destf
.Height
= units_to_pixels(metafile
->bounds
.Height
, metafile
->unit
, metafile
->image
.yres
);
2059 return GdipEnumerateMetafileDestRect(graphics
, metafile
, &destf
, callback
, cb_data
, attrs
);
2062 GpStatus WINGDIPAPI
GdipEnumerateMetafileDestPointI(GpGraphics
*graphics
,
2063 GDIPCONST GpMetafile
*metafile
, GDIPCONST GpPoint
*dest
,
2064 EnumerateMetafileProc callback
, VOID
*cb_data
, GDIPCONST GpImageAttributes
*attrs
)
2068 if (!graphics
|| !metafile
|| !dest
) return InvalidParameter
;
2073 return GdipEnumerateMetafileDestPoint(graphics
, metafile
, &ptf
, callback
, cb_data
, attrs
);
2076 GpStatus WINGDIPAPI
GdipGetMetafileHeaderFromMetafile(GpMetafile
* metafile
,
2077 MetafileHeader
* header
)
2081 TRACE("(%p, %p)\n", metafile
, header
);
2083 if(!metafile
|| !header
)
2084 return InvalidParameter
;
2088 status
= GdipGetMetafileHeaderFromEmf(metafile
->hemf
, header
);
2089 if (status
!= Ok
) return status
;
2093 memset(header
, 0, sizeof(*header
));
2094 header
->Version
= VERSION_MAGIC2
;
2097 header
->Type
= metafile
->metafile_type
;
2098 header
->DpiX
= metafile
->image
.xres
;
2099 header
->DpiY
= metafile
->image
.yres
;
2100 header
->Width
= gdip_round(metafile
->bounds
.Width
);
2101 header
->Height
= gdip_round(metafile
->bounds
.Height
);
2106 static int CALLBACK
get_emfplus_header_proc(HDC hDC
, HANDLETABLE
*lpHTable
, const ENHMETARECORD
*lpEMFR
,
2107 int nObj
, LPARAM lpData
)
2109 EmfPlusHeader
*dst_header
= (EmfPlusHeader
*)lpData
;
2111 if (lpEMFR
->iType
== EMR_GDICOMMENT
)
2113 const EMRGDICOMMENT
*comment
= (const EMRGDICOMMENT
*)lpEMFR
;
2115 if (comment
->cbData
>= 4 && memcmp(comment
->Data
, "EMF+", 4) == 0)
2117 const EmfPlusRecordHeader
*header
= (const EmfPlusRecordHeader
*)&comment
->Data
[4];
2119 if (4 + sizeof(EmfPlusHeader
) <= comment
->cbData
&&
2120 header
->Type
== EmfPlusRecordTypeHeader
)
2122 memcpy(dst_header
, header
, sizeof(*dst_header
));
2126 else if (lpEMFR
->iType
== EMR_HEADER
)
2132 GpStatus WINGDIPAPI
GdipGetMetafileHeaderFromEmf(HENHMETAFILE hemf
,
2133 MetafileHeader
*header
)
2135 ENHMETAHEADER3 emfheader
;
2136 EmfPlusHeader emfplusheader
;
2137 MetafileType metafile_type
;
2139 TRACE("(%p,%p)\n", hemf
, header
);
2141 if(!hemf
|| !header
)
2142 return InvalidParameter
;
2144 if (GetEnhMetaFileHeader(hemf
, sizeof(emfheader
), (ENHMETAHEADER
*)&emfheader
) == 0)
2145 return GenericError
;
2147 emfplusheader
.Header
.Type
= 0;
2149 EnumEnhMetaFile(NULL
, hemf
, get_emfplus_header_proc
, &emfplusheader
, NULL
);
2151 if (emfplusheader
.Header
.Type
== EmfPlusRecordTypeHeader
)
2153 if ((emfplusheader
.Header
.Flags
& 1) == 1)
2154 metafile_type
= MetafileTypeEmfPlusDual
;
2156 metafile_type
= MetafileTypeEmfPlusOnly
;
2159 metafile_type
= MetafileTypeEmf
;
2161 header
->Type
= metafile_type
;
2162 header
->Size
= emfheader
.nBytes
;
2163 header
->DpiX
= (REAL
)emfheader
.szlDevice
.cx
* 25.4 / emfheader
.szlMillimeters
.cx
;
2164 header
->DpiY
= (REAL
)emfheader
.szlDevice
.cy
* 25.4 / emfheader
.szlMillimeters
.cy
;
2165 header
->X
= gdip_round((REAL
)emfheader
.rclFrame
.left
/ 2540.0 * header
->DpiX
);
2166 header
->Y
= gdip_round((REAL
)emfheader
.rclFrame
.top
/ 2540.0 * header
->DpiY
);
2167 header
->Width
= gdip_round((REAL
)(emfheader
.rclFrame
.right
- emfheader
.rclFrame
.left
) / 2540.0 * header
->DpiX
);
2168 header
->Height
= gdip_round((REAL
)(emfheader
.rclFrame
.bottom
- emfheader
.rclFrame
.top
) / 2540.0 * header
->DpiY
);
2169 header
->u
.EmfHeader
= emfheader
;
2171 if (metafile_type
== MetafileTypeEmfPlusDual
|| metafile_type
== MetafileTypeEmfPlusOnly
)
2173 header
->Version
= emfplusheader
.Version
;
2174 header
->EmfPlusFlags
= emfplusheader
.EmfPlusFlags
;
2175 header
->EmfPlusHeaderSize
= emfplusheader
.Header
.Size
;
2176 header
->LogicalDpiX
= emfplusheader
.LogicalDpiX
;
2177 header
->LogicalDpiY
= emfplusheader
.LogicalDpiY
;
2181 header
->Version
= emfheader
.nVersion
;
2182 header
->EmfPlusFlags
= 0;
2183 header
->EmfPlusHeaderSize
= 0;
2184 header
->LogicalDpiX
= 0;
2185 header
->LogicalDpiY
= 0;
2191 GpStatus WINGDIPAPI
GdipGetMetafileHeaderFromWmf(HMETAFILE hwmf
,
2192 GDIPCONST WmfPlaceableFileHeader
*placeable
, MetafileHeader
*header
)
2195 GpMetafile
*metafile
;
2197 TRACE("(%p,%p,%p)\n", hwmf
, placeable
, header
);
2199 status
= GdipCreateMetafileFromWmf(hwmf
, FALSE
, placeable
, &metafile
);
2202 status
= GdipGetMetafileHeaderFromMetafile(metafile
, header
);
2203 GdipDisposeImage(&metafile
->image
);
2208 GpStatus WINGDIPAPI
GdipGetMetafileHeaderFromFile(GDIPCONST WCHAR
*filename
,
2209 MetafileHeader
*header
)
2212 GpMetafile
*metafile
;
2214 TRACE("(%s,%p)\n", debugstr_w(filename
), header
);
2216 if (!filename
|| !header
)
2217 return InvalidParameter
;
2219 status
= GdipCreateMetafileFromFile(filename
, &metafile
);
2222 status
= GdipGetMetafileHeaderFromMetafile(metafile
, header
);
2223 GdipDisposeImage(&metafile
->image
);
2228 GpStatus WINGDIPAPI
GdipGetMetafileHeaderFromStream(IStream
*stream
,
2229 MetafileHeader
*header
)
2232 GpMetafile
*metafile
;
2234 TRACE("(%p,%p)\n", stream
, header
);
2236 if (!stream
|| !header
)
2237 return InvalidParameter
;
2239 status
= GdipCreateMetafileFromStream(stream
, &metafile
);
2242 status
= GdipGetMetafileHeaderFromMetafile(metafile
, header
);
2243 GdipDisposeImage(&metafile
->image
);
2248 GpStatus WINGDIPAPI
GdipCreateMetafileFromEmf(HENHMETAFILE hemf
, BOOL
delete,
2249 GpMetafile
**metafile
)
2252 MetafileHeader header
;
2254 TRACE("(%p,%i,%p)\n", hemf
, delete, metafile
);
2256 if(!hemf
|| !metafile
)
2257 return InvalidParameter
;
2259 stat
= GdipGetMetafileHeaderFromEmf(hemf
, &header
);
2263 *metafile
= heap_alloc_zero(sizeof(GpMetafile
));
2267 (*metafile
)->image
.type
= ImageTypeMetafile
;
2268 (*metafile
)->image
.format
= ImageFormatEMF
;
2269 (*metafile
)->image
.frame_count
= 1;
2270 (*metafile
)->image
.xres
= header
.DpiX
;
2271 (*metafile
)->image
.yres
= header
.DpiY
;
2272 (*metafile
)->bounds
.X
= (REAL
)header
.u
.EmfHeader
.rclFrame
.left
/ 2540.0 * header
.DpiX
;
2273 (*metafile
)->bounds
.Y
= (REAL
)header
.u
.EmfHeader
.rclFrame
.top
/ 2540.0 * header
.DpiY
;
2274 (*metafile
)->bounds
.Width
= (REAL
)(header
.u
.EmfHeader
.rclFrame
.right
- header
.u
.EmfHeader
.rclFrame
.left
)
2275 / 2540.0 * header
.DpiX
;
2276 (*metafile
)->bounds
.Height
= (REAL
)(header
.u
.EmfHeader
.rclFrame
.bottom
- header
.u
.EmfHeader
.rclFrame
.top
)
2277 / 2540.0 * header
.DpiY
;
2278 (*metafile
)->unit
= UnitPixel
;
2279 (*metafile
)->metafile_type
= header
.Type
;
2280 (*metafile
)->hemf
= hemf
;
2281 (*metafile
)->preserve_hemf
= !delete;
2282 list_init(&(*metafile
)->containers
);
2284 TRACE("<-- %p\n", *metafile
);
2289 GpStatus WINGDIPAPI
GdipCreateMetafileFromWmf(HMETAFILE hwmf
, BOOL
delete,
2290 GDIPCONST WmfPlaceableFileHeader
* placeable
, GpMetafile
**metafile
)
2295 GpStatus retval
= Ok
;
2297 TRACE("(%p, %d, %p, %p)\n", hwmf
, delete, placeable
, metafile
);
2299 if(!hwmf
|| !metafile
)
2300 return InvalidParameter
;
2303 read
= GetMetaFileBitsEx(hwmf
, 0, NULL
);
2305 return GenericError
;
2306 copy
= heap_alloc_zero(read
);
2307 GetMetaFileBitsEx(hwmf
, read
, copy
);
2309 hemf
= SetWinMetaFileBits(read
, copy
, NULL
, NULL
);
2312 /* FIXME: We should store and use hwmf instead of converting to hemf */
2313 retval
= GdipCreateMetafileFromEmf(hemf
, TRUE
, metafile
);
2319 (*metafile
)->image
.xres
= (REAL
)placeable
->Inch
;
2320 (*metafile
)->image
.yres
= (REAL
)placeable
->Inch
;
2321 (*metafile
)->bounds
.X
= ((REAL
)placeable
->BoundingBox
.Left
) / ((REAL
)placeable
->Inch
);
2322 (*metafile
)->bounds
.Y
= ((REAL
)placeable
->BoundingBox
.Top
) / ((REAL
)placeable
->Inch
);
2323 (*metafile
)->bounds
.Width
= (REAL
)(placeable
->BoundingBox
.Right
-
2324 placeable
->BoundingBox
.Left
);
2325 (*metafile
)->bounds
.Height
= (REAL
)(placeable
->BoundingBox
.Bottom
-
2326 placeable
->BoundingBox
.Top
);
2327 (*metafile
)->metafile_type
= MetafileTypeWmfPlaceable
;
2330 (*metafile
)->metafile_type
= MetafileTypeWmf
;
2331 (*metafile
)->image
.format
= ImageFormatWMF
;
2333 if (delete) DeleteMetaFile(hwmf
);
2336 DeleteEnhMetaFile(hemf
);
2340 GpStatus WINGDIPAPI
GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR
*file
,
2341 GDIPCONST WmfPlaceableFileHeader
* placeable
, GpMetafile
**metafile
)
2346 TRACE("(%s, %p, %p)\n", debugstr_w(file
), placeable
, metafile
);
2348 hmf
= GetMetaFileW(file
);
2350 return GdipCreateMetafileFromWmf(hmf
, TRUE
, placeable
, metafile
);
2352 emf
= GetEnhMetaFileW(file
);
2354 return GdipCreateMetafileFromEmf(emf
, TRUE
, metafile
);
2356 return GenericError
;
2359 GpStatus WINGDIPAPI
GdipCreateMetafileFromFile(GDIPCONST WCHAR
*file
,
2360 GpMetafile
**metafile
)
2365 TRACE("(%p, %p)\n", file
, metafile
);
2367 if (!file
|| !metafile
) return InvalidParameter
;
2371 status
= GdipCreateStreamOnFile(file
, GENERIC_READ
, &stream
);
2374 status
= GdipCreateMetafileFromStream(stream
, metafile
);
2375 IStream_Release(stream
);
2380 GpStatus WINGDIPAPI
GdipCreateMetafileFromStream(IStream
*stream
,
2381 GpMetafile
**metafile
)
2385 TRACE("%p %p\n", stream
, metafile
);
2387 stat
= GdipLoadImageFromStream(stream
, (GpImage
**)metafile
);
2388 if (stat
!= Ok
) return stat
;
2390 if ((*metafile
)->image
.type
!= ImageTypeMetafile
)
2392 GdipDisposeImage(&(*metafile
)->image
);
2394 return GenericError
;
2400 GpStatus WINGDIPAPI
GdipSetMetafileDownLevelRasterizationLimit(GpMetafile
*metafile
,
2403 TRACE("(%p,%u)\n", metafile
, limitDpi
);
2408 GpStatus WINGDIPAPI
GdipConvertToEmfPlus(const GpGraphics
* ref
,
2409 GpMetafile
* metafile
, BOOL
* succ
, EmfType emfType
,
2410 const WCHAR
* description
, GpMetafile
** out_metafile
)
2414 TRACE("(%p,%p,%p,%u,%s,%p)\n", ref
, metafile
, succ
, emfType
,
2415 debugstr_w(description
), out_metafile
);
2417 if(!ref
|| !metafile
|| !out_metafile
|| emfType
< EmfTypeEmfOnly
|| emfType
> EmfTypeEmfPlusDual
)
2418 return InvalidParameter
;
2422 *out_metafile
= NULL
;
2425 FIXME("not implemented\n");
2427 return NotImplemented
;
2430 GpStatus WINGDIPAPI
GdipEmfToWmfBits(HENHMETAFILE hemf
, UINT cbData16
,
2431 LPBYTE pData16
, INT iMapMode
, INT eFlags
)
2433 FIXME("(%p, %d, %p, %d, %d): stub\n", hemf
, cbData16
, pData16
, iMapMode
, eFlags
);
2434 return NotImplemented
;
2437 GpStatus WINGDIPAPI
GdipRecordMetafileFileName(GDIPCONST WCHAR
* fileName
,
2438 HDC hdc
, EmfType type
, GDIPCONST GpRectF
*pFrameRect
,
2439 MetafileFrameUnit frameUnit
, GDIPCONST WCHAR
*desc
,
2440 GpMetafile
**metafile
)
2442 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName
), hdc
, type
, pFrameRect
,
2443 frameUnit
, debugstr_w(desc
), metafile
);
2445 return NotImplemented
;
2448 GpStatus WINGDIPAPI
GdipRecordMetafileFileNameI(GDIPCONST WCHAR
* fileName
, HDC hdc
, EmfType type
,
2449 GDIPCONST GpRect
*pFrameRect
, MetafileFrameUnit frameUnit
,
2450 GDIPCONST WCHAR
*desc
, GpMetafile
**metafile
)
2452 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName
), hdc
, type
, pFrameRect
,
2453 frameUnit
, debugstr_w(desc
), metafile
);
2455 return NotImplemented
;
2458 /*****************************************************************************
2459 * GdipConvertToEmfPlusToFile [GDIPLUS.@]
2462 GpStatus WINGDIPAPI
GdipConvertToEmfPlusToFile(const GpGraphics
* refGraphics
,
2463 GpMetafile
* metafile
, BOOL
* conversionSuccess
,
2464 const WCHAR
* filename
, EmfType emfType
,
2465 const WCHAR
* description
, GpMetafile
** out_metafile
)
2467 FIXME("stub: %p, %p, %p, %p, %u, %p, %p\n", refGraphics
, metafile
, conversionSuccess
, filename
, emfType
, description
, out_metafile
);
2468 return NotImplemented
;
2471 static GpStatus
METAFILE_CreateCompressedImageStream(GpImage
*image
, IStream
**stream
, DWORD
*size
)
2480 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, stream
);
2481 if (FAILED(hr
)) return hresult_to_status(hr
);
2483 stat
= encode_image_png(image
, *stream
, NULL
);
2486 IStream_Release(*stream
);
2490 hr
= IStream_Stat(*stream
, &statstg
, 1);
2493 IStream_Release(*stream
);
2494 return hresult_to_status(hr
);
2496 *size
= statstg
.cbSize
.u
.LowPart
;
2499 hr
= IStream_Seek(*stream
, zero
, STREAM_SEEK_SET
, NULL
);
2502 IStream_Release(*stream
);
2503 return hresult_to_status(hr
);
2509 static GpStatus
METAFILE_FillEmfPlusBitmap(EmfPlusBitmap
*record
, IStream
*stream
, DWORD size
)
2516 record
->PixelFormat
= 0;
2517 record
->Type
= BitmapDataTypeCompressed
;
2519 hr
= IStream_Read(stream
, record
->BitmapData
, size
, NULL
);
2520 if (FAILED(hr
)) return hresult_to_status(hr
);
2524 static GpStatus
METAFILE_AddImageObject(GpMetafile
*metafile
, GpImage
*image
, DWORD
*id
)
2526 EmfPlusObject
*object_record
;
2532 if (metafile
->metafile_type
!= MetafileTypeEmfPlusOnly
&& metafile
->metafile_type
!= MetafileTypeEmfPlusDual
)
2535 if (image
->type
== ImageTypeBitmap
)
2540 stat
= METAFILE_CreateCompressedImageStream(image
, &stream
, &size
);
2541 if (stat
!= Ok
) return stat
;
2542 aligned_size
= (size
+ 3) & ~3;
2544 stat
= METAFILE_AllocateRecord(metafile
,
2545 FIELD_OFFSET(EmfPlusObject
, ObjectData
.image
.ImageData
.bitmap
.BitmapData
[aligned_size
]),
2546 (void**)&object_record
);
2549 IStream_Release(stream
);
2552 memset(object_record
->ObjectData
.image
.ImageData
.bitmap
.BitmapData
+ size
, 0, aligned_size
- size
);
2554 *id
= METAFILE_AddObjectId(metafile
);
2555 object_record
->Header
.Type
= EmfPlusRecordTypeObject
;
2556 object_record
->Header
.Flags
= *id
| ObjectTypeImage
<< 8;
2557 object_record
->ObjectData
.image
.Version
= VERSION_MAGIC2
;
2558 object_record
->ObjectData
.image
.Type
= ImageDataTypeBitmap
;
2560 stat
= METAFILE_FillEmfPlusBitmap(&object_record
->ObjectData
.image
.ImageData
.bitmap
, stream
, size
);
2561 IStream_Release(stream
);
2562 if (stat
!= Ok
) METAFILE_RemoveLastRecord(metafile
, &object_record
->Header
);
2565 else if (image
->type
== ImageTypeMetafile
)
2567 HENHMETAFILE hemf
= ((GpMetafile
*)image
)->hemf
;
2568 EmfPlusMetafile
*metafile_record
;
2570 if (!hemf
) return InvalidParameter
;
2572 size
= GetEnhMetaFileBits(hemf
, 0, NULL
);
2573 if (!size
) return GenericError
;
2575 stat
= METAFILE_AllocateRecord(metafile
,
2576 FIELD_OFFSET(EmfPlusObject
, ObjectData
.image
.ImageData
.metafile
.MetafileData
[size
]),
2577 (void**)&object_record
);
2578 if (stat
!= Ok
) return stat
;
2580 *id
= METAFILE_AddObjectId(metafile
);
2581 object_record
->Header
.Type
= EmfPlusRecordTypeObject
;
2582 object_record
->Header
.Flags
= *id
| ObjectTypeImage
<< 8;
2583 object_record
->ObjectData
.image
.Version
= VERSION_MAGIC2
;
2584 object_record
->ObjectData
.image
.Type
= ImageDataTypeMetafile
;
2585 metafile_record
= &object_record
->ObjectData
.image
.ImageData
.metafile
;
2586 metafile_record
->Type
= ((GpMetafile
*)image
)->metafile_type
;
2587 metafile_record
->MetafileDataSize
= size
;
2588 if (GetEnhMetaFileBits(hemf
, size
, metafile_record
->MetafileData
) != size
)
2590 METAFILE_RemoveLastRecord(metafile
, &object_record
->Header
);
2591 return GenericError
;
2597 FIXME("not supported image type (%d)\n", image
->type
);
2598 return NotImplemented
;
2602 static GpStatus
METAFILE_AddImageAttributesObject(GpMetafile
*metafile
, const GpImageAttributes
*attrs
, DWORD
*id
)
2604 EmfPlusObject
*object_record
;
2605 EmfPlusImageAttributes
*attrs_record
;
2610 if (metafile
->metafile_type
!= MetafileTypeEmfPlusOnly
&& metafile
->metafile_type
!= MetafileTypeEmfPlusDual
)
2616 stat
= METAFILE_AllocateRecord(metafile
,
2617 FIELD_OFFSET(EmfPlusObject
, ObjectData
.image_attributes
) + sizeof(EmfPlusImageAttributes
),
2618 (void**)&object_record
);
2619 if (stat
!= Ok
) return stat
;
2621 *id
= METAFILE_AddObjectId(metafile
);
2622 object_record
->Header
.Type
= EmfPlusRecordTypeObject
;
2623 object_record
->Header
.Flags
= *id
| (ObjectTypeImageAttributes
<< 8);
2624 attrs_record
= &object_record
->ObjectData
.image_attributes
;
2625 attrs_record
->Version
= VERSION_MAGIC2
;
2626 attrs_record
->Reserved1
= 0;
2627 attrs_record
->WrapMode
= attrs
->wrap
;
2628 attrs_record
->ClampColor
.Blue
= attrs
->outside_color
& 0xff;
2629 attrs_record
->ClampColor
.Green
= (attrs
->outside_color
>> 8) & 0xff;
2630 attrs_record
->ClampColor
.Red
= (attrs
->outside_color
>> 16) & 0xff;
2631 attrs_record
->ClampColor
.Alpha
= attrs
->outside_color
>> 24;
2632 attrs_record
->ObjectClamp
= attrs
->clamp
;
2633 attrs_record
->Reserved2
= 0;
2637 GpStatus
METAFILE_DrawImagePointsRect(GpMetafile
*metafile
, GpImage
*image
,
2638 GDIPCONST GpPointF
*points
, INT count
, REAL srcx
, REAL srcy
, REAL srcwidth
,
2639 REAL srcheight
, GpUnit srcUnit
, GDIPCONST GpImageAttributes
* imageAttributes
,
2640 DrawImageAbort callback
, VOID
*callbackData
)
2642 EmfPlusDrawImagePoints
*draw_image_record
;
2643 DWORD image_id
, attributes_id
;
2646 if (count
!= 3) return InvalidParameter
;
2648 if (metafile
->metafile_type
== MetafileTypeEmf
)
2650 FIXME("MetafileTypeEmf metafiles not supported\n");
2651 return NotImplemented
;
2654 FIXME("semi-stub\n");
2656 if (!imageAttributes
)
2658 stat
= METAFILE_AddImageObject(metafile
, image
, &image_id
);
2660 else if (image
->type
== ImageTypeBitmap
)
2662 INT width
= ((GpBitmap
*)image
)->width
;
2663 INT height
= ((GpBitmap
*)image
)->height
;
2664 GpGraphics
*graphics
;
2667 stat
= GdipCreateBitmapFromScan0(width
, height
,
2668 0, PixelFormat32bppARGB
, NULL
, &bitmap
);
2669 if (stat
!= Ok
) return stat
;
2671 stat
= GdipGetImageGraphicsContext((GpImage
*)bitmap
, &graphics
);
2674 GdipDisposeImage((GpImage
*)bitmap
);
2678 stat
= GdipDrawImageRectRectI(graphics
, image
, 0, 0, width
, height
,
2679 0, 0, width
, height
, UnitPixel
, imageAttributes
, NULL
, NULL
);
2680 GdipDeleteGraphics(graphics
);
2683 GdipDisposeImage((GpImage
*)bitmap
);
2687 stat
= METAFILE_AddImageObject(metafile
, (GpImage
*)bitmap
, &image_id
);
2688 GdipDisposeImage((GpImage
*)bitmap
);
2692 FIXME("imageAttributes not supported (image type %d)\n", image
->type
);
2693 return NotImplemented
;
2695 if (stat
!= Ok
) return stat
;
2697 stat
= METAFILE_AddImageAttributesObject(metafile
, imageAttributes
, &attributes_id
);
2698 if (stat
!= Ok
) return stat
;
2700 stat
= METAFILE_AllocateRecord(metafile
, sizeof(EmfPlusDrawImagePoints
), (void**)&draw_image_record
);
2701 if (stat
!= Ok
) return stat
;
2702 draw_image_record
->Header
.Type
= EmfPlusRecordTypeDrawImagePoints
;
2703 draw_image_record
->Header
.Flags
= image_id
;
2704 draw_image_record
->ImageAttributesID
= attributes_id
;
2705 draw_image_record
->SrcUnit
= UnitPixel
;
2706 draw_image_record
->SrcRect
.X
= units_to_pixels(srcx
, srcUnit
, metafile
->image
.xres
);
2707 draw_image_record
->SrcRect
.Y
= units_to_pixels(srcy
, srcUnit
, metafile
->image
.yres
);
2708 draw_image_record
->SrcRect
.Width
= units_to_pixels(srcwidth
, srcUnit
, metafile
->image
.xres
);
2709 draw_image_record
->SrcRect
.Height
= units_to_pixels(srcheight
, srcUnit
, metafile
->image
.yres
);
2710 draw_image_record
->count
= 3;
2711 draw_image_record
->PointData
[0].pointF
.X
= points
[0].X
;
2712 draw_image_record
->PointData
[0].pointF
.Y
= points
[0].Y
;
2713 draw_image_record
->PointData
[1].pointF
.X
= points
[1].X
;
2714 draw_image_record
->PointData
[1].pointF
.Y
= points
[1].Y
;
2715 draw_image_record
->PointData
[2].pointF
.X
= points
[2].X
;
2716 draw_image_record
->PointData
[2].pointF
.Y
= points
[2].Y
;
2717 METAFILE_WriteRecords(metafile
);
2721 GpStatus
METAFILE_AddSimpleProperty(GpMetafile
*metafile
, SHORT prop
, SHORT val
)
2723 EmfPlusRecordHeader
*record
;
2726 if (metafile
->metafile_type
!= MetafileTypeEmfPlusOnly
&& metafile
->metafile_type
!= MetafileTypeEmfPlusDual
)
2729 stat
= METAFILE_AllocateRecord(metafile
, sizeof(*record
), (void**)&record
);
2730 if (stat
!= Ok
) return stat
;
2732 record
->Type
= prop
;
2733 record
->Flags
= val
;
2735 METAFILE_WriteRecords(metafile
);
2739 static GpStatus
METAFILE_AddPathObject(GpMetafile
*metafile
, GpPath
*path
, DWORD
*id
)
2741 EmfPlusObject
*object_record
;
2746 if (metafile
->metafile_type
!= MetafileTypeEmfPlusOnly
&& metafile
->metafile_type
!= MetafileTypeEmfPlusDual
)
2749 size
= write_path_data(path
, NULL
);
2750 stat
= METAFILE_AllocateRecord(metafile
,
2751 FIELD_OFFSET(EmfPlusObject
, ObjectData
.path
) + size
,
2752 (void**)&object_record
);
2753 if (stat
!= Ok
) return stat
;
2755 *id
= METAFILE_AddObjectId(metafile
);
2756 object_record
->Header
.Type
= EmfPlusRecordTypeObject
;
2757 object_record
->Header
.Flags
= *id
| ObjectTypePath
<< 8;
2758 write_path_data(path
, &object_record
->ObjectData
.path
);
2762 static GpStatus
METAFILE_PrepareBrushData(GpBrush
*brush
, DWORD
*size
)
2764 if (brush
->bt
== BrushTypeSolidColor
)
2766 *size
= FIELD_OFFSET(EmfPlusBrush
, BrushData
.solid
) + sizeof(EmfPlusSolidBrushData
);
2770 FIXME("unsupported brush type: %d\n", brush
->bt
);
2771 return NotImplemented
;
2774 static void METAFILE_FillBrushData(GpBrush
*brush
, EmfPlusBrush
*data
)
2776 if (brush
->bt
== BrushTypeSolidColor
)
2778 GpSolidFill
*solid
= (GpSolidFill
*)brush
;
2780 data
->Version
= VERSION_MAGIC2
;
2781 data
->Type
= solid
->brush
.bt
;
2782 data
->BrushData
.solid
.SolidColor
.Blue
= solid
->color
& 0xff;
2783 data
->BrushData
.solid
.SolidColor
.Green
= (solid
->color
>> 8) & 0xff;
2784 data
->BrushData
.solid
.SolidColor
.Red
= (solid
->color
>> 16) & 0xff;
2785 data
->BrushData
.solid
.SolidColor
.Alpha
= solid
->color
>> 24;
2789 static GpStatus
METAFILE_AddPenObject(GpMetafile
*metafile
, GpPen
*pen
, DWORD
*id
)
2791 DWORD i
, data_flags
, pen_data_size
, brush_size
;
2792 EmfPlusObject
*object_record
;
2793 EmfPlusPenData
*pen_data
;
2798 if (metafile
->metafile_type
!= MetafileTypeEmfPlusOnly
&& metafile
->metafile_type
!= MetafileTypeEmfPlusDual
)
2802 pen_data_size
= FIELD_OFFSET(EmfPlusPenData
, OptionalData
);
2804 GdipIsMatrixIdentity(&pen
->transform
, &result
);
2807 data_flags
|= PenDataTransform
;
2808 pen_data_size
+= sizeof(EmfPlusTransformMatrix
);
2810 if (pen
->startcap
!= LineCapFlat
)
2812 data_flags
|= PenDataStartCap
;
2813 pen_data_size
+= sizeof(DWORD
);
2815 if (pen
->endcap
!= LineCapFlat
)
2817 data_flags
|= PenDataEndCap
;
2818 pen_data_size
+= sizeof(DWORD
);
2820 if (pen
->join
!= LineJoinMiter
)
2822 data_flags
|= PenDataJoin
;
2823 pen_data_size
+= sizeof(DWORD
);
2825 if (pen
->miterlimit
!= 10.0)
2827 data_flags
|= PenDataMiterLimit
;
2828 pen_data_size
+= sizeof(REAL
);
2830 if (pen
->style
!= GP_DEFAULT_PENSTYLE
)
2832 data_flags
|= PenDataLineStyle
;
2833 pen_data_size
+= sizeof(DWORD
);
2835 if (pen
->dashcap
!= DashCapFlat
)
2837 data_flags
|= PenDataDashedLineCap
;
2838 pen_data_size
+= sizeof(DWORD
);
2840 data_flags
|= PenDataDashedLineOffset
;
2841 pen_data_size
+= sizeof(REAL
);
2844 data_flags
|= PenDataDashedLine
;
2845 pen_data_size
+= sizeof(DWORD
) + pen
->numdashes
*sizeof(REAL
);
2847 if (pen
->align
!= PenAlignmentCenter
)
2849 data_flags
|= PenDataNonCenter
;
2850 pen_data_size
+= sizeof(DWORD
);
2852 /* TODO: Add support for PenDataCompoundLine */
2853 if (pen
->customstart
)
2855 FIXME("ignoring custom start cup\n");
2859 FIXME("ignoring custom end cup\n");
2862 stat
= METAFILE_PrepareBrushData(pen
->brush
, &brush_size
);
2863 if (stat
!= Ok
) return stat
;
2865 stat
= METAFILE_AllocateRecord(metafile
,
2866 FIELD_OFFSET(EmfPlusObject
, ObjectData
.pen
.data
) + pen_data_size
+ brush_size
,
2867 (void**)&object_record
);
2868 if (stat
!= Ok
) return stat
;
2870 *id
= METAFILE_AddObjectId(metafile
);
2871 object_record
->Header
.Type
= EmfPlusRecordTypeObject
;
2872 object_record
->Header
.Flags
= *id
| ObjectTypePen
<< 8;
2873 object_record
->ObjectData
.pen
.Version
= VERSION_MAGIC2
;
2874 object_record
->ObjectData
.pen
.Type
= 0;
2876 pen_data
= (EmfPlusPenData
*)object_record
->ObjectData
.pen
.data
;
2877 pen_data
->PenDataFlags
= data_flags
;
2878 pen_data
->PenUnit
= pen
->unit
;
2879 pen_data
->PenWidth
= pen
->width
;
2882 if (data_flags
& PenDataTransform
)
2884 EmfPlusTransformMatrix
*m
= (EmfPlusTransformMatrix
*)(pen_data
->OptionalData
+ i
);
2885 memcpy(m
, &pen
->transform
, sizeof(*m
));
2886 i
+= sizeof(EmfPlusTransformMatrix
);
2888 if (data_flags
& PenDataStartCap
)
2890 *(DWORD
*)(pen_data
->OptionalData
+ i
) = pen
->startcap
;
2893 if (data_flags
& PenDataEndCap
)
2895 *(DWORD
*)(pen_data
->OptionalData
+ i
) = pen
->endcap
;
2898 if (data_flags
& PenDataJoin
)
2900 *(DWORD
*)(pen_data
->OptionalData
+ i
) = pen
->join
;
2903 if (data_flags
& PenDataMiterLimit
)
2905 *(REAL
*)(pen_data
->OptionalData
+ i
) = pen
->miterlimit
;
2908 if (data_flags
& PenDataLineStyle
)
2910 switch (pen
->style
& PS_STYLE_MASK
)
2912 case PS_SOLID
: *(DWORD
*)(pen_data
->OptionalData
+ i
) = LineStyleSolid
; break;
2913 case PS_DASH
: *(DWORD
*)(pen_data
->OptionalData
+ i
) = LineStyleDash
; break;
2914 case PS_DOT
: *(DWORD
*)(pen_data
->OptionalData
+ i
) = LineStyleDot
; break;
2915 case PS_DASHDOT
: *(DWORD
*)(pen_data
->OptionalData
+ i
) = LineStyleDashDot
; break;
2916 case PS_DASHDOTDOT
: *(DWORD
*)(pen_data
->OptionalData
+ i
) = LineStyleDashDotDot
; break;
2917 default: *(DWORD
*)(pen_data
->OptionalData
+ i
) = LineStyleCustom
; break;
2921 if (data_flags
& PenDataDashedLineCap
)
2923 *(DWORD
*)(pen_data
->OptionalData
+ i
) = pen
->dashcap
;
2926 if (data_flags
& PenDataDashedLineOffset
)
2928 *(REAL
*)(pen_data
->OptionalData
+ i
) = pen
->offset
;
2931 if (data_flags
& PenDataDashedLine
)
2935 *(DWORD
*)(pen_data
->OptionalData
+ i
) = pen
->numdashes
;
2938 for (j
=0; j
<pen
->numdashes
; j
++)
2940 *(REAL
*)(pen_data
->OptionalData
+ i
) = pen
->dashes
[j
];
2944 if (data_flags
& PenDataNonCenter
)
2946 *(REAL
*)(pen_data
->OptionalData
+ i
) = pen
->align
;
2950 METAFILE_FillBrushData(pen
->brush
,
2951 (EmfPlusBrush
*)(object_record
->ObjectData
.pen
.data
+ pen_data_size
));
2955 GpStatus
METAFILE_DrawPath(GpMetafile
*metafile
, GpPen
*pen
, GpPath
*path
)
2957 EmfPlusDrawPath
*draw_path_record
;
2962 if (metafile
->metafile_type
== MetafileTypeEmf
)
2965 return NotImplemented
;
2968 stat
= METAFILE_AddPenObject(metafile
, pen
, &pen_id
);
2969 if (stat
!= Ok
) return stat
;
2971 stat
= METAFILE_AddPathObject(metafile
, path
, &path_id
);
2972 if (stat
!= Ok
) return stat
;
2974 stat
= METAFILE_AllocateRecord(metafile
, sizeof(EmfPlusDrawPath
), (void**)&draw_path_record
);
2975 if (stat
!= Ok
) return stat
;
2976 draw_path_record
->Header
.Type
= EmfPlusRecordTypeDrawPath
;
2977 draw_path_record
->Header
.Flags
= path_id
;
2978 draw_path_record
->PenId
= pen_id
;
2980 METAFILE_WriteRecords(metafile
);
2984 static GpStatus
METAFILE_AddBrushObject(GpMetafile
*metafile
, GpBrush
*brush
, DWORD
*id
)
2986 EmfPlusObject
*object_record
;
2991 if (metafile
->metafile_type
!= MetafileTypeEmfPlusOnly
&& metafile
->metafile_type
!= MetafileTypeEmfPlusDual
)
2994 stat
= METAFILE_PrepareBrushData(brush
, &size
);
2995 if (stat
!= Ok
) return stat
;
2997 stat
= METAFILE_AllocateRecord(metafile
,
2998 FIELD_OFFSET(EmfPlusObject
, ObjectData
) + size
, (void**)&object_record
);
2999 if (stat
!= Ok
) return stat
;
3001 *id
= METAFILE_AddObjectId(metafile
);
3002 object_record
->Header
.Type
= EmfPlusRecordTypeObject
;
3003 object_record
->Header
.Flags
= *id
| ObjectTypeBrush
<< 8;
3004 METAFILE_FillBrushData(brush
, &object_record
->ObjectData
.brush
);
3008 GpStatus
METAFILE_FillPath(GpMetafile
*metafile
, GpBrush
*brush
, GpPath
*path
)
3010 EmfPlusFillPath
*fill_path_record
;
3011 DWORD brush_id
= -1, path_id
;
3015 if (metafile
->metafile_type
== MetafileTypeEmf
)
3018 return NotImplemented
;
3021 inline_color
= brush
->bt
== BrushTypeSolidColor
;
3024 stat
= METAFILE_AddBrushObject(metafile
, brush
, &brush_id
);
3025 if (stat
!= Ok
) return stat
;
3028 stat
= METAFILE_AddPathObject(metafile
, path
, &path_id
);
3029 if (stat
!= Ok
) return stat
;
3031 stat
= METAFILE_AllocateRecord(metafile
,
3032 sizeof(EmfPlusFillPath
), (void**)&fill_path_record
);
3033 if (stat
!= Ok
) return stat
;
3034 fill_path_record
->Header
.Type
= EmfPlusRecordTypeFillPath
;
3037 fill_path_record
->Header
.Flags
= 0x8000 | path_id
;
3038 fill_path_record
->data
.Color
.Blue
= ((GpSolidFill
*)brush
)->color
& 0xff;
3039 fill_path_record
->data
.Color
.Green
= (((GpSolidFill
*)brush
)->color
>> 8) & 0xff;
3040 fill_path_record
->data
.Color
.Red
= (((GpSolidFill
*)brush
)->color
>> 16) & 0xff;
3041 fill_path_record
->data
.Color
.Alpha
= ((GpSolidFill
*)brush
)->color
>> 24;
3045 fill_path_record
->Header
.Flags
= path_id
;
3046 fill_path_record
->data
.BrushId
= brush_id
;
3049 METAFILE_WriteRecords(metafile
);