2 * Enhanced metafile functions
3 * Copyright 1998 Douglas Ridgway
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 * The enhanced format consists of the following elements:
25 * A table of handles to GDI objects
26 * An array of metafile records
30 * The standard format consists of a header and an array of metafile records.
35 #include "wine/port.h"
44 #include "wine/debug.h"
46 WINE_DEFAULT_DEBUG_CHANNEL(enhmetafile
);
52 BOOL on_disk
; /* true if metafile is on disk */
56 /****************************************************************************
57 * EMF_Create_HENHMETAFILE
59 HENHMETAFILE
EMF_Create_HENHMETAFILE(ENHMETAHEADER
*emh
, BOOL on_disk
)
62 ENHMETAFILEOBJ
*metaObj
= GDI_AllocObject( sizeof(ENHMETAFILEOBJ
),
63 ENHMETAFILE_MAGIC
, &hmf
, NULL
);
67 metaObj
->on_disk
= on_disk
;
68 GDI_ReleaseObj( hmf
);
73 /****************************************************************************
74 * EMF_Delete_HENHMETAFILE
76 static BOOL
EMF_Delete_HENHMETAFILE( HENHMETAFILE hmf
)
78 ENHMETAFILEOBJ
*metaObj
= (ENHMETAFILEOBJ
*)GDI_GetObjPtr( hmf
,
80 if(!metaObj
) return FALSE
;
83 UnmapViewOfFile( metaObj
->emh
);
85 HeapFree( GetProcessHeap(), 0, metaObj
->emh
);
86 return GDI_FreeObject( hmf
, metaObj
);
89 /******************************************************************
90 * EMF_GetEnhMetaHeader
92 * Returns ptr to ENHMETAHEADER associated with HENHMETAFILE
94 static ENHMETAHEADER
*EMF_GetEnhMetaHeader( HENHMETAFILE hmf
)
96 ENHMETAHEADER
*ret
= NULL
;
97 ENHMETAFILEOBJ
*metaObj
= (ENHMETAFILEOBJ
*)GDI_GetObjPtr( hmf
, ENHMETAFILE_MAGIC
);
98 TRACE("hmf %04x -> enhmetaObj %p\n", hmf
, metaObj
);
102 GDI_ReleaseObj( hmf
);
107 /*****************************************************************************
111 static HENHMETAFILE
EMF_GetEnhMetaFile( HANDLE hFile
)
116 hMapping
= CreateFileMappingA( hFile
, NULL
, PAGE_READONLY
, 0, 0, NULL
);
117 emh
= MapViewOfFile( hMapping
, FILE_MAP_READ
, 0, 0, 0 );
118 CloseHandle( hMapping
);
122 if (emh
->iType
!= EMR_HEADER
|| emh
->dSignature
!= ENHMETA_SIGNATURE
) {
123 WARN("Invalid emf header type 0x%08lx sig 0x%08lx.\n",
124 emh
->iType
, emh
->dSignature
);
125 UnmapViewOfFile( emh
);
128 return EMF_Create_HENHMETAFILE( emh
, TRUE
);
132 /*****************************************************************************
133 * GetEnhMetaFileA (GDI32.@)
137 HENHMETAFILE WINAPI
GetEnhMetaFileA(
138 LPCSTR lpszMetaFile
/* [in] filename of enhanced metafile */
144 hFile
= CreateFileA(lpszMetaFile
, GENERIC_READ
, FILE_SHARE_READ
, 0,
145 OPEN_EXISTING
, 0, 0);
146 if (hFile
== INVALID_HANDLE_VALUE
) {
147 WARN("could not open %s\n", lpszMetaFile
);
150 hmf
= EMF_GetEnhMetaFile( hFile
);
151 CloseHandle( hFile
);
155 /*****************************************************************************
156 * GetEnhMetaFileW (GDI32.@)
158 HENHMETAFILE WINAPI
GetEnhMetaFileW(
159 LPCWSTR lpszMetaFile
) /* [in] filename of enhanced metafile */
164 hFile
= CreateFileW(lpszMetaFile
, GENERIC_READ
, FILE_SHARE_READ
, 0,
165 OPEN_EXISTING
, 0, 0);
166 if (hFile
== INVALID_HANDLE_VALUE
) {
167 WARN("could not open %s\n", debugstr_w(lpszMetaFile
));
170 hmf
= EMF_GetEnhMetaFile( hFile
);
171 CloseHandle( hFile
);
175 /*****************************************************************************
176 * GetEnhMetaFileHeader (GDI32.@)
178 * If buf is NULL, returns the size of buffer required.
179 * Otherwise, copy up to bufsize bytes of enhanced metafile header into
182 UINT WINAPI
GetEnhMetaFileHeader(
183 HENHMETAFILE hmf
, /* [in] enhanced metafile */
184 UINT bufsize
, /* [in] size of buffer */
185 LPENHMETAHEADER buf
/* [out] buffer */
191 emh
= EMF_GetEnhMetaHeader(hmf
);
192 if(!emh
) return FALSE
;
194 if (!buf
) return size
;
195 size
= min(size
, bufsize
);
196 memmove(buf
, emh
, size
);
201 /*****************************************************************************
202 * GetEnhMetaFileDescriptionA (GDI32.@)
204 UINT WINAPI
GetEnhMetaFileDescriptionA(
205 HENHMETAFILE hmf
, /* [in] enhanced metafile */
206 UINT size
, /* [in] size of buf */
207 LPSTR buf
/* [out] buffer to receive description */
210 LPENHMETAHEADER emh
= EMF_GetEnhMetaHeader(hmf
);
214 if(!emh
) return FALSE
;
215 if(emh
->nDescription
== 0 || emh
->offDescription
== 0) return 0;
216 descrW
= (WCHAR
*) ((char *) emh
+ emh
->offDescription
);
217 len
= WideCharToMultiByte( CP_ACP
, 0, descrW
, emh
->nDescription
, NULL
, 0, NULL
, NULL
);
219 if (!buf
|| !size
) return len
;
221 len
= min( size
, len
);
222 WideCharToMultiByte( CP_ACP
, 0, descrW
, emh
->nDescription
, buf
, len
, NULL
, NULL
);
226 /*****************************************************************************
227 * GetEnhMetaFileDescriptionW (GDI32.@)
229 * Copies the description string of an enhanced metafile into a buffer
232 * If _buf_ is NULL, returns size of _buf_ required. Otherwise, returns
233 * number of characters copied.
235 UINT WINAPI
GetEnhMetaFileDescriptionW(
236 HENHMETAFILE hmf
, /* [in] enhanced metafile */
237 UINT size
, /* [in] size of buf */
238 LPWSTR buf
/* [out] buffer to receive description */
241 LPENHMETAHEADER emh
= EMF_GetEnhMetaHeader(hmf
);
243 if(!emh
) return FALSE
;
244 if(emh
->nDescription
== 0 || emh
->offDescription
== 0) return 0;
245 if (!buf
|| !size
) return emh
->nDescription
;
247 memmove(buf
, (char *) emh
+ emh
->offDescription
, min(size
,emh
->nDescription
)*sizeof(WCHAR
));
248 return min(size
, emh
->nDescription
);
251 /****************************************************************************
252 * SetEnhMetaFileBits (GDI32.@)
254 * Creates an enhanced metafile by copying _bufsize_ bytes from _buf_.
256 HENHMETAFILE WINAPI
SetEnhMetaFileBits(UINT bufsize
, const BYTE
*buf
)
258 ENHMETAHEADER
*emh
= HeapAlloc( GetProcessHeap(), 0, bufsize
);
259 memmove(emh
, buf
, bufsize
);
260 return EMF_Create_HENHMETAFILE( emh
, FALSE
);
263 /*****************************************************************************
264 * GetEnhMetaFileBits (GDI32.@)
267 UINT WINAPI
GetEnhMetaFileBits(
273 LPENHMETAHEADER emh
= EMF_GetEnhMetaHeader( hmf
);
279 if( buf
== NULL
) return size
;
281 size
= min( size
, bufsize
);
282 memmove(buf
, emh
, size
);
286 /*****************************************************************************
287 * PlayEnhMetaFileRecord (GDI32.@)
289 * Render a single enhanced metafile record in the device context hdc.
292 * TRUE (non zero) on success, FALSE on error.
294 * Many unimplemented records.
295 * No error handling on record play failures (ie checking return codes)
297 BOOL WINAPI
PlayEnhMetaFileRecord(
298 HDC hdc
, /* [in] device context in which to render EMF record */
299 LPHANDLETABLE handletable
, /* [in] array of handles to be used in rendering record */
300 const ENHMETARECORD
*mr
, /* [in] EMF record to render */
301 UINT handles
/* [in] size of handle array */
306 "hdc = %08x, handletable = %p, record = %p, numHandles = %d\n",
307 hdc
, handletable
, mr
, handles
);
308 if (!mr
) return FALSE
;
312 TRACE(" type=%d\n", type
);
321 PEMRGDICOMMENT lpGdiComment
= (PEMRGDICOMMENT
)mr
;
322 /* In an enhanced metafile, there can be both public and private GDI comments */
323 GdiComment( hdc
, lpGdiComment
->cbData
, lpGdiComment
->Data
);
328 PEMRSETMAPMODE pSetMapMode
= (PEMRSETMAPMODE
) mr
;
329 SetMapMode(hdc
, pSetMapMode
->iMode
);
334 PEMRSETBKMODE pSetBkMode
= (PEMRSETBKMODE
) mr
;
335 SetBkMode(hdc
, pSetBkMode
->iMode
);
340 PEMRSETBKCOLOR pSetBkColor
= (PEMRSETBKCOLOR
) mr
;
341 SetBkColor(hdc
, pSetBkColor
->crColor
);
344 case EMR_SETPOLYFILLMODE
:
346 PEMRSETPOLYFILLMODE pSetPolyFillMode
= (PEMRSETPOLYFILLMODE
) mr
;
347 SetPolyFillMode(hdc
, pSetPolyFillMode
->iMode
);
352 PEMRSETROP2 pSetROP2
= (PEMRSETROP2
) mr
;
353 SetROP2(hdc
, pSetROP2
->iMode
);
356 case EMR_SETSTRETCHBLTMODE
:
358 PEMRSETSTRETCHBLTMODE pSetStretchBltMode
= (PEMRSETSTRETCHBLTMODE
) mr
;
359 SetStretchBltMode(hdc
, pSetStretchBltMode
->iMode
);
362 case EMR_SETTEXTALIGN
:
364 PEMRSETTEXTALIGN pSetTextAlign
= (PEMRSETTEXTALIGN
) mr
;
365 SetTextAlign(hdc
, pSetTextAlign
->iMode
);
368 case EMR_SETTEXTCOLOR
:
370 PEMRSETTEXTCOLOR pSetTextColor
= (PEMRSETTEXTCOLOR
) mr
;
371 SetTextColor(hdc
, pSetTextColor
->crColor
);
381 PEMRRESTOREDC pRestoreDC
= (PEMRRESTOREDC
) mr
;
382 RestoreDC(hdc
, pRestoreDC
->iRelative
);
385 case EMR_INTERSECTCLIPRECT
:
387 PEMRINTERSECTCLIPRECT pClipRect
= (PEMRINTERSECTCLIPRECT
) mr
;
388 IntersectClipRect(hdc
, pClipRect
->rclClip
.left
, pClipRect
->rclClip
.top
,
389 pClipRect
->rclClip
.right
, pClipRect
->rclClip
.bottom
);
392 case EMR_SELECTOBJECT
:
394 PEMRSELECTOBJECT pSelectObject
= (PEMRSELECTOBJECT
) mr
;
395 if( pSelectObject
->ihObject
& 0x80000000 ) {
396 /* High order bit is set - it's a stock object
397 * Strip the high bit to get the index.
398 * See MSDN article Q142319
400 SelectObject( hdc
, GetStockObject( pSelectObject
->ihObject
&
403 /* High order bit wasn't set - not a stock object
406 (handletable
->objectHandle
)[pSelectObject
->ihObject
] );
410 case EMR_DELETEOBJECT
:
412 PEMRDELETEOBJECT pDeleteObject
= (PEMRDELETEOBJECT
) mr
;
413 DeleteObject( (handletable
->objectHandle
)[pDeleteObject
->ihObject
]);
414 (handletable
->objectHandle
)[pDeleteObject
->ihObject
] = 0;
417 case EMR_SETWINDOWORGEX
:
420 PEMRSETWINDOWORGEX pSetWindowOrgEx
= (PEMRSETWINDOWORGEX
) mr
;
426 xform
.eDx
= -pSetWindowOrgEx
->ptlOrigin
.x
;
427 xform
.eDy
= -pSetWindowOrgEx
->ptlOrigin
.y
;
429 ModifyWorldTransform(hdc
, &xform
, MWT_LEFTMULTIPLY
);
432 case EMR_SETWINDOWEXTEX
:
434 PEMRSETWINDOWEXTEX pSetWindowExtEx
= (PEMRSETWINDOWEXTEX
) mr
;
435 SetWindowExtEx(hdc
, pSetWindowExtEx
->szlExtent
.cx
,
436 pSetWindowExtEx
->szlExtent
.cy
, NULL
);
439 case EMR_SETVIEWPORTORGEX
:
441 PEMRSETVIEWPORTORGEX pSetViewportOrgEx
= (PEMRSETVIEWPORTORGEX
) mr
;
442 SetViewportOrgEx(hdc
, pSetViewportOrgEx
->ptlOrigin
.x
,
443 pSetViewportOrgEx
->ptlOrigin
.y
, NULL
);
446 case EMR_SETVIEWPORTEXTEX
:
448 PEMRSETVIEWPORTEXTEX pSetViewportExtEx
= (PEMRSETVIEWPORTEXTEX
) mr
;
449 SetViewportExtEx(hdc
, pSetViewportExtEx
->szlExtent
.cx
,
450 pSetViewportExtEx
->szlExtent
.cy
, NULL
);
455 PEMRCREATEPEN pCreatePen
= (PEMRCREATEPEN
) mr
;
456 (handletable
->objectHandle
)[pCreatePen
->ihPen
] =
457 CreatePenIndirect(&pCreatePen
->lopn
);
460 case EMR_EXTCREATEPEN
:
462 PEMREXTCREATEPEN pPen
= (PEMREXTCREATEPEN
) mr
;
464 lb
.lbStyle
= pPen
->elp
.elpBrushStyle
;
465 lb
.lbColor
= pPen
->elp
.elpColor
;
466 lb
.lbHatch
= pPen
->elp
.elpHatch
;
468 if(pPen
->offBmi
|| pPen
->offBits
)
469 FIXME("EMR_EXTCREATEPEN: Need to copy brush bitmap\n");
471 (handletable
->objectHandle
)[pPen
->ihPen
] =
472 ExtCreatePen(pPen
->elp
.elpPenStyle
, pPen
->elp
.elpWidth
, &lb
,
473 pPen
->elp
.elpNumEntries
, pPen
->elp
.elpStyleEntry
);
476 case EMR_CREATEBRUSHINDIRECT
:
478 PEMRCREATEBRUSHINDIRECT pBrush
= (PEMRCREATEBRUSHINDIRECT
) mr
;
479 (handletable
->objectHandle
)[pBrush
->ihBrush
] =
480 CreateBrushIndirect(&pBrush
->lb
);
483 case EMR_EXTCREATEFONTINDIRECTW
:
485 PEMREXTCREATEFONTINDIRECTW pFont
= (PEMREXTCREATEFONTINDIRECTW
) mr
;
486 (handletable
->objectHandle
)[pFont
->ihFont
] =
487 CreateFontIndirectW(&pFont
->elfw
.elfLogFont
);
492 PEMRMOVETOEX pMoveToEx
= (PEMRMOVETOEX
) mr
;
493 MoveToEx(hdc
, pMoveToEx
->ptl
.x
, pMoveToEx
->ptl
.y
, NULL
);
498 PEMRLINETO pLineTo
= (PEMRLINETO
) mr
;
499 LineTo(hdc
, pLineTo
->ptl
.x
, pLineTo
->ptl
.y
);
504 PEMRRECTANGLE pRect
= (PEMRRECTANGLE
) mr
;
505 Rectangle(hdc
, pRect
->rclBox
.left
, pRect
->rclBox
.top
,
506 pRect
->rclBox
.right
, pRect
->rclBox
.bottom
);
511 PEMRELLIPSE pEllipse
= (PEMRELLIPSE
) mr
;
512 Ellipse(hdc
, pEllipse
->rclBox
.left
, pEllipse
->rclBox
.top
,
513 pEllipse
->rclBox
.right
, pEllipse
->rclBox
.bottom
);
518 PEMRPOLYGON16 pPoly
= (PEMRPOLYGON16
) mr
;
519 /* Shouldn't use Polygon16 since pPoly->cpts is DWORD */
520 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
521 pPoly
->cpts
* sizeof(POINT
) );
523 for(i
= 0; i
< pPoly
->cpts
; i
++)
524 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
525 Polygon(hdc
, pts
, pPoly
->cpts
);
526 HeapFree( GetProcessHeap(), 0, pts
);
531 PEMRPOLYLINE16 pPoly
= (PEMRPOLYLINE16
) mr
;
532 /* Shouldn't use Polyline16 since pPoly->cpts is DWORD */
533 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
534 pPoly
->cpts
* sizeof(POINT
) );
536 for(i
= 0; i
< pPoly
->cpts
; i
++)
537 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
538 Polyline(hdc
, pts
, pPoly
->cpts
);
539 HeapFree( GetProcessHeap(), 0, pts
);
542 case EMR_POLYLINETO16
:
544 PEMRPOLYLINETO16 pPoly
= (PEMRPOLYLINETO16
) mr
;
545 /* Shouldn't use PolylineTo16 since pPoly->cpts is DWORD */
546 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
547 pPoly
->cpts
* sizeof(POINT
) );
549 for(i
= 0; i
< pPoly
->cpts
; i
++)
550 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
551 PolylineTo(hdc
, pts
, pPoly
->cpts
);
552 HeapFree( GetProcessHeap(), 0, pts
);
555 case EMR_POLYBEZIER16
:
557 PEMRPOLYBEZIER16 pPoly
= (PEMRPOLYBEZIER16
) mr
;
558 /* Shouldn't use PolyBezier16 since pPoly->cpts is DWORD */
559 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
560 pPoly
->cpts
* sizeof(POINT
) );
562 for(i
= 0; i
< pPoly
->cpts
; i
++)
563 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
564 PolyBezier(hdc
, pts
, pPoly
->cpts
);
565 HeapFree( GetProcessHeap(), 0, pts
);
568 case EMR_POLYBEZIERTO16
:
570 PEMRPOLYBEZIERTO16 pPoly
= (PEMRPOLYBEZIERTO16
) mr
;
571 /* Shouldn't use PolyBezierTo16 since pPoly->cpts is DWORD */
572 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
573 pPoly
->cpts
* sizeof(POINT
) );
575 for(i
= 0; i
< pPoly
->cpts
; i
++)
576 CONV_POINT16TO32(pPoly
->apts
+ i
, pts
+ i
);
577 PolyBezierTo(hdc
, pts
, pPoly
->cpts
);
578 HeapFree( GetProcessHeap(), 0, pts
);
581 case EMR_POLYPOLYGON16
:
583 PEMRPOLYPOLYGON16 pPolyPoly
= (PEMRPOLYPOLYGON16
) mr
;
584 /* NB POINTS array doesn't start at pPolyPoly->apts it's actually
585 pPolyPoly->aPolyCounts + pPolyPoly->nPolys */
587 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
588 pPolyPoly
->cpts
* sizeof(POINT
) );
590 for(i
= 0; i
< pPolyPoly
->cpts
; i
++)
591 CONV_POINT16TO32((POINT16
*) (pPolyPoly
->aPolyCounts
+
592 pPolyPoly
->nPolys
) + i
, pts
+ i
);
594 PolyPolygon(hdc
, pts
, (INT
*)pPolyPoly
->aPolyCounts
, pPolyPoly
->nPolys
);
595 HeapFree( GetProcessHeap(), 0, pts
);
598 case EMR_POLYPOLYLINE16
:
600 PEMRPOLYPOLYLINE16 pPolyPoly
= (PEMRPOLYPOLYLINE16
) mr
;
601 /* NB POINTS array doesn't start at pPolyPoly->apts it's actually
602 pPolyPoly->aPolyCounts + pPolyPoly->nPolys */
604 POINT
*pts
= HeapAlloc( GetProcessHeap(), 0,
605 pPolyPoly
->cpts
* sizeof(POINT
) );
607 for(i
= 0; i
< pPolyPoly
->cpts
; i
++)
608 CONV_POINT16TO32((POINT16
*) (pPolyPoly
->aPolyCounts
+
609 pPolyPoly
->nPolys
) + i
, pts
+ i
);
611 PolyPolyline(hdc
, pts
, pPolyPoly
->aPolyCounts
, pPolyPoly
->nPolys
);
612 HeapFree( GetProcessHeap(), 0, pts
);
616 case EMR_STRETCHDIBITS
:
618 EMRSTRETCHDIBITS
*pStretchDIBits
= (EMRSTRETCHDIBITS
*)mr
;
621 pStretchDIBits
->xDest
,
622 pStretchDIBits
->yDest
,
623 pStretchDIBits
->cxDest
,
624 pStretchDIBits
->cyDest
,
625 pStretchDIBits
->xSrc
,
626 pStretchDIBits
->ySrc
,
627 pStretchDIBits
->cxSrc
,
628 pStretchDIBits
->cySrc
,
629 (BYTE
*)mr
+ pStretchDIBits
->offBitsSrc
,
630 (const BITMAPINFO
*)((BYTE
*)mr
+ pStretchDIBits
->offBmiSrc
),
631 pStretchDIBits
->iUsageSrc
,
632 pStretchDIBits
->dwRop
);
636 case EMR_EXTTEXTOUTA
:
638 PEMREXTTEXTOUTA pExtTextOutA
= (PEMREXTTEXTOUTA
)mr
;
641 rc
.left
= pExtTextOutA
->emrtext
.rcl
.left
;
642 rc
.top
= pExtTextOutA
->emrtext
.rcl
.top
;
643 rc
.right
= pExtTextOutA
->emrtext
.rcl
.right
;
644 rc
.bottom
= pExtTextOutA
->emrtext
.rcl
.bottom
;
645 ExtTextOutA(hdc
, pExtTextOutA
->emrtext
.ptlReference
.x
, pExtTextOutA
->emrtext
.ptlReference
.y
,
646 pExtTextOutA
->emrtext
.fOptions
, &rc
,
647 (LPSTR
)((BYTE
*)mr
+ pExtTextOutA
->emrtext
.offString
), pExtTextOutA
->emrtext
.nChars
,
648 (INT
*)((BYTE
*)mr
+ pExtTextOutA
->emrtext
.offDx
));
652 case EMR_EXTTEXTOUTW
:
654 PEMREXTTEXTOUTW pExtTextOutW
= (PEMREXTTEXTOUTW
)mr
;
657 rc
.left
= pExtTextOutW
->emrtext
.rcl
.left
;
658 rc
.top
= pExtTextOutW
->emrtext
.rcl
.top
;
659 rc
.right
= pExtTextOutW
->emrtext
.rcl
.right
;
660 rc
.bottom
= pExtTextOutW
->emrtext
.rcl
.bottom
;
661 ExtTextOutW(hdc
, pExtTextOutW
->emrtext
.ptlReference
.x
, pExtTextOutW
->emrtext
.ptlReference
.y
,
662 pExtTextOutW
->emrtext
.fOptions
, &rc
,
663 (LPWSTR
)((BYTE
*)mr
+ pExtTextOutW
->emrtext
.offString
), pExtTextOutW
->emrtext
.nChars
,
664 (INT
*)((BYTE
*)mr
+ pExtTextOutW
->emrtext
.offDx
));
668 case EMR_CREATEPALETTE
:
670 PEMRCREATEPALETTE lpCreatePal
= (PEMRCREATEPALETTE
)mr
;
672 (handletable
->objectHandle
)[ lpCreatePal
->ihPal
] =
673 CreatePalette( &lpCreatePal
->lgpl
);
678 case EMR_SELECTPALETTE
:
680 PEMRSELECTPALETTE lpSelectPal
= (PEMRSELECTPALETTE
)mr
;
682 if( lpSelectPal
->ihPal
& 0x80000000 ) {
683 SelectPalette( hdc
, GetStockObject(lpSelectPal
->ihPal
& 0x7fffffff), TRUE
);
685 (handletable
->objectHandle
)[ lpSelectPal
->ihPal
] =
686 SelectPalette( hdc
, (handletable
->objectHandle
)[lpSelectPal
->ihPal
], TRUE
);
691 case EMR_REALIZEPALETTE
:
693 RealizePalette( hdc
);
697 case EMR_EXTSELECTCLIPRGN
:
699 PEMREXTSELECTCLIPRGN lpRgn
= (PEMREXTSELECTCLIPRGN
)mr
;
700 HRGN hRgn
= ExtCreateRegion(NULL
, lpRgn
->cbRgnData
, (RGNDATA
*)lpRgn
->RgnData
);
701 ExtSelectClipRgn(hdc
, hRgn
, (INT
)(lpRgn
->iMode
));
702 /* ExtSelectClipRgn created a copy of the region */
713 case EMR_SETWORLDTRANSFORM
:
715 PEMRSETWORLDTRANSFORM lpXfrm
= (PEMRSETWORLDTRANSFORM
)mr
;
716 SetWorldTransform( hdc
, &lpXfrm
->xform
);
722 PEMRPOLYBEZIER lpPolyBez
= (PEMRPOLYBEZIER
)mr
;
723 PolyBezier(hdc
, (const LPPOINT
)lpPolyBez
->aptl
, (UINT
)lpPolyBez
->cptl
);
729 PEMRPOLYGON lpPoly
= (PEMRPOLYGON
)mr
;
730 Polygon( hdc
, (const LPPOINT
)lpPoly
->aptl
, (UINT
)lpPoly
->cptl
);
736 PEMRPOLYLINE lpPolyLine
= (PEMRPOLYLINE
)mr
;
737 Polyline(hdc
, (const LPPOINT
)lpPolyLine
->aptl
, (UINT
)lpPolyLine
->cptl
);
741 case EMR_POLYBEZIERTO
:
743 PEMRPOLYBEZIERTO lpPolyBezierTo
= (PEMRPOLYBEZIERTO
)mr
;
744 PolyBezierTo( hdc
, (const LPPOINT
)lpPolyBezierTo
->aptl
,
745 (UINT
)lpPolyBezierTo
->cptl
);
751 PEMRPOLYLINETO lpPolyLineTo
= (PEMRPOLYLINETO
)mr
;
752 PolylineTo( hdc
, (const LPPOINT
)lpPolyLineTo
->aptl
,
753 (UINT
)lpPolyLineTo
->cptl
);
757 case EMR_POLYPOLYLINE
:
759 PEMRPOLYPOLYLINE pPolyPolyline
= (PEMRPOLYPOLYLINE
) mr
;
760 /* NB Points at pPolyPolyline->aPolyCounts + pPolyPolyline->nPolys */
762 PolyPolyline(hdc
, (LPPOINT
)(pPolyPolyline
->aPolyCounts
+
763 pPolyPolyline
->nPolys
),
764 pPolyPolyline
->aPolyCounts
,
765 pPolyPolyline
->nPolys
);
770 case EMR_POLYPOLYGON
:
772 PEMRPOLYPOLYGON pPolyPolygon
= (PEMRPOLYPOLYGON
) mr
;
774 /* NB Points at pPolyPolygon->aPolyCounts + pPolyPolygon->nPolys */
776 PolyPolygon(hdc
, (LPPOINT
)(pPolyPolygon
->aPolyCounts
+
777 pPolyPolygon
->nPolys
),
778 (INT
*)pPolyPolygon
->aPolyCounts
, pPolyPolygon
->nPolys
);
782 case EMR_SETBRUSHORGEX
:
784 PEMRSETBRUSHORGEX lpSetBrushOrgEx
= (PEMRSETBRUSHORGEX
)mr
;
787 (INT
)lpSetBrushOrgEx
->ptlOrigin
.x
,
788 (INT
)lpSetBrushOrgEx
->ptlOrigin
.y
,
796 PEMRSETPIXELV lpSetPixelV
= (PEMRSETPIXELV
)mr
;
799 (INT
)lpSetPixelV
->ptlPixel
.x
,
800 (INT
)lpSetPixelV
->ptlPixel
.y
,
801 lpSetPixelV
->crColor
);
806 case EMR_SETMAPPERFLAGS
:
808 PEMRSETMAPPERFLAGS lpSetMapperFlags
= (PEMRSETMAPPERFLAGS
)mr
;
810 SetMapperFlags( hdc
, lpSetMapperFlags
->dwFlags
);
815 case EMR_SETCOLORADJUSTMENT
:
817 PEMRSETCOLORADJUSTMENT lpSetColorAdjust
= (PEMRSETCOLORADJUSTMENT
)mr
;
819 SetColorAdjustment( hdc
, &lpSetColorAdjust
->ColorAdjustment
);
824 case EMR_OFFSETCLIPRGN
:
826 PEMROFFSETCLIPRGN lpOffsetClipRgn
= (PEMROFFSETCLIPRGN
)mr
;
829 (INT
)lpOffsetClipRgn
->ptlOffset
.x
,
830 (INT
)lpOffsetClipRgn
->ptlOffset
.y
);
835 case EMR_EXCLUDECLIPRECT
:
837 PEMREXCLUDECLIPRECT lpExcludeClipRect
= (PEMREXCLUDECLIPRECT
)mr
;
839 ExcludeClipRect( hdc
,
840 lpExcludeClipRect
->rclClip
.left
,
841 lpExcludeClipRect
->rclClip
.top
,
842 lpExcludeClipRect
->rclClip
.right
,
843 lpExcludeClipRect
->rclClip
.bottom
);
848 case EMR_SCALEVIEWPORTEXTEX
:
850 PEMRSCALEVIEWPORTEXTEX lpScaleViewportExtEx
= (PEMRSCALEVIEWPORTEXTEX
)mr
;
852 ScaleViewportExtEx( hdc
,
853 lpScaleViewportExtEx
->xNum
,
854 lpScaleViewportExtEx
->xDenom
,
855 lpScaleViewportExtEx
->yNum
,
856 lpScaleViewportExtEx
->yDenom
,
862 case EMR_SCALEWINDOWEXTEX
:
864 PEMRSCALEWINDOWEXTEX lpScaleWindowExtEx
= (PEMRSCALEWINDOWEXTEX
)mr
;
866 ScaleWindowExtEx( hdc
,
867 lpScaleWindowExtEx
->xNum
,
868 lpScaleWindowExtEx
->xDenom
,
869 lpScaleWindowExtEx
->yNum
,
870 lpScaleWindowExtEx
->yDenom
,
876 case EMR_MODIFYWORLDTRANSFORM
:
878 PEMRMODIFYWORLDTRANSFORM lpModifyWorldTrans
= (PEMRMODIFYWORLDTRANSFORM
)mr
;
880 ModifyWorldTransform( hdc
, &lpModifyWorldTrans
->xform
,
881 lpModifyWorldTrans
->iMode
);
888 PEMRANGLEARC lpAngleArc
= (PEMRANGLEARC
)mr
;
891 (INT
)lpAngleArc
->ptlCenter
.x
, (INT
)lpAngleArc
->ptlCenter
.y
,
892 lpAngleArc
->nRadius
, lpAngleArc
->eStartAngle
,
893 lpAngleArc
->eSweepAngle
);
900 PEMRROUNDRECT lpRoundRect
= (PEMRROUNDRECT
)mr
;
903 lpRoundRect
->rclBox
.left
,
904 lpRoundRect
->rclBox
.top
,
905 lpRoundRect
->rclBox
.right
,
906 lpRoundRect
->rclBox
.bottom
,
907 lpRoundRect
->szlCorner
.cx
,
908 lpRoundRect
->szlCorner
.cy
);
915 PEMRARC lpArc
= (PEMRARC
)mr
;
918 (INT
)lpArc
->rclBox
.left
,
919 (INT
)lpArc
->rclBox
.top
,
920 (INT
)lpArc
->rclBox
.right
,
921 (INT
)lpArc
->rclBox
.bottom
,
922 (INT
)lpArc
->ptlStart
.x
,
923 (INT
)lpArc
->ptlStart
.y
,
924 (INT
)lpArc
->ptlEnd
.x
,
925 (INT
)lpArc
->ptlEnd
.y
);
932 PEMRCHORD lpChord
= (PEMRCHORD
)mr
;
935 (INT
)lpChord
->rclBox
.left
,
936 (INT
)lpChord
->rclBox
.top
,
937 (INT
)lpChord
->rclBox
.right
,
938 (INT
)lpChord
->rclBox
.bottom
,
939 (INT
)lpChord
->ptlStart
.x
,
940 (INT
)lpChord
->ptlStart
.y
,
941 (INT
)lpChord
->ptlEnd
.x
,
942 (INT
)lpChord
->ptlEnd
.y
);
949 PEMRPIE lpPie
= (PEMRPIE
)mr
;
952 (INT
)lpPie
->rclBox
.left
,
953 (INT
)lpPie
->rclBox
.top
,
954 (INT
)lpPie
->rclBox
.right
,
955 (INT
)lpPie
->rclBox
.bottom
,
956 (INT
)lpPie
->ptlStart
.x
,
957 (INT
)lpPie
->ptlStart
.y
,
958 (INT
)lpPie
->ptlEnd
.x
,
959 (INT
)lpPie
->ptlEnd
.y
);
966 PEMRARC lpArcTo
= (PEMRARC
)mr
;
969 (INT
)lpArcTo
->rclBox
.left
,
970 (INT
)lpArcTo
->rclBox
.top
,
971 (INT
)lpArcTo
->rclBox
.right
,
972 (INT
)lpArcTo
->rclBox
.bottom
,
973 (INT
)lpArcTo
->ptlStart
.x
,
974 (INT
)lpArcTo
->ptlStart
.y
,
975 (INT
)lpArcTo
->ptlEnd
.x
,
976 (INT
)lpArcTo
->ptlEnd
.y
);
981 case EMR_EXTFLOODFILL
:
983 PEMREXTFLOODFILL lpExtFloodFill
= (PEMREXTFLOODFILL
)mr
;
986 (INT
)lpExtFloodFill
->ptlStart
.x
,
987 (INT
)lpExtFloodFill
->ptlStart
.y
,
988 lpExtFloodFill
->crColor
,
989 (UINT
)lpExtFloodFill
->iMode
);
996 PEMRPOLYDRAW lpPolyDraw
= (PEMRPOLYDRAW
)mr
;
998 (const LPPOINT
)lpPolyDraw
->aptl
,
1000 (INT
)lpPolyDraw
->cptl
);
1005 case EMR_SETARCDIRECTION
:
1007 PEMRSETARCDIRECTION lpSetArcDirection
= (PEMRSETARCDIRECTION
)mr
;
1008 SetArcDirection( hdc
, (INT
)lpSetArcDirection
->iArcDirection
);
1012 case EMR_SETMITERLIMIT
:
1014 PEMRSETMITERLIMIT lpSetMiterLimit
= (PEMRSETMITERLIMIT
)mr
;
1015 SetMiterLimit( hdc
, lpSetMiterLimit
->eMiterLimit
, NULL
);
1031 case EMR_CLOSEFIGURE
:
1039 /*PEMRFILLPATH lpFillPath = (PEMRFILLPATH)mr;*/
1044 case EMR_STROKEANDFILLPATH
:
1046 /*PEMRSTROKEANDFILLPATH lpStrokeAndFillPath = (PEMRSTROKEANDFILLPATH)mr;*/
1047 StrokeAndFillPath( hdc
);
1051 case EMR_STROKEPATH
:
1053 /*PEMRSTROKEPATH lpStrokePath = (PEMRSTROKEPATH)mr;*/
1058 case EMR_FLATTENPATH
:
1070 case EMR_SELECTCLIPPATH
:
1072 PEMRSELECTCLIPPATH lpSelectClipPath
= (PEMRSELECTCLIPPATH
)mr
;
1073 SelectClipPath( hdc
, (INT
)lpSelectClipPath
->iMode
);
1083 case EMR_CREATECOLORSPACE
:
1085 PEMRCREATECOLORSPACE lpCreateColorSpace
= (PEMRCREATECOLORSPACE
)mr
;
1086 (handletable
->objectHandle
)[lpCreateColorSpace
->ihCS
] =
1087 CreateColorSpaceA( &lpCreateColorSpace
->lcs
);
1091 case EMR_SETCOLORSPACE
:
1093 PEMRSETCOLORSPACE lpSetColorSpace
= (PEMRSETCOLORSPACE
)mr
;
1095 (handletable
->objectHandle
)[lpSetColorSpace
->ihCS
] );
1099 case EMR_DELETECOLORSPACE
:
1101 PEMRDELETECOLORSPACE lpDeleteColorSpace
= (PEMRDELETECOLORSPACE
)mr
;
1102 DeleteColorSpace( (handletable
->objectHandle
)[lpDeleteColorSpace
->ihCS
] );
1106 case EMR_SETICMMODE
:
1108 PERMSETICMMODE lpSetICMMode
= (PERMSETICMMODE
)mr
;
1109 SetICMMode( hdc
, (INT
)lpSetICMMode
->iMode
);
1113 case EMR_PIXELFORMAT
:
1116 PEMRPIXELFORMAT lpPixelFormat
= (PEMRPIXELFORMAT
)mr
;
1118 iPixelFormat
= ChoosePixelFormat( hdc
, &lpPixelFormat
->pfd
);
1119 SetPixelFormat( hdc
, iPixelFormat
, &lpPixelFormat
->pfd
);
1124 case EMR_SETPALETTEENTRIES
:
1126 PEMRSETPALETTEENTRIES lpSetPaletteEntries
= (PEMRSETPALETTEENTRIES
)mr
;
1128 SetPaletteEntries( (handletable
->objectHandle
)[lpSetPaletteEntries
->ihPal
],
1129 (UINT
)lpSetPaletteEntries
->iStart
,
1130 (UINT
)lpSetPaletteEntries
->cEntries
,
1131 lpSetPaletteEntries
->aPalEntries
);
1136 case EMR_RESIZEPALETTE
:
1138 PEMRRESIZEPALETTE lpResizePalette
= (PEMRRESIZEPALETTE
)mr
;
1140 ResizePalette( (handletable
->objectHandle
)[lpResizePalette
->ihPal
],
1141 (UINT
)lpResizePalette
->cEntries
);
1146 case EMR_CREATEDIBPATTERNBRUSHPT
:
1148 PEMRCREATEDIBPATTERNBRUSHPT lpCreate
= (PEMRCREATEDIBPATTERNBRUSHPT
)mr
;
1150 /* This is a BITMAPINFO struct followed directly by bitmap bits */
1151 LPVOID lpPackedStruct
= HeapAlloc( GetProcessHeap(),
1153 lpCreate
->cbBmi
+ lpCreate
->cbBits
);
1154 /* Now pack this structure */
1155 memcpy( lpPackedStruct
,
1156 ((BYTE
*)lpCreate
) + lpCreate
->offBmi
,
1158 memcpy( ((BYTE
*)lpPackedStruct
) + lpCreate
->cbBmi
,
1159 ((BYTE
*)lpCreate
) + lpCreate
->offBits
,
1162 (handletable
->objectHandle
)[lpCreate
->ihBrush
] =
1163 CreateDIBPatternBrushPt( lpPackedStruct
,
1164 (UINT
)lpCreate
->iUsage
);
1169 case EMR_CREATEMONOBRUSH
:
1171 PEMRCREATEMONOBRUSH pCreateMonoBrush
= (PEMRCREATEMONOBRUSH
)mr
;
1172 BITMAPINFO
*pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pCreateMonoBrush
->offBmi
);
1173 HBITMAP hBmp
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1174 (BYTE
*)mr
+ pCreateMonoBrush
->offBits
, pbi
, pCreateMonoBrush
->iUsage
);
1175 (handletable
->objectHandle
)[pCreateMonoBrush
->ihBrush
] = CreatePatternBrush(hBmp
);
1176 /* CreatePatternBrush created a copy of the bitmap */
1183 PEMRBITBLT pBitBlt
= (PEMRBITBLT
)mr
;
1184 HDC hdcSrc
= CreateCompatibleDC(hdc
);
1185 HBRUSH hBrush
, hBrushOld
;
1186 HBITMAP hBmp
= 0, hBmpOld
= 0;
1187 BITMAPINFO
*pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pBitBlt
->offBmiSrc
);
1189 SetWorldTransform(hdcSrc
, &pBitBlt
->xformSrc
);
1191 hBrush
= CreateSolidBrush(pBitBlt
->crBkColorSrc
);
1192 hBrushOld
= SelectObject(hdcSrc
, hBrush
);
1193 PatBlt(hdcSrc
, pBitBlt
->rclBounds
.left
, pBitBlt
->rclBounds
.top
,
1194 pBitBlt
->rclBounds
.right
- pBitBlt
->rclBounds
.left
,
1195 pBitBlt
->rclBounds
.bottom
- pBitBlt
->rclBounds
.top
, PATCOPY
);
1196 SelectObject(hdcSrc
, hBrushOld
);
1197 DeleteObject(hBrush
);
1199 if (pBitBlt
->offBmiSrc
> 0)
1201 hBmp
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1202 (BYTE
*)mr
+ pBitBlt
->offBitsSrc
, pbi
, pBitBlt
->iUsageSrc
);
1203 hBmpOld
= SelectObject(hdcSrc
, hBmp
);
1216 if (pBitBlt
->offBmiSrc
> 0)
1218 SelectObject(hdcSrc
, hBmpOld
);
1225 case EMR_STRETCHBLT
:
1227 PEMRSTRETCHBLT pStretchBlt
= (PEMRSTRETCHBLT
)mr
;
1228 HDC hdcSrc
= CreateCompatibleDC(hdc
);
1229 HBRUSH hBrush
, hBrushOld
;
1230 HBITMAP hBmp
= 0, hBmpOld
= 0;
1231 BITMAPINFO
*pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pStretchBlt
->offBmiSrc
);
1233 SetWorldTransform(hdcSrc
, &pStretchBlt
->xformSrc
);
1235 hBrush
= CreateSolidBrush(pStretchBlt
->crBkColorSrc
);
1236 hBrushOld
= SelectObject(hdcSrc
, hBrush
);
1237 PatBlt(hdcSrc
, pStretchBlt
->rclBounds
.left
, pStretchBlt
->rclBounds
.top
,
1238 pStretchBlt
->rclBounds
.right
- pStretchBlt
->rclBounds
.left
,
1239 pStretchBlt
->rclBounds
.bottom
- pStretchBlt
->rclBounds
.top
, PATCOPY
);
1240 SelectObject(hdcSrc
, hBrushOld
);
1241 DeleteObject(hBrush
);
1243 if (pStretchBlt
->offBmiSrc
)
1245 hBmp
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1246 (BYTE
*)mr
+ pStretchBlt
->offBitsSrc
, pbi
, pStretchBlt
->iUsageSrc
);
1247 hBmpOld
= SelectObject(hdcSrc
, hBmp
);
1253 pStretchBlt
->cxDest
,
1254 pStretchBlt
->cyDest
,
1260 pStretchBlt
->dwRop
);
1263 if (pStretchBlt
->offBmiSrc
)
1265 SelectObject(hdcSrc
, hBmpOld
);
1275 PEMRMASKBLT pMaskBlt
= (PEMRMASKBLT
)mr
;
1276 HDC hdcSrc
= CreateCompatibleDC(hdc
);
1277 HBRUSH hBrush
, hBrushOld
;
1278 HBITMAP hBmp
, hBmpOld
, hBmpMask
;
1281 SetWorldTransform(hdcSrc
, &pMaskBlt
->xformSrc
);
1283 hBrush
= CreateSolidBrush(pMaskBlt
->crBkColorSrc
);
1284 hBrushOld
= SelectObject(hdcSrc
, hBrush
);
1285 PatBlt(hdcSrc
, pMaskBlt
->rclBounds
.left
, pMaskBlt
->rclBounds
.top
,
1286 pMaskBlt
->rclBounds
.right
- pMaskBlt
->rclBounds
.left
,
1287 pMaskBlt
->rclBounds
.bottom
- pMaskBlt
->rclBounds
.top
, PATCOPY
);
1288 SelectObject(hdcSrc
, hBrushOld
);
1289 DeleteObject(hBrush
);
1291 pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pMaskBlt
->offBmiMask
);
1292 hBmpMask
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1293 (BYTE
*)mr
+ pMaskBlt
->offBitsMask
, pbi
, pMaskBlt
->iUsageMask
);
1295 pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pMaskBlt
->offBmiSrc
);
1296 hBmp
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1297 (BYTE
*)mr
+ pMaskBlt
->offBitsSrc
, pbi
, pMaskBlt
->iUsageSrc
);
1298 hBmpOld
= SelectObject(hdcSrc
, hBmp
);
1311 SelectObject(hdcSrc
, hBmpOld
);
1313 DeleteObject(hBmpMask
);
1320 PEMRPLGBLT pPlgBlt
= (PEMRPLGBLT
)mr
;
1321 HDC hdcSrc
= CreateCompatibleDC(hdc
);
1322 HBRUSH hBrush
, hBrushOld
;
1323 HBITMAP hBmp
, hBmpOld
, hBmpMask
;
1327 SetWorldTransform(hdcSrc
, &pPlgBlt
->xformSrc
);
1329 pts
[0].x
= pPlgBlt
->aptlDst
[0].x
; pts
[0].y
= pPlgBlt
->aptlDst
[0].y
;
1330 pts
[1].x
= pPlgBlt
->aptlDst
[1].x
; pts
[1].y
= pPlgBlt
->aptlDst
[1].y
;
1331 pts
[2].x
= pPlgBlt
->aptlDst
[2].x
; pts
[2].y
= pPlgBlt
->aptlDst
[2].y
;
1333 hBrush
= CreateSolidBrush(pPlgBlt
->crBkColorSrc
);
1334 hBrushOld
= SelectObject(hdcSrc
, hBrush
);
1335 PatBlt(hdcSrc
, pPlgBlt
->rclBounds
.left
, pPlgBlt
->rclBounds
.top
,
1336 pPlgBlt
->rclBounds
.right
- pPlgBlt
->rclBounds
.left
,
1337 pPlgBlt
->rclBounds
.bottom
- pPlgBlt
->rclBounds
.top
, PATCOPY
);
1338 SelectObject(hdcSrc
, hBrushOld
);
1339 DeleteObject(hBrush
);
1341 pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pPlgBlt
->offBmiMask
);
1342 hBmpMask
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1343 (BYTE
*)mr
+ pPlgBlt
->offBitsMask
, pbi
, pPlgBlt
->iUsageMask
);
1345 pbi
= (BITMAPINFO
*)((BYTE
*)mr
+ pPlgBlt
->offBmiSrc
);
1346 hBmp
= CreateDIBitmap(0, (BITMAPINFOHEADER
*)pbi
, CBM_INIT
,
1347 (BYTE
*)mr
+ pPlgBlt
->offBitsSrc
, pbi
, pPlgBlt
->iUsageSrc
);
1348 hBmpOld
= SelectObject(hdcSrc
, hBmp
);
1359 SelectObject(hdcSrc
, hBmpOld
);
1361 DeleteObject(hBmpMask
);
1366 case EMR_SETDIBITSTODEVICE
:
1368 PEMRSETDIBITSTODEVICE pSetDIBitsToDevice
= (PEMRSETDIBITSTODEVICE
)mr
;
1370 SetDIBitsToDevice(hdc
,
1371 pSetDIBitsToDevice
->xDest
,
1372 pSetDIBitsToDevice
->yDest
,
1373 pSetDIBitsToDevice
->cxSrc
,
1374 pSetDIBitsToDevice
->cySrc
,
1375 pSetDIBitsToDevice
->xSrc
,
1376 pSetDIBitsToDevice
->ySrc
,
1377 pSetDIBitsToDevice
->iStartScan
,
1378 pSetDIBitsToDevice
->cScans
,
1379 (BYTE
*)mr
+ pSetDIBitsToDevice
->offBitsSrc
,
1380 (BITMAPINFO
*)((BYTE
*)mr
+ pSetDIBitsToDevice
->offBmiSrc
),
1381 pSetDIBitsToDevice
->iUsageSrc
);
1385 case EMR_POLYTEXTOUTA
:
1387 PEMRPOLYTEXTOUTA pPolyTextOutA
= (PEMRPOLYTEXTOUTA
)mr
;
1388 POLYTEXTA
*polytextA
= HeapAlloc(GetProcessHeap(), 0, pPolyTextOutA
->cStrings
* sizeof(POLYTEXTA
));
1390 XFORM xform
, xformOld
;
1393 gModeOld
= SetGraphicsMode(hdc
, pPolyTextOutA
->iGraphicsMode
);
1394 GetWorldTransform(hdc
, &xformOld
);
1396 xform
.eM11
= pPolyTextOutA
->exScale
;
1399 xform
.eM22
= pPolyTextOutA
->eyScale
;
1402 SetWorldTransform(hdc
, &xform
);
1404 /* Set up POLYTEXTA structures */
1405 for(i
= 0; i
< pPolyTextOutA
->cStrings
; i
++)
1407 polytextA
[i
].x
= pPolyTextOutA
->aemrtext
[i
].ptlReference
.x
;
1408 polytextA
[i
].y
= pPolyTextOutA
->aemrtext
[i
].ptlReference
.y
;
1409 polytextA
[i
].n
= pPolyTextOutA
->aemrtext
[i
].nChars
;
1410 polytextA
[i
].lpstr
= (LPSTR
)((BYTE
*)mr
+ pPolyTextOutA
->aemrtext
[i
].offString
);
1411 polytextA
[i
].uiFlags
= pPolyTextOutA
->aemrtext
[i
].fOptions
;
1412 polytextA
[i
].rcl
.left
= pPolyTextOutA
->aemrtext
[i
].rcl
.left
;
1413 polytextA
[i
].rcl
.right
= pPolyTextOutA
->aemrtext
[i
].rcl
.right
;
1414 polytextA
[i
].rcl
.top
= pPolyTextOutA
->aemrtext
[i
].rcl
.top
;
1415 polytextA
[i
].rcl
.bottom
= pPolyTextOutA
->aemrtext
[i
].rcl
.bottom
;
1416 polytextA
[i
].pdx
= (int *)((BYTE
*)mr
+ pPolyTextOutA
->aemrtext
[i
].offDx
);
1418 PolyTextOutA(hdc
, polytextA
, pPolyTextOutA
->cStrings
);
1419 HeapFree(GetProcessHeap(), 0, polytextA
);
1421 SetWorldTransform(hdc
, &xformOld
);
1422 SetGraphicsMode(hdc
, gModeOld
);
1426 case EMR_POLYTEXTOUTW
:
1428 PEMRPOLYTEXTOUTW pPolyTextOutW
= (PEMRPOLYTEXTOUTW
)mr
;
1429 POLYTEXTW
*polytextW
= HeapAlloc(GetProcessHeap(), 0, pPolyTextOutW
->cStrings
* sizeof(POLYTEXTW
));
1431 XFORM xform
, xformOld
;
1434 gModeOld
= SetGraphicsMode(hdc
, pPolyTextOutW
->iGraphicsMode
);
1435 GetWorldTransform(hdc
, &xformOld
);
1437 xform
.eM11
= pPolyTextOutW
->exScale
;
1440 xform
.eM22
= pPolyTextOutW
->eyScale
;
1443 SetWorldTransform(hdc
, &xform
);
1445 /* Set up POLYTEXTW structures */
1446 for(i
= 0; i
< pPolyTextOutW
->cStrings
; i
++)
1448 polytextW
[i
].x
= pPolyTextOutW
->aemrtext
[i
].ptlReference
.x
;
1449 polytextW
[i
].y
= pPolyTextOutW
->aemrtext
[i
].ptlReference
.y
;
1450 polytextW
[i
].n
= pPolyTextOutW
->aemrtext
[i
].nChars
;
1451 polytextW
[i
].lpstr
= (LPWSTR
)((BYTE
*)mr
+ pPolyTextOutW
->aemrtext
[i
].offString
);
1452 polytextW
[i
].uiFlags
= pPolyTextOutW
->aemrtext
[i
].fOptions
;
1453 polytextW
[i
].rcl
.left
= pPolyTextOutW
->aemrtext
[i
].rcl
.left
;
1454 polytextW
[i
].rcl
.right
= pPolyTextOutW
->aemrtext
[i
].rcl
.right
;
1455 polytextW
[i
].rcl
.top
= pPolyTextOutW
->aemrtext
[i
].rcl
.top
;
1456 polytextW
[i
].rcl
.bottom
= pPolyTextOutW
->aemrtext
[i
].rcl
.bottom
;
1457 polytextW
[i
].pdx
= (int *)((BYTE
*)mr
+ pPolyTextOutW
->aemrtext
[i
].offDx
);
1459 PolyTextOutW(hdc
, polytextW
, pPolyTextOutW
->cStrings
);
1460 HeapFree(GetProcessHeap(), 0, polytextW
);
1462 SetWorldTransform(hdc
, &xformOld
);
1463 SetGraphicsMode(hdc
, gModeOld
);
1469 PEMRFILLRGN pFillRgn
= (PEMRFILLRGN
)mr
;
1470 HRGN hRgn
= ExtCreateRegion(NULL
, pFillRgn
->cbRgnData
, (RGNDATA
*)pFillRgn
->RgnData
);
1473 (handletable
->objectHandle
)[pFillRgn
->ihBrush
]);
1480 PEMRFRAMERGN pFrameRgn
= (PEMRFRAMERGN
)mr
;
1481 HRGN hRgn
= ExtCreateRegion(NULL
, pFrameRgn
->cbRgnData
, (RGNDATA
*)pFrameRgn
->RgnData
);
1484 (handletable
->objectHandle
)[pFrameRgn
->ihBrush
],
1485 pFrameRgn
->szlStroke
.cx
,
1486 pFrameRgn
->szlStroke
.cy
);
1493 PEMRINVERTRGN pInvertRgn
= (PEMRINVERTRGN
)mr
;
1494 HRGN hRgn
= ExtCreateRegion(NULL
, pInvertRgn
->cbRgnData
, (RGNDATA
*)pInvertRgn
->RgnData
);
1495 InvertRgn(hdc
, hRgn
);
1502 PEMRPAINTRGN pPaintRgn
= (PEMRPAINTRGN
)mr
;
1503 HRGN hRgn
= ExtCreateRegion(NULL
, pPaintRgn
->cbRgnData
, (RGNDATA
*)pPaintRgn
->RgnData
);
1504 PaintRgn(hdc
, hRgn
);
1509 case EMR_SETTEXTJUSTIFICATION
:
1511 PEMRSETTEXTJUSTIFICATION pSetTextJust
= (PEMRSETTEXTJUSTIFICATION
)mr
;
1512 SetTextJustification(hdc
, pSetTextJust
->nBreakExtra
, pSetTextJust
->nBreakCount
);
1518 PEMRSETLAYOUT pSetLayout
= (PEMRSETLAYOUT
)mr
;
1519 SetLayout(hdc
, pSetLayout
->iMode
);
1523 case EMR_POLYDRAW16
:
1525 case EMR_GLSBOUNDEDRECORD
:
1526 case EMR_DRAWESCAPE
:
1529 case EMR_SMALLTEXTOUT
:
1530 case EMR_FORCEUFIMAPPING
:
1531 case EMR_NAMEDESCAPE
:
1532 case EMR_COLORCORRECTPALETTE
:
1533 case EMR_SETICMPROFILEA
:
1534 case EMR_SETICMPROFILEW
:
1535 case EMR_ALPHABLEND
:
1536 case EMR_TRANSPARENTBLT
:
1537 case EMR_GRADIENTFILL
:
1538 case EMR_SETLINKEDUFI
:
1539 case EMR_COLORMATCHTOTARGETW
:
1540 case EMR_CREATECOLORSPACEW
:
1543 /* From docs: If PlayEnhMetaFileRecord doesn't recognize a
1544 record then ignore and return TRUE. */
1545 FIXME("type %d is unimplemented\n", type
);
1552 /*****************************************************************************
1554 * EnumEnhMetaFile (GDI32.@)
1556 * Walk an enhanced metafile, calling a user-specified function _EnhMetaFunc_
1558 * record. Returns when either every record has been used or
1559 * when _EnhMetaFunc_ returns FALSE.
1563 * TRUE if every record is used, FALSE if any invocation of _EnhMetaFunc_
1569 BOOL WINAPI
EnumEnhMetaFile(
1570 HDC hdc
, /* [in] device context to pass to _EnhMetaFunc_ */
1571 HENHMETAFILE hmf
, /* [in] EMF to walk */
1572 ENHMFENUMPROC callback
, /* [in] callback function */
1573 LPVOID data
, /* [in] optional data for callback function */
1574 const RECT
*lpRect
/* [in] bounding rectangle for rendered metafile */
1584 FLOAT xSrcPixSize
, ySrcPixSize
, xscale
, yscale
;
1585 XFORM savedXform
, xform
;
1586 HPEN hPen
= (HPEN
)NULL
;
1587 HBRUSH hBrush
= (HBRUSH
)NULL
;
1588 HFONT hFont
= (HFONT
)NULL
;
1592 SetLastError(ERROR_INVALID_PARAMETER
);
1596 emh
= EMF_GetEnhMetaHeader(hmf
);
1598 SetLastError(ERROR_INVALID_HANDLE
);
1602 ht
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
1603 sizeof(HANDLETABLE
) * emh
->nHandles
);
1606 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1609 ht
->objectHandle
[0] = hmf
;
1613 TRACE("rect: %d,%d - %d,%d. rclFrame: %ld,%ld - %ld,%ld\n",
1614 lpRect
->left
, lpRect
->top
, lpRect
->right
, lpRect
->bottom
,
1615 emh
->rclFrame
.left
, emh
->rclFrame
.top
, emh
->rclFrame
.right
,
1616 emh
->rclFrame
.bottom
);
1618 xSrcPixSize
= (FLOAT
) emh
->szlMillimeters
.cx
/ emh
->szlDevice
.cx
;
1619 ySrcPixSize
= (FLOAT
) emh
->szlMillimeters
.cy
/ emh
->szlDevice
.cy
;
1620 xscale
= (FLOAT
)(lpRect
->right
- lpRect
->left
) * 100.0 /
1621 (emh
->rclFrame
.right
- emh
->rclFrame
.left
) * xSrcPixSize
;
1622 yscale
= (FLOAT
)(lpRect
->bottom
- lpRect
->top
) * 100.0 /
1623 (emh
->rclFrame
.bottom
- emh
->rclFrame
.top
) * ySrcPixSize
;
1625 xform
.eM11
= xscale
;
1628 xform
.eM22
= yscale
;
1629 xform
.eDx
= (FLOAT
) lpRect
->left
- (lpRect
->right
- lpRect
->left
) *
1630 emh
->rclFrame
.left
/ (emh
->rclFrame
.right
- emh
->rclFrame
.left
);
1631 xform
.eDy
= (FLOAT
) lpRect
->top
- (lpRect
->bottom
- lpRect
->top
) *
1632 emh
->rclFrame
.top
/ (emh
->rclFrame
.bottom
- emh
->rclFrame
.top
);
1634 savedMode
= SetGraphicsMode(hdc
, GM_ADVANCED
);
1635 GetWorldTransform(hdc
, &savedXform
);
1637 if (!ModifyWorldTransform(hdc
, &xform
, MWT_RIGHTMULTIPLY
)) {
1638 ERR("World transform failed!\n");
1641 /* save the current pen, brush and font */
1642 hPen
= GetCurrentObject(hdc
, OBJ_PEN
);
1643 hBrush
= GetCurrentObject(hdc
, OBJ_BRUSH
);
1644 hFont
= GetCurrentObject(hdc
, OBJ_FONT
);
1647 TRACE("nSize = %ld, nBytes = %ld, nHandles = %d, nRecords = %ld, nPalEntries = %ld\n",
1648 emh
->nSize
, emh
->nBytes
, emh
->nHandles
, emh
->nRecords
, emh
->nPalEntries
);
1652 while(ret
&& offset
< emh
->nBytes
)
1654 emr
= (ENHMETARECORD
*)((char *)emh
+ offset
);
1655 TRACE("Calling EnumFunc with record type %ld, size %ld\n", emr
->iType
, emr
->nSize
);
1656 ret
= (*callback
)(hdc
, ht
, emr
, emh
->nHandles
, data
);
1657 offset
+= emr
->nSize
;
1662 /* restore pen, brush and font */
1663 SelectObject(hdc
, hBrush
);
1664 SelectObject(hdc
, hPen
);
1665 SelectObject(hdc
, hFont
);
1667 SetWorldTransform(hdc
, &savedXform
);
1669 SetGraphicsMode(hdc
, savedMode
);
1672 for(i
= 1; i
< emh
->nHandles
; i
++) /* Don't delete element 0 (hmf) */
1673 if( (ht
->objectHandle
)[i
] )
1674 DeleteObject( (ht
->objectHandle
)[i
] );
1676 HeapFree( GetProcessHeap(), 0, ht
);
1680 static INT CALLBACK
EMF_PlayEnhMetaFileCallback(HDC hdc
, HANDLETABLE
*ht
,
1682 INT handles
, LPVOID data
)
1684 return PlayEnhMetaFileRecord(hdc
, ht
, emr
, handles
);
1687 /**************************************************************************
1688 * PlayEnhMetaFile (GDI32.@)
1690 * Renders an enhanced metafile into a specified rectangle *lpRect
1691 * in device context hdc.
1694 BOOL WINAPI
PlayEnhMetaFile(
1695 HDC hdc
, /* [in] DC to render into */
1696 HENHMETAFILE hmf
, /* [in] metafile to render */
1697 const RECT
*lpRect
/* [in] rectangle to place metafile inside */
1700 return EnumEnhMetaFile(hdc
, hmf
, EMF_PlayEnhMetaFileCallback
, NULL
,
1704 /*****************************************************************************
1705 * DeleteEnhMetaFile (GDI32.@)
1707 * Deletes an enhanced metafile and frees the associated storage.
1709 BOOL WINAPI
DeleteEnhMetaFile(HENHMETAFILE hmf
)
1711 return EMF_Delete_HENHMETAFILE( hmf
);
1714 /*****************************************************************************
1715 * CopyEnhMetaFileA (GDI32.@) Duplicate an enhanced metafile
1719 HENHMETAFILE WINAPI
CopyEnhMetaFileA(
1720 HENHMETAFILE hmfSrc
,
1723 ENHMETAHEADER
*emrSrc
= EMF_GetEnhMetaHeader( hmfSrc
), *emrDst
;
1724 HENHMETAFILE hmfDst
;
1726 if(!emrSrc
) return FALSE
;
1728 emrDst
= HeapAlloc( GetProcessHeap(), 0, emrSrc
->nBytes
);
1729 memcpy( emrDst
, emrSrc
, emrSrc
->nBytes
);
1730 hmfDst
= EMF_Create_HENHMETAFILE( emrDst
, FALSE
);
1733 hFile
= CreateFileA( file
, GENERIC_WRITE
| GENERIC_READ
, 0, NULL
,
1734 CREATE_ALWAYS
, 0, 0);
1735 WriteFile( hFile
, emrSrc
, emrSrc
->nBytes
, 0, 0);
1736 hmfDst
= EMF_GetEnhMetaFile( hFile
);
1737 CloseHandle( hFile
);
1743 /* Struct to be used to be passed in the LPVOID parameter for cbEnhPaletteCopy */
1744 typedef struct tagEMF_PaletteCopy
1747 LPPALETTEENTRY lpPe
;
1750 /***************************************************************
1751 * Find the EMR_EOF record and then use it to find the
1752 * palette entries for this enhanced metafile.
1753 * The lpData is actually a pointer to a EMF_PaletteCopy struct
1754 * which contains the max number of elements to copy and where
1757 * NOTE: To be used by GetEnhMetaFilePaletteEntries only!
1759 INT CALLBACK
cbEnhPaletteCopy( HDC a
,
1761 LPENHMETARECORD lpEMR
,
1766 if ( lpEMR
->iType
== EMR_EOF
)
1768 PEMREOF lpEof
= (PEMREOF
)lpEMR
;
1769 EMF_PaletteCopy
* info
= (EMF_PaletteCopy
*)lpData
;
1770 DWORD dwNumPalToCopy
= min( lpEof
->nPalEntries
, info
->cEntries
);
1772 TRACE( "copying 0x%08lx palettes\n", dwNumPalToCopy
);
1774 memcpy( (LPVOID
)info
->lpPe
,
1775 (LPVOID
)(((LPSTR
)lpEof
) + lpEof
->offPalEntries
),
1776 sizeof( *(info
->lpPe
) ) * dwNumPalToCopy
);
1778 /* Update the passed data as a return code */
1779 info
->lpPe
= NULL
; /* Palettes were copied! */
1780 info
->cEntries
= (UINT
)dwNumPalToCopy
;
1782 return FALSE
; /* That's all we need */
1788 /*****************************************************************************
1789 * GetEnhMetaFilePaletteEntries (GDI32.@)
1791 * Copy the palette and report size
1793 * BUGS: Error codes (SetLastError) are not set on failures
1795 UINT WINAPI
GetEnhMetaFilePaletteEntries( HENHMETAFILE hEmf
,
1797 LPPALETTEENTRY lpPe
)
1799 ENHMETAHEADER
* enhHeader
= EMF_GetEnhMetaHeader( hEmf
);
1800 EMF_PaletteCopy infoForCallBack
;
1802 TRACE( "(%04x,%d,%p)\n", hEmf
, cEntries
, lpPe
);
1804 /* First check if there are any palettes associated with
1806 if ( enhHeader
->nPalEntries
== 0 ) return 0;
1808 /* Is the user requesting the number of palettes? */
1809 if ( lpPe
== NULL
) return (UINT
)enhHeader
->nPalEntries
;
1811 /* Copy cEntries worth of PALETTEENTRY structs into the buffer */
1812 infoForCallBack
.cEntries
= cEntries
;
1813 infoForCallBack
.lpPe
= lpPe
;
1815 if ( !EnumEnhMetaFile( 0, hEmf
, cbEnhPaletteCopy
,
1816 &infoForCallBack
, NULL
) )
1819 /* Verify that the callback executed correctly */
1820 if ( infoForCallBack
.lpPe
!= NULL
)
1822 /* Callback proc had error! */
1823 ERR( "cbEnhPaletteCopy didn't execute correctly\n" );
1827 return infoForCallBack
.cEntries
;
1830 /******************************************************************
1831 * SetWinMetaFileBits (GDI32.@)
1833 * Translate from old style to new style.
1835 * BUGS: - This doesn't take the DC and scaling into account
1836 * - Most record conversions aren't implemented
1837 * - Handle slot assignement is primative and most likely doesn't work
1839 HENHMETAFILE WINAPI
SetWinMetaFileBits(UINT cbBuffer
,
1840 CONST BYTE
*lpbBuffer
,
1842 CONST METAFILEPICT
*lpmfp
1846 LPVOID lpNewEnhMetaFileBuffer
= NULL
;
1847 UINT uNewEnhMetaFileBufferSize
= 0;
1848 BOOL bFoundEOF
= FALSE
;
1850 FIXME( "(%d,%p,%04x,%p):stub\n", cbBuffer
, lpbBuffer
, hdcRef
, lpmfp
);
1852 /* 1. Get the header - skip over this and get straight to the records */
1854 uNewEnhMetaFileBufferSize
= sizeof( ENHMETAHEADER
);
1855 lpNewEnhMetaFileBuffer
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
1856 uNewEnhMetaFileBufferSize
);
1858 if( lpNewEnhMetaFileBuffer
== NULL
)
1863 /* Fill in the header record */
1865 LPENHMETAHEADER lpNewEnhMetaFileHeader
= (LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
;
1867 lpNewEnhMetaFileHeader
->iType
= EMR_HEADER
;
1868 lpNewEnhMetaFileHeader
->nSize
= sizeof( ENHMETAHEADER
);
1870 /* FIXME: Not right. Must be able to get this from the DC */
1871 lpNewEnhMetaFileHeader
->rclBounds
.left
= 0;
1872 lpNewEnhMetaFileHeader
->rclBounds
.right
= 0;
1873 lpNewEnhMetaFileHeader
->rclBounds
.top
= 0;
1874 lpNewEnhMetaFileHeader
->rclBounds
.bottom
= 0;
1876 /* FIXME: Not right. Must be able to get this from the DC */
1877 lpNewEnhMetaFileHeader
->rclFrame
.left
= 0;
1878 lpNewEnhMetaFileHeader
->rclFrame
.right
= 0;
1879 lpNewEnhMetaFileHeader
->rclFrame
.top
= 0;
1880 lpNewEnhMetaFileHeader
->rclFrame
.bottom
= 0;
1882 lpNewEnhMetaFileHeader
->dSignature
=ENHMETA_SIGNATURE
;
1883 lpNewEnhMetaFileHeader
->nVersion
=0x10000;
1884 lpNewEnhMetaFileHeader
->nBytes
= lpNewEnhMetaFileHeader
->nSize
;
1885 lpNewEnhMetaFileHeader
->sReserved
=0;
1887 /* FIXME: if there is a description add it */
1888 lpNewEnhMetaFileHeader
->nDescription
=0;
1889 lpNewEnhMetaFileHeader
->offDescription
=0;
1891 lpNewEnhMetaFileHeader
->nHandles
= 0; /* No handles yet */
1892 lpNewEnhMetaFileHeader
->nRecords
= 0;
1894 /* I am pretty sure this starts at 0 and grows as entries are added */
1895 lpNewEnhMetaFileHeader
->nPalEntries
= 0;
1897 /* Size in Pixels */
1898 lpNewEnhMetaFileHeader
->szlDevice
.cx
= GetDeviceCaps(hdcRef
,HORZRES
);
1899 lpNewEnhMetaFileHeader
->szlDevice
.cy
= GetDeviceCaps(hdcRef
,VERTRES
);
1902 lpNewEnhMetaFileHeader
->szlMillimeters
.cx
=
1903 GetDeviceCaps(hdcRef
,HORZSIZE
);
1904 lpNewEnhMetaFileHeader
->szlMillimeters
.cy
=
1905 GetDeviceCaps(hdcRef
,VERTSIZE
);
1907 /* FIXME: Add in the rest of the fields to the header */
1913 (char*)lpbBuffer
+= ((METAHEADER
*)lpbBuffer
)->mtHeaderSize
* 2; /* Point past the header - FIXME: metafile quirk? */
1915 /* 2. Enum over individual records and convert them to the new type of records */
1919 LPMETARECORD lpMetaRecord
= (LPMETARECORD
)lpbBuffer
;
1921 #define EMF_ReAllocAndAdjustPointers( a , b ) \
1924 lpTmp = HeapReAlloc( GetProcessHeap(), 0, \
1925 lpNewEnhMetaFileBuffer, \
1926 uNewEnhMetaFileBufferSize + (b) ); \
1927 if( lpTmp == NULL ) { ERR( "No memory!\n" ); goto error; } \
1928 lpNewEnhMetaFileBuffer = lpTmp; \
1929 lpRecord = (a)( (char*)lpNewEnhMetaFileBuffer + uNewEnhMetaFileBufferSize ); \
1930 uNewEnhMetaFileBufferSize += (b); \
1933 switch( lpMetaRecord
->rdFunction
)
1938 size_t uRecord
= sizeof(*lpRecord
);
1940 EMF_ReAllocAndAdjustPointers(PEMREOF
,uRecord
);
1942 /* Fill the new record - FIXME: This is not right */
1943 lpRecord
->emr
.iType
= EMR_EOF
;
1944 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1945 lpRecord
->nPalEntries
= 0; /* FIXME */
1946 lpRecord
->offPalEntries
= 0; /* FIXME */
1947 lpRecord
->nSizeLast
= 0; /* FIXME */
1949 /* No more records after this one */
1952 FIXME( "META_EOF conversion not correct\n" );
1956 case META_SETMAPMODE
:
1958 PEMRSETMAPMODE lpRecord
;
1959 size_t uRecord
= sizeof(*lpRecord
);
1961 EMF_ReAllocAndAdjustPointers(PEMRSETMAPMODE
,uRecord
);
1963 lpRecord
->emr
.iType
= EMR_SETMAPMODE
;
1964 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1966 lpRecord
->iMode
= lpMetaRecord
->rdParm
[0];
1971 case META_DELETEOBJECT
: /* Select and Delete structures are the same */
1972 case META_SELECTOBJECT
:
1974 PEMRDELETEOBJECT lpRecord
;
1975 size_t uRecord
= sizeof(*lpRecord
);
1977 EMF_ReAllocAndAdjustPointers(PEMRDELETEOBJECT
,uRecord
);
1979 if( lpMetaRecord
->rdFunction
== META_DELETEOBJECT
)
1981 lpRecord
->emr
.iType
= EMR_DELETEOBJECT
;
1985 lpRecord
->emr
.iType
= EMR_SELECTOBJECT
;
1987 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
1989 lpRecord
->ihObject
= lpMetaRecord
->rdParm
[0]; /* FIXME: Handle */
1994 case META_POLYGON
: /* This is just plain busted. I don't know what I'm doing */
1996 PEMRPOLYGON16 lpRecord
; /* FIXME: Should it be a poly or poly16? */
1997 size_t uRecord
= sizeof(*lpRecord
);
1999 EMF_ReAllocAndAdjustPointers(PEMRPOLYGON16
,uRecord
);
2001 /* FIXME: This is mostly all wrong */
2002 lpRecord
->emr
.iType
= EMR_POLYGON16
;
2003 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
2005 lpRecord
->rclBounds
.left
= 0;
2006 lpRecord
->rclBounds
.right
= 0;
2007 lpRecord
->rclBounds
.top
= 0;
2008 lpRecord
->rclBounds
.bottom
= 0;
2011 lpRecord
->apts
[0].x
= 0;
2012 lpRecord
->apts
[0].y
= 0;
2014 FIXME( "META_POLYGON conversion not correct\n" );
2019 case META_SETPOLYFILLMODE
:
2021 PEMRSETPOLYFILLMODE lpRecord
;
2022 size_t uRecord
= sizeof(*lpRecord
);
2024 EMF_ReAllocAndAdjustPointers(PEMRSETPOLYFILLMODE
,uRecord
);
2026 lpRecord
->emr
.iType
= EMR_SETPOLYFILLMODE
;
2027 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
2029 lpRecord
->iMode
= lpMetaRecord
->rdParm
[0];
2034 case META_SETWINDOWORG
:
2036 PEMRSETWINDOWORGEX lpRecord
; /* Seems to be the closest thing */
2037 size_t uRecord
= sizeof(*lpRecord
);
2039 EMF_ReAllocAndAdjustPointers(PEMRSETWINDOWORGEX
,uRecord
);
2041 lpRecord
->emr
.iType
= EMR_SETWINDOWORGEX
;
2042 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
2044 lpRecord
->ptlOrigin
.x
= lpMetaRecord
->rdParm
[1];
2045 lpRecord
->ptlOrigin
.y
= lpMetaRecord
->rdParm
[0];
2050 case META_SETWINDOWEXT
: /* Structure is the same for SETWINDOWEXT & SETVIEWPORTEXT */
2051 case META_SETVIEWPORTEXT
:
2053 PEMRSETWINDOWEXTEX lpRecord
;
2054 size_t uRecord
= sizeof(*lpRecord
);
2056 EMF_ReAllocAndAdjustPointers(PEMRSETWINDOWEXTEX
,uRecord
);
2058 if ( lpMetaRecord
->rdFunction
== META_SETWINDOWEXT
)
2060 lpRecord
->emr
.iType
= EMR_SETWINDOWORGEX
;
2064 lpRecord
->emr
.iType
= EMR_SETVIEWPORTEXTEX
;
2066 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
2068 lpRecord
->szlExtent
.cx
= lpMetaRecord
->rdParm
[1];
2069 lpRecord
->szlExtent
.cy
= lpMetaRecord
->rdParm
[0];
2074 case META_CREATEBRUSHINDIRECT
:
2076 PEMRCREATEBRUSHINDIRECT lpRecord
;
2077 size_t uRecord
= sizeof(*lpRecord
);
2079 EMF_ReAllocAndAdjustPointers(PEMRCREATEBRUSHINDIRECT
,uRecord
);
2081 lpRecord
->emr
.iType
= EMR_CREATEBRUSHINDIRECT
;
2082 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
2084 lpRecord
->ihBrush
= ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nHandles
;
2085 lpRecord
->lb
.lbStyle
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbStyle
;
2086 lpRecord
->lb
.lbColor
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbColor
;
2087 lpRecord
->lb
.lbHatch
= ((LPLOGBRUSH16
)lpMetaRecord
->rdParm
)->lbHatch
;
2089 ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nHandles
+= 1; /* New handle */
2097 PEMRLINETO lpRecord
;
2098 size_t uRecord
= sizeof(*lpRecord
);
2100 EMF_ReAllocAndAdjustPointers(PEMRLINETO
,uRecord
);
2102 if ( lpMetaRecord
->rdFunction
== META_LINETO
)
2104 lpRecord
->emr
.iType
= EMR_LINETO
;
2108 lpRecord
->emr
.iType
= EMR_MOVETOEX
;
2110 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
2112 lpRecord
->ptl
.x
= lpMetaRecord
->rdParm
[1];
2113 lpRecord
->ptl
.y
= lpMetaRecord
->rdParm
[0];
2118 case META_SETTEXTCOLOR
:
2119 case META_SETBKCOLOR
:
2121 PEMRSETBKCOLOR lpRecord
;
2122 size_t uRecord
= sizeof(*lpRecord
);
2124 EMF_ReAllocAndAdjustPointers(PEMRSETBKCOLOR
,uRecord
);
2126 if ( lpMetaRecord
->rdFunction
== META_SETTEXTCOLOR
)
2128 lpRecord
->emr
.iType
= EMR_SETTEXTCOLOR
;
2132 lpRecord
->emr
.iType
= EMR_SETBKCOLOR
;
2134 lpRecord
->emr
.nSize
= sizeof( *lpRecord
);
2136 lpRecord
->crColor
= MAKELONG(lpMetaRecord
->rdParm
[0],
2137 lpMetaRecord
->rdParm
[1]);
2144 /* These are all unimplemented and as such are intended to fall through to the default case */
2145 case META_SETBKMODE
:
2147 case META_SETRELABS
:
2148 case META_SETSTRETCHBLTMODE
:
2149 case META_SETVIEWPORTORG
:
2150 case META_OFFSETWINDOWORG
:
2151 case META_SCALEWINDOWEXT
:
2152 case META_OFFSETVIEWPORTORG
:
2153 case META_SCALEVIEWPORTEXT
:
2154 case META_EXCLUDECLIPRECT
:
2155 case META_INTERSECTCLIPRECT
:
2158 case META_FLOODFILL
:
2160 case META_RECTANGLE
:
2161 case META_ROUNDRECT
:
2165 case META_OFFSETCLIPRGN
:
2167 case META_POLYPOLYGON
:
2169 case META_RESTOREDC
:
2171 case META_CREATEPATTERNBRUSH
:
2172 case META_CREATEPENINDIRECT
:
2173 case META_CREATEFONTINDIRECT
:
2174 case META_CREATEPALETTE
:
2175 case META_SETTEXTALIGN
:
2176 case META_SELECTPALETTE
:
2177 case META_SETMAPPERFLAGS
:
2178 case META_REALIZEPALETTE
:
2180 case META_EXTTEXTOUT
:
2181 case META_STRETCHDIB
:
2182 case META_DIBSTRETCHBLT
:
2183 case META_STRETCHBLT
:
2185 case META_CREATEREGION
:
2186 case META_FILLREGION
:
2187 case META_FRAMEREGION
:
2188 case META_INVERTREGION
:
2189 case META_PAINTREGION
:
2190 case META_SELECTCLIPREGION
:
2191 case META_DIBCREATEPATTERNBRUSH
:
2192 case META_DIBBITBLT
:
2193 case META_SETTEXTCHAREXTRA
:
2194 case META_SETTEXTJUSTIFICATION
:
2195 case META_EXTFLOODFILL
:
2196 case META_SETDIBTODEV
:
2198 case META_ANIMATEPALETTE
:
2199 case META_SETPALENTRIES
:
2200 case META_RESIZEPALETTE
:
2203 case META_STARTPAGE
:
2207 case META_CREATEBRUSH
:
2208 case META_CREATEBITMAPINDIRECT
:
2209 case META_CREATEBITMAP
:
2210 /* Fall through to unimplemented */
2213 /* Not implemented yet */
2214 FIXME( "Conversion of record type 0x%x not implemented.\n", lpMetaRecord
->rdFunction
);
2219 /* Move to the next record */
2220 (char*)lpbBuffer
+= ((LPMETARECORD
)lpbBuffer
)->rdSize
* 2; /* FIXME: Seem to be doing this in metafile.c */
2222 #undef ReAllocAndAdjustPointers
2225 /* We know the last of the header information now */
2226 ((LPENHMETAHEADER
)lpNewEnhMetaFileBuffer
)->nBytes
= uNewEnhMetaFileBufferSize
;
2228 /* Create the enhanced metafile */
2229 hMf
= SetEnhMetaFileBits( uNewEnhMetaFileBufferSize
, (const BYTE
*)lpNewEnhMetaFileBuffer
);
2232 ERR( "Problem creating metafile. Did the conversion fail somewhere?\n" );
2237 /* Free the data associated with our copy since it's been copied */
2238 HeapFree( GetProcessHeap(), 0, lpNewEnhMetaFileBuffer
);