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 "debugtools.h"
28 DEFAULT_DEBUG_CHANNEL(enhmetafile
);
34 BOOL on_disk
; /* true if metafile is on disk */
38 /****************************************************************************
39 * EMF_Create_HENHMETAFILE
41 HENHMETAFILE
EMF_Create_HENHMETAFILE(ENHMETAHEADER
*emh
, BOOL on_disk
)
44 ENHMETAFILEOBJ
*metaObj
= GDI_AllocObject( sizeof(ENHMETAFILEOBJ
),
45 ENHMETAFILE_MAGIC
, &hmf
);
49 metaObj
->on_disk
= on_disk
;
50 GDI_ReleaseObj( hmf
);
55 /****************************************************************************
56 * EMF_Delete_HENHMETAFILE
58 static BOOL
EMF_Delete_HENHMETAFILE( HENHMETAFILE hmf
)
60 ENHMETAFILEOBJ
*metaObj
= (ENHMETAFILEOBJ
*)GDI_GetObjPtr( hmf
,
62 if(!metaObj
) return FALSE
;
65 UnmapViewOfFile( metaObj
->emh
);
67 HeapFree( GetProcessHeap(), 0, metaObj
->emh
);
68 return GDI_FreeObject( hmf
, metaObj
);
71 /******************************************************************
72 * EMF_GetEnhMetaHeader
74 * Returns ptr to ENHMETAHEADER associated with HENHMETAFILE
75 * Should be followed by call to EMF_ReleaseEnhMetaHeader
77 static ENHMETAHEADER
*EMF_GetEnhMetaHeader( HENHMETAFILE hmf
)
79 ENHMETAFILEOBJ
*metaObj
= (ENHMETAFILEOBJ
*)GDI_GetObjPtr( hmf
,
81 TRACE("hmf %04x -> enhmetaObj %p\n", hmf
, metaObj
);
82 return metaObj
? metaObj
->emh
: NULL
;
85 /******************************************************************
86 * EMF_ReleaseEnhMetaHeader
88 * Releases ENHMETAHEADER associated with HENHMETAFILE
90 static void EMF_ReleaseEnhMetaHeader( HENHMETAFILE hmf
)
92 GDI_ReleaseObj( hmf
);
95 /*****************************************************************************
99 static HENHMETAFILE
EMF_GetEnhMetaFile( HANDLE hFile
)
104 hMapping
= CreateFileMappingA( hFile
, NULL
, PAGE_READONLY
, 0, 0, NULL
);
105 emh
= MapViewOfFile( hMapping
, FILE_MAP_READ
, 0, 0, 0 );
106 CloseHandle( hMapping
);
110 if (emh
->iType
!= EMR_HEADER
|| emh
->dSignature
!= ENHMETA_SIGNATURE
) {
111 WARN("Invalid emf header type 0x%08lx sig 0x%08lx.\n",
112 emh
->iType
, emh
->dSignature
);
113 UnmapViewOfFile( emh
);
116 return EMF_Create_HENHMETAFILE( emh
, TRUE
);
120 /*****************************************************************************
121 * GetEnhMetaFileA (GDI32.@)
125 HENHMETAFILE WINAPI
GetEnhMetaFileA(
126 LPCSTR lpszMetaFile
/* [in] filename of enhanced metafile */
132 hFile
= CreateFileA(lpszMetaFile
, GENERIC_READ
, FILE_SHARE_READ
, 0,
133 OPEN_EXISTING
, 0, 0);
134 if (hFile
== INVALID_HANDLE_VALUE
) {
135 WARN("could not open %s\n", lpszMetaFile
);
138 hmf
= EMF_GetEnhMetaFile( hFile
);
139 CloseHandle( hFile
);
143 /*****************************************************************************
144 * GetEnhMetaFileW (GDI32.@)
146 HENHMETAFILE WINAPI
GetEnhMetaFileW(
147 LPCWSTR lpszMetaFile
) /* [in] filename of enhanced metafile */
152 hFile
= CreateFileW(lpszMetaFile
, GENERIC_READ
, FILE_SHARE_READ
, 0,
153 OPEN_EXISTING
, 0, 0);
154 if (hFile
== INVALID_HANDLE_VALUE
) {
155 WARN("could not open %s\n", debugstr_w(lpszMetaFile
));
158 hmf
= EMF_GetEnhMetaFile( hFile
);
159 CloseHandle( hFile
);
163 /*****************************************************************************
164 * GetEnhMetaFileHeader (GDI32.@)
166 * If buf is NULL, returns the size of buffer required.
167 * Otherwise, copy up to bufsize bytes of enhanced metafile header into
170 UINT WINAPI
GetEnhMetaFileHeader(
171 HENHMETAFILE hmf
, /* [in] enhanced metafile */
172 UINT bufsize
, /* [in] size of buffer */
173 LPENHMETAHEADER buf
/* [out] buffer */
179 emh
= EMF_GetEnhMetaHeader(hmf
);
180 if(!emh
) return FALSE
;
183 EMF_ReleaseEnhMetaHeader(hmf
);
186 size
= min(size
, bufsize
);
187 memmove(buf
, emh
, size
);
188 EMF_ReleaseEnhMetaHeader(hmf
);
193 /*****************************************************************************
194 * GetEnhMetaFileDescriptionA (GDI32.@)
196 UINT WINAPI
GetEnhMetaFileDescriptionA(
197 HENHMETAFILE hmf
, /* [in] enhanced metafile */
198 UINT size
, /* [in] size of buf */
199 LPSTR buf
/* [out] buffer to receive description */
202 LPENHMETAHEADER emh
= EMF_GetEnhMetaHeader(hmf
);
206 if(!emh
) return FALSE
;
207 if(emh
->nDescription
== 0 || emh
->offDescription
== 0) {
208 EMF_ReleaseEnhMetaHeader(hmf
);
211 descrW
= (WCHAR
*) ((char *) emh
+ emh
->offDescription
);
212 len
= WideCharToMultiByte( CP_ACP
, 0, descrW
, emh
->nDescription
, NULL
, 0, NULL
, NULL
);
214 if (!buf
|| !size
) {
215 EMF_ReleaseEnhMetaHeader(hmf
);
219 len
= min( size
, len
);
220 WideCharToMultiByte( CP_ACP
, 0, descrW
, emh
->nDescription
, buf
, len
, NULL
, NULL
);
221 EMF_ReleaseEnhMetaHeader(hmf
);
225 /*****************************************************************************
226 * GetEnhMetaFileDescriptionW (GDI32.@)
228 * Copies the description string of an enhanced metafile into a buffer
231 * If _buf_ is NULL, returns size of _buf_ required. Otherwise, returns
232 * number of characters copied.
234 UINT WINAPI
GetEnhMetaFileDescriptionW(
235 HENHMETAFILE hmf
, /* [in] enhanced metafile */
236 UINT size
, /* [in] size of buf */
237 LPWSTR buf
/* [out] buffer to receive description */
240 LPENHMETAHEADER emh
= EMF_GetEnhMetaHeader(hmf
);
242 if(!emh
) return FALSE
;
243 if(emh
->nDescription
== 0 || emh
->offDescription
== 0) {
244 EMF_ReleaseEnhMetaHeader(hmf
);
247 if (!buf
|| !size
) {
248 EMF_ReleaseEnhMetaHeader(hmf
);
249 return emh
->nDescription
;
252 memmove(buf
, (char *) emh
+ emh
->offDescription
,
253 min(size
,emh
->nDescription
)*sizeof(WCHAR
));
254 EMF_ReleaseEnhMetaHeader(hmf
);
255 return min(size
, emh
->nDescription
);
258 /****************************************************************************
259 * SetEnhMetaFileBits (GDI32.@)
261 * Creates an enhanced metafile by copying _bufsize_ bytes from _buf_.
263 HENHMETAFILE WINAPI
SetEnhMetaFileBits(UINT bufsize
, const BYTE
*buf
)
265 ENHMETAHEADER
*emh
= HeapAlloc( GetProcessHeap(), 0, bufsize
);
266 memmove(emh
, buf
, bufsize
);
267 return EMF_Create_HENHMETAFILE( emh
, FALSE
);
270 /*****************************************************************************
271 * GetEnhMetaFileBits (GDI32.@)
274 UINT WINAPI
GetEnhMetaFileBits(
280 LPENHMETAHEADER emh
= EMF_GetEnhMetaHeader( hmf
);
287 EMF_ReleaseEnhMetaHeader( hmf
);
291 size
= min( size
, bufsize
);
292 memmove(buf
, emh
, size
);
294 EMF_ReleaseEnhMetaHeader( hmf
);
298 /*****************************************************************************
299 * PlayEnhMetaFileRecord (GDI32.@)
301 * Render a single enhanced metafile record in the device context hdc.
304 * TRUE (non zero) on success, FALSE on error.
306 * Many unimplemented records.
307 * No error handling on record play failures (ie checking return codes)
309 BOOL WINAPI
PlayEnhMetaFileRecord(
310 HDC hdc
, /* [in] device context in which to render EMF record */
311 LPHANDLETABLE handletable
, /* [in] array of handles to be used in rendering record */
312 const ENHMETARECORD
*mr
, /* [in] EMF record to render */
313 UINT handles
/* [in] size of handle array */
318 "hdc = %08x, handletable = %p, record = %p, numHandles = %d\n",
319 hdc
, handletable
, mr
, handles
);
320 if (!mr
) return FALSE
;
324 TRACE(" type=%d\n", type
);
333 PEMRGDICOMMENT lpGdiComment
= (PEMRGDICOMMENT
)mr
;
334 /* In an enhanced metafile, there can be both public and private GDI comments */
335 GdiComment( hdc
, lpGdiComment
->cbData
, lpGdiComment
->Data
);
340 PEMRSETMAPMODE pSetMapMode
= (PEMRSETMAPMODE
) mr
;
341 SetMapMode(hdc
, pSetMapMode
->iMode
);
346 PEMRSETBKMODE pSetBkMode
= (PEMRSETBKMODE
) mr
;
347 SetBkMode(hdc
, pSetBkMode
->iMode
);
352 PEMRSETBKCOLOR pSetBkColor
= (PEMRSETBKCOLOR
) mr
;
353 SetBkColor(hdc
, pSetBkColor
->crColor
);
356 case EMR_SETPOLYFILLMODE
:
358 PEMRSETPOLYFILLMODE pSetPolyFillMode
= (PEMRSETPOLYFILLMODE
) mr
;
359 SetPolyFillMode(hdc
, pSetPolyFillMode
->iMode
);
364 PEMRSETROP2 pSetROP2
= (PEMRSETROP2
) mr
;
365 SetROP2(hdc
, pSetROP2
->iMode
);
368 case EMR_SETSTRETCHBLTMODE
:
370 PEMRSETSTRETCHBLTMODE pSetStretchBltMode
= (PEMRSETSTRETCHBLTMODE
) mr
;
371 SetStretchBltMode(hdc
, pSetStretchBltMode
->iMode
);
374 case EMR_SETTEXTALIGN
:
376 PEMRSETTEXTALIGN pSetTextAlign
= (PEMRSETTEXTALIGN
) mr
;
377 SetTextAlign(hdc
, pSetTextAlign
->iMode
);
380 case EMR_SETTEXTCOLOR
:
382 PEMRSETTEXTCOLOR pSetTextColor
= (PEMRSETTEXTCOLOR
) mr
;
383 SetTextColor(hdc
, pSetTextColor
->crColor
);
393 PEMRRESTOREDC pRestoreDC
= (PEMRRESTOREDC
) mr
;
394 RestoreDC(hdc
, pRestoreDC
->iRelative
);
397 case EMR_INTERSECTCLIPRECT
:
399 PEMRINTERSECTCLIPRECT pClipRect
= (PEMRINTERSECTCLIPRECT
) mr
;
400 IntersectClipRect(hdc
, pClipRect
->rclClip
.left
, pClipRect
->rclClip
.top
,
401 pClipRect
->rclClip
.right
, pClipRect
->rclClip
.bottom
);
404 case EMR_SELECTOBJECT
:
406 PEMRSELECTOBJECT pSelectObject
= (PEMRSELECTOBJECT
) mr
;
407 if( pSelectObject
->ihObject
& 0x80000000 ) {
408 /* High order bit is set - it's a stock object
409 * Strip the high bit to get the index.
410 * See MSDN article Q142319
412 SelectObject( hdc
, GetStockObject( pSelectObject
->ihObject
&
415 /* High order bit wasn't set - not a stock object
418 (handletable
->objectHandle
)[pSelectObject
->ihObject
] );
422 case EMR_DELETEOBJECT
:
424 PEMRDELETEOBJECT pDeleteObject
= (PEMRDELETEOBJECT
) mr
;
425 DeleteObject( (handletable
->objectHandle
)[pDeleteObject
->ihObject
]);
426 (handletable
->objectHandle
)[pDeleteObject
->ihObject
] = 0;
429 case EMR_SETWINDOWORGEX
:
432 * FIXME: The call to SetWindowOrgEx prevents EMFs from being scrolled
433 * by an application. This is very BAD!!!
436 PEMRSETWINDOWORGEX pSetWindowOrgEx
= (PEMRSETWINDOWORGEX
) mr
;
437 SetWindowOrgEx(hdc
, pSetWindowOrgEx
->ptlOrigin
.x
,
438 pSetWindowOrgEx
->ptlOrigin
.y
, NULL
);
442 case EMR_SETWINDOWEXTEX
:
444 PEMRSETWINDOWEXTEX pSetWindowExtEx
= (PEMRSETWINDOWEXTEX
) mr
;
445 SetWindowExtEx(hdc
, pSetWindowExtEx
->szlExtent
.cx
,
446 pSetWindowExtEx
->szlExtent
.cy
, NULL
);
449 case EMR_SETVIEWPORTORGEX
:
451 PEMRSETVIEWPORTORGEX pSetViewportOrgEx
= (PEMRSETVIEWPORTORGEX
) mr
;
452 SetViewportOrgEx(hdc
, pSetViewportOrgEx
->ptlOrigin
.x
,
453 pSetViewportOrgEx
->ptlOrigin
.y
, NULL
);
456 case EMR_SETVIEWPORTEXTEX
:
458 PEMRSETVIEWPORTEXTEX pSetViewportExtEx
= (PEMRSETVIEWPORTEXTEX
) mr
;
459 SetViewportExtEx(hdc
, pSetViewportExtEx
->szlExtent
.cx
,
460 pSetViewportExtEx
->szlExtent
.cy
, NULL
);
465 PEMRCREATEPEN pCreatePen
= (PEMRCREATEPEN
) mr
;
466 (handletable
->objectHandle
)[pCreatePen
->ihPen
] =
467 CreatePenIndirect(&pCreatePen
->lopn
);
470 case EMR_EXTCREATEPEN
:
472 PEMREXTCREATEPEN pPen
= (PEMREXTCREATEPEN
) mr
;
474 lb
.lbStyle
= pPen
->elp
.elpBrushStyle
;
475 lb
.lbColor
= pPen
->elp
.elpColor
;
476 lb
.lbHatch
= pPen
->elp
.elpHatch
;
478 if(pPen
->offBmi
|| pPen
->offBits
)
479 FIXME("EMR_EXTCREATEPEN: Need to copy brush bitmap\n");
481 (handletable
->objectHandle
)[pPen
->ihPen
] =
482 ExtCreatePen(pPen
->elp
.elpPenStyle
, pPen
->elp
.elpWidth
, &lb
,
483 pPen
->elp
.elpNumEntries
, pPen
->elp
.elpStyleEntry
);
486 case EMR_CREATEBRUSHINDIRECT
:
488 PEMRCREATEBRUSHINDIRECT pBrush
= (PEMRCREATEBRUSHINDIRECT
) mr
;
489 (handletable
->objectHandle
)[pBrush
->ihBrush
] =
490 CreateBrushIndirect(&pBrush
->lb
);
493 case EMR_EXTCREATEFONTINDIRECTW
:
495 PEMREXTCREATEFONTINDIRECTW pFont
= (PEMREXTCREATEFONTINDIRECTW
) mr
;
496 (handletable
->objectHandle
)[pFont
->ihFont
] =
497 CreateFontIndirectW(&pFont
->elfw
.elfLogFont
);
502 PEMRMOVETOEX pMoveToEx
= (PEMRMOVETOEX
) mr
;
503 MoveToEx(hdc
, pMoveToEx
->ptl
.x
, pMoveToEx
->ptl
.y
, NULL
);
508 PEMRLINETO pLineTo
= (PEMRLINETO
) mr
;
509 LineTo(hdc
, pLineTo
->ptl
.x
, pLineTo
->ptl
.y
);
514 PEMRRECTANGLE pRect
= (PEMRRECTANGLE
) mr
;
515 Rectangle(hdc
, pRect
->rclBox
.left
, pRect
->rclBox
.top
,
516 pRect
->rclBox
.right
, pRect
->rclBox
.bottom
);
521 PEMRELLIPSE pEllipse
= (PEMRELLIPSE
) mr
;
522 Ellipse(hdc
, pEllipse
->rclBox
.left
, pEllipse
->rclBox
.top
,
523 pEllipse
->rclBox
.right
, pEllipse
->rclBox
.bottom
);
528 PEMRPOLYGON16 pPoly
= (PEMRPOLYGON16
) mr
;
529 /* Shouldn't use Polygon16 since pPoly->cpts is DWORD */
530 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
531 pPoly
->cpts
* sizeof(POINT
) );
533 for(i
= 0; i
< pPoly
->cpts
; i
++)
534 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
535 Polygon(hdc
, pts
, pPoly
->cpts
);
536 HeapFree( GetProcessHeap(), 0, pts
);
541 PEMRPOLYLINE16 pPoly
= (PEMRPOLYLINE16
) mr
;
542 /* Shouldn't use Polyline16 since pPoly->cpts is DWORD */
543 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
544 pPoly
->cpts
* sizeof(POINT
) );
546 for(i
= 0; i
< pPoly
->cpts
; i
++)
547 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
548 Polyline(hdc
, pts
, pPoly
->cpts
);
549 HeapFree( GetProcessHeap(), 0, pts
);
552 case EMR_POLYLINETO16
:
554 PEMRPOLYLINETO16 pPoly
= (PEMRPOLYLINETO16
) mr
;
555 /* Shouldn't use PolylineTo16 since pPoly->cpts is DWORD */
556 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
557 pPoly
->cpts
* sizeof(POINT
) );
559 for(i
= 0; i
< pPoly
->cpts
; i
++)
560 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
561 PolylineTo(hdc
, pts
, pPoly
->cpts
);
562 HeapFree( GetProcessHeap(), 0, pts
);
565 case EMR_POLYBEZIER16
:
567 PEMRPOLYBEZIER16 pPoly
= (PEMRPOLYBEZIER16
) mr
;
568 /* Shouldn't use PolyBezier16 since pPoly->cpts is DWORD */
569 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
570 pPoly
->cpts
* sizeof(POINT
) );
572 for(i
= 0; i
< pPoly
->cpts
; i
++)
573 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
574 PolyBezier(hdc
, pts
, pPoly
->cpts
);
575 HeapFree( GetProcessHeap(), 0, pts
);
578 case EMR_POLYBEZIERTO16
:
580 PEMRPOLYBEZIERTO16 pPoly
= (PEMRPOLYBEZIERTO16
) mr
;
581 /* Shouldn't use PolyBezierTo16 since pPoly->cpts is DWORD */
582 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
583 pPoly
->cpts
* sizeof(POINT
) );
585 for(i
= 0; i
< pPoly
->cpts
; i
++)
586 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
587 PolyBezierTo(hdc
, pts
, pPoly
->cpts
);
588 HeapFree( GetProcessHeap(), 0, pts
);
591 case EMR_POLYPOLYGON16
:
593 PEMRPOLYPOLYGON16 pPolyPoly
= (PEMRPOLYPOLYGON16
) mr
;
594 /* NB POINTS array doesn't start at pPolyPoly->apts it's actually
595 pPolyPoly->aPolyCounts + pPolyPoly->nPolys */
597 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
598 pPolyPoly
->cpts
* sizeof(POINT
) );
600 for(i
= 0; i
< pPolyPoly
->cpts
; i
++)
601 CONV_POINT16TO32((POINT16
*) (pPolyPoly
->aPolyCounts
+
602 pPolyPoly
->nPolys
) + i
, pts
+ i
);
604 PolyPolygon(hdc
, pts
, (INT
*)pPolyPoly
->aPolyCounts
, pPolyPoly
->nPolys
);
605 HeapFree( GetProcessHeap(), 0, pts
);
608 case EMR_POLYPOLYLINE16
:
610 PEMRPOLYPOLYLINE16 pPolyPoly
= (PEMRPOLYPOLYLINE16
) mr
;
611 /* NB POINTS array doesn't start at pPolyPoly->apts it's actually
612 pPolyPoly->aPolyCounts + pPolyPoly->nPolys */
614 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
615 pPolyPoly
->cpts
* sizeof(POINT
) );
617 for(i
= 0; i
< pPolyPoly
->cpts
; i
++)
618 CONV_POINT16TO32((POINT16
*) (pPolyPoly
->aPolyCounts
+
619 pPolyPoly
->nPolys
) + i
, pts
+ i
);
621 PolyPolyline(hdc
, pts
, pPolyPoly
->aPolyCounts
, pPolyPoly
->nPolys
);
622 HeapFree( GetProcessHeap(), 0, pts
);
626 case EMR_STRETCHDIBITS
:
628 EMRSTRETCHDIBITS
*pStretchDIBits
= (EMRSTRETCHDIBITS
*)mr
;
631 pStretchDIBits
->xDest
,
632 pStretchDIBits
->yDest
,
633 pStretchDIBits
->cxDest
,
634 pStretchDIBits
->cyDest
,
635 pStretchDIBits
->xSrc
,
636 pStretchDIBits
->ySrc
,
637 pStretchDIBits
->cxSrc
,
638 pStretchDIBits
->cySrc
,
639 (BYTE
*)mr
+ pStretchDIBits
->offBitsSrc
,
640 (const BITMAPINFO
*)((BYTE
*)mr
+ pStretchDIBits
->offBmiSrc
),
641 pStretchDIBits
->iUsageSrc
,
642 pStretchDIBits
->dwRop
);
646 case EMR_EXTTEXTOUTA
:
648 PEMREXTTEXTOUTA pExtTextOutA
= (PEMREXTTEXTOUTA
)mr
;
651 rc
.left
= pExtTextOutA
->emrtext
.rcl
.left
;
652 rc
.top
= pExtTextOutA
->emrtext
.rcl
.top
;
653 rc
.right
= pExtTextOutA
->emrtext
.rcl
.right
;
654 rc
.bottom
= pExtTextOutA
->emrtext
.rcl
.bottom
;
655 ExtTextOutA(hdc
, pExtTextOutA
->emrtext
.ptlReference
.x
, pExtTextOutA
->emrtext
.ptlReference
.y
,
656 pExtTextOutA
->emrtext
.fOptions
, &rc
,
657 (LPSTR
)((BYTE
*)mr
+ pExtTextOutA
->emrtext
.offString
), pExtTextOutA
->emrtext
.nChars
,
658 (INT
*)((BYTE
*)mr
+ pExtTextOutA
->emrtext
.offDx
));
662 case EMR_EXTTEXTOUTW
:
664 PEMREXTTEXTOUTW pExtTextOutW
= (PEMREXTTEXTOUTW
)mr
;
667 rc
.left
= pExtTextOutW
->emrtext
.rcl
.left
;
668 rc
.top
= pExtTextOutW
->emrtext
.rcl
.top
;
669 rc
.right
= pExtTextOutW
->emrtext
.rcl
.right
;
670 rc
.bottom
= pExtTextOutW
->emrtext
.rcl
.bottom
;
671 ExtTextOutW(hdc
, pExtTextOutW
->emrtext
.ptlReference
.x
, pExtTextOutW
->emrtext
.ptlReference
.y
,
672 pExtTextOutW
->emrtext
.fOptions
, &rc
,
673 (LPWSTR
)((BYTE
*)mr
+ pExtTextOutW
->emrtext
.offString
), pExtTextOutW
->emrtext
.nChars
,
674 (INT
*)((BYTE
*)mr
+ pExtTextOutW
->emrtext
.offDx
));
678 case EMR_CREATEPALETTE
:
680 PEMRCREATEPALETTE lpCreatePal
= (PEMRCREATEPALETTE
)mr
;
682 (handletable
->objectHandle
)[ lpCreatePal
->ihPal
] =
683 CreatePalette( &lpCreatePal
->lgpl
);
688 case EMR_SELECTPALETTE
:
690 PEMRSELECTPALETTE lpSelectPal
= (PEMRSELECTPALETTE
)mr
;
692 if( lpSelectPal
->ihPal
& 0x80000000 ) {
693 SelectPalette( hdc
, GetStockObject(lpSelectPal
->ihPal
& 0x7fffffff), TRUE
);
695 (handletable
->objectHandle
)[ lpSelectPal
->ihPal
] =
696 SelectPalette( hdc
, (handletable
->objectHandle
)[lpSelectPal
->ihPal
], TRUE
);
701 case EMR_REALIZEPALETTE
:
703 RealizePalette( hdc
);
707 case EMR_EXTSELECTCLIPRGN
:
709 PEMREXTSELECTCLIPRGN lpRgn
= (PEMREXTSELECTCLIPRGN
)mr
;
710 HRGN hRgn
= ExtCreateRegion(NULL
, lpRgn
->cbRgnData
, (RGNDATA
*)lpRgn
->RgnData
);
711 ExtSelectClipRgn(hdc
, hRgn
, (INT
)(lpRgn
->iMode
));
712 /* ExtSelectClipRgn created a copy of the region */
723 case EMR_SETWORLDTRANSFORM
:
725 PEMRSETWORLDTRANSFORM lpXfrm
= (PEMRSETWORLDTRANSFORM
)mr
;
726 SetWorldTransform( hdc
, &lpXfrm
->xform
);
732 PEMRPOLYBEZIER lpPolyBez
= (PEMRPOLYBEZIER
)mr
;
733 PolyBezier(hdc
, (const LPPOINT
)lpPolyBez
->aptl
, (UINT
)lpPolyBez
->cptl
);
739 PEMRPOLYGON lpPoly
= (PEMRPOLYGON
)mr
;
740 Polygon( hdc
, (const LPPOINT
)lpPoly
->aptl
, (UINT
)lpPoly
->cptl
);
746 PEMRPOLYLINE lpPolyLine
= (PEMRPOLYLINE
)mr
;
747 Polyline(hdc
, (const LPPOINT
)lpPolyLine
->aptl
, (UINT
)lpPolyLine
->cptl
);
751 case EMR_POLYBEZIERTO
:
753 PEMRPOLYBEZIERTO lpPolyBezierTo
= (PEMRPOLYBEZIERTO
)mr
;
754 PolyBezierTo( hdc
, (const LPPOINT
)lpPolyBezierTo
->aptl
,
755 (UINT
)lpPolyBezierTo
->cptl
);
761 PEMRPOLYLINETO lpPolyLineTo
= (PEMRPOLYLINETO
)mr
;
762 PolylineTo( hdc
, (const LPPOINT
)lpPolyLineTo
->aptl
,
763 (UINT
)lpPolyLineTo
->cptl
);
767 case EMR_POLYPOLYLINE
:
769 PEMRPOLYPOLYLINE pPolyPolyline
= (PEMRPOLYPOLYLINE
) mr
;
770 /* NB Points at pPolyPolyline->aPolyCounts + pPolyPolyline->nPolys */
772 PolyPolyline(hdc
, (LPPOINT
)(pPolyPolyline
->aPolyCounts
+
773 pPolyPolyline
->nPolys
),
774 pPolyPolyline
->aPolyCounts
,
775 pPolyPolyline
->nPolys
);
780 case EMR_POLYPOLYGON
:
782 PEMRPOLYPOLYGON pPolyPolygon
= (PEMRPOLYPOLYGON
) mr
;
784 /* NB Points at pPolyPolygon->aPolyCounts + pPolyPolygon->nPolys */
786 PolyPolygon(hdc
, (LPPOINT
)(pPolyPolygon
->aPolyCounts
+
787 pPolyPolygon
->nPolys
),
788 (INT
*)pPolyPolygon
->aPolyCounts
, pPolyPolygon
->nPolys
);
792 case EMR_SETBRUSHORGEX
:
794 PEMRSETBRUSHORGEX lpSetBrushOrgEx
= (PEMRSETBRUSHORGEX
)mr
;
797 (INT
)lpSetBrushOrgEx
->ptlOrigin
.x
,
798 (INT
)lpSetBrushOrgEx
->ptlOrigin
.y
,
806 PEMRSETPIXELV lpSetPixelV
= (PEMRSETPIXELV
)mr
;
809 (INT
)lpSetPixelV
->ptlPixel
.x
,
810 (INT
)lpSetPixelV
->ptlPixel
.y
,
811 lpSetPixelV
->crColor
);
816 case EMR_SETMAPPERFLAGS
:
818 PEMRSETMAPPERFLAGS lpSetMapperFlags
= (PEMRSETMAPPERFLAGS
)mr
;
820 SetMapperFlags( hdc
, lpSetMapperFlags
->dwFlags
);
825 case EMR_SETCOLORADJUSTMENT
:
827 PEMRSETCOLORADJUSTMENT lpSetColorAdjust
= (PEMRSETCOLORADJUSTMENT
)mr
;
829 SetColorAdjustment( hdc
, &lpSetColorAdjust
->ColorAdjustment
);
834 case EMR_OFFSETCLIPRGN
:
836 PEMROFFSETCLIPRGN lpOffsetClipRgn
= (PEMROFFSETCLIPRGN
)mr
;
839 (INT
)lpOffsetClipRgn
->ptlOffset
.x
,
840 (INT
)lpOffsetClipRgn
->ptlOffset
.y
);
845 case EMR_EXCLUDECLIPRECT
:
847 PEMREXCLUDECLIPRECT lpExcludeClipRect
= (PEMREXCLUDECLIPRECT
)mr
;
849 ExcludeClipRect( hdc
,
850 lpExcludeClipRect
->rclClip
.left
,
851 lpExcludeClipRect
->rclClip
.top
,
852 lpExcludeClipRect
->rclClip
.right
,
853 lpExcludeClipRect
->rclClip
.bottom
);
858 case EMR_SCALEVIEWPORTEXTEX
:
860 PEMRSCALEVIEWPORTEXTEX lpScaleViewportExtEx
= (PEMRSCALEVIEWPORTEXTEX
)mr
;
862 ScaleViewportExtEx( hdc
,
863 lpScaleViewportExtEx
->xNum
,
864 lpScaleViewportExtEx
->xDenom
,
865 lpScaleViewportExtEx
->yNum
,
866 lpScaleViewportExtEx
->yDenom
,
872 case EMR_SCALEWINDOWEXTEX
:
874 PEMRSCALEWINDOWEXTEX lpScaleWindowExtEx
= (PEMRSCALEWINDOWEXTEX
)mr
;
876 ScaleWindowExtEx( hdc
,
877 lpScaleWindowExtEx
->xNum
,
878 lpScaleWindowExtEx
->xDenom
,
879 lpScaleWindowExtEx
->yNum
,
880 lpScaleWindowExtEx
->yDenom
,
886 case EMR_MODIFYWORLDTRANSFORM
:
888 PEMRMODIFYWORLDTRANSFORM lpModifyWorldTrans
= (PEMRMODIFYWORLDTRANSFORM
)mr
;
890 ModifyWorldTransform( hdc
, &lpModifyWorldTrans
->xform
,
891 lpModifyWorldTrans
->iMode
);
898 PEMRANGLEARC lpAngleArc
= (PEMRANGLEARC
)mr
;
901 (INT
)lpAngleArc
->ptlCenter
.x
, (INT
)lpAngleArc
->ptlCenter
.y
,
902 lpAngleArc
->nRadius
, lpAngleArc
->eStartAngle
,
903 lpAngleArc
->eSweepAngle
);
910 PEMRROUNDRECT lpRoundRect
= (PEMRROUNDRECT
)mr
;
913 lpRoundRect
->rclBox
.left
,
914 lpRoundRect
->rclBox
.top
,
915 lpRoundRect
->rclBox
.right
,
916 lpRoundRect
->rclBox
.bottom
,
917 lpRoundRect
->szlCorner
.cx
,
918 lpRoundRect
->szlCorner
.cy
);
925 PEMRARC lpArc
= (PEMRARC
)mr
;
928 (INT
)lpArc
->rclBox
.left
,
929 (INT
)lpArc
->rclBox
.top
,
930 (INT
)lpArc
->rclBox
.right
,
931 (INT
)lpArc
->rclBox
.bottom
,
932 (INT
)lpArc
->ptlStart
.x
,
933 (INT
)lpArc
->ptlStart
.y
,
934 (INT
)lpArc
->ptlEnd
.x
,
935 (INT
)lpArc
->ptlEnd
.y
);
942 PEMRCHORD lpChord
= (PEMRCHORD
)mr
;
945 (INT
)lpChord
->rclBox
.left
,
946 (INT
)lpChord
->rclBox
.top
,
947 (INT
)lpChord
->rclBox
.right
,
948 (INT
)lpChord
->rclBox
.bottom
,
949 (INT
)lpChord
->ptlStart
.x
,
950 (INT
)lpChord
->ptlStart
.y
,
951 (INT
)lpChord
->ptlEnd
.x
,
952 (INT
)lpChord
->ptlEnd
.y
);
959 PEMRPIE lpPie
= (PEMRPIE
)mr
;
962 (INT
)lpPie
->rclBox
.left
,
963 (INT
)lpPie
->rclBox
.top
,
964 (INT
)lpPie
->rclBox
.right
,
965 (INT
)lpPie
->rclBox
.bottom
,
966 (INT
)lpPie
->ptlStart
.x
,
967 (INT
)lpPie
->ptlStart
.y
,
968 (INT
)lpPie
->ptlEnd
.x
,
969 (INT
)lpPie
->ptlEnd
.y
);
976 PEMRARC lpArcTo
= (PEMRARC
)mr
;
979 (INT
)lpArcTo
->rclBox
.left
,
980 (INT
)lpArcTo
->rclBox
.top
,
981 (INT
)lpArcTo
->rclBox
.right
,
982 (INT
)lpArcTo
->rclBox
.bottom
,
983 (INT
)lpArcTo
->ptlStart
.x
,
984 (INT
)lpArcTo
->ptlStart
.y
,
985 (INT
)lpArcTo
->ptlEnd
.x
,
986 (INT
)lpArcTo
->ptlEnd
.y
);
991 case EMR_EXTFLOODFILL
:
993 PEMREXTFLOODFILL lpExtFloodFill
= (PEMREXTFLOODFILL
)mr
;
996 (INT
)lpExtFloodFill
->ptlStart
.x
,
997 (INT
)lpExtFloodFill
->ptlStart
.y
,
998 lpExtFloodFill
->crColor
,
999 (UINT
)lpExtFloodFill
->iMode
);
1006 PEMRPOLYDRAW lpPolyDraw
= (PEMRPOLYDRAW
)mr
;
1008 (const LPPOINT
)lpPolyDraw
->aptl
,
1009 lpPolyDraw
->abTypes
,
1010 (INT
)lpPolyDraw
->cptl
);
1015 case EMR_SETARCDIRECTION
:
1017 PEMRSETARCDIRECTION lpSetArcDirection
= (PEMRSETARCDIRECTION
)mr
;
1018 SetArcDirection( hdc
, (INT
)lpSetArcDirection
->iArcDirection
);
1022 case EMR_SETMITERLIMIT
:
1024 PEMRSETMITERLIMIT lpSetMiterLimit
= (PEMRSETMITERLIMIT
)mr
;
1025 SetMiterLimit( hdc
, lpSetMiterLimit
->eMiterLimit
, NULL
);
1041 case EMR_CLOSEFIGURE
:
1049 /*PEMRFILLPATH lpFillPath = (PEMRFILLPATH)mr;*/
1054 case EMR_STROKEANDFILLPATH
:
1056 /*PEMRSTROKEANDFILLPATH lpStrokeAndFillPath = (PEMRSTROKEANDFILLPATH)mr;*/
1057 StrokeAndFillPath( hdc
);
1061 case EMR_STROKEPATH
:
1063 /*PEMRSTROKEPATH lpStrokePath = (PEMRSTROKEPATH)mr;*/
1068 case EMR_FLATTENPATH
:
1080 case EMR_SELECTCLIPPATH
:
1082 PEMRSELECTCLIPPATH lpSelectClipPath
= (PEMRSELECTCLIPPATH
)mr
;
1083 SelectClipPath( hdc
, (INT
)lpSelectClipPath
->iMode
);
1093 case EMR_CREATECOLORSPACE
:
1095 PEMRCREATECOLORSPACE lpCreateColorSpace
= (PEMRCREATECOLORSPACE
)mr
;
1096 (handletable
->objectHandle
)[lpCreateColorSpace
->ihCS
] =
1097 CreateColorSpaceA( &lpCreateColorSpace
->lcs
);
1101 case EMR_SETCOLORSPACE
:
1103 PEMRSETCOLORSPACE lpSetColorSpace
= (PEMRSETCOLORSPACE
)mr
;
1105 (handletable
->objectHandle
)[lpSetColorSpace
->ihCS
] );
1109 case EMR_DELETECOLORSPACE
:
1111 PEMRDELETECOLORSPACE lpDeleteColorSpace
= (PEMRDELETECOLORSPACE
)mr
;
1112 DeleteColorSpace( (handletable
->objectHandle
)[lpDeleteColorSpace
->ihCS
] );
1116 case EMR_SETICMMODE
:
1118 PERMSETICMMODE lpSetICMMode
= (PERMSETICMMODE
)mr
;
1119 SetICMMode( hdc
, (INT
)lpSetICMMode
->iMode
);
1123 case EMR_PIXELFORMAT
:
1126 PEMRPIXELFORMAT lpPixelFormat
= (PEMRPIXELFORMAT
)mr
;
1128 iPixelFormat
= ChoosePixelFormat( hdc
, &lpPixelFormat
->pfd
);
1129 SetPixelFormat( hdc
, iPixelFormat
, &lpPixelFormat
->pfd
);
1134 case EMR_SETPALETTEENTRIES
:
1136 PEMRSETPALETTEENTRIES lpSetPaletteEntries
= (PEMRSETPALETTEENTRIES
)mr
;
1138 SetPaletteEntries( (handletable
->objectHandle
)[lpSetPaletteEntries
->ihPal
],
1139 (UINT
)lpSetPaletteEntries
->iStart
,
1140 (UINT
)lpSetPaletteEntries
->cEntries
,
1141 lpSetPaletteEntries
->aPalEntries
);
1146 case EMR_RESIZEPALETTE
:
1148 PEMRRESIZEPALETTE lpResizePalette
= (PEMRRESIZEPALETTE
)mr
;
1150 ResizePalette( (handletable
->objectHandle
)[lpResizePalette
->ihPal
],
1151 (UINT
)lpResizePalette
->cEntries
);
1156 case EMR_CREATEDIBPATTERNBRUSHPT
:
1158 PEMRCREATEDIBPATTERNBRUSHPT lpCreate
= (PEMRCREATEDIBPATTERNBRUSHPT
)mr
;
1160 /* This is a BITMAPINFO struct followed directly by bitmap bits */
1161 LPVOID lpPackedStruct
= HeapAlloc( GetProcessHeap(),
1163 lpCreate
->cbBmi
+ lpCreate
->cbBits
);
1164 /* Now pack this structure */
1165 memcpy( lpPackedStruct
,
1166 ((BYTE
*)lpCreate
) + lpCreate
->offBmi
,
1168 memcpy( ((BYTE
*)lpPackedStruct
) + lpCreate
->cbBmi
,
1169 ((BYTE
*)lpCreate
) + lpCreate
->offBits
,
1172 (handletable
->objectHandle
)[lpCreate
->ihBrush
] =
1173 CreateDIBPatternBrushPt( lpPackedStruct
,
1174 (UINT
)lpCreate
->iUsage
);
1179 case EMR_CREATEMONOBRUSH
:
1181 PEMRCREATEMONOBRUSH pCreateMonoBrush
= (PEMRCREATEMONOBRUSH
)mr
;
1182 BITMAPINFO
*pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pCreateMonoBrush
->offBmi
);
1183 HBITMAP hBmp
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1184 (BYTE
*)mr
+ pCreateMonoBrush
->offBits
, pbi
, pCreateMonoBrush
->iUsage
);
1185 (handletable
->objectHandle
)[pCreateMonoBrush
->ihBrush
] = CreatePatternBrush(hBmp
);
1186 /* CreatePatternBrush created a copy of the bitmap */
1193 PEMRBITBLT pBitBlt
= (PEMRBITBLT
)mr
;
1194 HDC hdcSrc
= CreateCompatibleDC(hdc
);
1195 HBRUSH hBrush
, hBrushOld
;
1196 HBITMAP hBmp
, hBmpOld
;
1197 BITMAPINFO
*pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pBitBlt
->offBmiSrc
);
1199 SetWorldTransform(hdcSrc
, &pBitBlt
->xformSrc
);
1201 hBrush
= CreateSolidBrush(pBitBlt
->crBkColorSrc
);
1202 hBrushOld
= SelectObject(hdcSrc
, hBrush
);
1203 PatBlt(hdcSrc
, pBitBlt
->rclBounds
.left
, pBitBlt
->rclBounds
.top
,
1204 pBitBlt
->rclBounds
.right
- pBitBlt
->rclBounds
.left
,
1205 pBitBlt
->rclBounds
.bottom
- pBitBlt
->rclBounds
.top
, PATCOPY
);
1206 SelectObject(hdcSrc
, hBrushOld
);
1207 DeleteObject(hBrush
);
1209 hBmp
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1210 (BYTE
*)mr
+ pBitBlt
->offBitsSrc
, pbi
, pBitBlt
->iUsageSrc
);
1211 hBmpOld
= SelectObject(hdcSrc
, hBmp
);
1221 SelectObject(hdcSrc
, hBmpOld
);
1227 case EMR_STRETCHBLT
:
1229 PEMRSTRETCHBLT pStretchBlt
= (PEMRSTRETCHBLT
)mr
;
1230 HDC hdcSrc
= CreateCompatibleDC(hdc
);
1231 HBRUSH hBrush
, hBrushOld
;
1232 HBITMAP hBmp
, hBmpOld
;
1233 BITMAPINFO
*pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pStretchBlt
->offBmiSrc
);
1235 SetWorldTransform(hdcSrc
, &pStretchBlt
->xformSrc
);
1237 hBrush
= CreateSolidBrush(pStretchBlt
->crBkColorSrc
);
1238 hBrushOld
= SelectObject(hdcSrc
, hBrush
);
1239 PatBlt(hdcSrc
, pStretchBlt
->rclBounds
.left
, pStretchBlt
->rclBounds
.top
,
1240 pStretchBlt
->rclBounds
.right
- pStretchBlt
->rclBounds
.left
,
1241 pStretchBlt
->rclBounds
.bottom
- pStretchBlt
->rclBounds
.top
, PATCOPY
);
1242 SelectObject(hdcSrc
, hBrushOld
);
1243 DeleteObject(hBrush
);
1245 hBmp
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1246 (BYTE
*)mr
+ pStretchBlt
->offBitsSrc
, pbi
, pStretchBlt
->iUsageSrc
);
1247 hBmpOld
= SelectObject(hdcSrc
, hBmp
);
1251 pStretchBlt
->cxDest
,
1252 pStretchBlt
->cyDest
,
1258 pStretchBlt
->dwRop
);
1259 SelectObject(hdcSrc
, hBmpOld
);
1267 PEMRMASKBLT pMaskBlt
= (PEMRMASKBLT
)mr
;
1268 HDC hdcSrc
= CreateCompatibleDC(hdc
);
1269 HBRUSH hBrush
, hBrushOld
;
1270 HBITMAP hBmp
, hBmpOld
, hBmpMask
;
1273 SetWorldTransform(hdcSrc
, &pMaskBlt
->xformSrc
);
1275 hBrush
= CreateSolidBrush(pMaskBlt
->crBkColorSrc
);
1276 hBrushOld
= SelectObject(hdcSrc
, hBrush
);
1277 PatBlt(hdcSrc
, pMaskBlt
->rclBounds
.left
, pMaskBlt
->rclBounds
.top
,
1278 pMaskBlt
->rclBounds
.right
- pMaskBlt
->rclBounds
.left
,
1279 pMaskBlt
->rclBounds
.bottom
- pMaskBlt
->rclBounds
.top
, PATCOPY
);
1280 SelectObject(hdcSrc
, hBrushOld
);
1281 DeleteObject(hBrush
);
1283 pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pMaskBlt
->offBmiMask
);
1284 hBmpMask
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1285 (BYTE
*)mr
+ pMaskBlt
->offBitsMask
, pbi
, pMaskBlt
->iUsageMask
);
1287 pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pMaskBlt
->offBmiSrc
);
1288 hBmp
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1289 (BYTE
*)mr
+ pMaskBlt
->offBitsSrc
, pbi
, pMaskBlt
->iUsageSrc
);
1290 hBmpOld
= SelectObject(hdcSrc
, hBmp
);
1303 SelectObject(hdcSrc
, hBmpOld
);
1305 DeleteObject(hBmpMask
);
1312 PEMRPLGBLT pPlgBlt
= (PEMRPLGBLT
)mr
;
1313 HDC hdcSrc
= CreateCompatibleDC(hdc
);
1314 HBRUSH hBrush
, hBrushOld
;
1315 HBITMAP hBmp
, hBmpOld
, hBmpMask
;
1319 SetWorldTransform(hdcSrc
, &pPlgBlt
->xformSrc
);
1321 pts
[0].x
= pPlgBlt
->aptlDst
[0].x
; pts
[0].y
= pPlgBlt
->aptlDst
[0].y
;
1322 pts
[1].x
= pPlgBlt
->aptlDst
[1].x
; pts
[1].y
= pPlgBlt
->aptlDst
[1].y
;
1323 pts
[2].x
= pPlgBlt
->aptlDst
[2].x
; pts
[2].y
= pPlgBlt
->aptlDst
[2].y
;
1325 hBrush
= CreateSolidBrush(pPlgBlt
->crBkColorSrc
);
1326 hBrushOld
= SelectObject(hdcSrc
, hBrush
);
1327 PatBlt(hdcSrc
, pPlgBlt
->rclBounds
.left
, pPlgBlt
->rclBounds
.top
,
1328 pPlgBlt
->rclBounds
.right
- pPlgBlt
->rclBounds
.left
,
1329 pPlgBlt
->rclBounds
.bottom
- pPlgBlt
->rclBounds
.top
, PATCOPY
);
1330 SelectObject(hdcSrc
, hBrushOld
);
1331 DeleteObject(hBrush
);
1333 pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pPlgBlt
->offBmiMask
);
1334 hBmpMask
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1335 (BYTE
*)mr
+ pPlgBlt
->offBitsMask
, pbi
, pPlgBlt
->iUsageMask
);
1337 pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pPlgBlt
->offBmiSrc
);
1338 hBmp
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1339 (BYTE
*)mr
+ pPlgBlt
->offBitsSrc
, pbi
, pPlgBlt
->iUsageSrc
);
1340 hBmpOld
= SelectObject(hdcSrc
, hBmp
);
1351 SelectObject(hdcSrc
, hBmpOld
);
1353 DeleteObject(hBmpMask
);
1358 case EMR_SETDIBITSTODEVICE
:
1360 PEMRSETDIBITSTODEVICE pSetDIBitsToDevice
= (PEMRSETDIBITSTODEVICE
)mr
;
1362 SetDIBitsToDevice(hdc
,
1363 pSetDIBitsToDevice
->xDest
,
1364 pSetDIBitsToDevice
->yDest
,
1365 pSetDIBitsToDevice
->cxSrc
,
1366 pSetDIBitsToDevice
->cySrc
,
1367 pSetDIBitsToDevice
->xSrc
,
1368 pSetDIBitsToDevice
->ySrc
,
1369 pSetDIBitsToDevice
->iStartScan
,
1370 pSetDIBitsToDevice
->cScans
,
1371 (BYTE
*)mr
+ pSetDIBitsToDevice
->offBitsSrc
,
1372 (BITMAPINFO
*)((BYTE
*)mr
+ pSetDIBitsToDevice
->offBmiSrc
),
1373 pSetDIBitsToDevice
->iUsageSrc
);
1377 case EMR_POLYTEXTOUTA
:
1379 PEMRPOLYTEXTOUTA pPolyTextOutA
= (PEMRPOLYTEXTOUTA
)mr
;
1380 POLYTEXTA
*polytextA
= HeapAlloc(GetProcessHeap(), 0, pPolyTextOutA
->cStrings
* sizeof(POLYTEXTA
));
1382 XFORM xform
, xformOld
;
1385 gModeOld
= SetGraphicsMode(hdc
, pPolyTextOutA
->iGraphicsMode
);
1386 GetWorldTransform(hdc
, &xformOld
);
1388 xform
.eM11
= pPolyTextOutA
->exScale
;
1391 xform
.eM22
= pPolyTextOutA
->eyScale
;
1394 SetWorldTransform(hdc
, &xform
);
1396 /* Set up POLYTEXTA structures */
1397 for(i
= 0; i
< pPolyTextOutA
->cStrings
; i
++)
1399 polytextA
[i
].x
= pPolyTextOutA
->aemrtext
[i
].ptlReference
.x
;
1400 polytextA
[i
].y
= pPolyTextOutA
->aemrtext
[i
].ptlReference
.y
;
1401 polytextA
[i
].n
= pPolyTextOutA
->aemrtext
[i
].nChars
;
1402 polytextA
[i
].lpstr
= (LPSTR
)((BYTE
*)mr
+ pPolyTextOutA
->aemrtext
[i
].offString
);
1403 polytextA
[i
].uiFlags
= pPolyTextOutA
->aemrtext
[i
].fOptions
;
1404 polytextA
[i
].rcl
.left
= pPolyTextOutA
->aemrtext
[i
].rcl
.left
;
1405 polytextA
[i
].rcl
.right
= pPolyTextOutA
->aemrtext
[i
].rcl
.right
;
1406 polytextA
[i
].rcl
.top
= pPolyTextOutA
->aemrtext
[i
].rcl
.top
;
1407 polytextA
[i
].rcl
.bottom
= pPolyTextOutA
->aemrtext
[i
].rcl
.bottom
;
1408 polytextA
[i
].pdx
= (int *)((BYTE
*)mr
+ pPolyTextOutA
->aemrtext
[i
].offDx
);
1410 PolyTextOutA(hdc
, polytextA
, pPolyTextOutA
->cStrings
);
1411 HeapFree(GetProcessHeap(), 0, polytextA
);
1413 SetWorldTransform(hdc
, &xformOld
);
1414 SetGraphicsMode(hdc
, gModeOld
);
1418 case EMR_POLYTEXTOUTW
:
1420 PEMRPOLYTEXTOUTW pPolyTextOutW
= (PEMRPOLYTEXTOUTW
)mr
;
1421 POLYTEXTW
*polytextW
= HeapAlloc(GetProcessHeap(), 0, pPolyTextOutW
->cStrings
* sizeof(POLYTEXTW
));
1423 XFORM xform
, xformOld
;
1426 gModeOld
= SetGraphicsMode(hdc
, pPolyTextOutW
->iGraphicsMode
);
1427 GetWorldTransform(hdc
, &xformOld
);
1429 xform
.eM11
= pPolyTextOutW
->exScale
;
1432 xform
.eM22
= pPolyTextOutW
->eyScale
;
1435 SetWorldTransform(hdc
, &xform
);
1437 /* Set up POLYTEXTW structures */
1438 for(i
= 0; i
< pPolyTextOutW
->cStrings
; i
++)
1440 polytextW
[i
].x
= pPolyTextOutW
->aemrtext
[i
].ptlReference
.x
;
1441 polytextW
[i
].y
= pPolyTextOutW
->aemrtext
[i
].ptlReference
.y
;
1442 polytextW
[i
].n
= pPolyTextOutW
->aemrtext
[i
].nChars
;
1443 polytextW
[i
].lpstr
= (LPWSTR
)((BYTE
*)mr
+ pPolyTextOutW
->aemrtext
[i
].offString
);
1444 polytextW
[i
].uiFlags
= pPolyTextOutW
->aemrtext
[i
].fOptions
;
1445 polytextW
[i
].rcl
.left
= pPolyTextOutW
->aemrtext
[i
].rcl
.left
;
1446 polytextW
[i
].rcl
.right
= pPolyTextOutW
->aemrtext
[i
].rcl
.right
;
1447 polytextW
[i
].rcl
.top
= pPolyTextOutW
->aemrtext
[i
].rcl
.top
;
1448 polytextW
[i
].rcl
.bottom
= pPolyTextOutW
->aemrtext
[i
].rcl
.bottom
;
1449 polytextW
[i
].pdx
= (int *)((BYTE
*)mr
+ pPolyTextOutW
->aemrtext
[i
].offDx
);
1451 PolyTextOutW(hdc
, polytextW
, pPolyTextOutW
->cStrings
);
1452 HeapFree(GetProcessHeap(), 0, polytextW
);
1454 SetWorldTransform(hdc
, &xformOld
);
1455 SetGraphicsMode(hdc
, gModeOld
);
1461 PEMRFILLRGN pFillRgn
= (PEMRFILLRGN
)mr
;
1462 HRGN hRgn
= ExtCreateRegion(NULL
, pFillRgn
->cbRgnData
, (RGNDATA
*)pFillRgn
->RgnData
);
1465 (handletable
->objectHandle
)[pFillRgn
->ihBrush
]);
1472 PEMRFRAMERGN pFrameRgn
= (PEMRFRAMERGN
)mr
;
1473 HRGN hRgn
= ExtCreateRegion(NULL
, pFrameRgn
->cbRgnData
, (RGNDATA
*)pFrameRgn
->RgnData
);
1476 (handletable
->objectHandle
)[pFrameRgn
->ihBrush
],
1477 pFrameRgn
->szlStroke
.cx
,
1478 pFrameRgn
->szlStroke
.cy
);
1485 PEMRINVERTRGN pInvertRgn
= (PEMRINVERTRGN
)mr
;
1486 HRGN hRgn
= ExtCreateRegion(NULL
, pInvertRgn
->cbRgnData
, (RGNDATA
*)pInvertRgn
->RgnData
);
1487 InvertRgn(hdc
, hRgn
);
1494 PEMRPAINTRGN pPaintRgn
= (PEMRPAINTRGN
)mr
;
1495 HRGN hRgn
= ExtCreateRegion(NULL
, pPaintRgn
->cbRgnData
, (RGNDATA
*)pPaintRgn
->RgnData
);
1496 PaintRgn(hdc
, hRgn
);
1501 case EMR_POLYDRAW16
:
1503 case EMR_GLSBOUNDEDRECORD
:
1505 /* From docs: If PlayEnhMetaFileRecord doesn't recognize a
1506 record then ignore and return TRUE. */
1507 FIXME("type %d is unimplemented\n", type
);
1514 /*****************************************************************************
1516 * EnumEnhMetaFile (GDI32.@)
1518 * Walk an enhanced metafile, calling a user-specified function _EnhMetaFunc_
1520 * record. Returns when either every record has been used or
1521 * when _EnhMetaFunc_ returns FALSE.
1525 * TRUE if every record is used, FALSE if any invocation of _EnhMetaFunc_
1531 BOOL WINAPI
EnumEnhMetaFile(
1532 HDC hdc
, /* [in] device context to pass to _EnhMetaFunc_ */
1533 HENHMETAFILE hmf
, /* [in] EMF to walk */
1534 ENHMFENUMPROC callback
, /* [in] callback function */
1535 LPVOID data
, /* [in] optional data for callback function */
1536 const RECT
*lpRect
/* [in] bounding rectangle for rendered metafile */
1540 ENHMETAHEADER
*emh
, *emhTemp
;
1546 FLOAT xSrcPixSize
, ySrcPixSize
, xscale
, yscale
;
1547 XFORM savedXform
, xform
;
1548 HPEN hPen
= (HPEN
)NULL
;
1549 HBRUSH hBrush
= (HBRUSH
)NULL
;
1550 HFONT hFont
= (HFONT
)NULL
;
1554 SetLastError(ERROR_INVALID_PARAMETER
);
1558 emh
= EMF_GetEnhMetaHeader(hmf
);
1560 SetLastError(ERROR_INVALID_HANDLE
);
1564 /* Copy the metafile into memory, because we need to avoid deadlock. */
1565 emhTemp
= HeapAlloc(GetProcessHeap(), 0, emh
->nSize
+ emh
->nBytes
);
1568 EMF_ReleaseEnhMetaHeader(hmf
);
1569 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1572 memcpy(emhTemp
, emh
, emh
->nSize
+ emh
->nBytes
);
1574 EMF_ReleaseEnhMetaHeader(hmf
);
1576 ht
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
1577 sizeof(HANDLETABLE
) * emh
->nHandles
);
1580 HeapFree(GetProcessHeap(), 0, emhTemp
);
1581 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1584 ht
->objectHandle
[0] = hmf
;
1588 TRACE("rect: %d,%d - %d,%d. rclFrame: %ld,%ld - %ld,%ld\n",
1589 lpRect
->left
, lpRect
->top
, lpRect
->right
, lpRect
->bottom
,
1590 emh
->rclFrame
.left
, emh
->rclFrame
.top
, emh
->rclFrame
.right
,
1591 emh
->rclFrame
.bottom
);
1593 xSrcPixSize
= (FLOAT
) emh
->szlMillimeters
.cx
/ emh
->szlDevice
.cx
;
1594 ySrcPixSize
= (FLOAT
) emh
->szlMillimeters
.cy
/ emh
->szlDevice
.cy
;
1595 xscale
= (FLOAT
)(lpRect
->right
- lpRect
->left
) * 100.0 /
1596 (emh
->rclFrame
.right
- emh
->rclFrame
.left
) * xSrcPixSize
;
1597 yscale
= (FLOAT
)(lpRect
->bottom
- lpRect
->top
) * 100.0 /
1598 (emh
->rclFrame
.bottom
- emh
->rclFrame
.top
) * ySrcPixSize
;
1600 xform
.eM11
= xscale
;
1603 xform
.eM22
= yscale
;
1604 xform
.eDx
= (FLOAT
) lpRect
->left
- (lpRect
->right
- lpRect
->left
) *
1605 emh
->rclFrame
.left
/ (emh
->rclFrame
.right
- emh
->rclFrame
.left
);
1606 xform
.eDy
= (FLOAT
) lpRect
->top
- (lpRect
->bottom
- lpRect
->top
) *
1607 emh
->rclFrame
.top
/ (emh
->rclFrame
.bottom
- emh
->rclFrame
.top
);
1609 savedMode
= SetGraphicsMode(hdc
, GM_ADVANCED
);
1610 GetWorldTransform(hdc
, &savedXform
);
1612 if (!ModifyWorldTransform(hdc
, &xform
, MWT_RIGHTMULTIPLY
)) {
1613 ERR("World transform failed!\n");
1616 /* save the current pen, brush and font */
1617 hPen
= GetCurrentObject(hdc
, OBJ_PEN
);
1618 hBrush
= GetCurrentObject(hdc
, OBJ_BRUSH
);
1619 hFont
= GetCurrentObject(hdc
, OBJ_FONT
);
1622 TRACE("nSize = %ld, nBytes = %ld, nHandles = %d, nRecords = %ld, nPalEntries = %ld\n",
1623 emh
->nSize
, emh
->nBytes
, emh
->nHandles
, emh
->nRecords
, emh
->nPalEntries
);
1627 while(ret
&& offset
< emh
->nBytes
)
1629 emr
= (ENHMETARECORD
*)((char *)emh
+ offset
);
1630 TRACE("Calling EnumFunc with record type %ld, size %ld\n", emr
->iType
, emr
->nSize
);
1631 ret
= (*callback
)(hdc
, ht
, emr
, emh
->nHandles
, data
);
1632 offset
+= emr
->nSize
;
1637 /* restore pen, brush and font */
1638 SelectObject(hdc
, hBrush
);
1639 SelectObject(hdc
, hPen
);
1640 SelectObject(hdc
, hFont
);
1642 SetWorldTransform(hdc
, &savedXform
);
1644 SetGraphicsMode(hdc
, savedMode
);
1647 for(i
= 1; i
< emh
->nHandles
; i
++) /* Don't delete element 0 (hmf) */
1648 if( (ht
->objectHandle
)[i
] )
1649 DeleteObject( (ht
->objectHandle
)[i
] );
1651 HeapFree( GetProcessHeap(), 0, ht
);
1652 HeapFree(GetProcessHeap(), 0, emhTemp
);
1657 static INT CALLBACK
EMF_PlayEnhMetaFileCallback(HDC hdc
, HANDLETABLE
*ht
,
1659 INT handles
, LPVOID data
)
1661 return PlayEnhMetaFileRecord(hdc
, ht
, emr
, handles
);
1664 /**************************************************************************
1665 * PlayEnhMetaFile (GDI32.@)
1667 * Renders an enhanced metafile into a specified rectangle *lpRect
1668 * in device context hdc.
1671 BOOL WINAPI
PlayEnhMetaFile(
1672 HDC hdc
, /* [in] DC to render into */
1673 HENHMETAFILE hmf
, /* [in] metafile to render */
1674 const RECT
*lpRect
/* [in] rectangle to place metafile inside */
1677 return EnumEnhMetaFile(hdc
, hmf
, EMF_PlayEnhMetaFileCallback
, NULL
,
1681 /*****************************************************************************
1682 * DeleteEnhMetaFile (GDI32.@)
1684 * Deletes an enhanced metafile and frees the associated storage.
1686 BOOL WINAPI
DeleteEnhMetaFile(HENHMETAFILE hmf
)
1688 return EMF_Delete_HENHMETAFILE( hmf
);
1691 /*****************************************************************************
1692 * CopyEnhMetaFileA (GDI32.@) Duplicate an enhanced metafile
1696 HENHMETAFILE WINAPI
CopyEnhMetaFileA(
1697 HENHMETAFILE hmfSrc
,
1700 ENHMETAHEADER
*emrSrc
= EMF_GetEnhMetaHeader( hmfSrc
), *emrDst
;
1701 HENHMETAFILE hmfDst
;
1703 if(!emrSrc
) return FALSE
;
1705 emrDst
= HeapAlloc( GetProcessHeap(), 0, emrSrc
->nBytes
);
1706 memcpy( emrDst
, emrSrc
, emrSrc
->nBytes
);
1707 hmfDst
= EMF_Create_HENHMETAFILE( emrDst
, FALSE
);
1710 hFile
= CreateFileA( file
, GENERIC_WRITE
| GENERIC_READ
, 0, NULL
,
1711 CREATE_ALWAYS
, 0, 0);
1712 WriteFile( hFile
, emrSrc
, emrSrc
->nBytes
, 0, 0);
1713 hmfDst
= EMF_GetEnhMetaFile( hFile
);
1714 CloseHandle( hFile
);
1716 EMF_ReleaseEnhMetaHeader( hmfSrc
);
1721 /* Struct to be used to be passed in the LPVOID parameter for cbEnhPaletteCopy */
1722 typedef struct tagEMF_PaletteCopy
1725 LPPALETTEENTRY lpPe
;
1728 /***************************************************************
1729 * Find the EMR_EOF record and then use it to find the
1730 * palette entries for this enhanced metafile.
1731 * The lpData is actually a pointer to a EMF_PaletteCopy struct
1732 * which contains the max number of elements to copy and where
1735 * NOTE: To be used by GetEnhMetaFilePaletteEntries only!
1737 INT CALLBACK
cbEnhPaletteCopy( HDC a
,
1739 LPENHMETARECORD lpEMR
,
1744 if ( lpEMR
->iType
== EMR_EOF
)
1746 PEMREOF lpEof
= (PEMREOF
)lpEMR
;
1747 EMF_PaletteCopy
* info
= (EMF_PaletteCopy
*)lpData
;
1748 DWORD dwNumPalToCopy
= min( lpEof
->nPalEntries
, info
->cEntries
);
1750 TRACE( "copying 0x%08lx palettes\n", dwNumPalToCopy
);
1752 memcpy( (LPVOID
)info
->lpPe
,
1753 (LPVOID
)(((LPSTR
)lpEof
) + lpEof
->offPalEntries
),
1754 sizeof( *(info
->lpPe
) ) * dwNumPalToCopy
);
1756 /* Update the passed data as a return code */
1757 info
->lpPe
= NULL
; /* Palettes were copied! */
1758 info
->cEntries
= (UINT
)dwNumPalToCopy
;
1760 return FALSE
; /* That's all we need */
1766 /*****************************************************************************
1767 * GetEnhMetaFilePaletteEntries (GDI32.@)
1769 * Copy the palette and report size
1771 * BUGS: Error codes (SetLastError) are not set on failures
1773 UINT WINAPI
GetEnhMetaFilePaletteEntries( HENHMETAFILE hEmf
,
1775 LPPALETTEENTRY lpPe
)
1777 ENHMETAHEADER
* enhHeader
= EMF_GetEnhMetaHeader( hEmf
);
1778 UINT uReturnValue
= GDI_ERROR
;
1779 EMF_PaletteCopy infoForCallBack
;
1781 TRACE( "(%04x,%d,%p)\n", hEmf
, cEntries
, lpPe
);
1783 /* First check if there are any palettes associated with
1785 if ( enhHeader
->nPalEntries
== 0 )
1787 /* No palette associated with this enhanced metafile */
1792 /* Is the user requesting the number of palettes? */
1795 uReturnValue
= (UINT
)enhHeader
->nPalEntries
;
1799 /* Copy cEntries worth of PALETTEENTRY structs into the buffer */
1800 infoForCallBack
.cEntries
= cEntries
;
1801 infoForCallBack
.lpPe
= lpPe
;
1803 if ( !EnumEnhMetaFile( 0, hEmf
, cbEnhPaletteCopy
,
1804 &infoForCallBack
, NULL
) )
1809 /* Verify that the callback executed correctly */
1810 if ( infoForCallBack
.lpPe
!= NULL
)
1812 /* Callback proc had error! */
1813 ERR( "cbEnhPaletteCopy didn't execute correctly\n" );
1817 uReturnValue
= infoForCallBack
.cEntries
;
1821 EMF_ReleaseEnhMetaHeader( hEmf
);
1823 return uReturnValue
;
1826 /******************************************************************
1827 * SetWinMetaFileBits (GDI32.@)
1829 * Translate from old style to new style.
1831 * BUGS: - This doesn't take the DC and scaling into account
1832 * - Most record conversions aren't implemented
1833 * - Handle slot assignement is primative and most likely doesn't work
1835 HENHMETAFILE WINAPI
SetWinMetaFileBits(UINT cbBuffer
,
1836 CONST BYTE
*lpbBuffer
,
1838 CONST METAFILEPICT
*lpmfp
1842 LPVOID lpNewEnhMetaFileBuffer
= NULL
;
1843 UINT uNewEnhMetaFileBufferSize
= 0;
1844 BOOL bFoundEOF
= FALSE
;
1846 FIXME( "(%d,%p,%04x,%p):stub\n", cbBuffer
, lpbBuffer
, hdcRef
, lpmfp
);
1848 /* 1. Get the header - skip over this and get straight to the records */
1850 uNewEnhMetaFileBufferSize
= sizeof( ENHMETAHEADER
);
1851 lpNewEnhMetaFileBuffer
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
1852 uNewEnhMetaFileBufferSize
);
1854 if( lpNewEnhMetaFileBuffer
== NULL
)
1859 /* Fill in the header record */
1861 LPENHMETAHEADER lpNewEnhMetaFileHeader
= (LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
;
1863 lpNewEnhMetaFileHeader
->iType
= EMR_HEADER
;
1864 lpNewEnhMetaFileHeader
->nSize
= sizeof( ENHMETAHEADER
);
1866 /* FIXME: Not right. Must be able to get this from the DC */
1867 lpNewEnhMetaFileHeader
->rclBounds
.left
= 0;
1868 lpNewEnhMetaFileHeader
->rclBounds
.right
= 0;
1869 lpNewEnhMetaFileHeader
->rclBounds
.top
= 0;
1870 lpNewEnhMetaFileHeader
->rclBounds
.bottom
= 0;
1872 /* FIXME: Not right. Must be able to get this from the DC */
1873 lpNewEnhMetaFileHeader
->rclFrame
.left
= 0;
1874 lpNewEnhMetaFileHeader
->rclFrame
.right
= 0;
1875 lpNewEnhMetaFileHeader
->rclFrame
.top
= 0;
1876 lpNewEnhMetaFileHeader
->rclFrame
.bottom
= 0;
1878 lpNewEnhMetaFileHeader
->nHandles
= 0; /* No handles yet */
1880 /* FIXME: Add in the rest of the fields to the header */
1895 (char*)lpbBuffer
+= ((METAHEADER
*)lpbBuffer
)->mtHeaderSize
* 2; /* Point past the header - FIXME: metafile quirk? */
1897 /* 2. Enum over individual records and convert them to the new type of records */
1901 LPMETARECORD lpMetaRecord
= (LPMETARECORD
)lpbBuffer
;
1903 #define EMF_ReAllocAndAdjustPointers( a , b ) \
1906 lpTmp = HeapReAlloc( GetProcessHeap(), 0, \
1907 lpNewEnhMetaFileBuffer, \
1908 uNewEnhMetaFileBufferSize + (b) ); \
1909 if( lpTmp == NULL ) { ERR( "No memory!\n" ); goto error; } \
1910 lpNewEnhMetaFileBuffer = lpTmp; \
1911 lpRecord = (a)( (char*)lpNewEnhMetaFileBuffer + uNewEnhMetaFileBufferSize ); \
1912 uNewEnhMetaFileBufferSize += (b); \
1915 switch( lpMetaRecord
->rdFunction
)
1920 size_t uRecord
= sizeof(*lpRecord
);
1922 EMF_ReAllocAndAdjustPointers(PEMREOF
,uRecord
);
1924 /* Fill the new record - FIXME: This is not right */
1925 lpRecord
->emr
.iType
= EMR_EOF
;
1926 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1927 lpRecord
->nPalEntries
= 0; /* FIXME */
1928 lpRecord
->offPalEntries
= 0; /* FIXME */
1929 lpRecord
->nSizeLast
= 0; /* FIXME */
1931 /* No more records after this one */
1934 FIXME( "META_EOF conversion not correct\n" );
1938 case META_SETMAPMODE
:
1940 PEMRSETMAPMODE lpRecord
;
1941 size_t uRecord
= sizeof(*lpRecord
);
1943 EMF_ReAllocAndAdjustPointers(PEMRSETMAPMODE
,uRecord
);
1945 lpRecord
->emr
.iType
= EMR_SETMAPMODE
;
1946 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1948 lpRecord
->iMode
= lpMetaRecord
->rdParm
[0];
1953 case META_DELETEOBJECT
: /* Select and Delete structures are the same */
1954 case META_SELECTOBJECT
:
1956 PEMRDELETEOBJECT lpRecord
;
1957 size_t uRecord
= sizeof(*lpRecord
);
1959 EMF_ReAllocAndAdjustPointers(PEMRDELETEOBJECT
,uRecord
);
1961 if( lpMetaRecord
->rdFunction
== META_DELETEOBJECT
)
1963 lpRecord
->emr
.iType
= EMR_DELETEOBJECT
;
1967 lpRecord
->emr
.iType
= EMR_SELECTOBJECT
;
1969 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1971 lpRecord
->ihObject
= lpMetaRecord
->rdParm
[0]; /* FIXME: Handle */
1976 case META_POLYGON
: /* This is just plain busted. I don't know what I'm doing */
1978 PEMRPOLYGON16 lpRecord
; /* FIXME: Should it be a poly or poly16? */
1979 size_t uRecord
= sizeof(*lpRecord
);
1981 EMF_ReAllocAndAdjustPointers(PEMRPOLYGON16
,uRecord
);
1983 /* FIXME: This is mostly all wrong */
1984 lpRecord
->emr
.iType
= EMR_POLYGON16
;
1985 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1987 lpRecord
->rclBounds
.left
= 0;
1988 lpRecord
->rclBounds
.right
= 0;
1989 lpRecord
->rclBounds
.top
= 0;
1990 lpRecord
->rclBounds
.bottom
= 0;
1993 lpRecord
->apts
[0].x
= 0;
1994 lpRecord
->apts
[0].y
= 0;
1996 FIXME( "META_POLYGON conversion not correct\n" );
2001 case META_SETPOLYFILLMODE
:
2003 PEMRSETPOLYFILLMODE lpRecord
;
2004 size_t uRecord
= sizeof(*lpRecord
);
2006 EMF_ReAllocAndAdjustPointers(PEMRSETPOLYFILLMODE
,uRecord
);
2008 lpRecord
->emr
.iType
= EMR_SETPOLYFILLMODE
;
2009 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
2011 lpRecord
->iMode
= lpMetaRecord
->rdParm
[0];
2016 case META_SETWINDOWORG
:
2018 PEMRSETWINDOWORGEX lpRecord
; /* Seems to be the closest thing */
2019 size_t uRecord
= sizeof(*lpRecord
);
2021 EMF_ReAllocAndAdjustPointers(PEMRSETWINDOWORGEX
,uRecord
);
2023 lpRecord
->emr
.iType
= EMR_SETWINDOWORGEX
;
2024 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
2026 lpRecord
->ptlOrigin
.x
= lpMetaRecord
->rdParm
[1];
2027 lpRecord
->ptlOrigin
.y
= lpMetaRecord
->rdParm
[0];
2032 case META_SETWINDOWEXT
: /* Structure is the same for SETWINDOWEXT & SETVIEWPORTEXT */
2033 case META_SETVIEWPORTEXT
:
2035 PEMRSETWINDOWEXTEX lpRecord
;
2036 size_t uRecord
= sizeof(*lpRecord
);
2038 EMF_ReAllocAndAdjustPointers(PEMRSETWINDOWEXTEX
,uRecord
);
2040 if ( lpMetaRecord
->rdFunction
== META_SETWINDOWEXT
)
2042 lpRecord
->emr
.iType
= EMR_SETWINDOWORGEX
;
2046 lpRecord
->emr
.iType
= EMR_SETVIEWPORTEXTEX
;
2048 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
2050 lpRecord
->szlExtent
.cx
= lpMetaRecord
->rdParm
[1];
2051 lpRecord
->szlExtent
.cy
= lpMetaRecord
->rdParm
[0];
2056 case META_CREATEBRUSHINDIRECT
:
2058 PEMRCREATEBRUSHINDIRECT lpRecord
;
2059 size_t uRecord
= sizeof(*lpRecord
);
2061 EMF_ReAllocAndAdjustPointers(PEMRCREATEBRUSHINDIRECT
,uRecord
);
2063 lpRecord
->emr
.iType
= EMR_CREATEBRUSHINDIRECT
;
2064 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
2066 lpRecord
->ihBrush
= ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nHandles
;
2067 lpRecord
->lb
.lbStyle
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbStyle
;
2068 lpRecord
->lb
.lbColor
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbColor
;
2069 lpRecord
->lb
.lbHatch
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbHatch
;
2071 ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nHandles
+= 1; /* New handle */
2077 /* These are all unimplemented and as such are intended to fall through to the default case */
2078 case META_SETBKCOLOR
:
2079 case META_SETBKMODE
:
2081 case META_SETRELABS
:
2082 case META_SETSTRETCHBLTMODE
:
2083 case META_SETTEXTCOLOR
:
2084 case META_SETVIEWPORTORG
:
2085 case META_OFFSETWINDOWORG
:
2086 case META_SCALEWINDOWEXT
:
2087 case META_OFFSETVIEWPORTORG
:
2088 case META_SCALEVIEWPORTEXT
:
2091 case META_EXCLUDECLIPRECT
:
2092 case META_INTERSECTCLIPRECT
:
2095 case META_FLOODFILL
:
2097 case META_RECTANGLE
:
2098 case META_ROUNDRECT
:
2102 case META_OFFSETCLIPRGN
:
2104 case META_POLYPOLYGON
:
2106 case META_RESTOREDC
:
2108 case META_CREATEPATTERNBRUSH
:
2109 case META_CREATEPENINDIRECT
:
2110 case META_CREATEFONTINDIRECT
:
2111 case META_CREATEPALETTE
:
2112 case META_SETTEXTALIGN
:
2113 case META_SELECTPALETTE
:
2114 case META_SETMAPPERFLAGS
:
2115 case META_REALIZEPALETTE
:
2117 case META_EXTTEXTOUT
:
2118 case META_STRETCHDIB
:
2119 case META_DIBSTRETCHBLT
:
2120 case META_STRETCHBLT
:
2122 case META_CREATEREGION
:
2123 case META_FILLREGION
:
2124 case META_FRAMEREGION
:
2125 case META_INVERTREGION
:
2126 case META_PAINTREGION
:
2127 case META_SELECTCLIPREGION
:
2128 case META_DIBCREATEPATTERNBRUSH
:
2129 case META_DIBBITBLT
:
2130 case META_SETTEXTCHAREXTRA
:
2131 case META_SETTEXTJUSTIFICATION
:
2132 case META_EXTFLOODFILL
:
2133 case META_SETDIBTODEV
:
2135 case META_ANIMATEPALETTE
:
2136 case META_SETPALENTRIES
:
2137 case META_RESIZEPALETTE
:
2140 case META_STARTPAGE
:
2144 case META_CREATEBRUSH
:
2145 case META_CREATEBITMAPINDIRECT
:
2146 case META_CREATEBITMAP
:
2147 /* Fall through to unimplemented */
2150 /* Not implemented yet */
2151 FIXME( "Conversion of record type 0x%x not implemented.\n", lpMetaRecord
->rdFunction
);
2156 /* Move to the next record */
2157 (char*)lpbBuffer
+= ((LPMETARECORD
)lpbBuffer
)->rdSize
* 2; /* FIXME: Seem to be doing this in metafile.c */
2159 #undef ReAllocAndAdjustPointers
2162 /* We know the last of the header information now */
2163 ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nBytes
= uNewEnhMetaFileBufferSize
;
2165 /* Create the enhanced metafile */
2166 hMf
= SetEnhMetaFileBits( uNewEnhMetaFileBufferSize
, (const BYTE
*)lpNewEnhMetaFileBuffer
);
2169 ERR( "Problem creating metafile. Did the conversion fail somewhere?\n" );
2174 /* Free the data associated with our copy since it's been copied */
2175 HeapFree( GetProcessHeap(), 0, lpNewEnhMetaFileBuffer
);