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.
40 #include "wine/debug.h"
43 WINE_DEFAULT_DEBUG_CHANNEL(enhmetafile);
49 BOOL on_disk; /* true if metafile is on disk */
53 /****************************************************************************
54 * EMF_Create_HENHMETAFILE
56 HENHMETAFILE EMF_Create_HENHMETAFILE(ENHMETAHEADER *emh, BOOL on_disk )
59 ENHMETAFILEOBJ *metaObj = GDI_AllocObject( sizeof(ENHMETAFILEOBJ),
60 ENHMETAFILE_MAGIC, &hmf );
64 metaObj->on_disk = on_disk;
65 GDI_ReleaseObj( hmf );
70 /****************************************************************************
71 * EMF_Delete_HENHMETAFILE
73 static BOOL EMF_Delete_HENHMETAFILE( HENHMETAFILE hmf )
75 ENHMETAFILEOBJ *metaObj = (ENHMETAFILEOBJ *)GDI_GetObjPtr( hmf,
77 if(!metaObj) return FALSE;
80 UnmapViewOfFile( metaObj->emh );
82 HeapFree( GetProcessHeap(), 0, metaObj->emh );
83 return GDI_FreeObject( hmf, metaObj );
86 /******************************************************************
87 * EMF_GetEnhMetaHeader
89 * Returns ptr to ENHMETAHEADER associated with HENHMETAFILE
91 static ENHMETAHEADER *EMF_GetEnhMetaHeader( HENHMETAFILE hmf )
93 ENHMETAHEADER *ret = NULL;
94 ENHMETAFILEOBJ *metaObj = (ENHMETAFILEOBJ *)GDI_GetObjPtr( hmf, ENHMETAFILE_MAGIC );
95 TRACE("hmf %04x -> enhmetaObj %p\n", hmf, metaObj);
99 GDI_ReleaseObj( hmf );
104 /*****************************************************************************
108 static HENHMETAFILE EMF_GetEnhMetaFile( HANDLE hFile )
113 hMapping = CreateFileMappingA( hFile, NULL, PAGE_READONLY, 0, 0, NULL );
114 emh = MapViewOfFile( hMapping, FILE_MAP_READ, 0, 0, 0 );
115 CloseHandle( hMapping );
119 if (emh->iType != EMR_HEADER || emh->dSignature != ENHMETA_SIGNATURE) {
120 WARN("Invalid emf header type 0x%08lx sig 0x%08lx.\n",
121 emh->iType, emh->dSignature);
122 UnmapViewOfFile( emh );
125 return EMF_Create_HENHMETAFILE( emh, TRUE );
129 /*****************************************************************************
130 * GetEnhMetaFileA (GDI32.@)
134 HENHMETAFILE WINAPI GetEnhMetaFileA(
135 LPCSTR lpszMetaFile /* [in] filename of enhanced metafile */
141 hFile = CreateFileA(lpszMetaFile, GENERIC_READ, FILE_SHARE_READ, 0,
142 OPEN_EXISTING, 0, 0);
143 if (hFile == INVALID_HANDLE_VALUE) {
144 WARN("could not open %s\n", lpszMetaFile);
147 hmf = EMF_GetEnhMetaFile( hFile );
148 CloseHandle( hFile );
152 /*****************************************************************************
153 * GetEnhMetaFileW (GDI32.@)
155 HENHMETAFILE WINAPI GetEnhMetaFileW(
156 LPCWSTR lpszMetaFile) /* [in] filename of enhanced metafile */
161 hFile = CreateFileW(lpszMetaFile, GENERIC_READ, FILE_SHARE_READ, 0,
162 OPEN_EXISTING, 0, 0);
163 if (hFile == INVALID_HANDLE_VALUE) {
164 WARN("could not open %s\n", debugstr_w(lpszMetaFile));
167 hmf = EMF_GetEnhMetaFile( hFile );
168 CloseHandle( hFile );
172 /*****************************************************************************
173 * GetEnhMetaFileHeader (GDI32.@)
175 * If buf is NULL, returns the size of buffer required.
176 * Otherwise, copy up to bufsize bytes of enhanced metafile header into
179 UINT WINAPI GetEnhMetaFileHeader(
180 HENHMETAFILE hmf, /* [in] enhanced metafile */
181 UINT bufsize, /* [in] size of buffer */
182 LPENHMETAHEADER buf /* [out] buffer */
188 emh = EMF_GetEnhMetaHeader(hmf);
189 if(!emh) return FALSE;
191 if (!buf) return size;
192 size = min(size, bufsize);
193 memmove(buf, emh, size);
198 /*****************************************************************************
199 * GetEnhMetaFileDescriptionA (GDI32.@)
201 UINT WINAPI GetEnhMetaFileDescriptionA(
202 HENHMETAFILE hmf, /* [in] enhanced metafile */
203 UINT size, /* [in] size of buf */
204 LPSTR buf /* [out] buffer to receive description */
207 LPENHMETAHEADER emh = EMF_GetEnhMetaHeader(hmf);
211 if(!emh) return FALSE;
212 if(emh->nDescription == 0 || emh->offDescription == 0) return 0;
213 descrW = (WCHAR *) ((char *) emh + emh->offDescription);
214 len = WideCharToMultiByte( CP_ACP, 0, descrW, emh->nDescription, NULL, 0, NULL, NULL );
216 if (!buf || !size ) return len;
218 len = min( size, len );
219 WideCharToMultiByte( CP_ACP, 0, descrW, emh->nDescription, buf, len, NULL, NULL );
223 /*****************************************************************************
224 * GetEnhMetaFileDescriptionW (GDI32.@)
226 * Copies the description string of an enhanced metafile into a buffer
229 * If _buf_ is NULL, returns size of _buf_ required. Otherwise, returns
230 * number of characters copied.
232 UINT WINAPI GetEnhMetaFileDescriptionW(
233 HENHMETAFILE hmf, /* [in] enhanced metafile */
234 UINT size, /* [in] size of buf */
235 LPWSTR buf /* [out] buffer to receive description */
238 LPENHMETAHEADER emh = EMF_GetEnhMetaHeader(hmf);
240 if(!emh) return FALSE;
241 if(emh->nDescription == 0 || emh->offDescription == 0) return 0;
242 if (!buf || !size ) return emh->nDescription;
244 memmove(buf, (char *) emh + emh->offDescription, min(size,emh->nDescription)*sizeof(WCHAR));
245 return min(size, emh->nDescription);
248 /****************************************************************************
249 * SetEnhMetaFileBits (GDI32.@)
251 * Creates an enhanced metafile by copying _bufsize_ bytes from _buf_.
253 HENHMETAFILE WINAPI SetEnhMetaFileBits(UINT bufsize, const BYTE *buf)
255 ENHMETAHEADER *emh = HeapAlloc( GetProcessHeap(), 0, bufsize );
256 memmove(emh, buf, bufsize);
257 return EMF_Create_HENHMETAFILE( emh, FALSE );
260 /*****************************************************************************
261 * GetEnhMetaFileBits (GDI32.@)
264 UINT WINAPI GetEnhMetaFileBits(
270 LPENHMETAHEADER emh = EMF_GetEnhMetaHeader( hmf );
276 if( buf == NULL ) return size;
278 size = min( size, bufsize );
279 memmove(buf, emh, size);
283 /*****************************************************************************
284 * PlayEnhMetaFileRecord (GDI32.@)
286 * Render a single enhanced metafile record in the device context hdc.
289 * TRUE (non zero) on success, FALSE on error.
291 * Many unimplemented records.
292 * No error handling on record play failures (ie checking return codes)
294 BOOL WINAPI PlayEnhMetaFileRecord(
295 HDC hdc, /* [in] device context in which to render EMF record */
296 LPHANDLETABLE handletable, /* [in] array of handles to be used in rendering record */
297 const ENHMETARECORD *mr, /* [in] EMF record to render */
298 UINT handles /* [in] size of handle array */
303 "hdc = %08x, handletable = %p, record = %p, numHandles = %d\n",
304 hdc, handletable, mr, handles);
305 if (!mr) return FALSE;
309 TRACE(" type=%d\n", type);
318 PEMRGDICOMMENT lpGdiComment = (PEMRGDICOMMENT)mr;
319 /* In an enhanced metafile, there can be both public and private GDI comments */
320 GdiComment( hdc, lpGdiComment->cbData, lpGdiComment->Data );
325 PEMRSETMAPMODE pSetMapMode = (PEMRSETMAPMODE) mr;
326 SetMapMode(hdc, pSetMapMode->iMode);
331 PEMRSETBKMODE pSetBkMode = (PEMRSETBKMODE) mr;
332 SetBkMode(hdc, pSetBkMode->iMode);
337 PEMRSETBKCOLOR pSetBkColor = (PEMRSETBKCOLOR) mr;
338 SetBkColor(hdc, pSetBkColor->crColor);
341 case EMR_SETPOLYFILLMODE:
343 PEMRSETPOLYFILLMODE pSetPolyFillMode = (PEMRSETPOLYFILLMODE) mr;
344 SetPolyFillMode(hdc, pSetPolyFillMode->iMode);
349 PEMRSETROP2 pSetROP2 = (PEMRSETROP2) mr;
350 SetROP2(hdc, pSetROP2->iMode);
353 case EMR_SETSTRETCHBLTMODE:
355 PEMRSETSTRETCHBLTMODE pSetStretchBltMode = (PEMRSETSTRETCHBLTMODE) mr;
356 SetStretchBltMode(hdc, pSetStretchBltMode->iMode);
359 case EMR_SETTEXTALIGN:
361 PEMRSETTEXTALIGN pSetTextAlign = (PEMRSETTEXTALIGN) mr;
362 SetTextAlign(hdc, pSetTextAlign->iMode);
365 case EMR_SETTEXTCOLOR:
367 PEMRSETTEXTCOLOR pSetTextColor = (PEMRSETTEXTCOLOR) mr;
368 SetTextColor(hdc, pSetTextColor->crColor);
378 PEMRRESTOREDC pRestoreDC = (PEMRRESTOREDC) mr;
379 RestoreDC(hdc, pRestoreDC->iRelative);
382 case EMR_INTERSECTCLIPRECT:
384 PEMRINTERSECTCLIPRECT pClipRect = (PEMRINTERSECTCLIPRECT) mr;
385 IntersectClipRect(hdc, pClipRect->rclClip.left, pClipRect->rclClip.top,
386 pClipRect->rclClip.right, pClipRect->rclClip.bottom);
389 case EMR_SELECTOBJECT:
391 PEMRSELECTOBJECT pSelectObject = (PEMRSELECTOBJECT) mr;
392 if( pSelectObject->ihObject & 0x80000000 ) {
393 /* High order bit is set - it's a stock object
394 * Strip the high bit to get the index.
395 * See MSDN article Q142319
397 SelectObject( hdc, GetStockObject( pSelectObject->ihObject &
400 /* High order bit wasn't set - not a stock object
403 (handletable->objectHandle)[pSelectObject->ihObject] );
407 case EMR_DELETEOBJECT:
409 PEMRDELETEOBJECT pDeleteObject = (PEMRDELETEOBJECT) mr;
410 DeleteObject( (handletable->objectHandle)[pDeleteObject->ihObject]);
411 (handletable->objectHandle)[pDeleteObject->ihObject] = 0;
414 case EMR_SETWINDOWORGEX:
417 * FIXME: The call to SetWindowOrgEx prevents EMFs from being scrolled
418 * by an application. This is very BAD!!!
421 PEMRSETWINDOWORGEX pSetWindowOrgEx = (PEMRSETWINDOWORGEX) mr;
422 SetWindowOrgEx(hdc, pSetWindowOrgEx->ptlOrigin.x,
423 pSetWindowOrgEx->ptlOrigin.y, NULL);
427 case EMR_SETWINDOWEXTEX:
429 PEMRSETWINDOWEXTEX pSetWindowExtEx = (PEMRSETWINDOWEXTEX) mr;
430 SetWindowExtEx(hdc, pSetWindowExtEx->szlExtent.cx,
431 pSetWindowExtEx->szlExtent.cy, NULL);
434 case EMR_SETVIEWPORTORGEX:
436 PEMRSETVIEWPORTORGEX pSetViewportOrgEx = (PEMRSETVIEWPORTORGEX) mr;
437 SetViewportOrgEx(hdc, pSetViewportOrgEx->ptlOrigin.x,
438 pSetViewportOrgEx->ptlOrigin.y, NULL);
441 case EMR_SETVIEWPORTEXTEX:
443 PEMRSETVIEWPORTEXTEX pSetViewportExtEx = (PEMRSETVIEWPORTEXTEX) mr;
444 SetViewportExtEx(hdc, pSetViewportExtEx->szlExtent.cx,
445 pSetViewportExtEx->szlExtent.cy, NULL);
450 PEMRCREATEPEN pCreatePen = (PEMRCREATEPEN) mr;
451 (handletable->objectHandle)[pCreatePen->ihPen] =
452 CreatePenIndirect(&pCreatePen->lopn);
455 case EMR_EXTCREATEPEN:
457 PEMREXTCREATEPEN pPen = (PEMREXTCREATEPEN) mr;
459 lb.lbStyle = pPen->elp.elpBrushStyle;
460 lb.lbColor = pPen->elp.elpColor;
461 lb.lbHatch = pPen->elp.elpHatch;
463 if(pPen->offBmi || pPen->offBits)
464 FIXME("EMR_EXTCREATEPEN: Need to copy brush bitmap\n");
466 (handletable->objectHandle)[pPen->ihPen] =
467 ExtCreatePen(pPen->elp.elpPenStyle, pPen->elp.elpWidth, &lb,
468 pPen->elp.elpNumEntries, pPen->elp.elpStyleEntry);
471 case EMR_CREATEBRUSHINDIRECT:
473 PEMRCREATEBRUSHINDIRECT pBrush = (PEMRCREATEBRUSHINDIRECT) mr;
474 (handletable->objectHandle)[pBrush->ihBrush] =
475 CreateBrushIndirect(&pBrush->lb);
478 case EMR_EXTCREATEFONTINDIRECTW:
480 PEMREXTCREATEFONTINDIRECTW pFont = (PEMREXTCREATEFONTINDIRECTW) mr;
481 (handletable->objectHandle)[pFont->ihFont] =
482 CreateFontIndirectW(&pFont->elfw.elfLogFont);
487 PEMRMOVETOEX pMoveToEx = (PEMRMOVETOEX) mr;
488 MoveToEx(hdc, pMoveToEx->ptl.x, pMoveToEx->ptl.y, NULL);
493 PEMRLINETO pLineTo = (PEMRLINETO) mr;
494 LineTo(hdc, pLineTo->ptl.x, pLineTo->ptl.y);
499 PEMRRECTANGLE pRect = (PEMRRECTANGLE) mr;
500 Rectangle(hdc, pRect->rclBox.left, pRect->rclBox.top,
501 pRect->rclBox.right, pRect->rclBox.bottom);
506 PEMRELLIPSE pEllipse = (PEMRELLIPSE) mr;
507 Ellipse(hdc, pEllipse->rclBox.left, pEllipse->rclBox.top,
508 pEllipse->rclBox.right, pEllipse->rclBox.bottom);
513 PEMRPOLYGON16 pPoly = (PEMRPOLYGON16) mr;
514 /* Shouldn't use Polygon16 since pPoly->cpts is DWORD */
515 POINT *pts = HeapAlloc( GetProcessHeap(), 0,
516 pPoly->cpts * sizeof(POINT) );
518 for(i = 0; i < pPoly->cpts; i++)
519 CONV_POINT16TO32(pPoly->apts + i, pts + i);
520 Polygon(hdc, pts, pPoly->cpts);
521 HeapFree( GetProcessHeap(), 0, pts );
526 PEMRPOLYLINE16 pPoly = (PEMRPOLYLINE16) mr;
527 /* Shouldn't use Polyline16 since pPoly->cpts is DWORD */
528 POINT *pts = HeapAlloc( GetProcessHeap(), 0,
529 pPoly->cpts * sizeof(POINT) );
531 for(i = 0; i < pPoly->cpts; i++)
532 CONV_POINT16TO32(pPoly->apts + i, pts + i);
533 Polyline(hdc, pts, pPoly->cpts);
534 HeapFree( GetProcessHeap(), 0, pts );
537 case EMR_POLYLINETO16:
539 PEMRPOLYLINETO16 pPoly = (PEMRPOLYLINETO16) mr;
540 /* Shouldn't use PolylineTo16 since pPoly->cpts is DWORD */
541 POINT *pts = HeapAlloc( GetProcessHeap(), 0,
542 pPoly->cpts * sizeof(POINT) );
544 for(i = 0; i < pPoly->cpts; i++)
545 CONV_POINT16TO32(pPoly->apts + i, pts + i);
546 PolylineTo(hdc, pts, pPoly->cpts);
547 HeapFree( GetProcessHeap(), 0, pts );
550 case EMR_POLYBEZIER16:
552 PEMRPOLYBEZIER16 pPoly = (PEMRPOLYBEZIER16) mr;
553 /* Shouldn't use PolyBezier16 since pPoly->cpts is DWORD */
554 POINT *pts = HeapAlloc( GetProcessHeap(), 0,
555 pPoly->cpts * sizeof(POINT) );
557 for(i = 0; i < pPoly->cpts; i++)
558 CONV_POINT16TO32(pPoly->apts + i, pts + i);
559 PolyBezier(hdc, pts, pPoly->cpts);
560 HeapFree( GetProcessHeap(), 0, pts );
563 case EMR_POLYBEZIERTO16:
565 PEMRPOLYBEZIERTO16 pPoly = (PEMRPOLYBEZIERTO16) mr;
566 /* Shouldn't use PolyBezierTo16 since pPoly->cpts is DWORD */
567 POINT *pts = HeapAlloc( GetProcessHeap(), 0,
568 pPoly->cpts * sizeof(POINT) );
570 for(i = 0; i < pPoly->cpts; i++)
571 CONV_POINT16TO32(pPoly->apts + i, pts + i);
572 PolyBezierTo(hdc, pts, pPoly->cpts);
573 HeapFree( GetProcessHeap(), 0, pts );
576 case EMR_POLYPOLYGON16:
578 PEMRPOLYPOLYGON16 pPolyPoly = (PEMRPOLYPOLYGON16) mr;
579 /* NB POINTS array doesn't start at pPolyPoly->apts it's actually
580 pPolyPoly->aPolyCounts + pPolyPoly->nPolys */
582 POINT *pts = HeapAlloc( GetProcessHeap(), 0,
583 pPolyPoly->cpts * sizeof(POINT) );
585 for(i = 0; i < pPolyPoly->cpts; i++)
586 CONV_POINT16TO32((POINT16*) (pPolyPoly->aPolyCounts +
587 pPolyPoly->nPolys) + i, pts + i);
589 PolyPolygon(hdc, pts, (INT*)pPolyPoly->aPolyCounts, pPolyPoly->nPolys);
590 HeapFree( GetProcessHeap(), 0, pts );
593 case EMR_POLYPOLYLINE16:
595 PEMRPOLYPOLYLINE16 pPolyPoly = (PEMRPOLYPOLYLINE16) mr;
596 /* NB POINTS array doesn't start at pPolyPoly->apts it's actually
597 pPolyPoly->aPolyCounts + pPolyPoly->nPolys */
599 POINT *pts = HeapAlloc( GetProcessHeap(), 0,
600 pPolyPoly->cpts * sizeof(POINT) );
602 for(i = 0; i < pPolyPoly->cpts; i++)
603 CONV_POINT16TO32((POINT16*) (pPolyPoly->aPolyCounts +
604 pPolyPoly->nPolys) + i, pts + i);
606 PolyPolyline(hdc, pts, pPolyPoly->aPolyCounts, pPolyPoly->nPolys);
607 HeapFree( GetProcessHeap(), 0, pts );
611 case EMR_STRETCHDIBITS:
613 EMRSTRETCHDIBITS *pStretchDIBits = (EMRSTRETCHDIBITS *)mr;
616 pStretchDIBits->xDest,
617 pStretchDIBits->yDest,
618 pStretchDIBits->cxDest,
619 pStretchDIBits->cyDest,
620 pStretchDIBits->xSrc,
621 pStretchDIBits->ySrc,
622 pStretchDIBits->cxSrc,
623 pStretchDIBits->cySrc,
624 (BYTE *)mr + pStretchDIBits->offBitsSrc,
625 (const BITMAPINFO *)((BYTE *)mr + pStretchDIBits->offBmiSrc),
626 pStretchDIBits->iUsageSrc,
627 pStretchDIBits->dwRop);
631 case EMR_EXTTEXTOUTA:
633 PEMREXTTEXTOUTA pExtTextOutA = (PEMREXTTEXTOUTA)mr;
636 rc.left = pExtTextOutA->emrtext.rcl.left;
637 rc.top = pExtTextOutA->emrtext.rcl.top;
638 rc.right = pExtTextOutA->emrtext.rcl.right;
639 rc.bottom = pExtTextOutA->emrtext.rcl.bottom;
640 ExtTextOutA(hdc, pExtTextOutA->emrtext.ptlReference.x, pExtTextOutA->emrtext.ptlReference.y,
641 pExtTextOutA->emrtext.fOptions, &rc,
642 (LPSTR)((BYTE *)mr + pExtTextOutA->emrtext.offString), pExtTextOutA->emrtext.nChars,
643 (INT *)((BYTE *)mr + pExtTextOutA->emrtext.offDx));
647 case EMR_EXTTEXTOUTW:
649 PEMREXTTEXTOUTW pExtTextOutW = (PEMREXTTEXTOUTW)mr;
652 rc.left = pExtTextOutW->emrtext.rcl.left;
653 rc.top = pExtTextOutW->emrtext.rcl.top;
654 rc.right = pExtTextOutW->emrtext.rcl.right;
655 rc.bottom = pExtTextOutW->emrtext.rcl.bottom;
656 ExtTextOutW(hdc, pExtTextOutW->emrtext.ptlReference.x, pExtTextOutW->emrtext.ptlReference.y,
657 pExtTextOutW->emrtext.fOptions, &rc,
658 (LPWSTR)((BYTE *)mr + pExtTextOutW->emrtext.offString), pExtTextOutW->emrtext.nChars,
659 (INT *)((BYTE *)mr + pExtTextOutW->emrtext.offDx));
663 case EMR_CREATEPALETTE:
665 PEMRCREATEPALETTE lpCreatePal = (PEMRCREATEPALETTE)mr;
667 (handletable->objectHandle)[ lpCreatePal->ihPal ] =
668 CreatePalette( &lpCreatePal->lgpl );
673 case EMR_SELECTPALETTE:
675 PEMRSELECTPALETTE lpSelectPal = (PEMRSELECTPALETTE)mr;
677 if( lpSelectPal->ihPal & 0x80000000 ) {
678 SelectPalette( hdc, GetStockObject(lpSelectPal->ihPal & 0x7fffffff), TRUE);
680 (handletable->objectHandle)[ lpSelectPal->ihPal ] =
681 SelectPalette( hdc, (handletable->objectHandle)[lpSelectPal->ihPal], TRUE);
686 case EMR_REALIZEPALETTE:
688 RealizePalette( hdc );
692 case EMR_EXTSELECTCLIPRGN:
694 PEMREXTSELECTCLIPRGN lpRgn = (PEMREXTSELECTCLIPRGN)mr;
695 HRGN hRgn = ExtCreateRegion(NULL, lpRgn->cbRgnData, (RGNDATA *)lpRgn->RgnData);
696 ExtSelectClipRgn(hdc, hRgn, (INT)(lpRgn->iMode));
697 /* ExtSelectClipRgn created a copy of the region */
708 case EMR_SETWORLDTRANSFORM:
710 PEMRSETWORLDTRANSFORM lpXfrm = (PEMRSETWORLDTRANSFORM)mr;
711 SetWorldTransform( hdc, &lpXfrm->xform );
717 PEMRPOLYBEZIER lpPolyBez = (PEMRPOLYBEZIER)mr;
718 PolyBezier(hdc, (const LPPOINT)lpPolyBez->aptl, (UINT)lpPolyBez->cptl);
724 PEMRPOLYGON lpPoly = (PEMRPOLYGON)mr;
725 Polygon( hdc, (const LPPOINT)lpPoly->aptl, (UINT)lpPoly->cptl );
731 PEMRPOLYLINE lpPolyLine = (PEMRPOLYLINE)mr;
732 Polyline(hdc, (const LPPOINT)lpPolyLine->aptl, (UINT)lpPolyLine->cptl);
736 case EMR_POLYBEZIERTO:
738 PEMRPOLYBEZIERTO lpPolyBezierTo = (PEMRPOLYBEZIERTO)mr;
739 PolyBezierTo( hdc, (const LPPOINT)lpPolyBezierTo->aptl,
740 (UINT)lpPolyBezierTo->cptl );
746 PEMRPOLYLINETO lpPolyLineTo = (PEMRPOLYLINETO)mr;
747 PolylineTo( hdc, (const LPPOINT)lpPolyLineTo->aptl,
748 (UINT)lpPolyLineTo->cptl );
752 case EMR_POLYPOLYLINE:
754 PEMRPOLYPOLYLINE pPolyPolyline = (PEMRPOLYPOLYLINE) mr;
755 /* NB Points at pPolyPolyline->aPolyCounts + pPolyPolyline->nPolys */
757 PolyPolyline(hdc, (LPPOINT)(pPolyPolyline->aPolyCounts +
758 pPolyPolyline->nPolys),
759 pPolyPolyline->aPolyCounts,
760 pPolyPolyline->nPolys );
765 case EMR_POLYPOLYGON:
767 PEMRPOLYPOLYGON pPolyPolygon = (PEMRPOLYPOLYGON) mr;
769 /* NB Points at pPolyPolygon->aPolyCounts + pPolyPolygon->nPolys */
771 PolyPolygon(hdc, (LPPOINT)(pPolyPolygon->aPolyCounts +
772 pPolyPolygon->nPolys),
773 (INT*)pPolyPolygon->aPolyCounts, pPolyPolygon->nPolys );
777 case EMR_SETBRUSHORGEX:
779 PEMRSETBRUSHORGEX lpSetBrushOrgEx = (PEMRSETBRUSHORGEX)mr;
782 (INT)lpSetBrushOrgEx->ptlOrigin.x,
783 (INT)lpSetBrushOrgEx->ptlOrigin.y,
791 PEMRSETPIXELV lpSetPixelV = (PEMRSETPIXELV)mr;
794 (INT)lpSetPixelV->ptlPixel.x,
795 (INT)lpSetPixelV->ptlPixel.y,
796 lpSetPixelV->crColor );
801 case EMR_SETMAPPERFLAGS:
803 PEMRSETMAPPERFLAGS lpSetMapperFlags = (PEMRSETMAPPERFLAGS)mr;
805 SetMapperFlags( hdc, lpSetMapperFlags->dwFlags );
810 case EMR_SETCOLORADJUSTMENT:
812 PEMRSETCOLORADJUSTMENT lpSetColorAdjust = (PEMRSETCOLORADJUSTMENT)mr;
814 SetColorAdjustment( hdc, &lpSetColorAdjust->ColorAdjustment );
819 case EMR_OFFSETCLIPRGN:
821 PEMROFFSETCLIPRGN lpOffsetClipRgn = (PEMROFFSETCLIPRGN)mr;
824 (INT)lpOffsetClipRgn->ptlOffset.x,
825 (INT)lpOffsetClipRgn->ptlOffset.y );
830 case EMR_EXCLUDECLIPRECT:
832 PEMREXCLUDECLIPRECT lpExcludeClipRect = (PEMREXCLUDECLIPRECT)mr;
834 ExcludeClipRect( hdc,
835 lpExcludeClipRect->rclClip.left,
836 lpExcludeClipRect->rclClip.top,
837 lpExcludeClipRect->rclClip.right,
838 lpExcludeClipRect->rclClip.bottom );
843 case EMR_SCALEVIEWPORTEXTEX:
845 PEMRSCALEVIEWPORTEXTEX lpScaleViewportExtEx = (PEMRSCALEVIEWPORTEXTEX)mr;
847 ScaleViewportExtEx( hdc,
848 lpScaleViewportExtEx->xNum,
849 lpScaleViewportExtEx->xDenom,
850 lpScaleViewportExtEx->yNum,
851 lpScaleViewportExtEx->yDenom,
857 case EMR_SCALEWINDOWEXTEX:
859 PEMRSCALEWINDOWEXTEX lpScaleWindowExtEx = (PEMRSCALEWINDOWEXTEX)mr;
861 ScaleWindowExtEx( hdc,
862 lpScaleWindowExtEx->xNum,
863 lpScaleWindowExtEx->xDenom,
864 lpScaleWindowExtEx->yNum,
865 lpScaleWindowExtEx->yDenom,
871 case EMR_MODIFYWORLDTRANSFORM:
873 PEMRMODIFYWORLDTRANSFORM lpModifyWorldTrans = (PEMRMODIFYWORLDTRANSFORM)mr;
875 ModifyWorldTransform( hdc, &lpModifyWorldTrans->xform,
876 lpModifyWorldTrans->iMode );
883 PEMRANGLEARC lpAngleArc = (PEMRANGLEARC)mr;
886 (INT)lpAngleArc->ptlCenter.x, (INT)lpAngleArc->ptlCenter.y,
887 lpAngleArc->nRadius, lpAngleArc->eStartAngle,
888 lpAngleArc->eSweepAngle );
895 PEMRROUNDRECT lpRoundRect = (PEMRROUNDRECT)mr;
898 lpRoundRect->rclBox.left,
899 lpRoundRect->rclBox.top,
900 lpRoundRect->rclBox.right,
901 lpRoundRect->rclBox.bottom,
902 lpRoundRect->szlCorner.cx,
903 lpRoundRect->szlCorner.cy );
910 PEMRARC lpArc = (PEMRARC)mr;
913 (INT)lpArc->rclBox.left,
914 (INT)lpArc->rclBox.top,
915 (INT)lpArc->rclBox.right,
916 (INT)lpArc->rclBox.bottom,
917 (INT)lpArc->ptlStart.x,
918 (INT)lpArc->ptlStart.y,
919 (INT)lpArc->ptlEnd.x,
920 (INT)lpArc->ptlEnd.y );
927 PEMRCHORD lpChord = (PEMRCHORD)mr;
930 (INT)lpChord->rclBox.left,
931 (INT)lpChord->rclBox.top,
932 (INT)lpChord->rclBox.right,
933 (INT)lpChord->rclBox.bottom,
934 (INT)lpChord->ptlStart.x,
935 (INT)lpChord->ptlStart.y,
936 (INT)lpChord->ptlEnd.x,
937 (INT)lpChord->ptlEnd.y );
944 PEMRPIE lpPie = (PEMRPIE)mr;
947 (INT)lpPie->rclBox.left,
948 (INT)lpPie->rclBox.top,
949 (INT)lpPie->rclBox.right,
950 (INT)lpPie->rclBox.bottom,
951 (INT)lpPie->ptlStart.x,
952 (INT)lpPie->ptlStart.y,
953 (INT)lpPie->ptlEnd.x,
954 (INT)lpPie->ptlEnd.y );
961 PEMRARC lpArcTo = (PEMRARC)mr;
964 (INT)lpArcTo->rclBox.left,
965 (INT)lpArcTo->rclBox.top,
966 (INT)lpArcTo->rclBox.right,
967 (INT)lpArcTo->rclBox.bottom,
968 (INT)lpArcTo->ptlStart.x,
969 (INT)lpArcTo->ptlStart.y,
970 (INT)lpArcTo->ptlEnd.x,
971 (INT)lpArcTo->ptlEnd.y );
976 case EMR_EXTFLOODFILL:
978 PEMREXTFLOODFILL lpExtFloodFill = (PEMREXTFLOODFILL)mr;
981 (INT)lpExtFloodFill->ptlStart.x,
982 (INT)lpExtFloodFill->ptlStart.y,
983 lpExtFloodFill->crColor,
984 (UINT)lpExtFloodFill->iMode );
991 PEMRPOLYDRAW lpPolyDraw = (PEMRPOLYDRAW)mr;
993 (const LPPOINT)lpPolyDraw->aptl,
995 (INT)lpPolyDraw->cptl );
1000 case EMR_SETARCDIRECTION:
1002 PEMRSETARCDIRECTION lpSetArcDirection = (PEMRSETARCDIRECTION)mr;
1003 SetArcDirection( hdc, (INT)lpSetArcDirection->iArcDirection );
1007 case EMR_SETMITERLIMIT:
1009 PEMRSETMITERLIMIT lpSetMiterLimit = (PEMRSETMITERLIMIT)mr;
1010 SetMiterLimit( hdc, lpSetMiterLimit->eMiterLimit, NULL );
1026 case EMR_CLOSEFIGURE:
1034 /*PEMRFILLPATH lpFillPath = (PEMRFILLPATH)mr;*/
1039 case EMR_STROKEANDFILLPATH:
1041 /*PEMRSTROKEANDFILLPATH lpStrokeAndFillPath = (PEMRSTROKEANDFILLPATH)mr;*/
1042 StrokeAndFillPath( hdc );
1046 case EMR_STROKEPATH:
1048 /*PEMRSTROKEPATH lpStrokePath = (PEMRSTROKEPATH)mr;*/
1053 case EMR_FLATTENPATH:
1065 case EMR_SELECTCLIPPATH:
1067 PEMRSELECTCLIPPATH lpSelectClipPath = (PEMRSELECTCLIPPATH)mr;
1068 SelectClipPath( hdc, (INT)lpSelectClipPath->iMode );
1078 case EMR_CREATECOLORSPACE:
1080 PEMRCREATECOLORSPACE lpCreateColorSpace = (PEMRCREATECOLORSPACE)mr;
1081 (handletable->objectHandle)[lpCreateColorSpace->ihCS] =
1082 CreateColorSpaceA( &lpCreateColorSpace->lcs );
1086 case EMR_SETCOLORSPACE:
1088 PEMRSETCOLORSPACE lpSetColorSpace = (PEMRSETCOLORSPACE)mr;
1090 (handletable->objectHandle)[lpSetColorSpace->ihCS] );
1094 case EMR_DELETECOLORSPACE:
1096 PEMRDELETECOLORSPACE lpDeleteColorSpace = (PEMRDELETECOLORSPACE)mr;
1097 DeleteColorSpace( (handletable->objectHandle)[lpDeleteColorSpace->ihCS] );
1101 case EMR_SETICMMODE:
1103 PERMSETICMMODE lpSetICMMode = (PERMSETICMMODE)mr;
1104 SetICMMode( hdc, (INT)lpSetICMMode->iMode );
1108 case EMR_PIXELFORMAT:
1111 PEMRPIXELFORMAT lpPixelFormat = (PEMRPIXELFORMAT)mr;
1113 iPixelFormat = ChoosePixelFormat( hdc, &lpPixelFormat->pfd );
1114 SetPixelFormat( hdc, iPixelFormat, &lpPixelFormat->pfd );
1119 case EMR_SETPALETTEENTRIES:
1121 PEMRSETPALETTEENTRIES lpSetPaletteEntries = (PEMRSETPALETTEENTRIES)mr;
1123 SetPaletteEntries( (handletable->objectHandle)[lpSetPaletteEntries->ihPal],
1124 (UINT)lpSetPaletteEntries->iStart,
1125 (UINT)lpSetPaletteEntries->cEntries,
1126 lpSetPaletteEntries->aPalEntries );
1131 case EMR_RESIZEPALETTE:
1133 PEMRRESIZEPALETTE lpResizePalette = (PEMRRESIZEPALETTE)mr;
1135 ResizePalette( (handletable->objectHandle)[lpResizePalette->ihPal],
1136 (UINT)lpResizePalette->cEntries );
1141 case EMR_CREATEDIBPATTERNBRUSHPT:
1143 PEMRCREATEDIBPATTERNBRUSHPT lpCreate = (PEMRCREATEDIBPATTERNBRUSHPT)mr;
1145 /* This is a BITMAPINFO struct followed directly by bitmap bits */
1146 LPVOID lpPackedStruct = HeapAlloc( GetProcessHeap(),
1148 lpCreate->cbBmi + lpCreate->cbBits );
1149 /* Now pack this structure */
1150 memcpy( lpPackedStruct,
1151 ((BYTE*)lpCreate) + lpCreate->offBmi,
1153 memcpy( ((BYTE*)lpPackedStruct) + lpCreate->cbBmi,
1154 ((BYTE*)lpCreate) + lpCreate->offBits,
1157 (handletable->objectHandle)[lpCreate->ihBrush] =
1158 CreateDIBPatternBrushPt( lpPackedStruct,
1159 (UINT)lpCreate->iUsage );
1164 case EMR_CREATEMONOBRUSH:
1166 PEMRCREATEMONOBRUSH pCreateMonoBrush = (PEMRCREATEMONOBRUSH)mr;
1167 BITMAPINFO *pbi = (BITMAPINFO *)((BYTE *)mr + pCreateMonoBrush->offBmi);
1168 HBITMAP hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1169 (BYTE *)mr + pCreateMonoBrush->offBits, pbi, pCreateMonoBrush->iUsage);
1170 (handletable->objectHandle)[pCreateMonoBrush->ihBrush] = CreatePatternBrush(hBmp);
1171 /* CreatePatternBrush created a copy of the bitmap */
1178 PEMRBITBLT pBitBlt = (PEMRBITBLT)mr;
1179 HDC hdcSrc = CreateCompatibleDC(hdc);
1180 HBRUSH hBrush, hBrushOld;
1181 HBITMAP hBmp, hBmpOld;
1182 BITMAPINFO *pbi = (BITMAPINFO *)((BYTE *)mr + pBitBlt->offBmiSrc);
1184 SetWorldTransform(hdcSrc, &pBitBlt->xformSrc);
1186 hBrush = CreateSolidBrush(pBitBlt->crBkColorSrc);
1187 hBrushOld = SelectObject(hdcSrc, hBrush);
1188 PatBlt(hdcSrc, pBitBlt->rclBounds.left, pBitBlt->rclBounds.top,
1189 pBitBlt->rclBounds.right - pBitBlt->rclBounds.left,
1190 pBitBlt->rclBounds.bottom - pBitBlt->rclBounds.top, PATCOPY);
1191 SelectObject(hdcSrc, hBrushOld);
1192 DeleteObject(hBrush);
1194 hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1195 (BYTE *)mr + pBitBlt->offBitsSrc, pbi, pBitBlt->iUsageSrc);
1196 hBmpOld = SelectObject(hdcSrc, hBmp);
1206 SelectObject(hdcSrc, hBmpOld);
1212 case EMR_STRETCHBLT:
1214 PEMRSTRETCHBLT pStretchBlt= (PEMRSTRETCHBLT)mr;
1215 HDC hdcSrc = CreateCompatibleDC(hdc);
1216 HBRUSH hBrush, hBrushOld;
1217 HBITMAP hBmp, hBmpOld;
1218 BITMAPINFO *pbi = (BITMAPINFO *)((BYTE *)mr + pStretchBlt->offBmiSrc);
1220 SetWorldTransform(hdcSrc, &pStretchBlt->xformSrc);
1222 hBrush = CreateSolidBrush(pStretchBlt->crBkColorSrc);
1223 hBrushOld = SelectObject(hdcSrc, hBrush);
1224 PatBlt(hdcSrc, pStretchBlt->rclBounds.left, pStretchBlt->rclBounds.top,
1225 pStretchBlt->rclBounds.right - pStretchBlt->rclBounds.left,
1226 pStretchBlt->rclBounds.bottom - pStretchBlt->rclBounds.top, PATCOPY);
1227 SelectObject(hdcSrc, hBrushOld);
1228 DeleteObject(hBrush);
1230 hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1231 (BYTE *)mr + pStretchBlt->offBitsSrc, pbi, pStretchBlt->iUsageSrc);
1232 hBmpOld = SelectObject(hdcSrc, hBmp);
1236 pStretchBlt->cxDest,
1237 pStretchBlt->cyDest,
1243 pStretchBlt->dwRop);
1244 SelectObject(hdcSrc, hBmpOld);
1252 PEMRMASKBLT pMaskBlt= (PEMRMASKBLT)mr;
1253 HDC hdcSrc = CreateCompatibleDC(hdc);
1254 HBRUSH hBrush, hBrushOld;
1255 HBITMAP hBmp, hBmpOld, hBmpMask;
1258 SetWorldTransform(hdcSrc, &pMaskBlt->xformSrc);
1260 hBrush = CreateSolidBrush(pMaskBlt->crBkColorSrc);
1261 hBrushOld = SelectObject(hdcSrc, hBrush);
1262 PatBlt(hdcSrc, pMaskBlt->rclBounds.left, pMaskBlt->rclBounds.top,
1263 pMaskBlt->rclBounds.right - pMaskBlt->rclBounds.left,
1264 pMaskBlt->rclBounds.bottom - pMaskBlt->rclBounds.top, PATCOPY);
1265 SelectObject(hdcSrc, hBrushOld);
1266 DeleteObject(hBrush);
1268 pbi = (BITMAPINFO *)((BYTE *)mr + pMaskBlt->offBmiMask);
1269 hBmpMask = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1270 (BYTE *)mr + pMaskBlt->offBitsMask, pbi, pMaskBlt->iUsageMask);
1272 pbi = (BITMAPINFO *)((BYTE *)mr + pMaskBlt->offBmiSrc);
1273 hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1274 (BYTE *)mr + pMaskBlt->offBitsSrc, pbi, pMaskBlt->iUsageSrc);
1275 hBmpOld = SelectObject(hdcSrc, hBmp);
1288 SelectObject(hdcSrc, hBmpOld);
1290 DeleteObject(hBmpMask);
1297 PEMRPLGBLT pPlgBlt= (PEMRPLGBLT)mr;
1298 HDC hdcSrc = CreateCompatibleDC(hdc);
1299 HBRUSH hBrush, hBrushOld;
1300 HBITMAP hBmp, hBmpOld, hBmpMask;
1304 SetWorldTransform(hdcSrc, &pPlgBlt->xformSrc);
1306 pts[0].x = pPlgBlt->aptlDst[0].x; pts[0].y = pPlgBlt->aptlDst[0].y;
1307 pts[1].x = pPlgBlt->aptlDst[1].x; pts[1].y = pPlgBlt->aptlDst[1].y;
1308 pts[2].x = pPlgBlt->aptlDst[2].x; pts[2].y = pPlgBlt->aptlDst[2].y;
1310 hBrush = CreateSolidBrush(pPlgBlt->crBkColorSrc);
1311 hBrushOld = SelectObject(hdcSrc, hBrush);
1312 PatBlt(hdcSrc, pPlgBlt->rclBounds.left, pPlgBlt->rclBounds.top,
1313 pPlgBlt->rclBounds.right - pPlgBlt->rclBounds.left,
1314 pPlgBlt->rclBounds.bottom - pPlgBlt->rclBounds.top, PATCOPY);
1315 SelectObject(hdcSrc, hBrushOld);
1316 DeleteObject(hBrush);
1318 pbi = (BITMAPINFO *)((BYTE *)mr + pPlgBlt->offBmiMask);
1319 hBmpMask = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1320 (BYTE *)mr + pPlgBlt->offBitsMask, pbi, pPlgBlt->iUsageMask);
1322 pbi = (BITMAPINFO *)((BYTE *)mr + pPlgBlt->offBmiSrc);
1323 hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1324 (BYTE *)mr + pPlgBlt->offBitsSrc, pbi, pPlgBlt->iUsageSrc);
1325 hBmpOld = SelectObject(hdcSrc, hBmp);
1336 SelectObject(hdcSrc, hBmpOld);
1338 DeleteObject(hBmpMask);
1343 case EMR_SETDIBITSTODEVICE:
1345 PEMRSETDIBITSTODEVICE pSetDIBitsToDevice = (PEMRSETDIBITSTODEVICE)mr;
1347 SetDIBitsToDevice(hdc,
1348 pSetDIBitsToDevice->xDest,
1349 pSetDIBitsToDevice->yDest,
1350 pSetDIBitsToDevice->cxSrc,
1351 pSetDIBitsToDevice->cySrc,
1352 pSetDIBitsToDevice->xSrc,
1353 pSetDIBitsToDevice->ySrc,
1354 pSetDIBitsToDevice->iStartScan,
1355 pSetDIBitsToDevice->cScans,
1356 (BYTE *)mr + pSetDIBitsToDevice->offBitsSrc,
1357 (BITMAPINFO *)((BYTE *)mr + pSetDIBitsToDevice->offBmiSrc),
1358 pSetDIBitsToDevice->iUsageSrc);
1362 case EMR_POLYTEXTOUTA:
1364 PEMRPOLYTEXTOUTA pPolyTextOutA = (PEMRPOLYTEXTOUTA)mr;
1365 POLYTEXTA *polytextA = HeapAlloc(GetProcessHeap(), 0, pPolyTextOutA->cStrings * sizeof(POLYTEXTA));
1367 XFORM xform, xformOld;
1370 gModeOld = SetGraphicsMode(hdc, pPolyTextOutA->iGraphicsMode);
1371 GetWorldTransform(hdc, &xformOld);
1373 xform.eM11 = pPolyTextOutA->exScale;
1376 xform.eM22 = pPolyTextOutA->eyScale;
1379 SetWorldTransform(hdc, &xform);
1381 /* Set up POLYTEXTA structures */
1382 for(i = 0; i < pPolyTextOutA->cStrings; i++)
1384 polytextA[i].x = pPolyTextOutA->aemrtext[i].ptlReference.x;
1385 polytextA[i].y = pPolyTextOutA->aemrtext[i].ptlReference.y;
1386 polytextA[i].n = pPolyTextOutA->aemrtext[i].nChars;
1387 polytextA[i].lpstr = (LPSTR)((BYTE *)mr + pPolyTextOutA->aemrtext[i].offString);
1388 polytextA[i].uiFlags = pPolyTextOutA->aemrtext[i].fOptions;
1389 polytextA[i].rcl.left = pPolyTextOutA->aemrtext[i].rcl.left;
1390 polytextA[i].rcl.right = pPolyTextOutA->aemrtext[i].rcl.right;
1391 polytextA[i].rcl.top = pPolyTextOutA->aemrtext[i].rcl.top;
1392 polytextA[i].rcl.bottom = pPolyTextOutA->aemrtext[i].rcl.bottom;
1393 polytextA[i].pdx = (int *)((BYTE *)mr + pPolyTextOutA->aemrtext[i].offDx);
1395 PolyTextOutA(hdc, polytextA, pPolyTextOutA->cStrings);
1396 HeapFree(GetProcessHeap(), 0, polytextA);
1398 SetWorldTransform(hdc, &xformOld);
1399 SetGraphicsMode(hdc, gModeOld);
1403 case EMR_POLYTEXTOUTW:
1405 PEMRPOLYTEXTOUTW pPolyTextOutW = (PEMRPOLYTEXTOUTW)mr;
1406 POLYTEXTW *polytextW = HeapAlloc(GetProcessHeap(), 0, pPolyTextOutW->cStrings * sizeof(POLYTEXTW));
1408 XFORM xform, xformOld;
1411 gModeOld = SetGraphicsMode(hdc, pPolyTextOutW->iGraphicsMode);
1412 GetWorldTransform(hdc, &xformOld);
1414 xform.eM11 = pPolyTextOutW->exScale;
1417 xform.eM22 = pPolyTextOutW->eyScale;
1420 SetWorldTransform(hdc, &xform);
1422 /* Set up POLYTEXTW structures */
1423 for(i = 0; i < pPolyTextOutW->cStrings; i++)
1425 polytextW[i].x = pPolyTextOutW->aemrtext[i].ptlReference.x;
1426 polytextW[i].y = pPolyTextOutW->aemrtext[i].ptlReference.y;
1427 polytextW[i].n = pPolyTextOutW->aemrtext[i].nChars;
1428 polytextW[i].lpstr = (LPWSTR)((BYTE *)mr + pPolyTextOutW->aemrtext[i].offString);
1429 polytextW[i].uiFlags = pPolyTextOutW->aemrtext[i].fOptions;
1430 polytextW[i].rcl.left = pPolyTextOutW->aemrtext[i].rcl.left;
1431 polytextW[i].rcl.right = pPolyTextOutW->aemrtext[i].rcl.right;
1432 polytextW[i].rcl.top = pPolyTextOutW->aemrtext[i].rcl.top;
1433 polytextW[i].rcl.bottom = pPolyTextOutW->aemrtext[i].rcl.bottom;
1434 polytextW[i].pdx = (int *)((BYTE *)mr + pPolyTextOutW->aemrtext[i].offDx);
1436 PolyTextOutW(hdc, polytextW, pPolyTextOutW->cStrings);
1437 HeapFree(GetProcessHeap(), 0, polytextW);
1439 SetWorldTransform(hdc, &xformOld);
1440 SetGraphicsMode(hdc, gModeOld);
1446 PEMRFILLRGN pFillRgn = (PEMRFILLRGN)mr;
1447 HRGN hRgn = ExtCreateRegion(NULL, pFillRgn->cbRgnData, (RGNDATA *)pFillRgn->RgnData);
1450 (handletable->objectHandle)[pFillRgn->ihBrush]);
1457 PEMRFRAMERGN pFrameRgn = (PEMRFRAMERGN)mr;
1458 HRGN hRgn = ExtCreateRegion(NULL, pFrameRgn->cbRgnData, (RGNDATA *)pFrameRgn->RgnData);
1461 (handletable->objectHandle)[pFrameRgn->ihBrush],
1462 pFrameRgn->szlStroke.cx,
1463 pFrameRgn->szlStroke.cy);
1470 PEMRINVERTRGN pInvertRgn = (PEMRINVERTRGN)mr;
1471 HRGN hRgn = ExtCreateRegion(NULL, pInvertRgn->cbRgnData, (RGNDATA *)pInvertRgn->RgnData);
1472 InvertRgn(hdc, hRgn);
1479 PEMRPAINTRGN pPaintRgn = (PEMRPAINTRGN)mr;
1480 HRGN hRgn = ExtCreateRegion(NULL, pPaintRgn->cbRgnData, (RGNDATA *)pPaintRgn->RgnData);
1481 PaintRgn(hdc, hRgn);
1486 case EMR_POLYDRAW16:
1488 case EMR_GLSBOUNDEDRECORD:
1490 /* From docs: If PlayEnhMetaFileRecord doesn't recognize a
1491 record then ignore and return TRUE. */
1492 FIXME("type %d is unimplemented\n", type);
1499 /*****************************************************************************
1501 * EnumEnhMetaFile (GDI32.@)
1503 * Walk an enhanced metafile, calling a user-specified function _EnhMetaFunc_
1505 * record. Returns when either every record has been used or
1506 * when _EnhMetaFunc_ returns FALSE.
1510 * TRUE if every record is used, FALSE if any invocation of _EnhMetaFunc_
1516 BOOL WINAPI EnumEnhMetaFile(
1517 HDC hdc, /* [in] device context to pass to _EnhMetaFunc_ */
1518 HENHMETAFILE hmf, /* [in] EMF to walk */
1519 ENHMFENUMPROC callback, /* [in] callback function */
1520 LPVOID data, /* [in] optional data for callback function */
1521 const RECT *lpRect /* [in] bounding rectangle for rendered metafile */
1531 FLOAT xSrcPixSize, ySrcPixSize, xscale, yscale;
1532 XFORM savedXform, xform;
1533 HPEN hPen = (HPEN)NULL;
1534 HBRUSH hBrush = (HBRUSH)NULL;
1535 HFONT hFont = (HFONT)NULL;
1539 SetLastError(ERROR_INVALID_PARAMETER);
1543 emh = EMF_GetEnhMetaHeader(hmf);
1545 SetLastError(ERROR_INVALID_HANDLE);
1549 ht = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1550 sizeof(HANDLETABLE) * emh->nHandles );
1553 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1556 ht->objectHandle[0] = hmf;
1560 TRACE("rect: %d,%d - %d,%d. rclFrame: %ld,%ld - %ld,%ld\n",
1561 lpRect->left, lpRect->top, lpRect->right, lpRect->bottom,
1562 emh->rclFrame.left, emh->rclFrame.top, emh->rclFrame.right,
1563 emh->rclFrame.bottom);
1565 xSrcPixSize = (FLOAT) emh->szlMillimeters.cx / emh->szlDevice.cx;
1566 ySrcPixSize = (FLOAT) emh->szlMillimeters.cy / emh->szlDevice.cy;
1567 xscale = (FLOAT)(lpRect->right - lpRect->left) * 100.0 /
1568 (emh->rclFrame.right - emh->rclFrame.left) * xSrcPixSize;
1569 yscale = (FLOAT)(lpRect->bottom - lpRect->top) * 100.0 /
1570 (emh->rclFrame.bottom - emh->rclFrame.top) * ySrcPixSize;
1572 xform.eM11 = xscale;
1575 xform.eM22 = yscale;
1576 xform.eDx = (FLOAT) lpRect->left - (lpRect->right - lpRect->left) *
1577 emh->rclFrame.left / (emh->rclFrame.right - emh->rclFrame.left);
1578 xform.eDy = (FLOAT) lpRect->top - (lpRect->bottom - lpRect->top) *
1579 emh->rclFrame.top / (emh->rclFrame.bottom - emh->rclFrame.top);
1581 savedMode = SetGraphicsMode(hdc, GM_ADVANCED);
1582 GetWorldTransform(hdc, &savedXform);
1584 if (!ModifyWorldTransform(hdc, &xform, MWT_RIGHTMULTIPLY)) {
1585 ERR("World transform failed!\n");
1588 /* save the current pen, brush and font */
1589 hPen = GetCurrentObject(hdc, OBJ_PEN);
1590 hBrush = GetCurrentObject(hdc, OBJ_BRUSH);
1591 hFont = GetCurrentObject(hdc, OBJ_FONT);
1594 TRACE("nSize = %ld, nBytes = %ld, nHandles = %d, nRecords = %ld, nPalEntries = %ld\n",
1595 emh->nSize, emh->nBytes, emh->nHandles, emh->nRecords, emh->nPalEntries);
1599 while(ret && offset < emh->nBytes)
1601 emr = (ENHMETARECORD *)((char *)emh + offset);
1602 TRACE("Calling EnumFunc with record type %ld, size %ld\n", emr->iType, emr->nSize);
1603 ret = (*callback)(hdc, ht, emr, emh->nHandles, data);
1604 offset += emr->nSize;
1609 /* restore pen, brush and font */
1610 SelectObject(hdc, hBrush);
1611 SelectObject(hdc, hPen);
1612 SelectObject(hdc, hFont);
1614 SetWorldTransform(hdc, &savedXform);
1616 SetGraphicsMode(hdc, savedMode);
1619 for(i = 1; i < emh->nHandles; i++) /* Don't delete element 0 (hmf) */
1620 if( (ht->objectHandle)[i] )
1621 DeleteObject( (ht->objectHandle)[i] );
1623 HeapFree( GetProcessHeap(), 0, ht );
1627 static INT CALLBACK EMF_PlayEnhMetaFileCallback(HDC hdc, HANDLETABLE *ht,
1629 INT handles, LPVOID data)
1631 return PlayEnhMetaFileRecord(hdc, ht, emr, handles);
1634 /**************************************************************************
1635 * PlayEnhMetaFile (GDI32.@)
1637 * Renders an enhanced metafile into a specified rectangle *lpRect
1638 * in device context hdc.
1641 BOOL WINAPI PlayEnhMetaFile(
1642 HDC hdc, /* [in] DC to render into */
1643 HENHMETAFILE hmf, /* [in] metafile to render */
1644 const RECT *lpRect /* [in] rectangle to place metafile inside */
1647 return EnumEnhMetaFile(hdc, hmf, EMF_PlayEnhMetaFileCallback, NULL,
1651 /*****************************************************************************
1652 * DeleteEnhMetaFile (GDI32.@)
1654 * Deletes an enhanced metafile and frees the associated storage.
1656 BOOL WINAPI DeleteEnhMetaFile(HENHMETAFILE hmf)
1658 return EMF_Delete_HENHMETAFILE( hmf );
1661 /*****************************************************************************
1662 * CopyEnhMetaFileA (GDI32.@) Duplicate an enhanced metafile
1666 HENHMETAFILE WINAPI CopyEnhMetaFileA(
1667 HENHMETAFILE hmfSrc,
1670 ENHMETAHEADER *emrSrc = EMF_GetEnhMetaHeader( hmfSrc ), *emrDst;
1671 HENHMETAFILE hmfDst;
1673 if(!emrSrc) return FALSE;
1675 emrDst = HeapAlloc( GetProcessHeap(), 0, emrSrc->nBytes );
1676 memcpy( emrDst, emrSrc, emrSrc->nBytes );
1677 hmfDst = EMF_Create_HENHMETAFILE( emrDst, FALSE );
1680 hFile = CreateFileA( file, GENERIC_WRITE | GENERIC_READ, 0, NULL,
1681 CREATE_ALWAYS, 0, 0);
1682 WriteFile( hFile, emrSrc, emrSrc->nBytes, 0, 0);
1683 hmfDst = EMF_GetEnhMetaFile( hFile );
1684 CloseHandle( hFile );
1690 /* Struct to be used to be passed in the LPVOID parameter for cbEnhPaletteCopy */
1691 typedef struct tagEMF_PaletteCopy
1694 LPPALETTEENTRY lpPe;
1697 /***************************************************************
1698 * Find the EMR_EOF record and then use it to find the
1699 * palette entries for this enhanced metafile.
1700 * The lpData is actually a pointer to a EMF_PaletteCopy struct
1701 * which contains the max number of elements to copy and where
1704 * NOTE: To be used by GetEnhMetaFilePaletteEntries only!
1706 INT CALLBACK cbEnhPaletteCopy( HDC a,
1708 LPENHMETARECORD lpEMR,
1713 if ( lpEMR->iType == EMR_EOF )
1715 PEMREOF lpEof = (PEMREOF)lpEMR;
1716 EMF_PaletteCopy* info = (EMF_PaletteCopy*)lpData;
1717 DWORD dwNumPalToCopy = min( lpEof->nPalEntries, info->cEntries );
1719 TRACE( "copying 0x%08lx palettes\n", dwNumPalToCopy );
1721 memcpy( (LPVOID)info->lpPe,
1722 (LPVOID)(((LPSTR)lpEof) + lpEof->offPalEntries),
1723 sizeof( *(info->lpPe) ) * dwNumPalToCopy );
1725 /* Update the passed data as a return code */
1726 info->lpPe = NULL; /* Palettes were copied! */
1727 info->cEntries = (UINT)dwNumPalToCopy;
1729 return FALSE; /* That's all we need */
1735 /*****************************************************************************
1736 * GetEnhMetaFilePaletteEntries (GDI32.@)
1738 * Copy the palette and report size
1740 * BUGS: Error codes (SetLastError) are not set on failures
1742 UINT WINAPI GetEnhMetaFilePaletteEntries( HENHMETAFILE hEmf,
1744 LPPALETTEENTRY lpPe )
1746 ENHMETAHEADER* enhHeader = EMF_GetEnhMetaHeader( hEmf );
1747 EMF_PaletteCopy infoForCallBack;
1749 TRACE( "(%04x,%d,%p)\n", hEmf, cEntries, lpPe );
1751 /* First check if there are any palettes associated with
1753 if ( enhHeader->nPalEntries == 0 ) return 0;
1755 /* Is the user requesting the number of palettes? */
1756 if ( lpPe == NULL ) return (UINT)enhHeader->nPalEntries;
1758 /* Copy cEntries worth of PALETTEENTRY structs into the buffer */
1759 infoForCallBack.cEntries = cEntries;
1760 infoForCallBack.lpPe = lpPe;
1762 if ( !EnumEnhMetaFile( 0, hEmf, cbEnhPaletteCopy,
1763 &infoForCallBack, NULL ) )
1766 /* Verify that the callback executed correctly */
1767 if ( infoForCallBack.lpPe != NULL )
1769 /* Callback proc had error! */
1770 ERR( "cbEnhPaletteCopy didn't execute correctly\n" );
1774 return infoForCallBack.cEntries;
1777 /******************************************************************
1778 * SetWinMetaFileBits (GDI32.@)
1780 * Translate from old style to new style.
1782 * BUGS: - This doesn't take the DC and scaling into account
1783 * - Most record conversions aren't implemented
1784 * - Handle slot assignement is primative and most likely doesn't work
1786 HENHMETAFILE WINAPI SetWinMetaFileBits(UINT cbBuffer,
1787 CONST BYTE *lpbBuffer,
1789 CONST METAFILEPICT *lpmfp
1793 LPVOID lpNewEnhMetaFileBuffer = NULL;
1794 UINT uNewEnhMetaFileBufferSize = 0;
1795 BOOL bFoundEOF = FALSE;
1797 FIXME( "(%d,%p,%04x,%p):stub\n", cbBuffer, lpbBuffer, hdcRef, lpmfp );
1799 /* 1. Get the header - skip over this and get straight to the records */
1801 uNewEnhMetaFileBufferSize = sizeof( ENHMETAHEADER );
1802 lpNewEnhMetaFileBuffer = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1803 uNewEnhMetaFileBufferSize );
1805 if( lpNewEnhMetaFileBuffer == NULL )
1810 /* Fill in the header record */
1812 LPENHMETAHEADER lpNewEnhMetaFileHeader = (LPENHMETAHEADER)lpNewEnhMetaFileBuffer;
1814 lpNewEnhMetaFileHeader->iType = EMR_HEADER;
1815 lpNewEnhMetaFileHeader->nSize = sizeof( ENHMETAHEADER );
1817 /* FIXME: Not right. Must be able to get this from the DC */
1818 lpNewEnhMetaFileHeader->rclBounds.left = 0;
1819 lpNewEnhMetaFileHeader->rclBounds.right = 0;
1820 lpNewEnhMetaFileHeader->rclBounds.top = 0;
1821 lpNewEnhMetaFileHeader->rclBounds.bottom = 0;
1823 /* FIXME: Not right. Must be able to get this from the DC */
1824 lpNewEnhMetaFileHeader->rclFrame.left = 0;
1825 lpNewEnhMetaFileHeader->rclFrame.right = 0;
1826 lpNewEnhMetaFileHeader->rclFrame.top = 0;
1827 lpNewEnhMetaFileHeader->rclFrame.bottom = 0;
1829 lpNewEnhMetaFileHeader->dSignature=ENHMETA_SIGNATURE;
1830 lpNewEnhMetaFileHeader->nVersion=0x10000;
1831 lpNewEnhMetaFileHeader->nBytes = lpNewEnhMetaFileHeader->nSize;
1832 lpNewEnhMetaFileHeader->sReserved=0;
1834 /* FIXME: if there is a description add it */
1835 lpNewEnhMetaFileHeader->nDescription=0;
1836 lpNewEnhMetaFileHeader->offDescription=0;
1838 lpNewEnhMetaFileHeader->nHandles = 0; /* No handles yet */
1839 lpNewEnhMetaFileHeader->nRecords = 0;
1841 /* I am pretty sure this starts at 0 and grows as entries are added */
1842 lpNewEnhMetaFileHeader->nPalEntries = 0;
1844 /* Size in Pixels */
1845 lpNewEnhMetaFileHeader->szlDevice.cx = GetDeviceCaps(hdcRef,HORZRES);
1846 lpNewEnhMetaFileHeader->szlDevice.cy = GetDeviceCaps(hdcRef,VERTRES);
1849 lpNewEnhMetaFileHeader->szlMillimeters.cx =
1850 GetDeviceCaps(hdcRef,HORZSIZE);
1851 lpNewEnhMetaFileHeader->szlMillimeters.cy =
1852 GetDeviceCaps(hdcRef,VERTSIZE);
1854 /* FIXME: Add in the rest of the fields to the header */
1860 (char*)lpbBuffer += ((METAHEADER*)lpbBuffer)->mtHeaderSize * 2; /* Point past the header - FIXME: metafile quirk? */
1862 /* 2. Enum over individual records and convert them to the new type of records */
1866 LPMETARECORD lpMetaRecord = (LPMETARECORD)lpbBuffer;
1868 #define EMF_ReAllocAndAdjustPointers( a , b ) \
1871 lpTmp = HeapReAlloc( GetProcessHeap(), 0, \
1872 lpNewEnhMetaFileBuffer, \
1873 uNewEnhMetaFileBufferSize + (b) ); \
1874 if( lpTmp == NULL ) { ERR( "No memory!\n" ); goto error; } \
1875 lpNewEnhMetaFileBuffer = lpTmp; \
1876 lpRecord = (a)( (char*)lpNewEnhMetaFileBuffer + uNewEnhMetaFileBufferSize ); \
1877 uNewEnhMetaFileBufferSize += (b); \
1880 switch( lpMetaRecord->rdFunction )
1885 size_t uRecord = sizeof(*lpRecord);
1887 EMF_ReAllocAndAdjustPointers(PEMREOF,uRecord);
1889 /* Fill the new record - FIXME: This is not right */
1890 lpRecord->emr.iType = EMR_EOF;
1891 lpRecord->emr.nSize = sizeof( *lpRecord );
1892 lpRecord->nPalEntries = 0; /* FIXME */
1893 lpRecord->offPalEntries = 0; /* FIXME */
1894 lpRecord->nSizeLast = 0; /* FIXME */
1896 /* No more records after this one */
1899 FIXME( "META_EOF conversion not correct\n" );
1903 case META_SETMAPMODE:
1905 PEMRSETMAPMODE lpRecord;
1906 size_t uRecord = sizeof(*lpRecord);
1908 EMF_ReAllocAndAdjustPointers(PEMRSETMAPMODE,uRecord);
1910 lpRecord->emr.iType = EMR_SETMAPMODE;
1911 lpRecord->emr.nSize = sizeof( *lpRecord );
1913 lpRecord->iMode = lpMetaRecord->rdParm[0];
1918 case META_DELETEOBJECT: /* Select and Delete structures are the same */
1919 case META_SELECTOBJECT:
1921 PEMRDELETEOBJECT lpRecord;
1922 size_t uRecord = sizeof(*lpRecord);
1924 EMF_ReAllocAndAdjustPointers(PEMRDELETEOBJECT,uRecord);
1926 if( lpMetaRecord->rdFunction == META_DELETEOBJECT )
1928 lpRecord->emr.iType = EMR_DELETEOBJECT;
1932 lpRecord->emr.iType = EMR_SELECTOBJECT;
1934 lpRecord->emr.nSize = sizeof( *lpRecord );
1936 lpRecord->ihObject = lpMetaRecord->rdParm[0]; /* FIXME: Handle */
1941 case META_POLYGON: /* This is just plain busted. I don't know what I'm doing */
1943 PEMRPOLYGON16 lpRecord; /* FIXME: Should it be a poly or poly16? */
1944 size_t uRecord = sizeof(*lpRecord);
1946 EMF_ReAllocAndAdjustPointers(PEMRPOLYGON16,uRecord);
1948 /* FIXME: This is mostly all wrong */
1949 lpRecord->emr.iType = EMR_POLYGON16;
1950 lpRecord->emr.nSize = sizeof( *lpRecord );
1952 lpRecord->rclBounds.left = 0;
1953 lpRecord->rclBounds.right = 0;
1954 lpRecord->rclBounds.top = 0;
1955 lpRecord->rclBounds.bottom = 0;
1958 lpRecord->apts[0].x = 0;
1959 lpRecord->apts[0].y = 0;
1961 FIXME( "META_POLYGON conversion not correct\n" );
1966 case META_SETPOLYFILLMODE:
1968 PEMRSETPOLYFILLMODE lpRecord;
1969 size_t uRecord = sizeof(*lpRecord);
1971 EMF_ReAllocAndAdjustPointers(PEMRSETPOLYFILLMODE,uRecord);
1973 lpRecord->emr.iType = EMR_SETPOLYFILLMODE;
1974 lpRecord->emr.nSize = sizeof( *lpRecord );
1976 lpRecord->iMode = lpMetaRecord->rdParm[0];
1981 case META_SETWINDOWORG:
1983 PEMRSETWINDOWORGEX lpRecord; /* Seems to be the closest thing */
1984 size_t uRecord = sizeof(*lpRecord);
1986 EMF_ReAllocAndAdjustPointers(PEMRSETWINDOWORGEX,uRecord);
1988 lpRecord->emr.iType = EMR_SETWINDOWORGEX;
1989 lpRecord->emr.nSize = sizeof( *lpRecord );
1991 lpRecord->ptlOrigin.x = lpMetaRecord->rdParm[1];
1992 lpRecord->ptlOrigin.y = lpMetaRecord->rdParm[0];
1997 case META_SETWINDOWEXT: /* Structure is the same for SETWINDOWEXT & SETVIEWPORTEXT */
1998 case META_SETVIEWPORTEXT:
2000 PEMRSETWINDOWEXTEX lpRecord;
2001 size_t uRecord = sizeof(*lpRecord);
2003 EMF_ReAllocAndAdjustPointers(PEMRSETWINDOWEXTEX,uRecord);
2005 if ( lpMetaRecord->rdFunction == META_SETWINDOWEXT )
2007 lpRecord->emr.iType = EMR_SETWINDOWORGEX;
2011 lpRecord->emr.iType = EMR_SETVIEWPORTEXTEX;
2013 lpRecord->emr.nSize = sizeof( *lpRecord );
2015 lpRecord->szlExtent.cx = lpMetaRecord->rdParm[1];
2016 lpRecord->szlExtent.cy = lpMetaRecord->rdParm[0];
2021 case META_CREATEBRUSHINDIRECT:
2023 PEMRCREATEBRUSHINDIRECT lpRecord;
2024 size_t uRecord = sizeof(*lpRecord);
2026 EMF_ReAllocAndAdjustPointers(PEMRCREATEBRUSHINDIRECT,uRecord);
2028 lpRecord->emr.iType = EMR_CREATEBRUSHINDIRECT;
2029 lpRecord->emr.nSize = sizeof( *lpRecord );
2031 lpRecord->ihBrush = ((LPENHMETAHEADER)lpNewEnhMetaFileBuffer)->nHandles;
2032 lpRecord->lb.lbStyle = ((LPLOGBRUSH16)lpMetaRecord->rdParm)->lbStyle;
2033 lpRecord->lb.lbColor = ((LPLOGBRUSH16)lpMetaRecord->rdParm)->lbColor;
2034 lpRecord->lb.lbHatch = ((LPLOGBRUSH16)lpMetaRecord->rdParm)->lbHatch;
2036 ((LPENHMETAHEADER)lpNewEnhMetaFileBuffer)->nHandles += 1; /* New handle */
2044 PEMRLINETO lpRecord;
2045 size_t uRecord = sizeof(*lpRecord);
2047 EMF_ReAllocAndAdjustPointers(PEMRLINETO,uRecord);
2049 if ( lpMetaRecord->rdFunction == META_LINETO )
2051 lpRecord->emr.iType = EMR_LINETO;
2055 lpRecord->emr.iType = EMR_MOVETOEX;
2057 lpRecord->emr.nSize = sizeof( *lpRecord );
2059 lpRecord->ptl.x = lpMetaRecord->rdParm[1];
2060 lpRecord->ptl.y = lpMetaRecord->rdParm[0];
2065 case META_SETTEXTCOLOR:
2066 case META_SETBKCOLOR:
2068 PEMRSETBKCOLOR lpRecord;
2069 size_t uRecord = sizeof(*lpRecord);
2071 EMF_ReAllocAndAdjustPointers(PEMRSETBKCOLOR,uRecord);
2073 if ( lpMetaRecord->rdFunction == META_SETTEXTCOLOR )
2075 lpRecord->emr.iType = EMR_SETTEXTCOLOR;
2079 lpRecord->emr.iType = EMR_SETBKCOLOR;
2081 lpRecord->emr.nSize = sizeof( *lpRecord );
2083 lpRecord->crColor = MAKELONG(lpMetaRecord->rdParm[0],
2084 lpMetaRecord->rdParm[1]);
2091 /* These are all unimplemented and as such are intended to fall through to the default case */
2092 case META_SETBKMODE:
2094 case META_SETRELABS:
2095 case META_SETSTRETCHBLTMODE:
2096 case META_SETVIEWPORTORG:
2097 case META_OFFSETWINDOWORG:
2098 case META_SCALEWINDOWEXT:
2099 case META_OFFSETVIEWPORTORG:
2100 case META_SCALEVIEWPORTEXT:
2101 case META_EXCLUDECLIPRECT:
2102 case META_INTERSECTCLIPRECT:
2105 case META_FLOODFILL:
2107 case META_RECTANGLE:
2108 case META_ROUNDRECT:
2112 case META_OFFSETCLIPRGN:
2114 case META_POLYPOLYGON:
2116 case META_RESTOREDC:
2118 case META_CREATEPATTERNBRUSH:
2119 case META_CREATEPENINDIRECT:
2120 case META_CREATEFONTINDIRECT:
2121 case META_CREATEPALETTE:
2122 case META_SETTEXTALIGN:
2123 case META_SELECTPALETTE:
2124 case META_SETMAPPERFLAGS:
2125 case META_REALIZEPALETTE:
2127 case META_EXTTEXTOUT:
2128 case META_STRETCHDIB:
2129 case META_DIBSTRETCHBLT:
2130 case META_STRETCHBLT:
2132 case META_CREATEREGION:
2133 case META_FILLREGION:
2134 case META_FRAMEREGION:
2135 case META_INVERTREGION:
2136 case META_PAINTREGION:
2137 case META_SELECTCLIPREGION:
2138 case META_DIBCREATEPATTERNBRUSH:
2139 case META_DIBBITBLT:
2140 case META_SETTEXTCHAREXTRA:
2141 case META_SETTEXTJUSTIFICATION:
2142 case META_EXTFLOODFILL:
2143 case META_SETDIBTODEV:
2145 case META_ANIMATEPALETTE:
2146 case META_SETPALENTRIES:
2147 case META_RESIZEPALETTE:
2150 case META_STARTPAGE:
2154 case META_CREATEBRUSH:
2155 case META_CREATEBITMAPINDIRECT:
2156 case META_CREATEBITMAP:
2157 /* Fall through to unimplemented */
2160 /* Not implemented yet */
2161 FIXME( "Conversion of record type 0x%x not implemented.\n", lpMetaRecord->rdFunction );
2166 /* Move to the next record */
2167 (char*)lpbBuffer += ((LPMETARECORD)lpbBuffer)->rdSize * 2; /* FIXME: Seem to be doing this in metafile.c */
2169 #undef ReAllocAndAdjustPointers
2172 /* We know the last of the header information now */
2173 ((LPENHMETAHEADER)lpNewEnhMetaFileBuffer)->nBytes = uNewEnhMetaFileBufferSize;
2175 /* Create the enhanced metafile */
2176 hMf = SetEnhMetaFileBits( uNewEnhMetaFileBufferSize, (const BYTE*)lpNewEnhMetaFileBuffer );
2179 ERR( "Problem creating metafile. Did the conversion fail somewhere?\n" );
2184 /* Free the data associated with our copy since it's been copied */
2185 HeapFree( GetProcessHeap(), 0, lpNewEnhMetaFileBuffer );