?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Send LVN_DELETEITEM notification first, to avoid crashes if the app
[wine.git] / objects / enhmetafile.c
blobc64eb11f081b1d231c4da4cd25a053946e4f1b93
1 /*
2 * Enhanced metafile functions
3 * Copyright 1998 Douglas Ridgway
4 * 1999 Huw D M Davies
5 *
6 *
7 * The enhanced format consists of the following elements:
8 *
9 * A header
10 * A table of handles to GDI objects
11 * An array of metafile records
12 * A private palette
13 *
14 *
15 * The standard format consists of a header and an array of metafile records.
16 *
17 */
18
19 #include <string.h>
20 #include <assert.h>
21 #include "winnls.h"
22 #include "winbase.h"
23 #include "wingdi.h"
24 #include "winerror.h"
25 #include "enhmetafile.h"
26 #include "debugtools.h"
27 #include "heap.h"
28 #include "metafile.h"
29
30 DEFAULT_DEBUG_CHANNEL(enhmetafile);
31
32 /****************************************************************************
33 * EMF_Create_HENHMETAFILE
34 */
35 HENHMETAFILE EMF_Create_HENHMETAFILE(ENHMETAHEADER *emh, HFILE hFile, HANDLE
36 hMapping )
37 {
38 HENHMETAFILE hmf = 0;
39 ENHMETAFILEOBJ *metaObj = GDI_AllocObject( sizeof(ENHMETAFILEOBJ),
40 ENHMETAFILE_MAGIC, &hmf );
41 if (metaObj)
42 {
43 metaObj->emh = emh;
44 metaObj->hFile = hFile;
45 metaObj->hMapping = hMapping;
46 GDI_ReleaseObj( hmf );
47 }
48 return hmf;
49 }
50
51 /****************************************************************************
52 * EMF_Delete_HENHMETAFILE
53 */
54 static BOOL EMF_Delete_HENHMETAFILE( HENHMETAFILE hmf )
55 {
56 ENHMETAFILEOBJ *metaObj = (ENHMETAFILEOBJ *)GDI_GetObjPtr( hmf,
57 ENHMETAFILE_MAGIC );
58 if(!metaObj) return FALSE;
59 if(metaObj->hMapping) {
60 UnmapViewOfFile( metaObj->emh );
61 CloseHandle( metaObj->hMapping );
62 CloseHandle( metaObj->hFile );
63 } else
64 HeapFree( GetProcessHeap(), 0, metaObj->emh );
65 return GDI_FreeObject( hmf, metaObj );
66 }
67
68 /******************************************************************
69 * EMF_GetEnhMetaHeader
70 *
71 * Returns ptr to ENHMETAHEADER associated with HENHMETAFILE
72 * Should be followed by call to EMF_ReleaseEnhMetaHeader
73 */
74 static ENHMETAHEADER *EMF_GetEnhMetaHeader( HENHMETAFILE hmf )
75 {
76 ENHMETAFILEOBJ *metaObj = (ENHMETAFILEOBJ *)GDI_GetObjPtr( hmf,
77 ENHMETAFILE_MAGIC );
78 TRACE("hmf %04x -> enhmetaObj %p\n", hmf, metaObj);
79 return metaObj ? metaObj->emh : NULL;
80 }
81
82 /******************************************************************
83 * EMF_ReleaseEnhMetaHeader
84 *
85 * Releases ENHMETAHEADER associated with HENHMETAFILE
86 */
87 static void EMF_ReleaseEnhMetaHeader( HENHMETAFILE hmf )
88 {
89 GDI_ReleaseObj( hmf );
90 }
91
92 /*****************************************************************************
93 * EMF_GetEnhMetaFile
94 *
95 */
96 static HENHMETAFILE EMF_GetEnhMetaFile( HANDLE hFile )
97 {
98 ENHMETAHEADER *emh;
99 HANDLE hMapping;
100
101 hMapping = CreateFileMappingA( hFile, NULL, PAGE_READONLY, 0, 0, NULL );
102 emh = MapViewOfFile( hMapping, FILE_MAP_READ, 0, 0, 0 );
103
104 if (emh->iType != EMR_HEADER || emh->dSignature != ENHMETA_SIGNATURE) {
105 WARN("Invalid emf header type 0x%08lx sig 0x%08lx.\n",
106 emh->iType, emh->dSignature);
107 UnmapViewOfFile( emh );
108 CloseHandle( hMapping );
109 return 0;
110 }
111 return EMF_Create_HENHMETAFILE( emh, hFile, hMapping );
112 }
113
114
115 /*****************************************************************************
116 * GetEnhMetaFileA (GDI32.@)
117 *
118 *
119 */
120 HENHMETAFILE WINAPI GetEnhMetaFileA(
121 LPCSTR lpszMetaFile /* [in] filename of enhanced metafile */
122 )
123 {
124 HENHMETAFILE hmf;
125 HANDLE hFile;
126
127 hFile = CreateFileA(lpszMetaFile, GENERIC_READ, FILE_SHARE_READ, 0,
128 OPEN_EXISTING, 0, 0);
129 if (hFile == INVALID_HANDLE_VALUE) {
130 WARN("could not open %s\n", lpszMetaFile);
131 return 0;
132 }
133 hmf = EMF_GetEnhMetaFile( hFile );
134 if(!hmf)
135 CloseHandle( hFile );
136 return hmf;
137 }
138
139 /*****************************************************************************
140 * GetEnhMetaFileW (GDI32.@)
141 */
142 HENHMETAFILE WINAPI GetEnhMetaFileW(
143 LPCWSTR lpszMetaFile) /* [in] filename of enhanced metafile */
144 {
145 HENHMETAFILE hmf;
146 HANDLE hFile;
147
148 hFile = CreateFileW(lpszMetaFile, GENERIC_READ, FILE_SHARE_READ, 0,
149 OPEN_EXISTING, 0, 0);
150 if (hFile == INVALID_HANDLE_VALUE) {
151 WARN("could not open %s\n", debugstr_w(lpszMetaFile));
152 return 0;
153 }
154 hmf = EMF_GetEnhMetaFile( hFile );
155 if(!hmf)
156 CloseHandle( hFile );
157 return hmf;
158 }
159
160 /*****************************************************************************
161 * GetEnhMetaFileHeader (GDI32.@)
162 *
163 * If buf is NULL, returns the size of buffer required.
164 * Otherwise, copy up to bufsize bytes of enhanced metafile header into
165 * buf.
166 */
167 UINT WINAPI GetEnhMetaFileHeader(
168 HENHMETAFILE hmf, /* [in] enhanced metafile */
169 UINT bufsize, /* [in] size of buffer */
170 LPENHMETAHEADER buf /* [out] buffer */
171 )
172 {
173 LPENHMETAHEADER emh;
174 UINT size;
175
176 emh = EMF_GetEnhMetaHeader(hmf);
177 if(!emh) return FALSE;
178 size = emh->nSize;
179 if (!buf) {
180 EMF_ReleaseEnhMetaHeader(hmf);
181 return size;
182 }
183 size = min(size, bufsize);
184 memmove(buf, emh, size);
185 EMF_ReleaseEnhMetaHeader(hmf);
186 return size;
187 }
188
189
190 /*****************************************************************************
191 * GetEnhMetaFileDescriptionA (GDI32.@)
192 */
193 UINT WINAPI GetEnhMetaFileDescriptionA(
194 HENHMETAFILE hmf, /* [in] enhanced metafile */
195 UINT size, /* [in] size of buf */
196 LPSTR buf /* [out] buffer to receive description */
197 )
198 {
199 LPENHMETAHEADER emh = EMF_GetEnhMetaHeader(hmf);
200 DWORD len;
201 WCHAR *descrW;
202
203 if(!emh) return FALSE;
204 if(emh->nDescription == 0 || emh->offDescription == 0) {
205 EMF_ReleaseEnhMetaHeader(hmf);
206 return 0;
207 }
208 descrW = (WCHAR *) ((char *) emh + emh->offDescription);
209 len = WideCharToMultiByte( CP_ACP, 0, descrW, emh->nDescription, NULL, 0, NULL, NULL );
210
211 if (!buf || !size ) {
212 EMF_ReleaseEnhMetaHeader(hmf);
213 return len;
214 }
215
216 len = min( size, len );
217 WideCharToMultiByte( CP_ACP, 0, descrW, emh->nDescription, buf, len, NULL, NULL );
218 EMF_ReleaseEnhMetaHeader(hmf);
219 return len;
220 }
221
222 /*****************************************************************************
223 * GetEnhMetaFileDescriptionW (GDI32.@)
224 *
225 * Copies the description string of an enhanced metafile into a buffer
226 * _buf_.
227 *
228 * If _buf_ is NULL, returns size of _buf_ required. Otherwise, returns
229 * number of characters copied.
230 */
231 UINT WINAPI GetEnhMetaFileDescriptionW(
232 HENHMETAFILE hmf, /* [in] enhanced metafile */
233 UINT size, /* [in] size of buf */
234 LPWSTR buf /* [out] buffer to receive description */
235 )
236 {
237 LPENHMETAHEADER emh = EMF_GetEnhMetaHeader(hmf);
238
239 if(!emh) return FALSE;
240 if(emh->nDescription == 0 || emh->offDescription == 0) {
241 EMF_ReleaseEnhMetaHeader(hmf);
242 return 0;
243 }
244 if (!buf || !size ) {
245 EMF_ReleaseEnhMetaHeader(hmf);
246 return emh->nDescription;
247 }
248
249 memmove(buf, (char *) emh + emh->offDescription,
250 min(size,emh->nDescription)*sizeof(WCHAR));
251 EMF_ReleaseEnhMetaHeader(hmf);
252 return min(size, emh->nDescription);
253 }
254
255 /****************************************************************************
256 * SetEnhMetaFileBits (GDI32.@)
257 *
258 * Creates an enhanced metafile by copying _bufsize_ bytes from _buf_.
259 */
260 HENHMETAFILE WINAPI SetEnhMetaFileBits(UINT bufsize, const BYTE *buf)
261 {
262 ENHMETAHEADER *emh = HeapAlloc( GetProcessHeap(), 0, bufsize );
263 memmove(emh, buf, bufsize);
264 return EMF_Create_HENHMETAFILE( emh, 0, 0 );
265 }
266
267 /*****************************************************************************
268 * GetEnhMetaFileBits (GDI32.@)
269 *
270 */
271 UINT WINAPI GetEnhMetaFileBits(
272 HENHMETAFILE hmf,
273 UINT bufsize,
274 LPBYTE buf
275 )
276 {
277 LPENHMETAHEADER emh = EMF_GetEnhMetaHeader( hmf );
278 UINT size;
279
280 if(!emh) return 0;
281
282 size = emh->nBytes;
283 if( buf == NULL ) {
284 EMF_ReleaseEnhMetaHeader( hmf );
285 return size;
286 }
287
288 size = min( size, bufsize );
289 memmove(buf, emh, size);
290
291 EMF_ReleaseEnhMetaHeader( hmf );
292 return size;
293 }
294
295 /*****************************************************************************
296 * PlayEnhMetaFileRecord (GDI32.@)
297 *
298 * Render a single enhanced metafile record in the device context hdc.
299 *
300 * RETURNS
301 * TRUE (non zero) on success, FALSE on error.
302 * BUGS
303 * Many unimplemented records.
304 * No error handling on record play failures (ie checking return codes)
305 */
306 BOOL WINAPI PlayEnhMetaFileRecord(
307 HDC hdc, /* [in] device context in which to render EMF record */
308 LPHANDLETABLE handletable, /* [in] array of handles to be used in rendering record */
309 const ENHMETARECORD *mr, /* [in] EMF record to render */
310 UINT handles /* [in] size of handle array */
311 )
312 {
313 int type;
314 TRACE(
315 "hdc = %08x, handletable = %p, record = %p, numHandles = %d\n",
316 hdc, handletable, mr, handles);
317 if (!mr) return FALSE;
318
319 type = mr->iType;
320
321 TRACE(" type=%d\n", type);
322 switch(type)
323 {
324 case EMR_HEADER:
325 break;
326 case EMR_EOF:
327 break;
328 case EMR_GDICOMMENT:
329 {
330 PEMRGDICOMMENT lpGdiComment = (PEMRGDICOMMENT)mr;
331 /* In an enhanced metafile, there can be both public and private GDI comments */
332 GdiComment( hdc, lpGdiComment->cbData, lpGdiComment->Data );
333 break;
334 }
335 case EMR_SETMAPMODE:
336 {
337 PEMRSETMAPMODE pSetMapMode = (PEMRSETMAPMODE) mr;
338 SetMapMode(hdc, pSetMapMode->iMode);
339 break;
340 }
341 case EMR_SETBKMODE:
342 {
343 PEMRSETBKMODE pSetBkMode = (PEMRSETBKMODE) mr;
344 SetBkMode(hdc, pSetBkMode->iMode);
345 break;
346 }
347 case EMR_SETBKCOLOR:
348 {
349 PEMRSETBKCOLOR pSetBkColor = (PEMRSETBKCOLOR) mr;
350 SetBkColor(hdc, pSetBkColor->crColor);
351 break;
352 }
353 case EMR_SETPOLYFILLMODE:
354 {
355 PEMRSETPOLYFILLMODE pSetPolyFillMode = (PEMRSETPOLYFILLMODE) mr;
356 SetPolyFillMode(hdc, pSetPolyFillMode->iMode);
357 break;
358 }
359 case EMR_SETROP2:
360 {
361 PEMRSETROP2 pSetROP2 = (PEMRSETROP2) mr;
362 SetROP2(hdc, pSetROP2->iMode);
363 break;
364 }
365 case EMR_SETSTRETCHBLTMODE:
366 {
367 PEMRSETSTRETCHBLTMODE pSetStretchBltMode = (PEMRSETSTRETCHBLTMODE) mr;
368 SetStretchBltMode(hdc, pSetStretchBltMode->iMode);
369 break;
370 }
371 case EMR_SETTEXTALIGN:
372 {
373 PEMRSETTEXTALIGN pSetTextAlign = (PEMRSETTEXTALIGN) mr;
374 SetTextAlign(hdc, pSetTextAlign->iMode);
375 break;
376 }
377 case EMR_SETTEXTCOLOR:
378 {
379 PEMRSETTEXTCOLOR pSetTextColor = (PEMRSETTEXTCOLOR) mr;
380 SetTextColor(hdc, pSetTextColor->crColor);
381 break;
382 }
383 case EMR_SAVEDC:
384 {
385 SaveDC(hdc);
386 break;
387 }
388 case EMR_RESTOREDC:
389 {
390 PEMRRESTOREDC pRestoreDC = (PEMRRESTOREDC) mr;
391 RestoreDC(hdc, pRestoreDC->iRelative);
392 break;
393 }
394 case EMR_INTERSECTCLIPRECT:
395 {
396 PEMRINTERSECTCLIPRECT pClipRect = (PEMRINTERSECTCLIPRECT) mr;
397 IntersectClipRect(hdc, pClipRect->rclClip.left, pClipRect->rclClip.top,
398 pClipRect->rclClip.right, pClipRect->rclClip.bottom);
399 break;
400 }
401 case EMR_SELECTOBJECT:
402 {
403 PEMRSELECTOBJECT pSelectObject = (PEMRSELECTOBJECT) mr;
404 if( pSelectObject->ihObject & 0x80000000 ) {
405 /* High order bit is set - it's a stock object
406 * Strip the high bit to get the index.
407 * See MSDN article Q142319
408 */
409 SelectObject( hdc, GetStockObject( pSelectObject->ihObject &
410 0x7fffffff ) );
411 } else {
412 /* High order bit wasn't set - not a stock object
413 */
414 SelectObject( hdc,
415 (handletable->objectHandle)[pSelectObject->ihObject] );
416 }
417 break;
418 }
419 case EMR_DELETEOBJECT:
420 {
421 PEMRDELETEOBJECT pDeleteObject = (PEMRDELETEOBJECT) mr;
422 DeleteObject( (handletable->objectHandle)[pDeleteObject->ihObject]);
423 (handletable->objectHandle)[pDeleteObject->ihObject] = 0;
424 break;
425 }
426 case EMR_SETWINDOWORGEX:
427 {
428 /*
429 * FIXME: The call to SetWindowOrgEx prevents EMFs from being scrolled
430 * by an application. This is very BAD!!!
431 */
432 #if 0
433 PEMRSETWINDOWORGEX pSetWindowOrgEx = (PEMRSETWINDOWORGEX) mr;
434 SetWindowOrgEx(hdc, pSetWindowOrgEx->ptlOrigin.x,
435 pSetWindowOrgEx->ptlOrigin.y, NULL);
436 #endif
437 break;
438 }
439 case EMR_SETWINDOWEXTEX:
440 {
441 PEMRSETWINDOWEXTEX pSetWindowExtEx = (PEMRSETWINDOWEXTEX) mr;
442 SetWindowExtEx(hdc, pSetWindowExtEx->szlExtent.cx,
443 pSetWindowExtEx->szlExtent.cy, NULL);
444 break;
445 }
446 case EMR_SETVIEWPORTORGEX:
447 {
448 PEMRSETVIEWPORTORGEX pSetViewportOrgEx = (PEMRSETVIEWPORTORGEX) mr;
449 SetViewportOrgEx(hdc, pSetViewportOrgEx->ptlOrigin.x,
450 pSetViewportOrgEx->ptlOrigin.y, NULL);
451 break;
452 }
453 case EMR_SETVIEWPORTEXTEX:
454 {
455 PEMRSETVIEWPORTEXTEX pSetViewportExtEx = (PEMRSETVIEWPORTEXTEX) mr;
456 SetViewportExtEx(hdc, pSetViewportExtEx->szlExtent.cx,
457 pSetViewportExtEx->szlExtent.cy, NULL);
458 break;
459 }
460 case EMR_CREATEPEN:
461 {
462 PEMRCREATEPEN pCreatePen = (PEMRCREATEPEN) mr;
463 (handletable->objectHandle)[pCreatePen->ihPen] =
464 CreatePenIndirect(&pCreatePen->lopn);
465 break;
466 }
467 case EMR_EXTCREATEPEN:
468 {
469 PEMREXTCREATEPEN pPen = (PEMREXTCREATEPEN) mr;
470 LOGBRUSH lb;
471 lb.lbStyle = pPen->elp.elpBrushStyle;
472 lb.lbColor = pPen->elp.elpColor;
473 lb.lbHatch = pPen->elp.elpHatch;
474
475 if(pPen->offBmi || pPen->offBits)
476 FIXME("EMR_EXTCREATEPEN: Need to copy brush bitmap\n");
477
478 (handletable->objectHandle)[pPen->ihPen] =
479 ExtCreatePen(pPen->elp.elpPenStyle, pPen->elp.elpWidth, &lb,
480 pPen->elp.elpNumEntries, pPen->elp.elpStyleEntry);
481 break;
482 }
483 case EMR_CREATEBRUSHINDIRECT:
484 {
485 PEMRCREATEBRUSHINDIRECT pBrush = (PEMRCREATEBRUSHINDIRECT) mr;
486 (handletable->objectHandle)[pBrush->ihBrush] =
487 CreateBrushIndirect(&pBrush->lb);
488 break;
489 }
490 case EMR_EXTCREATEFONTINDIRECTW:
491 {
492 PEMREXTCREATEFONTINDIRECTW pFont = (PEMREXTCREATEFONTINDIRECTW) mr;
493 (handletable->objectHandle)[pFont->ihFont] =
494 CreateFontIndirectW(&pFont->elfw.elfLogFont);
495 break;
496 }
497 case EMR_MOVETOEX:
498 {
499 PEMRMOVETOEX pMoveToEx = (PEMRMOVETOEX) mr;
500 MoveToEx(hdc, pMoveToEx->ptl.x, pMoveToEx->ptl.y, NULL);
501 break;
502 }
503 case EMR_LINETO:
504 {
505 PEMRLINETO pLineTo = (PEMRLINETO) mr;
506 LineTo(hdc, pLineTo->ptl.x, pLineTo->ptl.y);
507 break;
508 }
509 case EMR_RECTANGLE:
510 {
511 PEMRRECTANGLE pRect = (PEMRRECTANGLE) mr;
512 Rectangle(hdc, pRect->rclBox.left, pRect->rclBox.top,
513 pRect->rclBox.right, pRect->rclBox.bottom);
514 break;
515 }
516 case EMR_ELLIPSE:
517 {
518 PEMRELLIPSE pEllipse = (PEMRELLIPSE) mr;
519 Ellipse(hdc, pEllipse->rclBox.left, pEllipse->rclBox.top,
520 pEllipse->rclBox.right, pEllipse->rclBox.bottom);
521 break;
522 }
523 case EMR_POLYGON16:
524 {
525 PEMRPOLYGON16 pPoly = (PEMRPOLYGON16) mr;
526 /* Shouldn't use Polygon16 since pPoly->cpts is DWORD */
527 POINT *pts = HeapAlloc( GetProcessHeap(), 0,
528 pPoly->cpts * sizeof(POINT) );
529 DWORD i;
530 for(i = 0; i < pPoly->cpts; i++)
531 CONV_POINT16TO32(pPoly->apts + i, pts + i);
532 Polygon(hdc, pts, pPoly->cpts);
533 HeapFree( GetProcessHeap(), 0, pts );
534 break;
535 }
536 case EMR_POLYLINE16:
537 {
538 PEMRPOLYLINE16 pPoly = (PEMRPOLYLINE16) mr;
539 /* Shouldn't use Polyline16 since pPoly->cpts is DWORD */
540 POINT *pts = HeapAlloc( GetProcessHeap(), 0,
541 pPoly->cpts * sizeof(POINT) );
542 DWORD i;
543 for(i = 0; i < pPoly->cpts; i++)
544 CONV_POINT16TO32(pPoly->apts + i, pts + i);
545 Polyline(hdc, pts, pPoly->cpts);
546 HeapFree( GetProcessHeap(), 0, pts );
547 break;
548 }
549 case EMR_POLYLINETO16:
550 {
551 PEMRPOLYLINETO16 pPoly = (PEMRPOLYLINETO16) mr;
552 /* Shouldn't use PolylineTo16 since pPoly->cpts is DWORD */
553 POINT *pts = HeapAlloc( GetProcessHeap(), 0,
554 pPoly->cpts * sizeof(POINT) );
555 DWORD i;
556 for(i = 0; i < pPoly->cpts; i++)
557 CONV_POINT16TO32(pPoly->apts + i, pts + i);
558 PolylineTo(hdc, pts, pPoly->cpts);
559 HeapFree( GetProcessHeap(), 0, pts );
560 break;
561 }
562 case EMR_POLYBEZIER16:
563 {
564 PEMRPOLYBEZIER16 pPoly = (PEMRPOLYBEZIER16) mr;
565 /* Shouldn't use PolyBezier16 since pPoly->cpts is DWORD */
566 POINT *pts = HeapAlloc( GetProcessHeap(), 0,
567 pPoly->cpts * sizeof(POINT) );
568 DWORD i;
569 for(i = 0; i < pPoly->cpts; i++)
570 CONV_POINT16TO32(pPoly->apts + i, pts + i);
571 PolyBezier(hdc, pts, pPoly->cpts);
572 HeapFree( GetProcessHeap(), 0, pts );
573 break;
574 }
575 case EMR_POLYBEZIERTO16:
576 {
577 PEMRPOLYBEZIERTO16 pPoly = (PEMRPOLYBEZIERTO16) mr;
578 /* Shouldn't use PolyBezierTo16 since pPoly->cpts is DWORD */
579 POINT *pts = HeapAlloc( GetProcessHeap(), 0,
580 pPoly->cpts * sizeof(POINT) );
581 DWORD i;
582 for(i = 0; i < pPoly->cpts; i++)
583 CONV_POINT16TO32(pPoly->apts + i, pts + i);
584 PolyBezierTo(hdc, pts, pPoly->cpts);
585 HeapFree( GetProcessHeap(), 0, pts );
586 break;
587 }
588 case EMR_POLYPOLYGON16:
589 {
590 PEMRPOLYPOLYGON16 pPolyPoly = (PEMRPOLYPOLYGON16) mr;
591 /* NB POINTS array doesn't start at pPolyPoly->apts it's actually
592 pPolyPoly->aPolyCounts + pPolyPoly->nPolys */
593
594 POINT *pts = HeapAlloc( GetProcessHeap(), 0,
595 pPolyPoly->cpts * sizeof(POINT) );
596 DWORD i;
597 for(i = 0; i < pPolyPoly->cpts; i++)
598 CONV_POINT16TO32((POINT16*) (pPolyPoly->aPolyCounts +
599 pPolyPoly->nPolys) + i, pts + i);
600
601 PolyPolygon(hdc, pts, (INT*)pPolyPoly->aPolyCounts, pPolyPoly->nPolys);
602 HeapFree( GetProcessHeap(), 0, pts );
603 break;
604 }
605 case EMR_POLYPOLYLINE16:
606 {
607 PEMRPOLYPOLYLINE16 pPolyPoly = (PEMRPOLYPOLYLINE16) mr;
608 /* NB POINTS array doesn't start at pPolyPoly->apts it's actually
609 pPolyPoly->aPolyCounts + pPolyPoly->nPolys */
610
611 POINT *pts = HeapAlloc( GetProcessHeap(), 0,
612 pPolyPoly->cpts * sizeof(POINT) );
613 DWORD i;
614 for(i = 0; i < pPolyPoly->cpts; i++)
615 CONV_POINT16TO32((POINT16*) (pPolyPoly->aPolyCounts +
616 pPolyPoly->nPolys) + i, pts + i);
617
618 PolyPolyline(hdc, pts, pPolyPoly->aPolyCounts, pPolyPoly->nPolys);
619 HeapFree( GetProcessHeap(), 0, pts );
620 break;
621 }
622
623 case EMR_STRETCHDIBITS:
624 {
625 EMRSTRETCHDIBITS *pStretchDIBits = (EMRSTRETCHDIBITS *)mr;
626
627 StretchDIBits(hdc,
628 pStretchDIBits->xDest,
629 pStretchDIBits->yDest,
630 pStretchDIBits->cxDest,
631 pStretchDIBits->cyDest,
632 pStretchDIBits->xSrc,
633 pStretchDIBits->ySrc,
634 pStretchDIBits->cxSrc,
635 pStretchDIBits->cySrc,
636 (BYTE *)mr + pStretchDIBits->offBitsSrc,
637 (const BITMAPINFO *)((BYTE *)mr + pStretchDIBits->offBmiSrc),
638 pStretchDIBits->iUsageSrc,
639 pStretchDIBits->dwRop);
640 break;
641 }
642
643 case EMR_EXTTEXTOUTA:
644 {
645 PEMREXTTEXTOUTA pExtTextOutA = (PEMREXTTEXTOUTA)mr;
646 RECT rc;
647
648 rc.left = pExtTextOutA->emrtext.rcl.left;
649 rc.top = pExtTextOutA->emrtext.rcl.top;
650 rc.right = pExtTextOutA->emrtext.rcl.right;
651 rc.bottom = pExtTextOutA->emrtext.rcl.bottom;
652 ExtTextOutA(hdc, pExtTextOutA->emrtext.ptlReference.x, pExtTextOutA->emrtext.ptlReference.y,
653 pExtTextOutA->emrtext.fOptions, &rc,
654 (LPSTR)((BYTE *)mr + pExtTextOutA->emrtext.offString), pExtTextOutA->emrtext.nChars,
655 (INT *)((BYTE *)mr + pExtTextOutA->emrtext.offDx));
656 break;
657 }
658
659 case EMR_EXTTEXTOUTW:
660 {
661 PEMREXTTEXTOUTW pExtTextOutW = (PEMREXTTEXTOUTW)mr;
662 RECT rc;
663
664 rc.left = pExtTextOutW->emrtext.rcl.left;
665 rc.top = pExtTextOutW->emrtext.rcl.top;
666 rc.right = pExtTextOutW->emrtext.rcl.right;
667 rc.bottom = pExtTextOutW->emrtext.rcl.bottom;
668 ExtTextOutW(hdc, pExtTextOutW->emrtext.ptlReference.x, pExtTextOutW->emrtext.ptlReference.y,
669 pExtTextOutW->emrtext.fOptions, &rc,
670 (LPWSTR)((BYTE *)mr + pExtTextOutW->emrtext.offString), pExtTextOutW->emrtext.nChars,
671 (INT *)((BYTE *)mr + pExtTextOutW->emrtext.offDx));
672 break;
673 }
674
675 case EMR_CREATEPALETTE:
676 {
677 PEMRCREATEPALETTE lpCreatePal = (PEMRCREATEPALETTE)mr;
678
679 (handletable->objectHandle)[ lpCreatePal->ihPal ] =
680 CreatePalette( &lpCreatePal->lgpl );
681
682 break;
683 }
684
685 case EMR_SELECTPALETTE:
686 {
687 PEMRSELECTPALETTE lpSelectPal = (PEMRSELECTPALETTE)mr;
688
689 if( lpSelectPal->ihPal & 0x80000000 ) {
690 SelectPalette( hdc, GetStockObject(lpSelectPal->ihPal & 0x7fffffff), TRUE);
691 } else {
692 (handletable->objectHandle)[ lpSelectPal->ihPal ] =
693 SelectPalette( hdc, (handletable->objectHandle)[lpSelectPal->ihPal], TRUE);
694 }
695 break;
696 }
697
698 case EMR_REALIZEPALETTE:
699 {
700 RealizePalette( hdc );
701 break;
702 }
703
704 case EMR_EXTSELECTCLIPRGN:
705 {
706 PEMREXTSELECTCLIPRGN lpRgn = (PEMREXTSELECTCLIPRGN)mr;
707
708 if ((lpRgn->cbRgnData == 0) && (lpRgn->iMode == RGN_COPY)) {
709 ExtSelectClipRgn( hdc, 0, RGN_COPY );
710 } else {
711 FIXME("EMR_EXTSELECTCLIPRGN cbRgnData %lu\n", lpRgn->cbRgnData);
712
713 /* Need to make a region out of the RGNDATA we have */
714 /* ExtCreateRegion(....); */
715 /* ExtSelectClipRgn( hdc, ..., (INT)(lpRgn->iMode) ); */
716 }
717
718 break;
719 }
720
721 case EMR_SETMETARGN:
722 {
723 SetMetaRgn( hdc );
724 break;
725 }
726
727 case EMR_SETWORLDTRANSFORM:
728 {
729 PEMRSETWORLDTRANSFORM lpXfrm = (PEMRSETWORLDTRANSFORM)mr;
730 SetWorldTransform( hdc, &lpXfrm->xform );
731 break;
732 }
733
734 case EMR_POLYBEZIER:
735 {
736 PEMRPOLYBEZIER lpPolyBez = (PEMRPOLYBEZIER)mr;
737 PolyBezier(hdc, (const LPPOINT)lpPolyBez->aptl, (UINT)lpPolyBez->cptl);
738 break;
739 }
740
741 case EMR_POLYGON:
742 {
743 PEMRPOLYGON lpPoly = (PEMRPOLYGON)mr;
744 Polygon( hdc, (const LPPOINT)lpPoly->aptl, (UINT)lpPoly->cptl );
745 break;
746 }
747
748 case EMR_POLYLINE:
749 {
750 PEMRPOLYLINE lpPolyLine = (PEMRPOLYLINE)mr;
751 Polyline(hdc, (const LPPOINT)lpPolyLine->aptl, (UINT)lpPolyLine->cptl);
752 break;
753 }
754
755 case EMR_POLYBEZIERTO:
756 {
757 PEMRPOLYBEZIERTO lpPolyBezierTo = (PEMRPOLYBEZIERTO)mr;
758 PolyBezierTo( hdc, (const LPPOINT)lpPolyBezierTo->aptl,
759 (UINT)lpPolyBezierTo->cptl );
760 break;
761 }
762
763 case EMR_POLYLINETO:
764 {
765 PEMRPOLYLINETO lpPolyLineTo = (PEMRPOLYLINETO)mr;
766 PolylineTo( hdc, (const LPPOINT)lpPolyLineTo->aptl,
767 (UINT)lpPolyLineTo->cptl );
768 break;
769 }
770
771 case EMR_POLYPOLYLINE:
772 {
773 PEMRPOLYPOLYLINE pPolyPolyline = (PEMRPOLYPOLYLINE) mr;
774 /* NB Points at pPolyPolyline->aPolyCounts + pPolyPolyline->nPolys */
775
776 PolyPolyline(hdc, (LPPOINT)(pPolyPolyline->aPolyCounts +
777 pPolyPolyline->nPolys),
778 pPolyPolyline->aPolyCounts,
779 pPolyPolyline->nPolys );
780
781 break;
782 }
783
784 case EMR_POLYPOLYGON:
785 {
786 PEMRPOLYPOLYGON pPolyPolygon = (PEMRPOLYPOLYGON) mr;
787
788 /* NB Points at pPolyPolygon->aPolyCounts + pPolyPolygon->nPolys */
789
790 PolyPolygon(hdc, (LPPOINT)(pPolyPolygon->aPolyCounts +
791 pPolyPolygon->nPolys),
792 (INT*)pPolyPolygon->aPolyCounts, pPolyPolygon->nPolys );
793 break;
794 }
795
796 case EMR_SETBRUSHORGEX:
797 {
798 PEMRSETBRUSHORGEX lpSetBrushOrgEx = (PEMRSETBRUSHORGEX)mr;
799
800 SetBrushOrgEx( hdc,
801 (INT)lpSetBrushOrgEx->ptlOrigin.x,
802 (INT)lpSetBrushOrgEx->ptlOrigin.y,
803 NULL );
804
805 break;
806 }
807
808 case EMR_SETPIXELV:
809 {
810 PEMRSETPIXELV lpSetPixelV = (PEMRSETPIXELV)mr;
811
812 SetPixelV( hdc,
813 (INT)lpSetPixelV->ptlPixel.x,
814 (INT)lpSetPixelV->ptlPixel.y,
815 lpSetPixelV->crColor );
816
817 break;
818 }
819
820 case EMR_SETMAPPERFLAGS:
821 {
822 PEMRSETMAPPERFLAGS lpSetMapperFlags = (PEMRSETMAPPERFLAGS)mr;
823
824 SetMapperFlags( hdc, lpSetMapperFlags->dwFlags );
825
826 break;
827 }
828
829 case EMR_SETCOLORADJUSTMENT:
830 {
831 PEMRSETCOLORADJUSTMENT lpSetColorAdjust = (PEMRSETCOLORADJUSTMENT)mr;
832
833 SetColorAdjustment( hdc, &lpSetColorAdjust->ColorAdjustment );
834
835 break;
836 }
837
838 case EMR_OFFSETCLIPRGN:
839 {
840 PEMROFFSETCLIPRGN lpOffsetClipRgn = (PEMROFFSETCLIPRGN)mr;
841
842 OffsetClipRgn( hdc,
843 (INT)lpOffsetClipRgn->ptlOffset.x,
844 (INT)lpOffsetClipRgn->ptlOffset.y );
845
846 break;
847 }
848
849 case EMR_EXCLUDECLIPRECT:
850 {
851 PEMREXCLUDECLIPRECT lpExcludeClipRect = (PEMREXCLUDECLIPRECT)mr;
852
853 ExcludeClipRect( hdc,
854 lpExcludeClipRect->rclClip.left,
855 lpExcludeClipRect->rclClip.top,
856 lpExcludeClipRect->rclClip.right,
857 lpExcludeClipRect->rclClip.bottom );
858
859 break;
860 }
861
862 case EMR_SCALEVIEWPORTEXTEX:
863 {
864 PEMRSCALEVIEWPORTEXTEX lpScaleViewportExtEx = (PEMRSCALEVIEWPORTEXTEX)mr;
865
866 ScaleViewportExtEx( hdc,
867 lpScaleViewportExtEx->xNum,
868 lpScaleViewportExtEx->xDenom,
869 lpScaleViewportExtEx->yNum,
870 lpScaleViewportExtEx->yDenom,
871 NULL );
872
873 break;
874 }
875
876 case EMR_SCALEWINDOWEXTEX:
877 {
878 PEMRSCALEWINDOWEXTEX lpScaleWindowExtEx = (PEMRSCALEWINDOWEXTEX)mr;
879
880 ScaleWindowExtEx( hdc,
881 lpScaleWindowExtEx->xNum,
882 lpScaleWindowExtEx->xDenom,
883 lpScaleWindowExtEx->yNum,
884 lpScaleWindowExtEx->yDenom,
885 NULL );
886
887 break;
888 }
889
890 case EMR_MODIFYWORLDTRANSFORM:
891 {
892 PEMRMODIFYWORLDTRANSFORM lpModifyWorldTrans = (PEMRMODIFYWORLDTRANSFORM)mr;
893
894 ModifyWorldTransform( hdc, &lpModifyWorldTrans->xform,
895 lpModifyWorldTrans->iMode );
896
897 break;
898 }
899
900 case EMR_ANGLEARC:
901 {
902 PEMRANGLEARC lpAngleArc = (PEMRANGLEARC)mr;
903
904 AngleArc( hdc,
905 (INT)lpAngleArc->ptlCenter.x, (INT)lpAngleArc->ptlCenter.y,
906 lpAngleArc->nRadius, lpAngleArc->eStartAngle,
907 lpAngleArc->eSweepAngle );
908
909 break;
910 }
911
912 case EMR_ROUNDRECT:
913 {
914 PEMRROUNDRECT lpRoundRect = (PEMRROUNDRECT)mr;
915
916 RoundRect( hdc,
917 lpRoundRect->rclBox.left,
918 lpRoundRect->rclBox.top,
919 lpRoundRect->rclBox.right,
920 lpRoundRect->rclBox.bottom,
921 lpRoundRect->szlCorner.cx,
922 lpRoundRect->szlCorner.cy );
923
924 break;
925 }
926
927 case EMR_ARC:
928 {
929 PEMRARC lpArc = (PEMRARC)mr;
930
931 Arc( hdc,
932 (INT)lpArc->rclBox.left,
933 (INT)lpArc->rclBox.top,
934 (INT)lpArc->rclBox.right,
935 (INT)lpArc->rclBox.bottom,
936 (INT)lpArc->ptlStart.x,
937 (INT)lpArc->ptlStart.y,
938 (INT)lpArc->ptlEnd.x,
939 (INT)lpArc->ptlEnd.y );
940
941 break;
942 }
943
944 case EMR_CHORD:
945 {
946 PEMRCHORD lpChord = (PEMRCHORD)mr;
947
948 Chord( hdc,
949 (INT)lpChord->rclBox.left,
950 (INT)lpChord->rclBox.top,
951 (INT)lpChord->rclBox.right,
952 (INT)lpChord->rclBox.bottom,
953 (INT)lpChord->ptlStart.x,
954 (INT)lpChord->ptlStart.y,
955 (INT)lpChord->ptlEnd.x,
956 (INT)lpChord->ptlEnd.y );
957
958 break;
959 }
960
961 case EMR_PIE:
962 {
963 PEMRPIE lpPie = (PEMRPIE)mr;
964
965 Pie( hdc,
966 (INT)lpPie->rclBox.left,
967 (INT)lpPie->rclBox.top,
968 (INT)lpPie->rclBox.right,
969 (INT)lpPie->rclBox.bottom,
970 (INT)lpPie->ptlStart.x,
971 (INT)lpPie->ptlStart.y,
972 (INT)lpPie->ptlEnd.x,
973 (INT)lpPie->ptlEnd.y );
974
975 break;
976 }
977
978 case EMR_ARCTO:
979 {
980 PEMRARC lpArcTo = (PEMRARC)mr;
981
982 ArcTo( hdc,
983 (INT)lpArcTo->rclBox.left,
984 (INT)lpArcTo->rclBox.top,
985 (INT)lpArcTo->rclBox.right,
986 (INT)lpArcTo->rclBox.bottom,
987 (INT)lpArcTo->ptlStart.x,
988 (INT)lpArcTo->ptlStart.y,
989 (INT)lpArcTo->ptlEnd.x,
990 (INT)lpArcTo->ptlEnd.y );
991
992 break;
993 }
994
995 case EMR_EXTFLOODFILL:
996 {
997 PEMREXTFLOODFILL lpExtFloodFill = (PEMREXTFLOODFILL)mr;
998
999 ExtFloodFill( hdc,
1000 (INT)lpExtFloodFill->ptlStart.x,
1001 (INT)lpExtFloodFill->ptlStart.y,
1002 lpExtFloodFill->crColor,
1003 (UINT)lpExtFloodFill->iMode );
1004
1005 break;
1006 }
1007
1008 case EMR_POLYDRAW:
1009 {
1010 PEMRPOLYDRAW lpPolyDraw = (PEMRPOLYDRAW)mr;
1011 PolyDraw( hdc,
1012 (const LPPOINT)lpPolyDraw->aptl,
1013 lpPolyDraw->abTypes,
1014 (INT)lpPolyDraw->cptl );
1015
1016 break;
1017 }
1018
1019 case EMR_SETARCDIRECTION:
1020 {
1021 PEMRSETARCDIRECTION lpSetArcDirection = (PEMRSETARCDIRECTION)mr;
1022 SetArcDirection( hdc, (INT)lpSetArcDirection->iArcDirection );
1023 break;
1024 }
1025
1026 case EMR_SETMITERLIMIT:
1027 {
1028 PEMRSETMITERLIMIT lpSetMiterLimit = (PEMRSETMITERLIMIT)mr;
1029 SetMiterLimit( hdc, lpSetMiterLimit->eMiterLimit, NULL );
1030 break;
1031 }
1032
1033 case EMR_BEGINPATH:
1034 {
1035 BeginPath( hdc );
1036 break;
1037 }
1038
1039 case EMR_ENDPATH:
1040 {
1041 EndPath( hdc );
1042 break;
1043 }
1044
1045 case EMR_CLOSEFIGURE:
1046 {
1047 CloseFigure( hdc );
1048 break;
1049 }
1050
1051 case EMR_FILLPATH:
1052 {
1053 /*PEMRFILLPATH lpFillPath = (PEMRFILLPATH)mr;*/
1054 FillPath( hdc );
1055 break;
1056 }
1057
1058 case EMR_STROKEANDFILLPATH:
1059 {
1060 /*PEMRSTROKEANDFILLPATH lpStrokeAndFillPath = (PEMRSTROKEANDFILLPATH)mr;*/
1061 StrokeAndFillPath( hdc );
1062 break;
1063 }
1064
1065 case EMR_STROKEPATH:
1066 {
1067 /*PEMRSTROKEPATH lpStrokePath = (PEMRSTROKEPATH)mr;*/
1068 StrokePath( hdc );
1069 break;
1070 }
1071
1072 case EMR_FLATTENPATH:
1073 {
1074 FlattenPath( hdc );
1075 break;
1076 }
1077
1078 case EMR_WIDENPATH:
1079 {
1080 WidenPath( hdc );
1081 break;
1082 }
1083
1084 case EMR_SELECTCLIPPATH:
1085 {
1086 PEMRSELECTCLIPPATH lpSelectClipPath = (PEMRSELECTCLIPPATH)mr;
1087 SelectClipPath( hdc, (INT)lpSelectClipPath->iMode );
1088 break;
1089 }
1090
1091 case EMR_ABORTPATH:
1092 {
1093 AbortPath( hdc );
1094 break;
1095 }
1096
1097 case EMR_CREATECOLORSPACE:
1098 {
1099 PEMRCREATECOLORSPACE lpCreateColorSpace = (PEMRCREATECOLORSPACE)mr;
1100 (handletable->objectHandle)[lpCreateColorSpace->ihCS] =
1101 CreateColorSpaceA( &lpCreateColorSpace->lcs );
1102 break;
1103 }
1104
1105 case EMR_SETCOLORSPACE:
1106 {
1107 PEMRSETCOLORSPACE lpSetColorSpace = (PEMRSETCOLORSPACE)mr;
1108 SetColorSpace( hdc,
1109 (handletable->objectHandle)[lpSetColorSpace->ihCS] );
1110 break;
1111 }
1112
1113 case EMR_DELETECOLORSPACE:
1114 {
1115 PEMRDELETECOLORSPACE lpDeleteColorSpace = (PEMRDELETECOLORSPACE)mr;
1116 DeleteColorSpace( (handletable->objectHandle)[lpDeleteColorSpace->ihCS] );
1117 break;
1118 }
1119
1120 case EMR_SETICMMODE:
1121 {
1122 PERMSETICMMODE lpSetICMMode = (PERMSETICMMODE)mr;
1123 SetICMMode( hdc, (INT)lpSetICMMode->iMode );
1124 break;
1125 }
1126
1127 case EMR_PIXELFORMAT:
1128 {
1129 INT iPixelFormat;
1130 PEMRPIXELFORMAT lpPixelFormat = (PEMRPIXELFORMAT)mr;
1131
1132 iPixelFormat = ChoosePixelFormat( hdc, &lpPixelFormat->pfd );
1133 SetPixelFormat( hdc, iPixelFormat, &lpPixelFormat->pfd );
1134
1135 break;
1136 }
1137
1138 case EMR_SETPALETTEENTRIES:
1139 {
1140 PEMRSETPALETTEENTRIES lpSetPaletteEntries = (PEMRSETPALETTEENTRIES)mr;
1141
1142 SetPaletteEntries( (handletable->objectHandle)[lpSetPaletteEntries->ihPal],
1143 (UINT)lpSetPaletteEntries->iStart,
1144 (UINT)lpSetPaletteEntries->cEntries,
1145 lpSetPaletteEntries->aPalEntries );
1146
1147 break;
1148 }
1149
1150 case EMR_RESIZEPALETTE:
1151 {
1152 PEMRRESIZEPALETTE lpResizePalette = (PEMRRESIZEPALETTE)mr;
1153
1154 ResizePalette( (handletable->objectHandle)[lpResizePalette->ihPal],
1155 (UINT)lpResizePalette->cEntries );
1156
1157 break;
1158 }
1159
1160 case EMR_CREATEDIBPATTERNBRUSHPT:
1161 {
1162 PEMRCREATEDIBPATTERNBRUSHPT lpCreate = (PEMRCREATEDIBPATTERNBRUSHPT)mr;
1163
1164 /* This is a BITMAPINFO struct followed directly by bitmap bits */
1165 LPVOID lpPackedStruct = HeapAlloc( GetProcessHeap(),
1166 0,
1167 lpCreate->cbBmi + lpCreate->cbBits );
1168 /* Now pack this structure */
1169 memcpy( lpPackedStruct,
1170 ((BYTE*)lpCreate) + lpCreate->offBmi,
1171 lpCreate->cbBmi );
1172 memcpy( ((BYTE*)lpPackedStruct) + lpCreate->cbBmi,
1173 ((BYTE*)lpCreate) + lpCreate->offBits,
1174 lpCreate->cbBits );
1175
1176 (handletable->objectHandle)[lpCreate->ihBrush] =
1177 CreateDIBPatternBrushPt( lpPackedStruct,
1178 (UINT)lpCreate->iUsage );
1179
1180 break;
1181 }
1182
1183 case EMR_CREATEMONOBRUSH:
1184 {
1185 PEMRCREATEMONOBRUSH pCreateMonoBrush = (PEMRCREATEMONOBRUSH)mr;
1186 BITMAPINFO *pbi = (BITMAPINFO *)((BYTE *)mr + pCreateMonoBrush->offBmi);
1187 HBITMAP hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1188 (BYTE *)mr + pCreateMonoBrush->offBits, pbi, pCreateMonoBrush->iUsage);
1189 (handletable->objectHandle)[pCreateMonoBrush->ihBrush] = CreatePatternBrush(hBmp);
1190 /* CreatePatternBrush created a copy of the bitmap */
1191 DeleteObject(hBmp);
1192 break;
1193 }
1194
1195 case EMR_BITBLT:
1196 {
1197 PEMRBITBLT pBitBlt = (PEMRBITBLT)mr;
1198 HDC hdcSrc = CreateCompatibleDC(hdc);
1199 HBRUSH hBrush, hBrushOld;
1200 HBITMAP hBmp, hBmpOld;
1201 BITMAPINFO *pbi = (BITMAPINFO *)((BYTE *)mr + pBitBlt->offBmiSrc);
1202
1203 SetWorldTransform(hdcSrc, &pBitBlt->xformSrc);
1204
1205 hBrush = CreateSolidBrush(pBitBlt->crBkColorSrc);
1206 hBrushOld = SelectObject(hdcSrc, hBrush);
1207 PatBlt(hdcSrc, pBitBlt->rclBounds.left, pBitBlt->rclBounds.top,
1208 pBitBlt->rclBounds.right - pBitBlt->rclBounds.left,
1209 pBitBlt->rclBounds.bottom - pBitBlt->rclBounds.top, PATCOPY);
1210 SelectObject(hdcSrc, hBrushOld);
1211 DeleteObject(hBrush);
1212
1213 hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1214 (BYTE *)mr + pBitBlt->offBitsSrc, pbi, pBitBlt->iUsageSrc);
1215 hBmpOld = SelectObject(hdcSrc, hBmp);
1216 BitBlt(hdc,
1217 pBitBlt->xDest,
1218 pBitBlt->yDest,
1219 pBitBlt->cxDest,
1220 pBitBlt->cyDest,
1221 hdcSrc,
1222 pBitBlt->xSrc,
1223 pBitBlt->ySrc,
1224 pBitBlt->dwRop);
1225 SelectObject(hdcSrc, hBmpOld);
1226 DeleteObject(hBmp);
1227 DeleteDC(hdcSrc);
1228 break;
1229 }
1230
1231 case EMR_STRETCHBLT:
1232 {
1233 PEMRSTRETCHBLT pStretchBlt= (PEMRSTRETCHBLT)mr;
1234 HDC hdcSrc = CreateCompatibleDC(hdc);
1235 HBRUSH hBrush, hBrushOld;
1236 HBITMAP hBmp, hBmpOld;
1237 BITMAPINFO *pbi = (BITMAPINFO *)((BYTE *)mr + pStretchBlt->offBmiSrc);
1238
1239 SetWorldTransform(hdcSrc, &pStretchBlt->xformSrc);
1240
1241 hBrush = CreateSolidBrush(pStretchBlt->crBkColorSrc);
1242 hBrushOld = SelectObject(hdcSrc, hBrush);
1243 PatBlt(hdcSrc, pStretchBlt->rclBounds.left, pStretchBlt->rclBounds.top,
1244 pStretchBlt->rclBounds.right - pStretchBlt->rclBounds.left,
1245 pStretchBlt->rclBounds.bottom - pStretchBlt->rclBounds.top, PATCOPY);
1246 SelectObject(hdcSrc, hBrushOld);
1247 DeleteObject(hBrush);
1248
1249 hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1250 (BYTE *)mr + pStretchBlt->offBitsSrc, pbi, pStretchBlt->iUsageSrc);
1251 hBmpOld = SelectObject(hdcSrc, hBmp);
1252 StretchBlt(hdc,
1253 pStretchBlt->xDest,
1254 pStretchBlt->yDest,
1255 pStretchBlt->cxDest,
1256 pStretchBlt->cyDest,
1257 hdcSrc,
1258 pStretchBlt->xSrc,
1259 pStretchBlt->ySrc,
1260 pStretchBlt->cxSrc,
1261 pStretchBlt->cySrc,
1262 pStretchBlt->dwRop);
1263 SelectObject(hdcSrc, hBmpOld);
1264 DeleteObject(hBmp);
1265 DeleteDC(hdcSrc);
1266 break;
1267 }
1268
1269 case EMR_MASKBLT:
1270 {
1271 PEMRMASKBLT pMaskBlt= (PEMRMASKBLT)mr;
1272 HDC hdcSrc = CreateCompatibleDC(hdc);
1273 HBRUSH hBrush, hBrushOld;
1274 HBITMAP hBmp, hBmpOld, hBmpMask;
1275 BITMAPINFO *pbi;
1276
1277 SetWorldTransform(hdcSrc, &pMaskBlt->xformSrc);
1278
1279 hBrush = CreateSolidBrush(pMaskBlt->crBkColorSrc);
1280 hBrushOld = SelectObject(hdcSrc, hBrush);
1281 PatBlt(hdcSrc, pMaskBlt->rclBounds.left, pMaskBlt->rclBounds.top,
1282 pMaskBlt->rclBounds.right - pMaskBlt->rclBounds.left,
1283 pMaskBlt->rclBounds.bottom - pMaskBlt->rclBounds.top, PATCOPY);
1284 SelectObject(hdcSrc, hBrushOld);
1285 DeleteObject(hBrush);
1286
1287 pbi = (BITMAPINFO *)((BYTE *)mr + pMaskBlt->offBmiMask);
1288 hBmpMask = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1289 (BYTE *)mr + pMaskBlt->offBitsMask, pbi, pMaskBlt->iUsageMask);
1290
1291 pbi = (BITMAPINFO *)((BYTE *)mr + pMaskBlt->offBmiSrc);
1292 hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1293 (BYTE *)mr + pMaskBlt->offBitsSrc, pbi, pMaskBlt->iUsageSrc);
1294 hBmpOld = SelectObject(hdcSrc, hBmp);
1295 MaskBlt(hdc,
1296 pMaskBlt->xDest,
1297 pMaskBlt->yDest,
1298 pMaskBlt->cxDest,
1299 pMaskBlt->cyDest,
1300 hdcSrc,
1301 pMaskBlt->xSrc,
1302 pMaskBlt->ySrc,
1303 hBmpMask,
1304 pMaskBlt->xMask,
1305 pMaskBlt->yMask,
1306 pMaskBlt->dwRop);
1307 SelectObject(hdcSrc, hBmpOld);
1308 DeleteObject(hBmp);
1309 DeleteObject(hBmpMask);
1310 DeleteDC(hdcSrc);
1311 break;
1312 }
1313
1314 case EMR_PLGBLT:
1315 {
1316 PEMRPLGBLT pPlgBlt= (PEMRPLGBLT)mr;
1317 HDC hdcSrc = CreateCompatibleDC(hdc);
1318 HBRUSH hBrush, hBrushOld;
1319 HBITMAP hBmp, hBmpOld, hBmpMask;
1320 BITMAPINFO *pbi;
1321 POINT pts[3];
1322
1323 SetWorldTransform(hdcSrc, &pPlgBlt->xformSrc);
1324
1325 pts[0].x = pPlgBlt->aptlDst[0].x; pts[0].y = pPlgBlt->aptlDst[0].y;
1326 pts[1].x = pPlgBlt->aptlDst[1].x; pts[1].y = pPlgBlt->aptlDst[1].y;
1327 pts[2].x = pPlgBlt->aptlDst[2].x; pts[2].y = pPlgBlt->aptlDst[2].y;
1328
1329 hBrush = CreateSolidBrush(pPlgBlt->crBkColorSrc);
1330 hBrushOld = SelectObject(hdcSrc, hBrush);
1331 PatBlt(hdcSrc, pPlgBlt->rclBounds.left, pPlgBlt->rclBounds.top,
1332 pPlgBlt->rclBounds.right - pPlgBlt->rclBounds.left,
1333 pPlgBlt->rclBounds.bottom - pPlgBlt->rclBounds.top, PATCOPY);
1334 SelectObject(hdcSrc, hBrushOld);
1335 DeleteObject(hBrush);
1336
1337 pbi = (BITMAPINFO *)((BYTE *)mr + pPlgBlt->offBmiMask);
1338 hBmpMask = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1339 (BYTE *)mr + pPlgBlt->offBitsMask, pbi, pPlgBlt->iUsageMask);
1340
1341 pbi = (BITMAPINFO *)((BYTE *)mr + pPlgBlt->offBmiSrc);
1342 hBmp = CreateDIBitmap(0, (BITMAPINFOHEADER *)pbi, CBM_INIT,
1343 (BYTE *)mr + pPlgBlt->offBitsSrc, pbi, pPlgBlt->iUsageSrc);
1344 hBmpOld = SelectObject(hdcSrc, hBmp);
1345 PlgBlt(hdc,
1346 pts,
1347 hdcSrc,
1348 pPlgBlt->xSrc,
1349 pPlgBlt->ySrc,
1350 pPlgBlt->cxSrc,
1351 pPlgBlt->cySrc,
1352 hBmpMask,
1353 pPlgBlt->xMask,
1354 pPlgBlt->yMask);
1355 SelectObject(hdcSrc, hBmpOld);
1356 DeleteObject(hBmp);
1357 DeleteObject(hBmpMask);
1358 DeleteDC(hdcSrc);
1359 break;
1360 }
1361
1362 case EMR_SETDIBITSTODEVICE:
1363 {
1364 PEMRSETDIBITSTODEVICE pSetDIBitsToDevice = (PEMRSETDIBITSTODEVICE)mr;
1365
1366 SetDIBitsToDevice(hdc,
1367 pSetDIBitsToDevice->xDest,
1368 pSetDIBitsToDevice->yDest,
1369 pSetDIBitsToDevice->cxSrc,
1370 pSetDIBitsToDevice->cySrc,
1371 pSetDIBitsToDevice->xSrc,
1372 pSetDIBitsToDevice->ySrc,
1373 pSetDIBitsToDevice->iStartScan,
1374 pSetDIBitsToDevice->cScans,
1375 (BYTE *)mr + pSetDIBitsToDevice->offBitsSrc,
1376 (BITMAPINFO *)((BYTE *)mr + pSetDIBitsToDevice->offBmiSrc),
1377 pSetDIBitsToDevice->iUsageSrc);
1378 break;
1379 }
1380
1381 case EMR_POLYTEXTOUTA:
1382 {
1383 PEMRPOLYTEXTOUTA pPolyTextOutA = (PEMRPOLYTEXTOUTA)mr;
1384 POLYTEXTA *polytextA = HeapAlloc(GetProcessHeap(), 0, pPolyTextOutA->cStrings * sizeof(POLYTEXTA));
1385 LONG i;
1386 XFORM xform, xformOld;
1387 int gModeOld;
1388
1389 gModeOld = SetGraphicsMode(hdc, pPolyTextOutA->iGraphicsMode);
1390 GetWorldTransform(hdc, &xformOld);
1391
1392 xform.eM11 = pPolyTextOutA->exScale;
1393 xform.eM12 = 0.0;
1394 xform.eM21 = 0.0;
1395 xform.eM22 = pPolyTextOutA->eyScale;
1396 xform.eDx = 0.0;
1397 xform.eDy = 0.0;
1398 SetWorldTransform(hdc, &xform);
1399
1400 /* Set up POLYTEXTA structures */
1401 for(i = 0; i < pPolyTextOutA->cStrings; i++)
1402 {
1403 polytextA[i].x = pPolyTextOutA->aemrtext[i].ptlReference.x;
1404 polytextA[i].y = pPolyTextOutA->aemrtext[i].ptlReference.y;
1405 polytextA[i].n = pPolyTextOutA->aemrtext[i].nChars;
1406 polytextA[i].lpstr = (LPSTR)((BYTE *)mr + pPolyTextOutA->aemrtext[i].offString);
1407 polytextA[i].uiFlags = pPolyTextOutA->aemrtext[i].fOptions;
1408 polytextA[i].rcl.left = pPolyTextOutA->aemrtext[i].rcl.left;
1409 polytextA[i].rcl.right = pPolyTextOutA->aemrtext[i].rcl.right;
1410 polytextA[i].rcl.top = pPolyTextOutA->aemrtext[i].rcl.top;
1411 polytextA[i].rcl.bottom = pPolyTextOutA->aemrtext[i].rcl.bottom;
1412 polytextA[i].pdx = (int *)((BYTE *)mr + pPolyTextOutA->aemrtext[i].offDx);
1413 }
1414 PolyTextOutA(hdc, polytextA, pPolyTextOutA->cStrings);
1415 HeapFree(GetProcessHeap(), 0, polytextA);
1416
1417 SetWorldTransform(hdc, &xformOld);
1418 SetGraphicsMode(hdc, gModeOld);
1419 break;
1420 }
1421
1422 case EMR_POLYTEXTOUTW:
1423 {
1424 PEMRPOLYTEXTOUTW pPolyTextOutW = (PEMRPOLYTEXTOUTW)mr;
1425 POLYTEXTW *polytextW = HeapAlloc(GetProcessHeap(), 0, pPolyTextOutW->cStrings * sizeof(POLYTEXTW));
1426 LONG i;
1427 XFORM xform, xformOld;
1428 int gModeOld;
1429
1430 gModeOld = SetGraphicsMode(hdc, pPolyTextOutW->iGraphicsMode);
1431 GetWorldTransform(hdc, &xformOld);
1432
1433 xform.eM11 = pPolyTextOutW->exScale;
1434 xform.eM12 = 0.0;
1435 xform.eM21 = 0.0;
1436 xform.eM22 = pPolyTextOutW->eyScale;
1437 xform.eDx = 0.0;
1438 xform.eDy = 0.0;
1439 SetWorldTransform(hdc, &xform);
1440
1441 /* Set up POLYTEXTW structures */
1442 for(i = 0; i < pPolyTextOutW->cStrings; i++)
1443 {
1444 polytextW[i].x = pPolyTextOutW->aemrtext[i].ptlReference.x;
1445 polytextW[i].y = pPolyTextOutW->aemrtext[i].ptlReference.y;
1446 polytextW[i].n = pPolyTextOutW->aemrtext[i].nChars;
1447 polytextW[i].lpstr = (LPWSTR)((BYTE *)mr + pPolyTextOutW->aemrtext[i].offString);
1448 polytextW[i].uiFlags = pPolyTextOutW->aemrtext[i].fOptions;
1449 polytextW[i].rcl.left = pPolyTextOutW->aemrtext[i].rcl.left;
1450 polytextW[i].rcl.right = pPolyTextOutW->aemrtext[i].rcl.right;
1451 polytextW[i].rcl.top = pPolyTextOutW->aemrtext[i].rcl.top;
1452 polytextW[i].rcl.bottom = pPolyTextOutW->aemrtext[i].rcl.bottom;
1453 polytextW[i].pdx = (int *)((BYTE *)mr + pPolyTextOutW->aemrtext[i].offDx);
1454 }
1455 PolyTextOutW(hdc, polytextW, pPolyTextOutW->cStrings);
1456 HeapFree(GetProcessHeap(), 0, polytextW);
1457
1458 SetWorldTransform(hdc, &xformOld);
1459 SetGraphicsMode(hdc, gModeOld);
1460 break;
1461 }
1462
1463 case EMR_FILLRGN:
1464 {
1465 PEMRFILLRGN pFillRgn = (PEMRFILLRGN)mr;
1466 HRGN hRgn = ExtCreateRegion(NULL, pFillRgn->cbRgnData, (RGNDATA *)pFillRgn->RgnData);
1467 FillRgn(hdc,
1468 hRgn,
1469 (handletable->objectHandle)[pFillRgn->ihBrush]);
1470 DeleteObject(hRgn);
1471 break;
1472 }
1473
1474 case EMR_FRAMERGN:
1475 {
1476 PEMRFRAMERGN pFrameRgn = (PEMRFRAMERGN)mr;
1477 HRGN hRgn = ExtCreateRegion(NULL, pFrameRgn->cbRgnData, (RGNDATA *)pFrameRgn->RgnData);
1478 FrameRgn(hdc,
1479 hRgn,
1480 (handletable->objectHandle)[pFrameRgn->ihBrush],
1481 pFrameRgn->szlStroke.cx,
1482 pFrameRgn->szlStroke.cy);
1483 DeleteObject(hRgn);
1484 break;
1485 }
1486
1487 case EMR_INVERTRGN:
1488 {
1489 PEMRINVERTRGN pInvertRgn = (PEMRINVERTRGN)mr;
1490 HRGN hRgn = ExtCreateRegion(NULL, pInvertRgn->cbRgnData, (RGNDATA *)pInvertRgn->RgnData);
1491 InvertRgn(hdc, hRgn);
1492 DeleteObject(hRgn);
1493 break;
1494 }
1495
1496 case EMR_PAINTRGN:
1497 {
1498 PEMRPAINTRGN pPaintRgn = (PEMRPAINTRGN)mr;
1499 HRGN hRgn = ExtCreateRegion(NULL, pPaintRgn->cbRgnData, (RGNDATA *)pPaintRgn->RgnData);
1500 PaintRgn(hdc, hRgn);
1501 DeleteObject(hRgn);
1502 break;
1503 }
1504
1505 case EMR_POLYDRAW16:
1506 case EMR_GLSRECORD:
1507 case EMR_GLSBOUNDEDRECORD:
1508 default:
1509 /* From docs: If PlayEnhMetaFileRecord doesn't recognize a
1510 record then ignore and return TRUE. */
1511 FIXME("type %d is unimplemented\n", type);
1512 break;
1513 }
1514 return TRUE;
1515 }
1516
1517
1518 /*****************************************************************************
1519 *
1520 * EnumEnhMetaFile (GDI32.@)
1521 *
1522 * Walk an enhanced metafile, calling a user-specified function _EnhMetaFunc_
1523 * for each
1524 * record. Returns when either every record has been used or
1525 * when _EnhMetaFunc_ returns FALSE.
1526 *
1527 *
1528 * RETURNS
1529 * TRUE if every record is used, FALSE if any invocation of _EnhMetaFunc_
1530 * returns FALSE.
1531 *
1532 * BUGS
1533 * Ignores rect.
1534 */
1535 BOOL WINAPI EnumEnhMetaFile(
1536 HDC hdc, /* [in] device context to pass to _EnhMetaFunc_ */
1537 HENHMETAFILE hmf, /* [in] EMF to walk */
1538 ENHMFENUMPROC callback, /* [in] callback function */
1539 LPVOID data, /* [in] optional data for callback function */
1540 const RECT *lpRect /* [in] bounding rectangle for rendered metafile */
1541 )
1542 {
1543 BOOL ret;
1544 ENHMETAHEADER *emh, *emhTemp;
1545 ENHMETARECORD *emr;
1546 DWORD offset;
1547 UINT i;
1548 HANDLETABLE *ht;
1549 INT savedMode = 0;
1550 FLOAT xSrcPixSize, ySrcPixSize, xscale, yscale;
1551 XFORM savedXform, xform;
1552 HPEN hPen = (HPEN)NULL;
1553 HBRUSH hBrush = (HBRUSH)NULL;
1554 HFONT hFont = (HFONT)NULL;
1555
1556 if(!lpRect)
1557 {
1558 SetLastError(ERROR_INVALID_PARAMETER);
1559 return FALSE;
1560 }
1561
1562 emh = EMF_GetEnhMetaHeader(hmf);
1563 if(!emh) {
1564 SetLastError(ERROR_INVALID_HANDLE);
1565 return FALSE;
1566 }
1567
1568 /* Copy the metafile into memory, because we need to avoid deadlock. */
1569 emhTemp = HeapAlloc(GetProcessHeap(), 0, emh->nSize + emh->nBytes);
1570 if(!emhTemp)
1571 {
1572 EMF_ReleaseEnhMetaHeader(hmf);
1573 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1574 return FALSE;
1575 }
1576 memcpy(emhTemp, emh, emh->nSize + emh->nBytes);
1577 emh = emhTemp;
1578 EMF_ReleaseEnhMetaHeader(hmf);
1579
1580 ht = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1581 sizeof(HANDLETABLE) * emh->nHandles );
1582 if(!ht)
1583 {
1584 HeapFree(GetProcessHeap(), 0, emhTemp);
1585 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1586 return FALSE;
1587 }
1588 ht->objectHandle[0] = hmf;
1589
1590 if (hdc)
1591 {
1592 TRACE("rect: %d,%d - %d,%d. rclFrame: %ld,%ld - %ld,%ld\n",
1593 lpRect->left, lpRect->top, lpRect->right, lpRect->bottom,
1594 emh->rclFrame.left, emh->rclFrame.top, emh->rclFrame.right,
1595 emh->rclFrame.bottom);
1596
1597 xSrcPixSize = (FLOAT) emh->szlMillimeters.cx / emh->szlDevice.cx;
1598 ySrcPixSize = (FLOAT) emh->szlMillimeters.cy / emh->szlDevice.cy;
1599 xscale = (FLOAT)(lpRect->right - lpRect->left) * 100.0 /
1600 (emh->rclFrame.right - emh->rclFrame.left) * xSrcPixSize;
1601 yscale = (FLOAT)(lpRect->bottom - lpRect->top) * 100.0 /
1602 (emh->rclFrame.bottom - emh->rclFrame.top) * ySrcPixSize;
1603
1604 xform.eM11 = xscale;
1605 xform.eM12 = 0;
1606 xform.eM21 = 0;
1607 xform.eM22 = yscale;
1608 xform.eDx = (FLOAT) lpRect->left - (lpRect->right - lpRect->left) *
1609 emh->rclFrame.left / (emh->rclFrame.right - emh->rclFrame.left);
1610 xform.eDy = (FLOAT) lpRect->top - (lpRect->bottom - lpRect->top) *
1611 emh->rclFrame.top / (emh->rclFrame.bottom - emh->rclFrame.top);
1612
1613 savedMode = SetGraphicsMode(hdc, GM_ADVANCED);
1614 GetWorldTransform(hdc, &savedXform);
1615
1616 if (!ModifyWorldTransform(hdc, &xform, MWT_RIGHTMULTIPLY)) {
1617 ERR("World transform failed!\n");
1618 }
1619
1620 /* save the current pen, brush and font */
1621 hPen = GetCurrentObject(hdc, OBJ_PEN);
1622 hBrush = GetCurrentObject(hdc, OBJ_BRUSH);
1623 hFont = GetCurrentObject(hdc, OBJ_FONT);
1624 }
1625
1626 TRACE("nSize = %ld, nBytes = %ld, nHandles = %d, nRecords = %ld, nPalEntries = %ld\n",
1627 emh->nSize, emh->nBytes, emh->nHandles, emh->nRecords, emh->nPalEntries);
1628
1629 ret = TRUE;
1630 offset = 0;
1631 while(ret && offset < emh->nBytes)
1632 {
1633 emr = (ENHMETARECORD *)((char *)emh + offset);
1634 TRACE("Calling EnumFunc with record type %ld, size %ld\n", emr->iType, emr->nSize);
1635 ret = (*callback)(hdc, ht, emr, emh->nHandles, data);
1636 offset += emr->nSize;
1637 }
1638
1639 if (hdc)
1640 {
1641 /* restore pen, brush and font */
1642 SelectObject(hdc, hBrush);
1643 SelectObject(hdc, hPen);
1644 SelectObject(hdc, hFont);
1645
1646 SetWorldTransform(hdc, &savedXform);
1647 if (savedMode)
1648 SetGraphicsMode(hdc, savedMode);
1649 }
1650
1651 for(i = 1; i < emh->nHandles; i++) /* Don't delete element 0 (hmf) */
1652 if( (ht->objectHandle)[i] )
1653 DeleteObject( (ht->objectHandle)[i] );
1654
1655 HeapFree( GetProcessHeap(), 0, ht );
1656 HeapFree(GetProcessHeap(), 0, emhTemp);
1657
1658 return ret;
1659 }
1660
1661 static INT CALLBACK EMF_PlayEnhMetaFileCallback(HDC hdc, HANDLETABLE *ht,
1662 ENHMETARECORD *emr,
1663 INT handles, LPVOID data)
1664 {
1665 return PlayEnhMetaFileRecord(hdc, ht, emr, handles);
1666 }
1667
1668 /**************************************************************************
1669 * PlayEnhMetaFile (GDI32.@)
1670 *
1671 * Renders an enhanced metafile into a specified rectangle *lpRect
1672 * in device context hdc.
1673 *
1674 */
1675 BOOL WINAPI PlayEnhMetaFile(
1676 HDC hdc, /* [in] DC to render into */
1677 HENHMETAFILE hmf, /* [in] metafile to render */
1678 const RECT *lpRect /* [in] rectangle to place metafile inside */
1679 )
1680 {
1681 return EnumEnhMetaFile(hdc, hmf, EMF_PlayEnhMetaFileCallback, NULL,
1682 lpRect);
1683 }
1684
1685 /*****************************************************************************
1686 * DeleteEnhMetaFile (GDI32.@)
1687 *
1688 * Deletes an enhanced metafile and frees the associated storage.
1689 */
1690 BOOL WINAPI DeleteEnhMetaFile(HENHMETAFILE hmf)
1691 {
1692 return EMF_Delete_HENHMETAFILE( hmf );
1693 }
1694
1695 /*****************************************************************************
1696 * CopyEnhMetaFileA (GDI32.@) Duplicate an enhanced metafile
1697 *
1698 *
1699 */
1700 HENHMETAFILE WINAPI CopyEnhMetaFileA(
1701 HENHMETAFILE hmfSrc,
1702 LPCSTR file)
1703 {
1704 ENHMETAHEADER *emrSrc = EMF_GetEnhMetaHeader( hmfSrc ), *emrDst;
1705 HENHMETAFILE hmfDst;
1706
1707 if(!emrSrc) return FALSE;
1708 if (!file) {
1709 emrDst = HeapAlloc( GetProcessHeap(), 0, emrSrc->nBytes );
1710 memcpy( emrDst, emrSrc, emrSrc->nBytes );
1711 hmfDst = EMF_Create_HENHMETAFILE( emrDst, 0, 0 );
1712 } else {
1713 HANDLE hFile;
1714 hFile = CreateFileA( file, GENERIC_WRITE | GENERIC_READ, 0, NULL,
1715 CREATE_ALWAYS, 0, 0);
1716 WriteFile( hFile, emrSrc, emrSrc->nBytes, 0, 0);
1717 hmfDst = EMF_GetEnhMetaFile( hFile );
1718 }
1719 EMF_ReleaseEnhMetaHeader( hmfSrc );
1720 return hmfDst;
1721 }
1722
1723
1724 /* Struct to be used to be passed in the LPVOID parameter for cbEnhPaletteCopy */
1725 typedef struct tagEMF_PaletteCopy
1726 {
1727 UINT cEntries;
1728 LPPALETTEENTRY lpPe;
1729 } EMF_PaletteCopy;
1730
1731 /***************************************************************
1732 * Find the EMR_EOF record and then use it to find the
1733 * palette entries for this enhanced metafile.
1734 * The lpData is actually a pointer to a EMF_PaletteCopy struct
1735 * which contains the max number of elements to copy and where
1736 * to copy them to.
1737 *
1738 * NOTE: To be used by GetEnhMetaFilePaletteEntries only!
1739 */
1740 INT CALLBACK cbEnhPaletteCopy( HDC a,
1741 LPHANDLETABLE b,
1742 LPENHMETARECORD lpEMR,
1743 INT c,
1744 LPVOID lpData )
1745 {
1746
1747 if ( lpEMR->iType == EMR_EOF )
1748 {
1749 PEMREOF lpEof = (PEMREOF)lpEMR;
1750 EMF_PaletteCopy* info = (EMF_PaletteCopy*)lpData;
1751 DWORD dwNumPalToCopy = min( lpEof->nPalEntries, info->cEntries );
1752
1753 TRACE( "copying 0x%08lx palettes\n", dwNumPalToCopy );
1754
1755 memcpy( (LPVOID)info->lpPe,
1756 (LPVOID)(((LPSTR)lpEof) + lpEof->offPalEntries),
1757 sizeof( *(info->lpPe) ) * dwNumPalToCopy );
1758
1759 /* Update the passed data as a return code */
1760 info->lpPe = NULL; /* Palettes were copied! */
1761 info->cEntries = (UINT)dwNumPalToCopy;
1762
1763 return FALSE; /* That's all we need */
1764 }
1765
1766 return TRUE;
1767 }
1768
1769 /*****************************************************************************
1770 * GetEnhMetaFilePaletteEntries (GDI32.@)
1771 *
1772 * Copy the palette and report size
1773 *
1774 * BUGS: Error codes (SetLastError) are not set on failures
1775 */
1776 UINT WINAPI GetEnhMetaFilePaletteEntries( HENHMETAFILE hEmf,
1777 UINT cEntries,
1778 LPPALETTEENTRY lpPe )
1779 {
1780 ENHMETAHEADER* enhHeader = EMF_GetEnhMetaHeader( hEmf );
1781 UINT uReturnValue = GDI_ERROR;
1782 EMF_PaletteCopy infoForCallBack;
1783
1784 TRACE( "(%04x,%d,%p)\n", hEmf, cEntries, lpPe );
1785
1786 /* First check if there are any palettes associated with
1787 this metafile. */
1788 if ( enhHeader->nPalEntries == 0 )
1789 {
1790 /* No palette associated with this enhanced metafile */
1791 uReturnValue = 0;
1792 goto done;
1793 }
1794
1795 /* Is the user requesting the number of palettes? */
1796 if ( lpPe == NULL )
1797 {
1798 uReturnValue = (UINT)enhHeader->nPalEntries;
1799 goto done;
1800 }
1801
1802 /* Copy cEntries worth of PALETTEENTRY structs into the buffer */
1803 infoForCallBack.cEntries = cEntries;
1804 infoForCallBack.lpPe = lpPe;
1805
1806 if ( !EnumEnhMetaFile( 0, hEmf, cbEnhPaletteCopy,
1807 &infoForCallBack, NULL ) )
1808 {
1809 goto done;
1810 }
1811
1812 /* Verify that the callback executed correctly */
1813 if ( infoForCallBack.lpPe != NULL )
1814 {
1815 /* Callback proc had error! */
1816 ERR( "cbEnhPaletteCopy didn't execute correctly\n" );
1817 goto done;
1818 }
1819
1820 uReturnValue = infoForCallBack.cEntries;
1821
1822 done:
1823
1824 EMF_ReleaseEnhMetaHeader( hEmf );
1825
1826 return uReturnValue;
1827 }
1828
1829 /******************************************************************
1830 * SetWinMetaFileBits (GDI32.@)
1831 *
1832 * Translate from old style to new style.
1833 *
1834 * BUGS: - This doesn't take the DC and scaling into account
1835 * - Most record conversions aren't implemented
1836 * - Handle slot assignement is primative and most likely doesn't work
1837 */
1838 HENHMETAFILE WINAPI SetWinMetaFileBits(UINT cbBuffer,
1839 CONST BYTE *lpbBuffer,
1840 HDC hdcRef,
1841 CONST METAFILEPICT *lpmfp
1842 )
1843 {
1844 HENHMETAFILE hMf;
1845 LPVOID lpNewEnhMetaFileBuffer = NULL;
1846 UINT uNewEnhMetaFileBufferSize = 0;
1847 BOOL bFoundEOF = FALSE;
1848
1849 FIXME( "(%d,%p,%04x,%p):stub\n", cbBuffer, lpbBuffer, hdcRef, lpmfp );
1850
1851 /* 1. Get the header - skip over this and get straight to the records */
1852
1853 uNewEnhMetaFileBufferSize = sizeof( ENHMETAHEADER );
1854 lpNewEnhMetaFileBuffer = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1855 uNewEnhMetaFileBufferSize );
1856
1857 if( lpNewEnhMetaFileBuffer == NULL )
1858 {
1859 goto error;
1860 }
1861
1862 /* Fill in the header record */
1863 {
1864 LPENHMETAHEADER lpNewEnhMetaFileHeader = (LPENHMETAHEADER)lpNewEnhMetaFileBuffer;
1865
1866 lpNewEnhMetaFileHeader->iType = EMR_HEADER;
1867 lpNewEnhMetaFileHeader->nSize = sizeof( ENHMETAHEADER );
1868
1869 /* FIXME: Not right. Must be able to get this from the DC */
1870 lpNewEnhMetaFileHeader->rclBounds.left = 0;
1871 lpNewEnhMetaFileHeader->rclBounds.right = 0;
1872 lpNewEnhMetaFileHeader->rclBounds.top = 0;
1873 lpNewEnhMetaFileHeader->rclBounds.bottom = 0;
1874
1875 /* FIXME: Not right. Must be able to get this from the DC */
1876 lpNewEnhMetaFileHeader->rclFrame.left = 0;
1877 lpNewEnhMetaFileHeader->rclFrame.right = 0;
1878 lpNewEnhMetaFileHeader->rclFrame.top = 0;
1879 lpNewEnhMetaFileHeader->rclFrame.bottom = 0;
1880
1881 lpNewEnhMetaFileHeader->nHandles = 0; /* No handles yet */
1882
1883 /* FIXME: Add in the rest of the fields to the header */
1884 /* dSignature
1885 nVersion
1886 nRecords
1887 sReserved
1888 nDescription
1889 offDescription
1890 nPalEntries
1891 szlDevice
1892 szlMillimeters
1893 cbPixelFormat
1894 offPixelFormat,
1895 bOpenGL */
1896 }
1897
1898 (char*)lpbBuffer += ((METAHEADER*)lpbBuffer)->mtHeaderSize * 2; /* Point past the header - FIXME: metafile quirk? */
1899
1900 /* 2. Enum over individual records and convert them to the new type of records */
1901 while( !bFoundEOF )
1902 {
1903
1904 LPMETARECORD lpMetaRecord = (LPMETARECORD)lpbBuffer;
1905
1906 #define EMF_ReAllocAndAdjustPointers( a , b ) \
1907 { \
1908 LPVOID lpTmp; \
1909 lpTmp = HeapReAlloc( GetProcessHeap(), 0, \
1910 lpNewEnhMetaFileBuffer, \
1911 uNewEnhMetaFileBufferSize + (b) ); \
1912 if( lpTmp == NULL ) { ERR( "No memory!\n" ); goto error; } \
1913 lpNewEnhMetaFileBuffer = lpTmp; \
1914 lpRecord = (a)( (char*)lpNewEnhMetaFileBuffer + uNewEnhMetaFileBufferSize ); \
1915 uNewEnhMetaFileBufferSize += (b); \
1916 }
1917
1918 switch( lpMetaRecord->rdFunction )
1919 {
1920 case META_EOF:
1921 {
1922 PEMREOF lpRecord;
1923 size_t uRecord = sizeof(*lpRecord);
1924
1925 EMF_ReAllocAndAdjustPointers(PEMREOF,uRecord);
1926
1927 /* Fill the new record - FIXME: This is not right */
1928 lpRecord->emr.iType = EMR_EOF;
1929 lpRecord->emr.nSize = sizeof( *lpRecord );
1930 lpRecord->nPalEntries = 0; /* FIXME */
1931 lpRecord->offPalEntries = 0; /* FIXME */
1932 lpRecord->nSizeLast = 0; /* FIXME */
1933
1934 /* No more records after this one */
1935 bFoundEOF = TRUE;
1936
1937 FIXME( "META_EOF conversion not correct\n" );
1938 break;
1939 }
1940
1941 case META_SETMAPMODE:
1942 {
1943 PEMRSETMAPMODE lpRecord;
1944 size_t uRecord = sizeof(*lpRecord);
1945
1946 EMF_ReAllocAndAdjustPointers(PEMRSETMAPMODE,uRecord);
1947
1948 lpRecord->emr.iType = EMR_SETMAPMODE;
1949 lpRecord->emr.nSize = sizeof( *lpRecord );
1950
1951 lpRecord->iMode = lpMetaRecord->rdParm[0];
1952
1953 break;
1954 }
1955
1956 case META_DELETEOBJECT: /* Select and Delete structures are the same */
1957 case META_SELECTOBJECT:
1958 {
1959 PEMRDELETEOBJECT lpRecord;
1960 size_t uRecord = sizeof(*lpRecord);
1961
1962 EMF_ReAllocAndAdjustPointers(PEMRDELETEOBJECT,uRecord);
1963
1964 if( lpMetaRecord->rdFunction == META_DELETEOBJECT )
1965 {
1966 lpRecord->emr.iType = EMR_DELETEOBJECT;
1967 }
1968 else
1969 {
1970 lpRecord->emr.iType = EMR_SELECTOBJECT;
1971 }
1972 lpRecord->emr.nSize = sizeof( *lpRecord );
1973
1974 lpRecord->ihObject = lpMetaRecord->rdParm[0]; /* FIXME: Handle */
1975
1976 break;
1977 }
1978
1979 case META_POLYGON: /* This is just plain busted. I don't know what I'm doing */
1980 {
1981 PEMRPOLYGON16 lpRecord; /* FIXME: Should it be a poly or poly16? */
1982 size_t uRecord = sizeof(*lpRecord);
1983
1984 EMF_ReAllocAndAdjustPointers(PEMRPOLYGON16,uRecord);
1985
1986 /* FIXME: This is mostly all wrong */
1987 lpRecord->emr.iType = EMR_POLYGON16;
1988 lpRecord->emr.nSize = sizeof( *lpRecord );
1989
1990 lpRecord->rclBounds.left = 0;
1991 lpRecord->rclBounds.right = 0;
1992 lpRecord->rclBounds.top = 0;
1993 lpRecord->rclBounds.bottom = 0;
1994
1995 lpRecord->cpts = 0;
1996 lpRecord->apts[0].x = 0;
1997 lpRecord->apts[0].y = 0;
1998
1999 FIXME( "META_POLYGON conversion not correct\n" );
2000
2001 break;
2002 }
2003
2004 case META_SETPOLYFILLMODE:
2005 {
2006 PEMRSETPOLYFILLMODE lpRecord;
2007 size_t uRecord = sizeof(*lpRecord);
2008
2009 EMF_ReAllocAndAdjustPointers(PEMRSETPOLYFILLMODE,uRecord);
2010
2011 lpRecord->emr.iType = EMR_SETPOLYFILLMODE;
2012 lpRecord->emr.nSize = sizeof( *lpRecord );
2013
2014 lpRecord->iMode = lpMetaRecord->rdParm[0];
2015
2016 break;
2017 }
2018
2019 case META_SETWINDOWORG:
2020 {
2021 PEMRSETWINDOWORGEX lpRecord; /* Seems to be the closest thing */
2022 size_t uRecord = sizeof(*lpRecord);
2023
2024 EMF_ReAllocAndAdjustPointers(PEMRSETWINDOWORGEX,uRecord);
2025
2026 lpRecord->emr.iType = EMR_SETWINDOWORGEX;
2027 lpRecord->emr.nSize = sizeof( *lpRecord );
2028
2029 lpRecord->ptlOrigin.x = lpMetaRecord->rdParm[1];
2030 lpRecord->ptlOrigin.y = lpMetaRecord->rdParm[0];
2031
2032 break;
2033 }
2034
2035 case META_SETWINDOWEXT: /* Structure is the same for SETWINDOWEXT & SETVIEWPORTEXT */
2036 case META_SETVIEWPORTEXT:
2037 {
2038 PEMRSETWINDOWEXTEX lpRecord;
2039 size_t uRecord = sizeof(*lpRecord);
2040
2041 EMF_ReAllocAndAdjustPointers(PEMRSETWINDOWEXTEX,uRecord);
2042
2043 if ( lpMetaRecord->rdFunction == META_SETWINDOWEXT )
2044 {
2045 lpRecord->emr.iType = EMR_SETWINDOWORGEX;
2046 }
2047 else
2048 {
2049 lpRecord->emr.iType = EMR_SETVIEWPORTEXTEX;
2050 }
2051 lpRecord->emr.nSize = sizeof( *lpRecord );
2052
2053 lpRecord->szlExtent.cx = lpMetaRecord->rdParm[1];
2054 lpRecord->szlExtent.cy = lpMetaRecord->rdParm[0];
2055
2056 break;
2057 }
2058
2059 case META_CREATEBRUSHINDIRECT:
2060 {
2061 PEMRCREATEBRUSHINDIRECT lpRecord;
2062 size_t uRecord = sizeof(*lpRecord);
2063
2064 EMF_ReAllocAndAdjustPointers(PEMRCREATEBRUSHINDIRECT,uRecord);
2065
2066 lpRecord->emr.iType = EMR_CREATEBRUSHINDIRECT;
2067 lpRecord->emr.nSize = sizeof( *lpRecord );
2068
2069 lpRecord->ihBrush = ((LPENHMETAHEADER)lpNewEnhMetaFileBuffer)->nHandles;
2070 lpRecord->lb.lbStyle = ((LPLOGBRUSH16)lpMetaRecord->rdParm)->lbStyle;
2071 lpRecord->lb.lbColor = ((LPLOGBRUSH16)lpMetaRecord->rdParm)->lbColor;
2072 lpRecord->lb.lbHatch = ((LPLOGBRUSH16)lpMetaRecord->rdParm)->lbHatch;
2073
2074 ((LPENHMETAHEADER)lpNewEnhMetaFileBuffer)->nHandles += 1; /* New handle */
2075
2076 break;
2077 }
2078
2079
2080 /* These are all unimplemented and as such are intended to fall through to the default case */
2081 case META_SETBKCOLOR:
2082 case META_SETBKMODE:
2083 case META_SETROP2:
2084 case META_SETRELABS:
2085 case META_SETSTRETCHBLTMODE:
2086 case META_SETTEXTCOLOR:
2087 case META_SETVIEWPORTORG:
2088 case META_OFFSETWINDOWORG:
2089 case META_SCALEWINDOWEXT:
2090 case META_OFFSETVIEWPORTORG:
2091 case META_SCALEVIEWPORTEXT:
2092 case META_LINETO:
2093 case META_MOVETO:
2094 case META_EXCLUDECLIPRECT:
2095 case META_INTERSECTCLIPRECT:
2096 case META_ARC:
2097 case META_ELLIPSE:
2098 case META_FLOODFILL:
2099 case META_PIE:
2100 case META_RECTANGLE:
2101 case META_ROUNDRECT:
2102 case META_PATBLT:
2103 case META_SAVEDC:
2104 case META_SETPIXEL:
2105 case META_OFFSETCLIPRGN:
2106 case META_TEXTOUT:
2107 case META_POLYPOLYGON:
2108 case META_POLYLINE:
2109 case META_RESTOREDC:
2110 case META_CHORD:
2111 case META_CREATEPATTERNBRUSH:
2112 case META_CREATEPENINDIRECT:
2113 case META_CREATEFONTINDIRECT:
2114 case META_CREATEPALETTE:
2115 case META_SETTEXTALIGN:
2116 case META_SELECTPALETTE:
2117 case META_SETMAPPERFLAGS:
2118 case META_REALIZEPALETTE:
2119 case META_ESCAPE:
2120 case META_EXTTEXTOUT:
2121 case META_STRETCHDIB:
2122 case META_DIBSTRETCHBLT:
2123 case META_STRETCHBLT:
2124 case META_BITBLT:
2125 case META_CREATEREGION:
2126 case META_FILLREGION:
2127 case META_FRAMEREGION:
2128 case META_INVERTREGION:
2129 case META_PAINTREGION:
2130 case META_SELECTCLIPREGION:
2131 case META_DIBCREATEPATTERNBRUSH:
2132 case META_DIBBITBLT:
2133 case META_SETTEXTCHAREXTRA:
2134 case META_SETTEXTJUSTIFICATION:
2135 case META_EXTFLOODFILL:
2136 case META_SETDIBTODEV:
2137 case META_DRAWTEXT:
2138 case META_ANIMATEPALETTE:
2139 case META_SETPALENTRIES:
2140 case META_RESIZEPALETTE:
2141 case META_RESETDC:
2142 case META_STARTDOC:
2143 case META_STARTPAGE:
2144 case META_ENDPAGE:
2145 case META_ABORTDOC:
2146 case META_ENDDOC:
2147 case META_CREATEBRUSH:
2148 case META_CREATEBITMAPINDIRECT:
2149 case META_CREATEBITMAP:
2150 /* Fall through to unimplemented */
2151 default:
2152 {
2153 /* Not implemented yet */
2154 FIXME( "Conversion of record type 0x%x not implemented.\n", lpMetaRecord->rdFunction );
2155 break;
2156 }
2157 }
2158
2159 /* Move to the next record */
2160 (char*)lpbBuffer += ((LPMETARECORD)lpbBuffer)->rdSize * 2; /* FIXME: Seem to be doing this in metafile.c */
2161
2162 #undef ReAllocAndAdjustPointers
2163 }
2164
2165 /* We know the last of the header information now */
2166 ((LPENHMETAHEADER)lpNewEnhMetaFileBuffer)->nBytes = uNewEnhMetaFileBufferSize;
2167
2168 /* Create the enhanced metafile */
2169 hMf = SetEnhMetaFileBits( uNewEnhMetaFileBufferSize, (const BYTE*)lpNewEnhMetaFileBuffer );
2170
2171 if( !hMf )
2172 ERR( "Problem creating metafile. Did the conversion fail somewhere?\n" );
2173
2174 return hMf;
2175
2176 error:
2177 /* Free the data associated with our copy since it's been copied */
2178 HeapFree( GetProcessHeap(), 0, lpNewEnhMetaFileBuffer );
2179
2180 return 0;
2181 }
2182
2183
2184
Windows API implementation