2 * Enhanced metafile functions
3 * Copyright 1998 Douglas Ridgway
7 * The enhanced format consists of the following elements:
10 * A table of handles to GDI objects
11 * An array of metafile records
15 * The standard format consists of a header and an array of metafile records.
23 #include "wine/winestring.h"
25 #include "enhmetafile.h"
26 #include "debugtools.h"
30 DEFAULT_DEBUG_CHANNEL(enhmetafile
)
33 BOOL WINAPI
EnumEnhMetaFile( HDC hdc
, HENHMETAFILE hmf
, ENHMFENUMPROC callback
,
34 LPVOID data
, const RECT
*rect
);
37 /****************************************************************************
38 * EMF_Create_HENHMETAFILE
40 HENHMETAFILE
EMF_Create_HENHMETAFILE(ENHMETAHEADER
*emh
, HFILE hFile
, HANDLE
43 HENHMETAFILE hmf
= GDI_AllocObject( sizeof(ENHMETAFILEOBJ
),
45 ENHMETAFILEOBJ
*metaObj
= (ENHMETAFILEOBJ
*)GDI_HEAP_LOCK( hmf
);
47 metaObj
->hFile
= hFile
;
48 metaObj
->hMapping
= hMapping
;
49 GDI_HEAP_UNLOCK( hmf
);
53 /****************************************************************************
54 * EMF_Delete_HENHMETAFILE
56 static BOOL
EMF_Delete_HENHMETAFILE( HENHMETAFILE hmf
)
58 ENHMETAFILEOBJ
*metaObj
= (ENHMETAFILEOBJ
*)GDI_GetObjPtr( hmf
,
60 if(!metaObj
) return FALSE
;
61 if(metaObj
->hMapping
) {
62 UnmapViewOfFile( metaObj
->emh
);
63 CloseHandle( metaObj
->hMapping
);
64 CloseHandle( metaObj
->hFile
);
66 HeapFree( SystemHeap
, 0, metaObj
->emh
);
67 return GDI_FreeObject( hmf
);
70 /******************************************************************
71 * EMF_GetEnhMetaHeader
73 * Returns ptr to ENHMETAHEADER associated with HENHMETAFILE
74 * Should be followed by call to EMF_ReleaseEnhMetaHeader
76 static ENHMETAHEADER
*EMF_GetEnhMetaHeader( HENHMETAFILE hmf
)
78 ENHMETAFILEOBJ
*metaObj
= (ENHMETAFILEOBJ
*)GDI_GetObjPtr( hmf
,
80 TRACE("hmf %04x -> enhmetaObj %p\n", hmf
, metaObj
);
81 return metaObj
? metaObj
->emh
: NULL
;
84 /******************************************************************
85 * EMF_ReleaseEnhMetaHeader
87 * Releases ENHMETAHEADER associated with HENHMETAFILE
89 static BOOL
EMF_ReleaseEnhMetaHeader( HENHMETAFILE hmf
)
91 return GDI_HEAP_UNLOCK( hmf
);
94 /*****************************************************************************
98 static HENHMETAFILE
EMF_GetEnhMetaFile( HFILE hFile
)
103 hMapping
= CreateFileMappingA( hFile
, NULL
, PAGE_READONLY
, 0, 0, NULL
);
104 emh
= MapViewOfFile( hMapping
, FILE_MAP_READ
, 0, 0, 0 );
106 if (emh
->iType
!= EMR_HEADER
|| emh
->dSignature
!= ENHMETA_SIGNATURE
) {
107 WARN("Invalid emf header type 0x%08lx sig 0x%08lx.\n",
108 emh
->iType
, emh
->dSignature
);
109 UnmapViewOfFile( emh
);
110 CloseHandle( hMapping
);
113 return EMF_Create_HENHMETAFILE( emh
, hFile
, hMapping
);
117 /*****************************************************************************
118 * GetEnhMetaFileA (GDI32.174)
122 HENHMETAFILE WINAPI
GetEnhMetaFileA(
123 LPCSTR lpszMetaFile
/* filename of enhanced metafile */
129 hFile
= CreateFileA(lpszMetaFile
, GENERIC_READ
, FILE_SHARE_READ
, 0,
130 OPEN_EXISTING
, 0, 0);
131 if (hFile
== INVALID_HANDLE_VALUE
) {
132 WARN("could not open %s\n", lpszMetaFile
);
135 hmf
= EMF_GetEnhMetaFile( hFile
);
137 CloseHandle( hFile
);
141 /*****************************************************************************
142 * GetEnhMetaFile32W (GDI32.180)
144 HENHMETAFILE WINAPI
GetEnhMetaFileW(
145 LPCWSTR lpszMetaFile
) /* filename of enhanced metafile */
150 hFile
= CreateFileW(lpszMetaFile
, GENERIC_READ
, FILE_SHARE_READ
, 0,
151 OPEN_EXISTING
, 0, 0);
152 if (hFile
== INVALID_HANDLE_VALUE
) {
153 WARN("could not open %s\n", debugstr_w(lpszMetaFile
));
156 hmf
= EMF_GetEnhMetaFile( hFile
);
158 CloseHandle( hFile
);
162 /*****************************************************************************
163 * GetEnhMetaFileHeader (GDI32.178)
165 * If _buf_ is NULL, returns the size of buffer required.
166 * Otherwise, copy up to _bufsize_ bytes of enhanced metafile header into
169 UINT WINAPI
GetEnhMetaFileHeader(
170 HENHMETAFILE hmf
, /* enhanced metafile */
171 UINT bufsize
, /* size of buffer */
172 LPENHMETAHEADER buf
/* buffer */
177 if (!buf
) return sizeof(ENHMETAHEADER
);
178 emh
= EMF_GetEnhMetaHeader(hmf
);
179 if(!emh
) return FALSE
;
180 memmove(buf
, emh
, MIN(sizeof(ENHMETAHEADER
), bufsize
));
181 EMF_ReleaseEnhMetaHeader(hmf
);
182 return MIN(sizeof(ENHMETAHEADER
), bufsize
);
186 /*****************************************************************************
187 * GetEnhMetaFileDescription32A (GDI32.176)
189 UINT WINAPI
GetEnhMetaFileDescriptionA(
190 HENHMETAFILE hmf
, /* enhanced metafile */
191 UINT size
, /* size of buf */
192 LPSTR buf
/* buffer to receive description */
195 LPENHMETAHEADER emh
= EMF_GetEnhMetaHeader(hmf
);
198 if(!emh
) return FALSE
;
199 if(emh
->nDescription
== 0 || emh
->offDescription
== 0) {
200 EMF_ReleaseEnhMetaHeader(hmf
);
203 if (!buf
|| !size
) {
204 EMF_ReleaseEnhMetaHeader(hmf
);
205 return emh
->nDescription
;
208 first
= lstrlenW( (WCHAR
*) ((char *) emh
+ emh
->offDescription
));
210 lstrcpynWtoA(buf
, (WCHAR
*) ((char *) emh
+ emh
->offDescription
), size
);
212 lstrcpynWtoA(buf
, (WCHAR
*) ((char *) emh
+ emh
->offDescription
+2*(first
+1)),
215 EMF_ReleaseEnhMetaHeader(hmf
);
216 return MIN(size
, emh
->nDescription
);
219 /*****************************************************************************
220 * GetEnhMetaFileDescription32W (GDI32.177)
222 * Copies the description string of an enhanced metafile into a buffer
225 * If _buf_ is NULL, returns size of _buf_ required. Otherwise, returns
226 * number of characters copied.
228 UINT WINAPI
GetEnhMetaFileDescriptionW(
229 HENHMETAFILE hmf
, /* enhanced metafile */
230 UINT size
, /* size of buf */
231 LPWSTR buf
/* buffer to receive description */
234 LPENHMETAHEADER emh
= EMF_GetEnhMetaHeader(hmf
);
236 if(!emh
) return FALSE
;
237 if(emh
->nDescription
== 0 || emh
->offDescription
== 0) {
238 EMF_ReleaseEnhMetaHeader(hmf
);
241 if (!buf
|| !size
) {
242 EMF_ReleaseEnhMetaHeader(hmf
);
243 return emh
->nDescription
;
246 memmove(buf
, (char *) emh
+ emh
->offDescription
,
247 MIN(size
,emh
->nDescription
));
248 EMF_ReleaseEnhMetaHeader(hmf
);
249 return MIN(size
, emh
->nDescription
);
252 /****************************************************************************
253 * SetEnhMetaFileBits (GDI32.315)
255 * Creates an enhanced metafile by copying _bufsize_ bytes from _buf_.
257 HENHMETAFILE WINAPI
SetEnhMetaFileBits(UINT bufsize
, const BYTE
*buf
)
259 ENHMETAHEADER
*emh
= HeapAlloc( SystemHeap
, 0, bufsize
);
260 memmove(emh
, buf
, bufsize
);
261 return EMF_Create_HENHMETAFILE( emh
, 0, 0 );
264 INT CALLBACK
cbCountSizeOfEnhMetaFile( HDC a
,
266 LPENHMETARECORD lpEMR
,
270 LPUINT uSizeOfRecordData
= (LPUINT
)lpData
;
272 uSizeOfRecordData
+= lpEMR
->nSize
;
277 /*****************************************************************************
278 * GetEnhMetaFileBits (GDI32.175)
281 UINT WINAPI
GetEnhMetaFileBits(
287 LPENHMETAHEADER lpEnhMetaFile
;
288 UINT uEnhMetaFileSize
= 0;
290 FIXME( "(%04x,%u,%p): untested\n", hmf
, bufsize
, buf
);
292 /* Determine the required buffer size */
293 /* Enumerate all records and count their size */
294 if( !EnumEnhMetaFile( 0, hmf
, cbCountSizeOfEnhMetaFile
, &uEnhMetaFileSize
, NULL
) )
296 ERR( "Unable to enumerate enhanced metafile!\n" );
302 return uEnhMetaFileSize
;
305 /* Copy the lesser of the two byte counts */
306 uEnhMetaFileSize
= MIN( uEnhMetaFileSize
, bufsize
);
308 /* Copy everything */
309 lpEnhMetaFile
= EMF_GetEnhMetaHeader( hmf
);
311 if( lpEnhMetaFile
== NULL
)
316 /* Use memmove just in case they overlap */
317 memmove(buf
, lpEnhMetaFile
, bufsize
);
319 EMF_ReleaseEnhMetaHeader( hmf
);
324 /*****************************************************************************
325 * PlayEnhMetaFileRecord (GDI32.264)
327 * Render a single enhanced metafile record in the device context hdc.
330 * TRUE on success, FALSE on error.
332 * Many unimplemented records.
334 BOOL WINAPI
PlayEnhMetaFileRecord(
335 HDC hdc
, /* device context in which to render EMF record */
336 LPHANDLETABLE handletable
, /* array of handles to be used in rendering record */
337 const ENHMETARECORD
*mr
, /* EMF record to render */
338 UINT handles
/* size of handle array */
343 "hdc = %08x, handletable = %p, record = %p, numHandles = %d\n",
344 hdc
, handletable
, mr
, handles
);
345 if (!mr
) return FALSE
;
349 TRACE(" type=%d\n", type
);
354 /* ENHMETAHEADER *h = (LPENHMETAHEADER) mr; */
361 PEMRGDICOMMENT lpGdiComment
= (PEMRGDICOMMENT
)mr
;
362 /* In an enhanced metafile, there can be both public and private GDI comments */
363 GdiComment( hdc
, lpGdiComment
->cbData
, lpGdiComment
->Data
);
368 DWORD mode
= mr
->dParm
[0];
369 SetMapMode(hdc
, mode
);
374 DWORD mode
= mr
->dParm
[0];
375 SetBkMode(hdc
, mode
);
380 DWORD mode
= mr
->dParm
[0];
381 SetBkColor(hdc
, mode
);
384 case EMR_SETPOLYFILLMODE
:
386 DWORD mode
= mr
->dParm
[0];
387 SetPolyFillMode(hdc
, mode
);
392 DWORD mode
= mr
->dParm
[0];
396 case EMR_SETSTRETCHBLTMODE
:
398 DWORD mode
= mr
->dParm
[0];
399 SetStretchBltMode(hdc
, mode
);
402 case EMR_SETTEXTALIGN
:
404 DWORD align
= mr
->dParm
[0];
405 SetTextAlign(hdc
, align
);
408 case EMR_SETTEXTCOLOR
:
410 DWORD color
= mr
->dParm
[0];
411 SetTextColor(hdc
, color
);
421 RestoreDC(hdc
, mr
->dParm
[0]);
424 case EMR_INTERSECTCLIPRECT
:
426 INT left
= mr
->dParm
[0], top
= mr
->dParm
[1], right
= mr
->dParm
[2],
427 bottom
= mr
->dParm
[3];
428 IntersectClipRect(hdc
, left
, top
, right
, bottom
);
431 case EMR_SELECTOBJECT
:
433 DWORD obj
= mr
->dParm
[0];
434 SelectObject(hdc
, (handletable
->objectHandle
)[obj
]);
437 case EMR_DELETEOBJECT
:
439 DWORD obj
= mr
->dParm
[0];
440 DeleteObject( (handletable
->objectHandle
)[obj
]);
441 (handletable
->objectHandle
)[obj
] = 0;
444 case EMR_SETWINDOWORGEX
:
446 DWORD x
= mr
->dParm
[0], y
= mr
->dParm
[1];
447 SetWindowOrgEx(hdc
, x
, y
, NULL
);
450 case EMR_SETWINDOWEXTEX
:
452 DWORD x
= mr
->dParm
[0], y
= mr
->dParm
[1];
453 SetWindowExtEx(hdc
, x
, y
, NULL
);
456 case EMR_SETVIEWPORTORGEX
:
458 DWORD x
= mr
->dParm
[0], y
= mr
->dParm
[1];
459 SetViewportOrgEx(hdc
, x
, y
, NULL
);
462 case EMR_SETVIEWPORTEXTEX
:
464 DWORD x
= mr
->dParm
[0], y
= mr
->dParm
[1];
465 SetViewportExtEx(hdc
, x
, y
, NULL
);
470 DWORD obj
= mr
->dParm
[0];
471 (handletable
->objectHandle
)[obj
] =
472 CreatePenIndirect((LOGPEN
*) &(mr
->dParm
[1]));
475 case EMR_EXTCREATEPEN
:
477 DWORD obj
= mr
->dParm
[0];
478 DWORD style
= mr
->dParm
[1], brush
= mr
->dParm
[2];
479 LOGBRUSH
*b
= (LOGBRUSH
*) &mr
->dParm
[3];
480 FIXME("Some ExtCreatePen args not handled\n");
481 (handletable
->objectHandle
)[obj
] =
482 ExtCreatePen(style
, brush
, b
, 0, NULL
);
485 case EMR_CREATEBRUSHINDIRECT
:
487 DWORD obj
= mr
->dParm
[0];
488 (handletable
->objectHandle
)[obj
] =
489 CreateBrushIndirect((LOGBRUSH
*) &(mr
->dParm
[1]));
492 case EMR_EXTCREATEFONTINDIRECTW
:
494 DWORD obj
= mr
->dParm
[0];
495 (handletable
->objectHandle
)[obj
] =
496 CreateFontIndirectW((LOGFONTW
*) &(mr
->dParm
[1]));
501 DWORD x
= mr
->dParm
[0], y
= mr
->dParm
[1];
502 MoveToEx(hdc
, x
, y
, NULL
);
507 DWORD x
= mr
->dParm
[0], y
= mr
->dParm
[1];
513 INT left
= mr
->dParm
[0], top
= mr
->dParm
[1], right
= mr
->dParm
[2],
514 bottom
= mr
->dParm
[3];
515 Rectangle(hdc
, left
, top
, right
, bottom
);
520 INT left
= mr
->dParm
[0], top
= mr
->dParm
[1], right
= mr
->dParm
[2],
521 bottom
= mr
->dParm
[3];
522 Ellipse(hdc
, left
, top
, right
, bottom
);
527 /* 0-3 : a bounding rectangle? */
528 INT count
= mr
->dParm
[4];
529 FIXME("Some Polygon16 args not handled\n");
530 Polygon16(hdc
, (POINT16
*)&mr
->dParm
[5], count
);
535 /* 0-3 : a bounding rectangle? */
536 INT count
= mr
->dParm
[4];
537 FIXME("Some Polyline16 args not handled\n");
538 Polyline16(hdc
, (POINT16
*)&mr
->dParm
[5], count
);
542 case EMR_POLYPOLYGON16
:
544 PEMRPOLYPOLYGON16 lpPolyPoly16
= (PEMRPOLYPOLYGON16
)mr
;
548 lpPolyPoly16
->aPolyCounts
,
549 lpPolyPoly16
->nPolys
);
554 case EMR_STRETCHDIBITS
:
556 LONG xDest
= mr
->dParm
[4];
557 LONG yDest
= mr
->dParm
[5];
558 LONG xSrc
= mr
->dParm
[6];
559 LONG ySrc
= mr
->dParm
[7];
560 LONG cxSrc
= mr
->dParm
[8];
561 LONG cySrc
= mr
->dParm
[9];
562 DWORD offBmiSrc
= mr
->dParm
[10];
563 DWORD offBitsSrc
= mr
->dParm
[12];
564 DWORD iUsageSrc
= mr
->dParm
[14];
565 DWORD dwRop
= mr
->dParm
[15];
566 LONG cxDest
= mr
->dParm
[16];
567 LONG cyDest
= mr
->dParm
[17];
569 StretchDIBits(hdc
,xDest
,yDest
,cxDest
,cyDest
,
570 xSrc
,ySrc
,cxSrc
,cySrc
,
571 ((char *)mr
)+offBitsSrc
,
572 (const BITMAPINFO
*)(((char *)mr
)+offBmiSrc
),
576 case EMR_EXTTEXTOUTW
:
579 DWORD flags
= mr
->dParm
[4];
581 DWORD x
= mr
->dParm
[7], y
= mr
->dParm
[8];
582 DWORD count
= mr
->dParm
[9];
584 LPWSTR str
= (LPWSTR
)& mr
->dParm
[17];
585 /* trailing info: dx array? */
586 FIXME("Many ExtTextOut args not handled\n");
587 ExtTextOutW(hdc
, x
, y
, flags
, /* lpRect */ NULL
,
588 str
, count
, /* lpDx */ NULL
);
592 case EMR_CREATEPALETTE
:
594 PEMRCREATEPALETTE lpCreatePal
= (PEMRCREATEPALETTE
)mr
;
596 (handletable
->objectHandle
)[ lpCreatePal
->ihPal
] =
597 CreatePalette( &lpCreatePal
->lgpl
);
602 case EMR_SELECTPALETTE
:
604 PEMRSELECTPALETTE lpSelectPal
= (PEMRSELECTPALETTE
)mr
;
606 /* FIXME: Should this be forcing background mode? */
607 (handletable
->objectHandle
)[ lpSelectPal
->ihPal
] =
608 SelectPalette( hdc
, lpSelectPal
->ihPal
, FALSE
);
612 case EMR_REALIZEPALETTE
:
614 RealizePalette( hdc
);
619 case EMR_EXTSELECTCLIPRGN
:
621 PEMREXTSELECTCLIPRGN lpRgn
= (PEMREXTSELECTCLIPRGN
)mr
;
623 /* Need to make a region out of the RGNDATA we have */
624 ExtSelectClipRgn( hdc
, ..., (INT
)(lpRgn
->iMode
) );
633 case EMR_SETWORLDTRANSFORM
:
635 PEMRSETWORLDTRANSFORM lpXfrm
= (PEMRSETWORLDTRANSFORM
)mr
;
636 SetWorldTransform( hdc
, &lpXfrm
->xform
);
642 case EMR_POLYBEZIERTO
:
644 case EMR_POLYPOLYLINE
:
645 case EMR_POLYPOLYGON
:
646 case EMR_SETBRUSHORGEX
:
648 case EMR_SETMAPPERFLAGS
:
649 case EMR_SETCOLORADJUSTMENT
:
650 case EMR_OFFSETCLIPRGN
:
651 case EMR_EXCLUDECLIPRECT
:
652 case EMR_SCALEVIEWPORTEXTEX
:
653 case EMR_SCALEWINDOWEXTEX
:
654 case EMR_MODIFYWORLDTRANSFORM
:
660 case EMR_SETPALETTEENTRIES
:
661 case EMR_RESIZEPALETTE
:
662 case EMR_EXTFLOODFILL
:
665 case EMR_SETARCDIRECTION
:
666 case EMR_SETMITERLIMIT
:
669 case EMR_CLOSEFIGURE
:
671 case EMR_STROKEANDFILLPATH
:
673 case EMR_FLATTENPATH
:
675 case EMR_SELECTCLIPPATH
:
685 case EMR_SETDIBITSTODEVICE
:
686 case EMR_EXTTEXTOUTA
:
687 case EMR_POLYBEZIER16
:
688 case EMR_POLYBEZIERTO16
:
689 case EMR_POLYLINETO16
:
690 case EMR_POLYPOLYLINE16
:
691 case EMR_POLYPOLYGON16
:
693 case EMR_CREATEMONOBRUSH
:
694 case EMR_CREATEDIBPATTERNBRUSHPT
:
695 case EMR_POLYTEXTOUTA
:
696 case EMR_POLYTEXTOUTW
:
698 case EMR_CREATECOLORSPACE
:
699 case EMR_SETCOLORSPACE
:
700 case EMR_DELETECOLORSPACE
:
702 case EMR_GLSBOUNDEDRECORD
:
703 case EMR_PIXELFORMAT
:
705 FIXME("type %d is unimplemented\n", type
);
706 /* SetLastError(E_NOTIMPL); */
713 /*****************************************************************************
715 * EnumEnhMetaFile32 (GDI32.79)
717 * Walk an enhanced metafile, calling a user-specified function _EnhMetaFunc_
719 * record. Returns when either every record has been used or
720 * when _EnhMetaFunc_ returns FALSE.
724 * TRUE if every record is used, FALSE if any invocation of _EnhMetaFunc_
730 BOOL WINAPI
EnumEnhMetaFile(
731 HDC hdc
, /* device context to pass to _EnhMetaFunc_ */
732 HENHMETAFILE hmf
, /* EMF to walk */
733 ENHMFENUMPROC callback
, /* callback function */
734 LPVOID data
, /* optional data for callback function */
735 const RECT
*rect
/* bounding rectangle for rendered metafile */
739 LPENHMETARECORD p
= (LPENHMETARECORD
) EMF_GetEnhMetaHeader(hmf
);
744 count
= ((LPENHMETAHEADER
) p
)->nHandles
;
745 ht
= HeapAlloc( GetProcessHeap(), 0, sizeof(HANDLETABLE
)*count
);
746 ht
->objectHandle
[0] = hmf
;
748 ret
= (*callback
)(hdc
, ht
, p
, count
, data
);
749 if (p
->iType
== EMR_EOF
) break;
750 p
= (LPENHMETARECORD
) ((char *) p
+ p
->nSize
);
752 HeapFree( GetProcessHeap(), 0, ht
);
753 EMF_ReleaseEnhMetaHeader(hmf
);
758 /**************************************************************************
759 * PlayEnhMetaFile (GDI32.263)
761 * Renders an enhanced metafile into a specified rectangle *lpRect
762 * in device context hdc.
765 * Almost entirely unimplemented
768 BOOL WINAPI
PlayEnhMetaFile(
769 HDC hdc
, /* DC to render into */
770 HENHMETAFILE hmf
, /* metafile to render */
771 const RECT
*lpRect
/* rectangle to place metafile inside */
774 LPENHMETARECORD p
= (LPENHMETARECORD
) EMF_GetEnhMetaHeader(hmf
);
781 count
= ((LPENHMETAHEADER
) p
)->nHandles
;
782 ht
= HeapAlloc( GetProcessHeap(), 0, sizeof(HANDLETABLE
) * count
);
784 LPENHMETAHEADER h
= (LPENHMETAHEADER
) p
;
785 FLOAT xscale
= (h
->rclBounds
.right
- h
->rclBounds
.left
) /
786 (lpRect
->right
- lpRect
->left
);
787 FLOAT yscale
= (h
->rclBounds
.bottom
- h
->rclBounds
.top
) /
788 (lpRect
->bottom
- lpRect
->top
);
794 xform
.eDx
= lpRect
->left
;
795 xform
.eDy
= lpRect
->top
;
796 FIXME("play into rect doesn't work\n");
797 savedMode
= SetGraphicsMode(hdc
, GM_ADVANCED
);
798 if (!SetWorldTransform(hdc
, &xform
)) {
799 WARN("World transform failed!\n");
803 ht
->objectHandle
[0] = hmf
;
805 PlayEnhMetaFileRecord(hdc
, ht
, p
, count
);
806 if (p
->iType
== EMR_EOF
) break;
807 p
= (LPENHMETARECORD
) ((char *) p
+ p
->nSize
); /* casted so that arithmetic is in bytes */
809 HeapFree( GetProcessHeap(), 0, ht
);
810 EMF_ReleaseEnhMetaHeader(hmf
);
811 if (savedMode
) SetGraphicsMode(hdc
, savedMode
);
812 ret
= TRUE
; /* FIXME: calculate a more accurate return value */
816 /*****************************************************************************
817 * DeleteEnhMetaFile (GDI32.68)
819 * Deletes an enhanced metafile and frees the associated storage.
821 BOOL WINAPI
DeleteEnhMetaFile(HENHMETAFILE hmf
)
823 return EMF_Delete_HENHMETAFILE( hmf
);
826 /*****************************************************************************
827 * CopyEnhMetaFileA (GDI32.21) Duplicate an enhanced metafile
831 HENHMETAFILE WINAPI
CopyEnhMetaFileA(
835 ENHMETAHEADER
*emrSrc
= EMF_GetEnhMetaHeader( hmfSrc
), *emrDst
;
838 if(!emrSrc
) return FALSE
;
840 emrDst
= HeapAlloc( SystemHeap
, 0, emrSrc
->nBytes
);
841 memcpy( emrDst
, emrSrc
, emrSrc
->nBytes
);
842 hmfDst
= EMF_Create_HENHMETAFILE( emrDst
, 0, 0 );
845 hFile
= CreateFileA( file
, GENERIC_WRITE
| GENERIC_READ
, 0, NULL
,
846 CREATE_ALWAYS
, 0, -1);
847 WriteFile( hFile
, emrSrc
, emrSrc
->nBytes
, 0, 0);
848 hmfDst
= EMF_GetEnhMetaFile( hFile
);
850 EMF_ReleaseEnhMetaHeader( hmfSrc
);
855 /* Struct to be used to be passed in the LPVOID parameter for cbEnhPaletteCopy */
856 typedef struct tagEMF_PaletteCopy
862 /***************************************************************
863 * Find the EMR_EOF record and then use it to find the
864 * palette entries for this enhanced metafile.
865 * The lpData is actually a pointer to a EMF_PaletteCopy struct
866 * which contains the max number of elements to copy and where
869 * NOTE: To be used by GetEnhMetaFilePaletteEntries only!
871 INT CALLBACK
cbEnhPaletteCopy( HDC a
,
873 LPENHMETARECORD lpEMR
,
878 if ( lpEMR
->iType
== EMR_EOF
)
880 PEMREOF lpEof
= (PEMREOF
)lpEMR
;
881 EMF_PaletteCopy
* info
= (EMF_PaletteCopy
*)lpData
;
882 DWORD dwNumPalToCopy
= MIN( lpEof
->nPalEntries
, info
->cEntries
);
884 TRACE( "copying 0x%08lx palettes\n", dwNumPalToCopy
);
886 memcpy( (LPVOID
)info
->lpPe
,
887 (LPVOID
)(((LPSTR
)lpEof
) + lpEof
->offPalEntries
),
888 sizeof( *(info
->lpPe
) ) * dwNumPalToCopy
);
890 /* Update the passed data as a return code */
891 info
->lpPe
= NULL
; /* Palettes were copied! */
892 info
->cEntries
= (UINT
)dwNumPalToCopy
;
894 return FALSE
; /* That's all we need */
900 /*****************************************************************************
901 * GetEnhMetaFilePaletteEntries (GDI32.179)
903 * Copy the palette and report size
905 * BUGS: Error codes (SetLastError) are not set on failures
907 UINT WINAPI
GetEnhMetaFilePaletteEntries( HENHMETAFILE hEmf
,
909 LPPALETTEENTRY lpPe
)
911 ENHMETAHEADER
* enhHeader
= EMF_GetEnhMetaHeader( hEmf
);
912 UINT uReturnValue
= GDI_ERROR
;
913 EMF_PaletteCopy infoForCallBack
;
915 TRACE( "(%04x,%d,%p)\n", hEmf
, cEntries
, lpPe
);
917 /* First check if there are any palettes associated with
919 if ( enhHeader
->nPalEntries
== 0 )
921 /* No palette associated with this enhanced metafile */
926 /* Is the user requesting the number of palettes? */
929 uReturnValue
= (UINT
)enhHeader
->nPalEntries
;
933 /* Copy cEntries worth of PALETTEENTRY structs into the buffer */
934 infoForCallBack
.cEntries
= cEntries
;
935 infoForCallBack
.lpPe
= lpPe
;
937 if ( !EnumEnhMetaFile( 0, hEmf
, cbEnhPaletteCopy
,
938 &infoForCallBack
, NULL
) )
943 /* Verify that the callback executed correctly */
944 if ( infoForCallBack
.lpPe
!= NULL
)
946 /* Callback proc had error! */
947 ERR( "cbEnhPaletteCopy didn't execute correctly\n" );
951 uReturnValue
= infoForCallBack
.cEntries
;
955 EMF_ReleaseEnhMetaHeader( hEmf
);
960 /******************************************************************
961 * SetWinMetaFileBits (GDI32.343)
963 * Translate from old style to new style.
965 * BUGS: - This doesn't take the DC and scaling into account
966 * - Most record conversions aren't implemented
967 * - Handle slot assignement is primative and most likely doesn't work
969 HENHMETAFILE WINAPI
SetWinMetaFileBits(UINT cbBuffer
,
970 CONST BYTE
*lpbBuffer
,
972 CONST METAFILEPICT
*lpmfp
976 LPVOID lpNewEnhMetaFileBuffer
= NULL
;
977 UINT uNewEnhMetaFileBufferSize
= 0;
978 BOOL bFoundEOF
= FALSE
;
980 FIXME( "(%d,%p,%04x,%p):stub\n", cbBuffer
, lpbBuffer
, hdcRef
, lpmfp
);
982 /* 1. Get the header - skip over this and get straight to the records */
984 uNewEnhMetaFileBufferSize
= sizeof( ENHMETAHEADER
);
985 lpNewEnhMetaFileBuffer
= HeapAlloc( SystemHeap
, HEAP_ZERO_MEMORY
,
986 uNewEnhMetaFileBufferSize
);
988 if( lpNewEnhMetaFileBuffer
== NULL
)
993 /* Fill in the header record */
995 LPENHMETAHEADER lpNewEnhMetaFileHeader
= (LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
;
997 lpNewEnhMetaFileHeader
->iType
= EMR_HEADER
;
998 lpNewEnhMetaFileHeader
->nSize
= sizeof( ENHMETAHEADER
);
1000 /* FIXME: Not right. Must be able to get this from the DC */
1001 lpNewEnhMetaFileHeader
->rclBounds
.left
= 0;
1002 lpNewEnhMetaFileHeader
->rclBounds
.right
= 0;
1003 lpNewEnhMetaFileHeader
->rclBounds
.top
= 0;
1004 lpNewEnhMetaFileHeader
->rclBounds
.bottom
= 0;
1006 /* FIXME: Not right. Must be able to get this from the DC */
1007 lpNewEnhMetaFileHeader
->rclFrame
.left
= 0;
1008 lpNewEnhMetaFileHeader
->rclFrame
.right
= 0;
1009 lpNewEnhMetaFileHeader
->rclFrame
.top
= 0;
1010 lpNewEnhMetaFileHeader
->rclFrame
.bottom
= 0;
1012 lpNewEnhMetaFileHeader
->nHandles
= 0; /* No handles yet */
1014 /* FIXME: Add in the rest of the fields to the header */
1029 (char*)lpbBuffer
+= ((METAHEADER
*)lpbBuffer
)->mtHeaderSize
* 2; /* Point past the header - FIXME: metafile quirk? */
1031 /* 2. Enum over individual records and convert them to the new type of records */
1035 LPMETARECORD lpMetaRecord
= (LPMETARECORD
)lpbBuffer
;
1037 #define EMF_ReAllocAndAdjustPointers( a , b ) \
1040 lpTmp = HeapReAlloc( SystemHeap, 0, \
1041 lpNewEnhMetaFileBuffer, \
1042 uNewEnhMetaFileBufferSize + (b) ); \
1043 if( lpTmp == NULL ) { ERR( "No memory!\n" ); goto error; } \
1044 lpNewEnhMetaFileBuffer = lpTmp; \
1045 lpRecord = (a)( (char*)lpNewEnhMetaFileBuffer + uNewEnhMetaFileBufferSize ); \
1046 uNewEnhMetaFileBufferSize += (b); \
1049 switch( lpMetaRecord
->rdFunction
)
1054 size_t uRecord
= sizeof(*lpRecord
);
1056 EMF_ReAllocAndAdjustPointers(PEMREOF
,uRecord
);
1058 /* Fill the new record - FIXME: This is not right */
1059 lpRecord
->emr
.iType
= EMR_EOF
;
1060 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1061 lpRecord
->nPalEntries
= 0; /* FIXME */
1062 lpRecord
->offPalEntries
= 0; /* FIXME */
1063 lpRecord
->nSizeLast
= 0; /* FIXME */
1065 /* No more records after this one */
1068 FIXME( "META_EOF conversion not correct\n" );
1072 case META_SETMAPMODE
:
1074 PEMRSETMAPMODE lpRecord
;
1075 size_t uRecord
= sizeof(*lpRecord
);
1077 EMF_ReAllocAndAdjustPointers(PEMRSETMAPMODE
,uRecord
);
1079 lpRecord
->emr
.iType
= EMR_SETMAPMODE
;
1080 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1082 lpRecord
->iMode
= lpMetaRecord
->rdParm
[0];
1087 case META_DELETEOBJECT
: /* Select and Delete structures are the same */
1088 case META_SELECTOBJECT
:
1090 PEMRDELETEOBJECT lpRecord
;
1091 size_t uRecord
= sizeof(*lpRecord
);
1093 EMF_ReAllocAndAdjustPointers(PEMRDELETEOBJECT
,uRecord
);
1095 if( lpMetaRecord
->rdFunction
== META_DELETEOBJECT
)
1097 lpRecord
->emr
.iType
= EMR_DELETEOBJECT
;
1101 lpRecord
->emr
.iType
= EMR_SELECTOBJECT
;
1103 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1105 lpRecord
->ihObject
= lpMetaRecord
->rdParm
[0]; /* FIXME: Handle */
1110 case META_POLYGON
: /* This is just plain busted. I don't know what I'm doing */
1112 PEMRPOLYGON16 lpRecord
; /* FIXME: Should it be a poly or poly16? */
1113 size_t uRecord
= sizeof(*lpRecord
);
1115 EMF_ReAllocAndAdjustPointers(PEMRPOLYGON16
,uRecord
);
1117 /* FIXME: This is mostly all wrong */
1118 lpRecord
->emr
.iType
= EMR_POLYGON16
;
1119 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1121 lpRecord
->rclBounds
.left
= 0;
1122 lpRecord
->rclBounds
.right
= 0;
1123 lpRecord
->rclBounds
.top
= 0;
1124 lpRecord
->rclBounds
.bottom
= 0;
1127 lpRecord
->apts
[0].x
= 0;
1128 lpRecord
->apts
[0].y
= 0;
1130 FIXME( "META_POLYGON conversion not correct\n" );
1135 case META_SETPOLYFILLMODE
:
1137 PEMRSETPOLYFILLMODE lpRecord
;
1138 size_t uRecord
= sizeof(*lpRecord
);
1140 EMF_ReAllocAndAdjustPointers(PEMRSETPOLYFILLMODE
,uRecord
);
1142 lpRecord
->emr
.iType
= EMR_SETPOLYFILLMODE
;
1143 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1145 lpRecord
->iMode
= lpMetaRecord
->rdParm
[0];
1150 case META_SETWINDOWORG
:
1152 PEMRSETWINDOWORGEX lpRecord
; /* Seems to be the closest thing */
1153 size_t uRecord
= sizeof(*lpRecord
);
1155 EMF_ReAllocAndAdjustPointers(PEMRSETWINDOWORGEX
,uRecord
);
1157 lpRecord
->emr
.iType
= EMR_SETWINDOWORGEX
;
1158 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1160 lpRecord
->ptlOrigin
.x
= lpMetaRecord
->rdParm
[1];
1161 lpRecord
->ptlOrigin
.y
= lpMetaRecord
->rdParm
[0];
1166 case META_SETWINDOWEXT
: /* Structure is the same for SETWINDOWEXT & SETVIEWPORTEXT */
1167 case META_SETVIEWPORTEXT
:
1169 PEMRSETWINDOWEXTEX lpRecord
;
1170 size_t uRecord
= sizeof(*lpRecord
);
1172 EMF_ReAllocAndAdjustPointers(PEMRSETWINDOWEXTEX
,uRecord
);
1174 if ( lpMetaRecord
->rdFunction
== META_SETWINDOWEXT
)
1176 lpRecord
->emr
.iType
= EMR_SETWINDOWORGEX
;
1180 lpRecord
->emr
.iType
= EMR_SETVIEWPORTEXTEX
;
1182 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1184 lpRecord
->szlExtent
.cx
= lpMetaRecord
->rdParm
[1];
1185 lpRecord
->szlExtent
.cy
= lpMetaRecord
->rdParm
[0];
1190 case META_CREATEBRUSHINDIRECT
:
1192 PEMRCREATEBRUSHINDIRECT lpRecord
;
1193 size_t uRecord
= sizeof(*lpRecord
);
1195 EMF_ReAllocAndAdjustPointers(PEMRCREATEBRUSHINDIRECT
,uRecord
);
1197 lpRecord
->emr
.iType
= EMR_CREATEBRUSHINDIRECT
;
1198 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1200 lpRecord
->ihBrush
= ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nHandles
;
1201 lpRecord
->lb
.lbStyle
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbStyle
;
1202 lpRecord
->lb
.lbColor
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbColor
;
1203 lpRecord
->lb
.lbHatch
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbHatch
;
1205 ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nHandles
+= 1; /* New handle */
1211 /* These are all unimplemented and as such are intended to fall through to the default case */
1212 case META_SETBKCOLOR
:
1213 case META_SETBKMODE
:
1215 case META_SETRELABS
:
1216 case META_SETSTRETCHBLTMODE
:
1217 case META_SETTEXTCOLOR
:
1218 case META_SETVIEWPORTORG
:
1219 case META_OFFSETWINDOWORG
:
1220 case META_SCALEWINDOWEXT
:
1221 case META_OFFSETVIEWPORTORG
:
1222 case META_SCALEVIEWPORTEXT
:
1225 case META_EXCLUDECLIPRECT
:
1226 case META_INTERSECTCLIPRECT
:
1229 case META_FLOODFILL
:
1231 case META_RECTANGLE
:
1232 case META_ROUNDRECT
:
1236 case META_OFFSETCLIPRGN
:
1238 case META_POLYPOLYGON
:
1240 case META_RESTOREDC
:
1242 case META_CREATEPATTERNBRUSH
:
1243 case META_CREATEPENINDIRECT
:
1244 case META_CREATEFONTINDIRECT
:
1245 case META_CREATEPALETTE
:
1246 case META_SETTEXTALIGN
:
1247 case META_SELECTPALETTE
:
1248 case META_SETMAPPERFLAGS
:
1249 case META_REALIZEPALETTE
:
1251 case META_EXTTEXTOUT
:
1252 case META_STRETCHDIB
:
1253 case META_DIBSTRETCHBLT
:
1254 case META_STRETCHBLT
:
1256 case META_CREATEREGION
:
1257 case META_FILLREGION
:
1258 case META_FRAMEREGION
:
1259 case META_INVERTREGION
:
1260 case META_PAINTREGION
:
1261 case META_SELECTCLIPREGION
:
1262 case META_DIBCREATEPATTERNBRUSH
:
1263 case META_DIBBITBLT
:
1264 case META_SETTEXTCHAREXTRA
:
1265 case META_SETTEXTJUSTIFICATION
:
1266 case META_EXTFLOODFILL
:
1267 case META_SETDIBTODEV
:
1269 case META_ANIMATEPALETTE
:
1270 case META_SETPALENTRIES
:
1271 case META_RESIZEPALETTE
:
1274 case META_STARTPAGE
:
1278 case META_CREATEBRUSH
:
1279 case META_CREATEBITMAPINDIRECT
:
1280 case META_CREATEBITMAP
:
1281 /* Fall through to unimplemented */
1284 /* Not implemented yet */
1285 FIXME( "Conversion of record type 0x%x not implemented.\n", lpMetaRecord
->rdFunction
);
1290 /* Move to the next record */
1291 (char*)lpbBuffer
+= ((LPMETARECORD
)lpbBuffer
)->rdSize
* 2; /* FIXME: Seem to be doing this in metafile.c */
1293 #undef ReAllocAndAdjustPointers
1296 /* We know the last of the header information now */
1297 ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nBytes
= uNewEnhMetaFileBufferSize
;
1299 /* Create the enhanced metafile */
1300 hMf
= SetEnhMetaFileBits( uNewEnhMetaFileBufferSize
, (const BYTE
*)lpNewEnhMetaFileBuffer
);
1303 ERR( "Problem creating metafile. Did the conversion fail somewhere?\n" );
1308 /* Free the data associated with our copy since it's been copied */
1309 HeapFree( SystemHeap
, 0, lpNewEnhMetaFileBuffer
);