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.
25 #include "enhmetafile.h"
26 #include "debugtools.h"
30 DEFAULT_DEBUG_CHANNEL(enhmetafile
);
32 /****************************************************************************
33 * EMF_Create_HENHMETAFILE
35 HENHMETAFILE
EMF_Create_HENHMETAFILE(ENHMETAHEADER
*emh
, HFILE hFile
, HANDLE
39 ENHMETAFILEOBJ
*metaObj
= GDI_AllocObject( sizeof(ENHMETAFILEOBJ
),
40 ENHMETAFILE_MAGIC
, &hmf
);
44 metaObj
->hFile
= hFile
;
45 metaObj
->hMapping
= hMapping
;
46 GDI_ReleaseObj( hmf
);
51 /****************************************************************************
52 * EMF_Delete_HENHMETAFILE
54 static BOOL
EMF_Delete_HENHMETAFILE( HENHMETAFILE hmf
)
56 ENHMETAFILEOBJ
*metaObj
= (ENHMETAFILEOBJ
*)GDI_GetObjPtr( hmf
,
58 if(!metaObj
) return FALSE
;
59 if(metaObj
->hMapping
) {
60 UnmapViewOfFile( metaObj
->emh
);
61 CloseHandle( metaObj
->hMapping
);
62 CloseHandle( metaObj
->hFile
);
64 HeapFree( GetProcessHeap(), 0, metaObj
->emh
);
65 return GDI_FreeObject( hmf
, metaObj
);
68 /******************************************************************
69 * EMF_GetEnhMetaHeader
71 * Returns ptr to ENHMETAHEADER associated with HENHMETAFILE
72 * Should be followed by call to EMF_ReleaseEnhMetaHeader
74 static ENHMETAHEADER
*EMF_GetEnhMetaHeader( HENHMETAFILE hmf
)
76 ENHMETAFILEOBJ
*metaObj
= (ENHMETAFILEOBJ
*)GDI_GetObjPtr( hmf
,
78 TRACE("hmf %04x -> enhmetaObj %p\n", hmf
, metaObj
);
79 return metaObj
? metaObj
->emh
: NULL
;
82 /******************************************************************
83 * EMF_ReleaseEnhMetaHeader
85 * Releases ENHMETAHEADER associated with HENHMETAFILE
87 static void EMF_ReleaseEnhMetaHeader( HENHMETAFILE hmf
)
89 GDI_ReleaseObj( hmf
);
92 /*****************************************************************************
96 static HENHMETAFILE
EMF_GetEnhMetaFile( HANDLE hFile
)
101 hMapping
= CreateFileMappingA( hFile
, NULL
, PAGE_READONLY
, 0, 0, NULL
);
102 emh
= MapViewOfFile( hMapping
, FILE_MAP_READ
, 0, 0, 0 );
104 if (emh
->iType
!= EMR_HEADER
|| emh
->dSignature
!= ENHMETA_SIGNATURE
) {
105 WARN("Invalid emf header type 0x%08lx sig 0x%08lx.\n",
106 emh
->iType
, emh
->dSignature
);
107 UnmapViewOfFile( emh
);
108 CloseHandle( hMapping
);
111 return EMF_Create_HENHMETAFILE( emh
, hFile
, hMapping
);
115 /*****************************************************************************
116 * GetEnhMetaFileA (GDI32.174)
120 HENHMETAFILE WINAPI
GetEnhMetaFileA(
121 LPCSTR lpszMetaFile
/* [in] filename of enhanced metafile */
127 hFile
= CreateFileA(lpszMetaFile
, GENERIC_READ
, FILE_SHARE_READ
, 0,
128 OPEN_EXISTING
, 0, 0);
129 if (hFile
== INVALID_HANDLE_VALUE
) {
130 WARN("could not open %s\n", lpszMetaFile
);
133 hmf
= EMF_GetEnhMetaFile( hFile
);
135 CloseHandle( hFile
);
139 /*****************************************************************************
140 * GetEnhMetaFileW (GDI32.180)
142 HENHMETAFILE WINAPI
GetEnhMetaFileW(
143 LPCWSTR lpszMetaFile
) /* [in] filename of enhanced metafile */
148 hFile
= CreateFileW(lpszMetaFile
, GENERIC_READ
, FILE_SHARE_READ
, 0,
149 OPEN_EXISTING
, 0, 0);
150 if (hFile
== INVALID_HANDLE_VALUE
) {
151 WARN("could not open %s\n", debugstr_w(lpszMetaFile
));
154 hmf
= EMF_GetEnhMetaFile( hFile
);
156 CloseHandle( hFile
);
160 /*****************************************************************************
161 * GetEnhMetaFileHeader (GDI32.178)
163 * If buf is NULL, returns the size of buffer required.
164 * Otherwise, copy up to bufsize bytes of enhanced metafile header into
167 UINT WINAPI
GetEnhMetaFileHeader(
168 HENHMETAFILE hmf
, /* [in] enhanced metafile */
169 UINT bufsize
, /* [in] size of buffer */
170 LPENHMETAHEADER buf
/* [out] buffer */
176 emh
= EMF_GetEnhMetaHeader(hmf
);
177 if(!emh
) return FALSE
;
180 EMF_ReleaseEnhMetaHeader(hmf
);
183 size
= min(size
, bufsize
);
184 memmove(buf
, emh
, size
);
185 EMF_ReleaseEnhMetaHeader(hmf
);
190 /*****************************************************************************
191 * GetEnhMetaFileDescriptionA (GDI32.176)
193 UINT WINAPI
GetEnhMetaFileDescriptionA(
194 HENHMETAFILE hmf
, /* [in] enhanced metafile */
195 UINT size
, /* [in] size of buf */
196 LPSTR buf
/* [out] buffer to receive description */
199 LPENHMETAHEADER emh
= EMF_GetEnhMetaHeader(hmf
);
203 if(!emh
) return FALSE
;
204 if(emh
->nDescription
== 0 || emh
->offDescription
== 0) {
205 EMF_ReleaseEnhMetaHeader(hmf
);
208 descrW
= (WCHAR
*) ((char *) emh
+ emh
->offDescription
);
209 len
= WideCharToMultiByte( CP_ACP
, 0, descrW
, emh
->nDescription
, NULL
, 0, NULL
, NULL
);
211 if (!buf
|| !size
) {
212 EMF_ReleaseEnhMetaHeader(hmf
);
216 len
= min( size
, len
);
217 WideCharToMultiByte( CP_ACP
, 0, descrW
, emh
->nDescription
, buf
, len
, NULL
, NULL
);
218 EMF_ReleaseEnhMetaHeader(hmf
);
222 /*****************************************************************************
223 * GetEnhMetaFileDescriptionW (GDI32.177)
225 * Copies the description string of an enhanced metafile into a buffer
228 * If _buf_ is NULL, returns size of _buf_ required. Otherwise, returns
229 * number of characters copied.
231 UINT WINAPI
GetEnhMetaFileDescriptionW(
232 HENHMETAFILE hmf
, /* [in] enhanced metafile */
233 UINT size
, /* [in] size of buf */
234 LPWSTR buf
/* [out] buffer to receive description */
237 LPENHMETAHEADER emh
= EMF_GetEnhMetaHeader(hmf
);
239 if(!emh
) return FALSE
;
240 if(emh
->nDescription
== 0 || emh
->offDescription
== 0) {
241 EMF_ReleaseEnhMetaHeader(hmf
);
244 if (!buf
|| !size
) {
245 EMF_ReleaseEnhMetaHeader(hmf
);
246 return emh
->nDescription
;
249 memmove(buf
, (char *) emh
+ emh
->offDescription
,
250 min(size
,emh
->nDescription
)*sizeof(WCHAR
));
251 EMF_ReleaseEnhMetaHeader(hmf
);
252 return min(size
, emh
->nDescription
);
255 /****************************************************************************
256 * SetEnhMetaFileBits (GDI32.315)
258 * Creates an enhanced metafile by copying _bufsize_ bytes from _buf_.
260 HENHMETAFILE WINAPI
SetEnhMetaFileBits(UINT bufsize
, const BYTE
*buf
)
262 ENHMETAHEADER
*emh
= HeapAlloc( GetProcessHeap(), 0, bufsize
);
263 memmove(emh
, buf
, bufsize
);
264 return EMF_Create_HENHMETAFILE( emh
, 0, 0 );
267 /*****************************************************************************
268 * GetEnhMetaFileBits (GDI32.175)
271 UINT WINAPI
GetEnhMetaFileBits(
277 LPENHMETAHEADER emh
= EMF_GetEnhMetaHeader( hmf
);
284 EMF_ReleaseEnhMetaHeader( hmf
);
288 size
= min( size
, bufsize
);
289 memmove(buf
, emh
, size
);
291 EMF_ReleaseEnhMetaHeader( hmf
);
295 /*****************************************************************************
296 * PlayEnhMetaFileRecord (GDI32.264)
298 * Render a single enhanced metafile record in the device context hdc.
301 * TRUE (non zero) on success, FALSE on error.
303 * Many unimplemented records.
304 * No error handling on record play failures (ie checking return codes)
306 BOOL WINAPI
PlayEnhMetaFileRecord(
307 HDC hdc
, /* [in] device context in which to render EMF record */
308 LPHANDLETABLE handletable
, /* [in] array of handles to be used in rendering record */
309 const ENHMETARECORD
*mr
, /* [in] EMF record to render */
310 UINT handles
/* [in] size of handle array */
315 "hdc = %08x, handletable = %p, record = %p, numHandles = %d\n",
316 hdc
, handletable
, mr
, handles
);
317 if (!mr
) return FALSE
;
321 TRACE(" type=%d\n", type
);
330 PEMRGDICOMMENT lpGdiComment
= (PEMRGDICOMMENT
)mr
;
331 /* In an enhanced metafile, there can be both public and private GDI comments */
332 GdiComment( hdc
, lpGdiComment
->cbData
, lpGdiComment
->Data
);
337 PEMRSETMAPMODE pSetMapMode
= (PEMRSETMAPMODE
) mr
;
338 SetMapMode(hdc
, pSetMapMode
->iMode
);
343 PEMRSETBKMODE pSetBkMode
= (PEMRSETBKMODE
) mr
;
344 SetBkMode(hdc
, pSetBkMode
->iMode
);
349 PEMRSETBKCOLOR pSetBkColor
= (PEMRSETBKCOLOR
) mr
;
350 SetBkColor(hdc
, pSetBkColor
->crColor
);
353 case EMR_SETPOLYFILLMODE
:
355 PEMRSETPOLYFILLMODE pSetPolyFillMode
= (PEMRSETPOLYFILLMODE
) mr
;
356 SetPolyFillMode(hdc
, pSetPolyFillMode
->iMode
);
361 PEMRSETROP2 pSetROP2
= (PEMRSETROP2
) mr
;
362 SetROP2(hdc
, pSetROP2
->iMode
);
365 case EMR_SETSTRETCHBLTMODE
:
367 PEMRSETSTRETCHBLTMODE pSetStretchBltMode
= (PEMRSETSTRETCHBLTMODE
) mr
;
368 SetStretchBltMode(hdc
, pSetStretchBltMode
->iMode
);
371 case EMR_SETTEXTALIGN
:
373 PEMRSETTEXTALIGN pSetTextAlign
= (PEMRSETTEXTALIGN
) mr
;
374 SetTextAlign(hdc
, pSetTextAlign
->iMode
);
377 case EMR_SETTEXTCOLOR
:
379 PEMRSETTEXTCOLOR pSetTextColor
= (PEMRSETTEXTCOLOR
) mr
;
380 SetTextColor(hdc
, pSetTextColor
->crColor
);
390 PEMRRESTOREDC pRestoreDC
= (PEMRRESTOREDC
) mr
;
391 RestoreDC(hdc
, pRestoreDC
->iRelative
);
394 case EMR_INTERSECTCLIPRECT
:
396 PEMRINTERSECTCLIPRECT pClipRect
= (PEMRINTERSECTCLIPRECT
) mr
;
397 IntersectClipRect(hdc
, pClipRect
->rclClip
.left
, pClipRect
->rclClip
.top
,
398 pClipRect
->rclClip
.right
, pClipRect
->rclClip
.bottom
);
401 case EMR_SELECTOBJECT
:
403 PEMRSELECTOBJECT pSelectObject
= (PEMRSELECTOBJECT
) mr
;
404 if( pSelectObject
->ihObject
& 0x80000000 ) {
405 /* High order bit is set - it's a stock object
406 * Strip the high bit to get the index.
407 * See MSDN article Q142319
409 SelectObject( hdc
, GetStockObject( pSelectObject
->ihObject
&
412 /* High order bit wasn't set - not a stock object
415 (handletable
->objectHandle
)[pSelectObject
->ihObject
] );
419 case EMR_DELETEOBJECT
:
421 PEMRDELETEOBJECT pDeleteObject
= (PEMRDELETEOBJECT
) mr
;
422 DeleteObject( (handletable
->objectHandle
)[pDeleteObject
->ihObject
]);
423 (handletable
->objectHandle
)[pDeleteObject
->ihObject
] = 0;
426 case EMR_SETWINDOWORGEX
:
429 * FIXME: The call to SetWindowOrgEx prevents EMFs from being scrolled
430 * by an application. This is very BAD!!!
433 PEMRSETWINDOWORGEX pSetWindowOrgEx
= (PEMRSETWINDOWORGEX
) mr
;
434 SetWindowOrgEx(hdc
, pSetWindowOrgEx
->ptlOrigin
.x
,
435 pSetWindowOrgEx
->ptlOrigin
.y
, NULL
);
439 case EMR_SETWINDOWEXTEX
:
441 PEMRSETWINDOWEXTEX pSetWindowExtEx
= (PEMRSETWINDOWEXTEX
) mr
;
442 SetWindowExtEx(hdc
, pSetWindowExtEx
->szlExtent
.cx
,
443 pSetWindowExtEx
->szlExtent
.cy
, NULL
);
446 case EMR_SETVIEWPORTORGEX
:
448 PEMRSETVIEWPORTORGEX pSetViewportOrgEx
= (PEMRSETVIEWPORTORGEX
) mr
;
449 SetViewportOrgEx(hdc
, pSetViewportOrgEx
->ptlOrigin
.x
,
450 pSetViewportOrgEx
->ptlOrigin
.y
, NULL
);
453 case EMR_SETVIEWPORTEXTEX
:
455 PEMRSETVIEWPORTEXTEX pSetViewportExtEx
= (PEMRSETVIEWPORTEXTEX
) mr
;
456 SetViewportExtEx(hdc
, pSetViewportExtEx
->szlExtent
.cx
,
457 pSetViewportExtEx
->szlExtent
.cy
, NULL
);
462 PEMRCREATEPEN pCreatePen
= (PEMRCREATEPEN
) mr
;
463 (handletable
->objectHandle
)[pCreatePen
->ihPen
] =
464 CreatePenIndirect(&pCreatePen
->lopn
);
467 case EMR_EXTCREATEPEN
:
469 PEMREXTCREATEPEN pPen
= (PEMREXTCREATEPEN
) mr
;
471 lb
.lbStyle
= pPen
->elp
.elpBrushStyle
;
472 lb
.lbColor
= pPen
->elp
.elpColor
;
473 lb
.lbHatch
= pPen
->elp
.elpHatch
;
475 if(pPen
->offBmi
|| pPen
->offBits
)
476 FIXME("EMR_EXTCREATEPEN: Need to copy brush bitmap\n");
478 (handletable
->objectHandle
)[pPen
->ihPen
] =
479 ExtCreatePen(pPen
->elp
.elpPenStyle
, pPen
->elp
.elpWidth
, &lb
,
480 pPen
->elp
.elpNumEntries
, pPen
->elp
.elpStyleEntry
);
483 case EMR_CREATEBRUSHINDIRECT
:
485 PEMRCREATEBRUSHINDIRECT pBrush
= (PEMRCREATEBRUSHINDIRECT
) mr
;
486 (handletable
->objectHandle
)[pBrush
->ihBrush
] =
487 CreateBrushIndirect(&pBrush
->lb
);
490 case EMR_EXTCREATEFONTINDIRECTW
:
492 PEMREXTCREATEFONTINDIRECTW pFont
= (PEMREXTCREATEFONTINDIRECTW
) mr
;
493 (handletable
->objectHandle
)[pFont
->ihFont
] =
494 CreateFontIndirectW(&pFont
->elfw
.elfLogFont
);
499 PEMRMOVETOEX pMoveToEx
= (PEMRMOVETOEX
) mr
;
500 MoveToEx(hdc
, pMoveToEx
->ptl
.x
, pMoveToEx
->ptl
.y
, NULL
);
505 PEMRLINETO pLineTo
= (PEMRLINETO
) mr
;
506 LineTo(hdc
, pLineTo
->ptl
.x
, pLineTo
->ptl
.y
);
511 PEMRRECTANGLE pRect
= (PEMRRECTANGLE
) mr
;
512 Rectangle(hdc
, pRect
->rclBox
.left
, pRect
->rclBox
.top
,
513 pRect
->rclBox
.right
, pRect
->rclBox
.bottom
);
518 PEMRELLIPSE pEllipse
= (PEMRELLIPSE
) mr
;
519 Ellipse(hdc
, pEllipse
->rclBox
.left
, pEllipse
->rclBox
.top
,
520 pEllipse
->rclBox
.right
, pEllipse
->rclBox
.bottom
);
525 PEMRPOLYGON16 pPoly
= (PEMRPOLYGON16
) mr
;
526 /* Shouldn't use Polygon16 since pPoly->cpts is DWORD */
527 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
528 pPoly
->cpts
* sizeof(POINT
) );
530 for(i
= 0; i
< pPoly
->cpts
; i
++)
531 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
532 Polygon(hdc
, pts
, pPoly
->cpts
);
533 HeapFree( GetProcessHeap(), 0, pts
);
538 PEMRPOLYLINE16 pPoly
= (PEMRPOLYLINE16
) mr
;
539 /* Shouldn't use Polyline16 since pPoly->cpts is DWORD */
540 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
541 pPoly
->cpts
* sizeof(POINT
) );
543 for(i
= 0; i
< pPoly
->cpts
; i
++)
544 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
545 Polyline(hdc
, pts
, pPoly
->cpts
);
546 HeapFree( GetProcessHeap(), 0, pts
);
549 case EMR_POLYLINETO16
:
551 PEMRPOLYLINETO16 pPoly
= (PEMRPOLYLINETO16
) mr
;
552 /* Shouldn't use PolylineTo16 since pPoly->cpts is DWORD */
553 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
554 pPoly
->cpts
* sizeof(POINT
) );
556 for(i
= 0; i
< pPoly
->cpts
; i
++)
557 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
558 PolylineTo(hdc
, pts
, pPoly
->cpts
);
559 HeapFree( GetProcessHeap(), 0, pts
);
562 case EMR_POLYBEZIER16
:
564 PEMRPOLYBEZIER16 pPoly
= (PEMRPOLYBEZIER16
) mr
;
565 /* Shouldn't use PolyBezier16 since pPoly->cpts is DWORD */
566 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
567 pPoly
->cpts
* sizeof(POINT
) );
569 for(i
= 0; i
< pPoly
->cpts
; i
++)
570 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
571 PolyBezier(hdc
, pts
, pPoly
->cpts
);
572 HeapFree( GetProcessHeap(), 0, pts
);
575 case EMR_POLYBEZIERTO16
:
577 PEMRPOLYBEZIERTO16 pPoly
= (PEMRPOLYBEZIERTO16
) mr
;
578 /* Shouldn't use PolyBezierTo16 since pPoly->cpts is DWORD */
579 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
580 pPoly
->cpts
* sizeof(POINT
) );
582 for(i
= 0; i
< pPoly
->cpts
; i
++)
583 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
584 PolyBezierTo(hdc
, pts
, pPoly
->cpts
);
585 HeapFree( GetProcessHeap(), 0, pts
);
588 case EMR_POLYPOLYGON16
:
590 PEMRPOLYPOLYGON16 pPolyPoly
= (PEMRPOLYPOLYGON16
) mr
;
591 /* NB POINTS array doesn't start at pPolyPoly->apts it's actually
592 pPolyPoly->aPolyCounts + pPolyPoly->nPolys */
594 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
595 pPolyPoly
->cpts
* sizeof(POINT
) );
597 for(i
= 0; i
< pPolyPoly
->cpts
; i
++)
598 CONV_POINT16TO32((POINT16
*) (pPolyPoly
->aPolyCounts
+
599 pPolyPoly
->nPolys
) + i
, pts
+ i
);
601 PolyPolygon(hdc
, pts
, (INT
*)pPolyPoly
->aPolyCounts
, pPolyPoly
->nPolys
);
602 HeapFree( GetProcessHeap(), 0, pts
);
605 case EMR_POLYPOLYLINE16
:
607 PEMRPOLYPOLYLINE16 pPolyPoly
= (PEMRPOLYPOLYLINE16
) mr
;
608 /* NB POINTS array doesn't start at pPolyPoly->apts it's actually
609 pPolyPoly->aPolyCounts + pPolyPoly->nPolys */
611 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
612 pPolyPoly
->cpts
* sizeof(POINT
) );
614 for(i
= 0; i
< pPolyPoly
->cpts
; i
++)
615 CONV_POINT16TO32((POINT16
*) (pPolyPoly
->aPolyCounts
+
616 pPolyPoly
->nPolys
) + i
, pts
+ i
);
618 PolyPolyline(hdc
, pts
, pPolyPoly
->aPolyCounts
, pPolyPoly
->nPolys
);
619 HeapFree( GetProcessHeap(), 0, pts
);
623 case EMR_STRETCHDIBITS
:
625 EMRSTRETCHDIBITS
*pStretchDIBits
= (EMRSTRETCHDIBITS
*)mr
;
628 pStretchDIBits
->xDest
,
629 pStretchDIBits
->yDest
,
630 pStretchDIBits
->cxDest
,
631 pStretchDIBits
->cyDest
,
632 pStretchDIBits
->xSrc
,
633 pStretchDIBits
->ySrc
,
634 pStretchDIBits
->cxSrc
,
635 pStretchDIBits
->cySrc
,
636 (BYTE
*)mr
+ pStretchDIBits
->offBitsSrc
,
637 (const BITMAPINFO
*)((BYTE
*)mr
+ pStretchDIBits
->offBmiSrc
),
638 pStretchDIBits
->iUsageSrc
,
639 pStretchDIBits
->dwRop
);
643 case EMR_EXTTEXTOUTA
:
645 PEMREXTTEXTOUTA pExtTextOutA
= (PEMREXTTEXTOUTA
)mr
;
648 rc
.left
= pExtTextOutA
->emrtext
.rcl
.left
;
649 rc
.top
= pExtTextOutA
->emrtext
.rcl
.top
;
650 rc
.right
= pExtTextOutA
->emrtext
.rcl
.right
;
651 rc
.bottom
= pExtTextOutA
->emrtext
.rcl
.bottom
;
652 ExtTextOutA(hdc
, pExtTextOutA
->emrtext
.ptlReference
.x
, pExtTextOutA
->emrtext
.ptlReference
.y
,
653 pExtTextOutA
->emrtext
.fOptions
, &rc
,
654 (LPSTR
)((BYTE
*)mr
+ pExtTextOutA
->emrtext
.offString
), pExtTextOutA
->emrtext
.nChars
,
655 (INT
*)((BYTE
*)mr
+ pExtTextOutA
->emrtext
.offDx
));
659 case EMR_EXTTEXTOUTW
:
661 PEMREXTTEXTOUTW pExtTextOutW
= (PEMREXTTEXTOUTW
)mr
;
664 rc
.left
= pExtTextOutW
->emrtext
.rcl
.left
;
665 rc
.top
= pExtTextOutW
->emrtext
.rcl
.top
;
666 rc
.right
= pExtTextOutW
->emrtext
.rcl
.right
;
667 rc
.bottom
= pExtTextOutW
->emrtext
.rcl
.bottom
;
668 ExtTextOutW(hdc
, pExtTextOutW
->emrtext
.ptlReference
.x
, pExtTextOutW
->emrtext
.ptlReference
.y
,
669 pExtTextOutW
->emrtext
.fOptions
, &rc
,
670 (LPWSTR
)((BYTE
*)mr
+ pExtTextOutW
->emrtext
.offString
), pExtTextOutW
->emrtext
.nChars
,
671 (INT
*)((BYTE
*)mr
+ pExtTextOutW
->emrtext
.offDx
));
675 case EMR_CREATEPALETTE
:
677 PEMRCREATEPALETTE lpCreatePal
= (PEMRCREATEPALETTE
)mr
;
679 (handletable
->objectHandle
)[ lpCreatePal
->ihPal
] =
680 CreatePalette( &lpCreatePal
->lgpl
);
685 case EMR_SELECTPALETTE
:
687 PEMRSELECTPALETTE lpSelectPal
= (PEMRSELECTPALETTE
)mr
;
689 if( lpSelectPal
->ihPal
& 0x80000000 ) {
690 SelectPalette( hdc
, GetStockObject(lpSelectPal
->ihPal
& 0x7fffffff), TRUE
);
692 (handletable
->objectHandle
)[ lpSelectPal
->ihPal
] =
693 SelectPalette( hdc
, (handletable
->objectHandle
)[lpSelectPal
->ihPal
], TRUE
);
698 case EMR_REALIZEPALETTE
:
700 RealizePalette( hdc
);
704 case EMR_EXTSELECTCLIPRGN
:
706 PEMREXTSELECTCLIPRGN lpRgn
= (PEMREXTSELECTCLIPRGN
)mr
;
708 if ((lpRgn
->cbRgnData
== 0) && (lpRgn
->iMode
== RGN_COPY
)) {
709 ExtSelectClipRgn( hdc
, 0, RGN_COPY
);
711 FIXME("EMR_EXTSELECTCLIPRGN cbRgnData %lu\n", lpRgn
->cbRgnData
);
713 /* Need to make a region out of the RGNDATA we have */
714 /* ExtCreateRegion(....); */
715 /* ExtSelectClipRgn( hdc, ..., (INT)(lpRgn->iMode) ); */
727 case EMR_SETWORLDTRANSFORM
:
729 PEMRSETWORLDTRANSFORM lpXfrm
= (PEMRSETWORLDTRANSFORM
)mr
;
730 SetWorldTransform( hdc
, &lpXfrm
->xform
);
736 PEMRPOLYBEZIER lpPolyBez
= (PEMRPOLYBEZIER
)mr
;
737 PolyBezier(hdc
, (const LPPOINT
)lpPolyBez
->aptl
, (UINT
)lpPolyBez
->cptl
);
743 PEMRPOLYGON lpPoly
= (PEMRPOLYGON
)mr
;
744 Polygon( hdc
, (const LPPOINT
)lpPoly
->aptl
, (UINT
)lpPoly
->cptl
);
750 PEMRPOLYLINE lpPolyLine
= (PEMRPOLYLINE
)mr
;
751 Polyline(hdc
, (const LPPOINT
)lpPolyLine
->aptl
, (UINT
)lpPolyLine
->cptl
);
755 case EMR_POLYBEZIERTO
:
757 PEMRPOLYBEZIERTO lpPolyBezierTo
= (PEMRPOLYBEZIERTO
)mr
;
758 PolyBezierTo( hdc
, (const LPPOINT
)lpPolyBezierTo
->aptl
,
759 (UINT
)lpPolyBezierTo
->cptl
);
765 PEMRPOLYLINETO lpPolyLineTo
= (PEMRPOLYLINETO
)mr
;
766 PolylineTo( hdc
, (const LPPOINT
)lpPolyLineTo
->aptl
,
767 (UINT
)lpPolyLineTo
->cptl
);
771 case EMR_POLYPOLYLINE
:
773 PEMRPOLYPOLYLINE pPolyPolyline
= (PEMRPOLYPOLYLINE
) mr
;
774 /* NB Points at pPolyPolyline->aPolyCounts + pPolyPolyline->nPolys */
776 PolyPolyline(hdc
, (LPPOINT
)(pPolyPolyline
->aPolyCounts
+
777 pPolyPolyline
->nPolys
),
778 pPolyPolyline
->aPolyCounts
,
779 pPolyPolyline
->nPolys
);
784 case EMR_POLYPOLYGON
:
786 PEMRPOLYPOLYGON pPolyPolygon
= (PEMRPOLYPOLYGON
) mr
;
788 /* NB Points at pPolyPolygon->aPolyCounts + pPolyPolygon->nPolys */
790 PolyPolygon(hdc
, (LPPOINT
)(pPolyPolygon
->aPolyCounts
+
791 pPolyPolygon
->nPolys
),
792 (INT
*)pPolyPolygon
->aPolyCounts
, pPolyPolygon
->nPolys
);
796 case EMR_SETBRUSHORGEX
:
798 PEMRSETBRUSHORGEX lpSetBrushOrgEx
= (PEMRSETBRUSHORGEX
)mr
;
801 (INT
)lpSetBrushOrgEx
->ptlOrigin
.x
,
802 (INT
)lpSetBrushOrgEx
->ptlOrigin
.y
,
810 PEMRSETPIXELV lpSetPixelV
= (PEMRSETPIXELV
)mr
;
813 (INT
)lpSetPixelV
->ptlPixel
.x
,
814 (INT
)lpSetPixelV
->ptlPixel
.y
,
815 lpSetPixelV
->crColor
);
820 case EMR_SETMAPPERFLAGS
:
822 PEMRSETMAPPERFLAGS lpSetMapperFlags
= (PEMRSETMAPPERFLAGS
)mr
;
824 SetMapperFlags( hdc
, lpSetMapperFlags
->dwFlags
);
829 case EMR_SETCOLORADJUSTMENT
:
831 PEMRSETCOLORADJUSTMENT lpSetColorAdjust
= (PEMRSETCOLORADJUSTMENT
)mr
;
833 SetColorAdjustment( hdc
, &lpSetColorAdjust
->ColorAdjustment
);
838 case EMR_OFFSETCLIPRGN
:
840 PEMROFFSETCLIPRGN lpOffsetClipRgn
= (PEMROFFSETCLIPRGN
)mr
;
843 (INT
)lpOffsetClipRgn
->ptlOffset
.x
,
844 (INT
)lpOffsetClipRgn
->ptlOffset
.y
);
849 case EMR_EXCLUDECLIPRECT
:
851 PEMREXCLUDECLIPRECT lpExcludeClipRect
= (PEMREXCLUDECLIPRECT
)mr
;
853 ExcludeClipRect( hdc
,
854 lpExcludeClipRect
->rclClip
.left
,
855 lpExcludeClipRect
->rclClip
.top
,
856 lpExcludeClipRect
->rclClip
.right
,
857 lpExcludeClipRect
->rclClip
.bottom
);
862 case EMR_SCALEVIEWPORTEXTEX
:
864 PEMRSCALEVIEWPORTEXTEX lpScaleViewportExtEx
= (PEMRSCALEVIEWPORTEXTEX
)mr
;
866 ScaleViewportExtEx( hdc
,
867 lpScaleViewportExtEx
->xNum
,
868 lpScaleViewportExtEx
->xDenom
,
869 lpScaleViewportExtEx
->yNum
,
870 lpScaleViewportExtEx
->yDenom
,
876 case EMR_SCALEWINDOWEXTEX
:
878 PEMRSCALEWINDOWEXTEX lpScaleWindowExtEx
= (PEMRSCALEWINDOWEXTEX
)mr
;
880 ScaleWindowExtEx( hdc
,
881 lpScaleWindowExtEx
->xNum
,
882 lpScaleWindowExtEx
->xDenom
,
883 lpScaleWindowExtEx
->yNum
,
884 lpScaleWindowExtEx
->yDenom
,
890 case EMR_MODIFYWORLDTRANSFORM
:
892 PEMRMODIFYWORLDTRANSFORM lpModifyWorldTrans
= (PEMRMODIFYWORLDTRANSFORM
)mr
;
894 ModifyWorldTransform( hdc
, &lpModifyWorldTrans
->xform
,
895 lpModifyWorldTrans
->iMode
);
902 PEMRANGLEARC lpAngleArc
= (PEMRANGLEARC
)mr
;
905 (INT
)lpAngleArc
->ptlCenter
.x
, (INT
)lpAngleArc
->ptlCenter
.y
,
906 lpAngleArc
->nRadius
, lpAngleArc
->eStartAngle
,
907 lpAngleArc
->eSweepAngle
);
914 PEMRROUNDRECT lpRoundRect
= (PEMRROUNDRECT
)mr
;
917 lpRoundRect
->rclBox
.left
,
918 lpRoundRect
->rclBox
.top
,
919 lpRoundRect
->rclBox
.right
,
920 lpRoundRect
->rclBox
.bottom
,
921 lpRoundRect
->szlCorner
.cx
,
922 lpRoundRect
->szlCorner
.cy
);
929 PEMRARC lpArc
= (PEMRARC
)mr
;
932 (INT
)lpArc
->rclBox
.left
,
933 (INT
)lpArc
->rclBox
.top
,
934 (INT
)lpArc
->rclBox
.right
,
935 (INT
)lpArc
->rclBox
.bottom
,
936 (INT
)lpArc
->ptlStart
.x
,
937 (INT
)lpArc
->ptlStart
.y
,
938 (INT
)lpArc
->ptlEnd
.x
,
939 (INT
)lpArc
->ptlEnd
.y
);
946 PEMRCHORD lpChord
= (PEMRCHORD
)mr
;
949 (INT
)lpChord
->rclBox
.left
,
950 (INT
)lpChord
->rclBox
.top
,
951 (INT
)lpChord
->rclBox
.right
,
952 (INT
)lpChord
->rclBox
.bottom
,
953 (INT
)lpChord
->ptlStart
.x
,
954 (INT
)lpChord
->ptlStart
.y
,
955 (INT
)lpChord
->ptlEnd
.x
,
956 (INT
)lpChord
->ptlEnd
.y
);
963 PEMRPIE lpPie
= (PEMRPIE
)mr
;
966 (INT
)lpPie
->rclBox
.left
,
967 (INT
)lpPie
->rclBox
.top
,
968 (INT
)lpPie
->rclBox
.right
,
969 (INT
)lpPie
->rclBox
.bottom
,
970 (INT
)lpPie
->ptlStart
.x
,
971 (INT
)lpPie
->ptlStart
.y
,
972 (INT
)lpPie
->ptlEnd
.x
,
973 (INT
)lpPie
->ptlEnd
.y
);
980 PEMRARC lpArcTo
= (PEMRARC
)mr
;
983 (INT
)lpArcTo
->rclBox
.left
,
984 (INT
)lpArcTo
->rclBox
.top
,
985 (INT
)lpArcTo
->rclBox
.right
,
986 (INT
)lpArcTo
->rclBox
.bottom
,
987 (INT
)lpArcTo
->ptlStart
.x
,
988 (INT
)lpArcTo
->ptlStart
.y
,
989 (INT
)lpArcTo
->ptlEnd
.x
,
990 (INT
)lpArcTo
->ptlEnd
.y
);
995 case EMR_EXTFLOODFILL
:
997 PEMREXTFLOODFILL lpExtFloodFill
= (PEMREXTFLOODFILL
)mr
;
1000 (INT
)lpExtFloodFill
->ptlStart
.x
,
1001 (INT
)lpExtFloodFill
->ptlStart
.y
,
1002 lpExtFloodFill
->crColor
,
1003 (UINT
)lpExtFloodFill
->iMode
);
1010 PEMRPOLYDRAW lpPolyDraw
= (PEMRPOLYDRAW
)mr
;
1012 (const LPPOINT
)lpPolyDraw
->aptl
,
1013 lpPolyDraw
->abTypes
,
1014 (INT
)lpPolyDraw
->cptl
);
1019 case EMR_SETARCDIRECTION
:
1021 PEMRSETARCDIRECTION lpSetArcDirection
= (PEMRSETARCDIRECTION
)mr
;
1022 SetArcDirection( hdc
, (INT
)lpSetArcDirection
->iArcDirection
);
1026 case EMR_SETMITERLIMIT
:
1028 PEMRSETMITERLIMIT lpSetMiterLimit
= (PEMRSETMITERLIMIT
)mr
;
1029 SetMiterLimit( hdc
, lpSetMiterLimit
->eMiterLimit
, NULL
);
1045 case EMR_CLOSEFIGURE
:
1053 /*PEMRFILLPATH lpFillPath = (PEMRFILLPATH)mr;*/
1058 case EMR_STROKEANDFILLPATH
:
1060 /*PEMRSTROKEANDFILLPATH lpStrokeAndFillPath = (PEMRSTROKEANDFILLPATH)mr;*/
1061 StrokeAndFillPath( hdc
);
1065 case EMR_STROKEPATH
:
1067 /*PEMRSTROKEPATH lpStrokePath = (PEMRSTROKEPATH)mr;*/
1072 case EMR_FLATTENPATH
:
1084 case EMR_SELECTCLIPPATH
:
1086 PEMRSELECTCLIPPATH lpSelectClipPath
= (PEMRSELECTCLIPPATH
)mr
;
1087 SelectClipPath( hdc
, (INT
)lpSelectClipPath
->iMode
);
1097 case EMR_CREATECOLORSPACE
:
1099 PEMRCREATECOLORSPACE lpCreateColorSpace
= (PEMRCREATECOLORSPACE
)mr
;
1100 (handletable
->objectHandle
)[lpCreateColorSpace
->ihCS
] =
1101 CreateColorSpaceA( &lpCreateColorSpace
->lcs
);
1105 case EMR_SETCOLORSPACE
:
1107 PEMRSETCOLORSPACE lpSetColorSpace
= (PEMRSETCOLORSPACE
)mr
;
1109 (handletable
->objectHandle
)[lpSetColorSpace
->ihCS
] );
1113 case EMR_DELETECOLORSPACE
:
1115 PEMRDELETECOLORSPACE lpDeleteColorSpace
= (PEMRDELETECOLORSPACE
)mr
;
1116 DeleteColorSpace( (handletable
->objectHandle
)[lpDeleteColorSpace
->ihCS
] );
1120 case EMR_SETICMMODE
:
1122 PERMSETICMMODE lpSetICMMode
= (PERMSETICMMODE
)mr
;
1123 SetICMMode( hdc
, (INT
)lpSetICMMode
->iMode
);
1127 case EMR_PIXELFORMAT
:
1130 PEMRPIXELFORMAT lpPixelFormat
= (PEMRPIXELFORMAT
)mr
;
1132 iPixelFormat
= ChoosePixelFormat( hdc
, &lpPixelFormat
->pfd
);
1133 SetPixelFormat( hdc
, iPixelFormat
, &lpPixelFormat
->pfd
);
1138 case EMR_SETPALETTEENTRIES
:
1140 PEMRSETPALETTEENTRIES lpSetPaletteEntries
= (PEMRSETPALETTEENTRIES
)mr
;
1142 SetPaletteEntries( (handletable
->objectHandle
)[lpSetPaletteEntries
->ihPal
],
1143 (UINT
)lpSetPaletteEntries
->iStart
,
1144 (UINT
)lpSetPaletteEntries
->cEntries
,
1145 lpSetPaletteEntries
->aPalEntries
);
1150 case EMR_RESIZEPALETTE
:
1152 PEMRRESIZEPALETTE lpResizePalette
= (PEMRRESIZEPALETTE
)mr
;
1154 ResizePalette( (handletable
->objectHandle
)[lpResizePalette
->ihPal
],
1155 (UINT
)lpResizePalette
->cEntries
);
1160 case EMR_CREATEDIBPATTERNBRUSHPT
:
1162 PEMRCREATEDIBPATTERNBRUSHPT lpCreate
= (PEMRCREATEDIBPATTERNBRUSHPT
)mr
;
1164 /* This is a BITMAPINFO struct followed directly by bitmap bits */
1165 LPVOID lpPackedStruct
= HeapAlloc( GetProcessHeap(),
1167 lpCreate
->cbBmi
+ lpCreate
->cbBits
);
1168 /* Now pack this structure */
1169 memcpy( lpPackedStruct
,
1170 ((BYTE
*)lpCreate
) + lpCreate
->offBmi
,
1172 memcpy( ((BYTE
*)lpPackedStruct
) + lpCreate
->cbBmi
,
1173 ((BYTE
*)lpCreate
) + lpCreate
->offBits
,
1176 (handletable
->objectHandle
)[lpCreate
->ihBrush
] =
1177 CreateDIBPatternBrushPt( lpPackedStruct
,
1178 (UINT
)lpCreate
->iUsage
);
1183 case EMR_CREATEMONOBRUSH
:
1185 PEMRCREATEMONOBRUSH pCreateMonoBrush
= (PEMRCREATEMONOBRUSH
)mr
;
1186 BITMAPINFO
*pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pCreateMonoBrush
->offBmi
);
1187 HBITMAP hBmp
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1188 (BYTE
*)mr
+ pCreateMonoBrush
->offBits
, pbi
, 0);
1189 (handletable
->objectHandle
)[pCreateMonoBrush
->ihBrush
] = CreatePatternBrush(hBmp
);
1190 /* CreatePatternBrush created a copy of the bitmap */
1196 case EMR_STRETCHBLT
:
1199 case EMR_SETDIBITSTODEVICE
:
1200 case EMR_POLYDRAW16
:
1201 case EMR_POLYTEXTOUTA
:
1202 case EMR_POLYTEXTOUTW
:
1208 case EMR_GLSBOUNDEDRECORD
:
1210 /* From docs: If PlayEnhMetaFileRecord doesn't recognize a
1211 record then ignore and return TRUE. */
1212 FIXME("type %d is unimplemented\n", type
);
1219 /*****************************************************************************
1221 * EnumEnhMetaFile (GDI32.79)
1223 * Walk an enhanced metafile, calling a user-specified function _EnhMetaFunc_
1225 * record. Returns when either every record has been used or
1226 * when _EnhMetaFunc_ returns FALSE.
1230 * TRUE if every record is used, FALSE if any invocation of _EnhMetaFunc_
1236 BOOL WINAPI
EnumEnhMetaFile(
1237 HDC hdc
, /* [in] device context to pass to _EnhMetaFunc_ */
1238 HENHMETAFILE hmf
, /* [in] EMF to walk */
1239 ENHMFENUMPROC callback
, /* [in] callback function */
1240 LPVOID data
, /* [in] optional data for callback function */
1241 const RECT
*lpRect
/* [in] bounding rectangle for rendered metafile */
1245 ENHMETAHEADER
*emh
, *emhTemp
;
1251 FLOAT xSrcPixSize
, ySrcPixSize
, xscale
, yscale
;
1252 XFORM savedXform
, xform
;
1253 HPEN hPen
= (HPEN
)NULL
;
1254 HBRUSH hBrush
= (HBRUSH
)NULL
;
1255 HFONT hFont
= (HFONT
)NULL
;
1259 SetLastError(ERROR_INVALID_PARAMETER
);
1263 emh
= EMF_GetEnhMetaHeader(hmf
);
1265 SetLastError(ERROR_INVALID_HANDLE
);
1269 /* Copy the metafile into memory, because we need to avoid deadlock. */
1270 emhTemp
= HeapAlloc(GetProcessHeap(), 0, emh
->nSize
+ emh
->nBytes
);
1273 EMF_ReleaseEnhMetaHeader(hmf
);
1274 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1277 memcpy(emhTemp
, emh
, emh
->nSize
+ emh
->nBytes
);
1279 EMF_ReleaseEnhMetaHeader(hmf
);
1281 ht
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
1282 sizeof(HANDLETABLE
) * emh
->nHandles
);
1285 HeapFree(GetProcessHeap(), 0, emhTemp
);
1286 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1289 ht
->objectHandle
[0] = hmf
;
1293 TRACE("rect: %d,%d - %d,%d. rclFrame: %ld,%ld - %ld,%ld\n",
1294 lpRect
->left
, lpRect
->top
, lpRect
->right
, lpRect
->bottom
,
1295 emh
->rclFrame
.left
, emh
->rclFrame
.top
, emh
->rclFrame
.right
,
1296 emh
->rclFrame
.bottom
);
1298 xSrcPixSize
= (FLOAT
) emh
->szlMillimeters
.cx
/ emh
->szlDevice
.cx
;
1299 ySrcPixSize
= (FLOAT
) emh
->szlMillimeters
.cy
/ emh
->szlDevice
.cy
;
1300 xscale
= (FLOAT
)(lpRect
->right
- lpRect
->left
) * 100.0 /
1301 (emh
->rclFrame
.right
- emh
->rclFrame
.left
) * xSrcPixSize
;
1302 yscale
= (FLOAT
)(lpRect
->bottom
- lpRect
->top
) * 100.0 /
1303 (emh
->rclFrame
.bottom
- emh
->rclFrame
.top
) * ySrcPixSize
;
1305 xform
.eM11
= xscale
;
1308 xform
.eM22
= yscale
;
1309 xform
.eDx
= (FLOAT
) lpRect
->left
- (lpRect
->right
- lpRect
->left
) *
1310 emh
->rclFrame
.left
/ (emh
->rclFrame
.right
- emh
->rclFrame
.left
);
1311 xform
.eDy
= (FLOAT
) lpRect
->top
- (lpRect
->bottom
- lpRect
->top
) *
1312 emh
->rclFrame
.top
/ (emh
->rclFrame
.bottom
- emh
->rclFrame
.top
);
1314 savedMode
= SetGraphicsMode(hdc
, GM_ADVANCED
);
1315 GetWorldTransform(hdc
, &savedXform
);
1317 if (!ModifyWorldTransform(hdc
, &xform
, MWT_RIGHTMULTIPLY
)) {
1318 ERR("World transform failed!\n");
1321 /* save the current pen, brush and font */
1322 hPen
= GetCurrentObject(hdc
, OBJ_PEN
);
1323 hBrush
= GetCurrentObject(hdc
, OBJ_BRUSH
);
1324 hFont
= GetCurrentObject(hdc
, OBJ_FONT
);
1327 TRACE("nSize = %ld, nBytes = %ld, nHandles = %d, nRecords = %ld, nPalEntries = %ld\n",
1328 emh
->nSize
, emh
->nBytes
, emh
->nHandles
, emh
->nRecords
, emh
->nPalEntries
);
1332 while(ret
&& offset
< emh
->nBytes
)
1334 emr
= (ENHMETARECORD
*)((char *)emh
+ offset
);
1335 TRACE("Calling EnumFunc with record type %ld, size %ld\n", emr
->iType
, emr
->nSize
);
1336 ret
= (*callback
)(hdc
, ht
, emr
, emh
->nHandles
, data
);
1337 offset
+= emr
->nSize
;
1342 /* restore pen, brush and font */
1343 SelectObject(hdc
, hBrush
);
1344 SelectObject(hdc
, hPen
);
1345 SelectObject(hdc
, hFont
);
1347 SetWorldTransform(hdc
, &savedXform
);
1349 SetGraphicsMode(hdc
, savedMode
);
1352 for(i
= 1; i
< emh
->nHandles
; i
++) /* Don't delete element 0 (hmf) */
1353 if( (ht
->objectHandle
)[i
] )
1354 DeleteObject( (ht
->objectHandle
)[i
] );
1356 HeapFree( GetProcessHeap(), 0, ht
);
1357 HeapFree(GetProcessHeap(), 0, emhTemp
);
1362 static INT CALLBACK
EMF_PlayEnhMetaFileCallback(HDC hdc
, HANDLETABLE
*ht
,
1364 INT handles
, LPVOID data
)
1366 return PlayEnhMetaFileRecord(hdc
, ht
, emr
, handles
);
1369 /**************************************************************************
1370 * PlayEnhMetaFile (GDI32.263)
1372 * Renders an enhanced metafile into a specified rectangle *lpRect
1373 * in device context hdc.
1376 BOOL WINAPI
PlayEnhMetaFile(
1377 HDC hdc
, /* [in] DC to render into */
1378 HENHMETAFILE hmf
, /* [in] metafile to render */
1379 const RECT
*lpRect
/* [in] rectangle to place metafile inside */
1382 return EnumEnhMetaFile(hdc
, hmf
, EMF_PlayEnhMetaFileCallback
, NULL
,
1386 /*****************************************************************************
1387 * DeleteEnhMetaFile (GDI32.68)
1389 * Deletes an enhanced metafile and frees the associated storage.
1391 BOOL WINAPI
DeleteEnhMetaFile(HENHMETAFILE hmf
)
1393 return EMF_Delete_HENHMETAFILE( hmf
);
1396 /*****************************************************************************
1397 * CopyEnhMetaFileA (GDI32.21) Duplicate an enhanced metafile
1401 HENHMETAFILE WINAPI
CopyEnhMetaFileA(
1402 HENHMETAFILE hmfSrc
,
1405 ENHMETAHEADER
*emrSrc
= EMF_GetEnhMetaHeader( hmfSrc
), *emrDst
;
1406 HENHMETAFILE hmfDst
;
1408 if(!emrSrc
) return FALSE
;
1410 emrDst
= HeapAlloc( GetProcessHeap(), 0, emrSrc
->nBytes
);
1411 memcpy( emrDst
, emrSrc
, emrSrc
->nBytes
);
1412 hmfDst
= EMF_Create_HENHMETAFILE( emrDst
, 0, 0 );
1415 hFile
= CreateFileA( file
, GENERIC_WRITE
| GENERIC_READ
, 0, NULL
,
1416 CREATE_ALWAYS
, 0, 0);
1417 WriteFile( hFile
, emrSrc
, emrSrc
->nBytes
, 0, 0);
1418 hmfDst
= EMF_GetEnhMetaFile( hFile
);
1420 EMF_ReleaseEnhMetaHeader( hmfSrc
);
1425 /* Struct to be used to be passed in the LPVOID parameter for cbEnhPaletteCopy */
1426 typedef struct tagEMF_PaletteCopy
1429 LPPALETTEENTRY lpPe
;
1432 /***************************************************************
1433 * Find the EMR_EOF record and then use it to find the
1434 * palette entries for this enhanced metafile.
1435 * The lpData is actually a pointer to a EMF_PaletteCopy struct
1436 * which contains the max number of elements to copy and where
1439 * NOTE: To be used by GetEnhMetaFilePaletteEntries only!
1441 INT CALLBACK
cbEnhPaletteCopy( HDC a
,
1443 LPENHMETARECORD lpEMR
,
1448 if ( lpEMR
->iType
== EMR_EOF
)
1450 PEMREOF lpEof
= (PEMREOF
)lpEMR
;
1451 EMF_PaletteCopy
* info
= (EMF_PaletteCopy
*)lpData
;
1452 DWORD dwNumPalToCopy
= min( lpEof
->nPalEntries
, info
->cEntries
);
1454 TRACE( "copying 0x%08lx palettes\n", dwNumPalToCopy
);
1456 memcpy( (LPVOID
)info
->lpPe
,
1457 (LPVOID
)(((LPSTR
)lpEof
) + lpEof
->offPalEntries
),
1458 sizeof( *(info
->lpPe
) ) * dwNumPalToCopy
);
1460 /* Update the passed data as a return code */
1461 info
->lpPe
= NULL
; /* Palettes were copied! */
1462 info
->cEntries
= (UINT
)dwNumPalToCopy
;
1464 return FALSE
; /* That's all we need */
1470 /*****************************************************************************
1471 * GetEnhMetaFilePaletteEntries (GDI32.179)
1473 * Copy the palette and report size
1475 * BUGS: Error codes (SetLastError) are not set on failures
1477 UINT WINAPI
GetEnhMetaFilePaletteEntries( HENHMETAFILE hEmf
,
1479 LPPALETTEENTRY lpPe
)
1481 ENHMETAHEADER
* enhHeader
= EMF_GetEnhMetaHeader( hEmf
);
1482 UINT uReturnValue
= GDI_ERROR
;
1483 EMF_PaletteCopy infoForCallBack
;
1485 TRACE( "(%04x,%d,%p)\n", hEmf
, cEntries
, lpPe
);
1487 /* First check if there are any palettes associated with
1489 if ( enhHeader
->nPalEntries
== 0 )
1491 /* No palette associated with this enhanced metafile */
1496 /* Is the user requesting the number of palettes? */
1499 uReturnValue
= (UINT
)enhHeader
->nPalEntries
;
1503 /* Copy cEntries worth of PALETTEENTRY structs into the buffer */
1504 infoForCallBack
.cEntries
= cEntries
;
1505 infoForCallBack
.lpPe
= lpPe
;
1507 if ( !EnumEnhMetaFile( 0, hEmf
, cbEnhPaletteCopy
,
1508 &infoForCallBack
, NULL
) )
1513 /* Verify that the callback executed correctly */
1514 if ( infoForCallBack
.lpPe
!= NULL
)
1516 /* Callback proc had error! */
1517 ERR( "cbEnhPaletteCopy didn't execute correctly\n" );
1521 uReturnValue
= infoForCallBack
.cEntries
;
1525 EMF_ReleaseEnhMetaHeader( hEmf
);
1527 return uReturnValue
;
1530 /******************************************************************
1531 * SetWinMetaFileBits (GDI32.343)
1533 * Translate from old style to new style.
1535 * BUGS: - This doesn't take the DC and scaling into account
1536 * - Most record conversions aren't implemented
1537 * - Handle slot assignement is primative and most likely doesn't work
1539 HENHMETAFILE WINAPI
SetWinMetaFileBits(UINT cbBuffer
,
1540 CONST BYTE
*lpbBuffer
,
1542 CONST METAFILEPICT
*lpmfp
1546 LPVOID lpNewEnhMetaFileBuffer
= NULL
;
1547 UINT uNewEnhMetaFileBufferSize
= 0;
1548 BOOL bFoundEOF
= FALSE
;
1550 FIXME( "(%d,%p,%04x,%p):stub\n", cbBuffer
, lpbBuffer
, hdcRef
, lpmfp
);
1552 /* 1. Get the header - skip over this and get straight to the records */
1554 uNewEnhMetaFileBufferSize
= sizeof( ENHMETAHEADER
);
1555 lpNewEnhMetaFileBuffer
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
1556 uNewEnhMetaFileBufferSize
);
1558 if( lpNewEnhMetaFileBuffer
== NULL
)
1563 /* Fill in the header record */
1565 LPENHMETAHEADER lpNewEnhMetaFileHeader
= (LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
;
1567 lpNewEnhMetaFileHeader
->iType
= EMR_HEADER
;
1568 lpNewEnhMetaFileHeader
->nSize
= sizeof( ENHMETAHEADER
);
1570 /* FIXME: Not right. Must be able to get this from the DC */
1571 lpNewEnhMetaFileHeader
->rclBounds
.left
= 0;
1572 lpNewEnhMetaFileHeader
->rclBounds
.right
= 0;
1573 lpNewEnhMetaFileHeader
->rclBounds
.top
= 0;
1574 lpNewEnhMetaFileHeader
->rclBounds
.bottom
= 0;
1576 /* FIXME: Not right. Must be able to get this from the DC */
1577 lpNewEnhMetaFileHeader
->rclFrame
.left
= 0;
1578 lpNewEnhMetaFileHeader
->rclFrame
.right
= 0;
1579 lpNewEnhMetaFileHeader
->rclFrame
.top
= 0;
1580 lpNewEnhMetaFileHeader
->rclFrame
.bottom
= 0;
1582 lpNewEnhMetaFileHeader
->nHandles
= 0; /* No handles yet */
1584 /* FIXME: Add in the rest of the fields to the header */
1599 (char*)lpbBuffer
+= ((METAHEADER
*)lpbBuffer
)->mtHeaderSize
* 2; /* Point past the header - FIXME: metafile quirk? */
1601 /* 2. Enum over individual records and convert them to the new type of records */
1605 LPMETARECORD lpMetaRecord
= (LPMETARECORD
)lpbBuffer
;
1607 #define EMF_ReAllocAndAdjustPointers( a , b ) \
1610 lpTmp = HeapReAlloc( GetProcessHeap(), 0, \
1611 lpNewEnhMetaFileBuffer, \
1612 uNewEnhMetaFileBufferSize + (b) ); \
1613 if( lpTmp == NULL ) { ERR( "No memory!\n" ); goto error; } \
1614 lpNewEnhMetaFileBuffer = lpTmp; \
1615 lpRecord = (a)( (char*)lpNewEnhMetaFileBuffer + uNewEnhMetaFileBufferSize ); \
1616 uNewEnhMetaFileBufferSize += (b); \
1619 switch( lpMetaRecord
->rdFunction
)
1624 size_t uRecord
= sizeof(*lpRecord
);
1626 EMF_ReAllocAndAdjustPointers(PEMREOF
,uRecord
);
1628 /* Fill the new record - FIXME: This is not right */
1629 lpRecord
->emr
.iType
= EMR_EOF
;
1630 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1631 lpRecord
->nPalEntries
= 0; /* FIXME */
1632 lpRecord
->offPalEntries
= 0; /* FIXME */
1633 lpRecord
->nSizeLast
= 0; /* FIXME */
1635 /* No more records after this one */
1638 FIXME( "META_EOF conversion not correct\n" );
1642 case META_SETMAPMODE
:
1644 PEMRSETMAPMODE lpRecord
;
1645 size_t uRecord
= sizeof(*lpRecord
);
1647 EMF_ReAllocAndAdjustPointers(PEMRSETMAPMODE
,uRecord
);
1649 lpRecord
->emr
.iType
= EMR_SETMAPMODE
;
1650 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1652 lpRecord
->iMode
= lpMetaRecord
->rdParm
[0];
1657 case META_DELETEOBJECT
: /* Select and Delete structures are the same */
1658 case META_SELECTOBJECT
:
1660 PEMRDELETEOBJECT lpRecord
;
1661 size_t uRecord
= sizeof(*lpRecord
);
1663 EMF_ReAllocAndAdjustPointers(PEMRDELETEOBJECT
,uRecord
);
1665 if( lpMetaRecord
->rdFunction
== META_DELETEOBJECT
)
1667 lpRecord
->emr
.iType
= EMR_DELETEOBJECT
;
1671 lpRecord
->emr
.iType
= EMR_SELECTOBJECT
;
1673 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1675 lpRecord
->ihObject
= lpMetaRecord
->rdParm
[0]; /* FIXME: Handle */
1680 case META_POLYGON
: /* This is just plain busted. I don't know what I'm doing */
1682 PEMRPOLYGON16 lpRecord
; /* FIXME: Should it be a poly or poly16? */
1683 size_t uRecord
= sizeof(*lpRecord
);
1685 EMF_ReAllocAndAdjustPointers(PEMRPOLYGON16
,uRecord
);
1687 /* FIXME: This is mostly all wrong */
1688 lpRecord
->emr
.iType
= EMR_POLYGON16
;
1689 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1691 lpRecord
->rclBounds
.left
= 0;
1692 lpRecord
->rclBounds
.right
= 0;
1693 lpRecord
->rclBounds
.top
= 0;
1694 lpRecord
->rclBounds
.bottom
= 0;
1697 lpRecord
->apts
[0].x
= 0;
1698 lpRecord
->apts
[0].y
= 0;
1700 FIXME( "META_POLYGON conversion not correct\n" );
1705 case META_SETPOLYFILLMODE
:
1707 PEMRSETPOLYFILLMODE lpRecord
;
1708 size_t uRecord
= sizeof(*lpRecord
);
1710 EMF_ReAllocAndAdjustPointers(PEMRSETPOLYFILLMODE
,uRecord
);
1712 lpRecord
->emr
.iType
= EMR_SETPOLYFILLMODE
;
1713 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1715 lpRecord
->iMode
= lpMetaRecord
->rdParm
[0];
1720 case META_SETWINDOWORG
:
1722 PEMRSETWINDOWORGEX lpRecord
; /* Seems to be the closest thing */
1723 size_t uRecord
= sizeof(*lpRecord
);
1725 EMF_ReAllocAndAdjustPointers(PEMRSETWINDOWORGEX
,uRecord
);
1727 lpRecord
->emr
.iType
= EMR_SETWINDOWORGEX
;
1728 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1730 lpRecord
->ptlOrigin
.x
= lpMetaRecord
->rdParm
[1];
1731 lpRecord
->ptlOrigin
.y
= lpMetaRecord
->rdParm
[0];
1736 case META_SETWINDOWEXT
: /* Structure is the same for SETWINDOWEXT & SETVIEWPORTEXT */
1737 case META_SETVIEWPORTEXT
:
1739 PEMRSETWINDOWEXTEX lpRecord
;
1740 size_t uRecord
= sizeof(*lpRecord
);
1742 EMF_ReAllocAndAdjustPointers(PEMRSETWINDOWEXTEX
,uRecord
);
1744 if ( lpMetaRecord
->rdFunction
== META_SETWINDOWEXT
)
1746 lpRecord
->emr
.iType
= EMR_SETWINDOWORGEX
;
1750 lpRecord
->emr
.iType
= EMR_SETVIEWPORTEXTEX
;
1752 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1754 lpRecord
->szlExtent
.cx
= lpMetaRecord
->rdParm
[1];
1755 lpRecord
->szlExtent
.cy
= lpMetaRecord
->rdParm
[0];
1760 case META_CREATEBRUSHINDIRECT
:
1762 PEMRCREATEBRUSHINDIRECT lpRecord
;
1763 size_t uRecord
= sizeof(*lpRecord
);
1765 EMF_ReAllocAndAdjustPointers(PEMRCREATEBRUSHINDIRECT
,uRecord
);
1767 lpRecord
->emr
.iType
= EMR_CREATEBRUSHINDIRECT
;
1768 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1770 lpRecord
->ihBrush
= ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nHandles
;
1771 lpRecord
->lb
.lbStyle
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbStyle
;
1772 lpRecord
->lb
.lbColor
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbColor
;
1773 lpRecord
->lb
.lbHatch
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbHatch
;
1775 ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nHandles
+= 1; /* New handle */
1781 /* These are all unimplemented and as such are intended to fall through to the default case */
1782 case META_SETBKCOLOR
:
1783 case META_SETBKMODE
:
1785 case META_SETRELABS
:
1786 case META_SETSTRETCHBLTMODE
:
1787 case META_SETTEXTCOLOR
:
1788 case META_SETVIEWPORTORG
:
1789 case META_OFFSETWINDOWORG
:
1790 case META_SCALEWINDOWEXT
:
1791 case META_OFFSETVIEWPORTORG
:
1792 case META_SCALEVIEWPORTEXT
:
1795 case META_EXCLUDECLIPRECT
:
1796 case META_INTERSECTCLIPRECT
:
1799 case META_FLOODFILL
:
1801 case META_RECTANGLE
:
1802 case META_ROUNDRECT
:
1806 case META_OFFSETCLIPRGN
:
1808 case META_POLYPOLYGON
:
1810 case META_RESTOREDC
:
1812 case META_CREATEPATTERNBRUSH
:
1813 case META_CREATEPENINDIRECT
:
1814 case META_CREATEFONTINDIRECT
:
1815 case META_CREATEPALETTE
:
1816 case META_SETTEXTALIGN
:
1817 case META_SELECTPALETTE
:
1818 case META_SETMAPPERFLAGS
:
1819 case META_REALIZEPALETTE
:
1821 case META_EXTTEXTOUT
:
1822 case META_STRETCHDIB
:
1823 case META_DIBSTRETCHBLT
:
1824 case META_STRETCHBLT
:
1826 case META_CREATEREGION
:
1827 case META_FILLREGION
:
1828 case META_FRAMEREGION
:
1829 case META_INVERTREGION
:
1830 case META_PAINTREGION
:
1831 case META_SELECTCLIPREGION
:
1832 case META_DIBCREATEPATTERNBRUSH
:
1833 case META_DIBBITBLT
:
1834 case META_SETTEXTCHAREXTRA
:
1835 case META_SETTEXTJUSTIFICATION
:
1836 case META_EXTFLOODFILL
:
1837 case META_SETDIBTODEV
:
1839 case META_ANIMATEPALETTE
:
1840 case META_SETPALENTRIES
:
1841 case META_RESIZEPALETTE
:
1844 case META_STARTPAGE
:
1848 case META_CREATEBRUSH
:
1849 case META_CREATEBITMAPINDIRECT
:
1850 case META_CREATEBITMAP
:
1851 /* Fall through to unimplemented */
1854 /* Not implemented yet */
1855 FIXME( "Conversion of record type 0x%x not implemented.\n", lpMetaRecord
->rdFunction
);
1860 /* Move to the next record */
1861 (char*)lpbBuffer
+= ((LPMETARECORD
)lpbBuffer
)->rdSize
* 2; /* FIXME: Seem to be doing this in metafile.c */
1863 #undef ReAllocAndAdjustPointers
1866 /* We know the last of the header information now */
1867 ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nBytes
= uNewEnhMetaFileBufferSize
;
1869 /* Create the enhanced metafile */
1870 hMf
= SetEnhMetaFileBits( uNewEnhMetaFileBufferSize
, (const BYTE
*)lpNewEnhMetaFileBuffer
);
1873 ERR( "Problem creating metafile. Did the conversion fail somewhere?\n" );
1878 /* Free the data associated with our copy since it's been copied */
1879 HeapFree( GetProcessHeap(), 0, lpNewEnhMetaFileBuffer
);