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
12 * 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; */
360 /* application defined and processed */
364 DWORD mode
= mr
->dParm
[0];
365 SetMapMode(hdc
, mode
);
370 DWORD mode
= mr
->dParm
[0];
371 SetBkMode(hdc
, mode
);
376 DWORD mode
= mr
->dParm
[0];
377 SetBkColor(hdc
, mode
);
380 case EMR_SETPOLYFILLMODE
:
382 DWORD mode
= mr
->dParm
[0];
383 SetPolyFillMode(hdc
, mode
);
388 DWORD mode
= mr
->dParm
[0];
392 case EMR_SETSTRETCHBLTMODE
:
394 DWORD mode
= mr
->dParm
[0];
395 SetStretchBltMode(hdc
, mode
);
398 case EMR_SETTEXTALIGN
:
400 DWORD align
= mr
->dParm
[0];
401 SetTextAlign(hdc
, align
);
404 case EMR_SETTEXTCOLOR
:
406 DWORD color
= mr
->dParm
[0];
407 SetTextColor(hdc
, color
);
417 RestoreDC(hdc
, mr
->dParm
[0]);
420 case EMR_INTERSECTCLIPRECT
:
422 INT left
= mr
->dParm
[0], top
= mr
->dParm
[1], right
= mr
->dParm
[2],
423 bottom
= mr
->dParm
[3];
424 IntersectClipRect(hdc
, left
, top
, right
, bottom
);
427 case EMR_SELECTOBJECT
:
429 DWORD obj
= mr
->dParm
[0];
430 SelectObject(hdc
, (handletable
->objectHandle
)[obj
]);
433 case EMR_DELETEOBJECT
:
435 DWORD obj
= mr
->dParm
[0];
436 DeleteObject( (handletable
->objectHandle
)[obj
]);
437 (handletable
->objectHandle
)[obj
] = 0;
440 case EMR_SETWINDOWORGEX
:
442 DWORD x
= mr
->dParm
[0], y
= mr
->dParm
[1];
443 SetWindowOrgEx(hdc
, x
, y
, NULL
);
446 case EMR_SETWINDOWEXTEX
:
448 DWORD x
= mr
->dParm
[0], y
= mr
->dParm
[1];
449 SetWindowExtEx(hdc
, x
, y
, NULL
);
452 case EMR_SETVIEWPORTORGEX
:
454 DWORD x
= mr
->dParm
[0], y
= mr
->dParm
[1];
455 SetViewportOrgEx(hdc
, x
, y
, NULL
);
458 case EMR_SETVIEWPORTEXTEX
:
460 DWORD x
= mr
->dParm
[0], y
= mr
->dParm
[1];
461 SetViewportExtEx(hdc
, x
, y
, NULL
);
466 DWORD obj
= mr
->dParm
[0];
467 (handletable
->objectHandle
)[obj
] =
468 CreatePenIndirect((LOGPEN
*) &(mr
->dParm
[1]));
471 case EMR_EXTCREATEPEN
:
473 DWORD obj
= mr
->dParm
[0];
474 DWORD style
= mr
->dParm
[1], brush
= mr
->dParm
[2];
475 LOGBRUSH
*b
= (LOGBRUSH
*) &mr
->dParm
[3];
476 FIXME("Some ExtCreatePen args not handled\n");
477 (handletable
->objectHandle
)[obj
] =
478 ExtCreatePen(style
, brush
, b
, 0, NULL
);
481 case EMR_CREATEBRUSHINDIRECT
:
483 DWORD obj
= mr
->dParm
[0];
484 (handletable
->objectHandle
)[obj
] =
485 CreateBrushIndirect((LOGBRUSH
*) &(mr
->dParm
[1]));
488 case EMR_EXTCREATEFONTINDIRECTW
:
490 DWORD obj
= mr
->dParm
[0];
491 (handletable
->objectHandle
)[obj
] =
492 CreateFontIndirectW((LOGFONTW
*) &(mr
->dParm
[1]));
497 DWORD x
= mr
->dParm
[0], y
= mr
->dParm
[1];
498 MoveToEx(hdc
, x
, y
, NULL
);
503 DWORD x
= mr
->dParm
[0], y
= mr
->dParm
[1];
509 INT left
= mr
->dParm
[0], top
= mr
->dParm
[1], right
= mr
->dParm
[2],
510 bottom
= mr
->dParm
[3];
511 Rectangle(hdc
, left
, top
, right
, bottom
);
516 INT left
= mr
->dParm
[0], top
= mr
->dParm
[1], right
= mr
->dParm
[2],
517 bottom
= mr
->dParm
[3];
518 Ellipse(hdc
, left
, top
, right
, bottom
);
523 /* 0-3 : a bounding rectangle? */
524 INT count
= mr
->dParm
[4];
525 FIXME("Some Polygon16 args not handled\n");
526 Polygon16(hdc
, (POINT16
*)&mr
->dParm
[5], count
);
531 /* 0-3 : a bounding rectangle? */
532 INT count
= mr
->dParm
[4];
533 FIXME("Some Polyline16 args not handled\n");
534 Polyline16(hdc
, (POINT16
*)&mr
->dParm
[5], count
);
539 case EMR_POLYPOLYGON16
:
541 INT polygons
= mr
->dParm
[z
];
542 LPPOINT16 pts
= (LPPOINT16
) &mr
->dParm
[x
];
543 LPINT16 counts
= (LPINT16
) &mr
->dParm
[y
];
544 PolyPolygon16(hdc
, pts
, counts
, polygons
);
548 case EMR_STRETCHDIBITS
:
550 LONG xDest
= mr
->dParm
[4];
551 LONG yDest
= mr
->dParm
[5];
552 LONG xSrc
= mr
->dParm
[6];
553 LONG ySrc
= mr
->dParm
[7];
554 LONG cxSrc
= mr
->dParm
[8];
555 LONG cySrc
= mr
->dParm
[9];
556 DWORD offBmiSrc
= mr
->dParm
[10];
557 DWORD offBitsSrc
= mr
->dParm
[12];
558 DWORD iUsageSrc
= mr
->dParm
[14];
559 DWORD dwRop
= mr
->dParm
[15];
560 LONG cxDest
= mr
->dParm
[16];
561 LONG cyDest
= mr
->dParm
[17];
563 StretchDIBits(hdc
,xDest
,yDest
,cxDest
,cyDest
,
564 xSrc
,ySrc
,cxSrc
,cySrc
,
565 ((char *)mr
)+offBitsSrc
,
566 (const BITMAPINFO
*)(((char *)mr
)+offBmiSrc
),
570 case EMR_EXTTEXTOUTW
:
573 DWORD flags
= mr
->dParm
[4];
575 DWORD x
= mr
->dParm
[7], y
= mr
->dParm
[8];
576 DWORD count
= mr
->dParm
[9];
578 LPWSTR str
= (LPWSTR
)& mr
->dParm
[17];
579 /* trailing info: dx array? */
580 FIXME("Many ExtTextOut args not handled\n");
581 ExtTextOutW(hdc
, x
, y
, flags
, /* lpRect */ NULL
,
582 str
, count
, /* lpDx */ NULL
);
587 FIXME("type %d is unimplemented\n", type
);
588 /* SetLastError(E_NOTIMPL); */
595 /*****************************************************************************
597 * EnumEnhMetaFile32 (GDI32.79)
599 * Walk an enhanced metafile, calling a user-specified function _EnhMetaFunc_
601 * record. Returns when either every record has been used or
602 * when _EnhMetaFunc_ returns FALSE.
606 * TRUE if every record is used, FALSE if any invocation of _EnhMetaFunc_
612 BOOL WINAPI
EnumEnhMetaFile(
613 HDC hdc
, /* device context to pass to _EnhMetaFunc_ */
614 HENHMETAFILE hmf
, /* EMF to walk */
615 ENHMFENUMPROC callback
, /* callback function */
616 LPVOID data
, /* optional data for callback function */
617 const RECT
*rect
/* bounding rectangle for rendered metafile */
621 LPENHMETARECORD p
= (LPENHMETARECORD
) EMF_GetEnhMetaHeader(hmf
);
626 count
= ((LPENHMETAHEADER
) p
)->nHandles
;
627 ht
= HeapAlloc( GetProcessHeap(), 0, sizeof(HANDLETABLE
)*count
);
628 ht
->objectHandle
[0] = hmf
;
630 ret
= (*callback
)(hdc
, ht
, p
, count
, data
);
631 if (p
->iType
== EMR_EOF
) break;
632 p
= (LPENHMETARECORD
) ((char *) p
+ p
->nSize
);
634 HeapFree( GetProcessHeap(), 0, ht
);
635 EMF_ReleaseEnhMetaHeader(hmf
);
640 /**************************************************************************
641 * PlayEnhMetaFile (GDI32.263)
643 * Renders an enhanced metafile into a specified rectangle *lpRect
644 * in device context hdc.
647 * Almost entirely unimplemented
650 BOOL WINAPI
PlayEnhMetaFile(
651 HDC hdc
, /* DC to render into */
652 HENHMETAFILE hmf
, /* metafile to render */
653 const RECT
*lpRect
/* rectangle to place metafile inside */
656 LPENHMETARECORD p
= (LPENHMETARECORD
) EMF_GetEnhMetaHeader(hmf
);
663 count
= ((LPENHMETAHEADER
) p
)->nHandles
;
664 ht
= HeapAlloc( GetProcessHeap(), 0, sizeof(HANDLETABLE
) * count
);
666 LPENHMETAHEADER h
= (LPENHMETAHEADER
) p
;
667 FLOAT xscale
= (h
->rclBounds
.right
- h
->rclBounds
.left
) /
668 (lpRect
->right
- lpRect
->left
);
669 FLOAT yscale
= (h
->rclBounds
.bottom
- h
->rclBounds
.top
) /
670 (lpRect
->bottom
- lpRect
->top
);
676 xform
.eDx
= lpRect
->left
;
677 xform
.eDy
= lpRect
->top
;
678 FIXME("play into rect doesn't work\n");
679 savedMode
= SetGraphicsMode(hdc
, GM_ADVANCED
);
680 if (!SetWorldTransform(hdc
, &xform
)) {
681 WARN("World transform failed!\n");
685 ht
->objectHandle
[0] = hmf
;
687 PlayEnhMetaFileRecord(hdc
, ht
, p
, count
);
688 if (p
->iType
== EMR_EOF
) break;
689 p
= (LPENHMETARECORD
) ((char *) p
+ p
->nSize
); /* casted so that arithmetic is in bytes */
691 HeapFree( GetProcessHeap(), 0, ht
);
692 EMF_ReleaseEnhMetaHeader(hmf
);
693 if (savedMode
) SetGraphicsMode(hdc
, savedMode
);
694 ret
= TRUE
; /* FIXME: calculate a more accurate return value */
698 /*****************************************************************************
699 * DeleteEnhMetaFile (GDI32.68)
701 * Deletes an enhanced metafile and frees the associated storage.
703 BOOL WINAPI
DeleteEnhMetaFile(HENHMETAFILE hmf
)
705 return EMF_Delete_HENHMETAFILE( hmf
);
708 /*****************************************************************************
709 * CopyEnhMetaFileA (GDI32.21) Duplicate an enhanced metafile
713 HENHMETAFILE WINAPI
CopyEnhMetaFileA(
717 ENHMETAHEADER
*emrSrc
= EMF_GetEnhMetaHeader( hmfSrc
), *emrDst
;
720 if(!emrSrc
) return FALSE
;
722 emrDst
= HeapAlloc( SystemHeap
, 0, emrSrc
->nBytes
);
723 memcpy( emrDst
, emrSrc
, emrSrc
->nBytes
);
724 hmfDst
= EMF_Create_HENHMETAFILE( emrDst
, 0, 0 );
727 hFile
= CreateFileA( file
, GENERIC_WRITE
| GENERIC_READ
, 0, NULL
,
728 CREATE_ALWAYS
, 0, -1);
729 WriteFile( hFile
, emrSrc
, emrSrc
->nBytes
, 0, 0);
730 hmfDst
= EMF_GetEnhMetaFile( hFile
);
732 EMF_ReleaseEnhMetaHeader( hmfSrc
);
737 /*****************************************************************************
738 * GetEnhMetaFilePaletteEntries (GDI32.179)
740 * Copy the palette and report size
743 UINT WINAPI
GetEnhMetaFilePaletteEntries(HENHMETAFILE hemf
,
747 FIXME( "(%04x,%d,%p):stub\n", hemf
, cEntries
, lppe
);
751 /******************************************************************
752 * SetWinMetaFileBits (GDI32.343)
754 * Translate from old style to new style.
756 * BUGS: - This doesn't take the DC and scaling into account
757 * - Most record conversions aren't implemented
758 * - Handle slot assignement is primative and most likely doesn't work
760 HENHMETAFILE WINAPI
SetWinMetaFileBits(UINT cbBuffer
,
761 CONST BYTE
*lpbBuffer
,
763 CONST METAFILEPICT
*lpmfp
767 LPVOID lpNewEnhMetaFileBuffer
= NULL
;
768 UINT uNewEnhMetaFileBufferSize
= 0;
769 BOOL bFoundEOF
= FALSE
;
771 FIXME( "(%d,%p,%04x,%p):stub\n", cbBuffer
, lpbBuffer
, hdcRef
, lpmfp
);
773 /* 1. Get the header - skip over this and get straight to the records */
775 uNewEnhMetaFileBufferSize
= sizeof( ENHMETAHEADER
);
776 lpNewEnhMetaFileBuffer
= HeapAlloc( SystemHeap
, HEAP_ZERO_MEMORY
,
777 uNewEnhMetaFileBufferSize
);
779 if( lpNewEnhMetaFileBuffer
== NULL
)
784 /* Fill in the header record */
786 LPENHMETAHEADER lpNewEnhMetaFileHeader
= (LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
;
788 lpNewEnhMetaFileHeader
->iType
= EMR_HEADER
;
789 lpNewEnhMetaFileHeader
->nSize
= sizeof( ENHMETAHEADER
);
791 /* FIXME: Not right. Must be able to get this from the DC */
792 lpNewEnhMetaFileHeader
->rclBounds
.left
= 0;
793 lpNewEnhMetaFileHeader
->rclBounds
.right
= 0;
794 lpNewEnhMetaFileHeader
->rclBounds
.top
= 0;
795 lpNewEnhMetaFileHeader
->rclBounds
.bottom
= 0;
797 /* FIXME: Not right. Must be able to get this from the DC */
798 lpNewEnhMetaFileHeader
->rclFrame
.left
= 0;
799 lpNewEnhMetaFileHeader
->rclFrame
.right
= 0;
800 lpNewEnhMetaFileHeader
->rclFrame
.top
= 0;
801 lpNewEnhMetaFileHeader
->rclFrame
.bottom
= 0;
803 lpNewEnhMetaFileHeader
->nHandles
= 0; /* No handles yet */
805 /* FIXME: Add in the rest of the fields to the header */
820 (char*)lpbBuffer
+= ((METAHEADER
*)lpbBuffer
)->mtHeaderSize
* 2; /* Point past the header - FIXME: metafile quirk? */
822 /* 2. Enum over individual records and convert them to the new type of records */
826 LPMETARECORD lpMetaRecord
= (LPMETARECORD
)lpbBuffer
;
828 #define EMF_ReAllocAndAdjustPointers( a , b ) \
831 lpTmp = HeapReAlloc( SystemHeap, 0, \
832 lpNewEnhMetaFileBuffer, \
833 uNewEnhMetaFileBufferSize + (b) ); \
834 if( lpTmp == NULL ) { ERR( "No memory!\n" ); goto error; } \
835 lpNewEnhMetaFileBuffer = lpTmp; \
836 lpRecord = (a)( (char*)lpNewEnhMetaFileBuffer + uNewEnhMetaFileBufferSize ); \
837 uNewEnhMetaFileBufferSize += (b); \
840 switch( lpMetaRecord
->rdFunction
)
845 size_t uRecord
= sizeof(*lpRecord
);
847 EMF_ReAllocAndAdjustPointers(PEMREOF
,uRecord
);
849 /* Fill the new record - FIXME: This is not right */
850 lpRecord
->emr
.iType
= EMR_EOF
;
851 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
852 lpRecord
->nPalEntries
= 0; /* FIXME */
853 lpRecord
->offPalEntries
= 0; /* FIXME */
854 lpRecord
->nSizeLast
= 0; /* FIXME */
856 /* No more records after this one */
859 FIXME( "META_EOF conversion not correct\n" );
863 case META_SETMAPMODE
:
865 PEMRSETMAPMODE lpRecord
;
866 size_t uRecord
= sizeof(*lpRecord
);
868 EMF_ReAllocAndAdjustPointers(PEMRSETMAPMODE
,uRecord
);
870 lpRecord
->emr
.iType
= EMR_SETMAPMODE
;
871 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
873 lpRecord
->iMode
= lpMetaRecord
->rdParm
[0];
878 case META_DELETEOBJECT
: /* Select and Delete structures are the same */
879 case META_SELECTOBJECT
:
881 PEMRDELETEOBJECT lpRecord
;
882 size_t uRecord
= sizeof(*lpRecord
);
884 EMF_ReAllocAndAdjustPointers(PEMRDELETEOBJECT
,uRecord
);
886 if( lpMetaRecord
->rdFunction
== META_DELETEOBJECT
)
888 lpRecord
->emr
.iType
= EMR_DELETEOBJECT
;
892 lpRecord
->emr
.iType
= EMR_SELECTOBJECT
;
894 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
896 lpRecord
->ihObject
= lpMetaRecord
->rdParm
[0]; /* FIXME: Handle */
901 case META_POLYGON
: /* This is just plain busted. I don't know what I'm doing */
903 PEMRPOLYGON16 lpRecord
; /* FIXME: Should it be a poly or poly16? */
904 size_t uRecord
= sizeof(*lpRecord
);
906 EMF_ReAllocAndAdjustPointers(PEMRPOLYGON16
,uRecord
);
908 /* FIXME: This is mostly all wrong */
909 lpRecord
->emr
.iType
=
910 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
912 lpRecord
->rclBounds
.left
= 0;
913 lpRecord
->rclBounds
.right
= 0;
914 lpRecord
->rclBounds
.top
= 0;
915 lpRecord
->rclBounds
.bottom
= 0;
918 lpRecord
->apts
[0].x
= 0;
919 lpRecord
->apts
[0].y
= 0;
921 FIXME( "META_POLYGON conversion not correct\n" );
926 case META_SETPOLYFILLMODE
:
928 PEMRSETPOLYFILLMODE lpRecord
;
929 size_t uRecord
= sizeof(*lpRecord
);
931 EMF_ReAllocAndAdjustPointers(PEMRSETPOLYFILLMODE
,uRecord
);
933 lpRecord
->emr
.iType
= EMR_SETPOLYFILLMODE
;
934 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
936 lpRecord
->iMode
= lpMetaRecord
->rdParm
[0];
941 case META_SETWINDOWORG
:
943 PEMRSETWINDOWORGEX lpRecord
; /* Seems to be the closest thing */
944 size_t uRecord
= sizeof(*lpRecord
);
946 EMF_ReAllocAndAdjustPointers(PEMRSETWINDOWORGEX
,uRecord
);
948 lpRecord
->emr
.iType
= EMR_SETWINDOWORGEX
;
949 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
951 lpRecord
->ptlOrigin
.x
= lpMetaRecord
->rdParm
[1];
952 lpRecord
->ptlOrigin
.y
= lpMetaRecord
->rdParm
[0];
957 case META_SETWINDOWEXT
: /* Structure is the same for SETWINDOWEXT & SETVIEWPORTEXT */
958 case META_SETVIEWPORTEXT
:
960 PEMRSETWINDOWEXTEX lpRecord
;
961 size_t uRecord
= sizeof(*lpRecord
);
963 EMF_ReAllocAndAdjustPointers(PEMRSETWINDOWEXTEX
,uRecord
);
965 if ( lpMetaRecord
->rdFunction
== META_SETWINDOWEXT
)
967 lpRecord
->emr
.iType
= EMR_SETWINDOWORGEX
;
971 lpRecord
->emr
.iType
= EMR_SETVIEWPORTEXTEX
;
973 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
975 lpRecord
->szlExtent
.cx
= lpMetaRecord
->rdParm
[1];
976 lpRecord
->szlExtent
.cy
= lpMetaRecord
->rdParm
[0];
981 case META_CREATEBRUSHINDIRECT
:
983 PEMRCREATEBRUSHINDIRECT lpRecord
;
984 size_t uRecord
= sizeof(*lpRecord
);
986 EMF_ReAllocAndAdjustPointers(PEMRCREATEBRUSHINDIRECT
,uRecord
);
988 lpRecord
->emr
.iType
= EMR_CREATEBRUSHINDIRECT
;
989 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
991 lpRecord
->ihBrush
= ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nHandles
;
992 lpRecord
->lb
.lbStyle
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbStyle
;
993 lpRecord
->lb
.lbColor
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbColor
;
994 lpRecord
->lb
.lbHatch
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbHatch
;
996 ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nHandles
+= 1; /* New handle */
1002 /* These are all unimplemented and as such are intended to fall through to the default case */
1003 case META_SETBKCOLOR
:
1004 case META_SETBKMODE
:
1006 case META_SETRELABS
:
1007 case META_SETSTRETCHBLTMODE
:
1008 case META_SETTEXTCOLOR
:
1009 case META_SETVIEWPORTORG
:
1010 case META_OFFSETWINDOWORG
:
1011 case META_SCALEWINDOWEXT
:
1012 case META_OFFSETVIEWPORTORG
:
1013 case META_SCALEVIEWPORTEXT
:
1016 case META_EXCLUDECLIPRECT
:
1017 case META_INTERSECTCLIPRECT
:
1020 case META_FLOODFILL
:
1022 case META_RECTANGLE
:
1023 case META_ROUNDRECT
:
1027 case META_OFFSETCLIPRGN
:
1029 case META_POLYPOLYGON
:
1031 case META_RESTOREDC
:
1033 case META_CREATEPATTERNBRUSH
:
1034 case META_CREATEPENINDIRECT
:
1035 case META_CREATEFONTINDIRECT
:
1036 case META_CREATEPALETTE
:
1037 case META_SETTEXTALIGN
:
1038 case META_SELECTPALETTE
:
1039 case META_SETMAPPERFLAGS
:
1040 case META_REALIZEPALETTE
:
1042 case META_EXTTEXTOUT
:
1043 case META_STRETCHDIB
:
1044 case META_DIBSTRETCHBLT
:
1045 case META_STRETCHBLT
:
1047 case META_CREATEREGION
:
1048 case META_FILLREGION
:
1049 case META_FRAMEREGION
:
1050 case META_INVERTREGION
:
1051 case META_PAINTREGION
:
1052 case META_SELECTCLIPREGION
:
1053 case META_DIBCREATEPATTERNBRUSH
:
1054 case META_DIBBITBLT
:
1055 case META_SETTEXTCHAREXTRA
:
1056 case META_SETTEXTJUSTIFICATION
:
1057 case META_EXTFLOODFILL
:
1058 case META_SETDIBTODEV
:
1060 case META_ANIMATEPALETTE
:
1061 case META_SETPALENTRIES
:
1062 case META_RESIZEPALETTE
:
1065 case META_STARTPAGE
:
1069 case META_CREATEBRUSH
:
1070 case META_CREATEBITMAPINDIRECT
:
1071 case META_CREATEBITMAP
:
1072 /* Fall through to unimplemented */
1075 /* Not implemented yet */
1076 FIXME( "Conversion of record type 0x%x not implemented.\n", lpMetaRecord
->rdFunction
);
1081 /* Move to the next record */
1082 (char*)lpbBuffer
+= ((LPMETARECORD
)lpbBuffer
)->rdSize
* 2; /* FIXME: Seem to be doing this in metafile.c */
1084 #undef ReAllocAndAdjustPointers
1087 /* We know the last of the header information now */
1088 ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nBytes
= uNewEnhMetaFileBufferSize
;
1090 /* Create the enhanced metafile */
1091 hMf
= SetEnhMetaFileBits( uNewEnhMetaFileBufferSize
, (const BYTE
*)lpNewEnhMetaFileBuffer
);
1094 ERR( "Problem creating metafile. Did the conversion fail somewhere?\n" );
1099 /* Free the data associated with our copy since it's been copied */
1100 HeapFree( SystemHeap
, 0, lpNewEnhMetaFileBuffer
);